Struct P2pNetworkYamuxState

pub struct P2pNetworkYamuxState {
    pub message_size_limit: Limit<usize>,
    pub pending_outgoing_limit: Limit<usize>,
    pub buffer: Vec<u8>,
    pub incoming: VecDeque<YamuxFrame>,
    pub streams: BTreeMap<StreamId, YamuxStreamState>,
    pub terminated: Option<Result<Result<(), YamuxSessionError>, YamuxFrameParseError>>,
    pub init: bool,
}

Fields

message_size_limit: Limit<usize>

pending_outgoing_limit: Limit<usize>

buffer: Vec<u8>

incoming: VecDeque<YamuxFrame>

streams: BTreeMap<StreamId, YamuxStreamState>

terminated: Option<Result<Result<(), YamuxSessionError>, YamuxFrameParseError>>

init: bool

Implementations

impl P2pNetworkYamuxState

pub fn next_stream_id( &self, kind: YamuxStreamKind, incoming: bool, ) -> Option<StreamId>

Calculates and returns the next available stream ID for outgoing communication.

pub fn consume(&mut self, len: usize)

pub fn limit(&self) -> usize

pub fn set_err(&mut self, err: YamuxFrameParseError)

pub fn set_res(&mut self, res: Result<(), YamuxSessionError>)

pub fn try_parse_frame(&mut self, offset: usize) -> Option<usize>

Attempts to parse a Yamux frame from the buffer starting at the given offset. Returns the number of bytes consumed if a frame was successfully parsed.

pub fn parse_frames(&mut self)

Attempts to parse all available complete frames from the buffer, then shifts and compacts the buffer as needed.

fn shift_and_compact_buffer(&mut self, offset: usize)

pub fn extend_buffer(&mut self, data: &[u8])

Extends the internal buffer with new data, ensuring it has appropriate capacity. On first use, reserves the initial capacity.

pub fn incoming_frame_count(&self) -> usize

Returns the number of incoming frames that have been parsed and are ready for processing.

impl P2pNetworkYamuxState

pub fn reducer<State, Action>( state_context: Substate<'_, Action, State, P2pNetworkSchedulerState>, action: ActionWithMeta<P2pNetworkYamuxAction>, ) -> Result<(), String>

where State: P2pStateTrait, Action: P2pActionTrait<State>,

Handles the main reducer logic for Yamux protocol actions. It processes incoming and outgoing data, selects appropriate behavior based on frame types, and manages the state of streams within a Yamux session.

High-Level Overview

• When data arrives, it is appended to an internal buffer. The buffer is then parsed for valid Yamux frames (using protocol-specific header fields and logic). Incomplete data remains in the buffer for future parsing.
• On successful parsing, frames are enqueued for further handling (e.g., dispatching actions to notify higher-level protocols or responding to pings).
• If protocol inconsistencies or invalid headers are encountered, it marks an error or terminates gracefully, preventing further processing of unexpected data.
• Outgoing data is prepared as frames that respect the window constraints and established flags (e.g., SYN, ACK, FIN), and they are dispatched for transmission.
• Once frames are processed, the function checks if the buffer has grown beyond a certain threshold relative to its initial capacity. If so, and if the remaining data is small, it resets the buffer capacity to a default size to avoid excessive memory usage.
• The function also manages streams and their states, ensuring that proper handshake flags are set (SYN, ACK) when a new stream is opened or accepted, enforcing limits on the number of streams, and notifying higher-level components about events like incoming data or connection errors.

Trait Implementations

impl Clone for P2pNetworkYamuxState

fn clone(&self) -> P2pNetworkYamuxState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for P2pNetworkYamuxState

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

Formats the value using the given formatter.

impl Default for P2pNetworkYamuxState

fn default() -> P2pNetworkYamuxState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for P2pNetworkYamuxState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MallocSizeOf for P2pNetworkYamuxState

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl Serialize for P2pNetworkYamuxState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.