public inbox for pve-devel@lists.proxmox.com
 help / color / mirror / Atom feed
From: Lukas Wagner <l.wagner@proxmox.com>
To: pve-devel@lists.proxmox.com
Subject: [PATCH proxmox v2 11/63] notify: move `send`, `test_target` and `Bus` to new `send` module
Date: Wed, 18 Nov 2026 10:42:55 +0100	[thread overview]
Message-ID: <20261118094348.273646-12-l.wagner@proxmox.com> (raw)
In-Reply-To: <20261118094348.273646-1-l.wagner@proxmox.com>

lib.rs has grown quite large, so moving functionality to smaller
submodules is appropriate. This also makes it easier to feature-gate
these functions/types with a single directive in lib.rs.

Signed-off-by: Lukas Wagner <l.wagner@proxmox.com>
---
 proxmox-notify/src/api/common.rs |  47 +---
 proxmox-notify/src/lib.rs        | 374 +----------------------------
 proxmox-notify/src/send.rs       | 393 +++++++++++++++++++++++++++++++
 3 files changed, 398 insertions(+), 416 deletions(-)
 create mode 100644 proxmox-notify/src/send.rs

diff --git a/proxmox-notify/src/api/common.rs b/proxmox-notify/src/api/common.rs
index 56a9797a9..a31cbaea8 100644
--- a/proxmox-notify/src/api/common.rs
+++ b/proxmox-notify/src/api/common.rs
@@ -1,51 +1,6 @@
 use proxmox_http_error::HttpError;
 
-use super::http_err;
-use crate::{Bus, Config, Context, Error, Notification};
-
-/// Send a notification to a given target.
-///
-/// The caller is responsible for any needed permission checks.
-/// Returns an `anyhow::Error` in case of an error.
-pub fn send(
-    context: &Context,
-    config: &Config,
-    notification: &Notification,
-) -> Result<(), HttpError> {
-    let bus = Bus::from_config(config).map_err(|err| {
-        http_err!(
-            INTERNAL_SERVER_ERROR,
-            "Could not instantiate notification bus: {err}"
-        )
-    })?;
-
-    bus.send(context, notification);
-
-    Ok(())
-}
-
-/// Test target (group or single endpoint) identified by its `name`.
-///
-/// The caller is responsible for any needed permission checks.
-/// Returns an `anyhow::Error` if sending via the endpoint failed.
-pub fn test_target(context: &Context, config: &Config, endpoint: &str) -> Result<(), HttpError> {
-    let bus = Bus::from_config(config).map_err(|err| {
-        http_err!(
-            INTERNAL_SERVER_ERROR,
-            "Could not instantiate notification bus: {err}"
-        )
-    })?;
-
-    bus.test_target(context, endpoint)
-        .map_err(|err| match err {
-            Error::TargetDoesNotExist(endpoint) => {
-                http_err!(NOT_FOUND, "endpoint '{endpoint}' does not exist")
-            }
-            _ => http_err!(INTERNAL_SERVER_ERROR, "Could not test target: {err}"),
-        })?;
-
-    Ok(())
-}
+use crate::Config;
 
 /// Return all entities (targets, groups, filters) that are linked to the entity.
 /// For instance, if a group 'grp1' contains the targets 'a', 'b' and 'c',
diff --git a/proxmox-notify/src/lib.rs b/proxmox-notify/src/lib.rs
index c74e7e1a9..2061d9150 100644
--- a/proxmox-notify/src/lib.rs
+++ b/proxmox-notify/src/lib.rs
@@ -7,8 +7,7 @@ use std::str::FromStr;
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use serde_json::json;
-use tracing::{error, info};
+use tracing::error;
 
 use proxmox_config_digest::ConfigDigest;
 use proxmox_schema::api;
@@ -24,6 +23,9 @@ pub mod endpoints;
 pub mod renderer;
 pub mod schema;
 
+#[cfg(feature = "send-impl")]
+pub mod send;
+
 #[cfg(feature = "api-types")]
 pub mod api_types;
 
@@ -33,11 +35,6 @@ pub use error::Error;
 pub use context::Context;
 pub use context::ContextImpl;
 
-use endpoints::Endpoint;
-
-use crate::api_types::MATCHER_TYPENAME;
-use crate::api_types::MatcherConfig;
-
 #[api()]
 #[derive(Clone, Debug, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd)]
 #[serde(rename_all = "kebab-case")]
@@ -307,366 +304,3 @@ impl Config {
         &self.digest
     }
 }
-
-/// Notification bus - distributes notifications to all registered endpoints
-// The reason for the split between `Config` and this struct is to make testing with mocked
-// endpoints a bit easier.
-#[derive(Default)]
-pub struct Bus {
-    endpoints: HashMap<String, Box<dyn Endpoint>>,
-    matchers: Vec<MatcherConfig>,
-}
-
-macro_rules! parse_endpoints_with_private_config {
-    ($config:ident, $public_config:ty, $private_config:ty, $endpoint_type:ident, $type_name:expr) => {
-        (|| -> Result<Vec<Box<dyn Endpoint>>, Error> {
-            let mut endpoints = Vec::<Box<dyn Endpoint>>::new();
-
-            let configs: Vec<$public_config> = $config
-                .config
-                .convert_to_typed_array($type_name)
-                .map_err(|err| Error::ConfigDeserialization(err.into()))?;
-
-            for config in configs {
-                match $config.private_config.sections.get(&config.name) {
-                    Some((section_type_name, private_config)) => {
-                        if $type_name != section_type_name {
-                            error!(
-                                "Could not instantiate endpoint '{name}': \
-                                private config has wrong type",
-                                name = config.name
-                            );
-                        }
-                        let private_config = <$private_config>::deserialize(private_config)
-                            .map_err(|err| Error::ConfigDeserialization(err.into()))?;
-
-                        endpoints.push(Box::new($endpoint_type {
-                            config,
-                            private_config: private_config.clone(),
-                        }));
-                    }
-                    None => error!(
-                        "Could not instantiate endpoint '{name}': \
-                            private config does not exist",
-                        name = config.name
-                    ),
-                }
-            }
-
-            Ok(endpoints)
-        })()
-    };
-}
-
-macro_rules! parse_endpoints_without_private_config {
-    ($config:ident, $public_config:ty, $endpoint_type:ident, $type_name:expr) => {
-        (|| -> Result<Vec<Box<dyn Endpoint>>, Error> {
-            let mut endpoints = Vec::<Box<dyn Endpoint>>::new();
-
-            let configs: Vec<$public_config> = $config
-                .config
-                .convert_to_typed_array($type_name)
-                .map_err(|err| Error::ConfigDeserialization(err.into()))?;
-
-            for config in configs {
-                endpoints.push(Box::new($endpoint_type { config }));
-            }
-
-            Ok(endpoints)
-        })()
-    };
-}
-
-impl Bus {
-    /// Instantiate notification bus from a given configuration.
-    pub fn from_config(config: &Config) -> Result<Self, Error> {
-        let mut endpoints = HashMap::new();
-
-        // Instantiate endpoints
-        use crate::api_types::{SENDMAIL_TYPENAME, SendmailConfig};
-        use endpoints::sendmail::SendmailEndpoint;
-        endpoints.extend(
-            parse_endpoints_without_private_config!(
-                config,
-                SendmailConfig,
-                SendmailEndpoint,
-                SENDMAIL_TYPENAME
-            )?
-            .into_iter()
-            .map(|e| (e.name().into(), e)),
-        );
-
-        use crate::api_types::{GOTIFY_TYPENAME, GotifyConfig, GotifyPrivateConfig};
-        use crate::endpoints::gotify::GotifyEndpoint;
-
-        endpoints.extend(
-            parse_endpoints_with_private_config!(
-                config,
-                GotifyConfig,
-                GotifyPrivateConfig,
-                GotifyEndpoint,
-                GOTIFY_TYPENAME
-            )?
-            .into_iter()
-            .map(|e| (e.name().into(), e)),
-        );
-
-        use crate::api_types::{SMTP_TYPENAME, SmtpConfig, SmtpPrivateConfig};
-        use endpoints::smtp::SmtpEndpoint;
-
-        endpoints.extend(
-            parse_endpoints_with_private_config!(
-                config,
-                SmtpConfig,
-                SmtpPrivateConfig,
-                SmtpEndpoint,
-                SMTP_TYPENAME
-            )?
-            .into_iter()
-            .map(|e| (e.name().into(), e)),
-        );
-
-        use crate::api_types::{WEBHOOK_TYPENAME, WebhookConfig, WebhookPrivateConfig};
-        use endpoints::webhook::WebhookEndpoint;
-        endpoints.extend(
-            parse_endpoints_with_private_config!(
-                config,
-                WebhookConfig,
-                WebhookPrivateConfig,
-                WebhookEndpoint,
-                WEBHOOK_TYPENAME
-            )?
-            .into_iter()
-            .map(|e| (e.name().into(), e)),
-        );
-
-        let matchers = config
-            .config
-            .convert_to_typed_array(MATCHER_TYPENAME)
-            .map_err(|err| Error::ConfigDeserialization(err.into()))?;
-
-        Ok(Bus {
-            endpoints,
-            matchers,
-        })
-    }
-
-    #[cfg(test)]
-    pub(crate) fn add_endpoint(&mut self, endpoint: Box<dyn Endpoint>) {
-        self.endpoints.insert(endpoint.name().to_string(), endpoint);
-    }
-
-    #[cfg(test)]
-    pub fn add_matcher(&mut self, filter: MatcherConfig) {
-        self.matchers.push(filter)
-    }
-
-    /// Send a notification. Notification matchers will determine which targets will receive
-    /// the notification.
-    ///
-    /// Any errors will not be returned but only logged.
-    pub fn send(&self, context: &Context, notification: &Notification) {
-        let targets = api_types::check_matches(self.matchers.as_slice(), notification);
-
-        for target in targets {
-            if let Some(endpoint) = self.endpoints.get(target) {
-                let name = endpoint.name();
-
-                if endpoint.disabled() {
-                    // Skip this target if it is disabled
-                    info!("skipping disabled target '{name}'");
-                    continue;
-                }
-
-                match endpoint.send(context, notification) {
-                    Ok(_) => {
-                        info!("notified via target `{name}`");
-                    }
-                    Err(e) => {
-                        // Only log on errors, do not propagate fail to the caller.
-                        error!("could not notify via target `{name}`: {e}");
-                    }
-                }
-            } else {
-                error!("could not notify via target '{target}', it does not exist");
-            }
-        }
-    }
-
-    /// Send a test notification to a target (endpoint or group).
-    ///
-    /// In contrast to the `send` function, this function will return
-    /// any errors to the caller.
-    pub fn test_target(&self, context: &Context, target: &str) -> Result<(), Error> {
-        let notification = Notification {
-            metadata: Metadata {
-                severity: Severity::Info,
-                // TODO: what fields would make sense for test notifications?
-                additional_fields: Default::default(),
-                timestamp: proxmox_time::epoch_i64(),
-            },
-            content: Content::Template {
-                template_name: "test".to_string(),
-                data: json!({ "target": target }),
-            },
-            id: Uuid::generate(),
-        };
-
-        if let Some(endpoint) = self.endpoints.get(target) {
-            endpoint.send(context, &notification)?;
-        } else {
-            return Err(Error::target_does_not_exist(target));
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::{cell::RefCell, rc::Rc};
-
-    use proxmox_match_expression::Expression;
-
-    use crate::{
-        api_types::{expression::NotificationMatcher, severity::SeverityMatcher},
-        context::{Context, test},
-    };
-
-    use super::*;
-
-    #[derive(Default, Clone)]
-    struct MockEndpoint {
-        name: &'static str,
-        // Needs to be an Rc so that we can clone MockEndpoint before
-        // passing it to Bus, while still retaining a handle to the Vec
-        messages: Rc<RefCell<Vec<Notification>>>,
-    }
-
-    impl Endpoint for MockEndpoint {
-        fn send(&self, _context: &Context, message: &Notification) -> Result<(), Error> {
-            self.messages.borrow_mut().push(message.clone());
-
-            Ok(())
-        }
-
-        fn name(&self) -> &str {
-            self.name
-        }
-
-        fn disabled(&self) -> bool {
-            false
-        }
-    }
-
-    impl MockEndpoint {
-        fn new(name: &'static str) -> Self {
-            Self {
-                name,
-                ..Default::default()
-            }
-        }
-
-        fn messages(&self) -> Vec<Notification> {
-            self.messages.borrow().clone()
-        }
-    }
-
-    fn expression_to_string(expression: Expression<NotificationMatcher>) -> String {
-        serde_json::to_string(&expression).unwrap()
-    }
-
-    #[test]
-    fn test_add_mock_endpoint() -> Result<(), Error> {
-        let context = test::test_context();
-        let mock = MockEndpoint::new("endpoint");
-
-        let mut bus = Bus::default();
-        bus.add_endpoint(Box::new(mock.clone()));
-
-        let matcher = MatcherConfig {
-            target: vec!["endpoint".into()],
-            expression: Some(expression_to_string(Expression::Constant(true))),
-            ..Default::default()
-        };
-
-        bus.add_matcher(matcher);
-
-        // Send directly to endpoint
-        bus.send(
-            &context,
-            &Notification::from_template(
-                Severity::Info,
-                "test",
-                Default::default(),
-                Default::default(),
-            ),
-        );
-        let messages = mock.messages();
-        assert_eq!(messages.len(), 1);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_multiple_endpoints_with_different_matchers() -> Result<(), Error> {
-        let context = test::test_context();
-
-        let endpoint1 = MockEndpoint::new("mock1");
-        let endpoint2 = MockEndpoint::new("mock2");
-
-        let mut bus = Bus::default();
-
-        bus.add_endpoint(Box::new(endpoint1.clone()));
-        bus.add_endpoint(Box::new(endpoint2.clone()));
-
-        bus.add_matcher(MatcherConfig {
-            name: "matcher1".into(),
-            expression: Some(expression_to_string(
-                SeverityMatcher {
-                    severities: vec![Severity::Error, Severity::Warning],
-                }
-                .into(),
-            )),
-            target: vec!["mock1".into()],
-            ..Default::default()
-        });
-
-        bus.add_matcher(MatcherConfig {
-            name: "matcher2".into(),
-            expression: Some(expression_to_string(
-                SeverityMatcher {
-                    severities: vec![Severity::Error],
-                }
-                .into(),
-            )),
-            target: vec!["mock2".into()],
-            ..Default::default()
-        });
-
-        let send_with_severity = |severity| {
-            let notification = Notification::from_template(
-                severity,
-                "test",
-                Default::default(),
-                Default::default(),
-            );
-
-            bus.send(&context, &notification);
-        };
-
-        send_with_severity(Severity::Info);
-        assert_eq!(endpoint1.messages().len(), 0);
-        assert_eq!(endpoint2.messages().len(), 0);
-
-        send_with_severity(Severity::Warning);
-        assert_eq!(endpoint1.messages().len(), 1);
-        assert_eq!(endpoint2.messages().len(), 0);
-
-        send_with_severity(Severity::Error);
-        assert_eq!(endpoint1.messages().len(), 2);
-        assert_eq!(endpoint2.messages().len(), 1);
-
-        Ok(())
-    }
-}
diff --git a/proxmox-notify/src/send.rs b/proxmox-notify/src/send.rs
new file mode 100644
index 000000000..3ef63aa8c
--- /dev/null
+++ b/proxmox-notify/src/send.rs
@@ -0,0 +1,393 @@
+use std::collections::HashMap;
+
+use proxmox_uuid::Uuid;
+use serde::Deserialize;
+use serde_json::json;
+use tracing::{error, info};
+
+use crate::api_types::{GOTIFY_TYPENAME, GotifyConfig, GotifyPrivateConfig};
+use crate::api_types::{MATCHER_TYPENAME, MatcherConfig};
+use crate::api_types::{SENDMAIL_TYPENAME, SendmailConfig};
+use crate::api_types::{SMTP_TYPENAME, SmtpConfig, SmtpPrivateConfig};
+use crate::api_types::{WEBHOOK_TYPENAME, WebhookConfig, WebhookPrivateConfig};
+use crate::endpoints::Endpoint;
+use crate::endpoints::gotify::GotifyEndpoint;
+use crate::endpoints::sendmail::SendmailEndpoint;
+use crate::endpoints::smtp::SmtpEndpoint;
+use crate::endpoints::webhook::WebhookEndpoint;
+use crate::{Config, Content, Context, Error, Metadata, Notification, Severity};
+
+/// Send a notification to a given target.
+///
+/// The caller is responsible for any needed permission checks.
+/// Returns an `anyhow::Error` in case of an error.
+pub fn send(context: &Context, config: &Config, notification: &Notification) -> Result<(), Error> {
+    let bus = Bus::from_config(config)?;
+    bus.send(context, notification);
+
+    Ok(())
+}
+
+/// Test target (group or single endpoint) identified by its `name`.
+///
+/// The caller is responsible for any needed permission checks.
+/// Returns an `anyhow::Error` if sending via the endpoint failed.
+pub fn test_target(context: &Context, config: &Config, endpoint: &str) -> Result<(), Error> {
+    let bus = Bus::from_config(config)?;
+    bus.test_target(context, endpoint)?;
+
+    Ok(())
+}
+
+/// Notification bus - distributes notifications to all registered endpoints
+// The reason for the split between `Config` and this struct is to make testing with mocked
+// endpoints a bit easier.
+#[derive(Default)]
+struct Bus {
+    endpoints: HashMap<String, Box<dyn Endpoint>>,
+    matchers: Vec<MatcherConfig>,
+}
+
+macro_rules! parse_endpoints_with_private_config {
+    ($config:ident, $public_config:ty, $private_config:ty, $endpoint_type:ident, $type_name:expr) => {
+        (|| -> Result<Vec<Box<dyn Endpoint>>, Error> {
+            let mut endpoints = Vec::<Box<dyn Endpoint>>::new();
+
+            let configs: Vec<$public_config> = $config
+                .config
+                .convert_to_typed_array($type_name)
+                .map_err(|err| Error::ConfigDeserialization(err.into()))?;
+
+            for config in configs {
+                match $config.private_config.sections.get(&config.name) {
+                    Some((section_type_name, private_config)) => {
+                        if $type_name != section_type_name {
+                            error!(
+                                "Could not instantiate endpoint '{name}': \
+                                private config has wrong type",
+                                name = config.name
+                            );
+                        }
+                        let private_config = <$private_config>::deserialize(private_config)
+                            .map_err(|err| Error::ConfigDeserialization(err.into()))?;
+
+                        endpoints.push(Box::new($endpoint_type {
+                            config,
+                            private_config: private_config.clone(),
+                        }));
+                    }
+                    None => error!(
+                        "Could not instantiate endpoint '{name}': \
+                            private config does not exist",
+                        name = config.name
+                    ),
+                }
+            }
+
+            Ok(endpoints)
+        })()
+    };
+}
+
+macro_rules! parse_endpoints_without_private_config {
+    ($config:ident, $public_config:ty, $endpoint_type:ident, $type_name:expr) => {
+        (|| -> Result<Vec<Box<dyn Endpoint>>, Error> {
+            let mut endpoints = Vec::<Box<dyn Endpoint>>::new();
+
+            let configs: Vec<$public_config> = $config
+                .config
+                .convert_to_typed_array($type_name)
+                .map_err(|err| Error::ConfigDeserialization(err.into()))?;
+
+            for config in configs {
+                endpoints.push(Box::new($endpoint_type { config }));
+            }
+
+            Ok(endpoints)
+        })()
+    };
+}
+
+impl Bus {
+    /// Instantiate notification bus from a given configuration.
+    pub fn from_config(config: &Config) -> Result<Self, Error> {
+        let mut endpoints = HashMap::new();
+
+        // Instantiate endpoints
+        endpoints.extend(
+            parse_endpoints_without_private_config!(
+                config,
+                SendmailConfig,
+                SendmailEndpoint,
+                SENDMAIL_TYPENAME
+            )?
+            .into_iter()
+            .map(|e| (e.name().into(), e)),
+        );
+
+        endpoints.extend(
+            parse_endpoints_with_private_config!(
+                config,
+                GotifyConfig,
+                GotifyPrivateConfig,
+                GotifyEndpoint,
+                GOTIFY_TYPENAME
+            )?
+            .into_iter()
+            .map(|e| (e.name().into(), e)),
+        );
+
+        endpoints.extend(
+            parse_endpoints_with_private_config!(
+                config,
+                SmtpConfig,
+                SmtpPrivateConfig,
+                SmtpEndpoint,
+                SMTP_TYPENAME
+            )?
+            .into_iter()
+            .map(|e| (e.name().into(), e)),
+        );
+
+        endpoints.extend(
+            parse_endpoints_with_private_config!(
+                config,
+                WebhookConfig,
+                WebhookPrivateConfig,
+                WebhookEndpoint,
+                WEBHOOK_TYPENAME
+            )?
+            .into_iter()
+            .map(|e| (e.name().into(), e)),
+        );
+
+        let matchers = config
+            .config
+            .convert_to_typed_array(MATCHER_TYPENAME)
+            .map_err(|err| Error::ConfigDeserialization(err.into()))?;
+
+        Ok(Bus {
+            endpoints,
+            matchers,
+        })
+    }
+
+    #[cfg(test)]
+    pub(crate) fn add_endpoint(&mut self, endpoint: Box<dyn Endpoint>) {
+        self.endpoints.insert(endpoint.name().to_string(), endpoint);
+    }
+
+    #[cfg(test)]
+    pub(crate) fn add_matcher(&mut self, filter: MatcherConfig) {
+        self.matchers.push(filter)
+    }
+
+    /// Send a notification. Notification matchers will determine which targets will receive
+    /// the notification.
+    ///
+    /// Any errors will not be returned but only logged.
+    pub fn send(&self, context: &Context, notification: &Notification) {
+        let targets = crate::api_types::check_matches(self.matchers.as_slice(), notification);
+
+        for target in targets {
+            if let Some(endpoint) = self.endpoints.get(target) {
+                let name = endpoint.name();
+
+                if endpoint.disabled() {
+                    // Skip this target if it is disabled
+                    info!("skipping disabled target '{name}'");
+                    continue;
+                }
+
+                match endpoint.send(context, notification) {
+                    Ok(_) => {
+                        info!("notified via target `{name}`");
+                    }
+                    Err(e) => {
+                        // Only log on errors, do not propagate fail to the caller.
+                        error!("could not notify via target `{name}`: {e}");
+                    }
+                }
+            } else {
+                error!("could not notify via target '{target}', it does not exist");
+            }
+        }
+    }
+
+    /// Send a test notification to a target (endpoint or group).
+    ///
+    /// In contrast to the `send` function, this function will return
+    /// any errors to the caller.
+    pub fn test_target(&self, context: &Context, target: &str) -> Result<(), Error> {
+        let notification = Notification {
+            metadata: Metadata {
+                severity: Severity::Info,
+                // TODO: what fields would make sense for test notifications?
+                additional_fields: Default::default(),
+                timestamp: proxmox_time::epoch_i64(),
+            },
+            content: Content::Template {
+                template_name: "test".to_string(),
+                data: json!({ "target": target }),
+            },
+            id: Uuid::generate(),
+        };
+
+        if let Some(endpoint) = self.endpoints.get(target) {
+            endpoint.send(context, &notification)?;
+        } else {
+            return Err(Error::target_does_not_exist(target));
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{cell::RefCell, rc::Rc};
+
+    use proxmox_match_expression::Expression;
+
+    use crate::{
+        api_types::{expression::NotificationMatcher, severity::SeverityMatcher},
+        context::{Context, test},
+    };
+
+    use super::*;
+
+    #[derive(Default, Clone)]
+    struct MockEndpoint {
+        name: &'static str,
+        // Needs to be an Rc so that we can clone MockEndpoint before
+        // passing it to Bus, while still retaining a handle to the Vec
+        messages: Rc<RefCell<Vec<Notification>>>,
+    }
+
+    impl Endpoint for MockEndpoint {
+        fn send(&self, _context: &Context, message: &Notification) -> Result<(), Error> {
+            self.messages.borrow_mut().push(message.clone());
+
+            Ok(())
+        }
+
+        fn name(&self) -> &str {
+            self.name
+        }
+
+        fn disabled(&self) -> bool {
+            false
+        }
+    }
+
+    impl MockEndpoint {
+        fn new(name: &'static str) -> Self {
+            Self {
+                name,
+                ..Default::default()
+            }
+        }
+
+        fn messages(&self) -> Vec<Notification> {
+            self.messages.borrow().clone()
+        }
+    }
+
+    fn expression_to_string(expression: Expression<NotificationMatcher>) -> String {
+        serde_json::to_string(&expression).unwrap()
+    }
+
+    #[test]
+    fn test_add_mock_endpoint() -> Result<(), Error> {
+        let context = test::test_context();
+        let mock = MockEndpoint::new("endpoint");
+
+        let mut bus = Bus::default();
+        bus.add_endpoint(Box::new(mock.clone()));
+
+        let matcher = MatcherConfig {
+            target: vec!["endpoint".into()],
+            expression: Some(expression_to_string(Expression::Constant(true))),
+            ..Default::default()
+        };
+
+        bus.add_matcher(matcher);
+
+        // Send directly to endpoint
+        bus.send(
+            &context,
+            &Notification::from_template(
+                Severity::Info,
+                "test",
+                Default::default(),
+                Default::default(),
+            ),
+        );
+        let messages = mock.messages();
+        assert_eq!(messages.len(), 1);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_multiple_endpoints_with_different_matchers() -> Result<(), Error> {
+        let context = test::test_context();
+
+        let endpoint1 = MockEndpoint::new("mock1");
+        let endpoint2 = MockEndpoint::new("mock2");
+
+        let mut bus = Bus::default();
+
+        bus.add_endpoint(Box::new(endpoint1.clone()));
+        bus.add_endpoint(Box::new(endpoint2.clone()));
+
+        bus.add_matcher(MatcherConfig {
+            name: "matcher1".into(),
+            expression: Some(expression_to_string(
+                SeverityMatcher {
+                    severities: vec![Severity::Error, Severity::Warning],
+                }
+                .into(),
+            )),
+            target: vec!["mock1".into()],
+            ..Default::default()
+        });
+
+        bus.add_matcher(MatcherConfig {
+            name: "matcher2".into(),
+            expression: Some(expression_to_string(
+                SeverityMatcher {
+                    severities: vec![Severity::Error],
+                }
+                .into(),
+            )),
+            target: vec!["mock2".into()],
+            ..Default::default()
+        });
+
+        let send_with_severity = |severity| {
+            let notification = Notification::from_template(
+                severity,
+                "test",
+                Default::default(),
+                Default::default(),
+            );
+
+            bus.send(&context, &notification);
+        };
+
+        send_with_severity(Severity::Info);
+        assert_eq!(endpoint1.messages().len(), 0);
+        assert_eq!(endpoint2.messages().len(), 0);
+
+        send_with_severity(Severity::Warning);
+        assert_eq!(endpoint1.messages().len(), 1);
+        assert_eq!(endpoint2.messages().len(), 0);
+
+        send_with_severity(Severity::Error);
+        assert_eq!(endpoint1.messages().len(), 2);
+        assert_eq!(endpoint2.messages().len(), 1);
+
+        Ok(())
+    }
+}
-- 
2.47.3





  parent reply	other threads:[~2026-11-18  9:50 UTC|newest]

Thread overview: 66+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-18  9:42 [PATCH many v2 00/63] notify: maintenance, PDM preparations, queue + worker Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 01/63] notify: disallow `unsafe` code Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 02/63] notify: refactor error type Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 03/63] notify: move `Endpoint` trait to endpoint module as pub(crate) Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 04/63] notify: use ConfigDigest instead of raw byte arrays Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 05/63] notify: remove static context and pass context as parameter Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 06/63] notify: matcher: drop unused field matcher verifiers Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 07/63] notify: introduce 'send-impl', 'api-impl' and 'api-types' features Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 08/63] notify: matcher: make matcher validation methods public Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 09/63] notify: matcher: stub CalendarMatcher::matches on wasm32 Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 10/63] notify: make SendmailEndpoint and SmtpEndpoint private types Lukas Wagner
2026-11-18  9:42 ` Lukas Wagner [this message]
2026-11-18  9:42 ` [PATCH proxmox v2 12/63] notify: move Origin type to api_types module Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 13/63] notify: move Target " Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 14/63] notify: move Config to config module Lukas Wagner
2026-11-18  9:42 ` [PATCH proxmox v2 15/63] notify: move Notification and sub-types to `notification` module Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 16/63] notify: move schema module to api_types Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 17/63] notify: move check_matches from api_types::matcher to send::Bus Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 18/63] notify: move TemplateSource to context module Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 19/63] notify: config: cleanup helper names and visibility Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 20/63] notify: config: rename section config parser/writer methods Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 21/63] notify: config: pass builtins explicitly when parsing section config Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 22/63] notify: implement PartialEq for all Config types Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 23/63] notify: use typed SectionConfigData Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 24/63] notify: api: api types: rename Deleteable* -> Deletable* Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 25/63] notify: context: parse builtin config only once Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 26/63] notify: context: parse proxy config in trait impl, not at the callsite Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 27/63] notify: gate sub-modules with the appropriate feature flags Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 28/63] notify: fold mail-forwarder feature into send-impl Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 29/63] notify: forwarded mails: don't hardcode severity and metadata fields Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 30/63] notify: don't pass uid when instantiating forwarded mail notifications Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 31/63] notify: derive PartialEq for Notification type Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 32/63] notify: add getters for severity and fields on " Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 33/63] notify: add test suite for " Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 34/63] notify: serialize raw, forwarded mail content as base64 Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 35/63] notify: unify code paths for legacy-sendmail and regular notifications Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 36/63] notify: add backwards-compat note to Notification type Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 37/63] notify: remove 'test_target' API Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 38/63] notify: replace notification instantiation with builder pattern Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 39/63] notify: add send receipts Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 40/63] notify: make sure that template name matches SAFE_ID_REGEX Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 41/63] notify: implement notification queue submitter Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 42/63] notify: context: add read_config Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 43/63] notify: queue: add queue consumer Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 44/63] notify: queue: add worker task Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-backup v2 45/63] notifications: don't ignore verification errors in legacy-sendmail mode Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-backup v2 46/63] notifications: adapt to proxmox-notify API changes Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-backup v2 47/63] api: notification: send test notification via proxmox_notify::send Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-backup v2 48/63] notifications: send all notifications via proxmox-notify's queue Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-perl-rs v2 49/63] pve: notify: adapt to changes in the public API of proxmox-notify Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-perl-rs v2 50/63] pve: notify: add `PVE::RS::Notify::enqueue` method Lukas Wagner
2026-11-18  9:43 ` [PATCH pve-cluster v2 51/63] notify: send notifications via notification queue Lukas Wagner
2026-11-18  9:43 ` [PATCH manager v2 52/63] vzdump: send legacy-sendmail notifications via simplified API Lukas Wagner
2026-11-18  9:43 ` [PATCH manager v2 53/63] debian: create notification queue directory via tmpfiles Lukas Wagner
2026-11-18  9:43 ` [PATCH manager v2 54/63] debian: add 'pve-notify-worker' as dependecy Lukas Wagner
2026-11-18  9:43 ` [PATCH manager v2 55/63] api: services: add 'pve-notify-worker' as known service Lukas Wagner
2026-11-18  9:43 ` [PATCH manager v2 56/63] services: request pve-notify-worker.service via Wants Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-mail-forward v2 57/63] forward mails via notification queue Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-mail-forward v2 58/63] use return code to signal permanent or temporary failure Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-mail-forward v2 59/63] limit size of mail read from stdin Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-mail-forward v2 60/63] cargo: move mail forwarder into a workspace member crate Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-mail-forward v2 61/63] add crate for code shared between the mail-forwarder and the worker Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-mail-forward v2 62/63] add pve-notify-worker crate and package Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox-mail-forward v2 63/63] debian: add versioned break for pve-manager and proxmox-backup-server Lukas Wagner
2026-11-18 21:44 ` [PATCH many v2 00/63] notify: maintenance, PDM preparations, queue + worker Thomas Lamprecht
2026-11-19 10:45   ` Lukas Wagner

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261118094348.273646-12-l.wagner@proxmox.com \
    --to=l.wagner@proxmox.com \
    --cc=pve-devel@lists.proxmox.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
Service provided by Proxmox Server Solutions GmbH | Privacy | Legal