Struct RunFsm 

pub struct RunFsm { /* private fields */ }

Finite state machine for a workflow run.

Wraps a RunStatus and enforces valid transitions via typed RunEvents. Records every transition in a history log.

Transition table

From	Event	To
Pending	PickedUp	Running
Pending	CancelRequested	Cancelled
Running	AllStepsCompleted	Completed
Running	StepFailed	Failed
Running	StepFailedRetryable	Retrying
Running	CancelRequested	Cancelled
Retrying	RetryStarted	Running
Retrying	MaxRetriesExceeded	Failed
Retrying	CancelRequested	Cancelled
Running	ApprovalRequested	AwaitingApproval
AwaitingApproval	Approved	Running
AwaitingApproval	Rejected	Failed
AwaitingApproval	CancelRequested	Cancelled

Examples

use ironflow_engine::fsm::{RunFsm, RunEvent};
use ironflow_store::entities::RunStatus;

let mut fsm = RunFsm::new();
assert_eq!(fsm.state(), RunStatus::Pending);

fsm.apply(RunEvent::PickedUp).unwrap();
assert_eq!(fsm.state(), RunStatus::Running);

fsm.apply(RunEvent::AllStepsCompleted).unwrap();
assert_eq!(fsm.state(), RunStatus::Completed);
assert_eq!(fsm.history().len(), 2);

Implementations

impl RunFsm

pub fn new() -> Self

Create a new FSM in Pending state.

Examples

use ironflow_engine::fsm::RunFsm;
use ironflow_store::entities::RunStatus;

let fsm = RunFsm::new();
assert_eq!(fsm.state(), RunStatus::Pending);

pub fn from_state(state: RunStatus) -> Self

Create a FSM from an existing state (e.g. loaded from DB).

Examples

use ironflow_engine::fsm::RunFsm;
use ironflow_store::entities::RunStatus;

let fsm = RunFsm::from_state(RunStatus::Running);
assert_eq!(fsm.state(), RunStatus::Running);

pub fn state(&self) -> RunStatus

Returns the current state.

pub fn history(&self) -> &[Transition<RunStatus, RunEvent>]

Returns the full transition history.

pub fn is_terminal(&self) -> bool

Returns true if the FSM is in a terminal state.

pub fn apply( &mut self, event: RunEvent, ) -> Result<RunStatus, TransitionError<RunStatus, RunEvent>>

Apply an event, transitioning to a new state if valid.

Errors

Returns TransitionError if the event is not allowed in the current state.

Examples

use ironflow_engine::fsm::{RunFsm, RunEvent};
use ironflow_store::entities::RunStatus;

let mut fsm = RunFsm::new();

// Valid transition
assert!(fsm.apply(RunEvent::PickedUp).is_ok());

// Invalid: can't pick up a running run
assert!(fsm.apply(RunEvent::PickedUp).is_err());

pub fn can_apply(&self, event: RunEvent) -> bool

Check if an event would be accepted without applying it.

Examples

use ironflow_engine::fsm::{RunFsm, RunEvent};

let fsm = RunFsm::new();
assert!(fsm.can_apply(RunEvent::PickedUp));
assert!(!fsm.can_apply(RunEvent::AllStepsCompleted));

Trait Implementations

impl Clone for RunFsm

fn clone(&self) -> RunFsm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunFsm

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

Formats the value using the given formatter.

impl Default for RunFsm

fn default() -> Self

Returns the “default value” for a type.