Struct StateWatchNotifier 

pub struct StateWatchNotifier<T> {
    metrics: Arc<Metrics>,
    seqno_tx: Sender<SeqNo>,
    upper_tx: Sender<Antichain<T>>,
}

Fields

metrics: Arc<Metrics>

seqno_tx: Sender<SeqNo>

Fires on every strict seqno advance. Used by waiters that care about any state change (e.g. lease/seqno machinery via StateWatch::wait_for_seqno_ge).

upper_tx: Sender<Antichain<T>>

Holds the current shard upper (write frontier), advanced only when the upper strictly moves forward. Used by StateWatch::wait_for_upper_past so upper waiters (Listen/Subscribe/snapshot) don’t wake on GC, rollups, or since- downgrades that bump the seqno without moving the upper. The watch channel coalesces: a waiter always reads the latest upper, never a stale intermediate.

Implementations

impl<T: Timestamp + Lattice> StateWatchNotifier<T>

pub(crate) fn new(metrics: Arc<Metrics>, initial_upper: Antichain<T>) -> Self

pub(crate) fn notify(&self, seqno: SeqNo, upper: &Antichain<T>)

Wake up any watchers of this state.

seqno is the state’s seqno after the modification, and upper is the shard upper after the modification.

This must be called while under the same lock that modified the state to avoid any potential for out of order SeqNos in the seqno broadcast channel, and so the watched upper never regresses.

This restriction can be lifted (i.e. we could notify after releasing the write lock), but we’d have to reason about out of order SeqNos in the broadcast channel. In particular, if we see RecvError::Lagged then it’s possible we lost X+1 and got X, so if X isn’t sufficient to return, we’d need to grab the read lock and verify the real SeqNo.

Trait Implementations

impl<T: Debug> Debug for StateWatchNotifier<T>

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

Formats the value using the given formatter.