Struct Supervisor 

pub struct Supervisor { /* private fields */ }

Manages the lifecycle of multiple async workers with coordinated, ordered shutdown.

Supervisor runs all registered processes concurrently and handles graceful shutdown when receiving SIGTERM or Ctrl+C. Tasks are shutdown in reverse order of their initial registration (LIFO), allowing dependent tasks to stop their dependencies. This mimics the Patterns of process management hierarchy and dependency familiar in the OTP Erlang runtime.

Example

use super_visor::Supervisor;

// Using the builder pattern
Supervisor::builder()
    .add_proc(server)
    .add_proc(worker)
    .build()
    .start()
    .await?;

// Or using direct construction
let mut supervisor = Supervisor::new();
supervisor.add(server);
supervisor.add(worker);
supervisor.start().await?;

Implementations

impl Supervisor

pub fn new() -> Self

Creates a new empty supervisor.

pub fn builder() -> SupervisorBuilder

Creates a new SupervisorBuilder for fluent task registration.

pub fn add(&mut self, proc: impl ManagedProc + 'static)

Adds a task to the supervisor

Tasks are started in the order they are added and shutdown in the reverse order.

pub async fn start(self) -> ProcResult

Starts all registered processes and waits for completion or shutdown.

This method:

1. Starts all processes concurrently
2. Listens for SIGTERM or Ctrl+C signals
3. On signal or error, shuts down all running processes in reverse order (LIFO)
4. Returns the first error encountered or Ok(()) if all tasks complete successfully

Trait Implementations

impl Default for Supervisor

fn default() -> Self

Returns the “default value” for a type.

impl ManagedProc for Supervisor

fn run_proc(self: Box<Self>, shutdown: ShutdownSignal) -> ManagedFuture

Starts the process and returns a future that completes when the work is complete or runs indefinitely in a continual loop.