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>, runner: R, terminal_hook: H, ) -> WorkflowRuntimeBuilder<R, H>

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

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

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

Submit a new run. Enqueues step 0 with payload spec.input. Idempotent against in-process duplicates: if a run with the same run_id is already active in this runtime, returns Error::DuplicateRun. Cross-process / cross-restart duplicate-prevention is enforced by Taquba’s dedup key on the step job.

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

Look up the in-process status of a run. Returns None for unknown or already-terminated runs (the registry only retains active runs).

Returns RunState::Cancelling for any run with a pending cancellation request, regardless of its underlying step lifecycle position; the cancellation overlay wins over Pending/Running until the terminal hook fires.

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

Request cancellation of an active run.

Returns Ok(true) if a cancellation was initiated for run_id, or Ok(false) if the run is not active in this runtime (already terminal, never submitted here, or owned by a different runtime instance).

The terminal hook fires once with TerminalStatus::Cancelled:

• Pending / scheduled step: the queued step job is cancelled in Taquba and the hook fires from this call before it returns.
• Running step: cancellation is delivered to the runner via Step::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 hook fires from the worker once the step returns, with any pending transient retry suppressed and the step acked rather than nacked.

Cancellation is best-effort: if the run is already terminal by the time cancel is called (either because the runner returned a terminating StepOutcome or a prior cancel already settled it), cancel returns Ok(false), the run keeps whatever terminal outcome it already delivered, and no additional hook fires.

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 and drains them on shutdown.

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.