Struct PeerPool 

pub struct PeerPool {
    pub id: PeerID,
    conn_queue: Arc<ConnQueue>,
    peers: RwLock<HashMap<PeerID, Arc<Peer>>>,
    pub(crate) protocols: RwLock<HashMap<ProtocolID, Box<ProtocolConstructor>>>,
    pub(crate) protocol_meta: RwLock<HashMap<ProtocolID, ProtocolMeta>>,
    peer_emitter: Arc<EventEmitter<PeerEventTopic>>,
    task_group: TaskGroup,
    pub(crate) executor: Executor,
    pub(crate) config: Arc<Config>,
    monitor: Arc<Monitor>,
}

Fields

id: PeerID

Peer’s ID

conn_queue: Arc<ConnQueue>

Connection queue

peers: RwLock<HashMap<PeerID, Arc<Peer>>>

Holds the running peers.

protocols: RwLock<HashMap<ProtocolID, Box<ProtocolConstructor>>>

Hashmap contains protocol constructors.

protocol_meta: RwLock<HashMap<ProtocolID, ProtocolMeta>>

Per-protocol metadata (version + kind, extensible). Keyed by protocol id. Source of truth for the handshake’s mandatory check and version negotiation.

peer_emitter: Arc<EventEmitter<PeerEventTopic>>

Peer-lifecycle event emitter. Each registered listener gets its own copy of every event.

task_group: TaskGroup

Managing spawned tasks.

executor: Executor

A global Executor

config: Arc<Config>

The Configuration for the P2P network.

monitor: Arc<Monitor>

Responsible for network and system monitoring.

Implementations

impl PeerPool

pub fn new( id: &PeerID, conn_queue: Arc<ConnQueue>, config: Arc<Config>, monitor: Arc<Monitor>, executor: Executor, ) -> Arc<Self>

Creates a new PeerPool

pub fn register_peer_events(&self) -> EventListener<PeerEventTopic, PeerEvent>

Register a listener for the peer-lifecycle events.

pub async fn start(self: &Arc<Self>) -> Result<()>

Starts the PeerPool

pub async fn shutdown(&self)

Shuts down

pub async fn attach_protocol<P: Protocol>( &self, c: Box<ProtocolConstructor>, ) -> Result<()>

Register a protocol’s user-supplied constructor and metadata. Bloom advertising is handled by Node::attach_protocol.

pub async fn broadcast(&self, proto_id: &ProtocolID, msg: Vec<u8>)

Broadcast a message to all connected peers.

pub async fn broadcast_to( &self, proto_id: &ProtocolID, msg: Vec<u8>, targets: &HashSet<PeerID>, )

Broadcast a message to a specific set of peers.

pub async fn send_to( &self, peer_id: &PeerID, proto_id: &ProtocolID, msg: Vec<u8>, ) -> Result<()>

Send a message to a specific peer on the given protocol. Returns PeerNotFound if the peer is not currently in the pool.

pub async fn peer_protocol_set( &self, pid: &PeerID, ) -> Option<HashSet<ProtocolID>>

Returns the negotiated protocol set for a peer.

pub async fn contains_peer(&self, pid: &PeerID) -> bool

Checks if the peer list contains a peer with the given peer id

pub async fn peers_len(&self) -> usize

Returns the number of currently connected peers.

pub async fn inbound_peers(&self) -> HashMap<PeerID, Endpoint>

Returns a map of inbound peers with their endpoints.

pub async fn outbound_peers(&self) -> HashMap<PeerID, Endpoint>

Returns a map of outbound peers with their endpoints.

async fn run(self: Arc<Self>)

async fn new_peer( self: &Arc<Self>, queued: QueuedConn, pid: PeerID, negotiated: Vec<ProtocolID>, ) -> Result<()>

Build a Peer from a post-handshake QueuedConn and run it.

async fn remove_peer(&self, pid: &PeerID) -> Result<()>

Shuts down the peer and remove it from the peer list.