Struct RecoveryObserver 

pub struct RecoveryObserver {
    pub observations: UnboundedSender<RecoveryObservation>,
    pub gate: Arc<RecoveryGate>,
}

Reports session activity to the recovery coordinator.

Reporting is a queued hand-off, never a round trip: the caller is often a UI event loop, and a copy decision must never hold that loop up. The queue is unbounded so an observation is never dropped, which matters because the idle observation that ends a turn is the one that makes a copy due. Queue depth stays small in practice: the coordinator only folds an observation into per-session policy state and hands the copy itself to another task. It does pause while it records a failed copy, and the queue is what absorbs that pause instead of the caller.

A caller that must know no copy can start uses RecoveryObserver::reserve rather than the queue: the reservation blocks a copy from starting whether or not queued observations have been read yet.

Fields

observations: UnboundedSender<RecoveryObservation>

gate: Arc<RecoveryGate>

Implementations

impl RecoveryObserver

pub fn observe(&self, observation: RecoveryObservation)

Queues one observation for the coordinator. Returns as soon as the observation is queued; a stopped coordinator makes this a no-op.

pub fn is_busy(&self, session_id: &str) -> bool

pub fn reserve(&self, session_id: &str) -> RecoveryReservation

Holds off any recovery copy for this session until the returned reservation is dropped. This, not the observation queue, is what a lifecycle operation relies on: queued observations may still be unread, and the coordinator refuses to start a copy for a reserved session whenever it reads them.

pub fn cancel_busy(&self, session_id: &str)

Asks an in-flight recovery copy for this session to stop. A foreground lifecycle operation calls this after reserving so it preempts the copy instead of waiting behind it.

pub async fn wait_idle(&self, session_id: &str)

Trait Implementations

impl Clone for RecoveryObserver

fn clone(&self) -> RecoveryObserver

Returns a duplicate of the value.

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

Performs copy-assignment from source.