Struct MessageReassembler 

pub struct MessageReassembler { /* private fields */ }

Receiver side: whole-message reassembly for reliable data-channel MessagePayload fragments. Buffers a message’s chunks keyed by id and yields the complete Bytes once every position has arrived (then forgets it).

Correct under duplicates / retransmits (first write per position wins during assembly, out-of-order arrival sorted), partial delivery (TTL eviction), and a message fully retransmitted after it already completed: a completed id is kept as a tombstone until it would expire, so a late re-send within the TTL window is dropped rather than re-assembled and delivered twice.

Bounded against a hostile peer by the ReassemblyLimits it is built with: every accepted chunk is validated and charged to both a per-peer pending-cost limit and a node-wide budget, so reassembly memory cannot grow without limit no matter how the load is shaped. Per-chunk data, per-message data, slot overhead, the pending/terminal id counts, and the completed-id tombstone set are all capped, and an already-expired chunk is rejected before it can be delivered or buffered.

Implementations

impl MessageReassembler

pub fn new() -> MessageReassembler

Empty reassembler with ReassemblyLimits::production bounds.

pub fn with_limits(limits: ReassemblyLimits) -> MessageReassembler

Empty reassembler enforcing the given limits. Tests use this with small limits to exercise the admission rule without giant synthetic payloads.

pub fn pending_count(&self) -> usize

Number of messages currently being reassembled (incomplete).

pub fn remove_expired(&mut self)

Drop messages whose TTL has elapsed, returning their cost to the budget, and evict completed-id tombstones that have likewise expired (a retransmit past its expiry is rejected anyway).

pub fn remove(&mut self, id: Uuid)

Forget a message (e.g. after it has been delivered), returning its cost to the budget.

pub fn handle(&mut self, chunk: Chunk) -> Option<Bytes>

Accept one chunk. Returns the fully reassembled payload when this chunk completes its message (which is then forgotten), otherwise None.

Imperative shell over a functional core: expire stale state, ask the pure classify for an admission verdict, and apply it. Accepted data mutation stays in admit; the shell records only bounded terminal/capacity evidence for rejected chunks so local loss cannot become a peer failure and one logical id cannot produce conflicting terminal outcomes.

Trait Implementations

impl Default for MessageReassembler

fn default() -> MessageReassembler

Returns the “default value” for a type.

impl Drop for MessageReassembler

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.