use std::sync::Arc;
use async_trait::async_trait;
use chrono::{DateTime, Utc};
use rusqlite::types::Value as SqlValue;
use wabot_feature_async::cron_job::{CronJob, CronJobData};
use wabot_feature_async::job::{Job, JobData};
use wabot_feature_async::repository::{CronJobRepository, JobRepository};
use wabot_feature_async::types::AsyncError;
use wabot_feature_sqlite::{SqliteDatabase, SqliteError, SqliteJsonbStore};
pub const JOBS_TABLE: &str = "jobs";
pub const CRON_JOBS_TABLE: &str = "cron_jobs";
macro_rules! field {
($name:literal) => {
concat!("\"data\"->>'$.\"", $name, "\"'")
};
}
pub struct SqliteJobRepository {
store: SqliteJsonbStore<JobData>,
}
impl SqliteJobRepository {
pub fn new(database: SqliteDatabase) -> Self {
Self::with_table(database, JOBS_TABLE)
}
pub fn with_table(database: SqliteDatabase, table: &str) -> Self {
let store = SqliteJsonbStore::new(database, table)
.with_index(concat!(
"CREATE INDEX IF NOT EXISTS jobs_pending_idx ON \"jobs\" (",
field!("scheduledAt"),
") WHERE ",
field!("startedAt"),
" IS NULL AND ",
field!("successAt"),
" IS NULL AND ",
field!("failedAt"),
" IS NULL"
))
.with_index(concat!(
"CREATE INDEX IF NOT EXISTS jobs_dedup_idx ON \"jobs\" (",
field!("commandName"),
", ",
field!("dedupKey"),
")"
))
.with_index(concat!(
"CREATE INDEX IF NOT EXISTS jobs_running_idx ON \"jobs\" (",
field!("commandName"),
") WHERE ",
field!("startedAt"),
" IS NOT NULL AND ",
field!("successAt"),
" IS NULL AND ",
field!("failedAt"),
" IS NULL"
));
Self { store }
}
pub fn store(&self) -> &SqliteJsonbStore<JobData> {
&self.store
}
pub async fn ensure_ready(&self) -> Result<(), AsyncError> {
self.store.ensure_ready().await.map_err(to_async_error)
}
}
#[async_trait]
impl JobRepository for SqliteJobRepository {
async fn find(&self, id: &str) -> Result<Option<Job>, AsyncError> {
self.store.find_by_id(id).await.map_err(to_async_error)
}
async fn create(&self, job: &Job) -> Result<(), AsyncError> {
self.store.save(job).await.map_err(to_async_error)
}
async fn update(&self, job: &Job) -> Result<(), AsyncError> {
self.store.save(job).await.map_err(to_async_error)
}
async fn delete(&self, job: &Job) -> Result<(), AsyncError> {
self.store.delete(job.id()).await.map_err(to_async_error)
}
async fn find_pending_for_run_from(
&self,
as_of: DateTime<Utc>,
limit: usize,
) -> Result<Vec<Job>, AsyncError> {
let sql = format!(
"SELECT \"data\" FROM {t} \
WHERE {scheduled} IS NOT NULL \
AND {scheduled} <= ?1 \
AND {started} IS NULL \
AND {success} IS NULL \
AND {failed} IS NULL \
ORDER BY {scheduled} ASC \
LIMIT ?2",
t = self.store.table(),
scheduled = field!("scheduledAt"),
started = field!("startedAt"),
success = field!("successAt"),
failed = field!("failedAt"),
);
self.store
.query(
&sql,
vec![
SqlValue::Integer(as_of.timestamp_millis()),
SqlValue::Integer(limit as i64),
],
)
.await
.map_err(to_async_error)
}
async fn find_running(&self) -> Result<Vec<Job>, AsyncError> {
let sql = format!(
"SELECT \"data\" FROM {t} \
WHERE {started} IS NOT NULL \
AND {success} IS NULL \
AND {failed} IS NULL",
t = self.store.table(),
started = field!("startedAt"),
success = field!("successAt"),
failed = field!("failedAt"),
);
self.store
.query(&sql, Vec::new())
.await
.map_err(to_async_error)
}
async fn count_running_by_command(&self, command_name: &str) -> Result<usize, AsyncError> {
let sql = format!(
"SELECT COUNT(*) FROM {t} \
WHERE {started} IS NOT NULL \
AND {success} IS NULL \
AND {failed} IS NULL \
AND {command} = ?1",
t = self.store.table(),
started = field!("startedAt"),
success = field!("successAt"),
failed = field!("failedAt"),
command = field!("commandName"),
);
let count = self
.store
.count(&sql, vec![SqlValue::Text(command_name.to_string())])
.await
.map_err(to_async_error)?;
Ok(count.max(0) as usize)
}
async fn find_active_by_dedup_key(
&self,
command_name: &str,
dedup_key: &str,
succeeded_since_ms: i64,
) -> Result<Option<Job>, AsyncError> {
let sql = format!(
"SELECT \"data\" FROM {t} \
WHERE {command} = ?1 \
AND {dedup} = ?2 \
AND {failed} IS NULL \
AND ({success} IS NULL OR {success} >= ?3) \
ORDER BY \"created_at\" DESC \
LIMIT 1",
t = self.store.table(),
command = field!("commandName"),
dedup = field!("dedupKey"),
failed = field!("failedAt"),
success = field!("successAt"),
);
self.store
.query_opt(
&sql,
vec![
SqlValue::Text(command_name.to_string()),
SqlValue::Text(dedup_key.to_string()),
SqlValue::Integer(succeeded_since_ms),
],
)
.await
.map_err(to_async_error)
}
}
impl wabot_core::injection::IsSingleton for SqliteJobRepository {
fn register_in(c: &wabot_core::injection::Container) {
c.register_singleton_factory::<SqliteJobRepository, _>(|c2| {
let database: Arc<SqliteDatabase> = c2.resolve();
Arc::new(SqliteJobRepository::new(database.as_ref().clone()))
});
}
}
pub struct SqliteCronJobRepository {
store: SqliteJsonbStore<CronJobData>,
}
impl SqliteCronJobRepository {
pub fn new(database: SqliteDatabase) -> Self {
Self::with_table(database, CRON_JOBS_TABLE)
}
pub fn with_table(database: SqliteDatabase, table: &str) -> Self {
let store = SqliteJsonbStore::new(database, table)
.with_index(concat!(
"CREATE INDEX IF NOT EXISTS cron_jobs_next_run_idx ON \"cron_jobs\" (",
field!("nextRunAt"),
")"
))
.with_index(concat!(
"CREATE UNIQUE INDEX IF NOT EXISTS cron_jobs_name_idx ON \"cron_jobs\" (",
field!("name"),
")"
));
Self { store }
}
pub fn store(&self) -> &SqliteJsonbStore<CronJobData> {
&self.store
}
pub async fn ensure_ready(&self) -> Result<(), AsyncError> {
self.store.ensure_ready().await.map_err(to_async_error)
}
}
#[async_trait]
impl CronJobRepository for SqliteCronJobRepository {
async fn find(&self, id: &str) -> Result<Option<CronJob>, AsyncError> {
self.store.find_by_id(id).await.map_err(to_async_error)
}
async fn find_by_name(&self, name: &str) -> Result<Option<CronJob>, AsyncError> {
let sql = format!(
"SELECT \"data\" FROM {t} WHERE {name} = ?1 LIMIT 1",
t = self.store.table(),
name = field!("name"),
);
self.store
.query_opt(&sql, vec![SqlValue::Text(name.to_string())])
.await
.map_err(to_async_error)
}
async fn create(&self, cron: &CronJob) -> Result<(), AsyncError> {
self.store.save(cron).await.map_err(to_async_error)
}
async fn update(&self, cron: &CronJob) -> Result<(), AsyncError> {
self.store.save(cron).await.map_err(to_async_error)
}
async fn find_due(&self, now: DateTime<Utc>) -> Result<Vec<CronJob>, AsyncError> {
let sql = format!(
"SELECT \"data\" FROM {t} \
WHERE {next} IS NOT NULL \
AND {next} <= ?1 \
AND {enabled} = 1 \
ORDER BY {next} ASC",
t = self.store.table(),
next = field!("nextRunAt"),
enabled = field!("enabled"),
);
self.store
.query(&sql, vec![SqlValue::Integer(now.timestamp_millis())])
.await
.map_err(to_async_error)
}
}
impl wabot_core::injection::IsSingleton for SqliteCronJobRepository {
fn register_in(c: &wabot_core::injection::Container) {
c.register_singleton_factory::<SqliteCronJobRepository, _>(|c2| {
let database: Arc<SqliteDatabase> = c2.resolve();
Arc::new(SqliteCronJobRepository::new(database.as_ref().clone()))
});
}
}
fn to_async_error(error: SqliteError) -> AsyncError {
AsyncError::Storage(error.to_string())
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
use wabot_core::entity::EntityData;
use wabot_feature_async::cron_job::{self, CronJobData};
use wabot_feature_async::job::new_job;
use wabot_feature_async::types::MisfirePolicy;
fn ts(ms: i64) -> DateTime<Utc> {
DateTime::<Utc>::from_timestamp_millis(ms).unwrap()
}
fn job(command: &str, scheduled_at: Option<i64>, dedup_key: Option<&str>) -> Job {
new_job(JobData {
base: EntityData::default(),
command_name: command.into(),
command_data: json!({}),
scheduled_at,
started_at: None,
success_at: None,
failed_at: None,
retry_delays_seconds: None,
intent_number: None,
error: None,
acceptable_running_time_seconds: None,
stuck_retry_attempts: None,
dedup_key: dedup_key.map(str::to_string),
actor: None,
request_id: None,
})
}
async fn jobs() -> SqliteJobRepository {
let repository = SqliteJobRepository::new(SqliteDatabase::in_memory().expect("open"));
repository.ensure_ready().await.expect("ready");
repository
}
#[tokio::test]
async fn a_job_round_trips() {
let repository = jobs().await;
let job = job("ping", Some(1_000), None);
repository.create(&job).await.expect("create");
let found = repository
.find(job.id())
.await
.expect("find")
.expect("present");
assert_eq!(found.data().command_name, "ping");
repository.delete(&job).await.expect("delete");
assert!(repository.find(job.id()).await.expect("find").is_none());
}
#[tokio::test]
async fn creating_the_same_job_twice_is_not_an_error() {
let repository = jobs().await;
let job = job("ping", Some(1), None);
repository.create(&job).await.expect("create");
repository.create(&job).await.expect("create again");
}
#[tokio::test]
async fn pending_finds_only_unstarted_jobs_that_are_due() {
let repository = jobs().await;
repository
.create(&job("due", Some(1_000), None))
.await
.unwrap();
repository
.create(&job("later", Some(9_000), None))
.await
.unwrap();
repository
.create(&job("unscheduled", None, None))
.await
.unwrap();
let mut started = job("started", Some(1_000), None);
started.update(|data| data.started_at = Some(1_500));
repository.create(&started).await.unwrap();
let mut done = job("done", Some(1_000), None);
done.update(|data| data.success_at = Some(1_500));
repository.create(&done).await.unwrap();
let pending = repository
.find_pending_for_run_from(ts(2_000), 10)
.await
.expect("pending");
assert_eq!(
pending
.iter()
.map(|j| j.data().command_name.as_str())
.collect::<Vec<_>>(),
vec!["due"]
);
}
#[tokio::test]
async fn pending_orders_numerically_not_lexicographically() {
let repository = jobs().await;
for at in [9_000, 10_000, 800] {
repository
.create(&job(&format!("j{at}"), Some(at), None))
.await
.unwrap();
}
let pending = repository
.find_pending_for_run_from(ts(20_000), 2)
.await
.expect("pending");
assert_eq!(
pending
.iter()
.map(|j| j.data().scheduled_at.unwrap())
.collect::<Vec<_>>(),
vec![800, 9_000],
"lexicographic ordering would have put 10000 before 800 and 9000"
);
}
#[tokio::test]
async fn running_jobs_are_counted_per_command() {
let repository = jobs().await;
for command in ["build", "build", "deploy"] {
let mut running = job(command, Some(1), None);
running.update(|data| data.started_at = Some(2));
repository.create(&running).await.unwrap();
}
let mut finished = job("build", Some(1), None);
finished.update(|data| {
data.started_at = Some(2);
data.success_at = Some(3);
});
repository.create(&finished).await.unwrap();
assert_eq!(repository.find_running().await.unwrap().len(), 3);
assert_eq!(
repository.count_running_by_command("build").await.unwrap(),
2
);
assert_eq!(
repository.count_running_by_command("absent").await.unwrap(),
0
);
}
#[tokio::test]
async fn dedup_finds_an_active_job_and_respects_the_success_window() {
let repository = jobs().await;
repository
.create(&job("send", Some(1), Some("key-1")))
.await
.unwrap();
assert!(repository
.find_active_by_dedup_key("send", "key-1", 0)
.await
.unwrap()
.is_some());
assert!(
repository
.find_active_by_dedup_key("send", "other", 0)
.await
.unwrap()
.is_none(),
"a different key is a different job"
);
let mut old = job("send", Some(1), Some("key-2"));
old.update(|data| data.success_at = Some(1_000));
repository.create(&old).await.unwrap();
assert!(repository
.find_active_by_dedup_key("send", "key-2", 5_000)
.await
.unwrap()
.is_none());
assert!(repository
.find_active_by_dedup_key("send", "key-2", 500)
.await
.unwrap()
.is_some());
let mut failed = job("send", Some(1), Some("key-3"));
failed.update(|data| data.failed_at = Some(1_000));
repository.create(&failed).await.unwrap();
assert!(repository
.find_active_by_dedup_key("send", "key-3", 0)
.await
.unwrap()
.is_none());
}
fn cron(name: &str, next_run_at: Option<i64>, enabled: bool) -> CronJob {
cron_job::new_cron_job(CronJobData {
base: EntityData::default(),
name: name.into(),
command_name: "ping".into(),
command_data: None,
cron: "0 0 * * * *".into(),
enabled,
last_run_at: None,
next_run_at,
max_running_jobs: Some(1),
misfire_policy: Some(MisfirePolicy::RunOnce),
retry_delays_seconds: None,
acceptable_running_time_seconds: None,
stuck_retry_attempts: None,
})
.unwrap()
}
async fn crons() -> SqliteCronJobRepository {
let repository = SqliteCronJobRepository::new(SqliteDatabase::in_memory().expect("open"));
repository.ensure_ready().await.expect("ready");
repository
}
#[tokio::test]
async fn a_cron_round_trips_and_is_findable_by_name() {
let repository = crons().await;
let cron = cron("nightly", Some(1_000), true);
repository.create(&cron).await.expect("create");
assert_eq!(
repository
.find_by_name("nightly")
.await
.expect("find")
.expect("present")
.id(),
cron.id()
);
assert!(repository.find_by_name("absent").await.unwrap().is_none());
}
#[tokio::test]
async fn due_crons_exclude_disabled_and_future_ones() {
let repository = crons().await;
repository
.create(&cron("due", Some(1_000), true))
.await
.unwrap();
repository
.create(&cron("later", Some(9_000), true))
.await
.unwrap();
repository
.create(&cron("off", Some(1_000), false))
.await
.unwrap();
repository.create(&cron("never", None, true)).await.unwrap();
let due = repository.find_due(ts(2_000)).await.expect("due");
assert_eq!(
due.iter()
.map(|c| c.data().name.as_str())
.collect::<Vec<_>>(),
vec!["due"],
"a JSON `true` reads back as 1, and a disabled cron must not fire"
);
}
#[tokio::test]
async fn two_crons_cannot_share_a_name() {
let repository = crons().await;
repository
.create(&cron("nightly", Some(1), true))
.await
.unwrap();
assert!(
repository
.create(&cron("nightly", Some(1), true))
.await
.is_err(),
"the unique index refused the duplicate"
);
}
}