Struct WorkflowContext

Source

pub struct WorkflowContext { /* private fields */ }

Implementations§

Source §

impl WorkflowContext

Source

pub fn workflow_identity(&self) -> Result<WorkflowIdentity>

Identity of the parent workflow currently being replayed.

Source

pub fn activity<T: Serialize>( &self, activity_type: impl Into<String>, args: T, ) -> ActivityCall ⓘ

Source

pub fn activity_on_queue<T, Q>( &self, activity_type: impl Into<String>, task_queue: Option<Q>, args: T, ) -> ActivityCall ⓘ
where T: Serialize, Q: Into<String>,

Source

pub fn activity_with_options<T: Serialize>( &self, activity_type: impl Into<String>, options: ActivityOptions, args: T, ) -> ActivityCall ⓘ

Schedule one durable activity with retry, routing, and timeout options.

Options are validated before the command is emitted. Once the command is recorded, replay consumes the same activity lifecycle at this command position and never emits a duplicate schedule.

let result = ctx
    .activity_with_options(
        "charge-card",
        ActivityOptions::new()
            .task_queue("payments")
            .retry_policy(
                ActivityRetryPolicy::new(4).exponential_backoff(
                    Duration::from_secs(1),
                    2,
                    Some(Duration::from_secs(30)),
                ),
            )
            .start_to_close_timeout(Duration::from_secs(60))
            .schedule_to_close_timeout(Duration::from_secs(180))
            .heartbeat_timeout(Duration::from_secs(15)),
        json!([{"order_id": "order-42"}]),
    )
    .await;
match result {
    Err(Error::ActivityFailed(failure)) => Ok(json!({
        "reason": failure.reason,
        "timeout_kind": failure.timeout_kind,
    })),
    other => other,
}

Source

pub fn wait_signal(&self, signal_name: impl Into<String>) -> SignalCall ⓘ

Source

pub fn sleep(&self, duration: Duration) -> TimerCall ⓘ

Wait for server-backed durable time without blocking the worker executor.

Polling this future emits one start_timer command and yields. The server records the deadline, so neither worker nor server restarts reset the wait. Replay resolves the future only from a TimerScheduled and TimerFired pair at the same position in the shared durable-command stream, with matching sequence, timer identity, and delay. Sub-second durations round up because protocol deadlines use whole seconds.

let mut worker = Worker::new(client, "rust-workers");
worker.register_workflow("delayed-greeting", |ctx, _input| async move {
    ctx.sleep(Duration::from_secs(5)).await?;
    Ok(json!({"status": "timer fired"}))
});

Source

pub fn start_timer(&self, duration: Duration) -> TimerCall ⓘ

Alias for WorkflowContext::sleep for timer-oriented workflow code.

Source

pub fn side_effect<T, F>(&self, callback: F) -> Result<T>
where T: Serialize + DeserializeOwned, F: FnOnce() -> T,

Evaluate a non-deterministic callback once and durably record its typed value.

On replay the callback is not invoked: the value is decoded from the sequence-matched SideEffectRecorded event using the workflow’s payload codec. Use this for UUIDs, wall-clock snapshots, random values, and other small values that must remain fixed for the lifetime of a workflow run.

Source

pub fn uuid_v4(&self) -> Result<Uuid>

Record a UUIDv4 once and return the same UUID on every replay.

Source

pub fn get_version( &self, change_id: impl Into<String>, min_supported: i32, max_supported: i32, ) -> Result<i32>

Select the newest supported version for a change, or replay the version already committed for that stable change ID.

Source

pub fn patched(&self, change_id: impl Into<String>) -> Result<bool>

Record or replay the standard -1 (legacy) / 1 (patched) marker.

Source

pub fn deprecate_patch(&self, change_id: impl Into<String>) -> Result<()>

Keep a patch marker in history after the legacy branch has been removed.

Source

pub fn start_child_workflow<T: Serialize>( &self, workflow_type: impl Into<String>, options: ChildWorkflowOptions, args: T, ) -> ChildWorkflowCall ⓘ

Start a named durable child on an explicit queue and await its result.

The command is recorded in the parent’s sequence-ordered durable command stream. Replay keeps a scheduled child pending without emitting another start, or consumes its matching terminal ChildRun* outcome. Successful values preserve the history payload codec and include both sides of the durable relationship; failures are returned as Error::ChildWorkflowFailed.

let mut worker = Worker::new(client, "parent-workers");
worker.register_workflow("order-parent", |ctx, _input| async move {
    let child = ctx
        .start_child_workflow(
            "fulfil-order",
            ChildWorkflowOptions::new("fulfilment-workers")
                .parent_close_policy(ParentClosePolicy::RequestCancel),
            json!([{"order_id": "order-42"}]),
        )
        .await?;
    Ok(child.result)
});