Struct SupervisorTree 

pub struct SupervisorTree {
    pub root_path: SupervisorPath,
    pub nodes: Vec<SupervisorTreeNode>,
}

Built supervisor tree with stable declaration order.

Fields

root_path: SupervisorPath

Root supervisor path.

nodes: Vec<SupervisorTreeNode>

Nodes in declaration order.

Implementations

impl SupervisorTree

pub fn build(spec: &SupervisorSpec) -> Result<Self, SupervisorError>

Builds a tree from a supervisor specification.

Arguments

• spec: Supervisor declaration to index.

Returns

Returns a SupervisorTree when child identifiers and paths are valid.

Examples

let spec = rust_supervisor::spec::supervisor::SupervisorSpec::root(Vec::new());
let tree = rust_supervisor::tree::builder::SupervisorTree::build(&spec).unwrap();
assert!(tree.nodes.is_empty());

Examples found in repository

examples/supervisor_tree_story.rs (line 55)

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 child_path(&self, child_id: &ChildId) -> Option<SupervisorPath>

Returns the path for a child identifier.

Arguments

• child_id: Child identifier to locate.

Returns

Returns the child path when the child exists.

pub fn nested_supervisors(&self) -> Vec<&SupervisorTreeNode>

Returns supervisor nodes declared as nested supervisors.

Arguments

This function has no arguments.

Returns

Returns nested supervisor nodes in declaration order.

Trait Implementations

impl Clone for SupervisorTree

fn clone(&self) -> SupervisorTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SupervisorTree

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

Formats the value using the given formatter.