Enum SessionMessage 

pub enum SessionMessage {
    Attach {
        peer: InstanceId,
        session_id: SessionId,
        as_role: ControlRole,
    },
    Detach {
        peer: InstanceId,
        session_id: SessionId,
    },
    YieldControl {
        peer: InstanceId,
        session_id: SessionId,
    },
    AcquireControl {
        peer: InstanceId,
        session_id: SessionId,
    },
    TriggerStaging {
        session_id: SessionId,
    },
    HoldBlocks {
        session_id: SessionId,
        hold_hashes: Vec<SequenceHash>,
    },
    ReleaseBlocks {
        session_id: SessionId,
        release_hashes: Vec<SequenceHash>,
    },
    BlocksPulled {
        session_id: SessionId,
        pulled_hashes: Vec<SequenceHash>,
    },
    StateResponse {
        session_id: SessionId,
        state: SessionStateSnapshot,
    },
    BlocksStaged {
        session_id: SessionId,
        staged_blocks: Vec<BlockInfo>,
        remaining: usize,
        layer_range: Option<Range<usize>>,
    },
    Close {
        session_id: SessionId,
    },
    Error {
        session_id: SessionId,
        message: String,
    },
}

Unified session message protocol. Unified session message protocol.

Unified, bidirectional protocol that supports dynamic control transfer.

Protocol Overview

1. Connection: Attach/Detach for peer management
2. Control Transfer: YieldControl/AcquireControl for bidirectional role changes
3. Block Operations: Commands from controller to controllee
4. State Sync: Responses from controllee to controller
5. Lifecycle: Close/Error for termination

Variants

Attach

Attach to a session as a specific role.

Sent by a peer to establish the session relationship.

Fields

peer: InstanceId

The instance ID of the attaching peer.

session_id: SessionId

The session to attach to.

as_role: ControlRole

The role this peer will assume (typically Controllee or Controller).

Detach

Detach from a session.

Graceful disconnection. The session may continue if other peers are attached.

Fields

peer: InstanceId

The instance ID of the detaching peer.

session_id: SessionId

The session to detach from.

YieldControl

Yield control to peer.

The sender transitions from Controller to Neutral. The receiver (if in Controllee) can then AcquireControl or remain passive.

Fields

peer: InstanceId

The instance ID of the yielding peer.

session_id: SessionId

The session.

AcquireControl

Acquire control from peer.

The sender attempts to become Controller. Valid when sender is Neutral or Controllee and peer is Neutral.

Fields

peer: InstanceId

The instance ID of the peer acquiring control.

session_id: SessionId

The session.

TriggerStaging

Trigger staging of blocks (e.g., G3→G2).

Fields

session_id: SessionId

The session.

HoldBlocks

Request that specific blocks be held (kept alive).

Fields

session_id: SessionId

The session.

hold_hashes: Vec<SequenceHash>

Sequence hashes of blocks to hold.

ReleaseBlocks

Release specific blocks (they can now be evicted).

Fields

session_id: SessionId

The session.

release_hashes: Vec<SequenceHash>

Sequence hashes of blocks to release.

BlocksPulled

Notify that blocks have been pulled via RDMA.

The controllee can release these blocks from its hold.

Fields

session_id: SessionId

The session.

pulled_hashes: Vec<SequenceHash>

Sequence hashes of blocks that were pulled.

StateResponse

Full state snapshot.

Sent after attachment and periodically on state changes.

Fields

session_id: SessionId

The session.

state: SessionStateSnapshot

Complete state snapshot.

BlocksStaged

Notification that blocks have been staged.

This message supports layerwise transfer by optionally specifying which layer range is ready. When layer_range is None, all layers of the staged blocks are ready for transfer.

Fields

session_id: SessionId

The session.

staged_blocks: Vec<BlockInfo>

Newly staged blocks (now in target tier).

remaining: usize

Count of blocks remaining to stage.

layer_range: Option<Range<usize>>

Layer range that is ready for transfer.

• None: All layers are ready (default behavior)
• Some(0..1): Only layer 0 is ready
• Some(0..60): Layers 0-59 are ready

This enables layerwise streaming where the sender computes layer-by-layer and notifies the receiver as each layer completes.

Close

Close the session gracefully.

Fields

session_id: SessionId

The session.

Error

Report an error.

Fields

session_id: SessionId

The session.

message: String

Error description.

Implementations

impl SessionMessage

pub fn session_id(&self) -> SessionId

Extract the session ID from any message variant.

pub fn peer(&self) -> Option<InstanceId>

Extract the peer instance ID if present.

pub fn is_control_command(&self) -> bool

Check if this is a control command (sent by controller).

pub fn is_state_response(&self) -> bool

Check if this is a state response (sent by controllee).

pub fn variant_name(&self) -> &'static str

Get the variant name as a string for logging.

Trait Implementations

impl Clone for SessionMessage

fn clone(&self) -> SessionMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SessionMessage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SessionMessage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SessionMessage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.