Struct PeerPool 

pub(crate) struct PeerPool {
    pub(crate) receiver: Receiver<PeerId>,
    pub(crate) sender: Sender<PeerId>,
}

Hands out guardians so that only one slice request is outstanding to each.

Whichever peer finishes first takes the next slice, so a slow guardian receives less work without anyone having to measure how slow it is, and one that is not answering ties up a single request rather than a share of all of them.

Fields

receiver: Receiver<PeerId>

sender: Sender<PeerId>

Implementations

impl PeerPool

pub(crate) fn new(peers: &BTreeSet<PeerId>) -> Self

pub(crate) async fn acquire(&self) -> PeerId

Wait for a guardian with no request outstanding.

pub(crate) fn retire(&self, peer: PeerId)

Take a guardian out of rotation, putting it back once it has sat out PEER_READMISSION.

Dropping it for good would cost a guardian that timed out once the rest of the recovery, which on a federation of four is a quarter of the capacity thrown away for a single bad request.

pub(crate) fn release(&self, peer: PeerId)

Put a guardian back for the next slice.

Trait Implementations

impl Clone for PeerPool

fn clone(&self) -> PeerPool

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.