Struct H2AsyncConn 

pub struct H2AsyncConn { /* private fields */ }

Async HTTP/2 connection with multiplexed request support.

Wraps a sans-IO H2Connection and a ConnCtx, providing a pump loop that bridges bytes between the transport and the H2 state machine.

Implementations

impl H2AsyncConn

pub async fn connect(addr: SocketAddr, host: &str) -> Result<Self, HttpError>

Connect to an HTTP/2 server over TLS.

Performs TLS handshake, sends the H2 connection preface, and waits for the server SETTINGS exchange to complete.

pub async fn connect_with_timeout( addr: SocketAddr, host: &str, timeout_ms: u64, ) -> Result<Self, HttpError>

Connect with a timeout (milliseconds).

pub async fn from_conn(conn: ConnCtx) -> Result<Self, HttpError>

Wrap an already-connected ConnCtx (must be TLS for H2).

Sends the H2 preface and waits for SETTINGS exchange.

pub fn close(&self)

Returns the underlying connection context.

pub fn conn(&self) -> ConnCtx

pub fn pending_count(&self) -> usize

Number of in-flight streams.

pub async fn send_request( &mut self, method: &str, path: &str, host: &str, extra_headers: &[(&str, &str)], body: Option<&[u8]>, ) -> Result<Response, HttpError>

Send a request and wait for the complete response.

pub fn fire_request( &mut self, method: &str, path: &str, host: &str, extra_headers: &[(&str, &str)], body: Option<&[u8]>, ) -> Result<u32, HttpError>

Fire an HTTP/2 request. Returns the stream ID immediately.

The request is queued for sending; call recv() or recv_stream() to pump the connection and collect responses.

pub async fn recv(&mut self) -> Result<(u32, Response), HttpError>

Pump until any stream completes. Returns (stream_id, Response).

pub async fn recv_stream( &mut self, stream_id: u32, ) -> Result<Response, HttpError>

Pump until a specific stream completes.

pub async fn send_request_streaming( &mut self, method: &str, path: &str, host: &str, extra_headers: &[(&str, &str)], body: Option<&[u8]>, ) -> Result<H2StreamingResponse<'_>, HttpError>

Send a request and return a streaming response after headers arrive.

The caller must drain the body via H2StreamingResponse::next_chunk() before issuing further requests on this connection.