use std::collections::{BTreeMap, HashSet};
use std::time::Duration;
use chrono_tz::Tz;
use serde::{Deserialize, Serialize};
use crate::schedule::{next_scheduled_after, Schedule};
pub(crate) const EXPAND_HORIZON: Duration = Duration::from_secs(48 * 60 * 60);
pub(crate) const EXPAND_THRESHOLD: Duration = Duration::from_secs(24 * 60 * 60);
pub(crate) const ADHOC_GRACE: Duration = Duration::from_secs(24 * 60 * 60);
const MAX_TASKS_PER_EXPANSION: usize = 1500;
#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Debug)]
#[serde(rename_all = "lowercase")]
pub(crate) enum TaskOrigin {
Schedule,
Adhoc,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub(crate) struct Task {
pub id: String,
pub origin: TaskOrigin,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trigger_id: Option<String>,
pub scheduled_at: u64,
pub created_at: u64,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub(crate) struct ExpansionState {
pub expanded_until: u64,
pub schedule: String,
#[serde(default)]
pub tz: Option<String>,
}
#[derive(Serialize, Deserialize, Default, Debug)]
pub(crate) struct TaskStore {
#[serde(default)]
pub tasks: Vec<Task>,
#[serde(default)]
pub expansion: BTreeMap<String, ExpansionState>,
}
impl TaskStore {
fn sort(&mut self) {
self.tasks
.sort_by(|a, b| a.scheduled_at.cmp(&b.scheduled_at).then(a.id.cmp(&b.id)));
}
pub(crate) fn normalize(&mut self) {
self.sort();
let mut seen = HashSet::new();
self.tasks.retain(|t| seen.insert(t.id.clone()));
}
pub(crate) fn insert(&mut self, task: Task) -> bool {
if self.tasks.iter().any(|t| t.id == task.id) {
return false;
}
self.tasks.push(task);
self.sort();
true
}
pub(crate) fn extend(&mut self, incoming: impl IntoIterator<Item = Task>) -> usize {
let mut ids: HashSet<String> = self.tasks.iter().map(|t| t.id.clone()).collect();
let mut added = 0;
for task in incoming {
if ids.insert(task.id.clone()) {
self.tasks.push(task);
added += 1;
}
}
if added > 0 {
self.sort();
}
added
}
pub(crate) fn remove(&mut self, id: &str) -> bool {
let before = self.tasks.len();
self.tasks.retain(|t| t.id != id);
self.tasks.len() != before
}
pub(crate) fn due(&self, now: u64) -> Vec<Task> {
self.tasks
.iter()
.take_while(|t| t.scheduled_at <= now)
.cloned()
.collect()
}
pub(crate) fn next_scheduled_for(&self, trigger_id: &str) -> Option<u64> {
self.tasks
.iter()
.filter(|t| t.trigger_id.as_deref() == Some(trigger_id))
.map(|t| t.scheduled_at)
.min()
}
}
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Disposition {
Run { delay_ms: u64 },
Orphaned,
Paused,
SkippedLate { delay_ms: u64 },
Expired { delay_ms: u64 },
}
pub(crate) type TriggerState = Option<TriggerRuntimeState>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct TriggerRuntimeState {
pub paused: bool,
}
pub(crate) fn classify_due(
task: &Task,
now: u64,
trigger: TriggerState,
schedule_grace: Duration,
) -> Disposition {
if task.trigger_id.is_some() {
match trigger {
None => return Disposition::Orphaned,
Some(state) if state.paused => return Disposition::Paused,
Some(_) => {}
}
}
let delay_ms = now.saturating_sub(task.scheduled_at);
let grace_ms = match task.origin {
TaskOrigin::Schedule => schedule_grace.as_millis() as u64,
TaskOrigin::Adhoc => ADHOC_GRACE.as_millis() as u64,
};
if delay_ms <= grace_ms {
return Disposition::Run { delay_ms };
}
match task.origin {
TaskOrigin::Schedule => Disposition::SkippedLate { delay_ms },
TaskOrigin::Adhoc => Disposition::Expired { delay_ms },
}
}
pub(crate) fn expand_trigger(
trigger_id: &str,
spec: &Schedule,
tz: &Tz,
expanded_until: u64,
now: u64,
) -> (Vec<Task>, u64) {
let horizon_end = now.saturating_add(EXPAND_HORIZON.as_millis() as u64);
let mut cursor = expanded_until.max(now);
let mut generated = Vec::new();
while generated.len() < MAX_TASKS_PER_EXPANSION {
let Some(next) = next_scheduled_after(cursor, spec, tz) else {
break;
};
if next > horizon_end {
break;
}
generated.push(Task {
id: format!("{trigger_id}@{next}"),
origin: TaskOrigin::Schedule,
trigger_id: Some(trigger_id.to_string()),
scheduled_at: next,
created_at: now,
});
cursor = next;
}
(generated, horizon_end)
}
pub(crate) fn needs_expansion(expanded_until: u64, now: u64) -> bool {
expanded_until < now.saturating_add(EXPAND_THRESHOLD.as_millis() as u64)
}
pub(crate) struct TriggerSpecView<'a> {
pub id: &'a str,
pub schedule: &'a str,
pub tz: Option<&'a str>,
}
#[derive(Debug, Default, PartialEq, Eq)]
pub(crate) struct ReconcileReport {
pub orphaned: Vec<(String, String)>,
pub rescheduled: Vec<String>,
}
pub(crate) fn reconcile(
store: &mut TaskStore,
triggers: &[TriggerSpecView<'_>],
now: u64,
) -> ReconcileReport {
let known: HashSet<&str> = triggers.iter().map(|t| t.id).collect();
let mut report = ReconcileReport::default();
store.tasks.retain(|t| match t.trigger_id.as_deref() {
Some(tid) if !known.contains(tid) => {
report.orphaned.push((t.id.clone(), tid.to_string()));
false
}
_ => true,
});
store
.expansion
.retain(|tid, _| known.contains(tid.as_str()));
for view in triggers {
let previous = store
.expansion
.get(view.id)
.map(|s| (s.schedule.clone(), s.tz.clone()));
let unchanged = matches!(
&previous,
Some((schedule, tz)) if schedule == view.schedule && tz.as_deref() == view.tz
);
if unchanged {
continue;
}
let is_new = previous.is_none();
store.expansion.insert(
view.id.to_string(),
ExpansionState {
expanded_until: now,
schedule: view.schedule.to_string(),
tz: view.tz.map(str::to_string),
},
);
if is_new {
continue;
}
report.rescheduled.push(view.id.to_string());
let tid = view.id;
store.tasks.retain(|t| {
!(t.origin == TaskOrigin::Schedule && t.trigger_id.as_deref() == Some(tid))
});
}
store.sort();
report
}
#[cfg(test)]
mod tests {
use super::*;
use crate::schedule::parse_schedule;
const HOUR: u64 = 60 * 60 * 1000;
const DAY: u64 = 24 * HOUR;
fn tz_utc() -> Tz {
"UTC".parse().unwrap()
}
fn base() -> u64 {
1_767_225_600_000
}
fn schedule_task(trigger: &str, at: u64) -> Task {
Task {
id: format!("{trigger}@{at}"),
origin: TaskOrigin::Schedule,
trigger_id: Some(trigger.to_string()),
scheduled_at: at,
created_at: at,
}
}
fn adhoc_task(trigger: Option<&str>, at: u64) -> Task {
Task {
id: format!("adhoc-{at}"),
origin: TaskOrigin::Adhoc,
trigger_id: trigger.map(str::to_string),
scheduled_at: at,
created_at: at,
}
}
fn running() -> TriggerState {
Some(TriggerRuntimeState { paused: false })
}
fn paused() -> TriggerState {
Some(TriggerRuntimeState { paused: true })
}
#[test]
fn expand_generates_tasks_within_horizon() {
let spec = parse_schedule("@daily 09:00").unwrap();
let now = base(); let (tasks, boundary) = expand_trigger("greeter", &spec, &tz_utc(), now, now);
assert_eq!(tasks.len(), 2);
assert_eq!(tasks[0].scheduled_at, now + 9 * HOUR);
assert_eq!(tasks[1].scheduled_at, now + DAY + 9 * HOUR);
assert_eq!(boundary, now + 2 * DAY);
assert!(tasks.iter().all(|t| t.origin == TaskOrigin::Schedule));
assert_eq!(tasks[0].trigger_id.as_deref(), Some("greeter"));
}
#[test]
fn expand_every_5m_stays_under_cap() {
let spec = parse_schedule("@every 5m").unwrap();
let now = base();
let (tasks, _) = expand_trigger("dense", &spec, &tz_utc(), now, now);
assert_eq!(tasks.len(), 576);
assert!(tasks.len() < MAX_TASKS_PER_EXPANSION);
}
#[test]
fn expand_is_idempotent_via_boundary() {
let spec = parse_schedule("@hourly").unwrap();
let now = base();
let (first, boundary) = expand_trigger("t", &spec, &tz_utc(), now, now);
assert!(!first.is_empty());
let (second, boundary2) = expand_trigger("t", &spec, &tz_utc(), boundary, now);
assert!(
second.is_empty(),
"境界以降・ホライズン以内には残りが無いはず: {second:?}"
);
assert_eq!(boundary2, boundary);
}
#[test]
fn expand_never_resurrects_deleted_task() {
let spec = parse_schedule("@hourly").unwrap();
let now = base();
let mut store = TaskStore::default();
let (tasks, boundary) = expand_trigger("t", &spec, &tz_utc(), now, now);
for t in tasks {
store.insert(t);
}
let victim = store.tasks[3].id.clone();
let victim_at = store.tasks[3].scheduled_at;
assert!(store.remove(&victim));
let later = now + HOUR;
let (again, _) = expand_trigger("t", &spec, &tz_utc(), boundary, later);
assert!(
!again.iter().any(|t| t.scheduled_at == victim_at),
"消した {victim} が復活している"
);
}
#[test]
fn expand_does_not_generate_past_tasks() {
let spec = parse_schedule("@hourly").unwrap();
let stale_boundary = base();
let now = base() + 7 * DAY;
let (tasks, boundary) = expand_trigger("t", &spec, &tz_utc(), stale_boundary, now);
assert!(
tasks.iter().all(|t| t.scheduled_at > now),
"過去タスクが生成された: {:?}",
tasks.iter().filter(|t| t.scheduled_at <= now).count()
);
assert_eq!(boundary, now + 2 * DAY);
}
#[test]
fn expand_at_yields_single_task_then_nothing() {
let target = base() + 10 * HOUR;
let dt = chrono::DateTime::from_timestamp_millis(target as i64)
.unwrap()
.naive_utc();
let spec = Schedule::At { datetime: dt };
let now = base();
let (tasks, boundary) = expand_trigger("once", &spec, &tz_utc(), now, now);
assert_eq!(tasks.len(), 1);
assert_eq!(tasks[0].scheduled_at, target);
let (again, _) = expand_trigger("once", &spec, &tz_utc(), boundary, now);
assert!(again.is_empty());
}
#[test]
fn needs_expansion_threshold() {
let now = base();
assert!(!needs_expansion(now + 2 * DAY, now));
assert!(needs_expansion(now + 12 * HOUR, now));
assert!(needs_expansion(now - DAY, now));
}
#[test]
fn due_returns_only_past_tasks_in_order() {
let now = base();
let mut store = TaskStore::default();
store.insert(schedule_task("t", now + HOUR));
store.insert(schedule_task("t", now - 2 * HOUR));
store.insert(schedule_task("t", now - HOUR));
let due = store.due(now);
assert_eq!(due.len(), 2);
assert_eq!(due[0].scheduled_at, now - 2 * HOUR);
assert_eq!(due[1].scheduled_at, now - HOUR);
assert_eq!(store.tasks.len(), 3);
}
#[test]
fn classify_runs_on_time_task() {
let now = base();
let task = schedule_task("t", now);
assert_eq!(
classify_due(&task, now, running(), Duration::from_secs(120)),
Disposition::Run { delay_ms: 0 }
);
}
#[test]
fn classify_runs_slightly_late_schedule_task() {
let now = base();
let task = schedule_task("t", now - 90_000); assert_eq!(
classify_due(&task, now, running(), Duration::from_secs(120)),
Disposition::Run { delay_ms: 90_000 }
);
}
#[test]
fn classify_discards_stale_schedule_task() {
let now = base();
let task = schedule_task("greeter-morning", now - HOUR);
assert_eq!(
classify_due(&task, now, running(), Duration::from_secs(120)),
Disposition::SkippedLate { delay_ms: HOUR }
);
}
#[test]
fn classify_runs_late_adhoc_task_within_grace() {
let now = base();
let task = adhoc_task(Some("t"), now - HOUR);
assert_eq!(
classify_due(&task, now, running(), Duration::from_secs(120)),
Disposition::Run { delay_ms: HOUR }
);
}
#[test]
fn classify_expires_ancient_adhoc_task() {
let now = base();
let task = adhoc_task(Some("t"), now - 7 * DAY);
assert_eq!(
classify_due(&task, now, running(), Duration::from_secs(120)),
Disposition::Expired { delay_ms: 7 * DAY }
);
}
#[test]
fn classify_discards_paused_trigger_task() {
let now = base();
let task = schedule_task("t", now);
assert_eq!(
classify_due(&task, now, paused(), Duration::from_secs(120)),
Disposition::Paused
);
}
#[test]
fn classify_reports_paused_over_late() {
let now = base();
let task = schedule_task("t", now - 7 * DAY);
assert_eq!(
classify_due(&task, now, paused(), Duration::from_secs(120)),
Disposition::Paused
);
}
#[test]
fn classify_discards_orphaned_task() {
let now = base();
let task = schedule_task("gone", now);
assert_eq!(
classify_due(&task, now, None, Duration::from_secs(120)),
Disposition::Orphaned
);
}
#[test]
fn classify_ignores_trigger_state_for_triggerless_task() {
let now = base();
let task = adhoc_task(None, now);
assert_eq!(
classify_due(&task, now, None, Duration::from_secs(120)),
Disposition::Run { delay_ms: 0 }
);
}
#[test]
fn reconcile_sweeps_orphaned_tasks() {
let now = base();
let mut store = TaskStore::default();
store.insert(schedule_task("alive", now + HOUR));
store.insert(schedule_task("gone", now + HOUR));
store.expansion.insert(
"gone".into(),
ExpansionState {
expanded_until: now + 2 * DAY,
schedule: "@hourly".into(),
tz: None,
},
);
let report = reconcile(
&mut store,
&[TriggerSpecView {
id: "alive",
schedule: "@hourly",
tz: None,
}],
now,
);
assert_eq!(store.tasks.len(), 1);
assert_eq!(store.tasks[0].trigger_id.as_deref(), Some("alive"));
assert_eq!(report.orphaned.len(), 1);
assert_eq!(report.orphaned[0].1, "gone");
assert!(!store.expansion.contains_key("gone"));
}
#[test]
fn reconcile_sweeps_orphaned_adhoc_task() {
let now = base();
let mut store = TaskStore::default();
store.insert(adhoc_task(Some("gone"), now));
let report = reconcile(&mut store, &[], now);
assert!(store.tasks.is_empty());
assert_eq!(report.orphaned.len(), 1);
}
#[test]
fn reconcile_reexpands_on_schedule_change() {
let now = base();
let mut store = TaskStore::default();
store.insert(schedule_task("greeter", now + 9 * HOUR));
store.insert(schedule_task("greeter", now + DAY + 9 * HOUR));
store.expansion.insert(
"greeter".into(),
ExpansionState {
expanded_until: now + 2 * DAY,
schedule: "@daily 09:00".into(),
tz: None,
},
);
let report = reconcile(
&mut store,
&[TriggerSpecView {
id: "greeter",
schedule: "@daily 08:00",
tz: None,
}],
now,
);
assert_eq!(report.rescheduled, vec!["greeter".to_string()]);
assert!(
store.tasks.is_empty(),
"古いスケジュールのタスクが残っている"
);
let state = &store.expansion["greeter"];
assert_eq!(state.expanded_until, now);
assert_eq!(state.schedule, "@daily 08:00");
}
#[test]
fn reconcile_reexpands_on_tz_change() {
let now = base();
let mut store = TaskStore::default();
store.expansion.insert(
"greeter".into(),
ExpansionState {
expanded_until: now + 2 * DAY,
schedule: "@daily 09:00".into(),
tz: Some("Asia/Tokyo".into()),
},
);
let report = reconcile(
&mut store,
&[TriggerSpecView {
id: "greeter",
schedule: "@daily 09:00",
tz: Some("Europe/Berlin"),
}],
now,
);
assert_eq!(report.rescheduled, vec!["greeter".to_string()]);
assert_eq!(store.expansion["greeter"].expanded_until, now);
}
#[test]
fn reconcile_is_noop_when_unchanged() {
let now = base();
let mut store = TaskStore::default();
store.insert(schedule_task("greeter", now + 9 * HOUR));
store.expansion.insert(
"greeter".into(),
ExpansionState {
expanded_until: now + 2 * DAY,
schedule: "@daily 09:00".into(),
tz: Some("Asia/Tokyo".into()),
},
);
let report = reconcile(
&mut store,
&[TriggerSpecView {
id: "greeter",
schedule: "@daily 09:00",
tz: Some("Asia/Tokyo"),
}],
now,
);
assert_eq!(report, ReconcileReport::default());
assert_eq!(store.tasks.len(), 1);
assert_eq!(store.expansion["greeter"].expanded_until, now + 2 * DAY);
}
#[test]
fn reconcile_keeps_adhoc_tasks_on_schedule_change() {
let now = base();
let mut store = TaskStore::default();
store.insert(schedule_task("greeter", now + 9 * HOUR));
store.insert(adhoc_task(Some("greeter"), now + 60_000));
store.expansion.insert(
"greeter".into(),
ExpansionState {
expanded_until: now + 2 * DAY,
schedule: "@daily 09:00".into(),
tz: None,
},
);
reconcile(
&mut store,
&[TriggerSpecView {
id: "greeter",
schedule: "@daily 08:00",
tz: None,
}],
now,
);
assert_eq!(store.tasks.len(), 1);
assert_eq!(store.tasks[0].origin, TaskOrigin::Adhoc);
}
#[test]
fn reconcile_registers_new_trigger_without_reporting() {
let now = base();
let mut store = TaskStore::default();
let report = reconcile(
&mut store,
&[TriggerSpecView {
id: "fresh",
schedule: "@hourly",
tz: None,
}],
now,
);
assert_eq!(report, ReconcileReport::default());
assert_eq!(store.expansion["fresh"].expanded_until, now);
}
#[test]
fn insert_dedups_by_id() {
let now = base();
let mut store = TaskStore::default();
assert!(store.insert(schedule_task("t", now)));
assert!(!store.insert(schedule_task("t", now)));
assert_eq!(store.tasks.len(), 1);
}
#[test]
fn next_scheduled_for_picks_earliest() {
let now = base();
let mut store = TaskStore::default();
store.insert(schedule_task("a", now + 2 * HOUR));
store.insert(schedule_task("a", now + HOUR));
store.insert(schedule_task("b", now + 30 * 60 * 1000));
assert_eq!(store.next_scheduled_for("a"), Some(now + HOUR));
assert_eq!(store.next_scheduled_for("b"), Some(now + 30 * 60 * 1000));
assert_eq!(store.next_scheduled_for("missing"), None);
}
#[test]
fn store_json_roundtrip_tolerates_unknown_fields() {
let now = base();
let mut store = TaskStore::default();
store.insert(schedule_task("t", now));
store.expansion.insert(
"t".into(),
ExpansionState {
expanded_until: now + DAY,
schedule: "@hourly".into(),
tz: None,
},
);
let json = serde_json::to_value(&store).unwrap();
let back: TaskStore = serde_json::from_value(json).unwrap();
assert_eq!(back.tasks.len(), 1);
assert_eq!(back.expansion["t"].expanded_until, now + DAY);
let with_future_field = serde_json::json!({
"tasks": [{
"id": "x@1",
"origin": "adhoc",
"scheduled_at": 1,
"created_at": 1,
"prompt": "来週の月曜に催促して",
}],
"expansion": {},
});
let parsed: TaskStore = serde_json::from_value(with_future_field).unwrap();
assert_eq!(parsed.tasks.len(), 1);
assert_eq!(parsed.tasks[0].origin, TaskOrigin::Adhoc);
assert!(parsed.tasks[0].trigger_id.is_none());
}
}