Struct PeerSetHarness 

pub struct PeerSetHarness {
    pub network: NetworkService,
    pub addrs: Vec<PeerSocketAddr>,
    peers: Vec<ClientTestHarness>,
    guard: PeerSetGuard,
    busy_requests: Vec<Pin<Box<dyn Future<Output = Result<Response, BoxError>> + Send + 'static>>>,
}

Owns a buffered peer set and the remote endpoints of its real client channels.

Fields

network: NetworkService

The service to pass to the production sync or inbound constructor.

addrs: Vec<PeerSocketAddr>

The connected addresses, in the same order as the supplied service flags.

peers: Vec<ClientTestHarness>

guard: PeerSetGuard

busy_requests: Vec<Pin<Box<dyn Future<Output = Result<Response, BoxError>> + Send + 'static>>>

Implementations

impl PeerSetHarness

pub async fn new(services: &[PeerServices], busy_peer: Option<usize>) -> Self

Constructs real clients, optionally filling one client’s two request-channel slots.

Inventory uses the existing one-entry test channel, so two updates without a poll deterministically exercise registry lag. No socket or wall-clock timing is involved.

pub fn take_request(&mut self, peer: usize) -> Option<ReceivedClientRequest>

Receives an already-dispatched client request, without advancing the clock.

pub async fn next_request(&mut self, peer: usize) -> ReceivedClientRequest

Waits at most one virtual second for the specified client to receive a request.

pub async fn next_request_from( &mut self, peers: &[usize], ) -> (usize, ReceivedClientRequest)

Receives the next request from any of the supplied peers, with a one-second bound.

pub fn advertise(&mut self, peer: usize, hash: Hash)

Publishes an inventory event through the real lossy registry channel.

pub async fn flush(&self)

Polls the production peer set through its normal buffered maintenance request.

pub async fn release_busy_peer(&mut self, peer: usize)

Frees the two pre-filled client slots and completes their unrelated requests.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 192 bytes