Struct HttpDatagramSession 

pub struct HttpDatagramSession<T = Upgraded> { /* private fields */ }

Available on crate features http and std only.

An HTTP Datagram and Capsule Protocol session on an established request.

Built from the upgraded I/O of a successful HTTP/1.x upgrade (101) or HTTP/2 and HTTP/3 Extended CONNECT (2xx); the protocol logic above it needs no version switch. Datagrams use a NativeDatagrams carrier when the I/O publishes one (HTTP/3 with negotiated QUIC DATAGRAM) and DATAGRAM capsules otherwise. Control capsules always use the reliable data stream.

Cancellation

A send accepts its value when a poll finds no earlier accepted bytes left to write; from then on the session owns it, and dropping the future leaves it to be written by the next capsule send (including a datagram carried as a capsule) or close. A native datagram send never waits for those bytes. A future dropped before that point sent nothing. Capsule headers are never interleaved. recv is cancel safe.

Dropping a healthy sender while a capsule is partially on the wire, or receiving a malformed data stream, aborts the carrier: through its OnMalformedMessage hook when published, and by closing the I/O in any case, even while the other half is retained. The peer then sees a reset where the carrier has one, and otherwise a close its decoder reports as truncated. A sender whose writes already failed leaves the receive half alone.

Implementations

impl<T> HttpDatagramSession<T>

where T: AsyncRead + AsyncWrite + ExtensionsRef,

pub fn new(io: T) -> HttpDatagramSession<T>

A session with the default configuration.

pub fn with_config(io: T, config: SessionConfig) -> HttpDatagramSession<T>

A session with config.

pub fn native(&self) -> Option<&NativeDatagrams>

The negotiated native carrier, if the transport offers one.

pub async fn send_datagram( &mut self, payload: Bytes, ) -> Result<DatagramTransport, SessionError>

Send an HTTP Datagram. See SessionSender::send_datagram.

pub async fn send_capsule( &mut self, ty: CapsuleType, value: Bytes, ) -> Result<(), SessionError>

Send a capsule reliably. See SessionSender::send_capsule.

pub async fn start_capsule( &mut self, header: CapsuleHeader, ) -> Result<(), SessionError>

Begin a capsule whose value follows in chunks. See SessionSender::start_capsule.

pub async fn send_capsule_data( &mut self, chunk: Bytes, ) -> Result<(), SessionError>

Append value bytes to the started capsule. See SessionSender::send_capsule_data.

pub async fn recv(&mut self) -> Result<Option<SessionEvent>, SessionError>

Receive the next event. See SessionReceiver::recv.

pub async fn close(&mut self) -> Result<(), SessionError>

Finish sending. See SessionSender::close.

pub fn split(self) -> (SessionSender<T>, SessionReceiver<T>)

Split into independently usable halves, for example for a bidirectional relay.

Trait Implementations

impl<T> Debug for HttpDatagramSession<T>

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

Formats the value using the given formatter.