Struct ActivityScope 

pub struct ActivityScope;

Scope for executing an activity within a transaction.

When an activity is executed within this scope:

1. A transaction is started from the storage backend
2. All writes are buffered via buffer_write
3. On success, buffered writes are applied to the transaction, then it commits
4. On failure (panic or error), the transaction rolls back

This ensures that persistence is SYNCHRONOUS with activity completion - the activity only returns success AFTER the transaction is committed.

Implementations

impl ActivityScope

pub async fn run<F, Fut, T>( storage: &Arc<dyn WorkflowStorage>, f: F, ) -> Result<T, ClusterError>

where F: FnOnce() -> Fut, Fut: Future<Output = Result<T, ClusterError>>,

Run an activity within a transactional scope.

The provided async closure is executed with an active transaction. If the closure returns Ok, the transaction is committed SYNCHRONOUSLY before this function returns. If the closure returns Err or panics, the transaction is rolled back.

During execution, the activity can:

• Buffer writes via ActivityScope::buffer_write() (committed atomically)
• Execute arbitrary SQL via ActivityScope::sql_transaction() (if using SQL storage)

pub fn is_active() -> bool

Check if there’s an active transaction in the current task.

pub fn buffer_write(key: String, value: Vec<u8>)

Buffer a write to be applied to the transaction on commit.

This is called by DurableContext to buffer journal writes so that activity results are persisted atomically.

The write is buffered synchronously and applied to the transaction BEFORE the activity returns. No fire-and-forget!

pub async fn db() -> SqlTransactionHandle

Get the activity’s SQL transaction handle.

This is a convenience method that calls sql_transaction() and panics if no SQL transaction is available. Use this in #[activity] methods when you know the storage backend supports SQL transactions.

Panics

Panics if called outside of an activity scope or if the storage backend does not support SQL transactions (e.g., memory storage).

Note

Prefer using self.tx() in activity methods instead. ActivityScope::db() is the legacy API retained for backward compatibility.

pub async fn sql_transaction() -> Option<SqlTransactionHandle>

Get the underlying SQL transaction for executing arbitrary SQL.

Returns None if:

• Not currently within an activity scope
• The storage backend doesn’t support SQL transactions (e.g., memory storage)