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 44/63] notify: queue: add worker task
Date: Wed, 18 Nov 2026 10:43:28 +0100	[thread overview]
Message-ID: <20261118094348.273646-45-l.wagner@proxmox.com> (raw)
In-Reply-To: <20261118094348.273646-1-l.wagner@proxmox.com>

Add a QueueWorker which periodically polls the notification queue and
sends any queued notifications according to the current notification
configuration. The worker is meant to run as a long-lived task in each
product's daemon and is built via a QueueWorkerBuilder.

The configuration is re-read before each notification. In most cycles
there will be at most one notification to handle, but if sending one ran
into long SMTP or HTTP timeouts, the config might have changed in the
meantime. The notification is only claimed after the config was read
successfully. Otherwise, a temporarily broken config could make
notifications exceed their retry limit and be dropped, even though
sending was never attempted. A config error also aborts the rest of the
cycle, since all remaining notifications would fail the same way.

Retry attempts only cover the case where a previous worker got
interrupted after claiming a notification but before resolving it, for
example due to a crash. Notifications that exceed the configured limit
are dropped to avoid a send-crash-recover loop. By default, no retries
are performed. If crate::send returns an error, no target was notified
at all, so the notification is put back into the queue for the next
cycle. Notifications that cannot be deserialized are marked as broken
and are not picked up again.

To avoid spamming the logs every few seconds while something is
persistently broken, the polling interval is raised by a factor of 10
after more than 10 consecutive cycles with errors, and reset to the
default after the first successful cycle.

Signed-off-by: Lukas Wagner <l.wagner@proxmox.com>
---
 proxmox-notify/Cargo.toml          |   3 +
 proxmox-notify/src/queue/mod.rs    |   5 +
 proxmox-notify/src/queue/worker.rs | 640 +++++++++++++++++++++++++++++
 3 files changed, 648 insertions(+)
 create mode 100644 proxmox-notify/src/queue/worker.rs

diff --git a/proxmox-notify/Cargo.toml b/proxmox-notify/Cargo.toml
index fbdd5e601..20bd3e7d4 100644
--- a/proxmox-notify/Cargo.toml
+++ b/proxmox-notify/Cargo.toml
@@ -25,6 +25,7 @@ serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 serde_regex = { workspace = true, optional = true }
 thiserror.workspace = true
+tokio = { workspace = true, optional = true, features = ["time", "rt"] }
 
 proxmox-api-macro = { workspace = true, optional = true }
 proxmox-base64 = { workspace = true, features = ["serde"]}
@@ -84,5 +85,7 @@ legacy-matchers = []
 queue-submitter = ["dep:proxmox-sys"]
 queue-worker = [
     "dep:libc",
+    "dep:tokio",
     "proxmox-sys/timer",
+    "send-impl",
 ]
diff --git a/proxmox-notify/src/queue/mod.rs b/proxmox-notify/src/queue/mod.rs
index 11317aa04..627cd43f6 100644
--- a/proxmox-notify/src/queue/mod.rs
+++ b/proxmox-notify/src/queue/mod.rs
@@ -16,6 +16,11 @@ mod consumer;
 #[cfg(feature = "queue-worker")]
 pub use consumer::QueueConsumer;
 
+#[cfg(feature = "queue-worker")]
+mod worker;
+#[cfg(feature = "queue-worker")]
+pub use worker::{QueueWorker, QueueWorkerBuilder};
+
 /// Maximum size of a queued notification file.
 ///
 /// Well above what legitimate producers submit, e.g. forwarded mails or backup logs limited to
diff --git a/proxmox-notify/src/queue/worker.rs b/proxmox-notify/src/queue/worker.rs
new file mode 100644
index 000000000..8d646c392
--- /dev/null
+++ b/proxmox-notify/src/queue/worker.rs
@@ -0,0 +1,640 @@
+//! Worker task that sends queued notifications.
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use proxmox_uuid::Uuid;
+
+use crate::{Context, Error};
+
+use crate::queue::consumer::{QueueConsumer, QueueLockGuard, QueuedNotification};
+
+const DEFAULT_INTERVAL: Duration = Duration::from_secs(5);
+
+/// Builder for the [`QueueWorker`] type.
+///
+/// Construct this via [`QueueWorker::builder`] and
+/// finalize via [`QueueWorkerBuilder::build`].
+pub struct QueueWorkerBuilder {
+    context: Context,
+    queue: Arc<QueueConsumer>,
+
+    interval: Option<Duration>,
+    retry_attempts: Option<u32>,
+}
+
+impl QueueWorkerBuilder {
+    /// Set the interval at which the queue directory shall be polled
+    /// for new notifications.
+    ///
+    /// If not set, the interval defaults to 5 seconds.
+    pub fn interval(mut self, interval: Duration) -> Self {
+        self.interval = Some(interval);
+        self
+    }
+
+    /// Number of retry attempts before dropping the notification entirely.
+    ///
+    /// This is not for retries after failing to deliver a notification
+    /// to one or more targets individually, but for when the worker
+    /// got interrupted during sending before removing the notification
+    /// from the queue.
+    ///
+    /// If set to e.g. 2, then sending a notification would be retried *twice*
+    /// after the first attempt, so in total three attempts.
+    ///
+    /// If not set, no retries are performed.
+    pub fn retry_attempts(mut self, attempts: u32) -> Self {
+        self.retry_attempts = Some(attempts);
+        self
+    }
+
+    /// Build the final [`QueueWorker`].
+    ///
+    /// All optional fields that were not initialized are set to
+    /// their defaults.
+    pub fn build(self) -> QueueWorker {
+        QueueWorker {
+            context: self.context,
+            queue: self.queue,
+            polling_backoff: PollingBackoff::new(self.interval.unwrap_or(DEFAULT_INTERVAL)),
+            retry_attempts: self.retry_attempts.unwrap_or(0),
+
+            #[cfg(test)]
+            history: Vec::new(),
+        }
+    }
+}
+
+/// Worker task that sends queued notifications.
+///
+/// The worker periodically polls the notification queue, claims each queued notification, sends it
+/// according to the current notification configuration and removes it from the queue afterwards.
+/// On startup, notifications that were still in flight when the previous worker stopped are sent
+/// again, unless they have already reached the attempt limit, in which case they are dropped.
+pub struct QueueWorker {
+    context: Context,
+    queue: Arc<QueueConsumer>,
+    polling_backoff: PollingBackoff,
+    retry_attempts: u32,
+
+    #[cfg(test)]
+    history: Vec<HistoryEntry>,
+}
+
+impl QueueWorker {
+    /// Create the builder to instantiate this worker task.
+    pub fn builder(context: Context, consumer: QueueConsumer) -> QueueWorkerBuilder {
+        QueueWorkerBuilder {
+            context,
+            queue: Arc::new(consumer),
+            interval: None,
+            retry_attempts: None,
+        }
+    }
+
+    /// Run the worker.
+    ///
+    /// The queue is polled at the defined interval (see [`QueueWorkerBuilder::interval`]).
+    ///
+    /// This function does not return.
+    pub async fn run(mut self) -> ! {
+        loop {
+            self.process_queued_notifications().await;
+            self.wait().await;
+        }
+    }
+
+    async fn process_queued_notifications(&mut self) {
+        // Hold the queue lock for the whole cycle, so that no other consumer of the same queue
+        // directory claims, requeues or resolves notifications concurrently.
+        let lock_guard = match self.lock_queue().await {
+            Ok(Some(guard)) => Arc::new(guard),
+            Ok(None) => {
+                tracing::debug!("queue directory is locked by another consumer, skipping cycle");
+                return;
+            }
+            Err(err) => {
+                tracing::error!("failed to lock queue: {err}");
+                self.polling_backoff.increment_error_count();
+                return;
+            }
+        };
+
+        let mut any_error = false;
+
+        let queued_notifications = self
+            .queued_notifications()
+            .await
+            .inspect_err(|err| {
+                tracing::error!("failed to read queue: {err}");
+                any_error = true
+            })
+            .unwrap_or_default();
+
+        for queued_notification in queued_notifications {
+            let id = queued_notification.id().clone();
+            let queue = Arc::clone(&self.queue);
+            let context = self.context.clone();
+            let max_retries = self.retry_attempts;
+            // The blocking task keeps running if this future is dropped, e.g. on daemon shutdown.
+            // Keep the queue locked until it finishes, so that no other worker can pick up the
+            // same notification while it is still being sent.
+            let lock_guard = Arc::clone(&lock_guard);
+
+            let res = tokio::task::spawn_blocking(move || {
+                let _lock_guard = lock_guard;
+                let current_attempt = queued_notification.attempt();
+                let id = queued_notification.id().clone();
+
+                if current_attempt > max_retries {
+                    tracing::warn!("dropping notification {id} after attempt {current_attempt}");
+                    queue.resolve(queued_notification)?;
+
+                    return Ok(HistoryEntry {
+                        status: HistoryStatus::Dropped,
+                        id,
+                    });
+                }
+
+                // In most cases, we handle at most one notification in each cycle. If there are
+                // multiple to handle, it makes sense to re-read the config after each one, in case
+                // sending of one notification ran into long SMTP/HTTP timeouts.
+                let config = context
+                    .read_config()
+                    .map_err(Error::config_deserialization)?;
+
+                // The notification is claimed *after* the configuration was read, to ensure
+                // that a temporarily broken notification config does *not* lead to notifications
+                // being dropped because they have exceeded the maximum number of retries.
+                let queued_notification = queue.claim(queued_notification)?;
+
+                let notification = match queue.read_notification(&queued_notification) {
+                    Ok(notification) => notification,
+                    Err(err) => {
+                        if matches!(err, Error::InvalidQueuedNotification { .. }) {
+                            tracing::error!("marking notification as broken: {err}");
+                            // If the notification itself is bad, we move it aside and don't
+                            // process it again.
+                            queue.mark_broken(queued_notification)?;
+                        }
+                        return Err(err);
+                    }
+                };
+
+                tracing::info!("handling notification {}", queued_notification.id());
+
+                match crate::send(&context, &config, &notification) {
+                    Ok(_receipt) => {
+                        queue.resolve(queued_notification)?;
+
+                        Ok(HistoryEntry {
+                            id,
+                            status: HistoryStatus::Sent,
+                        })
+                    }
+                    Err(err) => {
+                        // An error here means that the notification for sure was
+                        // not sent to anyone, because sending failed at some point
+                        // *before* a single target was notified.
+                        //
+                        // The notification itself is fine, so we keep it around by
+                        // putting it back into the queue.
+                        // The returned error leads to the backoff error count being
+                        // increased, triggering the backoff mechanism to avoid spamming
+                        // logs every couple seconds.
+                        queue.requeue(queued_notification)?;
+
+                        Err(err)
+                    }
+                }
+            })
+            .await;
+
+            match res {
+                Ok(Ok(_history_entry)) => {
+                    #[cfg(test)]
+                    self.history.push(_history_entry);
+                }
+                Ok(Err(err)) => {
+                    tracing::error!(
+                        "notification worker failed to handle notification {id}: {err}"
+                    );
+                    any_error = true;
+
+                    if matches!(err, Error::ConfigDeserialization(_)) {
+                        // There is no point in processing the remaining queue if the config
+                        // does not parse, let's just retry at the next cycle.
+                        break;
+                    }
+                }
+                Err(err) => {
+                    tracing::error!(
+                        "failed to join task in notification worker for notification {id}: {err}"
+                    );
+                    any_error = true;
+                }
+            }
+        }
+
+        if any_error {
+            self.polling_backoff.increment_error_count();
+        } else {
+            self.polling_backoff.reset_error_count();
+        }
+    }
+
+    async fn lock_queue(&self) -> Result<Option<QueueLockGuard>, Error> {
+        let queue = Arc::clone(&self.queue);
+        tokio::task::spawn_blocking(move || queue.try_lock())
+            .await
+            .map_err(|err| Error::other_with_source("could not join tokio task", err))?
+    }
+
+    async fn queued_notifications(&self) -> Result<Vec<QueuedNotification>, Error> {
+        let queue = Arc::clone(&self.queue);
+        tokio::task::spawn_blocking(move || queue.queued_notifications())
+            .await
+            .map_err(|err| Error::other_with_source("could not join tokio task", err))?
+    }
+
+    async fn wait(&self) {
+        tokio::time::sleep(self.polling_backoff.active_interval()).await;
+    }
+}
+
+#[derive(Debug, PartialEq)]
+enum HistoryStatus {
+    Sent,
+    Dropped,
+}
+
+#[derive(Debug, PartialEq)]
+// Added for better testability, once the notification history is implemented,
+// this would be extended and moved to api_types.
+struct HistoryEntry {
+    id: Uuid,
+    status: HistoryStatus,
+}
+
+/// Number of consecutive erroneous cycles after which the polling interval is raised.
+const BACKOFF_THRESHOLD: u64 = 10;
+/// Factor by which the polling interval is raised while backing off.
+const BACKOFF_FACTOR: u32 = 10;
+
+struct PollingBackoff {
+    default_interval: Duration,
+    error_count: u64,
+}
+
+impl PollingBackoff {
+    fn new(interval: Duration) -> Self {
+        Self {
+            default_interval: interval,
+            error_count: 0,
+        }
+    }
+
+    fn is_backing_off(&self) -> bool {
+        self.error_count > BACKOFF_THRESHOLD
+    }
+
+    fn increment_error_count(&mut self) {
+        let was_backing_off = self.is_backing_off();
+        self.error_count = self.error_count.saturating_add(1);
+
+        if !was_backing_off && self.is_backing_off() {
+            tracing::info!(
+                "notification worker encountered several errors in succession, raising polling interval to {:?}",
+                self.active_interval()
+            );
+        }
+    }
+
+    fn reset_error_count(&mut self) {
+        let was_backing_off = self.is_backing_off();
+        self.error_count = 0;
+
+        if was_backing_off {
+            tracing::info!(
+                "notification worker resetting queue polling interval to default of {:?}",
+                self.default_interval
+            );
+        }
+    }
+
+    fn active_interval(&self) -> Duration {
+        if self.is_backing_off() {
+            self.default_interval.saturating_mul(BACKOFF_FACTOR)
+        } else {
+            self.default_interval
+        }
+    }
+}
+
+#[cfg(all(test, feature = "queue-submitter"))]
+mod test {
+    use std::cell::Cell;
+    use std::time::SystemTime;
+
+    use proxmox_sys::fs::CreateOptions;
+    use tempfile::{TempDir, tempdir};
+
+    use crate::Notification;
+    use crate::context::test::TestContext;
+    use crate::queue::QueueSubmitter;
+
+    use super::*;
+
+    struct WorkerTestSetup {
+        dir: TempDir,
+        consumer: QueueConsumer,
+        submitter: QueueSubmitter,
+        submitted: Cell<u64>,
+    }
+
+    impl WorkerTestSetup {
+        fn new() -> Self {
+            let dir = tempdir().unwrap();
+
+            Self {
+                consumer: QueueConsumer::new(dir.path()),
+                submitter: QueueSubmitter::new(dir.path(), CreateOptions::new()),
+                submitted: Cell::new(0),
+                dir,
+            }
+        }
+
+        fn submit_notification(&self) -> Uuid {
+            let notification = Notification::template_builder("foo", ()).build().unwrap();
+            self.submitter.submit(&notification).unwrap();
+
+            // Notifications submitted in quick succession may share the same mtime, so give each one
+            // a distinct one to have them handled in submission order.
+            let count = self.submitted.get();
+            self.submitted.set(count + 1);
+
+            let path = self
+                .dir
+                .path()
+                .join(format!("notification-{}", notification.id()));
+            std::fs::File::options()
+                .write(true)
+                .open(path)
+                .unwrap()
+                .set_modified(SystemTime::UNIX_EPOCH + Duration::from_secs(count))
+                .unwrap();
+
+            notification.id().clone()
+        }
+
+        /// Claim all queued notifications without resolving them, like a worker that got
+        /// interrupted while sending.
+        fn claim_all(&self) {
+            for queued in self.consumer.queued_notifications().unwrap() {
+                self.consumer.claim(queued).unwrap();
+            }
+        }
+
+        fn attempts(&self) -> Vec<u32> {
+            self.consumer
+                .queued_notifications()
+                .unwrap()
+                .iter()
+                .map(QueuedNotification::attempt)
+                .collect()
+        }
+
+        fn create_worker(
+            &self,
+            config_readable: bool,
+            retries_before_drop: Option<u32>,
+        ) -> QueueWorker {
+            // With the default empty config, sending succeeds without reaching any target.
+            let context = Context::new(TestContext {
+                fail_read_config: !config_readable,
+            });
+            let mut builder = QueueWorker::builder(context, QueueConsumer::new(self.dir.path()));
+
+            if let Some(attempts) = retries_before_drop {
+                builder = builder.retry_attempts(attempts);
+            }
+
+            builder.build()
+        }
+    }
+
+    fn run_single_cycle(worker: &mut QueueWorker) {
+        tokio::runtime::Builder::new_current_thread()
+            .build()
+            .unwrap()
+            .block_on(worker.process_queued_notifications());
+    }
+
+    #[test]
+    fn test_send_with_defaults() {
+        let setup = WorkerTestSetup::new();
+        let ids = [setup.submit_notification(), setup.submit_notification()];
+
+        let mut worker = setup.create_worker(true, None);
+        run_single_cycle(&mut worker);
+
+        assert!(setup.attempts().is_empty());
+        // Queued notifications are handled oldest first.
+        assert_eq!(
+            worker.history,
+            ids.map(|id| HistoryEntry {
+                id,
+                status: HistoryStatus::Sent,
+            })
+        );
+        assert_eq!(worker.polling_backoff.error_count, 0);
+    }
+
+    #[test]
+    fn test_skip_cycle_while_locked() {
+        let setup = WorkerTestSetup::new();
+        let id = setup.submit_notification();
+
+        let mut worker = setup.create_worker(true, None);
+
+        let guard = setup.consumer.try_lock().unwrap().unwrap();
+        run_single_cycle(&mut worker);
+
+        // Another consumer holds the lock, so the notification must not be touched.
+        assert_eq!(setup.attempts(), [0]);
+        assert!(worker.history.is_empty());
+        assert_eq!(worker.polling_backoff.error_count, 0);
+
+        drop(guard);
+        run_single_cycle(&mut worker);
+
+        assert!(setup.attempts().is_empty());
+        assert_eq!(
+            worker.history,
+            [HistoryEntry {
+                id,
+                status: HistoryStatus::Sent,
+            }]
+        );
+    }
+
+    #[test]
+    fn test_config_error_keeps_notification() {
+        let setup = WorkerTestSetup::new();
+        let id = setup.submit_notification();
+
+        let mut worker = setup.create_worker(false, None);
+        run_single_cycle(&mut worker);
+
+        // A config error must not count as an interrupted send.
+        assert_eq!(setup.attempts(), [0]);
+        assert!(worker.history.is_empty());
+        assert_eq!(worker.polling_backoff.error_count, 1);
+
+        // Once the config can be read again, the notification is sent.
+        let mut worker = setup.create_worker(true, None);
+        run_single_cycle(&mut worker);
+
+        assert!(setup.attempts().is_empty());
+        assert_eq!(
+            worker.history,
+            [HistoryEntry {
+                id,
+                status: HistoryStatus::Sent,
+            }]
+        );
+    }
+
+    #[test]
+    fn test_recover_interrupted_send() {
+        let setup = WorkerTestSetup::new();
+        let id = setup.submit_notification();
+        setup.claim_all();
+        assert_eq!(setup.attempts(), [1]);
+
+        let mut worker = setup.create_worker(true, Some(1));
+        run_single_cycle(&mut worker);
+
+        assert!(setup.attempts().is_empty());
+        assert_eq!(
+            worker.history,
+            [HistoryEntry {
+                id,
+                status: HistoryStatus::Sent,
+            }]
+        );
+        assert_eq!(worker.polling_backoff.error_count, 0);
+    }
+
+    #[test]
+    fn test_drop_after_recovery_attempts() {
+        let setup = WorkerTestSetup::new();
+        let id = setup.submit_notification();
+        setup.claim_all();
+        setup.claim_all();
+        assert_eq!(setup.attempts(), [2]);
+
+        let mut worker = setup.create_worker(true, Some(1));
+        run_single_cycle(&mut worker);
+
+        assert!(setup.attempts().is_empty());
+        assert_eq!(
+            worker.history,
+            [HistoryEntry {
+                id,
+                status: HistoryStatus::Dropped,
+            }]
+        );
+    }
+
+    #[test]
+    fn test_default_drops_interrupted_send() {
+        let setup = WorkerTestSetup::new();
+        let id = setup.submit_notification();
+        setup.claim_all();
+
+        let mut worker = setup.create_worker(true, None);
+        run_single_cycle(&mut worker);
+
+        assert!(setup.attempts().is_empty());
+        assert_eq!(
+            worker.history,
+            [HistoryEntry {
+                id,
+                status: HistoryStatus::Dropped,
+            }]
+        );
+    }
+
+    #[test]
+    fn test_unreadable_notification_marked_broken() {
+        let setup = WorkerTestSetup::new();
+        let valid_id = setup.submit_notification();
+
+        let broken_id = Uuid::generate();
+        std::fs::write(
+            setup.dir.path().join(format!("notification-{broken_id}")),
+            b"not json",
+        )
+        .unwrap();
+
+        let mut worker = setup.create_worker(true, None);
+        run_single_cycle(&mut worker);
+
+        // The broken notification is moved aside and does not keep the other one from being sent.
+        assert!(setup.attempts().is_empty());
+        assert_eq!(
+            worker.history,
+            [HistoryEntry {
+                id: valid_id,
+                status: HistoryStatus::Sent,
+            }]
+        );
+        assert!(
+            setup
+                .dir
+                .path()
+                .join(format!("notification-{broken_id}.attempt-1.broken"))
+                .exists()
+        );
+
+        // A broken notification is not picked up again.
+        run_single_cycle(&mut worker);
+
+        assert_eq!(worker.history.len(), 1);
+    }
+
+    #[test]
+    fn test_interval_backoff() {
+        let interval = Duration::from_secs(1);
+        let mut backoff = PollingBackoff::new(interval);
+
+        for _ in 0..10 {
+            backoff.increment_error_count();
+        }
+        assert_eq!(backoff.active_interval(), interval);
+
+        backoff.increment_error_count();
+        assert_eq!(backoff.active_interval(), interval * 10);
+
+        backoff.reset_error_count();
+        assert_eq!(backoff.active_interval(), interval);
+
+        // Backoff must trigger again after another series of errors.
+        for _ in 0..11 {
+            backoff.increment_error_count();
+        }
+        assert_eq!(backoff.active_interval(), interval * 10);
+    }
+
+    #[test]
+    fn test_interval_backoff_saturates() {
+        let mut backoff = PollingBackoff::new(Duration::MAX);
+
+        for _ in 0..11 {
+            backoff.increment_error_count();
+        }
+        assert_eq!(backoff.active_interval(), Duration::MAX);
+    }
+}
-- 
2.47.3





  parent reply	other threads:[~2026-11-18  9:52 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 ` [PATCH proxmox v2 39/63] notify: add send receipts Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 40/63] notify: make sure that template name matches SAFE_ID_REGEX Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 41/63] notify: implement notification queue submitter Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 42/63] notify: context: add read_config Lukas Wagner
2026-11-18  9:43 ` [PATCH proxmox v2 43/63] notify: queue: add queue consumer Lukas Wagner
2026-11-18  9:43 ` Lukas Wagner [this message]
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-45-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