Struct IrohSession 

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

A JetStream session over an iroh connection.

Cloning the session 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> IrohSession<P>

where P: Protocol,

pub fn new(connection: Connection) -> IrohSession<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) -> IrohSession<P>

Wrap a connection and keep endpoint alive alongside it.

pub fn connection(&self) -> &Connection

The underlying connection.

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

Report this session as carrying no datagrams.

r[impl jetstream.session.capabilities] Session::capabilities derives datagram support from max_datagram_size, which underneath reads the peer’s advertised limit and the path MTU. It is silent about this endpoint’s own configuration: an endpoint built with datagrams switched off still sees a size, while every send fails and nothing can arrive. There is no way to read that back from the connection, so the caller that turned them 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 IrohSession<P>

where P: Protocol,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> Datagrams<P> for IrohSession<P>

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

r[impl jetstream.session.datagrams] iroh carries QUIC datagrams, which belong to the connection and 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, IrohSession<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, IrohSession<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 IrohSession<P>

where P: Protocol,

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

Formats the value using the given formatter.

impl<P> Session<P> for IrohSession<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 iroh 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. 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] iroh establishes the peer’s public key during the handshake, so the identity is available without the peer asserting anything.

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

where 'life0: 'async_trait, IrohSession<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<<IrohSession<P> as Session<P>>::ServiceLane, SessionError>> + Send + 'async_trait>>

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

r[impl jetstream.session.symmetric] Either peer may open a lane on an iroh connection, so a client that accepts is not doing anything unusual.

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

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

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

type ClientLane = IrohTransport<P>

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

type ServiceLane = IrohServiceLane<P>

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