Struct Executor

pub struct Executor {
    inner: Arc<ExecutorInner>,
}

Executor that drives forward state machines under its management.

Each state transition is atomic and supposed to be idempotent such that a stop/crash of the executor at any point can be recovered from on restart. The executor is aware of the concept of Fedimint modules and can give state machines a different execution context depending on the owning module, making it very flexible.

Fields

inner: Arc<ExecutorInner>

Implementations

impl Executor

pub fn builder() -> ExecutorBuilder

Creates an ExecutorBuilder

pub async fn get_active_states(&self) -> Vec<(DynState, ActiveStateMeta)>

pub async fn add_state_machines(&self, states: Vec<DynState>) -> Result<()>

Adds a number of state machines to the executor atomically. They will be driven to completion automatically in the background.

Attention: do not use before background task is started!

pub async fn add_state_machines_dbtx( &self, dbtx: &mut DatabaseTransaction<'_>, states: Vec<DynState>, ) -> AddStateMachinesResult

Adds a number of state machines to the executor atomically with other DB changes is dbtx. See Executor::add_state_machines for more details.

Panics

If called before background task is started using Executor::start_executor!

pub async fn contains_active_state<S: State>( &self, instance: ModuleInstanceId, state: S, ) -> bool

Mostly used for testing

Check if state exists in the database as part of an actively running state machine.

pub async fn contains_inactive_state<S: State>( &self, instance: ModuleInstanceId, state: S, ) -> bool

Mostly used for testing

Check if state exists in the database as inactive. If the state is terminal it means the corresponding state machine finished its execution. If the state is non-terminal it means the state machine was in that state at some point but moved on since then.

pub async fn await_inactive_state(&self, state: DynState) -> InactiveStateMeta

pub async fn await_active_state(&self, state: DynState) -> ActiveStateMeta

pub async fn get_operation_states( &self, operation_id: OperationId, ) -> (Vec<(DynState, ActiveStateMeta)>, Vec<(DynState, InactiveStateMeta)>)

Only meant for debug tooling

pub fn start_executor( &self, context_gen: Arc<dyn Fn(ModuleInstanceId, OperationId) -> DynGlobalClientContext + Send + Sync>, )

Starts the background thread that runs the state machines. This cannot be done when building the executor since some global contexts in turn may depend on the executor, forming a cyclic dependency.

Panics

If called more than once.

pub fn stop_executor(&self) -> Option<()>

Stops the background task that runs the state machines.

If a shutdown signal was sent it returns a [oneshot::Receiver] that will be signalled when the main loop of the background task has exited. This can be useful to block until the executor has stopped to avoid errors due to the async runtime shutting down while the task is still running.

If no shutdown signal was sent it returns None. This can happen if stop_executor is called multiple times.

Panics

If called in parallel with start_executor.

pub fn notifier(&self) -> &Notifier

Returns a reference to the Notifier that can be used to subscribe to state transitions

Trait Implementations

impl Clone for Executor

fn clone(&self) -> Executor

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Executor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.