Struct Supervisor 

pub struct Supervisor { /* private fields */ }

Runs an app’s long-lived tasks and owns their shutdown.

Spawn the server, job workers and cron through it, handing each one Supervisor::shutdown_token, then await Supervisor::run. It returns when the process should exit:

1. SIGTERM or SIGINT arrives (handlers are registered in Supervisor::new, so a signal during startup is not lost), or any task exits on its own.
2. The token is cancelled: workers stop claiming jobs, in-flight jobs get ShutdownBudget::job_drain to finish, and whatever is left is dropped with its lock released so another instance re-runs it at once instead of after the lock timeout.
3. Tasks still running at ShutdownBudget::deadline are aborted. With websockets or other long-lived connections that is routine, since they hold axum’s graceful shutdown open indefinitely.

A signal is a clean exit. A task exiting by itself is an error, because every task is meant to run for the life of the process; its peers are still drained first.

let mut supervisor = cja::tasks::Supervisor::new(ShutdownBudget::from_env())?;
let shutdown = supervisor.shutdown_token();

supervisor.spawn(
    "server",
    cja::server::run_server_until(routes(app_state.clone()), shutdown.clone().cancelled_owned()),
);
supervisor.spawn(
    "jobs",
    cja::jobs::worker::job_worker(
        app_state.clone(),
        Jobs,
        Duration::from_secs(60),
        cja::jobs::DEFAULT_MAX_RETRIES,
        shutdown.clone(),
        Default::default(),
    ),
);

supervisor.run().await

Implementations

impl Supervisor

pub fn new(budget: ShutdownBudget) -> Result<Self>

Register the signal handlers and create the shared shutdown token. Must be called from within a tokio runtime.

Errors

Fails if a signal handler cannot be registered.

pub fn shutdown_token(&self) -> CancellationToken

The token every supervised task should watch. Cancelled once, when shutdown starts.

pub fn budget(&self) -> ShutdownBudget

pub fn spawn<F>(&mut self, name: &'static str, future: F)

where F: Future<Output = Result<()>> + Send + 'static,

Spawn a named task on the tokio runtime.

pub async fn run(self) -> Result<()>

Run until a shutdown signal or a task exit, then stop everything within the budget.

Errors

Returns the failure of the task that ended the process. A signal-initiated stop is Ok, even when stragglers had to be aborted.