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::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

CoordinatedLeaseConfig

CoordinatedPendingTrigger

CoordinatedRuntimeState

CronSchedule

ExecutionGuardError

ExecutionLease

ExecutionSlot

GuardedRunner

InMemoryStateStore

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.

RunContext

RunRecord

Scheduler

SchedulerConfig

SchedulerHandle

SchedulerReport

StoreError

Task

TaskContext

TaskJoinError

TimeWindowSegment

ValkeyCoordinatedStateStore

ValkeyExecutionGuard

ValkeyLeaseConfig

ValkeyStateStore

Enums

ExecutionGuardAcquire

ExecutionGuardErrorKind

ExecutionGuardRenewal

ExecutionGuardScope

GuardedRunResult

InvalidJobKind

MissedRunPolicy

OverlapPolicy

PauseScope

RunSkipReason

RunStatus

Schedule

SchedulerError

SchedulerEvent

SchedulerStopReason

StateLoadSource

StoreErrorKind

StoreEvent

StoreOperation

TaskJoinErrorKind

TerminalStatePolicy

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.