Struct Pool 

pub struct Pool { /* private fields */ }

A pool of stream connections.

Implementations

impl Pool

pub fn new(config: PoolConfig, limits: Limits, events: Sender<Event>) -> Self

A pool that reports what it receives to events.

pub fn len(&self) -> usize

How many connections are held.

pub fn is_empty(&self) -> bool

Whether the pool is empty.

pub fn accept(&mut self, stream: TcpStream, peer: SocketAddr)

Adopt a connection a peer opened.

pub async fn send(&mut self, key: &ConnectionKey, bytes: Bytes) -> Result<()>

Send to a peer, connecting if there is no usable connection.

The dial never blocks the caller. A peer that black-holes SYN takes the OS connect timeout to fail — around two minutes — and the endpoint loop that calls this also owns every transaction timer. Waiting here would stop retransmissions for calls that have nothing to do with this peer, so the connection is established inside its own task and the bytes wait in the channel until it is up.

pub fn accept_tls(&mut self, stream: TlsStream<TcpStream>, peer: SocketAddr)

Adopt a TLS connection a peer opened, once the handshake has completed.

pub fn accept_quic(&mut self, connection: Connection, peer: SocketAddr)

Adopt an authenticated QUIC connection opened by a peer.

pub async fn send_tls( &mut self, key: &ConnectionKey, verification_name: &str, client: &ClientTls, bytes: Bytes, ) -> Result<()>

Send to a peer over TLS, connecting and verifying if there is no usable connection.

The verification name is the host from the URI, not the address — see docs/specs/sip-tls.md §3.3 — and it is part of the pool key, so a connection verified as one name is never handed to traffic for another.

pub fn accept_ws<S>( &mut self, ws: Socket<S>, key: ConnectionKey, keepalive: Duration, )

where S: AsyncRead + AsyncWrite + Unpin + Send + 'static,

Adopt a WebSocket connection a peer opened, once the handshake has completed.

pub async fn send_ws( &mut self, key: &ConnectionKey, authority: &str, keepalive: Duration, client: Option<&ClientTls>, bytes: Bytes, ) -> Result<()>

Send to a peer over WebSocket, doing the handshake if there is no usable connection.

authority is what goes in the Host header of the upgrade request and, under WSS, the name the certificate must be valid for. Both are the host from the URI.

pub fn remove(&mut self, key: &ConnectionKey, id: u64) -> bool

Forget a connection that has closed.

pub fn holds(&self, key: &ConnectionKey) -> bool

Whether this connection is held.

pub async fn send_on_existing( &mut self, key: &ConnectionKey, bytes: Bytes, ) -> bool

Answer on the connection a request arrived over, if it is still open.

Always tried before anything the Via says: opening a new connection to a NAT-ed client’s advertised address cannot work, which is what RFC 5923 exists to say.

pub fn evict_idle(&mut self) -> Vec<ConnectionKey>

Close connections idle for longer than the configured timeout.

pub async fn shutdown(&mut self)

Cancel every connection and wait until every tracked task has released its socket.

Trait Implementations

impl Debug for Pool

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Pool

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.