Struct WebTransportSession 

pub struct WebTransportSession<P>
where
    P: Protocol,
{ /* private fields */ }

A JetStream session over a WebTransport session.

Cloning is cheap and every clone addresses the same WebTransport session, so lanes can be opened from several tasks at once.

Implementations

impl<P> WebTransportSession<P>

where P: Protocol,

pub fn new( session: Arc<WebTransportSession<Connection, Bytes>>, context: Context, ) -> WebTransportSession<P>

Wrap an accepted WebTransport session.

context is the peer identity the HTTP/3 handshake established — the client certificate, where there is one.

pub fn inner(&self) -> &Arc<WebTransportSession<Connection, Bytes>>

The underlying WebTransport session.

Trait Implementations

impl<P> Clone for WebTransportSession<P>

where P: Protocol,

fn clone(&self) -> WebTransportSession<P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P> Session<P> for WebTransportSession<P>

where P: Protocol<Error = Error> + 'static,

fn capabilities(&self) -> Capabilities

r[impl jetstream.session.capabilities] r[impl jetstream.session.capabilities.degradation] The conformance row says WebTransport carries datagrams, and HTTP/3 does. This session does not: there is no Datagrams<P> impl for it, so there is nothing to send or receive one with.

Reporting the row whole would be worse than the missing impl. Code that names this type concretely fails to compile, which is fine; code that asks require(Capability::Datagrams) — which is the point of having capabilities at all — would be told yes and then find no way to use the channel. A capability is what this session has, not what its transport could do.

Binding h3-webtransport’s datagram handles is the real fix and belongs with making this type reachable from H3Service at all: both need an h3 handshake harness the tree does not have.

fn context(&self) -> Context

r[impl jetstream.session.identity] The identity the HTTP/3 handshake established, which for a WebTransport session is the client certificate where one was presented.

fn open_lane<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<<WebTransportSession<P> as Session<P>>::ClientLane, SessionError>> + Send + 'async_trait>>

where 'life0: 'async_trait, WebTransportSession<P>: 'async_trait,

r[impl jetstream.webtransport.upstream-initiated] r[impl jetstream.session.symmetric] The server opening a lane is the ordinary case here, not a special one: the end that opens a lane is the caller on it, so this lane is written as requests and read as responses.

fn accept_lane<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<<WebTransportSession<P> as Session<P>>::ServiceLane, SessionError>> + Send + 'async_trait>>

where 'life0: 'async_trait, WebTransportSession<P>: 'async_trait,

r[impl jetstream.webtransport.bidi.multi-stream] r[impl jetstream.lane.independence] Each accepted lane is its own WebTransport stream. Streams the peer opens that are HTTP/3 requests rather than WebTransport streams are not lanes, and are skipped.

fn close<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, WebTransportSession<P>: 'async_trait,

Stop opening and accepting lanes on this session.

r[impl jetstream.session.lifetime] Partial, and worth stating precisely. This cancels the session: further opens fail, and an accept already parked inside accept_bi wakes and returns SessionError::Closed rather than waiting on an idle peer forever. What it cannot do is terminate lanes already handed out — h3-webtransport 0.1 exposes no way to close a WebTransport session, so those end by being dropped or by the underlying QUIC connection going away. A lane here can therefore outlive its session, which the iroh, QUIC and in-process bindings all prevent.

type ClientLane = WebTransportClientLane<P>

The end of a lane this peer opened, driven as the RPC caller.

type ServiceLane = WebTransportServiceLane<P>

The end of a lane the peer opened, served as the RPC callee.