polkadot-node-subsystems: ChainApiBackend added + polkadot-debug image version fixed (#2411)

The out-dated version (bad tag) of [polkadot
image](https://github.com/paritytech/polkadot-sdk/blob/ede4a362622dfa69eb167eaa876246b1289f4b41/.gitlab/pipeline/zombienet/cumulus.yml#L31)
([docker
info](https://hub.docker.com/layers/paritypr/polkadot-debug/master/images/sha256:adb1658052cf671b50c90d5cece5c7a131efa1a95978249bd5cb85a5ad654f7a?context=explore))
was used. This PR fixes this.

See also:
https://github.com/paritytech/polkadot-sdk/pull/2411#issuecomment-1822632724

Also adds an abstraction that allows asynchronous backends to be passed to `ChainApiSubsystem`
---------

Co-authored-by: Sebastian Kunert <skunert49@gmail.com>

polkadot/node/core/chain-api/src/lib.rs

@@ -35,13 +35,13 @@ use std::sync::Arc;
 
 use futures::prelude::*;
 use sc_client_api::AuxStore;
-use sp_blockchain::HeaderBackend;
 
+use futures::stream::StreamExt;
 use polkadot_node_subsystem::{
 	messages::ChainApiMessage, overseer, FromOrchestra, OverseerSignal, SpawnedSubsystem,
 	SubsystemError, SubsystemResult,
 };
-use polkadot_primitives::Block;
+use polkadot_node_subsystem_types::ChainApiBackend;
 
 mod metrics;
 use self::metrics::Metrics;
@@ -67,7 +67,7 @@ impl<Client> ChainApiSubsystem<Client> {
 #[overseer::subsystem(ChainApi, error = SubsystemError, prefix = self::overseer)]
 impl<Client, Context> ChainApiSubsystem<Client>
 where
-	Client: HeaderBackend<Block> + AuxStore + 'static,
+	Client: ChainApiBackend + AuxStore + 'static,
 {
 	fn start(self, ctx: Context) -> SpawnedSubsystem {
 		let future = run::<Client, Context>(ctx, self)
@@ -83,7 +83,7 @@ async fn run<Client, Context>(
 	subsystem: ChainApiSubsystem<Client>,
 ) -> SubsystemResult<()>
 where
-	Client: HeaderBackend<Block> + AuxStore,
+	Client: ChainApiBackend + AuxStore,
 {
 	loop {
 		match ctx.recv().await? {
@@ -93,13 +93,15 @@ where
 			FromOrchestra::Communication { msg } => match msg {
 				ChainApiMessage::BlockNumber(hash, response_channel) => {
 					let _timer = subsystem.metrics.time_block_number();
-					let result = subsystem.client.number(hash).map_err(|e| e.to_string().into());
+					let result =
+						subsystem.client.number(hash).await.map_err(|e| e.to_string().into());
 					subsystem.metrics.on_request(result.is_ok());
 					let _ = response_channel.send(result);
 				},
 				ChainApiMessage::BlockHeader(hash, response_channel) => {
 					let _timer = subsystem.metrics.time_block_header();
-					let result = subsystem.client.header(hash).map_err(|e| e.to_string().into());
+					let result =
+						subsystem.client.header(hash).await.map_err(|e| e.to_string().into());
 					subsystem.metrics.on_request(result.is_ok());
 					let _ = response_channel.send(result);
 				},
@@ -113,46 +115,51 @@ where
 				ChainApiMessage::FinalizedBlockHash(number, response_channel) => {
 					let _timer = subsystem.metrics.time_finalized_block_hash();
 					// Note: we don't verify it's finalized
-					let result = subsystem.client.hash(number).map_err(|e| e.to_string().into());
+					let result =
+						subsystem.client.hash(number).await.map_err(|e| e.to_string().into());
 					subsystem.metrics.on_request(result.is_ok());
 					let _ = response_channel.send(result);
 				},
 				ChainApiMessage::FinalizedBlockNumber(response_channel) => {
 					let _timer = subsystem.metrics.time_finalized_block_number();
-					let result = subsystem.client.info().finalized_number;
-					// always succeeds
-					subsystem.metrics.on_request(true);
-					let _ = response_channel.send(Ok(result));
+					let result = subsystem
+						.client
+						.info()
+						.await
+						.map_err(|e| e.to_string().into())
+						.map(|info| info.finalized_number);
+					subsystem.metrics.on_request(result.is_ok());
+					let _ = response_channel.send(result);
 				},
 				ChainApiMessage::Ancestors { hash, k, response_channel } => {
 					let _timer = subsystem.metrics.time_ancestors();
 					gum::trace!(target: LOG_TARGET, hash=%hash, k=k, "ChainApiMessage::Ancestors");
 
-					let mut hash = hash;
+					let next_parent_stream = futures::stream::unfold(
+						(hash, subsystem.client.clone()),
+						|(hash, client)| async move {
+							let maybe_header = client.header(hash).await;
+							match maybe_header {
+								// propagate the error
+								Err(e) => {
+									let e = e.to_string().into();
+									Some((Err(e), (hash, client)))
+								},
+								// fewer than `k` ancestors are available
+								Ok(None) => None,
+								Ok(Some(header)) => {
+									// stop at the genesis header.
+									if header.number == 0 {
+										None
+									} else {
+										Some((Ok(header.parent_hash), (header.parent_hash, client)))
+									}
+								},
+							}
+						},
+					);
 
-					let next_parent = core::iter::from_fn(|| {
-						let maybe_header = subsystem.client.header(hash);
-						match maybe_header {
-							// propagate the error
-							Err(e) => {
-								let e = e.to_string().into();
-								Some(Err(e))
-							},
-							// fewer than `k` ancestors are available
-							Ok(None) => None,
-							Ok(Some(header)) => {
-								// stop at the genesis header.
-								if header.number == 0 {
-									None
-								} else {
-									hash = header.parent_hash;
-									Some(Ok(hash))
-								}
-							},
-						}
-					});
-
-					let result = next_parent.take(k).collect::<Result<Vec<_>, _>>();
+					let result = next_parent_stream.take(k).try_collect().await;
 					subsystem.metrics.on_request(result.is_ok());
 					let _ = response_channel.send(result);
 				},

polkadot/node/core/chain-api/src/tests.rs

@@ -22,7 +22,8 @@ use std::collections::BTreeMap;
 
 use polkadot_node_primitives::BlockWeight;
 use polkadot_node_subsystem_test_helpers::{make_subsystem_context, TestSubsystemContextHandle};
-use polkadot_primitives::{BlockNumber, Hash, Header};
+use polkadot_node_subsystem_types::ChainApiBackend;
+use polkadot_primitives::{Block, BlockNumber, Hash, Header};
 use sp_blockchain::Info as BlockInfo;
 use sp_core::testing::TaskExecutor;
 
@@ -110,7 +111,7 @@ fn last_key_value<K: Clone, V: Clone>(map: &BTreeMap<K, V>) -> (K, V) {
 	map.iter().last().map(|(k, v)| (k.clone(), v.clone())).unwrap()
 }
 
-impl HeaderBackend<Block> for TestClient {
+impl sp_blockchain::HeaderBackend<Block> for TestClient {
 	fn info(&self) -> BlockInfo<Block> {
 		let genesis_hash = self.blocks.iter().next().map(|(h, _)| *h).unwrap();
 		let (best_hash, best_number) = last_key_value(&self.blocks);
@@ -191,8 +192,8 @@ fn request_block_number() {
 		async move {
 			let zero = Hash::zero();
 			let test_cases = [
-				(TWO, client.number(TWO).unwrap()),
-				(zero, client.number(zero).unwrap()), // not here
+				(TWO, client.number(TWO).await.unwrap()),
+				(zero, client.number(zero).await.unwrap()), // not here
 			];
 			for (hash, expected) in &test_cases {
 				let (tx, rx) = oneshot::channel();
@@ -217,8 +218,10 @@ fn request_block_header() {
 	test_harness(|client, mut sender| {
 		async move {
 			const NOT_HERE: Hash = Hash::repeat_byte(0x5);
-			let test_cases =
-				[(TWO, client.header(TWO).unwrap()), (NOT_HERE, client.header(NOT_HERE).unwrap())];
+			let test_cases = [
+				(TWO, client.header(TWO).await.unwrap()),
+				(NOT_HERE, client.header(NOT_HERE).await.unwrap()),
+			];
 			for (hash, expected) in &test_cases {
 				let (tx, rx) = oneshot::channel();
 
@@ -270,8 +273,8 @@ fn request_finalized_hash() {
 	test_harness(|client, mut sender| {
 		async move {
 			let test_cases = [
-				(1, client.hash(1).unwrap()), // not here
-				(2, client.hash(2).unwrap()),
+				(1, client.hash(1).await.unwrap()), // not here
+				(2, client.hash(2).await.unwrap()),
 			];
 			for (number, expected) in &test_cases {
 				let (tx, rx) = oneshot::channel();
@@ -297,7 +300,7 @@ fn request_last_finalized_number() {
 		async move {
 			let (tx, rx) = oneshot::channel();
 
-			let expected = client.info().finalized_number;
+			let expected = client.info().await.unwrap().finalized_number;
 			sender
 				.send(FromOrchestra::Communication {
 					msg: ChainApiMessage::FinalizedBlockNumber(tx),