Struct Synchronizer

pub struct Synchronizer {
    pub shared: Arc<SyncShared>,
    /* private fields */
}

Sync protocol handle

Fields

shared: Arc<SyncShared>

Sync shared state

Implementations

impl Synchronizer

pub fn new(chain: ChainController, shared: Arc<SyncShared>) -> Synchronizer

Init sync protocol handle

This is a runtime sync protocol shared state, and any Sync protocol messages will be processed and forwarded by it

pub fn shared(&self) -> &Arc<SyncShared>

Get shared state

pub fn peers(&self) -> &Peers

Get peers info

pub fn asynchronous_process_remote_block(&self, remote_block: RemoteBlock)

Process a new block sync from other peer

pub fn get_blocks_to_fetch( &self, peer: PeerIndex, ibd: IBDState, ) -> Option<Vec<Vec<Byte32>>>

Get blocks to fetch

pub fn eviction(&self, nc: &dyn CKBProtocolContext)

Regularly check and eject some nodes that do not respond in time

Trait Implementations

impl CKBProtocolHandler for Synchronizer

fn init<'life0, 'async_trait>( &'life0 mut self, nc: Arc<dyn CKBProtocolContext + Sync>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Init action on service run

fn received<'life0, 'async_trait>( &'life0 mut self, nc: Arc<dyn CKBProtocolContext + Sync>, peer_index: PeerIndex, data: Bytes, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Called when the corresponding protocol message is received

fn connected<'life0, 'life1, 'async_trait>( &'life0 mut self, nc: Arc<dyn CKBProtocolContext + Sync>, peer_index: PeerIndex, _version: &'life1 str, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called when opening protocol

fn disconnected<'life0, 'async_trait>( &'life0 mut self, _nc: Arc<dyn CKBProtocolContext + Sync>, peer_index: PeerIndex, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Called when closing protocol

fn notify<'life0, 'async_trait>( &'life0 mut self, nc: Arc<dyn CKBProtocolContext + Sync>, token: u64, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Called when the Service receives the notify task

fn poll<'life0, 'async_trait>( &'life0 mut self, _nc: Arc<dyn CKBProtocolContext + Sync>, ) -> Pin<Box<dyn Future<Output = Option<()>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Behave like Stream::poll