Struct MultiplexPool 

pub struct MultiplexPool<C, ID> { /* private fields */ }

Available on crate feature net only.

Connection pool that multiplexes concurrent users over shared connections.

Implementations

impl<C, ID> MultiplexPool<C, ID>

pub fn new() -> MultiplexPool<C, ID>

Create a MultiplexPool without limits: each connection serves as many concurrent users as its peer allows, and connections are added as needed.

pub fn maybe_with_max_streams_per_connection( self, max: Option<NonZero<usize>>, ) -> MultiplexPool<C, ID>

Serve at most this many concurrent users per connection, below what the connection’s MaxConcurrency allows. Unset, the peer decides.

pub fn maybe_set_max_streams_per_connection( &mut self, max: Option<NonZero<usize>>, ) -> &mut MultiplexPool<C, ID>

Serve at most this many concurrent users per connection, below what the connection’s MaxConcurrency allows. Unset, the peer decides.

pub fn with_max_streams_per_connection( self, max: NonZero<usize>, ) -> MultiplexPool<C, ID>

Serve at most this many concurrent users per connection, below what the connection’s MaxConcurrency allows. Unset, the peer decides.

pub fn set_max_streams_per_connection( &mut self, max: NonZero<usize>, ) -> &mut MultiplexPool<C, ID>

Serve at most this many concurrent users per connection, below what the connection’s MaxConcurrency allows. Unset, the peer decides.

pub fn without_max_streams_per_connection(self) -> MultiplexPool<C, ID>

Serve at most this many concurrent users per connection, below what the connection’s MaxConcurrency allows. Unset, the peer decides.

pub fn unset_max_streams_per_connection(&mut self) -> &mut MultiplexPool<C, ID>

Serve at most this many concurrent users per connection, below what the connection’s MaxConcurrency allows. Unset, the peer decides.

pub fn with_max_connections_total( self, max: NonZero<usize>, ) -> MultiplexPool<C, ID>

Keep at most max connections, stored or being established, across all ids, at most [Semaphore::MAX_PERMITS]. At the limit, SaturationPolicy decides. Without it, no limit.

Configure it before the pool is used: clones share its connections, and so the slots they hold. Waiting at the limit may use tokio timers (the default policy’s, the idle timeout’s): the runtime needs its time driver.

pub fn maybe_with_max_connections_total( self, max: Option<NonZero<usize>>, ) -> MultiplexPool<C, ID>

See Self::with_max_connections_total; None is no limit.

pub fn with_saturation_policy( self, policy: SaturationPolicy, ) -> MultiplexPool<C, ID>

What a checkout that needs a connection does at a limit, see Self::with_max_connections_total and Self::with_max_connections_per_id.

pub fn set_saturation_policy( &mut self, policy: SaturationPolicy, ) -> &mut MultiplexPool<C, ID>

What a checkout that needs a connection does at a limit, see Self::with_max_connections_total and Self::with_max_connections_per_id.

pub fn with_max_connections_per_id( self, max: NonZero<usize>, ) -> MultiplexPool<C, ID>

Keep at most max connections, stored or being established, per id (at most [Semaphore::MAX_PERMITS]): at the limit a checkout waits for its id’s capacity or, as SaturationPolicy allows, replaces one of the id’s idle connections; other ids go on. Without it, no limit.

Configure it before the pool is used: clones share the slots of each id. Waiting at the limit may use tokio timers (the default policy’s, the idle timeout’s): the runtime needs its time driver.

pub fn maybe_with_max_connections_per_id( self, max: Option<NonZero<usize>>, ) -> MultiplexPool<C, ID>

See Self::with_max_connections_per_id; None is no limit.

pub fn with_max_idle_per_id(self, max: NonZero<usize>) -> MultiplexPool<C, ID>

Keep at most max idle connections per id: once more go idle, the least recently used ones close. It never holds back a checkout, and nothing closes while checkouts wait. Without it, no limit.

Configure it before the pool is used: clones share their count.

pub fn maybe_with_max_idle_per_id( self, max: Option<NonZero<usize>>, ) -> MultiplexPool<C, ID>

See Self::with_max_idle_per_id; None is no limit.

pub fn with_max_idle_total(self, max: NonZero<usize>) -> MultiplexPool<C, ID>

Keep at most max idle connections across all ids, as Self::with_max_idle_per_id does per id.

pub fn maybe_with_max_idle_total( self, max: Option<NonZero<usize>>, ) -> MultiplexPool<C, ID>

See Self::with_max_idle_total; None is no limit.

pub fn maybe_with_idle_timeout( self, timeout: Option<Duration>, ) -> MultiplexPool<C, ID>

Drop connections that have been idle (no active streams) for longer than the given timeout. Only checked when a connection is requested, never by a scan of the pool: the connection a checkout is about to hand out is always checked, and checkouts of any id close the others about in the order they went idle, a few each once the first is due: one used again since it was last looked at may close up to a timeout late. A checkout waiting at a connection limit looks again once one would expire, on a tokio timer: the runtime needs its time driver enabled. Configure it before the pool is used: clones share their connections.

pub fn maybe_set_idle_timeout( &mut self, timeout: Option<Duration>, ) -> &mut MultiplexPool<C, ID>

Drop connections that have been idle (no active streams) for longer than the given timeout. Only checked when a connection is requested, never by a scan of the pool: the connection a checkout is about to hand out is always checked, and checkouts of any id close the others about in the order they went idle, a few each once the first is due: one used again since it was last looked at may close up to a timeout late. A checkout waiting at a connection limit looks again once one would expire, on a tokio timer: the runtime needs its time driver enabled. Configure it before the pool is used: clones share their connections.

pub fn with_idle_timeout(self, timeout: Duration) -> MultiplexPool<C, ID>

Drop connections that have been idle (no active streams) for longer than the given timeout. Only checked when a connection is requested, never by a scan of the pool: the connection a checkout is about to hand out is always checked, and checkouts of any id close the others about in the order they went idle, a few each once the first is due: one used again since it was last looked at may close up to a timeout late. A checkout waiting at a connection limit looks again once one would expire, on a tokio timer: the runtime needs its time driver enabled. Configure it before the pool is used: clones share their connections.

pub fn set_idle_timeout( &mut self, timeout: Duration, ) -> &mut MultiplexPool<C, ID>

Drop connections that have been idle (no active streams) for longer than the given timeout. Only checked when a connection is requested, never by a scan of the pool: the connection a checkout is about to hand out is always checked, and checkouts of any id close the others about in the order they went idle, a few each once the first is due: one used again since it was last looked at may close up to a timeout late. A checkout waiting at a connection limit looks again once one would expire, on a tokio timer: the runtime needs its time driver enabled. Configure it before the pool is used: clones share their connections.

pub fn without_idle_timeout(self) -> MultiplexPool<C, ID>

Drop connections that have been idle (no active streams) for longer than the given timeout. Only checked when a connection is requested, never by a scan of the pool: the connection a checkout is about to hand out is always checked, and checkouts of any id close the others about in the order they went idle, a few each once the first is due: one used again since it was last looked at may close up to a timeout late. A checkout waiting at a connection limit looks again once one would expire, on a tokio timer: the runtime needs its time driver enabled. Configure it before the pool is used: clones share their connections.

pub fn unset_idle_timeout(&mut self) -> &mut MultiplexPool<C, ID>

Drop connections that have been idle (no active streams) for longer than the given timeout. Only checked when a connection is requested, never by a scan of the pool: the connection a checkout is about to hand out is always checked, and checkouts of any id close the others about in the order they went idle, a few each once the first is due: one used again since it was last looked at may close up to a timeout late. A checkout waiting at a connection limit looks again once one would expire, on a tokio timer: the runtime needs its time driver enabled. Configure it before the pool is used: clones share their connections.

pub fn maybe_with_streams_hint( self, hint: Option<fn(&ID, &Extensions) -> Option<NonZero<usize>>>, ) -> MultiplexPool<C, ID>

Whether a request expects a connection to multiplex before the pool knows, so a burst on a new id waits for a few connects instead of each request dialing its own: the protocol is negotiated, so only a request can tell, such as one requiring a multiplexing protocol. The streams such a connection takes are what the pool’s multiplexed connections took last, the hint’s guess only if it saw none; once an id had a connection, what it took. It runs outside the pool’s locks.

pub fn maybe_set_streams_hint( &mut self, hint: Option<fn(&ID, &Extensions) -> Option<NonZero<usize>>>, ) -> &mut MultiplexPool<C, ID>

Whether a request expects a connection to multiplex before the pool knows, so a burst on a new id waits for a few connects instead of each request dialing its own: the protocol is negotiated, so only a request can tell, such as one requiring a multiplexing protocol. The streams such a connection takes are what the pool’s multiplexed connections took last, the hint’s guess only if it saw none; once an id had a connection, what it took. It runs outside the pool’s locks.

pub fn with_streams_hint( self, hint: fn(&ID, &Extensions) -> Option<NonZero<usize>>, ) -> MultiplexPool<C, ID>

Whether a request expects a connection to multiplex before the pool knows, so a burst on a new id waits for a few connects instead of each request dialing its own: the protocol is negotiated, so only a request can tell, such as one requiring a multiplexing protocol. The streams such a connection takes are what the pool’s multiplexed connections took last, the hint’s guess only if it saw none; once an id had a connection, what it took. It runs outside the pool’s locks.

pub fn set_streams_hint( &mut self, hint: fn(&ID, &Extensions) -> Option<NonZero<usize>>, ) -> &mut MultiplexPool<C, ID>

Whether a request expects a connection to multiplex before the pool knows, so a burst on a new id waits for a few connects instead of each request dialing its own: the protocol is negotiated, so only a request can tell, such as one requiring a multiplexing protocol. The streams such a connection takes are what the pool’s multiplexed connections took last, the hint’s guess only if it saw none; once an id had a connection, what it took. It runs outside the pool’s locks.

pub fn without_streams_hint(self) -> MultiplexPool<C, ID>

Whether a request expects a connection to multiplex before the pool knows, so a burst on a new id waits for a few connects instead of each request dialing its own: the protocol is negotiated, so only a request can tell, such as one requiring a multiplexing protocol. The streams such a connection takes are what the pool’s multiplexed connections took last, the hint’s guess only if it saw none; once an id had a connection, what it took. It runs outside the pool’s locks.

pub fn unset_streams_hint(&mut self) -> &mut MultiplexPool<C, ID>

Whether a request expects a connection to multiplex before the pool knows, so a burst on a new id waits for a few connects instead of each request dialing its own: the protocol is negotiated, so only a request can tell, such as one requiring a multiplexing protocol. The streams such a connection takes are what the pool’s multiplexed connections took last, the hint’s guess only if it saw none; once an id had a connection, what it took. It runs outside the pool’s locks.

pub fn maybe_with_max_wait_before_dial( self, wait: Option<Duration>, ) -> MultiplexPool<C, ID>

How long a checkout waits for connects in flight before it dials its own, if its limits let it. Unset, it waits for them until its caller’s deadline, if any (see Pool::get_conn).

pub fn maybe_set_max_wait_before_dial( &mut self, wait: Option<Duration>, ) -> &mut MultiplexPool<C, ID>

How long a checkout waits for connects in flight before it dials its own, if its limits let it. Unset, it waits for them until its caller’s deadline, if any (see Pool::get_conn).

pub fn with_max_wait_before_dial(self, wait: Duration) -> MultiplexPool<C, ID>

How long a checkout waits for connects in flight before it dials its own, if its limits let it. Unset, it waits for them until its caller’s deadline, if any (see Pool::get_conn).

pub fn set_max_wait_before_dial( &mut self, wait: Duration, ) -> &mut MultiplexPool<C, ID>

How long a checkout waits for connects in flight before it dials its own, if its limits let it. Unset, it waits for them until its caller’s deadline, if any (see Pool::get_conn).

pub fn without_max_wait_before_dial(self) -> MultiplexPool<C, ID>

How long a checkout waits for connects in flight before it dials its own, if its limits let it. Unset, it waits for them until its caller’s deadline, if any (see Pool::get_conn).

pub fn unset_max_wait_before_dial(&mut self) -> &mut MultiplexPool<C, ID>

How long a checkout waits for connects in flight before it dials its own, if its limits let it. Unset, it waits for them until its caller’s deadline, if any (see Pool::get_conn).

pub fn maybe_with_max_connecting_per_id( self, max: Option<NonZero<usize>>, ) -> MultiplexPool<C, ID>

At most this many connects in flight per id and reuse key: further checkouts that need a connection wait for one to land, as browsers open few connections per host at once. It also binds a checkout done waiting (see Self::with_max_wait_before_dial), and connects that turn out not to multiplex, so a cold burst on an HTTP/1 origin dials this many at a time, but not a checkout a total limit hands a slot: it dials with it. Unset, a burst dials what it needs.

pub fn maybe_set_max_connecting_per_id( &mut self, max: Option<NonZero<usize>>, ) -> &mut MultiplexPool<C, ID>

At most this many connects in flight per id and reuse key: further checkouts that need a connection wait for one to land, as browsers open few connections per host at once. It also binds a checkout done waiting (see Self::with_max_wait_before_dial), and connects that turn out not to multiplex, so a cold burst on an HTTP/1 origin dials this many at a time, but not a checkout a total limit hands a slot: it dials with it. Unset, a burst dials what it needs.

pub fn with_max_connecting_per_id( self, max: NonZero<usize>, ) -> MultiplexPool<C, ID>

At most this many connects in flight per id and reuse key: further checkouts that need a connection wait for one to land, as browsers open few connections per host at once. It also binds a checkout done waiting (see Self::with_max_wait_before_dial), and connects that turn out not to multiplex, so a cold burst on an HTTP/1 origin dials this many at a time, but not a checkout a total limit hands a slot: it dials with it. Unset, a burst dials what it needs.

pub fn set_max_connecting_per_id( &mut self, max: NonZero<usize>, ) -> &mut MultiplexPool<C, ID>

At most this many connects in flight per id and reuse key: further checkouts that need a connection wait for one to land, as browsers open few connections per host at once. It also binds a checkout done waiting (see Self::with_max_wait_before_dial), and connects that turn out not to multiplex, so a cold burst on an HTTP/1 origin dials this many at a time, but not a checkout a total limit hands a slot: it dials with it. Unset, a burst dials what it needs.

pub fn without_max_connecting_per_id(self) -> MultiplexPool<C, ID>

At most this many connects in flight per id and reuse key: further checkouts that need a connection wait for one to land, as browsers open few connections per host at once. It also binds a checkout done waiting (see Self::with_max_wait_before_dial), and connects that turn out not to multiplex, so a cold burst on an HTTP/1 origin dials this many at a time, but not a checkout a total limit hands a slot: it dials with it. Unset, a burst dials what it needs.

pub fn unset_max_connecting_per_id(&mut self) -> &mut MultiplexPool<C, ID>

At most this many connects in flight per id and reuse key: further checkouts that need a connection wait for one to land, as browsers open few connections per host at once. It also binds a checkout done waiting (see Self::with_max_wait_before_dial), and connects that turn out not to multiplex, so a cold burst on an HTTP/1 origin dials this many at a time, but not a checkout a total limit hands a slot: it dials with it. Unset, a burst dials what it needs.

pub fn with_selection(self, selection: MuxSelection) -> MultiplexPool<C, ID>

Set the MuxSelection strategy used to pick among same-id connections.

pub fn set_selection( &mut self, selection: MuxSelection, ) -> &mut MultiplexPool<C, ID>

Set the MuxSelection strategy used to pick among same-id connections.

pub fn maybe_with_metrics( self, metrics: Option<Arc<PoolMetrics>>, ) -> MultiplexPool<C, ID>

pub fn maybe_set_metrics( &mut self, metrics: Option<Arc<PoolMetrics>>, ) -> &mut MultiplexPool<C, ID>

pub fn with_metrics(self, metrics: Arc<PoolMetrics>) -> MultiplexPool<C, ID>

pub fn set_metrics( &mut self, metrics: Arc<PoolMetrics>, ) -> &mut MultiplexPool<C, ID>

pub fn without_metrics(self) -> MultiplexPool<C, ID>

pub fn unset_metrics(&mut self) -> &mut MultiplexPool<C, ID>

Trait Implementations

impl<C, ID> Clone for MultiplexPool<C, ID>

fn clone(&self) -> MultiplexPool<C, ID>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C, ID> Debug for MultiplexPool<C, ID>

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

Formats the value using the given formatter.

impl<C, ID> Default for MultiplexPool<C, ID>

fn default() -> MultiplexPool<C, ID>

Returns the “default value” for a type.

impl<C, ID> Extension for MultiplexPool<C, ID>

where C: Send + Sync + 'static, ID: Send + Sync + Debug + 'static,

impl<C, ID> NetExtension for MultiplexPool<C, ID>

where C: Send + Sync + 'static, ID: Send + Sync + Debug + 'static,

impl<C, ID> Pool<C, ID> for MultiplexPool<C, ID>

where C: Send + Sync + ExtensionsRef + 'static, ID: ConnID,

type Connection = MultiplexedConnection<C, ID>

type CreatePermit = MultiplexSlot

async fn get_conn( &self, id: &ID, input: &Extensions, deadline: Option<Instant>, ) -> Result<ConnectionResult<<MultiplexPool<C, ID> as Pool<C, ID>>::Connection, <MultiplexPool<C, ID> as Pool<C, ID>>::CreatePermit>, Box<dyn Error + Send + Sync>>

Get a compatible connection, or a permit to establish a new connection.

fn abandon(&self, create_permit: MultiplexSlot, error: &ConnectionError)

The connection create_permit was for could not be established. Pools that let checkouts wait for it instead of dialing fail them alike.

async fn create( &self, id: ID, conn: C, slot: MultiplexSlot, input: &Extensions, ) -> Result<<MultiplexPool<C, ID> as Pool<C, ID>>::Connection, Box<dyn Error + Send + Sync>>

Admit the establishing request before publishing its new connection.