Sync status refactoring

substrate/client/informant/src/display.rs

@@ -65,11 +65,11 @@ impl<B: BlockT> InformantDisplay<B> {
  info: &ClientInfo<B>,
  net_status: NetworkStatus,
  sync_status: SyncStatus<B>,
+ num_connected_peers: usize,
  ) {
  let best_number = info.chain.best_number;
  let best_hash = info.chain.best_hash;
  let finalized_number = info.chain.finalized_number;
- let num_connected_peers = sync_status.num_connected_peers;
  let speed = speed::<B>(best_number, self.last_number, self.last_update);
  let total_bytes_inbound = net_status.total_bytes_inbound;
  let total_bytes_outbound = net_status.total_bytes_outbound;

substrate/client/informant/src/lib.rs

@@ -24,7 +24,7 @@ use futures_timer::Delay;
 use log::{debug, info, trace};
 use sc_client_api::{BlockchainEvents, UsageProvider};
 use sc_network::NetworkStatusProvider;
-use sc_network_sync::SyncStatusProvider;
+use sc_network_sync::{SyncStatusProvider, SyncingService};
 use sp_blockchain::HeaderMetadata;
 use sp_runtime::traits::{Block as BlockT, Header};
 use std::{collections::VecDeque, fmt::Display, sync::Arc, time::Duration};
@@ -37,10 +37,9 @@ fn interval(duration: Duration) -> impl Stream<Item = ()> + Unpin {
 }
 
 /// Builds the informant and returns a `Future` that drives the informant.
-pub async fn build<B: BlockT, C, N, S>(client: Arc<C>, network: N, syncing: S)
+pub async fn build<B: BlockT, C, N>(client: Arc<C>, network: N, syncing: Arc<SyncingService<B>>)
 where
  N: NetworkStatusProvider,
- S: SyncStatusProvider<B>,
  C: UsageProvider<B> + HeaderMetadata<B> + BlockchainEvents<B>,
  <C as HeaderMetadata<B>>::Error: Display,
 {
@@ -52,13 +51,14 @@ where
  .filter_map(|_| async {
  let net_status = network.status().await;
  let sync_status = syncing.status().await;
+ let num_connected_peers = syncing.num_connected_peers();
 
- match (net_status.ok(), sync_status.ok()) {
- (Some(net), Some(sync)) => Some((net, sync)),
+ match (net_status, sync_status) {
+ (Ok(net), Ok(sync)) => Some((net, sync, num_connected_peers)),
  _ => None,
  }
  })
- .for_each(move |(net_status, sync_status)| {
+ .for_each(move |(net_status, sync_status, num_connected_peers)| {
  let info = client_1.usage_info();
  if let Some(ref usage) = info.usage {
  trace!(target: "usage", "Usage statistics: {}", usage);
@@ -68,7 +68,7 @@ where
  "Usage statistics not displayed as backend does not provide it",
  )
  }
- display.display(&info, net_status, sync_status);
+ display.display(&info, net_status, sync_status, num_connected_peers);
  future::ready(())
  });
 

substrate/client/network/sync/src/engine.rs

@@ -761,9 +761,7 @@ where
  );
  },
  ToServiceCommand::Status(tx) => {
- let mut status = self.strategy.status();
- status.num_connected_peers = self.peers.len() as u32;
- let _ = tx.send(status);
+ let _ = tx.send(self.strategy.status());
  },
  ToServiceCommand::NumActivePeers(tx) => {
  let _ = tx.send(self.num_active_peers());

substrate/client/network/sync/src/service/syncing_service.rs

@@ -79,6 +79,11 @@ impl<B: BlockT> SyncingService<B> {
  Self { tx, num_connected, is_major_syncing }
  }
 
+ /// Get the number of peers known to `SyncingEngine` (both full and light).
+ pub fn num_connected_peers(&self) -> usize {
+ self.num_connected.load(Ordering::Relaxed)
+ }
+
  /// Get the number of active peers.
  pub async fn num_active_peers(&self) -> Result<usize, oneshot::Canceled> {
  let (tx, rx) = oneshot::channel();

substrate/client/network/sync/src/strategy/chain_sync.rs

@@ -438,7 +438,6 @@ where
  state: sync_state,
  best_seen_block,
  num_peers: self.peers.len() as u32,
- num_connected_peers: 0u32,
  queued_blocks: self.queue_blocks.len() as u32,
  state_sync: self.state_sync.as_ref().map(|s| s.progress()),
  warp_sync: warp_sync_progress,

substrate/client/network/sync/src/strategy/state.rs

@@ -340,7 +340,6 @@ impl<B: BlockT> StateStrategy<B> {
  },
  best_seen_block: Some(self.state_sync.target_number()),
  num_peers: self.peers.len().saturated_into(),
- num_connected_peers: self.peers.len().saturated_into(),
  queued_blocks: 0,
  state_sync: Some(self.state_sync.progress()),
  warp_sync: None,

substrate/client/network/sync/src/strategy/warp.rs

@@ -576,7 +576,6 @@ where
  Phase::Complete => None,
  },
  num_peers: self.peers.len().saturated_into(),
- num_connected_peers: self.peers.len().saturated_into(),
  queued_blocks: 0,
  state_sync: None,
  warp_sync: Some(self.progress()),

substrate/client/network/sync/src/types.rs

@@ -76,8 +76,6 @@ pub struct SyncStatus<Block: BlockT> {
  pub best_seen_block: Option<NumberFor<Block>>,
  /// Number of peers participating in syncing.
  pub num_peers: u32,
- /// Number of peers known to `SyncingEngine` (both full and light).
- pub num_connected_peers: u32,
  /// Number of blocks queued for import
  pub queued_blocks: u32,
  /// State sync status in progress, if any.

substrate/client/network/test/src/lib.rs

@@ -266,7 +266,7 @@ where
 
  /// Returns the number of peers we're connected to.
  pub async fn num_peers(&self) -> usize {
- self.sync_service.status().await.unwrap().num_connected_peers as usize
+ self.sync_service.num_connected_peers()
  }
 
  /// Returns the number of downloaded blocks.
@@ -1094,9 +1094,7 @@ pub trait TestNetFactory: Default + Sized + Send {
 
  'outer: loop {
  for sync_service in &sync_services {
- if sync_service.status().await.unwrap().num_connected_peers as usize !=
- num_peers - 1
- {
+ if sync_service.num_connected_peers() != num_peers - 1 {
  futures::future::poll_fn::<(), _>(|cx| {
  self.poll(cx);
  Poll::Ready(())