Struct sc_network_sync::engine::SyncingEngine

pub struct SyncingEngine<B: BlockT, Client> { /* private fields */ }

Implementations

impl<B, Client> SyncingEngine<B, Client>where B: BlockT, Client: HeaderBackend<B> + BlockBackend<B> + HeaderMetadata<B, Error = Error> + ProofProvider<B> + Send + Sync + 'static,

pub fn new( roles: Roles, client: Arc<Client>, metrics_registry: Option<&Registry>, net_config: &FullNetworkConfiguration, protocol_id: ProtocolId, fork_id: &Option<String>, block_announce_validator: Box<dyn BlockAnnounceValidator<B> + Send>, warp_sync_params: Option<WarpSyncParams<B>>, network_service: NetworkServiceHandle, import_queue: Box<dyn ImportQueueService<B>>, block_request_protocol_name: ProtocolName, state_request_protocol_name: ProtocolName, warp_sync_protocol_name: Option<ProtocolName>, rx: TracingUnboundedReceiver<SyncEvent<B>> ) -> Result<(Self, SyncingService<B>, NonDefaultSetConfig), ClientError>

pub fn report_metrics(&self)

Report Prometheus metrics.

pub fn process_block_announce_validation_result( &mut self, validation_result: PollBlockAnnounceValidation<B::Header> )

Process the result of the block announce validation.

pub fn push_block_announce_validation( &mut self, who: PeerId, announce: BlockAnnounce<B::Header> )

Push a block announce validation.

It is required that ChainSync::poll_block_announce_validation is called later to check for finished validations. The result of the validation needs to be passed to SyncingEngine::process_block_announce_validation_result to finish the processing.

Note

This will internally create a future, but this future will not be registered in the task before being polled once. So, it is required to call ChainSync::poll_block_announce_validation to ensure that the future is registered properly and will wake up the task when being ready.

pub fn announce_block(&mut self, hash: B::Hash, data: Option<Vec<u8>>)

Make sure an important block is propagated to peers.

In chain-based consensus, we often need to make sure non-best forks are at least temporarily synced.

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

Inform sync about new best imported block.

pub async fn run(self)

pub fn poll(&mut self, cx: &mut Context<'_>) -> Poll<()>

pub fn on_sync_peer_disconnected(&mut self, peer: PeerId) -> Result<(), ()>

Called by peer when it is disconnecting.

Returns a result if the handshake of this peer was indeed accepted.

pub fn on_sync_peer_connected( &mut self, who: PeerId, status: &BlockAnnouncesHandshake<B>, sink: NotificationsSink, inbound: bool ) -> Result<(), ()>

Called on the first connection between two peers on the default set, after their exchange of handshake.

Returns Ok if the handshake is accepted and the peer added to the list of peers we sync from.