Struct Running 

pub struct Running { /* private fields */ }

A started dataflow: issue epochs, commit them, stop it, join it.

Implementations

impl Running

pub fn task_states(&self) -> Vec<(TaskId, TaskState, Option<TaskId>, i64)>

Every task’s current state: (task, state, send target, milliseconds in that state).

pub fn n_tasks(&self) -> usize

pub fn tracker(&self) -> EpochTracker

A tracker for the tasks this worker runs (every task for a solo run).

pub fn barrier(&self) -> u64

Issue the next epoch now (a barrier to every source); returns it.

pub fn inject_epoch(&self, epoch: u64)

Issue a barrier for a specific epoch to this worker’s sources, setting the local epoch to it. A joined worker calls this when the leader injects epoch e, so every worker’s sources stamp the same epoch — the barrier then aligns across a cross-worker shuffle. (The leader uses Running::barrier to pick e, then tells the workers to inject it.)

pub fn epoch(&self) -> u64

The last epoch issued.

pub fn commit(&self, epoch: u64)

Every task reported epoch: the sources may commit the positions they recorded at it.

pub fn signal_stop(&self)

Tell the sources to stop (Eos flows behind the last data) — WITHOUT issuing a barrier, unlike Running::stop. A clustered run uses this at shutdown: the final epoch was already issued and committed by the leader-coordinated round, so a fresh uncommitted barrier here would leave the sources waiting for a commit that never comes.

pub fn stop(&self) -> u64

Stop: no more periodic epochs, one final barrier, then Stop to every source (Eos flows downstream in order behind the barrier). Returns the final epoch. Idempotent.

pub fn finish( &self, events: &Receiver<Event>, tracker: &mut EpochTracker, on_epoch: impl FnMut(Completed) -> Result<(), String>, ) -> Result<(), String>

Drive events until every task finished: a completed epoch is committed to the sources and handed to on_epoch with its snapshots; a task’s failure stops the graph and is the result. Call after stop (or for a graph whose sources are bounded).

pub fn join(&self)

Join every task. Closes the control channels first, so a source waiting for a final commit that will never come (the coordinator gave up) still exits — uncommitted means replay.