Struct sc_network_sync::service::chain_sync::ChainSyncInterfaceHandle

pub struct ChainSyncInterfaceHandle<B: BlockT> { /* private fields */ }

Handle for communicating with ChainSync asynchronously

Implementations

impl<B: BlockT> ChainSyncInterfaceHandle<B>

pub fn new(tx: TracingUnboundedSender<ToServiceCommand<B>>) -> Self

Create new handle

Examples found in repository

src/lib.rs (line 1499)

	pub fn new(
		mode: SyncMode,
		client: Arc<Client>,
		protocol_id: ProtocolId,
		fork_id: &Option<String>,
		roles: Roles,
		block_announce_validator: Box<dyn BlockAnnounceValidator<B> + Send>,
		max_parallel_downloads: u32,
		warp_sync_provider: Option<Arc<dyn WarpSyncProvider<B>>>,
		metrics_registry: Option<&Registry>,
		network_service: service::network::NetworkServiceHandle,
		import_queue: Box<dyn ImportQueueService<B>>,
		block_request_protocol_name: ProtocolName,
		state_request_protocol_name: ProtocolName,
		warp_sync_protocol_name: Option<ProtocolName>,
	) -> Result<(Self, ChainSyncInterfaceHandle<B>, NonDefaultSetConfig), ClientError> {
		let (tx, service_rx) = tracing_unbounded("mpsc_chain_sync");
		let block_announce_config = Self::get_block_announce_proto_config(
			protocol_id,
			fork_id,
			roles,
			client.info().best_number,
			client.info().best_hash,
			client
				.block_hash(Zero::zero())
				.ok()
				.flatten()
				.expect("Genesis block exists; qed"),
		);

		let mut sync = Self {
			client,
			peers: HashMap::new(),
			blocks: BlockCollection::new(),
			best_queued_hash: Default::default(),
			best_queued_number: Zero::zero(),
			extra_justifications: ExtraRequests::new("justification"),
			mode,
			queue_blocks: Default::default(),
			fork_targets: Default::default(),
			allowed_requests: Default::default(),
			block_announce_validator,
			max_parallel_downloads,
			downloaded_blocks: 0,
			block_announce_validation: Default::default(),
			block_announce_validation_per_peer_stats: Default::default(),
			state_sync: None,
			warp_sync: None,
			warp_sync_provider,
			import_existing: false,
			gap_sync: None,
			service_rx,
			network_service,
			block_request_protocol_name,
			state_request_protocol_name,
			warp_sync_protocol_name,
			block_announce_protocol_name: block_announce_config
				.notifications_protocol
				.clone()
				.into(),
			pending_responses: Default::default(),
			import_queue,
			metrics: if let Some(r) = &metrics_registry {
				match SyncingMetrics::register(r) {
					Ok(metrics) => Some(metrics),
					Err(err) => {
						error!(target: "sync", "Failed to register metrics for ChainSync: {err:?}");
						None
					},
				}
			} else {
				None
			},
		};

		sync.reset_sync_start_point()?;
		Ok((sync, ChainSyncInterfaceHandle::new(tx), block_announce_config))
	}

Trait Implementations

impl<B: Clone + BlockT> Clone for ChainSyncInterfaceHandle<B>

fn clone(&self) -> ChainSyncInterfaceHandle<B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: BlockT> JustificationSyncLink<B> for ChainSyncInterfaceHandle<B>

fn request_justification(&self, hash: &B::Hash, number: NumberFor<B>)

Request a justification for the given block from the network.

On success, the justification will be passed to the import queue that was part at initialization as part of the configuration.

fn clear_justification_requests(&self)

Clear all pending justification requests.

impl<B: BlockT> Link<B> for ChainSyncInterfaceHandle<B>

fn blocks_processed(
    &mut self,
    imported: usize,
    count: usize,
    results: Vec<(Result<BlockImportStatus<NumberFor<B>>, BlockImportError>, B::Hash)>
)

Batch of blocks imported, with or without error.

fn justification_imported(
    &mut self,
    who: PeerId,
    hash: &B::Hash,
    number: NumberFor<B>,
    success: bool
)

Justification import result.

fn request_justification(&mut self, hash: &B::Hash, number: NumberFor<B>)

Request a justification for the given block.

impl<B: BlockT + 'static> NetworkSyncForkRequest<<B as Block>::Hash, <<B as Block>::Header as Header>::Number> for ChainSyncInterfaceHandle<B>

fn set_sync_fork_request(
    &self,
    peers: Vec<PeerId>,
    hash: B::Hash,
    number: NumberFor<B>
)

Configure an explicit fork sync request.

Note that this function should not be used for recent blocks. Sync should be able to download all the recent forks normally. set_sync_fork_request should only be used if external code detects that there’s a stale fork missing.

Passing empty peers set effectively removes the sync request.