Struct cfxcore::sync::request_manager::RequestManager

pub struct RequestManager {
    pub received_transactions: Arc<RwLock<ReceivedTransactionContainer>>,
    pub inflight_pending_transactions: Arc<RwLock<InflightPendingTransactionContainer>>,
    /* private fields */
}

When a header or block is requested by the RequestManager, it is ensured that if it’s not fully received, its hash exists in in_flight after every function call.

The thread who removes a hash from in_flight is responsible to request it again if it’s not received.

No lock is held when we call another function in this struct, and all locks are acquired in the same order, so there should exist no deadlocks.

Fields

received_transactions: Arc<RwLock<ReceivedTransactionContainer>>

inflight_pending_transactions: Arc<RwLock<InflightPendingTransactionContainer>>

Implementations

impl RequestManager

pub fn new( protocol_config: &ProtocolConfiguration, syn: Arc<SynchronizationState>, recover_public_queue: Arc<AsyncTaskQueue<RecoverPublicTask>> ) -> Self

pub fn num_epochs_in_flight(&self) -> u64

pub fn in_flight_blocks(&self) -> HashSet<H256>

pub fn request_with_delay( &self, io: &dyn NetworkContext, request: Box<dyn Request>, peer: Option<NodeId>, delay: Option<Duration> )

Send request to remote peer with delay mechanism. If failed, add the request to waiting queue to resend later.

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

pub fn request_epoch_hashes( &self, io: &dyn NetworkContext, peer_id: Option<NodeId>, epochs: Vec<u64>, delay: Option<Duration> )

pub fn request_blocks( &self, io: &dyn NetworkContext, peer_id: Option<NodeId>, hashes: Vec<H256>, with_public: bool, delay: Option<Duration>, preferred_node_type: Option<NodeType> )

pub fn request_transactions_from_digest( &self, io: &dyn NetworkContext, peer_id: NodeId, transaction_digests: &TransactionDigests )

pub fn request_transactions_from_tx_hashes( &self, io: &dyn NetworkContext, peer_id: NodeId, responded_tx_hashes: Vec<H256>, window_index: usize, tx_hashes_indices: &Vec<usize> )

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

pub fn request_blocktxn( &self, io: &dyn NetworkContext, peer_id: NodeId, block_hash: H256, index_skips: Vec<usize>, delay: Option<Duration> )

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

pub fn resend_request_to_another_peer( &self, io: &dyn NetworkContext, req: &RequestMessage )

pub fn match_request( &self, peer_id: &NodeId, request_id: u64 ) -> Result<RequestMessage, Error>

pub fn headers_received( &self, io: &dyn NetworkContext, req_hashes: HashSet<H256>, received_headers: HashSet<H256>, delay: Option<Duration> )

Remove inflight keys when a header is received.

If a request is removed from req_hashes, it’s the caller’s responsibility to ensure that the removed request either has already received or will be requested by the caller again.

pub fn epochs_received( &self, io: &dyn NetworkContext, req_epochs: HashSet<u64>, received_epochs: HashSet<u64>, delay: Option<Duration> )

Remove from inflight keys when a epoch is received.

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

Remove from inflight keys when a block is received.

If a request is removed from req_hashes, it’s the caller’s responsibility to ensure that the removed request either has already received or will be requested by the caller again (the case for Blocktxn).

pub fn transactions_received_from_digests( &self, io: &dyn NetworkContext, get_transactions_request: &GetTransactions, signed_transactions: Vec<Arc<SignedTransaction>> )

pub fn transactions_received_from_tx_hashes( &self, get_transactions_request: &GetTransactionsFromTxHashes, signed_transactions: Vec<Arc<SignedTransaction>> )

pub fn get_sent_transactions( &self, window_index: usize, indices: &Vec<usize> ) -> Vec<TransactionWithSignature>

pub fn append_sent_transactions( &self, transactions: Vec<Arc<SignedTransaction>> ) -> usize

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

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

pub fn resend_waiting_requests( &self, io: &dyn NetworkContext, remove_timeout_requests: bool, prefer_archive_node_for_blocks: bool ) -> Vec<Box<dyn Request>>

Send waiting requests that their backoff delay have passes. Return the cancelled requests that have timeout too many times.

pub fn on_peer_connected(&self, peer: &NodeId)

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

pub fn remove_net_inflight_blocks<'a, I: Iterator<Item = &'a H256>>( &self, blocks: I )

Trait Implementations

impl MallocSizeOf for RequestManager

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.