Struct Server 

pub struct Server { /* private fields */ }

Owner of a persistent server stream, accepting successive sessions. Closing or dropping the server ends its active session and shuts down the physical stream. Closing an individual Session keeps this owner and its stream available for another handshake.

Implementations

impl Server

pub fn new<R, W, A>( stream: Stream<R, W>, signer: SecretKey, attester: A, ) -> Self

where R: Read + Send + 'static, W: Write + Send + 'static, A: Attester + Send + 'static,

Takes ownership of a stream and constructs its transport internally. The attester supplies the current device attestation for each handshake. Starts its persistent reader immediately. Failure to start a required worker or an escaping worker panic aborts the process.

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

Sets the timeout for automatic UNANSWERED and UNKNOWN replies in the current and future sessions. Defaults to DEFAULT_AUTOREPLY_TIMEOUT. Applies even before accept(). Replies already queued keep their deadlines.

See Session::set_autoreply_timeout for when the timeout starts and expires. Changing a session’s timeout leaves the server’s default unchanged. This method also replaces a timeout set directly on the current session.

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

Sets both per-session inbound limits, initially DEFAULT_MAX_INBOUND_REQUESTS and DEFAULT_MAX_INBOUND_BYTES. Applies to the current session, even before accept(), and future sessions. Lowering either limit below usage closes that session. The server stays open.

See Session::set_inbound_limits for what each limit counts. Changing a session’s limits leaves the server’s defaults unchanged. This method also replaces limits set directly on the current session.

pub fn accept(&mut self) -> Result<Session, Error>

Blocks until a session is established or the server ends. Recoverable handshake failures leave the stream available for another attempt. A replacement session closes the previous one; old handles still refer to it.

The reader runs before acceptance. A returned session may already have queued requests or be closed, including from exceeding an inbound limit. If several sessions arrive before acceptance, only the newest is returned.

pub fn closer(&self) -> Closer

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

pub fn close(&self)

Permanently closes this server and its active session, wakes blocked acceptance and receive calls, and fails unresolved operations. Idempotent. Does not join application jobs or guarantee the peer has observed closure.

Trait Implementations

impl Debug for Server

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

Shows whether the server still accepts sessions. A state lock held elsewhere leaves the state out.

impl Drop for Server

fn drop(&mut self)

Ends the server and its attached session even when handles 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.