Struct H2Connection 

pub struct H2Connection { /* private fields */ }

Shared per-connection state for HTTP/2.

Wrapped in an Arc and held by both the H2Driver driver and every conn task that holds an open stream’s Conn. Per-stream StreamState, HPACK encoder state, and connection-level send flow control lives here.

Implementations

impl H2Connection

pub fn send_ping(&self, opaque: [u8; 8]) -> SendPing<'_>

Send a PING frame to the peer and resolve when its PING ACK arrives, returning the round-trip time.

opaque is the 8-byte payload the peer echoes back; the caller picks the value (typically a counter or random nonce). A PING whose opaque payload is already in flight resolves to io::ErrorKind::AlreadyExists.

No internal timeout. Wrap the returned future with the runtime’s race_with_timeout (or equivalent) to bound the wait.

Cancel safety

Dropping the returned future before completion removes the pending entry. The PING frame may still go out (or already have gone out) and the peer’s ACK is silently dropped. Re-using the same opaque after drop is safe.

Panics

Panics if any per-connection mutex is poisoned.

impl H2Connection

pub fn new(context: Arc<HttpContext>) -> Arc<Self>

Construct a new H2Connection to manage HTTP/2 for a single peer.

pub fn context(&self) -> Arc<HttpContext>

The HttpContext this connection was constructed with.

pub fn swansong(&self) -> &Swansong

The connection-scoped Swansong. Shuts down on peer GOAWAY or when the server- level swansong shuts down.

pub fn shut_down(&self) -> ShutdownCompletion

Attempt graceful shutdown of this HTTP/2 connection.

pub fn run<T>(self: Arc<Self>, transport: T) -> H2Driver<T>

where T: AsyncRead + AsyncWrite + Unpin + Send,

Bind this H2Connection to a TCP transport and return an H2Driver that drives the connection.

The driver must be polled to completion via repeated calls to H2Driver::next (or its Stream impl); each returned Conn should be spawned on its own task.

pub async fn process_inbound<Transport, Handler, Fut>( conn: Conn<Transport>, handler: Handler, ) -> Result<Conn<Transport>>

where Transport: AsyncRead + AsyncWrite + Unpin + Send + Sync + 'static, Handler: FnOnce(Conn<Transport>) -> Fut, Fut: Future<Output = Conn<Transport>>,

Per-stream entry point — call from the runtime adapter’s spawned task for each Conn returned by H2Driver::next. Runs handler to produce the response, then send_h2 to hand the framed response to the driver.

Errors

Returns the io::Error from send_h2 if the body’s poll_read errors or the underlying transport fails partway through the response.

Trait Implementations

impl Debug for H2Connection

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

Formats the value using the given formatter.