Struct SupervisorApi 

pub struct SupervisorApi { /* private fields */ }

Thin wrapper around taskvisor Supervisor with a runner router.

This type is responsible for:

• constructing and running the supervisor;
• selecting a concrete runner for each TaskSpec;
• mapping model-level specs into controller specs and submitting them.

Also

• CoreError error type returned by all methods.
• StateConfig configures sweep TTLs and interval (defaults are sane).
• solti_runner::RunnerRouter picks a runner for each submitted spec.

Implementations

impl SupervisorApi

pub async fn new( sup_cfg: SupervisorConfig, ctrl_cfg: ControllerConfig, subscribers: Vec<Arc<dyn Subscribe>>, router: RunnerRouter, state_cfg: StateConfig, ) -> Result<Self, CoreError>

Create a supervisor with explicit configs and start its run loop in the background.

• sup_cfg - supervisor configuration;
• ctrl_cfg - controller configuration;
• subscribers - event subscribers to attach to the supervisor;
• router - runner router solti_model::TaskKind;
• state_cfg - sweep TTLs and interval (StateConfig::default() is usually fine).

The supervisor event loop is started via Supervisor::serve() which returns a SupervisorHandle for dynamic task management.

A periodic sweep task is automatically submitted to prevent unbounded memory growth. It removes completed runs and terminal tasks that exceed their configured TTLs.

pub fn get_task(&self, id: &TaskId) -> Option<Task>

Get task information by ID.

pub fn list_tasks_by_slot(&self, slot: &str) -> Vec<Task>

List all tasks in a specific slot.

pub fn list_all_tasks(&self) -> Vec<Task>

List all tasks.

pub fn list_tasks_by_status(&self, phase: TaskPhase) -> Vec<Task>

List tasks by phase.

pub fn query_tasks(&self, query: &TaskQuery) -> TaskPage<Task>

Query tasks with combined filters and pagination.

pub fn list_task_runs(&self, id: &TaskId) -> Vec<TaskRun>

List execution history for a specific task (oldest first).

pub async fn delete_task(&self, id: &TaskId) -> Result<(), CoreError>

Stop a task and purge its run history.

pub fn handle(&self) -> SupervisorHandle

Get a clone of the underlying supervisor handle.

pub async fn submit(&self, spec: &TaskSpec) -> Result<TaskId, CoreError>

Build and submit a task described by TaskSpec.

Steps:

1. Ask the RunnerRouter to pick a runner and build a TaskRef.
2. Delegate to SupervisorApi::submit_with_task.

This is the primary entrypoint for tasks that are fully described by the public solti_model::TaskKind model.

pub async fn submit_with_task( &self, task: TaskRef, spec: &TaskSpec, ) -> Result<TaskId, CoreError>

Submit a pre-built task together with its spec.

This API is intended for in-process / code-defined tasks (with TaskKind::Embedded).

The caller is responsible for constructing the TaskRef; the spec controls timeout, restart, backoff and admission behavior.

pub async fn shutdown(self) -> Result<(), CoreError>

Gracefully shut down the supervisor: cancel all tasks and wait for completion.

Consumes self - no further operations are possible after shutdown. The grace period is determined by SupervisorConfig passed to new.

Example

api.shutdown().await?;

pub async fn cancel_task(&self, id: &TaskId) -> Result<(), CoreError>

Cancel a running task by ID (in-process Rust API).