Enum FlowState 

pub enum FlowState {
    Created,
    Validated,
    Instantiated,
    Running,
    Draining,
    Completed,
    Cancelled,
    Failed,
}

Flow lifecycle state machine.

Per Doc 04, Section 10.1: 8 states with defined legal transitions. This is the label-only version in torvyn-types. The reactor crate provides an extended version with associated data (stats, error info).

State transition diagram:

  Created -> Validated -> Instantiated -> Running -> Draining -> Completed
  Created -> Failed                                            -> Cancelled
  Validated -> Failed                                          -> Failed
  Running -> Draining -> Failed

Examples

use torvyn_types::FlowState;

let state = FlowState::Created;
assert!(state.can_transition_to(&FlowState::Validated));
assert!(!state.can_transition_to(&FlowState::Running));

let new_state = state.transition_to(FlowState::Validated).unwrap();
assert_eq!(new_state, FlowState::Validated);

Variants

Created

Flow definition has been submitted but not yet validated.

Validated

Contracts and capabilities have been validated.

Instantiated

Components have been instantiated and streams are connected.

Running

The flow is actively processing stream elements.

Draining

The flow is draining remaining elements after a completion or cancellation signal.

Completed

The flow completed successfully.

Cancelled

The flow was cancelled by operator or policy.

Failed

The flow failed due to an unrecoverable error.

Implementations

impl FlowState

pub fn can_transition_to(&self, target: &FlowState) -> bool

Returns true if transitioning from self to target is legal.

Legal transitions (per Doc 04, Section 10.2):

• Created -> Validated | Failed
• Validated -> Instantiated | Failed
• Instantiated -> Running
• Running -> Draining
• Draining -> Completed | Cancelled | Failed

WARM PATH — called per flow state change.

pub fn transition_to( self, target: FlowState, ) -> Result<FlowState, InvalidTransition>

Attempt to transition from self to target.

Returns Ok(target) if the transition is legal, or Err(InvalidTransition) if it is not.

WARM PATH — called per flow state change.

pub const fn is_terminal(&self) -> bool

Returns true if this state is terminal (no further transitions possible).

WARM PATH — checked for flow cleanup.

pub const fn is_active(&self) -> bool

Returns true if this state is active (Created through Running).

Trait Implementations

impl Clone for FlowState

fn clone(&self) -> FlowState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FlowState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FlowState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FlowState

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

Formats the value using the given formatter.

impl Hash for FlowState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FlowState

fn eq(&self, other: &FlowState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for FlowState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for FlowState

impl Eq for FlowState

impl StructuralPartialEq for FlowState