Crate scheduler 

Async scheduling for a single logical job at a time.

The scheduler decides when to trigger work and persists the resulting job state through a StateStore. Domain-specific retry, idempotency, and cursor management remain in the caller.

Key semantics:

• Schedule::AtTimes waits until each planned timestamp and treats an empty list as a no-op schedule.
• Schedule::Interval schedules the first run at now + interval.
• Schedule::StaggeredInterval spreads interval jobs by a stable phase derived from the job id or an explicit seed.
• Schedule::GroupedInterval spreads known group members evenly across each interval.
• Schedule::GroupedCron spreads known group members evenly inside a stable post-cron window for each cron anchor.
• Schedule::WindowedInterval selects an interval by local time windows; None intervals disable triggers for the matching period.
• Schedule::Cron evaluates a standard 5-field cron expression in SchedulerConfig::timezone.
• JobTimeWindow can restrict execution by local weekday and time segments; outside-window occurrences are skipped with RunSkipReason::OutsideTimeWindow.
• Job::with_max_runs applies to every schedule kind; 0 exits without running.
• SchedulerConfig::timezone is forwarded through RunContext, drives Schedule::Cron evaluation, and does not rewrite absolute Schedule::AtTimes values.
• Restarts resume by job_id from the saved JobState::next_run_at.
• SchedulerHandle::pause pauses future scheduling without interrupting the current run. SchedulerHandle::resume recomputes immediately and applies the existing missed-run policy.
• Pause scope is backend-specific: legacy schedulers pause locally, while coordinated schedulers persist a shared pause state per job_id.
• Dependency injection here means passing an explicit deps value when the job is constructed. The scheduler does not auto-resolve parameters.

use std::time::Duration;

use scheduler::{InMemoryStateStore, Job, Schedule, Scheduler, SchedulerConfig, Task};

let runtime = tokio::runtime::Runtime::new().unwrap();
runtime.block_on(async {
    let scheduler = Scheduler::new(SchedulerConfig::default(), InMemoryStateStore::new());
    let job = Job::without_deps(
        "doc-simple",
        Schedule::Interval(Duration::from_millis(1)),
        Task::from_async(|_| async { Ok(()) }),
    )
    .with_max_runs(1);

    let report = scheduler.run(job).await.unwrap();
    assert_eq!(report.history.len(), 1);
});

Structs

CoordinatedClaim

CoordinatedCompletion

CoordinatedLeaseConfig

CoordinatedPendingTrigger

CoordinatedRuntimeState

CronSchedule

ExecutionGuardError

ExecutionLease

ExecutionSlot

GroupedCronSchedule

Cron schedule that spreads members evenly inside a post-anchor window.

GroupedIntervalSchedule

Interval schedule that spreads members evenly across the interval.

GuardedRunner

InMemoryStateStore

IntervalWindow

Interval override for a matching time window.

InvalidJobError

Job

JobState

JobTimeWindow

LogObserver

NoopCoordinatedStateStore

NoopExecutionGuard

NoopObserver

ResilientStateStore

Wraps a primary store with an in-process mirror that takes over after connection-class failures and opportunistically writes dirty state back once the primary accepts commands again.

RunContext

RunRecord

Scheduler

SchedulerConfig

SchedulerHandle

SchedulerReport

StaggeredIntervalSchedule

Interval schedule with a stable phase derived from a seed.

StoreError

Task

TaskContext

TaskJoinError

TimeWindowSegment

TriggeredTaskContext

ValkeyCoordinatedStateStore

ValkeyExecutionGuard

ValkeyLeaseConfig

ValkeyRecoveryConfig

ValkeyStateStore

WindowedIntervalSchedule

Interval schedule with per-window frequencies.

Enums

ExecutionGuardAcquire

ExecutionGuardErrorKind

ExecutionGuardEvent

ExecutionGuardRenewal

ExecutionGuardScope

GuardedRunResult

InvalidJobKind

MissedRunPolicy

OverlapPolicy

PauseScope

RunSkipReason

RunStatus

Schedule

SchedulerError

SchedulerEvent

SchedulerStopReason

StateLoadSource

StoreErrorKind

StoreEvent

StoreOperation

TaskJoinErrorKind

TerminalStatePolicy

TimeWindowAlignment

TriggerSource

Traits

CoordinatedStateStore

ExecutionGuard

ResilientStoreError

Classifies store errors that should trigger a one-way downgrade to the in-process mirror store.

SchedulerObserver

StateStore

Type Aliases

JobFuture

The boxed future returned by a scheduled job.

JobResult

The task return type used by scheduled jobs.