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.
43 lines
1.7 KiB
Rust
43 lines
1.7 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.
|
|
*/
|
|
|
|
use super::{dmarc::DmarcReporting, tls::TlsReporting};
|
|
use common::{BuildServer, Inner, ipc::ReportingEvent};
|
|
use std::sync::Arc;
|
|
use tokio::sync::mpsc;
|
|
|
|
pub trait SpawnReport {
|
|
fn spawn(self, core: Arc<Inner>);
|
|
}
|
|
|
|
impl SpawnReport for mpsc::Receiver<ReportingEvent> {
|
|
fn spawn(mut self, inner: Arc<Inner>) {
|
|
tokio::spawn(async move {
|
|
while let Some(event) = self.recv().await {
|
|
let server = inner.build_server();
|
|
// inbuxa: every node records what it received, whatever its
|
|
// role. An aggregate report covers all of a domain's mail,
|
|
// whichever node took it, and recording is a store write
|
|
// that nodes already share: the report's primary key is
|
|
// versioned, so concurrent appends from several nodes retry
|
|
// rather than overwrite. Only building and sending the
|
|
// report (the DmarcReport and TlsReport tasks) belongs to
|
|
// the outbound MTA; the task manager keeps those to nodes
|
|
// with that role. Upstream ran this only on outbound MTA
|
|
// nodes, so mail received anywhere else never reached a
|
|
// report.
|
|
match event {
|
|
ReportingEvent::Dmarc(event) => server.schedule_dmarc(event).await,
|
|
ReportingEvent::Tls(event) => server.schedule_tls(event).await,
|
|
ReportingEvent::Stop => break,
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|