Struct OrchestrationContext 

pub struct OrchestrationContext { /* private fields */ }

The orchestration context provided to orchestrator functions.

All methods are safe to call from async code. The context is cloneable and thread-safe (Send + Sync), backed by Arc<Mutex<>>.

Implementations

impl OrchestrationContext

pub fn instance_id(&self) -> Arc<str>

Get the instance ID.

pub fn current_utc_datetime(&self) -> DateTime<Utc>

Get the current UTC datetime (deterministic, from history events).

pub fn is_replaying(&self) -> bool

Check if the orchestrator is currently replaying.

pub fn name(&self) -> Arc<str>

Get the orchestration name.

pub fn input<T: DeserializeOwned>(&self) -> Result<T>

Get the orchestration input, deserialised from JSON.

pub fn propagated_history(&self) -> Option<Arc<PropagatedHistory>>

Returns history forwarded from the parent workflow, if the parent scheduled this child with a non-None history propagation scope.

See HistoryPropagationScope for the parent-side trade-off between OwnHistory and Lineage.

pub fn set_custom_status(&self, status: impl Into<String>)

Set a custom status string.

pub fn call_activity( &self, name: &str, input: impl Serialize, ) -> CompletableTask

Schedule an activity for execution.

Returns a CompletableTask that resolves when the activity completes.

During replay: if the corresponding TaskCompleted/TaskFailed event exists in history, the task will already be complete. During new execution: creates a ScheduleTaskAction.

pub fn call_activity_with_app_id( &self, name: &str, input: impl Serialize, app_id: &str, ) -> CompletableTask

Schedule an activity with an app_id for cross-app scenarios.

pub fn call_activity_with_options( &self, name: &str, input: impl Serialize, options: ActivityOptions, ) -> impl Future<Output = Result<Option<String>>> + Send + 'static

Schedule an activity with options (retry policy, app ID).

Returns a future that drives the activity to completion, transparently scheduling durable timers and re-issuing the activity on each retry.

pub fn call_sub_orchestrator( &self, name: &str, input: impl Serialize, instance_id: Option<&str>, ) -> CompletableTask

Schedule a sub-orchestration for execution.

pub fn call_sub_orchestrator_with_app_id( &self, name: &str, input: impl Serialize, instance_id: Option<&str>, app_id: &str, ) -> CompletableTask

Schedule a sub-orchestration targeting a specific Dapr app ID.

pub fn call_sub_orchestrator_with_options( &self, name: &str, input: impl Serialize, options: SubOrchestratorOptions, ) -> impl Future<Output = Result<Option<String>>> + Send + 'static

Schedule a sub-orchestration with options (instance ID, retry policy, app ID).

Returns a future that drives the sub-orchestration to completion, transparently scheduling durable timers and re-issuing the call on each retry.

Note: when a retry policy is set and no explicit instance_id is given, each retry uses a freshly generated instance ID.

pub fn create_timer(&self, delay: Duration) -> CompletableTask

Create a durable timer that fires after the specified duration.

pub fn wait_for_external_event(&self, name: &str) -> CompletableTask

Wait for an external event with the given name.

Event names are case-insensitive.

Patched executions also emit a far-future timer tagged with the event name, letting the runtime track the wait.

pub async fn wait_for_external_event_with_timeout( &self, name: &str, timeout: Duration, ) -> Result<ExternalEventResult>

Wait for an external event with a timeout.

Returns ExternalEventResult::Received if the event arrives before the timeout, or ExternalEventResult::TimedOut if the timeout fires first.

Always emits a timer tagged with the event name.

Event names are case-insensitive.

pub fn continue_as_new(&self, input: impl Serialize, save_events: bool)

Continue the orchestration as new with new input.

pub fn is_patched(&self, patch_name: &str) -> bool

Check whether a named patch should be applied in the current execution.

This enables safe, deterministic code upgrades. Wrap new behaviour in if ctx.is_patched("my-patch") to ensure that:

• Replaying executions that previously ran the unpatched path continue on the unpatched path (preserving determinism).
• Executions that previously ran the patched path continue on the patched path.
• Brand-new executions (at the history frontier) always take the patched path.

This matches the behaviour of the Go and Python SDKs.

Trait Implementations

impl Clone for OrchestrationContext

fn clone(&self) -> OrchestrationContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.