Struct Connection 

pub struct Connection<C, B>
where
    C: Connection<B>,
    B: Buf,
{ /* private fields */ }

Client connection driver

Maintains the internal state of an HTTP/3 connection, including control and QPACK. It needs to be polled continously via poll_close(). On connection closure, this will resolve to Ok(()) if the peer sent HTTP_NO_ERROR, or Err() if a connection-level error occured.

shutdown() initiates a graceful shutdown of this connection. After calling it, no request initiation will be further allowed. Then poll_close() will resolve when all ongoing requests and push streams complete. Finally, a connection closure with HTTP_NO_ERROR code will be sent to the server.

Examples

Drive a connection concurrenty

// Run the driver on a different task
tokio::spawn(async move {
    future::poll_fn(|cx| connection.poll_close(cx)).await?;
    Ok::<(), Box<dyn std::error::Error + Send + Sync>>(())
})

Shutdown a connection gracefully

// Prepare a channel to stop the driver thread
let (shutdown_tx, shutdown_rx) = oneshot::channel();

// Run the driver on a different task
let driver = tokio::spawn(async move {
    tokio::select! {
        // Drive the connection
        closed = future::poll_fn(|cx| connection.poll_close(cx)) => closed?,
        // Listen for shutdown condition
        max_streams = shutdown_rx => {
            // Initiate shutdown
            connection.shutdown(max_streams?);
            // Wait for ongoing work to complete
            future::poll_fn(|cx| connection.poll_close(cx)).await?;
        }
    };

    Ok::<(), Box<dyn std::error::Error + Send + Sync>>(())
});

// Do client things, wait for close contition...

// Initiate shutdown
shutdown_tx.send(2);
// Wait for the connection to be closed
driver.await?

Implementations

impl<C, B> Connection<C, B>

where C: Connection<B>, B: Buf,

pub async fn shutdown(&mut self, _max_push: usize) -> Result<(), Error>

Initiate a graceful shutdown, accepting max_push potentially in-flight server pushes

pub async fn wait_idle(&mut self) -> Result<(), Error>

Wait until the connection is closed

pub fn poll_close(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Error>>

Maintain the connection state until it is closed