Struct Runner

pub(crate) struct Runner {
    pub(crate) meta: Arc<ProcedureMeta>,
    pub(crate) procedure: BoxedProcedure,
    pub(crate) manager_ctx: Arc<ManagerContext>,
    pub(crate) step: u32,
    pub(crate) exponential_builder: ExponentialBuilder,
    pub(crate) store: Arc<ProcedureStore>,
    pub(crate) rolling_back: bool,
}

Fields

meta: Arc<ProcedureMeta>

procedure: BoxedProcedure

manager_ctx: Arc<ManagerContext>

step: u32

exponential_builder: ExponentialBuilder

store: Arc<ProcedureStore>

rolling_back: bool

Implementations

impl Runner

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

Return ProcedureManager is running.

pub(crate) async fn run(self)

Run the procedure.

async fn execute_procedure_in_loop(&mut self)

async fn execute_once_with_retry(&mut self, ctx: &Context)

async fn rollback(&mut self, ctx: &Context, err: Arc<Error>)

async fn prepare_rollback(&mut self, err: Arc<Error>)

async fn execute_once(&mut self, ctx: &Context)

fn submit_subprocedure( &self, procedure_id: ProcedureId, procedure_state: ProcedureState, procedure: BoxedProcedure, )

Submit a subprocedure with specific procedure_id.

async fn wait_on_err(&mut self, d: Duration, i: u64)

Extend the retry time to wait for the next retry.

async fn on_suspended(&mut self, subprocedures: Vec<ProcedureWithId>)

async fn persist_procedure(&mut self) -> Result<()>

async fn commit_procedure(&mut self) -> Result<()>

async fn write_procedure_state(&mut self, error: String) -> Result<()>

fn done(&self, output: Option<Output>)