Struct ChildSpec 

pub struct ChildSpec {
    pub id: ChildId,
    pub name: String,
    pub kind: TaskKind,
    pub factory: Option<Arc<dyn TaskFactory>>,
    pub restart_policy: RestartPolicy,
    pub shutdown_policy: ShutdownPolicy,
    pub health_policy: HealthPolicy,
    pub readiness_policy: ReadinessPolicy,
    pub backoff_policy: BackoffPolicy,
    pub dependencies: Vec<ChildId>,
    pub tags: Vec<String>,
    pub criticality: Criticality,
}

Declarative specification for a child task or nested supervisor.

Fields

id: ChildId

Stable child identifier.

name: String

Human-readable child name.

kind: TaskKind

Child task kind.

factory: Option<Arc<dyn TaskFactory>>

Optional factory for worker children.

restart_policy: RestartPolicy

Restart policy for this child.

shutdown_policy: ShutdownPolicy

Shutdown policy for this child.

health_policy: HealthPolicy

Health policy for this child.

readiness_policy: ReadinessPolicy

Readiness policy for this child.

backoff_policy: BackoffPolicy

Backoff policy for this child.

dependencies: Vec<ChildId>

Child identifiers that must become ready before this child starts.

tags: Vec<String>

Low-cardinality tags used for grouping and diagnostics.

criticality: Criticality

Criticality used by parent policy decisions.

Implementations

impl ChildSpec

pub fn worker( id: ChildId, name: impl Into<String>, kind: TaskKind, factory: Arc<dyn TaskFactory>, ) -> Self

Creates a worker child specification.

Arguments

• id: Stable child identifier.
• name: Human-readable child name.
• kind: Worker task kind.
• factory: Task factory used to build each attempt.

Returns

Returns a ChildSpec with conservative policy values.

Examples

let factory = rust_supervisor::task::factory::service_fn(|_ctx| async {
    rust_supervisor::task::factory::TaskResult::Succeeded
});
let spec = rust_supervisor::spec::child::ChildSpec::worker(
    rust_supervisor::id::types::ChildId::new("worker"),
    "worker",
    rust_supervisor::spec::child::TaskKind::AsyncWorker,
    std::sync::Arc::new(factory),
);
assert_eq!(spec.name, "worker");

Examples found in repository

examples/supervisor_tree_story.rs (lines 101-111)

fn worker(id: &str, name: &str) -> ChildSpec {
    // Capture the task name for the async task.
    let task_name = name.to_owned();
    // Create a task factory from a closure.
    let factory = service_fn(move |ctx| {
        // Clone the captured task name for this attempt.
        let task_name = task_name.clone();
        // Return the async task body.
        async move {
            // Emit a heartbeat from the task context.
            ctx.heartbeat();
            // Mark the task as ready.
            ctx.mark_ready();
            // Print the task path for learners.
            println!("worker={task_name} path={}", ctx.path);
            // Report a successful task result.
            TaskResult::Succeeded
            // Finish the async task body.
        }
        // Finish the task factory closure.
    });

    // Create the worker child specification.
    ChildSpec::worker(
        // Set the child identifier.
        ChildId::new(id),
        // Set the child name.
        name,
        // Set the task kind.
        TaskKind::AsyncWorker,
        // Store the task factory behind shared ownership.
        Arc::new(factory),
        // Finish the worker child specification.
    )
    // Finish the worker builder.
}

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

Validates local child specification invariants.

Arguments

This function has no arguments.

Returns

Returns Ok(()) when the child can be registered.

Trait Implementations

impl Clone for ChildSpec

fn clone(&self) -> ChildSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChildSpec

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

Formats the child specification without printing the task factory.