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 39/63] notify: add send receipts
Date: Wed, 18 Nov 2026 10:43:23 +0100	[thread overview]
Message-ID: <20261118094348.273646-40-l.wagner@proxmox.com> (raw)
In-Reply-To: <20261118094348.273646-1-l.wagner@proxmox.com>

Instead of only logging errors on proxmox_notify::send, return a receipt
that includes information such as:
  - the evaluation results of matchers
  - which targets these matchers yielded
  - a per-target status, including errors if there were any

Signed-off-by: Lukas Wagner <l.wagner@proxmox.com>
---
 proxmox-notify/src/api_types/matcher/mod.rs |  13 +-
 proxmox-notify/src/api_types/mod.rs         |   3 +
 proxmox-notify/src/api_types/receipt.rs     | 138 ++++++++++++++++
 proxmox-notify/src/send.rs                  | 172 ++++++++++++++++----
 4 files changed, 287 insertions(+), 39 deletions(-)
 create mode 100644 proxmox-notify/src/api_types/receipt.rs

diff --git a/proxmox-notify/src/api_types/matcher/mod.rs b/proxmox-notify/src/api_types/matcher/mod.rs
index fe2b61a9d..6dd6d5bc5 100644
--- a/proxmox-notify/src/api_types/matcher/mod.rs
+++ b/proxmox-notify/src/api_types/matcher/mod.rs
@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use proxmox_match_expression::Expression;
+use proxmox_match_expression::{EvaluatedExpressionWithResult, Expression};
 use serde::{Deserialize, Serialize};
 
 use proxmox_api_macro::api;
@@ -150,7 +150,10 @@ trait MatchDirective {
 }
 
 impl MatcherConfig {
-    pub fn matches(&self, notification: &Notification) -> Result<Option<&[String]>, Error> {
+    pub fn matches(
+        &self,
+        notification: &Notification,
+    ) -> Result<EvaluatedExpressionWithResult<NotificationMatcher>, Error> {
         #[cfg(feature = "legacy-matchers")]
         self.warn_about_invalid_configuration();
 
@@ -178,9 +181,7 @@ impl MatcherConfig {
         // This gives the user a trace of which rules matched and which did not.
         let evaluated_expression = expression.evaluate(notification)?;
 
-        Ok(evaluated_expression
-            .is_match()
-            .then_some(self.target.as_slice()))
+        Ok(evaluated_expression)
     }
 
     #[cfg(feature = "legacy-matchers")]
@@ -407,7 +408,7 @@ mod tests {
                 ..Default::default()
             };
 
-            assert!(config.matches(&notification).unwrap().is_some())
+            assert!(config.matches(&notification).unwrap().is_match())
         }
     }
 
diff --git a/proxmox-notify/src/api_types/mod.rs b/proxmox-notify/src/api_types/mod.rs
index f3b381a8b..f445618c1 100644
--- a/proxmox-notify/src/api_types/mod.rs
+++ b/proxmox-notify/src/api_types/mod.rs
@@ -27,6 +27,9 @@ pub use matcher::*;
 mod schema;
 pub use schema::*;
 
+mod receipt;
+pub use receipt::*;
+
 #[api]
 #[derive(Clone, Debug, Copy, Serialize, Deserialize, PartialEq, Eq, PartialOrd)]
 #[serde(rename_all = "kebab-case")]
diff --git a/proxmox-notify/src/api_types/receipt.rs b/proxmox-notify/src/api_types/receipt.rs
new file mode 100644
index 000000000..d05135ba3
--- /dev/null
+++ b/proxmox-notify/src/api_types/receipt.rs
@@ -0,0 +1,138 @@
+//! Types describing the outcome of sending a notification.
+//!
+//! Sending a notification yields a [`Receipt`], which records how the notification was routed and
+//! whether it reached its destinations:
+//!
+//! - One [`MatcherReceipt`] per configured matcher, if the notification was routed through the
+//!   matchers. It states whether the matcher matched, did not match, was disabled or failed to
+//!   be evaluated. For evaluated matchers, it also contains the evaluated match expression, which
+//!   shows why the notification was or was not matched.
+//! - One [`TargetReceipt`] per target the notification was dispatched to, stating whether the
+//!   notification was delivered, the target was disabled, or delivery failed.
+//!
+//! Delivery failures are reported in the receipt rather than as an error, so that the caller can
+//! inspect the result of every single target, even if only some of them failed.
+
+use serde::{Deserialize, Serialize};
+
+use proxmox_match_expression::EvaluatedExpressionWithResult;
+
+use crate::api_types::expression::NotificationMatcher;
+
+/// Outcome of sending a single notification.
+///
+/// Records which matchers were evaluated and which targets the notification was dispatched to,
+/// together with the result for each of them.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct Receipt {
+    pub(crate) target_receipts: Vec<TargetReceipt>,
+    pub(crate) matcher_receipts: Vec<MatcherReceipt>,
+}
+
+impl Receipt {
+    /// Returns the receipts of all targets the notification was dispatched to.
+    pub fn target_receipts(&self) -> &[TargetReceipt] {
+        &self.target_receipts
+    }
+
+    /// Returns the receipts of all matchers that were evaluated for the notification.
+    ///
+    /// This is empty if the notification was sent to a target or email recipient directly,
+    /// without going through the matchers.
+    pub fn matcher_receipts(&self) -> &[MatcherReceipt] {
+        &self.matcher_receipts
+    }
+}
+
+/// Result of dispatching a notification to a single target.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct TargetReceipt {
+    pub(crate) target: String,
+    #[serde(flatten)]
+    pub(crate) status: TargetReceiptStatus,
+    pub(crate) timestamp: i64,
+}
+
+impl TargetReceipt {
+    /// Returns the name of the target.
+    pub fn target(&self) -> &str {
+        &self.target
+    }
+
+    /// Returns the delivery status for this target.
+    pub fn status(&self) -> &TargetReceiptStatus {
+        &self.status
+    }
+
+    /// Returns the time the delivery attempt finished, as seconds since the UNIX epoch.
+    pub fn timestamp(&self) -> i64 {
+        self.timestamp
+    }
+}
+
+/// Delivery status of a notification for a single target.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case", tag = "status")]
+pub enum TargetReceiptStatus {
+    /// The notification was -- to the best of our knowledge -- delivered successfully.
+    Delivered,
+    /// Target was disabled.
+    Disabled,
+    /// The notification was -- to the best of our knowledge -- not delivered to the recipient.
+    #[serde(rename_all = "kebab-case")]
+    Error {
+        /// Human-readable description of the error.
+        error_message: String,
+    },
+}
+
+/// Result of evaluating a single notification matcher.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case", tag = "status")]
+pub enum MatcherReceiptStatus {
+    /// The matcher's expression matched the notification.
+    #[serde(rename_all = "kebab-case")]
+    Matched {
+        /// The evaluated match expression, including the results of its sub-expressions.
+        evaluated_expression: EvaluatedExpressionWithResult<NotificationMatcher>,
+        /// Targets configured for this matcher, which the notification is dispatched to.
+        targets: Vec<String>,
+    },
+    /// The matcher's expression did not match the notification.
+    #[serde(rename_all = "kebab-case")]
+    NoMatch {
+        /// The evaluated match expression, including the results of its sub-expressions.
+        evaluated_expression: EvaluatedExpressionWithResult<NotificationMatcher>,
+    },
+    /// Matcher was disabled and therefore not evaluated.
+    Disabled,
+    /// The matcher could not be evaluated. Its targets were not notified on its behalf.
+    #[serde(rename_all = "kebab-case")]
+    Error {
+        /// Human-readable description of the error.
+        error_message: String,
+    },
+}
+
+/// Result of evaluating a single notification matcher, identified by its name.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct MatcherReceipt {
+    pub(crate) matcher: String,
+    #[serde(flatten)]
+    pub(crate) status: MatcherReceiptStatus,
+}
+
+impl MatcherReceipt {
+    /// Returns the name of the matcher.
+    pub fn matcher(&self) -> &str {
+        &self.matcher
+    }
+
+    /// Returns the evaluation result of the matcher.
+    pub fn status(&self) -> &MatcherReceiptStatus {
+        &self.status
+    }
+}
diff --git a/proxmox-notify/src/send.rs b/proxmox-notify/src/send.rs
index d08d5af30..9fc3864ed 100644
--- a/proxmox-notify/src/send.rs
+++ b/proxmox-notify/src/send.rs
@@ -3,7 +3,10 @@ use std::collections::{HashMap, HashSet};
 use proxmox_section_config::typed::{convert_to_typed_array, lookup};
 use tracing::{error, info};
 
-use crate::api_types::{MatcherConfig, SendmailConfig};
+use crate::api_types::{
+    MatcherConfig, MatcherReceipt, MatcherReceiptStatus, Receipt, SendmailConfig, TargetReceipt,
+    TargetReceiptStatus,
+};
 use crate::config::{ConfigEntity, PrivateConfigEntity};
 use crate::endpoints::Endpoint;
 use crate::endpoints::gotify::GotifyEndpoint;
@@ -16,11 +19,13 @@ use crate::{Config, Context, EmailRecipient, Error, Notification, Recipient};
 ///
 /// 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> {
+pub fn send(
+    context: &Context,
+    config: &Config,
+    notification: &Notification,
+) -> Result<Receipt, Error> {
     let bus = Bus::from_config(config)?;
-    bus.send(context, notification);
-
-    Ok(())
+    Ok(bus.send(context, notification))
 }
 
 /// Notification bus - distributes notifications to all registered endpoints
@@ -129,20 +134,43 @@ impl Bus {
     /// the notification.
     ///
     /// Any errors will not be returned but only logged.
-    pub fn send(&self, context: &Context, notification: &Notification) {
+    pub fn send(&self, context: &Context, notification: &Notification) -> Receipt {
+        let mut target_receipts = Vec::new();
+        let mut matcher_receipts = Vec::new();
+
         match notification.recipient() {
-            Recipient::Email(params) => self.send_to_email(context, notification, params),
+            Recipient::Email(params) => {
+                target_receipts.push(self.send_to_email(context, notification, params))
+            }
             Recipient::Target(target) => {
-                self.send_to_target(context, notification, target);
+                target_receipts.push(self.send_to_target(context, notification, target));
             }
             Recipient::Matcher => {
-                let targets = self.check_matches(notification);
+                matcher_receipts = self.check_matches(notification);
 
-                for target in targets {
-                    self.send_to_target(context, notification, target);
+                let (matching_matchers, targets) =
+                    Self::matching_matchers_and_targets_from_receipts(&matcher_receipts);
+
+                if !matching_matchers.is_empty() {
+                    info!(
+                        "notification matched the following matchers: {}. The following targets will be notified: {}",
+                        matching_matchers.join(", "),
+                        targets.join(", ")
+                    );
+                } else {
+                    info!("notification was not matched by any matcher");
+                }
+
+                for target in &targets {
+                    target_receipts.push(self.send_to_target(context, notification, target));
                 }
             }
         }
+
+        Receipt {
+            target_receipts,
+            matcher_receipts,
+        }
     }
 
     fn send_to_email(
@@ -150,7 +178,7 @@ impl Bus {
         context: &Context,
         notification: &Notification,
         email_recipient: &EmailRecipient,
-    ) {
+    ) -> TargetReceipt {
         let recipient_list = email_recipient.mailto.join(", ");
 
         let endpoint = SendmailEndpoint {
@@ -165,72 +193,150 @@ impl Bus {
         match endpoint.send(context, notification) {
             Ok(_) => {
                 info!("notified via `{recipient_list}`");
+                TargetReceipt {
+                    target: "legacy-sendmail".into(),
+                    status: TargetReceiptStatus::Delivered,
+                    timestamp: proxmox_time::epoch_i64(),
+                }
             }
             Err(e) => {
                 // Only log on errors, do not propagate fail to the caller.
                 error!("could not notify via `{recipient_list}`: {e}");
+                TargetReceipt {
+                    target: "legacy-sendmail".into(),
+                    status: TargetReceiptStatus::Error {
+                        error_message: e.to_string(),
+                    },
+                    timestamp: proxmox_time::epoch_i64(),
+                }
             }
         }
     }
 
-    fn send_to_target(&self, context: &Context, notification: &Notification, target: &str) {
+    fn send_to_target(
+        &self,
+        context: &Context,
+        notification: &Notification,
+        target: &str,
+    ) -> TargetReceipt {
         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}'");
-                return;
+
+                return TargetReceipt {
+                    target: name.to_string(),
+                    status: TargetReceiptStatus::Disabled,
+                    timestamp: proxmox_time::epoch_i64(),
+                };
             }
 
             match endpoint.send(context, notification) {
                 Ok(_) => {
                     info!("notified via target `{name}`");
+                    TargetReceipt {
+                        target: name.to_string(),
+                        status: TargetReceiptStatus::Delivered,
+                        timestamp: proxmox_time::epoch_i64(),
+                    }
                 }
                 Err(e) => {
                     // Only log on errors, do not propagate fail to the caller.
                     error!("could not notify via target `{name}`: {e}");
+                    TargetReceipt {
+                        target: name.to_string(),
+                        status: TargetReceiptStatus::Error {
+                            error_message: e.to_string(),
+                        },
+                        timestamp: proxmox_time::epoch_i64(),
+                    }
                 }
             }
         } else {
             error!("could not notify via target '{target}', it does not exist");
+            TargetReceipt {
+                target: target.to_string(),
+                status: TargetReceiptStatus::Error {
+                    error_message: Error::target_does_not_exist(target).to_string(),
+                },
+                timestamp: proxmox_time::epoch_i64(),
+            }
         }
     }
 
-    fn check_matches(&self, notification: &Notification) -> HashSet<&str> {
-        let mut targets = HashSet::new();
-        let mut matching_matchers = Vec::new();
+    fn check_matches(&self, notification: &Notification) -> Vec<MatcherReceipt> {
+        let mut receipts = Vec::new();
 
         for matcher in &self.matchers {
+            let name = matcher.name.clone();
+
             if matcher.disable.unwrap_or_default() {
                 // Skip this matcher if it is disabled
-                info!("skipping disabled matcher '{name}'", name = matcher.name);
+                info!("skipping disabled matcher '{name}'");
+
+                receipts.push(MatcherReceipt {
+                    matcher: name,
+                    status: MatcherReceiptStatus::Disabled,
+                });
+
                 continue;
             }
 
             match matcher.matches(notification) {
-                Ok(Some(t)) => {
-                    matching_matchers.push(matcher.name.as_str());
-                    targets.extend(t.iter().map(|s| s.as_str()));
+                Ok(evaluated_expression) => {
+                    if evaluated_expression.is_match() {
+                        receipts.push(MatcherReceipt {
+                            matcher: name,
+                            status: MatcherReceiptStatus::Matched {
+                                evaluated_expression,
+                                targets: matcher.target.clone(),
+                            },
+                        });
+                    } else {
+                        receipts.push(MatcherReceipt {
+                            matcher: name,
+                            status: MatcherReceiptStatus::NoMatch {
+                                evaluated_expression,
+                            },
+                        });
+                    }
+                }
+                Err(err) => {
+                    receipts.push(MatcherReceipt {
+                        matcher: name,
+                        status: MatcherReceiptStatus::Error {
+                            error_message: err.to_string(),
+                        },
+                    });
+                    error!("matcher '{matcher}' failed: {err}", matcher = matcher.name);
                 }
-                Ok(None) => {}
-                Err(err) => error!("matcher '{matcher}' failed: {err}", matcher = matcher.name),
             }
         }
 
-        if !matching_matchers.is_empty() {
-            let target_list = Vec::from_iter(targets.iter().copied());
+        receipts
+    }
 
-            info!(
-                "notification matched the following matchers: {}. The following targets will be notified: {}",
-                matching_matchers.join(", "),
-                target_list.join(", ")
-            );
-        } else {
-            info!("notification was not matched by any matcher");
+    fn matching_matchers_and_targets_from_receipts(
+        matcher_receipts: &[MatcherReceipt],
+    ) -> (Vec<String>, Vec<String>) {
+        let mut matchers = Vec::new();
+        let mut deduplicated_targets = HashSet::new();
+
+        for receipt in matcher_receipts {
+            if let MatcherReceiptStatus::Matched { targets, .. } = &receipt.status {
+                matchers.push(receipt.matcher.clone());
+                deduplicated_targets.extend(targets);
+            }
         }
 
-        targets
+        let mut targets = Vec::from_iter(deduplicated_targets.into_iter().cloned());
+        targets.sort();
+
+        matchers.sort();
+
+        (matchers, targets)
     }
 }
 
-- 
2.47.3





  parent reply	other threads:[~2026-11-18  9:51 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 ` [PATCH proxmox v2 11/63] notify: move `send`, `test_target` and `Bus` to new `send` module Lukas Wagner
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 ` Lukas Wagner [this message]
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-40-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