Module protocol 

Bidirectional requests over the transport, with pipelining and explicit sessions.

A reader receives messages from each connection. Each session also has a writer that sends queued messages and a deadline worker that times out operations. Incoming requests and unread responses stay encoded until Session::recv or Promise::wait takes them. Invalid payloads close their original session when decoded.

Each session limits accepted peer requests and buffered incoming bytes. Set both with Session::set_inbound_limits or Server::set_inbound_limits. Exceeding a limit closes the session. The reader never waits for the application to make room. These limits are local; no flow control is negotiated with the peer. The outgoing queue has no capacity limit.

The application opens a crate::transport::Stream; this layer constructs and owns its transport. connect establishes one client session. Server owns a persistent stream and accepts successive server sessions. Each Session owns its receive queue and closes when dropped. Its Requester and Responder handles always target that session, even after it closes and another session connects.

Both sides use the same handle types. Sessions exchange Message, the union of every body in the schema. The schema::host_to_ark::Content and schema::ark_to_host::Content oneofs hold what each side may send. Convert a received Message into the peer’s oneof to dispatch on it exhaustively. Callers select response types when waiting on Promise<Message>. A request is refused with a schema::Error, an application’s own error type converting into one through CodedError. A request whose content this build does not know is refused as UNKNOWN by the session itself, so a newer peer learns what an older one serves. A response of unknown content is malformed, no request having asked for it.

Requests and replies return promises without waiting for I/O. Their deadlines include time in the outgoing queue, and waiting does not restart the timeout. Transport write timeouts are independent, so a request can still reach the peer after its promise expires. The reader and writer run independently of the application, but the application must keep receiving and answering requests while its own requests wait for replies. All waiting is blocking; no async runtime is required. Every request expects a reply, including notifications.

Closing a session fails its pending promises and discards queued messages. Completed promises keep their results. A write already in progress may still reach the peer.

Modules

schema

Protobuf bindings of the protocol, generated from proto/wire.proto.

Structs

Closer

Clonable handle for closing the session or server that created it.

Promise

Result of a queued request or reply.

Requester

Clonable handle for sending requests through the session that created it.

Responder

Handle for answering one incoming request through the session that received it.

Server

Owner of a persistent server stream, accepting successive sessions.

Session

Owner of one session and its incoming request queue.

Enums

Error

Failure of a protocol operation.

Message

Request or successful response body from either direction.

Constants

DEFAULT_AUTOREPLY_TIMEOUT

Default timeout of 5 s for sending an automatic reply.

DEFAULT_MAX_INBOUND_BYTES

Default limit of 16 MiB for queued requests and unread response promises.

DEFAULT_MAX_INBOUND_REQUESTS

Default limit of 1,024 accepted peer requests per session.

Traits

CodedError

Application failure that a request is answered with.

Functions

connect

Establishes a client session, verifies the peer and returns the verifier’s info.