Struct ConfigState 

pub struct ConfigState {
    pub supervisor: SupervisorRootConfig,
    pub policy: PolicyConfig,
    pub shutdown: ShutdownConfig,
    pub observability: ObservabilityConfig,
    pub ipc: Option<DashboardIpcConfig>,
}

Immutable validated configuration state.

Fields

supervisor: SupervisorRootConfig

Root supervisor declaration values.

policy: PolicyConfig

Runtime policy values.

shutdown: ShutdownConfig

Shutdown budget values.

observability: ObservabilityConfig

Observability switches and capacities.

ipc: Option<DashboardIpcConfig>

Optional target-side dashboard IPC configuration.

Implementations

impl ConfigState

pub fn to_supervisor_spec(&self) -> Result<SupervisorSpec, SupervisorError>

Converts validated configuration into a supervisor declaration.

Arguments

This function has no arguments.

Returns

Returns a crate::spec::supervisor::SupervisorSpec derived from the validated YAML configuration.

Examples

let yaml = r#"
supervisor:
  strategy: OneForAll
policy:
  child_restart_limit: 10
  child_restart_window_ms: 60000
  supervisor_failure_limit: 30
  supervisor_failure_window_ms: 60000
  initial_backoff_ms: 10
  max_backoff_ms: 1000
  jitter_ratio: 0.0
  heartbeat_interval_ms: 1000
  stale_after_ms: 3000
shutdown:
  graceful_timeout_ms: 1000
  abort_wait_ms: 100
observability:
  event_journal_capacity: 64
  metrics_enabled: true
  audit_enabled: true
"#;
let state = rust_supervisor::config::yaml::parse_config_state(yaml).unwrap();
let spec = state.to_supervisor_spec().unwrap();
assert_eq!(spec.strategy, rust_supervisor::spec::supervisor::SupervisionStrategy::OneForAll);
assert_eq!(spec.supervisor_failure_limit, 30);

Examples found in repository

examples/config_tree_supervisor.rs (line 15)

fn main() -> ExampleResult {
    // Load centralized YAML configuration.
    let state = load_config_state("examples/config/supervisor.yaml")?;
    // Convert configuration into a supervisor specification.
    let spec = state.to_supervisor_spec()?;
    // Print the derived specification for inspection.
    println!("{spec:#?}");
    // Finish the example successfully.
    Ok(())
    // End the configuration example.
}

examples/supervisor_quickstart.rs (line 19)

async fn main() -> ExampleResult {
    // Load centralized YAML configuration.
    let state = load_config_state("examples/config/supervisor.yaml")?;
    // Derive the supervisor specification from configuration.
    let spec = state.to_supervisor_spec()?;
    // Start the supervisor runtime from the specification.
    let handle = Supervisor::start(spec).await?;
    // Query the current runtime state.
    let current = handle.current_state().await?;
    // Print the current state for the learner.
    println!("{current:#?}");
    // Use the runtime handle for the shutdown request.
    handle
        // Request tree shutdown with audit metadata.
        .shutdown_tree("operator", "quickstart complete")
        // Wait for the shutdown command result.
        .await?;
    // Finish the example successfully.
    Ok(())
    // End the quickstart example.
}

examples/observability_probe.rs (line 19)

async fn main() -> ExampleResult {
    // Load centralized YAML configuration.
    let state = load_config_state("examples/config/supervisor.yaml")?;
    // Derive the supervisor specification from configuration.
    let spec = state.to_supervisor_spec()?;
    // Start the supervisor runtime from the specification.
    let handle = Supervisor::start(spec).await?;
    // Subscribe to runtime event text.
    let mut events = handle.subscribe_events();
    // Query the current runtime state.
    let current = handle.current_state().await?;
    // Print the current state for the learner.
    println!("current={current:#?}");
    // Read one emitted runtime event when it is available.
    let received = events.recv().await;
    // Continue only when an event was received.
    if let Ok(event) = received {
        // Print the observed runtime event.
        println!("event={event:#?}");
        // Finish the optional event display.
    }
    // Use the runtime handle for the shutdown request.
    handle
        // Request tree shutdown with audit metadata.
        .shutdown_tree("operator", "observability probe complete")
        // Wait for the shutdown command result.
        .await?;
    // Finish the example successfully.
    Ok(())
    // End the observability example.
}

examples/shutdown_tree.rs (line 21)

async fn main() -> ExampleResult {
    // Load centralized YAML configuration.
    let state = load_config_state("examples/config/supervisor.yaml")?;
    // Derive the supervisor specification from configuration.
    let spec = state.to_supervisor_spec()?;
    // Start the supervisor runtime from the specification.
    let handle = Supervisor::start(spec).await?;
    // Build the visible shutdown phase list.
    let phases = [
        // Show the stop request phase.
        ShutdownPhase::RequestStop,
        // Show the graceful drain phase.
        ShutdownPhase::GracefulDrain,
        // Show the abort stragglers phase.
        ShutdownPhase::AbortStragglers,
        // Show the final reconcile phase.
        ShutdownPhase::Reconcile,
        // Finish the shutdown phase list.
    ];
    // Iterate over the visible shutdown phases.
    for phase in phases {
        // Print each planned phase.
        println!("planned phase={phase:#?}");
        // Finish the phase display loop.
    }
    // Use the runtime handle for the shutdown request.
    handle
        // Request tree shutdown with audit metadata.
        .shutdown_tree("operator", "shutdown tree example")
        // Wait for the shutdown command result.
        .await?;
    // Finish the example successfully.
    Ok(())
    // End the shutdown example.
}

examples/runtime_control_story.rs (line 23)

async fn main() -> ExampleResult {
    // Load centralized YAML configuration.
    let state = load_config_state("examples/config/supervisor.yaml")?;
    // Derive the supervisor specification from configuration.
    let spec = state.to_supervisor_spec()?;
    // Start the supervisor runtime from the specification.
    let handle = Supervisor::start(spec).await?;
    // Subscribe to runtime event text.
    let mut events = handle.subscribe_events();
    // Build the child identifier used by operator commands.
    let child_id = ChildId::new("market_feed");

    // Send an add child command through the control handle.
    let add = handle
        // Add a manifest under the root supervisor.
        .add_child(
            // Target the root supervisor.
            SupervisorPath::root(),
            // Provide the child manifest text.
            "id=market_feed kind=AsyncWorker readiness=Explicit",
            // Provide the requesting actor.
            "operator",
            // Provide the audit reason.
            "attach market feed during incident rehearsal",
            // Finish the add child arguments.
        )
        // Wait for the add child command result.
        .await?;
    // Print the add child result.
    print_result("add_child", add);

    // Print the pause child result.
    print_result(
        // Label the pause result.
        "pause_child",
        // Send the pause child command.
        handle
            // Pause automatic governance.
            .pause_child(child_id.clone(), "operator", "stop automatic restart")
            // Wait for the pause result.
            .await?,
        // Finish the pause result print call.
    );
    // Print the resume child result.
    print_result(
        // Label the resume result.
        "resume_child",
        // Send the resume child command.
        handle
            // Resume lifecycle governance.
            .resume_child(child_id.clone(), "operator", "resume lifecycle governance")
            // Wait for the resume result.
            .await?,
        // Finish the resume result print call.
    );
    // Print the quarantine child result.
    print_result(
        // Label the quarantine result.
        "quarantine_child",
        // Send the quarantine child command.
        handle
            // Quarantine the child for manual investigation.
            .quarantine_child(child_id, "operator", "manual investigation")
            // Wait for the quarantine result.
            .await?,
        // Finish the quarantine result print call.
    );
    // Print the current state result.
    print_result("current_state", handle.current_state().await?);

    // Drain already available runtime events.
    while let Ok(event) = events.try_recv() {
        // Print one runtime event.
        println!("event={event}");
        // Finish the event drain loop.
    }

    // Print the shutdown result.
    print_result(
        // Label the shutdown result.
        "shutdown_tree",
        // Send the shutdown command.
        handle
            // Request tree shutdown.
            .shutdown_tree("operator", "runtime control story complete")
            // Wait for the shutdown result.
            .await?,
        // Finish the shutdown result print call.
    );

    // Finish the example successfully.
    Ok(())
    // End the runtime control example.
}

Trait Implementations

impl Clone for ConfigState

fn clone(&self) -> ConfigState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConfigState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConfigState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ConfigState

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<SupervisorConfig> for ConfigState

fn try_from(config: SupervisorConfig) -> Result<Self, Self::Error>

Converts a deserialized supervisor config into validated state.

type Error = SupervisorError

The type returned in the event of a conversion error.

impl StructuralPartialEq for ConfigState