jcoffey-dev
5dde9793eb
The report scheduler dropped DMARC and TLS events on a node whose role lacks outboundMta (upstream never started it there, so they sat in a channel nobody read). Mail received on a front node therefore never reached an aggregate report, which is meant to cover all of a domain's inbound mail, whichever node received it. In rehearsal, five messages received on port 25 on a front node were missing from every report. - The report scheduler records on every node. Recording is a store write the nodes already share, so it needs nothing from the outbound MTA. Building and sending a report (the DmarcReport and TlsReport tasks) stay with outboundMta nodes, as the task manager already enforces. - More nodes now append to one report at once. Appends already guard the report's versioned primary key; a write that loses now retries up to ten times after a short random pause, not three times at once. - The node sending a report deletes it only if it is unchanged since it was read, and reads it again otherwise, so a record another node appends meanwhile goes out with the report instead of being deleted unsent. Test: cluster::front_reports (PostgreSQL and MySQL). A front node's results appear in the report the MTA node sends, alongside eight appended at once from both nodes, and the front node never runs the report task. It fails on main: the front node's results are never recorded.
65 lines
2.0 KiB
Rust
65 lines
2.0 KiB
Rust
/*
|
|
* SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
|
|
*
|
|
* SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL
|
|
*
|
|
* Modified by Coffey Labs in 2026 for INBUXA.
|
|
*/
|
|
|
|
// inbuxa: composite stores (sharded members, read replicas) nest store
|
|
// futures deeply enough to pass rustc's default query depth
|
|
#![recursion_limit = "512"]
|
|
|
|
#![warn(clippy::large_futures)]
|
|
|
|
use common::{
|
|
Inner,
|
|
manager::boot::{BootManager, IpcReceivers},
|
|
};
|
|
use queue::manager::SpawnQueue;
|
|
use reporting::scheduler::SpawnReport;
|
|
use std::sync::Arc;
|
|
|
|
pub mod core;
|
|
pub mod inbound;
|
|
pub mod outbound;
|
|
pub mod queue;
|
|
pub mod reporting;
|
|
pub mod scripts;
|
|
|
|
pub trait StartQueueManager {
|
|
fn start_queue_manager(&mut self);
|
|
}
|
|
|
|
pub trait SpawnQueueManager {
|
|
fn spawn_queue_manager(&mut self, inner: Arc<Inner>);
|
|
}
|
|
|
|
impl StartQueueManager for BootManager {
|
|
fn start_queue_manager(&mut self) {
|
|
self.ipc_rxs.spawn_queue_manager(self.inner.clone());
|
|
}
|
|
}
|
|
|
|
impl SpawnQueueManager for IpcReceivers {
|
|
fn spawn_queue_manager(&mut self, inner: Arc<Inner>) {
|
|
let core = inner.shared_core.load();
|
|
// inbuxa: upstream started these only when the node's role included
|
|
// outboundMta at boot, so turning the role on later did nothing and
|
|
// turning it off left them delivering until a restart. They now run
|
|
// on every node: the queue follows the role live (see Queue::start),
|
|
// and the report scheduler records DMARC and TLS results on every
|
|
// node, whatever its role (see reporting/scheduler.rs). This also
|
|
// drains the queue channel on nodes
|
|
// without the role, where every queued message's refresh used to sit
|
|
// in a channel nobody read until it filled and queueing blocked.
|
|
if !core.storage.registry.is_recovery_mode() {
|
|
// Spawn queue manager
|
|
self.queue_rx.take().unwrap().spawn(inner.clone());
|
|
|
|
// Spawn report manager
|
|
self.report_rx.take().unwrap().spawn(inner);
|
|
}
|
|
}
|
|
}
|