Struct Builder 

pub struct Builder<Tls = TlsUnset> { /* private fields */ }

Available on crate feature default-client only.

Builds a partition-aware connection pool.

Implementations

impl<Tls> Builder<Tls>

pub fn idle_timeout(self, timeout: impl Into<Option<Duration>>) -> Self

Sets how long a reusable idle connection remains in the pool.

Passing None disables idle expiration. When unset, the pool uses a 90-second timeout.

pub fn set_idle_timeout( &mut self, timeout: Option<Option<Duration>>, ) -> &mut Self

Mutably sets the idle timeout.

The outer None restores the default; Some(None) disables expiry.

pub fn time_source(self, source: impl TimeSource + 'static) -> Self

Sets the clock used by pool maintenance and connection timing.

pub fn set_time_source(&mut self, source: Option<SharedTimeSource>) -> &mut Self

Mutably sets the clock used by pool maintenance and connection timing.

pub fn sleep_impl(self, sleep: impl AsyncSleep + 'static) -> Self

Sets the sleep implementation used by pool maintenance.

pub fn set_sleep_impl(&mut self, sleep: Option<SharedAsyncSleep>) -> &mut Self

Mutably sets the sleep implementation used by pool maintenance.

pub fn tcp_nodelay(self, enabled: bool) -> Self

Configures TCP_NODELAY for newly created sockets.

pub fn set_tcp_nodelay(&mut self, enabled: bool) -> &mut Self

Mutably configures TCP_NODELAY.

pub fn tcp_keepalive(self, time: impl Into<Option<Duration>>) -> Self

Configures TCP keepalive for newly created sockets.

pub fn set_tcp_keepalive(&mut self, time: Option<Option<Duration>>) -> &mut Self

Mutably configures TCP keepalive.

pub fn max_connections_per_host(self, limit: usize) -> Self

Bounds connection capacity for one origin across every pool partition.

An origin is a scheme, host, and port, so https://example.com and http://example.com are bounded separately, as is each non-default port. Establishing, idle, and active connections occupy capacity. Logical close normally returns capacity while accepted work drains. An HTTP/1 upgrade retains capacity until the caller releases upgraded I/O. This is not an idle-connection limit.

pub fn set_max_connections_per_host( &mut self, limit: Option<usize>, ) -> &mut Self

Mutably sets the connection-capacity bound described by Builder::max_connections_per_host.

pub fn connection_reuse_scope(self, scope: ConnectionReuseScope) -> Self

Selects which partitions may reuse each other’s connections.

pub fn set_connection_reuse_scope( &mut self, scope: ConnectionReuseScope, ) -> &mut Self

Mutably selects the connection reuse scope.

pub fn has_explicit_partitions(&self) -> bool

Returns whether an explicit partition set is configured.

An explicitly supplied empty set also returns true. Clearing the set with Self::set_partitions and None restores anonymous partition construction.

pub fn partitions(self, partitions: impl IntoIterator<Item = Partition>) -> Self

Declares the complete explicit partition set.

pub fn set_partitions( &mut self, partitions: Option<Vec<Partition>>, ) -> &mut Self

Mutably declares or clears the explicit partition set.

pub fn proxy_config(self, config: ProxyConfig) -> Self

Configures proxy selection for every connection established by this pool.

The configuration applies across every partition. Proxying is disabled unless this method is called.

pub fn set_proxy_config(&mut self, config: Option<ProxyConfig>) -> &mut Self

Mutably configures pool-wide proxy selection.

Passing None disables proxying.

pub fn dns_resolver(self, resolver: impl ResolveDns + 'static) -> Self

Configures the DNS resolver used by connections established by this pool.

The resolver applies across every partition. When unset, the client uses its default resolver, which currently delegates to the operating system.

Examples found in repository

examples/custom-dns.rs (line 29)

fn main() {
    let _legacy_client = Builder::new()
        .tls_provider(tls::Provider::Rustls(CryptoMode::Ring))
        .build_with_resolver(StaticResolver);

    let pool = ConnectionPool::builder()
        .dns_resolver(StaticResolver)
        .tls_provider(tls::Provider::Rustls(CryptoMode::Ring))
        .build_https()
        .expect("valid connection pool");
    let _partitioned_client =
        PoolClient::new(&pool).expect("pool contains the anonymous partition");
}

pub fn set_dns_resolver( &mut self, resolver: Option<SharedDnsResolver>, ) -> &mut Self

Mutably configures the pool-wide DNS resolver.

Passing None restores the client default.

pub fn event_listener(self, listener: impl ConnectionEventListener) -> Self

Observes connection establishment and installed-lifetime transitions.

The listener applies to every partition. Each callback runs synchronously on the task that completed the transition and after pool locks are released. A listener must not block on work that requires progress from that same task.

Observation is disabled unless a listener is configured.

pub fn set_event_listener( &mut self, listener: Option<SharedConnectionEventListener>, ) -> &mut Self

Mutably configures pool-wide connection lifecycle observation.

Passing None disables observation. The callback contract is the same as Builder::event_listener.

impl Builder<TlsUnset>

pub fn tls_provider(self, provider: Provider) -> Builder<TlsProviderSelected>

Selects the TLS provider used by HTTPS pool connections.

Examples found in repository

examples/custom-dns.rs (line 30)

fn main() {
    let _legacy_client = Builder::new()
        .tls_provider(tls::Provider::Rustls(CryptoMode::Ring))
        .build_with_resolver(StaticResolver);

    let pool = ConnectionPool::builder()
        .dns_resolver(StaticResolver)
        .tls_provider(tls::Provider::Rustls(CryptoMode::Ring))
        .build_https()
        .expect("valid connection pool");
    let _partitioned_client =
        PoolClient::new(&pool).expect("pool contains the anonymous partition");
}

impl Builder<TlsProviderSelected>

pub fn build_https(self) -> Result<ConnectionPool, BuildError>

Builds a pool whose connector performs TLS and ALPN negotiation.

Examples found in repository

examples/custom-dns.rs (line 31)

fn main() {
    let _legacy_client = Builder::new()
        .tls_provider(tls::Provider::Rustls(CryptoMode::Ring))
        .build_with_resolver(StaticResolver);

    let pool = ConnectionPool::builder()
        .dns_resolver(StaticResolver)
        .tls_provider(tls::Provider::Rustls(CryptoMode::Ring))
        .build_https()
        .expect("valid connection pool");
    let _partitioned_client =
        PoolClient::new(&pool).expect("pool contains the anonymous partition");
}

impl Builder<TlsProviderSelected>

pub fn tls_context(self, context: TlsContext) -> Self

Available on crate features __rustls or s2n-tls only.

Sets provider-specific TLS configuration for HTTPS connections.

pub fn set_tls_context(&mut self, context: TlsContext) -> &mut Self

Available on crate features __rustls or s2n-tls only.

Mutably sets provider-specific TLS configuration.

Trait Implementations

impl<Tls: Clone> Clone for Builder<Tls>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Tls: Debug> Debug for Builder<Tls>

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

Formats the value using the given formatter.

impl Default for Builder<TlsUnset>

fn default() -> Self

Returns the “default value” for a type.