notify: add calendar matcher

This allows matching by a notification's timestamp:

matcher: foo
  match-calendar mon..fri 8-12

Signed-off-by: Lukas Wagner <l.wagner@proxmox.com>

proxmox-notify/src/api/matcher.rs

@@ -80,6 +80,7 @@ pub fn update_matcher(
             match deleteable_property {
                 DeleteableMatcherProperty::MatchSeverity => matcher.match_severity = None,
                 DeleteableMatcherProperty::MatchField => matcher.match_field = None,
+                DeleteableMatcherProperty::MatchCalendar => matcher.match_calendar = None,
                 DeleteableMatcherProperty::Target => matcher.target = None,
                 DeleteableMatcherProperty::Mode => matcher.mode = None,
                 DeleteableMatcherProperty::InvertMatch => matcher.invert_match = None,
@@ -96,6 +97,10 @@ pub fn update_matcher(
         matcher.match_field = Some(match_field.clone());
     }
 
+    if let Some(match_calendar) = &matcher_updater.match_calendar {
+        matcher.match_calendar = Some(match_calendar.clone());
+    }
+
     if let Some(mode) = matcher_updater.mode {
         matcher.mode = Some(mode);
     }
@@ -200,6 +205,7 @@ matcher: matcher2
                 mode: Some(MatchModeOperator::Any),
                 match_field: None,
                 match_severity: None,
+                match_calendar: None,
                 invert_match: Some(true),
                 target: Some(vec!["foo".into()]),
                 comment: Some("new comment".into()),

proxmox-notify/src/lib.rs

@@ -154,6 +154,8 @@ pub enum Content {
 pub struct Metadata {
     /// Notification severity
     severity: Severity,
+    /// Timestamp of the notification as a UNIX epoch
+    timestamp: i64,
     /// Additional fields for additional key-value metadata
     additional_fields: HashMap<String, String>,
 }
@@ -179,6 +181,7 @@ impl Notification {
             metadata: Metadata {
                 severity,
                 additional_fields: fields,
+                timestamp: proxmox_time::epoch_i64(),
             },
             content: Content::Template {
                 title_template: title.as_ref().to_string(),
@@ -393,6 +396,7 @@ impl Bus {
                 severity: Severity::Info,
                 // TODO: what fields would make sense for test notifications?
                 additional_fields: Default::default(),
+                timestamp: proxmox_time::epoch_i64(),
             },
             content: Content::Template {
                 title_template: "Test notification".into(),

proxmox-notify/src/matcher.rs

@@ -10,6 +10,7 @@ use proxmox_schema::api_types::COMMENT_SCHEMA;
 use proxmox_schema::{
     api, const_regex, ApiStringFormat, Schema, StringSchema, Updater, SAFE_ID_REGEX_STR,
 };
+use proxmox_time::{parse_daily_duration, DailyDuration};
 
 use crate::schema::ENTITY_NAME_SCHEMA;
 use crate::{Error, Notification, Severity};
@@ -88,6 +89,14 @@ pub const MATCH_FIELD_ENTRY_SCHEMA: Schema = StringSchema::new("Match metadata f
             },
             optional: true,
         },
+        "match-calendar": {
+            type: Array,
+            items: {
+                description: "Time stamps to match",
+                type: String
+            },
+            optional: true,
+        },
         "target": {
             type: Array,
             items: {
@@ -112,6 +121,10 @@ pub struct MatcherConfig {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub match_severity: Option<Vec<SeverityMatcher>>,
 
+    /// List of matched severity levels
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub match_calendar: Option<Vec<CalendarMatcher>>,
+
     /// Decide if 'all' or 'any' match statements must match
     #[serde(skip_serializing_if = "Option::is_none")]
     pub mode: Option<MatchModeOperator>,
@@ -249,6 +262,7 @@ impl MatcherConfig {
         let mut is_match = mode.neutral_element();
         is_match = mode.apply(is_match, self.check_severity_match(notification));
         is_match = mode.apply(is_match, self.check_field_match(notification)?);
+        is_match = mode.apply(is_match, self.check_calendar_match(notification)?);
 
         let invert_match = self.invert_match.unwrap_or_default();
 
@@ -285,6 +299,19 @@ impl MatcherConfig {
 
         is_match
     }
+
+    fn check_calendar_match(&self, notification: &Notification) -> Result<bool, Error> {
+        let mode = self.mode.unwrap_or_default();
+        let mut is_match = mode.neutral_element();
+
+        if let Some(matchers) = self.match_calendar.as_ref() {
+            for matcher in matchers {
+                is_match = mode.apply(is_match, matcher.matches(notification)?);
+            }
+        }
+
+        Ok(is_match)
+    }
 }
 #[derive(Clone, Debug)]
 pub struct SeverityMatcher {
@@ -323,11 +350,49 @@ impl FromStr for SeverityMatcher {
     }
 }
 
+/// Match timestamp of the notification.
+#[derive(Clone, Debug)]
+pub struct CalendarMatcher {
+    schedule: DailyDuration,
+    original: String,
+}
+
+proxmox_serde::forward_deserialize_to_from_str!(CalendarMatcher);
+proxmox_serde::forward_serialize_to_display!(CalendarMatcher);
+
+impl CalendarMatcher {
+    fn matches(&self, notification: &Notification) -> Result<bool, Error> {
+        self.schedule
+            .time_match(notification.metadata.timestamp, false)
+            .map_err(|err| Error::Generic(format!("could not match timestamp: {err}")))
+    }
+}
+
+impl fmt::Display for CalendarMatcher {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(&self.original)
+    }
+}
+
+impl FromStr for CalendarMatcher {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Error> {
+        let schedule = parse_daily_duration(s)
+            .map_err(|e| Error::Generic(format!("could not parse schedule: {e}")))?;
+
+        Ok(Self {
+            schedule,
+            original: s.to_string(),
+        })
+    }
+}
+
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum DeleteableMatcherProperty {
     MatchSeverity,
     MatchField,
+    MatchCalendar,
     Target,
     Mode,
     InvertMatch,