use std::collections::HashMap;
use std::time::Duration;
use chrono::{DateTime, Utc};
use cron::Schedule;
use tracing::{debug, info, warn};
use crate::backend::Backend;
use crate::error::Result;
use crate::job::Perform;
use crate::queue::Queue;
struct CronEntry {
kind: &'static str,
queue: &'static str,
schedule: Schedule,
next_fire: DateTime<Utc>,
enqueue_fn: Box<dyn Fn() -> Vec<u8> + Send + Sync>,
max_attempts: u32,
}
impl CronEntry {
fn advance(&mut self) {
if let Some(next) = self.schedule.upcoming(Utc).next() {
self.next_fire = next;
}
}
}
pub struct Scheduler<B: Backend> {
queue: Queue<B>,
entries: Vec<CronEntry>,
poll_interval: Duration,
}
impl<B: Backend> Scheduler<B> {
pub fn new(queue: Queue<B>) -> Self {
Self {
queue,
entries: Vec::new(),
poll_interval: Duration::from_secs(1),
}
}
pub fn register<J: Perform + Default>(mut self, cron_expr: &str) -> Self {
let schedule: Schedule = cron_expr
.parse()
.unwrap_or_else(|e| panic!("invalid cron expression '{cron_expr}': {e}"));
let next_fire = schedule
.upcoming(Utc)
.next()
.expect("cron schedule has no upcoming fires");
let entry = CronEntry {
kind: J::KIND,
queue: J::QUEUE,
schedule,
next_fire,
enqueue_fn: Box::new(|| {
serde_json::to_vec(&J::default()).expect("job serialization failed")
}),
max_attempts: J::MAX_RETRIES,
};
info!(
kind = J::KIND,
queue = J::QUEUE,
cron = cron_expr,
next_fire = %next_fire,
"registered cron job"
);
self.entries.push(entry);
self
}
pub fn register_with<J, F>(mut self, cron_expr: &str, payload_fn: F) -> Self
where
J: Perform,
F: Fn() -> J + Send + Sync + 'static,
{
let schedule: Schedule = cron_expr
.parse()
.unwrap_or_else(|e| panic!("invalid cron expression '{cron_expr}': {e}"));
let next_fire = schedule
.upcoming(Utc)
.next()
.expect("cron schedule has no upcoming fires");
let entry = CronEntry {
kind: J::KIND,
queue: J::QUEUE,
schedule,
next_fire,
enqueue_fn: Box::new(move || {
serde_json::to_vec(&payload_fn()).expect("job serialization failed")
}),
max_attempts: J::MAX_RETRIES,
};
info!(
kind = J::KIND,
queue = J::QUEUE,
cron = cron_expr,
next_fire = %next_fire,
"registered cron job with custom payload"
);
self.entries.push(entry);
self
}
pub fn poll_interval(mut self, interval: Duration) -> Self {
self.poll_interval = interval;
self
}
pub async fn run(mut self) -> ! {
info!(
jobs = self.entries.len(),
poll_interval_ms = self.poll_interval.as_millis(),
"scheduler started"
);
loop {
let now = Utc::now();
for entry in &mut self.entries {
if entry.next_fire <= now {
let payload = (entry.enqueue_fn)();
let record = crate::job::JobRecord::new(
entry.kind,
entry.queue,
payload,
entry.max_attempts,
);
match self.queue.enqueue_record(record).await {
Ok(id) => {
info!(
kind = entry.kind,
job_id = %id,
"cron job enqueued"
);
}
Err(e) => {
warn!(
kind = entry.kind,
error = %e,
"failed to enqueue cron job"
);
}
}
entry.advance();
debug!(
kind = entry.kind,
next_fire = %entry.next_fire,
"next fire scheduled"
);
}
}
tokio::time::sleep(self.poll_interval).await;
}
}
pub async fn run_once(&mut self) -> Result<usize> {
let now = Utc::now();
let mut fired = 0;
for entry in &mut self.entries {
if entry.next_fire <= now {
let payload = (entry.enqueue_fn)();
let record = crate::job::JobRecord::new(
entry.kind,
entry.queue,
payload,
entry.max_attempts,
);
self.queue.enqueue_record(record).await?;
entry.advance();
fired += 1;
}
}
Ok(fired)
}
pub fn status(&self) -> HashMap<&'static str, DateTime<Utc>> {
self.entries
.iter()
.map(|e| (e.kind, e.next_fire))
.collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::backends::InMemoryBackend;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct TestCronJob;
impl crate::job::Job for TestCronJob {
const KIND: &'static str = "TestCronJob";
const QUEUE: &'static str = "test";
const MAX_RETRIES: u32 = 3;
const TIMEOUT_SECS: Option<u64> = None;
}
impl Perform for TestCronJob {
async fn perform(self, _ctx: crate::JobContext) -> crate::JobResult {
Ok(())
}
}
#[tokio::test]
async fn scheduler_registers_job() {
let backend = InMemoryBackend::new();
let queue = Queue::new(backend);
let scheduler = Scheduler::new(queue).register::<TestCronJob>("0 * * * * *");
assert_eq!(scheduler.entries.len(), 1);
assert_eq!(scheduler.entries[0].kind, "TestCronJob");
}
#[tokio::test]
async fn scheduler_fires_due_job() {
let backend = InMemoryBackend::new();
let queue = Queue::new(backend.clone());
let mut scheduler = Scheduler::new(queue).register::<TestCronJob>("* * * * * *");
scheduler.entries[0].next_fire = Utc::now() - chrono::Duration::seconds(1);
let fired = scheduler.run_once().await.unwrap();
assert_eq!(fired, 1);
let stats = backend.stats("test").await.unwrap();
assert_eq!(stats.pending, 1);
}
#[tokio::test]
async fn scheduler_does_not_fire_future_job() {
let backend = InMemoryBackend::new();
let queue = Queue::new(backend.clone());
let mut scheduler = Scheduler::new(queue).register::<TestCronJob>("0 0 0 1 1 *");
let fired = scheduler.run_once().await.unwrap();
assert_eq!(fired, 0);
let stats = backend.stats("test").await.unwrap();
assert_eq!(stats.pending, 0);
}
}