Struct LocalSession 

pub struct LocalSession<P: Protocol> { /* private fields */ }

One end of an in-process session.

Cheap to clone; clones address the same session, which is what makes a session usable from several tasks at once.

Implementations

impl<P: Protocol> LocalSession<P>

pub fn pair() -> LocalSessionPair<P>

A connected pair of in-process sessions.

pub fn pair_with_capacity(capacity: usize) -> LocalSessionPair<P>

A connected pair whose lanes hold capacity frames before applying backpressure.

Panics

If capacity is zero. A lane with no room for a frame cannot apply backpressure, it can only deadlock, and the bounded channel underneath rejects it — better to say so at construction than to panic inside the first open_lane.

pub fn live_lanes(&self) -> usize

How many lanes this session is currently keeping alive.

Trait Implementations

impl<P: Protocol> Clone for LocalSession<P>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Protocol> Debug for LocalSession<P>

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

Formats the value using the given formatter.

impl<P> Session<P> for LocalSession<P>

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

fn capabilities(&self) -> Capabilities

r[impl jetstream.session.local]

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

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

r[impl jetstream.lane.independence] Each lane is its own pair of channels, so a stalled lane holds up nothing but itself.

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

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

r[impl jetstream.session.lifetime] Dropping the lane tokens terminates every lane this session opened or accepted: their streams end and their sinks fail, so a call in flight fails rather than hanging.

type ClientLane = LocalClientLane<P>

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

type ServiceLane = LocalServiceLane<P>

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

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

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

Wait for the peer to open a lane and take the callee’s end of it.

fn context(&self) -> Context

The peer’s identity, in the form the transport established it.