Struct SessionPixSupervisorHandle 

pub struct SessionPixSupervisorHandle {
    cmd_tx: MAsyncTx<Array<WorkerCommand>>,
    pub(crate) gate: Arc<ServiceGate>,
    pub(crate) telemetry: Arc<PixSessionTelemetry>,
}

Cloneable handle to a running SessionPixWorker.

Fields

cmd_tx: MAsyncTx<Array<WorkerCommand>>

gate: Arc<ServiceGate>

telemetry: Arc<PixSessionTelemetry>

This Session’s share of the node-level PIX aggregates.

Carried here rather than on SessionSlot because the slot already holds this handle, and both parties that need it can reach it: the worker publishes through its own clone, and close_session releases through the slot’s.

Implementations

impl SessionPixSupervisorHandle

pub async fn send_event(&self, ev: SessionPixEvent) -> Result<(), ()>

Send a PIX event to the supervisor, awaiting capacity if the channel is full.

Returns Err if the worker is no longer running. Backpressures instead of dropping events, so overflow cannot occur by construction.

pub fn try_send_event(&self, ev: SessionPixEvent) -> bool

Deliver a PIX event without blocking, dropping it if the channel is full.

Returns true if the event was queued.

The synchronous counterpart to send_event, and it exists because one caller cannot await: close_session_with_reason is a plain fn, reached from the manager’s closure-notification task — which HoprSession::poll_close and the empty-read path feed through a non-blocking channel — from the public synchronous SessionManager::close_session, and from handle_session_error on a peer SessionError. None of them may park on a worker that happens to be mid-tick.

A refusal is not lost work, which is what makes dropping acceptable here where it would not be for a lifecycle transition. The only event sent this way is SessionPixEvent::SessionClosed, and its caller treats false as “this close was not answered by the supervisor” and falls back to the immediate teardown that has always been the behaviour on that path.

pub async fn send_action_result( &self, action: SessionPixAction, ok: bool, ) -> Result<(), ()>

Send an action result feedback to the supervisor, awaiting capacity if the channel is full.

pub fn try_send_progress( &self, progress: SsaRecoveryProgress<HoprPseudonym>, ) -> bool

Deliver a recovery-progress snapshot without blocking, dropping it if the channel is full.

Returns true if the snapshot was queued.

Unlike every other event, progress arrives once per acknowledgement batch rather than once per SSA lifecycle transition, so it is the one input whose rate is set by traffic. Awaiting capacity for it would put the supervisor’s scheduling latency on the acknowledgement path — where a stall costs share verification throughput for the whole Session.

Dropping is safe by construction rather than by tolerance: snapshots carry absolute counters, on_recovery_progress keeps the maximum it has seen, and a lower or repeated useful_shares is already treated as benign — concurrent acknowledgement batches make out-of-order snapshots ordinary. A dropped snapshot is therefore indistinguishable from one that arrived out of order, and the next batch supersedes it.

The one thing a drop delays is the ProgressNotification that resets the gate’s served-without-progress ceiling, so max_served_without_progress has to leave room for a few missed snapshots. Since the command channel is drained by a state machine that performs no I/O, drops require a genuinely wedged worker.

Trait Implementations

impl Clone for SessionPixSupervisorHandle

fn clone(&self) -> SessionPixSupervisorHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.