Struct SupervisorBuilder

pub struct SupervisorBuilder { /* private fields */ }

Builds a Supervisor instance with configurable parameters.

Allows customization of task timeout, heartbeat interval, health check timing, and per-task restart settings.

Implementations

impl SupervisorBuilder

pub fn new() -> Self

Creates a new builder with default configuration values.

pub fn with_task(self, name: &str, task: impl CloneableSupervisedTask) -> Self

Adds a task to the supervisor with the specified name.

pub fn with_health_check_interval(self, interval: Duration) -> Self

Sets the interval between health checks.

pub fn with_max_restart_attempts(self, attempts: u32) -> Self

Sets the maximum number of restart attempts for tasks.

pub fn with_base_restart_delay(self, delay: Duration) -> Self

Sets the base delay for task restarts, used in exponential backoff.

pub fn with_task_being_stable_after(self, delay: Duration) -> Self

Sets the delay after which a task is considered stable and healthy. When a task is considered stable, its restarts are reset to zero.

pub fn with_dead_tasks_threshold( self, threshold_percentage: Option<f64>, ) -> Self

Sets the threshold for the percentage of dead tasks that will trigger a supervisor shutdown.

The threshold_percentage should be a value between 0.0 (0%) and 1.0 (100%). If the percentage of dead tasks exceeds this value, the supervisor will shut down and return an error.

pub fn build(self) -> Supervisor

Constructs the Supervisor with the configured settings.

Examples found in repository

examples/simple.rs (line 27)

async fn main() -> Result<(), Box<dyn Error>> {
    // Build the supervisor with no initial tasks
    let supervisor = SupervisorBuilder::default().build();

    // Run the supervisor and get the handle
    let handle = supervisor.run();

    // Clone the handle for use in a separate task
    let h = handle.clone();

    // Spawn a task to manage and monitor the supervisor
    tokio::spawn(async move {
        // Add a new task after 5 seconds
        tokio::time::sleep(Duration::from_secs(5)).await;
        println!("Adding a task after 5 seconds...");
        h.add_task("task1", MyTask { emoji: '🆕' })
            .expect("Failed to add task");

        // Check the status of the task after 2 seconds
        tokio::time::sleep(Duration::from_secs(2)).await;
        match h.get_task_status("task1").await {
            Ok(Some(status)) => println!("Task 'task1' status: {status:?}"),
            Ok(None) => println!("Task 'task1' not found"),
            Err(e) => println!("Error getting task status: {e}"),
        }

        // Restart the task after 5 seconds
        tokio::time::sleep(Duration::from_secs(5)).await;
        println!("Restarting task after 5 seconds...");
        h.restart("task1").expect("Failed to restart task");

        // Check all task statuses after 2 seconds
        tokio::time::sleep(Duration::from_secs(2)).await;
        match h.get_all_task_statuses().await {
            Ok(statuses) => {
                println!("All task statuses:");
                for (name, status) in statuses {
                    println!("  {name}: {status:?}");
                }
            }
            Err(e) => println!("Error getting all task statuses: {}", e),
        }

        // Kill the task after 5 seconds
        tokio::time::sleep(Duration::from_secs(5)).await;
        println!("Killing task after 5 seconds...");
        h.kill_task("task1").expect("Failed to kill task");

        // Check the status again after killing
        tokio::time::sleep(Duration::from_secs(2)).await;
        match h.get_task_status("task1").await {
            Ok(Some(status)) => println!("Task 'task1' status after kill: {:?}", status),
            Ok(None) => println!("Task 'task1' not found after kill"),
            Err(e) => println!("Error getting task status after kill: {}", e),
        }

        // Shutdown the supervisor after 5 seconds
        tokio::time::sleep(Duration::from_secs(5)).await;
        println!("Shutting down supervisor...");
        h.shutdown().expect("Failed to shutdown supervisor");
    });

    // Wait for the supervisor to complete
    handle.wait().await?;
    println!("All tasks died and supervisor shut down! 🫡");

    Ok(())
}

Trait Implementations

impl Default for SupervisorBuilder

fn default() -> Self

Returns the “default value” for a type.