Struct Scheduler 

pub struct Scheduler { /* private fields */ }

A set of scheduled events, and the loop that runs them.

Implementations

impl Scheduler

pub fn new(queue: Arc<dyn Queue>) -> Self

pub fn job<J: Job>(&mut self, job: J) -> &mut ScheduledEvent

Schedule a job. It is dispatched onto the queue when due, not run here: the scheduler’s tick must stay short, and a worker is what runs work.

The payload is taken now, when the schedule is defined, so a job that needs fresh data at run time should read it in handle rather than capture it in a field.

pub fn push(&mut self, job: QueuedJob) -> &mut ScheduledEvent

Schedule an already-built envelope — a job with no Rust type behind it.

pub fn call<F>( &mut self, name: impl Into<String>, task: F, ) -> &mut ScheduledEvent

where F: Fn() -> BoxFuture<'static, Result<()>> + Send + Sync + 'static,

Schedule a closure to run in this process. For work with no job behind it: pruning a cache, touching a heartbeat file.

pub fn events(&self) -> &[ScheduledEvent]

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

Check every expression without running anything.

pub fn due_at(&self, at: i64) -> Result<Vec<String>>

The events due at a given moment, by name. For tests and schedule:list.

pub fn next_runs_after(&self, at: i64) -> Result<Vec<(String, Option<i64>)>>

When each event next runs after at, for schedule:list.

pub async fn tick(&self, at: i64) -> Result<TickReport>

Run everything due at at, and return without waiting for it.

Each due event is spawned rather than awaited: a scheduler that waited would be late for everything behind a slow task, which is the very thing without_overlapping exists to survive.

pub async fn run(&self, shutdown: Shutdown) -> Result<()>

Run the schedule until shutdown, waking on each minute boundary.

Aligning to the boundary rather than sleeping a fixed minute is what keeps a schedule from drifting: every tick is asked about a whole minute, so an expression matches exactly once however long a tick took.