Remove ChainSyncService

client/network/Cargo.toml

@@ -47,7 +47,6 @@ sc-block-builder = { version = "0.10.0-dev", path = "../block-builder" }
 sc-client-api = { version = "4.0.0-dev", path = "../api" }
 sc-consensus = { version = "0.10.0-dev", path = "../consensus/common" }
 sc-network-common = { version = "0.10.0-dev", path = "./common" }
-sc-network-sync = { version = "0.10.0-dev", path = "./sync" }
 sc-peerset = { version = "4.0.0-dev", path = "../peerset" }
 sc-utils = { version = "4.0.0-dev", path = "../utils" }
 sp-arithmetic = { version = "6.0.0", path = "../../primitives/arithmetic" }

client/network/common/src/sync.rs

@@ -467,32 +467,3 @@ pub trait ChainSync<Block: BlockT>: Send {
 	/// Send block request to peer
 	fn send_block_request(&mut self, who: PeerId, request: BlockRequest<Block>);
 }
-
-#[async_trait::async_trait]
-pub trait ChainSyncService<Block: BlockT>: Send + Sync {
-	/// Returns the number of peers we're connected to and that are being queried.
-	async fn num_active_peers(&self) -> Result<usize, oneshot::Canceled>;
-
-	/// Target sync block number.
-	async fn best_seen_block(&self) -> Result<Option<NumberFor<Block>>, oneshot::Canceled>;
-
-	/// Number of peers participating in syncing.
-	async fn num_sync_peers(&self) -> Result<u32, oneshot::Canceled>;
-
-	/// Number of blocks in the import queue.
-	async fn num_queued_blocks(&self) -> Result<u32, oneshot::Canceled>;
-
-	/// Number of downloaded blocks.
-	async fn num_downloaded_blocks(&self) -> Result<usize, oneshot::Canceled>;
-
-	/// Number of active sync requests.
-	async fn num_sync_requests(&self) -> Result<usize, oneshot::Canceled>;
-
-	/// Returns information about all the peers we are connected to after the handshake message.
-	async fn peers_info(&self)
-		-> Result<Vec<(PeerId, ExtendedPeerInfo<Block>)>, oneshot::Canceled>;
-
-	/// Call this when a block has been finalized. The sync layer may have some additional
-	/// requesting to perform.
-	fn on_block_finalized(&self, hash: Block::Hash, header: Block::Header);
-}

client/network/src/config.rs

@@ -56,10 +56,7 @@ use std::{
 use zeroize::Zeroize;
 
 /// Network initialization parameters.
-pub struct Params<B, Client>
-where
-	B: BlockT + 'static,
-{
+pub struct Params<Client> {
 	/// Assigned role for our node (full, light, ...).
 	pub role: Role,
 
@@ -80,10 +77,6 @@ where
 	/// name on the wire.
 	pub fork_id: Option<String>,
 
-	// TODO(aaro): remove this
-	/// Interface that can be used to delegate syncing-related function calls to `ChainSync`
-	pub sync_service: Arc<sc_network_sync::SyncingService<B>>,
-
 	/// Registry for recording prometheus metrics to.
 	pub metrics_registry: Option<Registry>,
 

client/network/src/lib.rs

@@ -272,8 +272,7 @@ pub use sc_network_common::{
 	},
 	sync::{
 		warp::{WarpSyncPhase, WarpSyncProgress},
-		ChainSyncService, ExtendedPeerInfo, StateDownloadProgress, SyncEventStream, SyncState,
-		SyncStatusProvider,
+		ExtendedPeerInfo, StateDownloadProgress, SyncEventStream, SyncState, SyncStatusProvider,
 	},
 };
 pub use service::{
@@ -296,34 +295,3 @@ const MAX_CONNECTIONS_PER_PEER: usize = 2;
 
 /// The maximum number of concurrent established connections that were incoming.
 const MAX_CONNECTIONS_ESTABLISHED_INCOMING: u32 = 10_000;
-
-/// Abstraction over syncing-related services
-pub trait ChainSyncInterface<B: BlockT>:
-	NetworkSyncForkRequest<B::Hash, NumberFor<B>>
-	+ JustificationSyncLink<B>
-	+ Link<B>
-	+ NetworkBlock<B::Hash, NumberFor<B>>
-	+ SyncStatusProvider<B>
-	+ SyncEventStream
-	+ ChainSyncService<B>
-	+ SyncOracle
-	+ Send
-	+ Sync
-	+ 'static
-{
-}
-
-impl<T, B: BlockT> ChainSyncInterface<B> for T where
-	T: NetworkSyncForkRequest<B::Hash, NumberFor<B>>
-		+ JustificationSyncLink<B>
-		+ Link<B>
-		+ NetworkBlock<B::Hash, NumberFor<B>>
-		+ SyncStatusProvider<B>
-		+ SyncEventStream
-		+ ChainSyncService<B>
-		+ SyncOracle
-		+ Send
-		+ Sync
-		+ 'static
-{
-}

client/network/src/service.rs

@@ -117,9 +117,6 @@ pub struct NetworkService<B: BlockT + 'static, H: ExHashT> {
 	peerset: PeersetHandle,
 	/// Channel that sends messages to the actual worker.
 	to_worker: TracingUnboundedSender<ServiceToWorkerMsg>,
-	// TODO(aaro): remove this
-	/// Interface that can be used to delegate calls to `ChainSync`
-	sync_service: Arc<sc_network_sync::SyncingService<B>>,
 	/// For each peer and protocol combination, an object that allows sending notifications to
 	/// that peer. Updated by the [`NetworkWorker`].
 	peers_notifications_sinks: Arc<Mutex<HashMap<(PeerId, ProtocolName), NotificationsSink>>>,
@@ -129,6 +126,8 @@ pub struct NetworkService<B: BlockT + 'static, H: ExHashT> {
 	/// Marker to pin the `H` generic. Serves no purpose except to not break backwards
 	/// compatibility.
 	_marker: PhantomData<H>,
+	/// Marker for block type
+	_block: PhantomData<B>,
 }
 
 impl<B, H, Client> NetworkWorker<B, H, Client>
@@ -148,7 +147,7 @@ where
 	/// Returns a `NetworkWorker` that implements `Future` and must be regularly polled in order
 	/// for the network processing to advance. From it, you can extract a `NetworkService` using
 	/// `worker.service()`. The `NetworkService` can be shared through the codebase.
-	pub fn new(mut params: Params<B, Client>) -> Result<Self, Error> {
+	pub fn new(mut params: Params<Client>) -> Result<Self, Error> {
 		// Private and public keys configuration.
 		let local_identity = params.network_config.node_key.clone().into_keypair()?;
 		let local_public = local_identity.public();
@@ -434,12 +433,12 @@ where
 			local_peer_id,
 			local_identity,
 			to_worker,
-			sync_service: params.sync_service,
 			peers_notifications_sinks: peers_notifications_sinks.clone(),
 			notifications_sizes_metric: metrics
 				.as_ref()
 				.map(|metrics| metrics.notifications_sizes.clone()),
 			_marker: PhantomData,
+			_block: Default::default(),
 		});
 
 		Ok(NetworkWorker {
@@ -453,6 +452,7 @@ where
 			metrics,
 			boot_node_ids,
 			_marker: Default::default(),
+			_block: Default::default(),
 		})
 	}
 
@@ -1152,6 +1152,8 @@ where
 	/// Marker to pin the `H` generic. Serves no purpose except to not break backwards
 	/// compatibility.
 	_marker: PhantomData<H>,
+	/// Marker for block type
+	_block: PhantomData<B>,
 }
 
 impl<B, H, Client> Future for NetworkWorker<B, H, Client>

client/network/src/service/tests/mod.rs

@@ -16,7 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{config, ChainSyncInterface, NetworkService, NetworkWorker};
+use crate::{config, NetworkService, NetworkWorker};
 
 use futures::prelude::*;
 use libp2p::Multiaddr;
@@ -33,6 +33,7 @@ use sc_network_sync::{
 	engine::SyncingEngine,
 	service::network::{NetworkServiceHandle, NetworkServiceProvider},
 	state_request_handler::StateRequestHandler,
+	SyncingService,
 };
 use sp_runtime::traits::{Block as BlockT, Header as _};
 use std::{collections::HashSet, sync::Arc};
@@ -91,7 +92,7 @@ struct TestNetworkBuilder {
 	client: Option<Arc<substrate_test_runtime_client::TestClient>>,
 	listen_addresses: Vec<Multiaddr>,
 	set_config: Option<SetConfig>,
-	chain_sync: Option<(Box<dyn ChainSyncT<TestBlock>>, Box<dyn ChainSyncInterface<TestBlock>>)>,
+	chain_sync: Option<(Box<dyn ChainSyncT<TestBlock>>, Box<SyncingService<TestBlock>>)>,
 	chain_sync_network: Option<(NetworkServiceProvider, NetworkServiceHandle)>,
 	config: Option<config::NetworkConfiguration>,
 }
@@ -132,7 +133,7 @@ impl TestNetworkBuilder {
 
 	pub fn with_chain_sync(
 		mut self,
-		chain_sync: (Box<dyn ChainSyncT<TestBlock>>, Box<dyn ChainSyncInterface<TestBlock>>),
+		chain_sync: (Box<dyn ChainSyncT<TestBlock>>, Box<SyncingService<TestBlock>>),
 	) -> Self {
 		self.chain_sync = Some(chain_sync);
 		self
@@ -287,7 +288,6 @@ impl TestNetworkBuilder {
 			chain: client.clone(),
 			protocol_id,
 			fork_id,
-			sync_service: Arc::new(chain_sync_service),
 			metrics_registry: None,
 			request_response_protocol_configs: [
 				block_request_protocol_config,

client/network/sync/src/service/chain_sync.rs

@@ -22,10 +22,7 @@ use libp2p::PeerId;
 use sc_consensus::{BlockImportError, BlockImportStatus, JustificationSyncLink, Link};
 use sc_network_common::{
 	service::{NetworkBlock, NetworkSyncForkRequest},
-	sync::{
-		ChainSyncService, ExtendedPeerInfo, SyncEvent, SyncEventStream, SyncStatus,
-		SyncStatusProvider,
-	},
+	sync::{ExtendedPeerInfo, SyncEvent, SyncEventStream, SyncStatus, SyncStatusProvider},
 };
 use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
 use sp_runtime::traits::{Block as BlockT, NumberFor};
@@ -83,6 +80,61 @@ impl<B: BlockT> SyncingService<B> {
 	) -> Self {
 		Self { tx, num_connected, is_major_syncing }
 	}
+
+	pub async fn num_active_peers(&self) -> Result<usize, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumActivePeers(tx));
+
+		rx.await
+	}
+
+	pub async fn best_seen_block(&self) -> Result<Option<NumberFor<B>>, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::BestSeenBlock(tx));
+
+		rx.await
+	}
+
+	pub async fn num_sync_peers(&self) -> Result<u32, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumSyncPeers(tx));
+
+		rx.await
+	}
+
+	pub async fn num_queued_blocks(&self) -> Result<u32, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumQueuedBlocks(tx));
+
+		rx.await
+	}
+
+	pub async fn num_downloaded_blocks(&self) -> Result<usize, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumDownloadedBlocks(tx));
+
+		rx.await
+	}
+
+	pub async fn num_sync_requests(&self) -> Result<usize, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumSyncRequests(tx));
+
+		rx.await
+	}
+
+	pub async fn peers_info(
+		&self,
+	) -> Result<Vec<(PeerId, ExtendedPeerInfo<B>)>, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::PeersInfo(tx));
+
+		rx.await
+	}
+
+	pub fn on_block_finalized(&self, hash: B::Hash, header: B::Header) {
+		let _ = self.tx.unbounded_send(ToServiceCommand::OnBlockFinalized(hash, header));
+	}
 }
 
 impl<B: BlockT + 'static> NetworkSyncForkRequest<B::Hash, NumberFor<B>> for SyncingService<B> {
@@ -174,62 +226,6 @@ impl<B: BlockT> NetworkBlock<B::Hash, NumberFor<B>> for SyncingService<B> {
 	}
 }
 
-#[async_trait::async_trait]
-impl<B: BlockT> ChainSyncService<B> for SyncingService<B> {
-	async fn num_active_peers(&self) -> Result<usize, oneshot::Canceled> {
-		let (tx, rx) = oneshot::channel();
-		let _ = self.tx.unbounded_send(ToServiceCommand::NumActivePeers(tx));
-
-		rx.await
-	}
-
-	async fn best_seen_block(&self) -> Result<Option<NumberFor<B>>, oneshot::Canceled> {
-		let (tx, rx) = oneshot::channel();
-		let _ = self.tx.unbounded_send(ToServiceCommand::BestSeenBlock(tx));
-
-		rx.await
-	}
-
-	async fn num_sync_peers(&self) -> Result<u32, oneshot::Canceled> {
-		let (tx, rx) = oneshot::channel();
-		let _ = self.tx.unbounded_send(ToServiceCommand::NumSyncPeers(tx));
-
-		rx.await
-	}
-
-	async fn num_queued_blocks(&self) -> Result<u32, oneshot::Canceled> {
-		let (tx, rx) = oneshot::channel();
-		let _ = self.tx.unbounded_send(ToServiceCommand::NumQueuedBlocks(tx));
-
-		rx.await
-	}
-
-	async fn num_downloaded_blocks(&self) -> Result<usize, oneshot::Canceled> {
-		let (tx, rx) = oneshot::channel();
-		let _ = self.tx.unbounded_send(ToServiceCommand::NumDownloadedBlocks(tx));
-
-		rx.await
-	}
-
-	async fn num_sync_requests(&self) -> Result<usize, oneshot::Canceled> {
-		let (tx, rx) = oneshot::channel();
-		let _ = self.tx.unbounded_send(ToServiceCommand::NumSyncRequests(tx));
-
-		rx.await
-	}
-
-	async fn peers_info(&self) -> Result<Vec<(PeerId, ExtendedPeerInfo<B>)>, oneshot::Canceled> {
-		let (tx, rx) = oneshot::channel();
-		let _ = self.tx.unbounded_send(ToServiceCommand::PeersInfo(tx));
-
-		rx.await
-	}
-
-	fn on_block_finalized(&self, hash: B::Hash, header: B::Header) {
-		let _ = self.tx.unbounded_send(ToServiceCommand::OnBlockFinalized(hash, header));
-	}
-}
-
 impl<B: BlockT> sp_consensus::SyncOracle for SyncingService<B> {
 	fn is_major_syncing(&self) -> bool {
 		self.is_major_syncing.load(Ordering::Relaxed)

client/network/test/src/lib.rs

@@ -50,7 +50,7 @@ use sc_consensus::{
 };
 use sc_network::{
 	config::{NetworkConfiguration, RequestResponseConfig, Role, SyncMode},
-	ChainSyncService, Multiaddr, NetworkService, NetworkWorker,
+	Multiaddr, NetworkService, NetworkWorker,
 };
 use sc_network_common::{
 	config::{
@@ -956,7 +956,6 @@ where
 			chain: client.clone(),
 			protocol_id,
 			fork_id,
-			sync_service: sync_service.clone(),
 			metrics_registry: None,
 			block_announce_config,
 			request_response_protocol_configs: [
@@ -1135,7 +1134,6 @@ where
 				while let Poll::Ready(Some(notification)) =
 					peer.finality_notification_stream.as_mut().poll_next(cx)
 				{
-					use sc_network::ChainSyncService;
 					peer.sync_service.on_block_finalized(notification.hash, notification.header);
 				}
 			}

client/service/src/builder.rs

@@ -37,7 +37,7 @@ use sc_client_db::{Backend, DatabaseSettings};
 use sc_consensus::import_queue::ImportQueue;
 use sc_executor::RuntimeVersionOf;
 use sc_keystore::LocalKeystore;
-use sc_network::{config::SyncMode, ChainSyncInterface, NetworkService};
+use sc_network::{config::SyncMode, NetworkService};
 use sc_network_bitswap::BitswapRequestHandler;
 use sc_network_common::{
 	protocol::role::Roles,
@@ -942,7 +942,6 @@ where
 		chain: client.clone(),
 		protocol_id: protocol_id.clone(),
 		fork_id: config.chain_spec.fork_id().map(ToOwned::to_owned),
-		sync_service: sync_service.clone(),
 		metrics_registry: config.prometheus_config.as_ref().map(|config| config.registry.clone()),
 		block_announce_config,
 		request_response_protocol_configs: request_response_protocol_configs