Struct SingleLaneSession 

pub struct SingleLaneSession<P: Protocol, C, S> { /* private fields */ }

A session over a transport that carries exactly one lane.

Built from a lane that already exists — a framed TCP or unix stream — and hands it out once.

Implementations

impl<P: Protocol, C> SingleLaneSession<P, C, NoServiceLane<P>>

pub fn client(lane: C) -> Self

Present lane as the one lane this peer may open.

impl<P: Protocol, S> SingleLaneSession<P, NoClientLane<P>, S>

pub fn service(lane: S) -> Self

Present lane as the one lane this peer may accept.

impl<P, T> SingleLaneSession<P, Framed<T, ClientCodec<P>>, NoServiceLane<P>>

where P: Protocol, T: AsyncRead + AsyncWrite + Send + Sync + Unpin,

pub fn client_io(io: T) -> Self

r[impl jetstream.session.conformance.single-stream] Frame a byte stream — TCP, TLS, a unix socket, stdio — as the one lane this peer can open. Its capabilities are Capabilities::byte_stream unless the caller reports an identity the stream established, as a TLS stream would.

impl<P, T> SingleLaneSession<P, NoClientLane<P>, Framed<T, ServerCodec<P>>>

where P: Protocol, T: AsyncRead + AsyncWrite + Send + Sync + Unpin, Framed<T, ServerCodec<P>>: Contextual,

pub fn service_io(io: T) -> Self

r[impl jetstream.session.conformance.single-stream] Frame an accepted byte stream as the one lane this peer serves.

For a stream that knows its peer — a unix socket or TCP. Anything else wants Self::service_io_with_context.

impl<P, T> SingleLaneSession<P, NoClientLane<P>, ContextualLane<Framed<T, ServerCodec<P>>>>

where P: Protocol, T: AsyncRead + AsyncWrite + Send + Sync + Unpin,

pub fn service_io_with_context(io: T, context: Context) -> Self

r[impl jetstream.session.conformance.single-stream] Frame an accepted byte stream whose peer identity the caller supplies rather than the stream knowing it.

r[impl jetstream.session.identity] This is the path for a TLS stream, whose peer is established by a handshake the framed bytes never see, and for stdio or an in-memory stream, which have no peer at all — pass Context::default for those.

impl<P: Protocol, C, S> SingleLaneSession<P, C, S>

pub fn live_lanes(&self) -> usize

How many lanes this session is currently keeping alive.

pub fn with_identity(self, identity: IdentityKind) -> Self

Report a peer identity model other than IdentityKind::None — a TLS stream authenticates its peer even though it carries one lane.

pub fn with_context(self, context: Context) -> Self

Attach the peer identity the transport established.

r[impl jetstream.session.identity] A lane accepted from this session reports this identity rather than whatever the framed stream underneath knows, so a TLS adapter’s authenticated peer reaches the handler.

Trait Implementations

impl<P: Protocol, C, S> Debug for SingleLaneSession<P, C, S>

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

Formats the value using the given formatter.

impl<P: Protocol, C, S> Drop for SingleLaneSession<P, C, S>

r[impl jetstream.session.lifetime] A lane must not outlive its session, so a session that goes away without close — dropped during error unwinding, say — terminates its lane just the same.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<P, C, S> Session<P> for SingleLaneSession<P, C, S>

where P: Protocol<Error = Error>, C: ClientTransport<P>, S: ServiceTransport<P> + Contextual,

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] Terminates the lane whether or not it has been handed out: cancelling reaches a lane the caller already owns, so a call in flight on it fails rather than continuing to run on a session that has closed. A lane handed out concurrently with this call is born cancelled rather than escaping it.

type ClientLane = LaneGuard<C>

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

type ServiceLane = LaneGuard<S>

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

fn capabilities(&self) -> Capabilities

What this session can do.

fn context(&self) -> Context

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

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,

Open a new lane and take the caller’s end of it.

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.