Struct ConfigState 

pub struct ConfigState {

    pub supervisor: SupervisorRootConfig,
    pub policy: PolicyConfig,
    pub shutdown: ShutdownConfig,
    pub observability: ObservabilityConfig,
    pub audit: AuditConfig,
    pub backpressure: BackpressureConfig,
    pub groups: Vec<GroupConfig>,
    pub group_strategies: Vec<GroupStrategyConfig>,
    pub group_dependencies: Vec<GroupDependencyConfig>,
    pub child_strategy_overrides: Vec<ChildStrategyOverrideConfig>,
    pub severity_defaults: Vec<SeverityDefaultConfig>,
    pub dashboard: Option<DashboardIpcConfig>,
    pub children: Vec<ChildSpec>,
    pub spec_hash: String,
    pub pending_additions: Vec<PendingChild>,
    pub compensating_records: Vec<CompensatingRecord>,
}

Supervisor configuration state with add_child transaction support.

Fields

supervisor: SupervisorRootConfig

Root supervisor declaration values.

policy: PolicyConfig

Runtime policy values.

shutdown: ShutdownConfig

Shutdown budget values.

observability: ObservabilityConfig

Observability switches and capacities.

audit: AuditConfig

Command audit persistence configuration.

backpressure: BackpressureConfig

Backpressure policy for observability event subscribers.

groups: Vec<GroupConfig>

Group-level restart budgets and membership declarations.

group_strategies: Vec<GroupStrategyConfig>

Group-level strategy overrides.

group_dependencies: Vec<GroupDependencyConfig>

Cross-group failure propagation dependencies.

child_strategy_overrides: Vec<ChildStrategyOverrideConfig>

Child-level strategy overrides.

severity_defaults: Vec<SeverityDefaultConfig>

Default severity class per task role.

dashboard: Option<DashboardIpcConfig>

Optional target-side dashboard IPC configuration.

children: Vec<ChildSpec>

Validated child specifications loaded from YAML declarations.

spec_hash: String

SHA-256 hash of the SupervisorSpec for audit reconciliation.

pending_additions: Vec<PendingChild>

Pending add_child transactions.

compensating_records: Vec<CompensatingRecord>

Compensating records for recovery.

Implementations

impl ConfigState

pub fn begin_transaction( &mut self, declaration: ChildDeclaration, ) -> Result<Uuid, 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

Begins an add_child transaction by creating a PendingChild entry.

Arguments

• declaration: The child declaration to stage.

Returns

Returns the generated transaction UUID on success.

Errors

Returns an error if a transaction is already in progress.

pub fn commit_transaction( &mut self, transaction_id: Uuid, ) -> Result<(), SupervisorError>

Commits an add_child transaction, registering the child in the topology.

Arguments

• transaction_id: The transaction UUID to commit.

pub fn rollback_transaction( &mut self, transaction_id: Uuid, error: String, ) -> Result<(), SupervisorError>

Rolls back an add_child transaction, creating a compensating record.

Arguments

• transaction_id: The transaction UUID to roll back.
• error: Human-readable error description.

pub fn has_pending_transaction(&self) -> bool

Returns true when a pending transaction exists.

pub fn hash(&self) -> &str

Returns the current spec hash for audit reconciliation.

pub fn recover_pending_transactions(&mut self)

Recovers pending transactions after a restart.

Iterates compensating records and reconciles them against the current spec state. Records with state “pending” that have a matching declaration hash are marked as committed.

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

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);

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

Manual partial equality — skips children because ChildSpec contains Arc<dyn TaskFactory> which does not implement PartialEq.

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

Compares two ConfigState values, skipping the children vector.

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.