Struct StateTransition 

pub struct StateTransition {
    pub from: String,
    pub to: String,
}

State transition recorded by an event payload.

Fields

from: String

State before the transition.

to: String

State after the transition.

Implementations

impl StateTransition

pub fn new(from: impl Into<String>, to: impl Into<String>) -> Self

Creates a state transition description.

Arguments

• from: Previous state name.
• to: New state name.

Returns

Returns a StateTransition.

Examples found in repository

examples/diagnostic_replay.rs (line 77)

fn main() {
    // Build the child identifier.
    let child_id = ChildId::new("market_feed");
    // Build the child path.
    let child_path = SupervisorPath::root().join("market_feed");
    // Build a typed task failure.
    let failure = TaskFailure::new(
        // Set the failure kind.
        TaskFailureKind::Timeout,
        // Set the low-cardinality failure category.
        "external_dependency",
        // Set the diagnostic failure message.
        "market feed heartbeat timed out",
        // Finish the typed task failure.
    );
    // Build the restart policy decision.
    let policy = PolicyDecision::new(
        // Set the decision label.
        "RestartAfter",
        // Set the restart delay.
        Some(500),
        // Set the diagnostic decision reason.
        Some("heartbeat timeout is restartable".to_owned()),
        // Finish the policy decision.
    );

    // Create the fixed-capacity event journal.
    let mut journal = EventJournal::new(8);
    // Push the running event.
    journal.push(event(
        // Set the event sequence.
        1,
        // Clone the child identifier.
        child_id.clone(),
        // Set the child display name.
        "Market Feed",
        // Build the running event payload.
        What::ChildRunning {
            // Attach the state transition.
            transition: Some(StateTransition::new("Starting", "Running")),
            // Finish the running event payload.
        },
        // Attach no policy decision.
        None,
        // Finish the running event.
    ));
    // Push the failed event.
    journal.push(event(
        // Set the event sequence.
        2,
        // Clone the child identifier.
        child_id.clone(),
        // Set the child display name.
        "Market Feed",
        // Build the failed event payload.
        What::ChildFailed {
            // Attach the typed failure.
            failure: failure.clone(),
            // Finish the failed event payload.
        },
        // Attach the restart policy decision.
        Some(policy.clone()),
        // Finish the failed event.
    ));
    // Push the backoff event.
    journal.push(event(
        // Set the event sequence.
        3,
        // Clone the child identifier.
        child_id.clone(),
        // Set the child display name.
        "Market Feed",
        // Build the backoff payload.
        What::BackoffScheduled { delay_ms: 500 },
        // Attach the restart policy decision.
        Some(policy.clone()),
        // Finish the backoff event.
    ));
    // Push the restarted event.
    journal.push(event(
        // Set the event sequence.
        4,
        // Clone the child identifier.
        child_id.clone(),
        // Set the child display name.
        "Market Feed",
        // Build the restarted payload.
        What::ChildRestarted { restart_count: 1 },
        // Attach the restart policy decision.
        Some(policy.clone()),
        // Finish the restarted event.
    ));

    // Build the final child state.
    let child = ChildState::declared(child_path, child_id, "Market Feed")
        // Set the child lifecycle state.
        .with_lifecycle_state(ChildLifecycleState::Running, EventSequence::new(1))
        // Record the latest failure.
        .record_failure(failure, EventSequence::new(2))
        // Record the latest policy decision.
        .with_policy_decision(policy, 1);
    // Build the final supervisor state.
    let final_state = SupervisorState::new(SupervisorPath::root(), EventSequence::new(4), 1)
        // Add the child state.
        .with_child(child)
        // Mark shutdown as completed for the replay.
        .with_shutdown_state(ShutdownState::Completed)
        // Attach the last journal sequence.
        .with_journal_sequence(EventSequence::new(4));
    // Build the diagnostic run summary.
    let summary = RunSummaryBuilder::new(8).build(
        // Read recent events from the journal.
        &journal,
        // Attach the final current state.
        final_state,
        // Attach the shutdown cause.
        Some("diagnostic replay complete".to_owned()),
        // Finish the summary construction.
    );
    // Create the metrics facade.
    let metrics = MetricsFacade::new();

    // Print summary counters.
    println!(
        // Provide the output template.
        "summary restart_count={} failure_count={} recent_events={}",
        // Print the restart count.
        summary.restart_count,
        // Print the failure count.
        summary.failure_count,
        // Print the recent event count.
        summary.recent_events.len(),
        // Finish summary output.
    );
    // Iterate over recent journal events.
    for event in journal.recent(8) {
        // Print event names and derived metrics.
        println!(
            // Provide the output template.
            "event={} metrics={:?}",
            // Print the event name.
            event.what.name(),
            // Print metrics derived from the event.
            metrics.samples_for_event(&event),
            // Finish event output.
        );
        // Finish the journal replay loop.
    }
    // End the diagnostic replay example.
}

Trait Implementations

impl Clone for StateTransition

fn clone(&self) -> StateTransition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StateTransition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StateTransition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for StateTransition

fn eq(&self, other: &StateTransition) -> 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 StateTransition

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for StateTransition

impl StructuralPartialEq for StateTransition