Struct WebTransportSession

Source

pub struct WebTransportSession { /* private fields */ }

Available on (crate features http1 or http2 or http3) and crate feature http3 and crate feature webtransport only.

Expand description

A WebTransport session handle.

This type provides access to bidirectional and unidirectional streams for a WebTransport session established over HTTP/3.

The session can be retrieved from the request extensions when handling a WebTransport CONNECT request.

§Example

async fn handle_webtransport(req: IncomingRequest) -> Result<Response<()>, std::convert::Infallible> {
    if let Some(session) = req.extensions().get::<WebTransportSession>() {
        // Handle WebTransport session
        tokio::spawn({
            let session = session.clone();
            async move {
                while let Ok(Some(accepted)) = session.accept_bi().await {
                    // Handle bidirectional streams
                }
            }
        });

        return Ok(Response::builder()
            .status(200)
            .body(())
            .unwrap());
    }

    Ok(Response::builder()
        .status(404)
        .body(())
        .unwrap())
}

Implementations§

Source §

impl WebTransportSession

Source

pub async fn accept_bi(&self) -> Result<Option<AcceptedBi>, StreamError>

Accept the next incoming bidirectional stream or request.

Returns None when the session is closed or no more streams are available.

§Example

async fn handle_session(session: WebTransportSession) {
    while let Ok(Some(accepted)) = session.accept_bi().await {
        match accepted {
            AcceptedBi::BidiStream(stream) => {
                // Handle raw bidirectional stream
            }
            AcceptedBi::Request(req, stream) => {
                // Handle HTTP request over WebTransport
            }
        }
    }
}

Source

pub async fn accept_uni( &self, ) -> Result<Option<(WebTransportStreamId, WebTransportRecvStream)>, ConnectionError>

Accept the next incoming unidirectional stream.

Returns None when the session is closed or no more streams are available.

Source

pub async fn open_bi( &self, ) -> Result<(WebTransportSendStream, WebTransportRecvStream), StreamError>

Open a new bidirectional stream.

§Example

let (mut send, mut recv) = session.open_bi().await?;
send.write(Bytes::from("Hello")).await?;
send.finish().await?;

Source

pub async fn open_uni(&self) -> Result<WebTransportSendStream, StreamError>

Open a new unidirectional stream.

§Example

let mut send = session.open_uni().await?;
send.write(Bytes::from("Hello")).await?;
send.finish().await?;

Source

pub fn session_id(&self) -> SessionId

Get the session ID for this WebTransport session.

Source

pub fn datagram_sender( &self, ) -> DatagramSender<<Connection as DatagramConnectionExt<Bytes>>::SendDatagramHandler, Bytes>

Get a datagram sender for sending datagrams over this session.

Datagrams are unreliable and unordered messages.

§Example

let mut sender = session.datagram_sender();
sender.send_datagram(Bytes::from("Hello"))?;

Source

pub fn datagram_reader( &self, ) -> DatagramReader<<Connection as DatagramConnectionExt<Bytes>>::RecvDatagramHandler>

Get a datagram reader for receiving datagrams over this session.

§Example

let mut reader = session.datagram_reader();
while let Ok(datagram) = reader.read_datagram().await {
    println!("Received: {} bytes", datagram.payload().len());
}