Struct ReassemblyLimits 

pub struct ReassemblyLimits {
    pub max_pending_messages: usize,
    pub max_chunk_data_len: usize,
    pub max_message_bytes: usize,
    pub max_chunks_per_message: usize,
    pub max_total_buffered_cost: usize,
    pub slot_overhead: usize,
    pub max_completed_ids: usize,
}

The limits a MessageReassembler enforces on incoming chunks, as an explicit value rather than module globals. This keeps the core admission rule independent of where the numbers come from: the shell supplies them (see ReassemblyLimits::production), the reassembler only enforces what it is given, and tests can use small limits instead of giant synthetic payloads.

Fields

max_pending_messages: usize

Max number of distinct in-flight message ids (a cheap first-line cap; the byte budgets are the real memory guard).

max_chunk_data_len: usize

Max data bytes a single chunk may carry.

max_message_bytes: usize

Max buffered data bytes for one in-flight message.

max_chunks_per_message: usize

Max number of slots (chunks) one in-flight message may have — i.e. the largest total a chunk may claim. Caps the slot/BTreeMap count of a single message so a hostile peer cannot use one id with a huge total and tiny chunks to allocate millions of slots while staying under max_message_bytes (which only counts data bytes).

max_total_buffered_cost: usize

Max buffered cost (data bytes + per-slot overhead) summed across all in-flight messages.

slot_overhead: usize

Bookkeeping charge per slot — a conservative estimate (not an exact measurement) of the BTreeMap node plus Bytes header/refcount a slot costs, so a flood of tiny chunks is bounded by slot count, not only by summed data bytes. Real per-slot heap use may differ; this is deliberately generous so the budget over- rather than under-counts.

max_completed_ids: usize

Max number of recently-completed message ids remembered as tombstones, to suppress a re-delivery if a message is fully retransmitted after it already completed (within its TTL window). Bounds the tombstone memory. NOTE: past this many concurrent live tombstones the oldest is dropped even if its TTL has not elapsed, so the “no post-completion redelivery” guarantee holds only for the most recent max_completed_ids completions within a TTL window.

Implementations

impl ReassemblyLimits

pub fn production() -> ReassemblyLimits

The limits used in production, derived from the transport / message ceilings. This is the one place that reaches for transport-specific constants; the reassembler itself does not.

pub fn constrained() -> ReassemblyLimits

Smaller limits for constrained deployments.

This profile preserves the protocol-level 60 MB send ceiling elsewhere, but bounds one receiver’s reassembly memory to a few MiB so weak devices can reject oversized in-flight transfers before allocating for them.

Trait Implementations

impl Clone for ReassemblyLimits

fn clone(&self) -> ReassemblyLimits

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ReassemblyLimits

impl Debug for ReassemblyLimits

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

Formats the value using the given formatter.

impl Default for ReassemblyLimits

fn default() -> ReassemblyLimits

Returns the “default value” for a type.