Struct SupervisorSpec 

pub struct SupervisorSpec {

    pub path: SupervisorPath,
    pub strategy: SupervisionStrategy,
    pub children: Vec<ChildSpec>,
    pub config_version: String,
    pub default_restart_policy: RestartPolicy,
    pub default_backoff_policy: BackoffPolicy,
    pub default_health_policy: HealthPolicy,
    pub default_shutdown_policy: ShutdownPolicy,
    pub supervisor_failure_limit: u32,
    pub restart_budget: Option<RestartBudget>,
    pub escalation_policy: Option<EscalationPolicy>,
    pub group_strategies: Vec<GroupStrategy>,
    pub child_strategy_overrides: Vec<ChildStrategyOverride>,
    pub dynamic_supervisor_policy: DynamicSupervisorPolicy,
    pub control_channel_capacity: usize,
    pub event_channel_capacity: usize,
}

Declarative specification for one supervisor node.

Fields

path: SupervisorPath

Stable path for this supervisor.

strategy: SupervisionStrategy

Restart scope strategy for child exits.

children: Vec<ChildSpec>

Children in declaration order.

config_version: String

Configuration version that produced this declaration.

default_restart_policy: RestartPolicy

Restart policy inherited by children that do not override it.

default_backoff_policy: BackoffPolicy

Backoff policy inherited by children that do not override it.

default_health_policy: HealthPolicy

Health policy inherited by children that do not override it.

default_shutdown_policy: ShutdownPolicy

Shutdown policy inherited by children that do not override it.

supervisor_failure_limit: u32

Maximum supervisor failures before parent escalation.

restart_budget: Option<RestartBudget>

Optional supervisor-level restart budget.

escalation_policy: Option<EscalationPolicy>

Optional supervisor-level escalation policy.

group_strategies: Vec<GroupStrategy>

Group-level strategy overrides.

child_strategy_overrides: Vec<ChildStrategyOverride>

Child-level strategy overrides.

dynamic_supervisor_policy: DynamicSupervisorPolicy

Runtime policy for dynamic child additions.

control_channel_capacity: usize

Control command channel capacity.

event_channel_capacity: usize

Event broadcast channel capacity.

Implementations

impl SupervisorSpec

pub fn root(children: Vec<ChildSpec>) -> Self

Creates a root supervisor specification.

Arguments

• children: Children declared under the root supervisor.

Returns

Returns a root SupervisorSpec with declaration-order children.

Examples

let spec = rust_supervisor::spec::supervisor::SupervisorSpec::root(Vec::new());
assert_eq!(spec.path.to_string(), "/");

Examples found in repository

examples/supervisor_tree_story.rs (line 48)

fn main() -> ExampleResult {
    // Build the market feed child.
    let mut market_feed = worker("market_feed", "Market Feed");
    // Add low-cardinality market feed tags.
    market_feed.tags = vec!["market".to_owned(), "network".to_owned()];
    // Require explicit readiness for the market feed.
    market_feed.readiness_policy = ReadinessPolicy::Explicit;

    // Build the risk engine child.
    let mut risk_engine = worker("risk_engine", "Risk Engine");
    // Make the risk engine depend on the market feed.
    risk_engine.dependencies = vec![market_feed.id.clone()];
    // Add low-cardinality risk engine tags.
    risk_engine.tags = vec!["risk".to_owned()];

    // Build the audit sink child.
    let mut audit_sink = worker("audit_sink", "Audit Sink");
    // Mark the audit sink as optional.
    audit_sink.criticality = Criticality::Optional;
    // Add low-cardinality audit tags.
    audit_sink.tags = vec!["audit".to_owned()];

    // Build the root supervisor specification.
    let mut spec = SupervisorSpec::root(vec![market_feed.clone(), risk_engine, audit_sink]);
    // Select the RestForOne restart strategy.
    spec.strategy = SupervisionStrategy::RestForOne;
    // Set an example configuration version.
    spec.config_version = "examples-supervisor-tree-story".to_owned();

    // Build the indexed supervisor tree.
    let tree = SupervisorTree::build(&spec)?;
    // Print the root supervisor path.
    println!("root_path={}", tree.root_path);
    // Print startup order by child name.
    println!("startup_order={:?}", child_names(startup_order(&tree)));
    // Print shutdown order by child name.
    println!("shutdown_order={:?}", child_names(shutdown_order(&tree)));
    // Print the restart scope after market feed failure.
    println!(
        // Provide the output template.
        "restart_scope_after_market_feed={:?}",
        // Calculate the restart scope.
        restart_scope(&tree, spec.strategy, &market_feed.id),
        // Finish printing the restart scope.
    );

    // Finish the example successfully.
    Ok(())
    // End the supervisor tree example.
}

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

Validates this supervisor and its direct children.

Arguments

This function has no arguments.

Returns

Returns Ok(()) when the supervisor declaration is usable.

Trait Implementations

impl Clone for SupervisorSpec

fn clone(&self) -> SupervisorSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SupervisorSpec

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

Formats the value using the given formatter.