Struct Session 

pub struct Session { /* private fields */ }

Owner of one session and its incoming request queue.

Incoming requests use Message, paired with a common responder. The application selects the reply type; there is no static request/response pairing table. The host/server role and envelope direction are handled internally.

Closing or dropping the session fails pending promises, discards queued requests, and wakes blocked recv() calls. Completed promises keep their results. Application jobs keep running, but their handles still refer to the closed session and cannot send messages through a replacement session.

A client session also closes its stream. A server session leaves the server’s stream available for another handshake. Handles do not keep the session open. The owner cannot be cloned; obtain requesters or closers for other threads:

use darkbio_wire::protocol::Session;
fn duplicate(session: Session) { let _ = session.clone(); }

Implementations

impl Session

pub fn set_autoreply_timeout(self, timeout: Duration) -> Self

Sets the timeout for automatic UNANSWERED and UNKNOWN replies. Defaults to DEFAULT_AUTOREPLY_TIMEOUT. Replies already queued keep their deadlines.

The budget starts when a responder is dropped or an unknown request is received, and includes queueing. Expiry discards a queued reply; a write already started still runs under the transport’s independent timeout. Explicit request/reply deadlines are unaffected. Zero or an unrepresentable deadline expires immediately. Use super::Server::set_autoreply_timeout to also set the timeout for future server sessions.

pub fn set_inbound_limits(self, requests: usize, bytes: usize) -> Self

Sets the maximum accepted peer requests and buffered incoming bytes together. Defaults to DEFAULT_MAX_INBOUND_REQUESTS and DEFAULT_MAX_INBOUND_BYTES.

requests counts queued requests, held responders and queued replies, including automatic replies to requests with unknown content. A slot is freed when the writer takes the reply or the reply is discarded. Zero refuses all peer requests but still allows responses to our requests.

bytes counts the full encoded envelopes of queued requests and unread responses. recv(), wait() or dropping a response promise releases that space in the budget. Zero allows no buffered envelopes. Decoded application data, outgoing messages and transport buffers are excluded.

Exceeding either limit closes this session with Error::InboundRequestLimitExceeded or Error::InboundByteLimitExceeded. The reader never waits for space. Lowering a limit below usage also closes the session. Completed promises keep their results and bytes until read or dropped. Raising limits does not reopen a closed session.

pub fn requester(&self) -> Requester

Returns a clonable requester bound to this session.

pub fn recv(&mut self) -> Result<(Message, Responder), Error>

Blocks for the next peer request and its Responder. Closing the session wakes this call with the error that closed it. The caller decides how to handle each request; this method does not run application callbacks.

Taking a request removes its bytes from the inbound byte count before decoding it. The request still counts toward the inbound request limit while its responder is held. Invalid protobuf returns Error::Malformed and closes this session.

If another thread closes the session after recv() takes a request from the queue, recv() can still return it. Replying after closure returns an error.

pub fn closer(&self) -> Closer

Returns a clonable handle for closing this session from another thread, including while its owner is blocked in Self::recv.

pub fn close(&self)

Closes this session. Repeated calls have no further effect. This does not wait for application jobs or guarantee the peer has observed closure. Discards queued messages and fails pending promises. A transport write already started may still finish, but cannot change a completed promise’s result or affect a replacement session.

Trait Implementations

impl Debug for Session

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

Shows the session label and whether the session is still open. A state lock held elsewhere leaves the state out.

impl Drop for Session

fn drop(&mut self)

Closes the session even when requesters, responders or closers remain.

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.