Struct cfxcore::sync::SynchronizationProtocolHandler

pub struct SynchronizationProtocolHandler {
    pub protocol_version: ProtocolVersion,
    pub protocol_config: ProtocolConfiguration,
    pub graph: SharedSynchronizationGraph,
    pub syn: Arc<SynchronizationState>,
    pub request_manager: Arc<RequestManager>,
    pub latest_epoch_requested: Mutex<(u64, Instant, u64, u64)>,
    pub phase_manager: SynchronizationPhaseManager,
    pub phase_manager_lock: Mutex<u32>,
    pub recover_public_queue: Arc<AsyncTaskQueue<RecoverPublicTask>>,
    pub state_sync: Arc<SnapshotChunkSync>,
    pub synced_epoch_id: Mutex<Option<EpochId>>,
    /* private fields */
}

Fields

protocol_version: ProtocolVersion

protocol_config: ProtocolConfiguration

graph: SharedSynchronizationGraph

syn: Arc<SynchronizationState>

request_manager: Arc<RequestManager>

latest_epoch_requested: Mutex<(u64, Instant, u64, u64)>

The latest (requested_epoch_number, request_time, old_best_epoch, retry_count)

phase_manager: SynchronizationPhaseManager

phase_manager_lock: Mutex<u32>

recover_public_queue: Arc<AsyncTaskQueue<RecoverPublicTask>>

state_sync: Arc<SnapshotChunkSync>

synced_epoch_id: Mutex<Option<EpochId>>

The epoch id of the remotely synchronized state. This is always None for archive nodes.

Implementations

impl SynchronizationProtocolHandler

pub fn new( node_type: NodeType, protocol_config: ProtocolConfiguration, state_sync_config: StateSyncConfiguration, initial_sync_phase: SyncPhaseType, sync_graph: SharedSynchronizationGraph, light_provider: Arc<LightProvider>, consensus: Arc<ConsensusGraph> ) -> Self

pub fn node_type(&self) -> NodeType

pub fn is_consortium(&self) -> bool

pub fn catch_up_mode(&self) -> bool

pub fn in_recover_from_db_phase(&self) -> bool

pub fn need_requesting_blocks(&self) -> bool

pub fn need_block_from_archive_node(&self) -> bool

pub fn preferred_peer_node_type_for_get_block(&self) -> Option<NodeType>

pub fn get_synchronization_graph(&self) -> SharedSynchronizationGraph

pub fn get_request_manager(&self) -> Arc<RequestManager>

pub fn append_received_transactions( &self, transactions: Vec<Arc<SignedTransaction>> )

pub fn start_sync(&self, io: &dyn NetworkContext)

pub fn request_missing_terminals(&self, io: &dyn NetworkContext)

pub fn request_block_bodies(&self, io: &dyn NetworkContext)

Request missing block bodies from random peers in batches.

pub fn request_epochs(&self, io: &dyn NetworkContext)

pub fn request_block_headers( &self, io: &dyn NetworkContext, peer: Option<NodeId>, header_hashes: Vec<H256>, ignore_db: bool )

pub fn on_mined_block(&self, block: Block)

pub fn relay_blocks( &self, io: &dyn NetworkContext, need_to_relay: Vec<H256> ) -> Result<(), Error>

pub fn check_future_blocks(&self, io: &dyn NetworkContext)

pub fn insert_header_to_consensus(&self) -> bool

If we are in SyncHeaders or CatchUpCheckpoint phase, we should insert graph-ready block headers to sync graph directly. For CatchUpCheckpoint, this is needed to move the target checkpoint, and avoid being blocked on a stale checkpoint that no peers can serve.

pub fn propagate_new_transactions(&self, io: &dyn NetworkContext)

pub fn remove_expired_flying_request(&self, io: &dyn NetworkContext)

pub fn send_heartbeat(&self, io: &dyn NetworkContext)

pub fn update_sync_phase(&self, io: &dyn NetworkContext)

pub fn request_missing_blocks( &self, io: &dyn NetworkContext, peer_id: Option<NodeId>, hashes: Vec<H256> )

pub fn request_blocks( &self, io: &dyn NetworkContext, peer_id: Option<NodeId>, hashes: Vec<H256> )

pub fn request_blocks_without_check( &self, io: &dyn NetworkContext, peer_id: Option<NodeId>, hashes: Vec<H256> )

pub fn blocks_received( &self, io: &dyn NetworkContext, requested_hashes: HashSet<H256>, returned_blocks: HashSet<H256>, ask_full_block: bool, peer: Option<NodeId>, delay: Option<Duration>, preferred_node_type_for_block_request: Option<NodeType> )

pub fn expire_block_gc( &self, _io: &dyn NetworkContext, timeout: u64 ) -> Result<(), Error>

pub fn is_block_queue_full(&self) -> bool

Trait Implementations

impl MallocSizeOf for SynchronizationProtocolHandler

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl NetworkProtocolHandler for SynchronizationProtocolHandler

fn minimum_supported_version(&self) -> ProtocolVersion

fn initialize(&self, io: &dyn NetworkContext)

fn send_local_message(&self, io: &dyn NetworkContext, message: Vec<u8>)

fn on_message(&self, io: &dyn NetworkContext, peer: &NodeId, raw: &[u8])

fn on_work_dispatch(&self, io: &dyn NetworkContext, work_type: HandlerWorkType)

fn on_peer_connected( &self, io: &dyn NetworkContext, node_id: &NodeId, peer_protocol_version: ProtocolVersion, _pos_public_key: Option<(ConsensusPublicKey, ConsensusVRFPublicKey)> )

fn on_peer_disconnected(&self, io: &dyn NetworkContext, peer: &NodeId)

fn on_timeout(&self, io: &dyn NetworkContext, timer: TimerToken)