first commit

src/scheduler.rs

@@ -0,0 +1,345 @@
+//! In-process scheduler, preserving APScheduler's Monday=0 weekday convention.
+use crate::{AppState, backup, models::Settings, routeros};
+use anyhow::{Context, Result, bail, ensure};
+use chrono::{DateTime, Datelike, Duration, TimeZone, Timelike, Utc};
+use chrono_tz::Tz;
+use serde_json::{Value, json};
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{Arc, Mutex},
+    time::Duration as StdDuration,
+};
+use tokio::sync::watch;
+
+#[derive(Clone)]
+struct Field {
+    values: HashSet<u32>,
+}
+#[derive(Clone)]
+struct Cron {
+    minute: Field,
+    hour: Field,
+    day: Field,
+    month: Field,
+    weekday: Field,
+    last_day: bool,
+    timezone: Tz,
+}
+fn value(raw: &str, minimum: u32, maximum: u32, names: &[&str]) -> Result<u32> {
+    let v = if let Ok(number) = raw.parse() {
+        number
+    } else {
+        names
+            .iter()
+            .position(|name| raw.eq_ignore_ascii_case(name))
+            .map(|i| i as u32 + minimum)
+            .context("Invalid cron field value")?
+    };
+    ensure!(
+        (minimum..=maximum).contains(&v),
+        "Cron field value is out of range"
+    );
+    Ok(v)
+}
+fn field(raw: &str, minimum: u32, maximum: u32, names: &[&str]) -> Result<Field> {
+    let mut values = HashSet::new();
+    for item in raw.split(',') {
+        let (range, step) = if let Some((range, step)) = item.split_once('/') {
+            (range, step.parse::<u32>().context("Invalid cron step")?)
+        } else {
+            (item, 1)
+        };
+        ensure!(
+            step > 0 && step <= maximum - minimum + 1,
+            "Cron step is out of range"
+        );
+        let (start, end) = if range == "*" {
+            (minimum, maximum)
+        } else if let Some((a, b)) = range.split_once('-') {
+            (
+                value(a, minimum, maximum, names)?,
+                value(b, minimum, maximum, names)?,
+            )
+        } else {
+            let start = value(range, minimum, maximum, names)?;
+            (start, if item.contains('/') { maximum } else { start })
+        };
+        ensure!(start <= end, "Cron range start exceeds end");
+        for v in (start..=end).step_by(step as usize) {
+            values.insert(v);
+        }
+    }
+    ensure!(!values.is_empty(), "Empty cron field");
+    Ok(Field { values })
+}
+impl Cron {
+    fn parse(expression: &str, timezone: &str) -> Result<Self> {
+        let parts: Vec<_> = expression.split_whitespace().collect();
+        ensure!(
+            parts.len() == 5,
+            "Cron expression must contain exactly 5 fields"
+        );
+        let last_day = parts[2].eq_ignore_ascii_case("last");
+        Ok(Self {
+            minute: field(parts[0], 0, 59, &[])?,
+            hour: field(parts[1], 0, 23, &[])?,
+            day: field(if last_day { "*" } else { parts[2] }, 1, 31, &[])?,
+            month: field(
+                parts[3],
+                1,
+                12,
+                &[
+                    "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov",
+                    "dec",
+                ],
+            )?,
+            weekday: field(
+                parts[4],
+                0,
+                6,
+                &["mon", "tue", "wed", "thu", "fri", "sat", "sun"],
+            )?,
+            last_day,
+            timezone: timezone.parse().context("Unknown timezone")?,
+        })
+    }
+    fn matches(&self, time: DateTime<Utc>) -> bool {
+        let local = time.with_timezone(&self.timezone);
+        let last = !self.last_day
+            || local
+                .date_naive()
+                .succ_opt()
+                .is_some_and(|next| next.month() != local.month());
+        self.minute.values.contains(&local.minute())
+            && self.hour.values.contains(&local.hour())
+            && self.day.values.contains(&local.day())
+            && self.month.values.contains(&local.month())
+            && self
+                .weekday
+                .values
+                .contains(&local.weekday().num_days_from_monday())
+            && last
+    }
+    fn next(&self, from: DateTime<Utc>, count: usize) -> Vec<DateTime<Tz>> {
+        let Some(mut time) = Utc
+            .timestamp_opt((from.timestamp() / 60 + 1) * 60, 0)
+            .single()
+        else {
+            return Vec::new();
+        };
+        let mut runs = Vec::new();
+        let limit = time + Duration::days(366 * 400);
+        while runs.len() < count && time < limit {
+            let local = time.with_timezone(&self.timezone);
+            if !self.month.values.contains(&local.month())
+                || !self.day.values.contains(&local.day())
+                || !self
+                    .weekday
+                    .values
+                    .contains(&local.weekday().num_days_from_monday())
+                || (self.last_day
+                    && local
+                        .date_naive()
+                        .succ_opt()
+                        .is_some_and(|next| next.month() == local.month()))
+            {
+                // Jump to the next local midnight, respecting timezone transitions.
+                if let Some(next_date) = local.date_naive().succ_opt()
+                    && let Some(midnight) = next_date.and_hms_opt(0, 0, 0)
+                    && let Some(next) = self.timezone.from_local_datetime(&midnight).earliest()
+                {
+                    let next = next.with_timezone(&Utc);
+                    if next > time {
+                        time = next;
+                        continue;
+                    }
+                }
+            }
+            if self.matches(time) {
+                runs.push(time.with_timezone(&self.timezone));
+            }
+            time += Duration::minutes(1);
+        }
+        runs
+    }
+}
+pub fn validate_cron(expression: &str, timezone: &str) -> Result<()> {
+    Cron::parse(expression, timezone).map(|_| ())
+}
+
+fn cron_status(key: &str, label: &str, enabled: bool, expression: &str, timezone: &str) -> Value {
+    if !enabled || expression.trim().is_empty() {
+        return json!({"key":key,"label":label,"enabled":false,"cron":if expression.is_empty(){None}else{Some(expression)},"description":"settings.scheduleDisabledHint","description_params":null,"valid":true,"next_runs":[],"error":null});
+    }
+    match Cron::parse(expression, timezone) {
+        Ok(cron) => {
+            json!({"key":key,"label":label,"enabled":true,"cron":expression,"description":"settings.schedulerCronDescription","description_params":{"description":expression},"valid":true,"next_runs":cron.next(Utc::now(),3),"error":null})
+        }
+        Err(error) => {
+            json!({"key":key,"label":label,"enabled":true,"cron":expression,"description":"settings.schedulerInvalidCron","description_params":null,"valid":false,"next_runs":[],"error":error.to_string()})
+        }
+    }
+}
+pub fn status(state: &AppState) -> Result<Value> {
+    let s = state.db.get_settings()?;
+    let minutes = s.connection_test_interval_minutes;
+    let now = Utc::now();
+    let runs: Vec<_> = if minutes > 0 {
+        (1..=3)
+            .map(|n| now + Duration::minutes(minutes * n))
+            .collect()
+    } else {
+        Vec::new()
+    };
+    Ok(
+        json!({"timezone":state.config.timezone,"running":true,"jobs":[
+            cron_status("auto_export","settings.schedulerAutoExportLabel",s.enable_auto_export,&s.export_cron,&state.config.timezone),
+            cron_status("auto_binary","settings.schedulerBinaryLabel",!s.binary_cron.is_empty(),&s.binary_cron,&state.config.timezone),
+            cron_status("retention","settings.schedulerRetentionLabel",!s.retention_cron.is_empty(),&s.retention_cron,&state.config.timezone),
+            {"key":"connection_probe","label":"settings.schedulerConnectionLabel","enabled":minutes>0,"cron":null,"description":if minutes>0{"settings.connectionTestsEverySummary"}else{"settings.connectionTestsDisabledHint"},"description_params":{"minutes":minutes},"valid":true,"next_runs":runs,"error":null},
+            {"key":"log_cleanup","label":"settings.schedulerLogsLabel","enabled":true,"cron":null,"description":"settings.schedulerLogsDescription","description_params":null,"valid":true,"next_runs":[],"error":null}
+        ]}),
+    )
+}
+
+struct RunningGuard {
+    key: String,
+    set: Arc<Mutex<HashSet<String>>>,
+}
+impl Drop for RunningGuard {
+    fn drop(&mut self) {
+        if let Ok(mut set) = self.set.lock() {
+            set.remove(&self.key);
+        }
+    }
+}
+async fn job(state: &AppState, key: &str) -> Result<()> {
+    match key {
+        "auto_export" => {
+            backup::run_all(state, None, "export").await?;
+        }
+        "auto_binary" => {
+            backup::run_all(state, None, "binary").await?;
+        }
+        "retention" => {
+            backup::cleanup(state).await?;
+        }
+        "connection_probe" => {
+            for router in state.db.routers(None)? {
+                routeros::test_connection(state, &router).await?;
+            }
+        }
+        "log_cleanup" => {
+            let s = state.db.get_settings()?;
+            let cutoff = (Utc::now() - Duration::days(s.log_retention_days.max(0))).to_rfc3339();
+            let count = state.db.with_conn(|conn| {
+                Ok(conn.execute(
+                    "DELETE FROM operation_logs WHERE julianday(timestamp)<julianday(?1)",
+                    [cutoff],
+                )?)
+            })?;
+            state.db.log(&format!(
+                "Log retention cleanup removed {count} entries older than {} days",
+                s.log_retention_days
+            ))?;
+        }
+        _ => bail!("Unknown scheduler job"),
+    }
+    Ok(())
+}
+
+fn signature(s: &Settings) -> String {
+    format!(
+        "{}|{}|{}|{}|{}",
+        s.enable_auto_export,
+        s.export_cron,
+        s.binary_cron,
+        s.retention_cron,
+        s.connection_test_interval_minutes
+    )
+}
+pub fn start(state: AppState, mut shutdown: watch::Receiver<bool>) -> tokio::task::JoinHandle<()> {
+    tokio::spawn(async move {
+        let mut tick = tokio::time::interval(StdDuration::from_secs(1));
+        tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+        let running = Arc::new(Mutex::new(HashSet::<String>::new()));
+        let mut tasks = tokio::task::JoinSet::new();
+        let mut schedules: HashMap<String, (Cron, DateTime<Utc>)> = HashMap::new();
+        let mut last_signature = String::new();
+        let mut next_probe = None;
+        let mut next_logs = Utc::now() + Duration::days(1);
+        loop {
+            tokio::select! {
+                changed=shutdown.changed()=>{if changed.is_err()||*shutdown.borrow(){break;}},
+                Some(_)=tasks.join_next(),if !tasks.is_empty()=>{},
+                _=tick.tick()=>{
+                    let now=Utc::now();let settings=match state.db.get_settings(){Ok(s)=>s,Err(error)=>{tracing::error!("Scheduler settings unavailable: {error}");continue;}};
+                    let current_signature=signature(&settings);
+                    if current_signature!=last_signature{
+                        schedules.clear();
+                        for (key,enabled,expression) in [("auto_export",settings.enable_auto_export,settings.export_cron.as_str()),("auto_binary",true,settings.binary_cron.as_str()),("retention",true,settings.retention_cron.as_str())]{
+                            if enabled&&!expression.trim().is_empty(){match Cron::parse(expression,&state.config.timezone){Ok(cron)=>{if let Some(next)=cron.next(now,1).first(){schedules.insert(key.to_owned(),(cron.clone(),next.with_timezone(&Utc)));}},Err(error)=>{let _=state.db.log(&format!("Scheduler skipped invalid {key} cron: {error}"));}}}
+                        }
+                        next_probe=(settings.connection_test_interval_minutes>0).then(||now+Duration::minutes(settings.connection_test_interval_minutes));last_signature=current_signature;
+                    }
+                    let mut due=Vec::new();
+                    for (key,(cron,next)) in &mut schedules{if now>=*next{if now.signed_duration_since(*next)<=Duration::minutes(5){due.push(key.clone());}
+                        if let Some(value)=cron.next(now,1).first(){*next=value.with_timezone(&Utc);}else{*next=now+Duration::days(366*400);}}}
+                    if next_probe.is_some_and(|time|now>=time){due.push("connection_probe".into());next_probe=Some(now+Duration::minutes(settings.connection_test_interval_minutes.max(1)));}
+                    if now>=next_logs{due.push("log_cleanup".into());next_logs=now+Duration::days(1);}
+                    for key in due{let inserted=running.lock().map(|mut set|set.insert(key.clone())).unwrap_or(false);if !inserted{continue;}let state=state.clone();let guard=RunningGuard{key:key.clone(),set:running.clone()};tasks.spawn(async move{let _guard=guard;if let Err(error)=job(&state,&key).await{let _=state.db.log(&format!("Scheduled {key} failed: {error:#}"));}});}
+                }
+            }
+        }
+        // Allow active jobs to finish; individual network operations have hard deadlines.
+        while tasks.join_next().await.is_some() {}
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn validates_cron_and_ranges() {
+        assert!(validate_cron("15 2 * * *", "Europe/Warsaw").is_ok());
+        for expression in [
+            "bad cron",
+            "61 * * * *",
+            "*/0 * * * *",
+            "0 0 * * 7",
+            "0 0 * 13 *",
+        ] {
+            assert!(validate_cron(expression, "Europe/Warsaw").is_err());
+        }
+    }
+    #[test]
+    fn monday_zero_matches_apscheduler() {
+        let cron = Cron::parse("0 2 * * 0", "UTC").unwrap();
+        assert!(cron.matches(Utc.with_ymd_and_hms(2026, 10, 26, 2, 0, 0).unwrap()));
+        assert!(!cron.matches(Utc.with_ymd_and_hms(2026, 10, 25, 2, 0, 0).unwrap()));
+    }
+    #[test]
+    fn timezone_and_dst_preview() {
+        let cron = Cron::parse("30 2 * * *", "Europe/Warsaw").unwrap();
+        let start = Utc.with_ymd_and_hms(2026, 3, 28, 12, 0, 0).unwrap();
+        let runs = cron.next(start, 2);
+        assert_eq!(runs.len(), 2);
+        assert_eq!(runs[0].day(), 30);
+        assert_eq!(runs[0].hour(), 2);
+        assert!(runs[0] < runs[1]);
+    }
+    #[test]
+    fn named_weekdays_and_last_day() {
+        let cron = Cron::parse("0 0 last * *", "UTC").unwrap();
+        assert!(cron.matches(Utc.with_ymd_and_hms(2028, 2, 29, 0, 0, 0).unwrap()));
+        assert!(!cron.matches(Utc.with_ymd_and_hms(2028, 2, 28, 0, 0, 0).unwrap()));
+        assert!(validate_cron("*/15 1-6/2 * jan-mar mon-fri", "UTC").is_ok());
+    }
+    #[test]
+    fn rare_calendar_schedule_is_not_lost() {
+        let cron = Cron::parse("0 0 29 feb mon", "UTC").unwrap();
+        let runs = cron.next(Utc.with_ymd_and_hms(2026, 10, 27, 0, 0, 0).unwrap(), 1);
+        assert_eq!(runs.len(), 1);
+        assert_eq!(runs[0].year(), 2044);
+    }
+}