Struct WorkflowRuntime 

pub struct WorkflowRuntime<R, H> { /* private fields */ }

Durable runtime for workflow runs. Cheap to clone (internally Arc).

Implementations

impl<R: StepRunner, H: TerminalHook> WorkflowRuntime<R, H>

pub fn builder( queue: Arc<Queue>, object_store: Arc<dyn ObjectStore>, runner: R, terminal_hook: H, ) -> WorkflowRuntimeBuilder<R, H>

Start configuring a runtime. Takes the four required dependencies (Taquba queue, object store, StepRunner, TerminalHook); optional fields are set via WorkflowRuntimeBuilder methods before build.

The object store backs Delivery::memo; it does not need to be the same store the Queue was opened with, though sharing one store is the common case (just clone the Arc). Use a distinct WorkflowRuntimeBuilder::memo_prefix when multiple runtimes share one store.

Use crate::NoopTerminalHook if you don’t need terminal callbacks.

pub async fn submit(&self, spec: RunSpec) -> Result<SubmitOutcome>

Submit a new run. Enqueues step 0 with payload spec.input.

Idempotent on (run_id, spec.input): if a run with the same id is already active (its durable run record in Taquba’s user KV namespace exists, whichever process submitted it) and spec.input matches the original submission, this call is a no-op and the returned SubmitOutcome has newly_submitted = false. A re-submission of an active run_id with a different input is rejected with Error::InputMismatch; pick a fresh run_id for a new run.

pub fn view(&self) -> &WorkflowView

The runtime’s view of its store: the read-only queries over the queue and the memo store the runtime writes to.

pub async fn status(&self, run_id: &RunId) -> Result<Option<RunStatus>>

WorkflowView::status through the runtime’s view, so the status is available after a restart and from any runtime over the same queue.

pub async fn outcome(&self, run_id: &RunId) -> Result<Option<RunOutcome>>

WorkflowView::outcome through the runtime’s view.

pub async fn wait(&self, run_id: &RunId) -> Result<RunEnd>

Wait until the run run_id terminates and report its end. The wait follows the run’s current step across its steps, so it answers for a run of any length, after a restart and from any runtime over the same queue; a run already terminated is reported at once from its records. A step dead-lettered outside the worker is terminated by the worker’s dead-step reconciliation, which the wait polls for at the poll interval.

Returns Error::RunNotFound for a run the runtime has no record of: never submitted, or terminated and swept.

pub async fn wait_timeout( &self, run_id: &RunId, timeout: Duration, ) -> Result<Option<RunEnd>>

Self::wait bounded by timeout; Ok(None) when the timeout elapses first.

pub async fn cancel(&self, run_id: &RunId) -> Result<bool>

Request cancellation of an active run.

Returns Ok(true) once the request is recorded on the run’s durable record, or Ok(false) if the run is unknown or already terminal, including a run whose current step the queue dead-lettered outside the worker, which the worker’s dead-step reconciliation terminates as failed. The request reaches a run after a restart and from any runtime over the same queue.

The run terminates as TerminalStatus::Cancelled and its notification job is enqueued for the terminal hook:

• Pending / scheduled step: the queued step job is removed and the notification enqueued in one transaction before this call returns; the hook runs from a worker afterwards.
• Running step: cancellation is delivered to the runner via Delivery::cancel_token; runners that watch the token short-circuit immediately. Runners that ignore the token are allowed to run to completion (futures cannot be safely aborted mid-step). In both cases the runner’s StepOutcome / StepError is discarded and the worker settles the run once the step returns, with any pending transient retry suppressed and the step acked rather than nacked.
• A step claimed after the request is settled as cancelled without running.

Cancellation is best-effort: a run whose terminal step settles while the request is recorded keeps the outcome it committed. A request applies only to the run it is recorded on, and a later submission of the same run id starts without it.

pub fn group(&self, id: RunId) -> RunGroup

The group named id.

pub fn new_group(&self) -> RunGroup

A group with a generated id.

pub fn spawn<F>(&self, shutdown: F) -> RunnerHandle

where F: Future<Output = ()> + Send + 'static, R: 'static, H: 'static,

Spawn Self::run as a Tokio task and return a handle for graceful shutdown. The worker runs until shutdown resolves or RunnerHandle::shutdown is called; in-flight steps finish either way.

pub async fn run<F>(&self, shutdown: F) -> Result<()>

where F: Future<Output = ()>, R: 'static, H: 'static,

Drive the step worker loop until shutdown resolves. Spawns up to max_concurrent_steps step processors, the dead-step reconciliation that terminates runs whose step the queue dead-lettered outside the worker and, when WorkflowRuntimeBuilder::memo_retention is set, a memo-retention sweeper, all running in parallel. All halt cleanly when shutdown resolves or the worker errors.

impl<R: StepRunner, H: TerminalHook> WorkflowRuntime<R, H>

pub async fn signal( &self, correlation_key: &str, payload: Vec<u8>, ) -> Result<SignalOutcome>

Deliver a signal for correlation_key, waking the run waiting on it via Trigger::OnSignal.

When a waiter is registered and still waiting, its next step is promoted immediately and observes payload on Step::signal; the call returns SignalOutcome::Delivered. Otherwise the signal is buffered durably under the correlation key and the next waiter registered for it consumes the buffered payload at its registration; the call returns SignalOutcome::Buffered.

One buffered signal is held per correlation key: a second signal before consumption replaces the first. A buffered signal persists until a waiter consumes it or Self::clear_signal discards it. The buffer write is durable before the call returns, so a signal is never lost once this call returns; delivery to a waiter whose registration is settling concurrently falls back to the buffer and reaches it no later than its timeout.

pub async fn clear_signal(&self, correlation_key: &str) -> Result<bool>

Discard the buffered signal for correlation_key, if one exists. Returns true when a buffered signal was removed.

Trait Implementations

impl<R, H> Clone for WorkflowRuntime<R, H>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.