Struct RpcRequestPayload 

pub struct RpcRequestPayload {
    pub service: String,
    pub deadline_ns: u64,
    pub flags: u16,
    pub headers: Vec<RpcHeader>,
    pub body: Bytes,
}

nRPC request payload. Lives after the 24-byte EventMeta prefix in a DISPATCH_RPC_REQUEST event.

Fields

service: String

Service-name dispatch key. The server’s fold looks this up in its serve_rpc registry and routes to the registered handler.

deadline_ns: u64

Absolute deadline (unix nanos). 0 means no deadline; the caller will cancel via DISPATCH_RPC_CANCEL if it changes its mind.

flags: u16

Bitfield of FLAG_RPC_* constants.

headers: Vec<RpcHeader>

Headers (trace context, idempotency key, content-type, etc.). Capped at MAX_RPC_HEADERS entries, name <= MAX_RPC_HEADER_NAME_LEN, value <= MAX_RPC_HEADER_VALUE_LEN.

body: Bytes

Application-defined request body. Caller and server agree on the codec out-of-band; nRPC doesn’t interpret these bytes.

Held as Bytes so Self::decode can zero-copy slice_ref the body out of the inbound event’s Bytes payload — pre-fix perf #84 in docs/performance/net-perf-analysis.md this was Vec<u8> and every decode did a data[body_start..body_end].to_vec() (a memcpy per frame). For high-RPS systems doing 100K+ RPCs/sec with 1 KB+ bodies that was 100+ MB/sec of pure memcpy.

Implementations

impl RpcRequestPayload

pub fn encoded_len(&self) -> usize

Compute the encoded byte length WITHOUT actually encoding. Used by request_wire_size and any caller that needs to budget event size at the bus layer (e.g., to refuse a request that wouldn’t fit in the configured packet budget) without paying the encode cost.

pub fn encode(&self) -> Vec<u8>

Encode to the wire format. The result is the bytes that follow the 24-byte EventMeta prefix in the RedEX payload.

Encoder bounds: every field that has a MAX_RPC_* cap is asserted against that cap. In debug builds an oversize field panics with a useful diagnostic so the programmer notices in tests; in release builds the assert is dropped (the decoder side still enforces the cap, so a malformed frame would be rejected by the receiver — but constructing one is always a caller bug).

pub fn encode_into(&self, buf: &mut Vec<u8>)

Encode directly into buf, appending the wire bytes (audit T2.2). Callers that already hold an EventMeta-prefixed buffer use this to skip encode()’s intermediate Vec allocation + copy. Produces the identical bytes encode() returns. Pre-reserve(encoded_len()) for an exact-fit single allocation when starting from an empty buffer.

pub fn decode(data: Bytes) -> Result<Self, RpcCodecError>

Decode from the wire bytes following the EventMeta prefix. All length fields are bounded by the MAX_RPC_* constants; over-cap inputs error rather than allocate unbounded buffers.

Takes Bytes (not &[u8]) so the decoded body field can be a zero-copy data.slice(..) instead of an owned to_vec — see perf #84.

Trait Implementations

impl Clone for RpcRequestPayload

fn clone(&self) -> RpcRequestPayload

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RpcRequestPayload

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

Formats the value using the given formatter.

impl Eq for RpcRequestPayload

impl PartialEq for RpcRequestPayload

fn eq(&self, other: &RpcRequestPayload) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RpcRequestPayload