Struct ManagerContext

pub(crate) struct ManagerContext {
    loaders: Mutex<HashMap<String, BoxedProcedureLoader>>,
    key_lock: KeyRwLock<String>,
    dynamic_key_lock: Arc<KeyRwLock<String>>,
    procedures: RwLock<HashMap<ProcedureId, Arc<ProcedureMeta>>>,
    running_procedures: Mutex<HashSet<ProcedureId>>,
    finished_procedures: Mutex<VecDeque<(ProcedureId, Instant)>>,
    running: Arc<AtomicBool>,
    poison_manager: PoisonStoreRef,
}

Shared context of the manager.

Fields

loaders: Mutex<HashMap<String, BoxedProcedureLoader>>

Procedure loaders. The key is the type name of the procedure which the loader returns.

key_lock: KeyRwLock<String>

The key lock for the procedure.

The lock keys are defined in Procedure::lock_key(). These locks are acquired before the procedure starts and released after the procedure finishes. They ensure exclusive access to resources throughout the entire procedure lifecycle.

dynamic_key_lock: Arc<KeyRwLock<String>>

The dynamic lock for procedure execution.

Unlike the procedure-level locks, these locks are acquired dynamically by the procedure during execution. They are only held when the procedure specifically needs these keys and are released as soon as the procedure no longer needs them. This allows for more fine-grained concurrency control during procedure execution.

procedures: RwLock<HashMap<ProcedureId, Arc<ProcedureMeta>>>

Procedures in the manager.

running_procedures: Mutex<HashSet<ProcedureId>>

Running procedures.

finished_procedures: Mutex<VecDeque<(ProcedureId, Instant)>>

Ids and finished time of finished procedures.

running: Arc<AtomicBool>

Running flag.

poison_manager: PoisonStoreRef

Poison manager.

Implementations

impl ManagerContext

fn new(poison_manager: PoisonStoreRef) -> ManagerContext

Returns a new ManagerContext.

pub(crate) fn start(&self)

Set the running flag.

pub(crate) fn stop(&self)

pub(crate) fn running(&self) -> bool

Return ProcedureManager is running.

fn contains_procedure(&self, procedure_id: ProcedureId) -> bool

Returns true if the procedure with specific procedure_id exists.

fn num_running_procedures(&self) -> usize

Returns the number of running procedures.

fn try_insert_procedure(&self, meta: Arc<ProcedureMeta>) -> bool

Try to insert the procedure to the context if there is no procedure with same ProcedureId.

Returns false if there is already a procedure using the same ProcedureId.

fn state(&self, procedure_id: ProcedureId) -> Option<ProcedureState>

Returns the ProcedureState of specific procedure_id.

fn list_procedure(&self) -> Vec<ProcedureInfo>

Returns the ProcedureMeta of all procedures.

fn watcher(&self, procedure_id: ProcedureId) -> Option<Watcher>

Returns the Watcher of specific procedure_id.

fn notify_by_subprocedure(&self, procedure_id: ProcedureId)

Notify a suspended parent procedure with specific procedure_id by its subprocedure.

fn load_one_procedure_from_message( &self, procedure_id: ProcedureId, message: &ProcedureMessage, ) -> Option<LoadedProcedure>

Load procedure from specific ProcedureMessage.

fn procedures_in_tree(&self, root: &Arc<ProcedureMeta>) -> Vec<ProcedureId>

Returns all procedures in the tree (including given root procedure).

If callers need a consistent view of the tree, they must ensure no new procedure is added to the tree during using this method.

fn find_procedures( &self, procedure_ids: &[ProcedureId], metas: &mut Vec<Arc<ProcedureMeta>>, )

Finds procedures by given procedure_ids.

Ignores the id if corresponding procedure is not found.

fn on_procedures_finish(&self, procedure_ids: &[ProcedureId])

Clean resources of finished procedures.

fn remove_outdated_meta(&self, ttl: Duration)

Remove metadata of outdated procedures.

Trait Implementations

impl ContextProvider for ManagerContext

fn procedure_state<'life0, 'async_trait>( &'life0 self, procedure_id: ProcedureId, ) -> Pin<Box<dyn Future<Output = Result<Option<ProcedureState>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Query the procedure state.

fn try_put_poison<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 PoisonKey, procedure_id: ProcedureId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Try to put a poison key for a procedure.

fn acquire_lock<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 StringKey, ) -> Pin<Box<dyn Future<Output = DynamicKeyLockGuard> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Acquires a key lock for the procedure.