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 22/55] notify: use typed SectionConfigData
Date: Fri, 13 Nov 2026 16:07:55 +0100	[thread overview]
Message-ID: <20261113150828.756836-23-l.wagner@proxmox.com> (raw)
In-Reply-To: <20261113150828.756836-1-l.wagner@proxmox.com>

This allows us to simplify working with the config quite a bit. Added a
config-parsing roundtrip test while at it.

Signed-off-by: Lukas Wagner <l.wagner@proxmox.com>
---
 proxmox-notify/Cargo.toml                     |   3 +
 proxmox-notify/src/api/gotify.rs              | 103 ++---
 proxmox-notify/src/api/matcher.rs             |  54 +--
 proxmox-notify/src/api/mod.rs                 |  41 +-
 proxmox-notify/src/api/sendmail.rs            |  49 +--
 proxmox-notify/src/api/smtp.rs                |  93 ++---
 proxmox-notify/src/api/webhook.rs             | 147 +++----
 proxmox-notify/src/config.rs                  | 393 +++++++++++-------
 proxmox-notify/src/send.rs                    | 183 ++++----
 .../testdata/notifications-priv.cfg.ref       |   8 +
 proxmox-notify/testdata/notifications.cfg.ref |  29 ++
 11 files changed, 540 insertions(+), 563 deletions(-)
 create mode 100644 proxmox-notify/testdata/notifications-priv.cfg.ref
 create mode 100644 proxmox-notify/testdata/notifications.cfg.ref

diff --git a/proxmox-notify/Cargo.toml b/proxmox-notify/Cargo.toml
index 6bb4871f7..5f7ea3176 100644
--- a/proxmox-notify/Cargo.toml
+++ b/proxmox-notify/Cargo.toml
@@ -40,6 +40,9 @@ proxmox-sys = { workspace = true, optional = true }
 proxmox-time.workspace = true
 proxmox-uuid = { workspace = true, features = ["serde"] }
 
+[dev-dependencies]
+pretty_assertions.workspace = true
+
 [features]
 default = ["send-impl", "api-types"]
 api-impl = [
diff --git a/proxmox-notify/src/api/gotify.rs b/proxmox-notify/src/api/gotify.rs
index e0f7cf16b..e4ac46328 100644
--- a/proxmox-notify/src/api/gotify.rs
+++ b/proxmox-notify/src/api/gotify.rs
@@ -1,12 +1,14 @@
 use proxmox_config_digest::ConfigDigest;
 use proxmox_http_error::HttpError;
+use proxmox_section_config::typed::{convert_to_typed_array, lookup};
 
 use crate::Config;
 use crate::api::http_err;
 use crate::api_types::{
-    DeleteableGotifyProperty, GOTIFY_TYPENAME, GotifyConfig, GotifyConfigUpdater,
-    GotifyPrivateConfig, GotifyPrivateConfigUpdater,
+    DeleteableGotifyProperty, GotifyConfig, GotifyConfigUpdater, GotifyPrivateConfig,
+    GotifyPrivateConfigUpdater,
 };
+use crate::config::{ConfigEntity, PrivateConfigEntity};
 
 /// Get a list of all gotify endpoints.
 ///
@@ -14,10 +16,10 @@ use crate::api_types::{
 /// Returns a list of all gotify endpoints or a `HttpError` if the config is
 /// erroneous (`500 Internal server error`).
 pub fn get_endpoints(config: &Config) -> Result<Vec<GotifyConfig>, HttpError> {
-    config
-        .config
-        .convert_to_typed_array(GOTIFY_TYPENAME)
-        .map_err(|e| http_err!(NOT_FOUND, "Could not fetch endpoints: {e}"))
+    Ok(convert_to_typed_array!(config.config, ConfigEntity::Gotify)
+        .into_iter()
+        .cloned()
+        .collect())
 }
 
 /// Get gotify endpoint with given `name`
@@ -25,10 +27,9 @@ pub fn get_endpoints(config: &Config) -> Result<Vec<GotifyConfig>, HttpError> {
 /// The caller is responsible for any needed permission checks.
 /// Returns the endpoint or a `HttpError` if the endpoint was not found (`404 Not found`).
 pub fn get_endpoint(config: &Config, name: &str) -> Result<GotifyConfig, HttpError> {
-    config
-        .config
-        .lookup(GOTIFY_TYPENAME, name)
-        .map_err(|_| http_err!(NOT_FOUND, "endpoint '{name}' not found"))
+    lookup!(config.config, name, ConfigEntity::Gotify)
+        .cloned()
+        .ok_or_else(|| http_err!(NOT_FOUND, "endpoint '{name}' not found"))
 }
 
 /// Add a new gotify endpoint.
@@ -52,18 +53,17 @@ pub fn add_endpoint(
 
     super::ensure_unique(config, &endpoint_config.name)?;
 
-    set_private_config_entry(config, &private_endpoint_config)?;
+    config.private_config.insert(
+        private_endpoint_config.name.clone(),
+        PrivateConfigEntity::Gotify(private_endpoint_config),
+    );
 
-    config
-        .config
-        .set_data(&endpoint_config.name, GOTIFY_TYPENAME, &endpoint_config)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save endpoint '{}': {e}",
-                endpoint_config.name
-            )
-        })
+    config.config.insert(
+        endpoint_config.name.clone(),
+        ConfigEntity::Gotify(endpoint_config),
+    );
+
+    Ok(())
 }
 
 /// Update existing gotify endpoint
@@ -99,13 +99,13 @@ pub fn update_endpoint(
     }
 
     if let Some(token) = private_endpoint_config_updater.token {
-        set_private_config_entry(
-            config,
-            &GotifyPrivateConfig {
+        config.private_config.insert(
+            name,
+            PrivateConfigEntity::Gotify(GotifyPrivateConfig {
                 name: name.into(),
                 token,
-            },
-        )?;
+            }),
+        );
     }
 
     if let Some(comment) = endpoint_config_updater.comment {
@@ -116,15 +116,9 @@ pub fn update_endpoint(
         endpoint.disable = Some(disable);
     }
 
-    config
-        .config
-        .set_data(name, GOTIFY_TYPENAME, &endpoint)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save endpoint '{name}': {e}"
-            )
-        })
+    config.config.insert(name, ConfigEntity::Gotify(endpoint));
+
+    Ok(())
 }
 
 /// Delete existing gotify endpoint
@@ -139,33 +133,12 @@ pub fn delete_gotify_endpoint(config: &mut Config, name: &str) -> Result<(), Htt
     let _ = get_endpoint(config, name)?;
     super::ensure_safe_to_delete(config, name)?;
 
-    remove_private_config_entry(config, name)?;
-    config.config.sections.remove(name);
+    config.private_config.remove(name);
+    config.config.remove(name);
 
     Ok(())
 }
 
-fn set_private_config_entry(
-    config: &mut Config,
-    private_config: &GotifyPrivateConfig,
-) -> Result<(), HttpError> {
-    config
-        .private_config
-        .set_data(&private_config.name, GOTIFY_TYPENAME, private_config)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save private config for endpoint '{}': {e}",
-                private_config.name
-            )
-        })
-}
-
-fn remove_private_config_entry(config: &mut Config, name: &str) -> Result<(), HttpError> {
-    config.private_config.sections.remove(name);
-    Ok(())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -255,13 +228,15 @@ mod tests {
 
         assert_eq!(endpoint.server, "newhost".to_string());
 
-        let token = config
-            .private_config
-            .lookup::<GotifyPrivateConfig>(GOTIFY_TYPENAME, "gotify-endpoint")
-            .unwrap()
-            .token;
+        let token = &lookup!(
+            config.private_config,
+            "gotify-endpoint",
+            PrivateConfigEntity::Gotify
+        )
+        .unwrap()
+        .token;
 
-        assert_eq!(token, "changedtoken".to_string());
+        assert_eq!(token, "changedtoken");
         assert_eq!(endpoint.comment, Some("newcomment".to_string()));
 
         // Test property deletion
diff --git a/proxmox-notify/src/api/matcher.rs b/proxmox-notify/src/api/matcher.rs
index f8bc06a9a..cdb66f368 100644
--- a/proxmox-notify/src/api/matcher.rs
+++ b/proxmox-notify/src/api/matcher.rs
@@ -1,11 +1,11 @@
 use proxmox_config_digest::ConfigDigest;
 use proxmox_http_error::HttpError;
+use proxmox_section_config::typed::{convert_to_typed_array, lookup};
 
 use crate::Config;
 use crate::api::http_err;
-use crate::api_types::{
-    DeleteableMatcherProperty, MATCHER_TYPENAME, MatcherConfig, MatcherConfigUpdater,
-};
+use crate::api_types::{DeleteableMatcherProperty, MatcherConfig, MatcherConfigUpdater};
+use crate::config::ConfigEntity;
 
 /// Get a list of all matchers
 ///
@@ -13,10 +13,12 @@ use crate::api_types::{
 /// Returns a list of all matchers or a `HttpError` if the config is
 /// (`500 Internal server error`).
 pub fn get_matchers(config: &Config) -> Result<Vec<MatcherConfig>, HttpError> {
-    config
-        .config
-        .convert_to_typed_array(MATCHER_TYPENAME)
-        .map_err(|e| http_err!(INTERNAL_SERVER_ERROR, "Could not fetch matchers: {e}"))
+    Ok(
+        convert_to_typed_array!(config.config, ConfigEntity::Matcher)
+            .into_iter()
+            .cloned()
+            .collect(),
+    )
 }
 
 /// Get matcher with given `name`
@@ -24,10 +26,9 @@ pub fn get_matchers(config: &Config) -> Result<Vec<MatcherConfig>, HttpError> {
 /// The caller is responsible for any needed permission checks.
 /// Returns the endpoint or a `HttpError` if the matcher was not found (`404 Not found`).
 pub fn get_matcher(config: &Config, name: &str) -> Result<MatcherConfig, HttpError> {
-    config
-        .config
-        .lookup(MATCHER_TYPENAME, name)
-        .map_err(|_| http_err!(NOT_FOUND, "matcher '{name}' not found"))
+    lookup!(config.config, name, ConfigEntity::Matcher)
+        .cloned()
+        .ok_or_else(|| http_err!(NOT_FOUND, "matcher '{name}' not found"))
 }
 
 /// Get matcher with given `name`, translating any existing 'match-*' keys into an
@@ -37,10 +38,7 @@ pub fn get_matcher(config: &Config, name: &str) -> Result<MatcherConfig, HttpErr
 /// Returns the endpoint or a `HttpError` if the matcher was not found (`404 Not found`).
 #[cfg(feature = "legacy-matchers")]
 pub fn get_matcher_as_expression(config: &Config, name: &str) -> Result<MatcherConfig, HttpError> {
-    let mut matcher: MatcherConfig = config
-        .config
-        .lookup(MATCHER_TYPENAME, name)
-        .map_err(|_| http_err!(NOT_FOUND, "matcher '{name}' not found"))?;
+    let mut matcher = get_matcher(config, name)?;
 
     if matcher.expression.is_none() {
         let expression = matcher.generate_expression_from_legacy_config();
@@ -80,16 +78,10 @@ pub fn add_matcher(
         .ensure_valid()
         .map_err(|err| http_err!(BAD_REQUEST, "invalid matcher config: {err}"))?;
 
-    config
-        .config
-        .set_data(&matcher_config.name, MATCHER_TYPENAME, &matcher_config)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save matcher '{}': {e}",
-                matcher_config.name
-            )
-        })?;
+    config.config.insert(
+        matcher_config.name.clone(),
+        ConfigEntity::Matcher(matcher_config),
+    );
 
     Ok(())
 }
@@ -176,15 +168,7 @@ pub fn update_matcher(
         .ensure_valid()
         .map_err(|err| http_err!(BAD_REQUEST, "invalid matcher config: {err}"))?;
 
-    config
-        .config
-        .set_data(name, MATCHER_TYPENAME, &matcher)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save matcher '{name}': {e}"
-            )
-        })?;
+    config.config.insert(name, ConfigEntity::Matcher(matcher));
 
     Ok(())
 }
@@ -199,7 +183,7 @@ pub fn delete_matcher(config: &mut Config, name: &str) -> Result<(), HttpError>
     // Check if the matcher exists
     let _ = get_matcher(config, name)?;
 
-    config.config.sections.remove(name);
+    config.config.remove(name);
 
     Ok(())
 }
diff --git a/proxmox-notify/src/api/mod.rs b/proxmox-notify/src/api/mod.rs
index b5b05e86f..5232098b4 100644
--- a/proxmox-notify/src/api/mod.rs
+++ b/proxmox-notify/src/api/mod.rs
@@ -1,12 +1,11 @@
 use std::collections::HashSet;
 
 use proxmox_config_digest::ConfigDigest;
-use serde::{Deserialize, Serialize};
-
 use proxmox_http_error::HttpError;
 
 use crate::Config;
 use crate::api_types::{EndpointType, Origin, Target};
+use crate::config::ConfigEntity;
 
 pub mod common;
 pub mod gotify;
@@ -124,7 +123,7 @@ fn ensure_endpoints_exist<T: AsRef<str>>(
 }
 
 fn ensure_unique(config: &Config, entity: &str) -> Result<(), HttpError> {
-    if config.config.sections.contains_key(entity) {
+    if config.config.contains_key(entity) {
         http_bail!(
             BAD_REQUEST,
             "Cannot create '{entity}', an entity with the same name already exists"
@@ -147,14 +146,11 @@ fn get_referrers(config: &Config, entity: &str) -> Result<HashSet<String>, HttpE
 }
 
 fn ensure_safe_to_delete(config: &Config, entity: &str) -> Result<(), HttpError> {
-    if let Some(entity_config) = config.config.sections.get(entity) {
-        if let Ok(origin) = Origin::deserialize(&entity_config.1["origin"]) {
-            // Built-ins are never actually removed, only reset to their default
-            // It is thus safe to do the reset if another entity depends
-            // on it
-            if origin == Origin::Builtin || origin == Origin::ModifiedBuiltin {
-                return Ok(());
-            }
+    if let Some(entity_config) = config.config.get(entity) {
+        let origin = entity_config.origin().unwrap_or(Origin::UserCreated);
+
+        if origin == Origin::Builtin || origin == Origin::ModifiedBuiltin {
+            return Ok(());
         }
     } else {
         http_bail!(NOT_FOUND, "entity '{entity}' does not exist");
@@ -202,29 +198,6 @@ fn get_referenced_entities(config: &Config, entity: &str) -> HashSet<String> {
     expanded
 }
 
-fn set_private_config_entry<T: Serialize>(
-    config: &mut Config,
-    private_config: T,
-    typename: &str,
-    name: &str,
-) -> Result<(), HttpError> {
-    config
-        .private_config
-        .set_data(name, typename, &private_config)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save private config for endpoint '{}': {e}",
-                name
-            )
-        })
-}
-
-fn remove_private_config_entry(config: &mut Config, name: &str) -> Result<(), HttpError> {
-    config.private_config.sections.remove(name);
-    Ok(())
-}
-
 #[cfg(test)]
 mod test_helpers {
     use crate::Config;
diff --git a/proxmox-notify/src/api/sendmail.rs b/proxmox-notify/src/api/sendmail.rs
index cff63b806..1d429c8f8 100644
--- a/proxmox-notify/src/api/sendmail.rs
+++ b/proxmox-notify/src/api/sendmail.rs
@@ -1,11 +1,11 @@
 use proxmox_config_digest::ConfigDigest;
 use proxmox_http_error::HttpError;
+use proxmox_section_config::typed::{convert_to_typed_array, lookup};
 
 use crate::Config;
 use crate::api::{http_bail, http_err};
-use crate::api_types::{
-    DeleteableSendmailProperty, SENDMAIL_TYPENAME, SendmailConfig, SendmailConfigUpdater,
-};
+use crate::api_types::{DeleteableSendmailProperty, SendmailConfig, SendmailConfigUpdater};
+use crate::config::ConfigEntity;
 
 /// Get a list of all sendmail endpoints.
 ///
@@ -13,10 +13,12 @@ use crate::api_types::{
 /// Returns a list of all sendmail endpoints or a `HttpError` if the config is
 /// erroneous (`500 Internal server error`).
 pub fn get_endpoints(config: &Config) -> Result<Vec<SendmailConfig>, HttpError> {
-    config
-        .config
-        .convert_to_typed_array(SENDMAIL_TYPENAME)
-        .map_err(|e| http_err!(NOT_FOUND, "Could not fetch endpoints: {e}"))
+    Ok(
+        convert_to_typed_array!(config.config, ConfigEntity::Sendmail)
+            .into_iter()
+            .cloned()
+            .collect(),
+    )
 }
 
 /// Get sendmail endpoint with given `name`.
@@ -24,10 +26,9 @@ pub fn get_endpoints(config: &Config) -> Result<Vec<SendmailConfig>, HttpError>
 /// The caller is responsible for any needed permission checks.
 /// Returns the endpoint or a `HttpError` if the endpoint was not found (`404 Not found`).
 pub fn get_endpoint(config: &Config, name: &str) -> Result<SendmailConfig, HttpError> {
-    config
-        .config
-        .lookup(SENDMAIL_TYPENAME, name)
-        .map_err(|_| http_err!(NOT_FOUND, "endpoint '{name}' not found"))
+    lookup!(config.config, name, ConfigEntity::Sendmail)
+        .cloned()
+        .ok_or_else(|| http_err!(NOT_FOUND, "endpoint '{name}' not found"))
 }
 
 /// Add a new sendmail endpoint.
@@ -50,14 +51,9 @@ pub fn add_endpoint(config: &mut Config, endpoint: SendmailConfig) -> Result<(),
 
     config
         .config
-        .set_data(&endpoint.name, SENDMAIL_TYPENAME, &endpoint)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save endpoint '{}': {e}",
-                endpoint.name
-            )
-        })
+        .insert(endpoint.name.clone(), ConfigEntity::Sendmail(endpoint));
+
+    Ok(())
 }
 
 /// Update existing sendmail endpoint
@@ -122,16 +118,9 @@ pub fn update_endpoint(
         );
     }
 
-    config
-        .config
-        .set_data(name, SENDMAIL_TYPENAME, &endpoint)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save endpoint '{}': {e}",
-                endpoint.name
-            )
-        })
+    config.config.insert(name, ConfigEntity::Sendmail(endpoint));
+
+    Ok(())
 }
 
 /// Delete existing sendmail endpoint
@@ -147,7 +136,7 @@ pub fn delete_endpoint(config: &mut Config, name: &str) -> Result<(), HttpError>
     let _ = get_endpoint(config, name)?;
     super::ensure_safe_to_delete(config, name)?;
 
-    config.config.sections.remove(name);
+    config.config.remove(name);
 
     Ok(())
 }
diff --git a/proxmox-notify/src/api/smtp.rs b/proxmox-notify/src/api/smtp.rs
index ceae77df3..30df66d21 100644
--- a/proxmox-notify/src/api/smtp.rs
+++ b/proxmox-notify/src/api/smtp.rs
@@ -1,12 +1,14 @@
 use proxmox_config_digest::ConfigDigest;
 use proxmox_http_error::HttpError;
+use proxmox_section_config::typed::{convert_to_typed_array, lookup};
 
 use crate::Config;
 use crate::api::{http_bail, http_err};
 use crate::api_types::{
-    DeleteableSmtpProperty, SMTP_TYPENAME, SmtpConfig, SmtpConfigUpdater, SmtpPrivateConfig,
+    DeleteableSmtpProperty, SmtpConfig, SmtpConfigUpdater, SmtpPrivateConfig,
     SmtpPrivateConfigUpdater,
 };
+use crate::config::{ConfigEntity, PrivateConfigEntity};
 
 /// Get a list of all smtp endpoints.
 ///
@@ -14,10 +16,10 @@ use crate::api_types::{
 /// Returns a list of all smtp endpoints or a `HttpError` if the config is
 /// erroneous (`500 Internal server error`).
 pub fn get_endpoints(config: &Config) -> Result<Vec<SmtpConfig>, HttpError> {
-    config
-        .config
-        .convert_to_typed_array(SMTP_TYPENAME)
-        .map_err(|e| http_err!(NOT_FOUND, "Could not fetch endpoints: {e}"))
+    Ok(convert_to_typed_array!(config.config, ConfigEntity::Smtp)
+        .into_iter()
+        .cloned()
+        .collect())
 }
 
 /// Get smtp endpoint with given `name`.
@@ -25,10 +27,9 @@ pub fn get_endpoints(config: &Config) -> Result<Vec<SmtpConfig>, HttpError> {
 /// The caller is responsible for any needed permission checks.
 /// Returns the endpoint or a `HttpError` if the endpoint was not found (`404 Not found`).
 pub fn get_endpoint(config: &Config, name: &str) -> Result<SmtpConfig, HttpError> {
-    config
-        .config
-        .lookup(SMTP_TYPENAME, name)
-        .map_err(|_| http_err!(NOT_FOUND, "endpoint '{name}' not found"))
+    lookup!(config.config, name, ConfigEntity::Smtp)
+        .cloned()
+        .ok_or_else(|| http_err!(NOT_FOUND, "endpoint '{name}' not found"))
 }
 
 /// Add a new smtp endpoint.
@@ -58,23 +59,17 @@ pub fn add_endpoint(
         );
     }
 
-    super::set_private_config_entry(
-        config,
-        private_endpoint_config,
-        SMTP_TYPENAME,
-        &endpoint_config.name,
-    )?;
+    config.private_config.insert(
+        private_endpoint_config.name.clone(),
+        PrivateConfigEntity::Smtp(private_endpoint_config),
+    );
 
-    config
-        .config
-        .set_data(&endpoint_config.name, SMTP_TYPENAME, &endpoint_config)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save endpoint '{}': {e}",
-                endpoint_config.name
-            )
-        })
+    config.config.insert(
+        endpoint_config.name.clone(),
+        ConfigEntity::Smtp(endpoint_config),
+    );
+
+    Ok(())
 }
 
 /// Update existing smtp endpoint
@@ -104,15 +99,15 @@ pub fn update_endpoint(
                 DeleteableSmtpProperty::Disable => endpoint.disable = None,
                 DeleteableSmtpProperty::Mailto => endpoint.mailto.clear(),
                 DeleteableSmtpProperty::MailtoUser => endpoint.mailto_user.clear(),
-                DeleteableSmtpProperty::Password => super::set_private_config_entry(
-                    config,
-                    SmtpPrivateConfig {
-                        name: name.to_string(),
-                        password: None,
-                    },
-                    SMTP_TYPENAME,
-                    name,
-                )?,
+                DeleteableSmtpProperty::Password => {
+                    config.private_config.insert(
+                        name,
+                        PrivateConfigEntity::Smtp(SmtpPrivateConfig {
+                            name: name.into(),
+                            password: None,
+                        }),
+                    );
+                }
                 DeleteableSmtpProperty::Port => endpoint.port = None,
                 DeleteableSmtpProperty::Username => endpoint.username = None,
             }
@@ -141,15 +136,13 @@ pub fn update_endpoint(
         endpoint.mode = Some(mode);
     }
     if let Some(password) = private_endpoint_config_updater.password {
-        super::set_private_config_entry(
-            config,
-            SmtpPrivateConfig {
+        config.private_config.insert(
+            name,
+            PrivateConfigEntity::Smtp(SmtpPrivateConfig {
                 name: name.into(),
                 password: Some(password),
-            },
-            SMTP_TYPENAME,
-            name,
-        )?;
+            }),
+        );
     }
 
     if let Some(author) = updater.author {
@@ -171,16 +164,9 @@ pub fn update_endpoint(
         );
     }
 
-    config
-        .config
-        .set_data(name, SMTP_TYPENAME, &endpoint)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save endpoint '{}': {e}",
-                endpoint.name
-            )
-        })
+    config.config.insert(name, ConfigEntity::Smtp(endpoint));
+
+    Ok(())
 }
 
 /// Delete existing smtp endpoint
@@ -195,8 +181,9 @@ pub fn delete_endpoint(config: &mut Config, name: &str) -> Result<(), HttpError>
     let _ = get_endpoint(config, name)?;
     super::ensure_safe_to_delete(config, name)?;
 
-    super::remove_private_config_entry(config, name)?;
-    config.config.sections.remove(name);
+    config.private_config.remove(name);
+
+    config.config.remove(name);
 
     Ok(())
 }
diff --git a/proxmox-notify/src/api/webhook.rs b/proxmox-notify/src/api/webhook.rs
index 7266faca6..beaa26f15 100644
--- a/proxmox-notify/src/api/webhook.rs
+++ b/proxmox-notify/src/api/webhook.rs
@@ -5,37 +5,38 @@
 use proxmox_config_digest::ConfigDigest;
 use proxmox_http_error::HttpError;
 use proxmox_schema::property_string::PropertyString;
+use proxmox_section_config::typed::{convert_to_typed_array, lookup};
 
 use crate::api::http_err;
 use crate::api_types::{
-    DeleteableWebhookProperty, KeyAndBase64Val, WEBHOOK_TYPENAME, WebhookConfig,
-    WebhookConfigUpdater, WebhookPrivateConfig,
+    DeleteableWebhookProperty, KeyAndBase64Val, WebhookConfig, WebhookConfigUpdater,
+    WebhookPrivateConfig,
 };
+use crate::config::{ConfigEntity, PrivateConfigEntity};
 use crate::{Config, http_bail};
 
-use super::remove_private_config_entry;
-use super::set_private_config_entry;
-
 /// Get a list of all webhook endpoints.
 ///
 /// The caller is responsible for any needed permission checks.
 /// Returns a list of all webhook endpoints or a [`HttpError`] if the config is
 /// erroneous (`500 Internal server error`).
 pub fn get_endpoints(config: &Config) -> Result<Vec<WebhookConfig>, HttpError> {
-    let mut endpoints: Vec<WebhookConfig> = config
-        .config
-        .convert_to_typed_array(WEBHOOK_TYPENAME)
-        .map_err(|e| http_err!(NOT_FOUND, "Could not fetch endpoints: {e}"))?;
+    let mut endpoints: Vec<WebhookConfig> =
+        convert_to_typed_array!(config.config, ConfigEntity::Webhook)
+            .into_iter()
+            .cloned()
+            .collect();
 
     for endpoint in &mut endpoints {
-        let priv_config: WebhookPrivateConfig = config
-            .private_config
-            .lookup(WEBHOOK_TYPENAME, &endpoint.name)
-            .unwrap_or_default();
+        let priv_config = lookup!(
+            config.private_config,
+            &endpoint.name,
+            PrivateConfigEntity::Webhook
+        );
 
         let mut secret_names = Vec::new();
         // We only return *which* secrets we have stored, but not their values.
-        for secret in priv_config.secret {
+        for secret in priv_config.into_iter().flat_map(|c| &c.secret) {
             secret_names.push(
                 KeyAndBase64Val {
                     name: secret.name.clone(),
@@ -56,15 +57,15 @@ pub fn get_endpoints(config: &Config) -> Result<Vec<WebhookConfig>, HttpError> {
 /// The caller is responsible for any needed permission checks.
 /// Returns the endpoint or a [`HttpError`] if the endpoint was not found (`404 Not found`).
 pub fn get_endpoint(config: &Config, name: &str) -> Result<WebhookConfig, HttpError> {
-    let mut endpoint: WebhookConfig = config
-        .config
-        .lookup(WEBHOOK_TYPENAME, name)
-        .map_err(|_| http_err!(NOT_FOUND, "endpoint '{name}' not found"))?;
+    let mut endpoint = lookup!(config.config, name, ConfigEntity::Webhook)
+        .cloned()
+        .ok_or_else(|| http_err!(NOT_FOUND, "endpoint '{name}' not found"))?;
 
-    let priv_config: Option<WebhookPrivateConfig> = config
-        .private_config
-        .lookup(WEBHOOK_TYPENAME, &endpoint.name)
-        .ok();
+    let priv_config = lookup!(
+        config.private_config,
+        &endpoint.name,
+        PrivateConfigEntity::Webhook
+    );
 
     let mut secret_names = Vec::new();
     if let Some(priv_config) = priv_config {
@@ -100,26 +101,20 @@ pub fn add_endpoint(
 
     let secrets = std::mem::take(&mut endpoint_config.secret);
 
-    set_private_config_entry(
-        config,
-        &WebhookPrivateConfig {
+    config.private_config.insert(
+        endpoint_config.name.clone(),
+        PrivateConfigEntity::Webhook(WebhookPrivateConfig {
             name: endpoint_config.name.clone(),
             secret: secrets,
-        },
-        WEBHOOK_TYPENAME,
-        &endpoint_config.name,
-    )?;
+        }),
+    );
 
-    config
-        .config
-        .set_data(&endpoint_config.name, WEBHOOK_TYPENAME, &endpoint_config)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save endpoint '{}': {e}",
-                endpoint_config.name
-            )
-        })
+    config.config.insert(
+        endpoint_config.name.clone(),
+        ConfigEntity::Webhook(endpoint_config),
+    );
+
+    Ok(())
 }
 
 /// Update existing webhook endpoint.
@@ -144,11 +139,10 @@ pub fn update_endpoint(
     let mut endpoint = get_endpoint(config, name)?;
     endpoint.secret.clear();
 
-    let old_secrets = config
-        .private_config
-        .lookup::<WebhookPrivateConfig>(WEBHOOK_TYPENAME, name)
-        .map_err(|err| http_err!(INTERNAL_SERVER_ERROR, "could not read secret config: {err}"))?
-        .secret;
+    let old_secrets = lookup!(config.private_config, name, PrivateConfigEntity::Webhook)
+        .ok_or_else(|| http_err!(INTERNAL_SERVER_ERROR, "could not read secret config"))?
+        .secret
+        .clone();
 
     if let Some(delete) = delete {
         for deleteable_property in delete {
@@ -158,15 +152,13 @@ pub fn update_endpoint(
                 DeleteableWebhookProperty::Header => endpoint.header = Vec::new(),
                 DeleteableWebhookProperty::Body => endpoint.body = None,
                 DeleteableWebhookProperty::Secret => {
-                    set_private_config_entry(
-                        config,
-                        &WebhookPrivateConfig {
+                    config.private_config.insert(
+                        name,
+                        PrivateConfigEntity::Webhook(WebhookPrivateConfig {
                             name: name.into(),
                             secret: Vec::new(),
-                        },
-                        WEBHOOK_TYPENAME,
-                        name,
-                    )?;
+                        }),
+                    );
                 }
             }
         }
@@ -250,26 +242,18 @@ pub fn update_endpoint(
             new_secrets.push(sec);
         }
 
-        set_private_config_entry(
-            config,
-            &WebhookPrivateConfig {
+        config.private_config.insert(
+            name,
+            PrivateConfigEntity::Webhook(WebhookPrivateConfig {
                 name: name.into(),
                 secret: new_secrets,
-            },
-            WEBHOOK_TYPENAME,
-            name,
-        )?;
+            }),
+        );
     }
 
-    config
-        .config
-        .set_data(name, WEBHOOK_TYPENAME, &endpoint)
-        .map_err(|e| {
-            http_err!(
-                INTERNAL_SERVER_ERROR,
-                "could not save endpoint '{name}': {e}"
-            )
-        })
+    config.config.insert(name, ConfigEntity::Webhook(endpoint));
+
+    Ok(())
 }
 
 /// Delete existing webhook endpoint.
@@ -284,8 +268,9 @@ pub fn delete_endpoint(config: &mut Config, name: &str) -> Result<(), HttpError>
     let _ = get_endpoint(config, name)?;
     super::ensure_safe_to_delete(config, name)?;
 
-    remove_private_config_entry(config, name)?;
-    config.config.sections.remove(name);
+    config.private_config.remove(name);
+
+    config.config.remove(name);
 
     Ok(())
 }
@@ -381,11 +366,13 @@ mod tests {
         assert_eq!(endpoint.comment, Some("newcomment".to_string()));
         assert!(matches!(endpoint.method, HttpMethod::Put));
 
-        let secrets = config
-            .private_config
-            .lookup::<WebhookPrivateConfig>(WEBHOOK_TYPENAME, "webhook-endpoint")
-            .unwrap()
-            .secret;
+        let secrets = &lookup!(
+            config.private_config,
+            "webhook-endpoint",
+            PrivateConfigEntity::Webhook
+        )
+        .unwrap()
+        .secret;
 
         assert_eq!(secrets[1].name, "token".to_string());
         assert_eq!(secrets[1].value, Some(proxmox_base64::encode("secret")));
@@ -407,11 +394,13 @@ mod tests {
         let endpoint = get_endpoint(&config, "webhook-endpoint")?;
         assert_eq!(endpoint.comment, None);
 
-        let secrets = config
-            .private_config
-            .lookup::<WebhookPrivateConfig>(WEBHOOK_TYPENAME, "webhook-endpoint")
-            .unwrap()
-            .secret;
+        let secrets = &lookup!(
+            config.private_config,
+            "webhook-endpoint",
+            PrivateConfigEntity::Webhook
+        )
+        .unwrap()
+        .secret;
 
         assert!(secrets.is_empty());
 
diff --git a/proxmox-notify/src/config.rs b/proxmox-notify/src/config.rs
index f59da9bdd..406d3cb53 100644
--- a/proxmox-notify/src/config.rs
+++ b/proxmox-notify/src/config.rs
@@ -1,138 +1,43 @@
 use std::sync::OnceLock;
 
 use proxmox_config_digest::ConfigDigest;
-use proxmox_schema::{ApiType, ObjectSchema};
-use proxmox_section_config::{SectionConfig, SectionConfigData, SectionConfigPlugin};
-use serde_json::Value;
-use tracing::error;
+use proxmox_schema::{ApiType, api};
+use proxmox_section_config::typed::{ApiSectionDataEntry, SectionConfigData};
+use proxmox_section_config::{SectionConfig, SectionConfigPlugin};
+use serde::{Deserialize, Serialize};
 
 use crate::Error;
 use crate::api_types::{
     BACKEND_NAME_SCHEMA, GOTIFY_TYPENAME, GotifyConfig, GotifyPrivateConfig, MATCHER_TYPENAME,
-    MatcherConfig, SENDMAIL_TYPENAME, SMTP_TYPENAME, SendmailConfig, SmtpConfig, SmtpPrivateConfig,
-    WEBHOOK_TYPENAME, WebhookConfig, WebhookPrivateConfig,
+    MatcherConfig, Origin, SENDMAIL_TYPENAME, SMTP_TYPENAME, SendmailConfig, SmtpConfig,
+    SmtpPrivateConfig, WEBHOOK_TYPENAME, WebhookConfig, WebhookPrivateConfig,
 };
 
-/// Section config schema for the public config file.
-pub fn config_parser() -> &'static SectionConfig {
-    static CONFIG: OnceLock<SectionConfig> = OnceLock::new();
-    CONFIG.get_or_init(config_init)
-}
-
-/// Section config schema for the private config file.
-pub fn private_config_parser() -> &'static SectionConfig {
-    static CONFIG: OnceLock<SectionConfig> = OnceLock::new();
-    CONFIG.get_or_init(private_config_init)
-}
-
-fn config_init() -> SectionConfig {
-    let mut config = SectionConfig::new(&BACKEND_NAME_SCHEMA);
-
-    {
-        const SENDMAIL_SCHEMA: &ObjectSchema = SendmailConfig::API_SCHEMA.unwrap_object_schema();
-        config.register_plugin(SectionConfigPlugin::new(
-            SENDMAIL_TYPENAME.to_string(),
-            Some(String::from("name")),
-            SENDMAIL_SCHEMA,
-        ));
-    }
-    {
-        const SMTP_SCHEMA: &ObjectSchema = SmtpConfig::API_SCHEMA.unwrap_object_schema();
-        config.register_plugin(SectionConfigPlugin::new(
-            SMTP_TYPENAME.to_string(),
-            Some(String::from("name")),
-            SMTP_SCHEMA,
-        ));
-    }
-    {
-        const GOTIFY_SCHEMA: &ObjectSchema = GotifyConfig::API_SCHEMA.unwrap_object_schema();
-        config.register_plugin(SectionConfigPlugin::new(
-            GOTIFY_TYPENAME.to_string(),
-            Some(String::from("name")),
-            GOTIFY_SCHEMA,
-        ));
-    }
-    {
-        const WEBHOOK_SCHEMA: &ObjectSchema = WebhookConfig::API_SCHEMA.unwrap_object_schema();
-        config.register_plugin(SectionConfigPlugin::new(
-            WEBHOOK_TYPENAME.to_string(),
-            Some(String::from("name")),
-            WEBHOOK_SCHEMA,
-        ));
-    }
-
-    const MATCHER_SCHEMA: &ObjectSchema = MatcherConfig::API_SCHEMA.unwrap_object_schema();
-    config.register_plugin(SectionConfigPlugin::new(
-        MATCHER_TYPENAME.to_string(),
-        Some(String::from("name")),
-        MATCHER_SCHEMA,
-    ));
-
-    config
-}
-
-fn private_config_init() -> SectionConfig {
-    let mut config = SectionConfig::new(&BACKEND_NAME_SCHEMA);
-
-    const GOTIFY_SCHEMA: &ObjectSchema = GotifyPrivateConfig::API_SCHEMA.unwrap_object_schema();
-    config.register_plugin(SectionConfigPlugin::new(
-        GOTIFY_TYPENAME.to_string(),
-        Some(String::from("name")),
-        GOTIFY_SCHEMA,
-    ));
-
-    const SMTP_SCHEMA: &ObjectSchema = SmtpPrivateConfig::API_SCHEMA.unwrap_object_schema();
-    config.register_plugin(SectionConfigPlugin::new(
-        SMTP_TYPENAME.to_string(),
-        Some(String::from("name")),
-        SMTP_SCHEMA,
-    ));
-
-    const WEBHOOK_SCHEMA: &ObjectSchema = WebhookPrivateConfig::API_SCHEMA.unwrap_object_schema();
-    config.register_plugin(SectionConfigPlugin::new(
-        WEBHOOK_TYPENAME.to_string(),
-        Some(String::from("name")),
-        WEBHOOK_SCHEMA,
-    ));
-
-    config
-}
-
-fn parse_config(raw_config: &str) -> Result<(SectionConfigData, ConfigDigest), Error> {
+fn parse_config(
+    raw_config: &str,
+) -> Result<(SectionConfigData<ConfigEntity>, ConfigDigest), Error> {
     let digest = ConfigDigest::from_slice(raw_config.as_bytes());
-    let data = config_parser()
-        .parse("notifications.cfg", raw_config)
+    let data = ConfigEntity::parse_section_config("notifications.cfg", raw_config)
         .map_err(Error::config_deserialization)?;
 
     Ok((data, digest))
 }
 
-fn parse_private_config(raw_config: &str) -> Result<(SectionConfigData, ConfigDigest), Error> {
+fn parse_private_config(
+    raw_config: &str,
+) -> Result<(SectionConfigData<PrivateConfigEntity>, ConfigDigest), Error> {
     let digest = ConfigDigest::from_slice(raw_config.as_bytes());
-    let data = private_config_parser()
-        .parse("priv/notifications.cfg", raw_config)
+    let data = PrivateConfigEntity::parse_section_config("priv/notifications.cfg", raw_config)
         .map_err(Error::config_deserialization)?;
 
     Ok((data, digest))
 }
 
-fn write(config: &SectionConfigData) -> Result<String, Error> {
-    config_parser()
-        .write("notifications.cfg", config)
-        .map_err(Error::config_serialization)
-}
-
-fn write_private(config: &SectionConfigData) -> Result<String, Error> {
-    private_config_parser()
-        .write("priv/notifications.cfg", config)
-        .map_err(Error::config_serialization)
-}
-
 /// Notification configuration
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct Config {
-    pub(crate) config: SectionConfigData,
-    pub(crate) private_config: SectionConfigData,
+    pub(crate) config: SectionConfigData<ConfigEntity>,
+    pub(crate) private_config: SectionConfigData<PrivateConfigEntity>,
     digest: ConfigDigest,
 }
 
@@ -141,53 +46,38 @@ impl Config {
     pub fn parse_section_config(
         raw_config: &str,
         raw_private_config: &str,
-        builtin_config: Option<&SectionConfigData>,
+        builtin_config: Option<&SectionConfigData<ConfigEntity>>,
     ) -> Result<Self, Error> {
         let (mut config, digest) = parse_config(raw_config)?;
         let (private_config, _) = parse_private_config(raw_private_config)?;
 
         if let Some(builtin_config) = builtin_config {
-            for (key, (builtin_typename, builtin_value)) in &builtin_config.sections {
-                if let Some((typename, value)) = config.sections.get_mut(key) {
-                    if builtin_typename == typename && value == builtin_value {
+            for (key, builtin_value) in builtin_config {
+                if let Some(value) = config.get_mut(key) {
+                    if value == builtin_value {
                         // Entry is built-in and the config entry section in notifications.cfg
                         // is exactly the same.
-                        if let Some(obj) = value.as_object_mut() {
-                            obj.insert("origin".to_string(), Value::String("builtin".into()));
-                        } else {
-                            error!("section config entry is not an object. This should not happen");
-                        }
+                        value.set_origin(Some(Origin::Builtin));
                     } else {
                         // Entry is built-in, but it has been modified by the user.
-                        if let Some(obj) = value.as_object_mut() {
-                            obj.insert(
-                                "origin".to_string(),
-                                Value::String("modified-builtin".into()),
-                            );
-                        } else {
-                            error!("section config entry is not an object. This should not happen");
-                        }
+                        value.set_origin(Some(Origin::ModifiedBuiltin));
                     }
                 } else {
-                    let mut val = builtin_value.clone();
-
-                    if let Some(obj) = val.as_object_mut() {
-                        obj.insert("origin".to_string(), Value::String("builtin".into()));
-                    } else {
-                        error!("section config entry is not an object. This should not happen");
-                    }
-                    config
-                        .set_data(key, builtin_typename, val)
-                        .map_err(|err| Error::ConfigDeserialization(err.into()))?;
+                    // If it doesn't exist, we insert the builtin
+                    let mut value = builtin_value.clone();
+                    value.set_origin(Some(Origin::Builtin));
+                    config.insert(key.to_string(), value);
                 }
             }
         }
 
-        for (_, (_, value)) in config.sections.iter_mut() {
-            if let Some(obj) = value.as_object_mut() {
-                if obj.get("origin").is_none() {
-                    obj.insert("origin".to_string(), Value::String("user-created".into()));
-                }
+        let keys: Vec<String> = config.keys().cloned().collect();
+
+        for key in keys {
+            if let Some(value) = config.get_mut(&key)
+                && value.origin().is_none()
+            {
+                value.set_origin(Some(Origin::UserCreated));
             }
         }
 
@@ -200,20 +90,48 @@ impl Config {
 
     /// Serialize config
     pub fn to_section_config(&self) -> Result<(String, String), Error> {
-        let mut c = self.config.clone();
-        for (_, (_, value)) in c.sections.iter_mut() {
-            // Remove 'origin' parameter, we do not want it in our
-            // config fields
-            // TODO: Check if there is a better way for this, maybe a
-            // separate type for API responses?
-            if let Some(obj) = value.as_object_mut() {
-                obj.remove("origin");
-            } else {
-                error!("section config entry is not an object. This should not happen");
+        let mut configs_without_origin = SectionConfigData::default();
+
+        for (name, section) in &self.config {
+            match section {
+                ConfigEntity::Sendmail(config) => {
+                    let mut config = config.clone();
+                    config.origin = None;
+                    configs_without_origin.insert(name, ConfigEntity::Sendmail(config));
+                }
+                ConfigEntity::Smtp(config) => {
+                    let mut config = config.clone();
+                    config.origin = None;
+                    configs_without_origin.insert(name, ConfigEntity::Smtp(config));
+                }
+                ConfigEntity::Gotify(config) => {
+                    let mut config = config.clone();
+                    config.origin = None;
+                    configs_without_origin.insert(name, ConfigEntity::Gotify(config));
+                }
+                ConfigEntity::Webhook(config) => {
+                    let mut config = config.clone();
+                    config.origin = None;
+                    configs_without_origin.insert(name, ConfigEntity::Webhook(config));
+                }
+                ConfigEntity::Matcher(config) => {
+                    let mut config = config.clone();
+                    config.origin = None;
+                    configs_without_origin.insert(name, ConfigEntity::Matcher(config));
+                }
             }
         }
 
-        Ok((write(&c)?, write_private(&self.private_config)?))
+        let config_str =
+            ConfigEntity::write_section_config("notifications.cfg", &configs_without_origin)
+                .map_err(Error::config_serialization)?;
+        let private_config_str = PrivateConfigEntity::write_section_config(
+            "priv/notifications.cfg",
+            &self.private_config,
+        )
+        .map_err(Error::config_serialization)?;
+
+        Ok((config_str, private_config_str))
     }
 
     /// Returns the SHA256 digest of the configuration.
@@ -222,3 +140,168 @@ impl Config {
         &self.digest
     }
 }
+
+#[api]
+/// Config entity in the notification config file.
+#[derive(Clone, Deserialize, Serialize, PartialEq)]
+#[serde(rename_all = "kebab-case", tag = "type")]
+pub enum ConfigEntity {
+    /// Sendmail endpoint.
+    Sendmail(SendmailConfig),
+    /// Gotify endpoint.
+    Gotify(GotifyConfig),
+    /// SMTP endpoint.
+    Smtp(SmtpConfig),
+    /// Webhook endpoint.
+    Webhook(WebhookConfig),
+    /// Matcher configuration.
+    Matcher(MatcherConfig),
+}
+
+impl ApiSectionDataEntry for ConfigEntity {
+    const INTERNALLY_TAGGED: Option<&'static str> = Some("type");
+
+    /// Get the `SectionConfig` configuration for this enum.
+    fn section_config() -> &'static SectionConfig {
+        static CONFIG: OnceLock<SectionConfig> = OnceLock::new();
+
+        CONFIG.get_or_init(|| {
+            let mut this = SectionConfig::new(&BACKEND_NAME_SCHEMA).with_type_key("type");
+            this.register_plugin(SectionConfigPlugin::new(
+                SENDMAIL_TYPENAME.into(),
+                Some("name".to_string()),
+                SendmailConfig::API_SCHEMA.unwrap_object_schema(),
+            ));
+            this.register_plugin(SectionConfigPlugin::new(
+                MATCHER_TYPENAME.into(),
+                Some("name".to_string()),
+                MatcherConfig::API_SCHEMA.unwrap_object_schema(),
+            ));
+            this.register_plugin(SectionConfigPlugin::new(
+                SMTP_TYPENAME.into(),
+                Some("name".to_string()),
+                SmtpConfig::API_SCHEMA.unwrap_object_schema(),
+            ));
+            this.register_plugin(SectionConfigPlugin::new(
+                GOTIFY_TYPENAME.into(),
+                Some("name".to_string()),
+                GotifyConfig::API_SCHEMA.unwrap_object_schema(),
+            ));
+            this.register_plugin(SectionConfigPlugin::new(
+                WEBHOOK_TYPENAME.into(),
+                Some("name".to_string()),
+                WebhookConfig::API_SCHEMA.unwrap_object_schema(),
+            ));
+            this
+        })
+    }
+
+    /// Maps an enum value to its type name.
+    fn section_type(&self) -> &'static str {
+        match self {
+            ConfigEntity::Sendmail(_) => "sendmail",
+            ConfigEntity::Gotify(_) => "gotify",
+            ConfigEntity::Smtp(_) => "smtp",
+            ConfigEntity::Webhook(_) => "webhook",
+            ConfigEntity::Matcher(_) => "matcher",
+        }
+    }
+}
+
+impl ConfigEntity {
+    pub(crate) fn set_origin(&mut self, origin: Option<Origin>) {
+        match self {
+            ConfigEntity::Sendmail(config) => config.origin = origin,
+            ConfigEntity::Gotify(config) => config.origin = origin,
+            ConfigEntity::Smtp(config) => config.origin = origin,
+            ConfigEntity::Webhook(config) => config.origin = origin,
+            ConfigEntity::Matcher(config) => config.origin = origin,
+        }
+    }
+
+    pub(crate) fn origin(&self) -> Option<Origin> {
+        match self {
+            ConfigEntity::Sendmail(config) => config.origin,
+            ConfigEntity::Gotify(config) => config.origin,
+            ConfigEntity::Smtp(config) => config.origin,
+            ConfigEntity::Webhook(config) => config.origin,
+            ConfigEntity::Matcher(config) => config.origin,
+        }
+    }
+}
+
+#[api]
+/// Config entity in the private notification config file.
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case", tag = "type")]
+pub enum PrivateConfigEntity {
+    /// Private config for a gotify endpoint.
+    Gotify(GotifyPrivateConfig),
+    /// Private config for an SMTP endpoint.
+    Smtp(SmtpPrivateConfig),
+    /// Private config for a webhook endpoint.
+    Webhook(WebhookPrivateConfig),
+}
+
+impl ApiSectionDataEntry for PrivateConfigEntity {
+    const INTERNALLY_TAGGED: Option<&'static str> = Some("type");
+
+    /// Get the `SectionConfig` configuration for this enum.
+    fn section_config() -> &'static SectionConfig {
+        static CONFIG: OnceLock<SectionConfig> = OnceLock::new();
+
+        CONFIG.get_or_init(|| {
+            let mut this = SectionConfig::new(&BACKEND_NAME_SCHEMA).with_type_key("type");
+            this.register_plugin(SectionConfigPlugin::new(
+                SMTP_TYPENAME.into(),
+                Some("name".to_string()),
+                SmtpPrivateConfig::API_SCHEMA.unwrap_object_schema(),
+            ));
+            this.register_plugin(SectionConfigPlugin::new(
+                GOTIFY_TYPENAME.into(),
+                Some("name".to_string()),
+                GotifyPrivateConfig::API_SCHEMA.unwrap_object_schema(),
+            ));
+            this.register_plugin(SectionConfigPlugin::new(
+                WEBHOOK_TYPENAME.into(),
+                Some("name".to_string()),
+                WebhookPrivateConfig::API_SCHEMA.unwrap_object_schema(),
+            ));
+            this
+        })
+    }
+
+    /// Maps an enum value to its type name.
+    fn section_type(&self) -> &'static str {
+        match self {
+            PrivateConfigEntity::Gotify(_) => "gotify",
+            PrivateConfigEntity::Smtp(_) => "smtp",
+            PrivateConfigEntity::Webhook(_) => "webhook",
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const CONFIG_REF: &str = include_str!("../testdata/notifications.cfg.ref");
+    const PRIV_CONFIG_REF: &str = include_str!("../testdata/notifications-priv.cfg.ref");
+
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn section_config_roundtrip() {
+        let config = Config::parse_section_config(CONFIG_REF, PRIV_CONFIG_REF, None).unwrap();
+
+        assert_eq!(
+            config.digest().to_string(),
+            "53554a97ca1747b69582f7cde5d4493f68b77c0d5946ce593a59547c9638d504"
+        );
+
+        let (public_config, private_config) = config.to_section_config().unwrap();
+
+        assert_eq!(public_config, CONFIG_REF);
+        assert_eq!(private_config, PRIV_CONFIG_REF);
+    }
+}
diff --git a/proxmox-notify/src/send.rs b/proxmox-notify/src/send.rs
index a96b838df..210a42599 100644
--- a/proxmox-notify/src/send.rs
+++ b/proxmox-notify/src/send.rs
@@ -1,20 +1,18 @@
 use std::collections::{HashMap, HashSet};
 
+use proxmox_section_config::typed::{convert_to_typed_array, lookup};
 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::api_types::MatcherConfig;
+use crate::config::{ConfigEntity, PrivateConfigEntity};
+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, Endpoint, Error, Metadata, Notification, Severity};
+use crate::{Config, Content, Context, Error, Metadata, Notification, Severity};
 
 /// Send a notification to a given target.
 ///
@@ -47,64 +45,8 @@ struct Bus {
     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)
-        })()
-    };
+fn log_missing_private_config(endpoint_name: &str) {
+    error!("Could not instantiate endpoint '{endpoint_name}': private config does not exist");
 }
 
 impl Bus {
@@ -112,58 +54,73 @@ impl Bus {
     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)),
-        );
+        for endpoint_config in convert_to_typed_array!(config.config, ConfigEntity::Sendmail) {
+            endpoints.insert(
+                endpoint_config.name.clone(),
+                Box::new(SendmailEndpoint {
+                    config: endpoint_config.clone(),
+                }) as Box<dyn Endpoint>,
+            );
+        }
 
-        endpoints.extend(
-            parse_endpoints_with_private_config!(
-                config,
-                GotifyConfig,
-                GotifyPrivateConfig,
-                GotifyEndpoint,
-                GOTIFY_TYPENAME
-            )?
-            .into_iter()
-            .map(|e| (e.name().into(), e)),
-        );
+        for endpoint_config in convert_to_typed_array!(config.config, ConfigEntity::Gotify) {
+            if let Some(private_config) = lookup!(
+                config.private_config,
+                &endpoint_config.name,
+                PrivateConfigEntity::Gotify
+            ) {
+                endpoints.insert(
+                    endpoint_config.name.clone(),
+                    Box::new(GotifyEndpoint {
+                        config: endpoint_config.clone(),
+                        private_config: private_config.clone(),
+                    }) as Box<dyn Endpoint>,
+                );
+            } else {
+                log_missing_private_config(&endpoint_config.name);
+            }
+        }
 
-        endpoints.extend(
-            parse_endpoints_with_private_config!(
-                config,
-                SmtpConfig,
-                SmtpPrivateConfig,
-                SmtpEndpoint,
-                SMTP_TYPENAME
-            )?
-            .into_iter()
-            .map(|e| (e.name().into(), e)),
-        );
+        for endpoint_config in convert_to_typed_array!(config.config, ConfigEntity::Webhook) {
+            if let Some(private_config) = lookup!(
+                config.private_config,
+                &endpoint_config.name,
+                PrivateConfigEntity::Webhook
+            ) {
+                endpoints.insert(
+                    endpoint_config.name.clone(),
+                    Box::new(WebhookEndpoint {
+                        config: endpoint_config.clone(),
+                        private_config: private_config.clone(),
+                    }) as Box<dyn Endpoint>,
+                );
+            } else {
+                log_missing_private_config(&endpoint_config.name);
+            }
+        }
 
-        endpoints.extend(
-            parse_endpoints_with_private_config!(
-                config,
-                WebhookConfig,
-                WebhookPrivateConfig,
-                WebhookEndpoint,
-                WEBHOOK_TYPENAME
-            )?
-            .into_iter()
-            .map(|e| (e.name().into(), e)),
-        );
+        for endpoint_config in convert_to_typed_array!(config.config, ConfigEntity::Smtp) {
+            if let Some(private_config) = lookup!(
+                config.private_config,
+                &endpoint_config.name,
+                PrivateConfigEntity::Smtp
+            ) {
+                endpoints.insert(
+                    endpoint_config.name.clone(),
+                    Box::new(SmtpEndpoint {
+                        config: endpoint_config.clone(),
+                        private_config: private_config.clone(),
+                    }) as Box<dyn Endpoint>,
+                );
+            } else {
+                log_missing_private_config(&endpoint_config.name);
+            }
+        }
 
-        let matchers = config
-            .config
-            .convert_to_typed_array(MATCHER_TYPENAME)
-            .map_err(|err| Error::ConfigDeserialization(err.into()))?;
+        let matchers = convert_to_typed_array!(config.config, ConfigEntity::Matcher)
+            .into_iter()
+            .cloned()
+            .collect();
 
         Ok(Bus {
             endpoints,
diff --git a/proxmox-notify/testdata/notifications-priv.cfg.ref b/proxmox-notify/testdata/notifications-priv.cfg.ref
new file mode 100644
index 000000000..fcf4d0dbe
--- /dev/null
+++ b/proxmox-notify/testdata/notifications-priv.cfg.ref
@@ -0,0 +1,8 @@
+gotify: test-gotify
+	token test
+
+smtp: test-smtp
+	password password
+
+webhook: test-webhook
+	secret name=key,value=c2VjcmV0
diff --git a/proxmox-notify/testdata/notifications.cfg.ref b/proxmox-notify/testdata/notifications.cfg.ref
new file mode 100644
index 000000000..53040973f
--- /dev/null
+++ b/proxmox-notify/testdata/notifications.cfg.ref
@@ -0,0 +1,29 @@
+sendmail: mail-to-root
+	comment Send mails to root@pam's email address
+	mailto-user root@pam
+
+matcher: default-matcher
+	comment Route all notifications to mail-to-root
+	expression {"constant":true}
+	target mail-to-root
+
+gotify: test-gotify
+	comment some comment
+	server https://localhost:8000
+
+smtp: test-smtp
+	author Proxmox VE (test)
+	comment some comment
+	from-address test@example.com
+	mailto test@example.com
+	mailto-user root@pam
+	mode tls
+	server mail.example.com
+	username testuser
+
+webhook: test-webhook
+	body c29tZXRoaW5n
+	comment some comment
+	header name=Content-Type,value=YXBwbGljYXRpb24vanNvbg==
+	method post
+	url https://localhost:8001
-- 
2.47.3





  parent reply	other threads:[~2026-11-13 15:18 UTC|newest]

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