Struct Http2Config 

pub struct Http2Config { /* private fields */ }

HTTP/2 connection settings.

These cover the HTTP/2 keepalive mechanism, the maximum lifetime of an individual connection, and how many concurrent streams a connection may carry. They apply only to connections actually served over HTTP/2; a connection negotiated as HTTP/1.1 ignores them.

Defaults to no keepalive, no connection age limit, and no stream limit, matching the behavior of a server that only expects short HTTP/1.1 request/response exchanges. Long-lived HTTP/2 clients – gRPC clients in particular – generally want at least a keepalive interval configured so that dead connections are detected rather than lingering.

Implementations

impl Http2Config

pub fn grpc_defaults() -> Self

Creates a configuration carrying the keepalive defaults conventionally used by gRPC servers.

This is a two hour keepalive interval with a twenty second timeout, which is what gRPC implementations generally settle on: long enough that idle connections cost almost nothing, short enough that a connection silently dropped by a NAT or load balancer is eventually noticed.

Deployments that need dead connections reclaimed faster should configure their own interval via with_keepalive rather than starting from this.

pub fn with_keepalive(self, interval: Duration, timeout: Duration) -> Self

Sets the HTTP/2 keepalive parameters.

After a connection has been idle for interval, the server sends a keepalive PING frame. If no PONG arrives within timeout, the connection is closed.

Defaults to keepalive being disabled. Shorter intervals detect dead peers faster at the cost of more PING traffic on otherwise idle connections; the right value depends on how many idle connections a deployment carries and how quickly it needs to reclaim them.

pub fn with_max_connection_age( self, max_age: Duration, grace: Option<Duration>, ) -> Self

Sets the maximum age of a connection, and the grace period that follows it.

Once a connection has existed for max_age, the server sends GOAWAY so the peer stops issuing new requests, and lets in-flight requests finish. If grace is Some, the connection is forcibly closed once that period elapses; if it is None, the server waits for the connection to close on its own.

Defaults to no limit, meaning connections live until either side closes them. Setting a limit is how a deployment behind a load balancer spreads load back out periodically, since HTTP/2 clients otherwise pin themselves to whichever backend they first reached.

pub fn with_max_concurrent_streams(self, max_concurrent_streams: u32) -> Self

Sets the maximum number of concurrent streams allowed on a single connection.

This is sent to the peer as the SETTINGS_MAX_CONCURRENT_STREAMS HTTP/2 setting, which bounds how many requests a client may have in flight on one connection: a client that reaches the limit waits for a stream to complete before opening another.

Defaults to no limit, meaning a client is bounded only by what the connection can carry. Setting a limit caps the work a single connection can queue up, at the cost of a client having to open more connections – or wait – to exceed it.

Trait Implementations

impl Clone for Http2Config

fn clone(&self) -> Http2Config

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Http2Config

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

Formats the value using the given formatter.

impl Default for Http2Config

fn default() -> Http2Config

Returns the “default value” for a type.

impl Copy for Http2Config