Struct PeerConnectionPool 

pub struct PeerConnectionPool {
    pub connections: HashMap<u64, PeerPooledConnection>,
    pub next_conn_id: u64,
    pub config: PeerPoolConfig,
    pub total_acquired: u64,
    pub total_released: u64,
    pub total_evicted: u64,
}

Tick-based, single-threaded peer connection pool.

Manages a set of reusable PeerPooledConnections keyed by a monotonically increasing conn_id. Callers drive time by passing an explicit tick counter; the pool does not use wall-clock time.

Example

use ipfrs_network::connection_pool::{PeerConnectionPool, PeerPoolConfig};

let mut pool = PeerConnectionPool::new(PeerPoolConfig::default());
let tick = 0_u64;

// Acquire (or create) a connection for "peer-1".
let conn_id = pool.acquire("peer-1", tick).expect("should succeed");

// Return the connection to the idle pool.
assert!(pool.release(conn_id, tick + 1));

// Evict connections that have been idle for too long.
pool.evict_idle(tick + 100);

Fields

connections: HashMap<u64, PeerPooledConnection>

All connections, keyed by their unique conn_id.

next_conn_id: u64

Monotonically increasing counter for assigning connection IDs.

config: PeerPoolConfig

Pool configuration.

total_acquired: u64

Cumulative successful acquires.

total_released: u64

Cumulative successful releases.

total_evicted: u64

Cumulative evictions.

Implementations

impl PeerConnectionPool

pub fn new(config: PeerPoolConfig) -> Self

Create a new, empty pool with the given configuration.

pub fn acquire(&mut self, peer_id: &str, tick: u64) -> Option<u64>

Acquire a connection for peer_id at the given logical tick.

Returns Some(conn_id) on success:

• If an Idle connection exists for the peer it is reused (set to InUse).
• Otherwise a new connection is created if the per-peer and global caps allow it.

Returns None when all capacity limits are exhausted.

pub fn release(&mut self, conn_id: u64, tick: u64) -> bool

Return a connection to the idle pool.

Returns true on success, false if the connection was not found or was not in the InUse state.

pub fn close(&mut self, conn_id: u64) -> bool

Mark a connection as Closing.

Returns false if no connection with the given ID exists.

pub fn evict_idle(&mut self, tick: u64)

Evict connections that are stale or marked for teardown.

Removes:

• Idle connections whose last_used_tick is at least idle_timeout_ticks ticks in the past.
• All Closing connections.

total_evicted is incremented for each removed connection.

pub fn connections_for_peer<'a>( &'a self, peer_id: &str, ) -> Vec<&'a PeerPooledConnection>

Return all connections associated with peer_id, sorted ascending by conn_id.

pub fn stats(&self) -> PeerPoolStats

Return a point-in-time snapshot of pool statistics.