Struct QuicSession 

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

A JetStream session over a QUIC connection.

Cloning is cheap and every clone addresses the same connection, so lanes can be opened from several tasks at once. The connection closes when the last clone goes away.

Implementations

impl<P> QuicSession<P>

where P: Protocol,

pub fn new(connection: Connection) -> QuicSession<P>

Wrap a connection whose endpoint the caller keeps alive.

The session takes ownership of the connection’s lifetime: when the last handle is dropped the connection closes, even if the caller holds a clone of it.

pub fn new_owned(connection: Connection, endpoint: Endpoint) -> QuicSession<P>

Wrap a connection and keep endpoint alive alongside it.

Use this whenever the caller does not otherwise hold the endpoint the connection came from — returning a session from a helper that built its own crate::Client, say. A quinn::Endpoint closes every connection made from it when its last handle drops, so a session built with Self::new in that position is unusable before the caller ever sees it.

pub fn connection(&self) -> &Connection

The underlying connection.

pub fn endpoint(&self) -> Option<&Endpoint>

The endpoint this session keeps alive, if it was given one.

pub fn without_datagrams(self) -> QuicSession<P>

Report this session as carrying no datagrams.

r[impl jetstream.session.capabilities] Session::capabilities derives datagram support from Connection::max_datagram_size, which reads the peer’s advertised limit and the path MTU. It is silent about this endpoint’s own configuration: a connection built with datagram_receive_buffer_size(None) still reports a size, while every send fails with Disabled and nothing can arrive.

quinn 0.11 documents max_size as returning None when datagrams are “disabled locally”, and its implementation does not check — so trusting the doc is how this goes wrong. quinn exposes no way to read the setting back from a Connection, so the caller that turned datagrams off says so here.

The override is shared by every handle on this connection, including clones taken before the call: a clone that went on claiming datagrams work would recreate exactly the mismatch this is here to prevent.

Trait Implementations

impl<P> Clone for QuicSession<P>

where P: Protocol,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> Datagrams<P> for QuicSession<P>

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

r[impl jetstream.session.datagrams] QUIC datagrams belong to the connection, not to any stream on it. Only the raw channel is bound here; framing is the model’s, so both peers agree on it.

fn max_datagram_size(&self) -> Option<u32>

The largest frame the path will carry, if the transport knows it.

fn send_datagram_bytes<'life0, 'async_trait>( &'life0 self, bytes: Bytes, ) -> Pin<Box<dyn Future<Output = Result<(), SessionError>> + Send + 'async_trait>>

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

Send one already-encoded datagram, or fail. Never fragmented, never retried.

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

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

Receive the next datagram that arrived intact.

fn send_request_datagram<'life0, 'async_trait>( &'life0 self, frame: Frame<<P as Protocol>::Request>, ) -> Pin<Box<dyn Future<Output = Result<(), SessionError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Send a request, as the caller.

fn send_response_datagram<'life0, 'async_trait>( &'life0 self, frame: Frame<<P as Protocol>::Response>, ) -> Pin<Box<dyn Future<Output = Result<(), SessionError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Send a response, as the callee.

impl<P> Debug for QuicSession<P>

where P: Protocol,

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

Formats the value using the given formatter.

impl<P> Session<P> for QuicSession<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 QUIC can carry datagrams. This connection may not: a peer that never advertised DATAGRAM support, or a transport configuration with them switched off, leaves max_datagram_size empty and every send failing with Disabled or UnsupportedByPeer. A capability is what this session has, not what its transport is capable of in general — reporting the row unconditionally would let require(Capability::Datagrams) succeed on a session that cannot carry one.

fn context(&self) -> Context

r[impl jetstream.session.identity.addressing] A certificate authenticates the peer once reached; the address is what reaches it, so both are reported.

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

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

r[impl jetstream.lane.independence] Every lane is its own QUIC stream, so one lane’s stalled frame does not delay another’s.

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

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

r[impl jetstream.session.symmetric] Either peer may open a lane on a QUIC connection.

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

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

r[impl jetstream.session.lifetime] Closing the connection resets every stream opened on it, so lanes terminate with the session and calls in flight on them fail rather than hang.

type ClientLane = QuicTransport<P>

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

type ServiceLane = QuicServiceLane<P>

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