Struct SessionEndpoint 

pub struct SessionEndpoint { /* private fields */ }

Point-to-point session endpoint with state machine. A point-to-point session endpoint.

This is the common building block for all session types. It encapsulates:

• Identity (session_id, instance_id)
• State machine (control role, attachment, phase)
• Communication (message receive, state publication)

The endpoint starts in Neutral + Unattached state by default.

Implementations

impl SessionEndpoint

pub fn new( session_id: SessionId, instance_id: InstanceId, transport: Arc<MessageTransport>, msg_rx: Receiver<SessionMessage>, ) -> Self

Create a new endpoint in Neutral + Unattached state.

pub fn new_attached( session_id: SessionId, instance_id: InstanceId, peer: InstanceId, role: ControlRole, phase: SessionPhase, transport: Arc<MessageTransport>, msg_rx: Receiver<SessionMessage>, ) -> Self

Create a new endpoint with pre-attached state.

Used when creating a session that is already attached to a peer (e.g., ResponderSession which is pre-attached to the initiator).

pub fn session_id(&self) -> SessionId

Get the session ID.

pub fn instance_id(&self) -> InstanceId

Get this endpoint’s instance ID.

pub fn control_role(&self) -> ControlRole

Get the current control role.

pub fn is_attached(&self) -> bool

Check if a peer is attached.

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

Get the attached peer’s instance ID.

pub fn phase(&self) -> SessionPhase

Get the current session phase.

pub fn is_complete(&self) -> bool

Check if the session is in a terminal state.

pub fn set_phase(&mut self, phase: SessionPhase)

Set the session phase.

pub fn set_control_role(&mut self, role: ControlRole)

Set the control role.

Use this for direct role changes (e.g., when processing YieldControl or AcquireControl messages).

pub fn accept_attachment(&mut self, peer: InstanceId, role: ControlRole)

Accept an attachment from a peer.

Transitions from Unattached to Attached and sets the control role.

pub fn detach(&mut self) -> Option<InstanceId>

Detach from the current peer.

Returns the detached peer’s instance ID if there was one.

pub fn yield_control(&mut self) -> Result<()>

Yield control to peer.

Transitions from Controller to Neutral. Returns Err if not currently Controller.

pub fn acquire_control(&mut self) -> Result<()>

Acquire control from peer.

Transitions from Neutral or Controllee to Controller. The peer must be in Neutral state for this to succeed.

pub fn peer_yielded_control(&mut self)

Handle a peer yielding control to us.

Transitions to Neutral (peer has yielded, we can now acquire if we want).

pub fn peer_acquired_control(&mut self) -> Result<()>

Handle a peer acquiring control.

Transitions from Neutral to Controllee.

pub async fn recv(&mut self) -> Option<SessionMessage>

Receive the next message.

Returns None when the channel is closed.

pub fn try_recv(&mut self) -> Result<SessionMessage, TryRecvError>

Try to receive a message without blocking.

pub async fn send_attach( &self, peer: InstanceId, as_role: ControlRole, ) -> Result<()>

Send an attach message to a peer.

pub async fn send_detach(&self) -> Result<()>

Send a detach message to the current peer.

pub async fn send_yield_control(&self) -> Result<()>

Send yield control message to peer.

pub async fn send_acquire_control(&self) -> Result<()>

Send acquire control message to peer.

pub async fn send_to(&self, peer: InstanceId, msg: SessionMessage) -> Result<()>

Send a message to a specific peer.

pub async fn send(&self, msg: SessionMessage) -> Result<()>

Send a message to the currently attached peer.

pub fn publish_state(&self, g2_blocks: Vec<BlockInfo>, g3_pending: usize)

Publish the current state snapshot.

This updates all watchers with the new state.

pub fn publish_state_with_layer_range( &self, g2_blocks: Vec<BlockInfo>, g3_pending: usize, layer_range: Option<Range<usize>>, )

Publish state with layer range information.

Used for layerwise transfer where specific layers are ready.

pub fn state_rx(&self) -> Receiver<SessionStateSnapshot>

Get a receiver for state updates.

Returns a watch receiver that will receive state snapshots whenever they are published.

pub fn transport(&self) -> &Arc<MessageTransport>

Get the transport for direct access (for legacy interop).