jcoffey-dev
b2453d066b
Eight conflicted files resolved, plus the lock file and the schema:
- crates/services/src/task_manager/spam_classifier.rs: upstream's rules
update now replaces existing rules, DNSBL servers, lookups and file
extensions, keeping only whether each is on. Taken, with one difference:
an object an admin edited is kept as it is. Every object an update writes
is fingerprinted (content without `enable`, SHA-256, stored under
SUBSPACE_INBUXA "Sf"), and only one that still matches is replaced.
Scores are never replaced, as upstream has it. The AU-1.10 summary record
now names what was added, replaced and kept, and the bundled rules are
marked applied only when the update fully succeeded, so a failure runs
again on the next start. The marker becomes "3.0.2+2", which runs the
update once on upgrade to fingerprint every rule still as bundled.
- crates/common/src/network/autoconfig/autodiscover.rs: upstream's rewrite
(implicit TLS first, labeled SSL), with the per-protocol switches (LP-7,
LP-14a) passed in as a filter.
- crates/store/src/backend/mysql/{search,write}.rs: upstream's chunked
deletes (no unbounded first DELETE, stop on a short chunk, halve the
chunk on the new chunk-too-large errors) inside the fork's query timeout.
- crates/smtp/src/lib.rs: the fork's queue spawn kept. It already fixed the
stall upstream fixes here (a node without outboundMta stops accepting
mail at about 1024 queued messages), and follows role changes live.
- crates/jmap/src/registry/mapping/bootstrap.rs: the log path stays
/var/log/inbuxa/; upstream's PowerDNS mapping taken.
- crates/main/Cargo.toml: the AGPL-only license kept, version 0.16.24.
- tests/src/jmap/principal/get.rs: the fork's capabilities kept.
- resources/schema/schema.json.gz: merged as JSON; upstream relabeled the
vendor Sieve extensions "(Stalwart)", kept as "(vnd.inbuxa)".
- Cargo.lock: upstream's, with the fork's crates added by Cargo.
Also:
- tests/src/smtp/inbound/spam_rules_kept.rs: an edited rule survives an
update, an unedited one is updated, rules from before fingerprints are
handled, and the audit summary says so. Upstream's own spam_rules test
passes unchanged.
- tests/src/smtp/reporting/reschedule.rs moves to port 19058; upstream's
new spam_rules test took 19057.
- tools/fork/renames.py renames the "(Stalwart)" labels and the default
log path, so neither conflicts again.
- tools/fork/notice-check.py compares against the newest snapshot in the
checked-out history instead of the upstream branch head, so moving the
branch no longer fails other open pull requests.
- tests/src/directory/issuer.rs (since v0.16.23) stays out, and is on the
build check's known list: it tests issuer-based directory routing, which
the fork doesn't have (DIR-2).
- Strip report: docs/fork/strip-reports/v0.16.24.{md,json}.
326 lines
10 KiB
Rust
326 lines
10 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::{RedisPool, RedisStore, into_error};
|
|
use crate::{Deserialize, write::now};
|
|
use deadpool::managed::{Manager, Object, Pool};
|
|
use redis::{AsyncCommands, RedisError, RedisResult, RetryMethod};
|
|
|
|
impl RedisStore {
|
|
pub async fn key_set(&self, key: &[u8], value: &[u8], expires: Option<u64>) -> trc::Result<()> {
|
|
match &self.pool {
|
|
RedisPool::Single(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
Self::key_set_(conn, key, value, expires).await
|
|
})
|
|
.await
|
|
}
|
|
RedisPool::Cluster(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
Self::key_set_(conn, key, value, expires).await
|
|
})
|
|
.await
|
|
}
|
|
RedisPool::Sentinel(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
Self::key_set_(conn, key, value, expires).await
|
|
})
|
|
.await
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn key_incr(&self, key: &[u8], value: i64, expires: Option<u64>) -> trc::Result<i64> {
|
|
match &self.pool {
|
|
RedisPool::Single(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
self.key_incr_(conn, key, value, expires).await
|
|
})
|
|
.await
|
|
}
|
|
RedisPool::Cluster(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
self.key_incr_(conn, key, value, expires).await
|
|
})
|
|
.await
|
|
}
|
|
RedisPool::Sentinel(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
self.key_incr_(conn, key, value, expires).await
|
|
})
|
|
.await
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn try_lock(&self, key: &[u8], expires: u64) -> trc::Result<bool> {
|
|
match &self.pool {
|
|
RedisPool::Single(pool) => {
|
|
with_conn(pool, async |conn| Self::try_lock_(conn, key, expires).await).await
|
|
}
|
|
RedisPool::Cluster(pool) => {
|
|
with_conn(pool, async |conn| Self::try_lock_(conn, key, expires).await).await
|
|
}
|
|
RedisPool::Sentinel(pool) => {
|
|
with_conn(pool, async |conn| Self::try_lock_(conn, key, expires).await).await
|
|
}
|
|
}
|
|
}
|
|
|
|
// inbuxa: see InMemoryStore::renew_lock
|
|
pub async fn renew_lock(&self, key: &[u8], expires: u64) -> trc::Result<bool> {
|
|
match &self.pool {
|
|
RedisPool::Single(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
Self::renew_lock_(conn, key, expires).await
|
|
})
|
|
.await
|
|
}
|
|
RedisPool::Cluster(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
Self::renew_lock_(conn, key, expires).await
|
|
})
|
|
.await
|
|
}
|
|
RedisPool::Sentinel(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
Self::renew_lock_(conn, key, expires).await
|
|
})
|
|
.await
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn key_delete(&self, key: &[u8]) -> trc::Result<()> {
|
|
match &self.pool {
|
|
RedisPool::Single(pool) => {
|
|
with_conn(pool, async |conn| Self::key_delete_(conn, key).await).await
|
|
}
|
|
RedisPool::Cluster(pool) => {
|
|
with_conn(pool, async |conn| Self::key_delete_(conn, key).await).await
|
|
}
|
|
RedisPool::Sentinel(pool) => {
|
|
with_conn(pool, async |conn| Self::key_delete_(conn, key).await).await
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn key_delete_prefix(&self, prefix: &[u8]) -> trc::Result<()> {
|
|
match &self.pool {
|
|
RedisPool::Single(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
Self::key_delete_prefix_(conn, prefix).await
|
|
})
|
|
.await
|
|
}
|
|
RedisPool::Cluster(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
Self::key_delete_prefix_(conn, prefix).await
|
|
})
|
|
.await
|
|
}
|
|
RedisPool::Sentinel(pool) => {
|
|
with_conn(pool, async |conn| {
|
|
Self::key_delete_prefix_(conn, prefix).await
|
|
})
|
|
.await
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn key_get<T: Deserialize + std::fmt::Debug + 'static>(
|
|
&self,
|
|
key: &[u8],
|
|
) -> trc::Result<Option<T>> {
|
|
let value = match &self.pool {
|
|
RedisPool::Single(pool) => {
|
|
with_conn(pool, async |conn| Self::key_get_(conn, key).await).await
|
|
}
|
|
RedisPool::Cluster(pool) => {
|
|
with_conn(pool, async |conn| Self::key_get_(conn, key).await).await
|
|
}
|
|
RedisPool::Sentinel(pool) => {
|
|
with_conn(pool, async |conn| Self::key_get_(conn, key).await).await
|
|
}
|
|
}?;
|
|
|
|
value.map(T::deserialize_owned).transpose()
|
|
}
|
|
|
|
pub async fn counter_get(&self, key: &[u8]) -> trc::Result<i64> {
|
|
match &self.pool {
|
|
RedisPool::Single(pool) => {
|
|
with_conn(pool, async |conn| Self::counter_get_(conn, key).await).await
|
|
}
|
|
RedisPool::Cluster(pool) => {
|
|
with_conn(pool, async |conn| Self::counter_get_(conn, key).await).await
|
|
}
|
|
RedisPool::Sentinel(pool) => {
|
|
with_conn(pool, async |conn| Self::counter_get_(conn, key).await).await
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn key_exists(&self, key: &[u8]) -> trc::Result<bool> {
|
|
match &self.pool {
|
|
RedisPool::Single(pool) => {
|
|
with_conn(pool, async |conn| Self::key_exists_(conn, key).await).await
|
|
}
|
|
RedisPool::Cluster(pool) => {
|
|
with_conn(pool, async |conn| Self::key_exists_(conn, key).await).await
|
|
}
|
|
RedisPool::Sentinel(pool) => {
|
|
with_conn(pool, async |conn| Self::key_exists_(conn, key).await).await
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn key_get_(conn: &mut impl AsyncCommands, key: &[u8]) -> RedisResult<Option<Vec<u8>>> {
|
|
redis::cmd("GET").arg(key).query_async(conn).await
|
|
}
|
|
|
|
async fn counter_get_(conn: &mut impl AsyncCommands, key: &[u8]) -> RedisResult<i64> {
|
|
redis::cmd("GET")
|
|
.arg(key)
|
|
.query_async::<Option<i64>>(conn)
|
|
.await
|
|
.map(|value| value.unwrap_or(0))
|
|
}
|
|
|
|
async fn key_exists_(conn: &mut impl AsyncCommands, key: &[u8]) -> RedisResult<bool> {
|
|
conn.exists(key).await
|
|
}
|
|
|
|
async fn key_set_(
|
|
conn: &mut impl AsyncCommands,
|
|
key: &[u8],
|
|
value: &[u8],
|
|
expires: Option<u64>,
|
|
) -> RedisResult<()> {
|
|
if let Some(expires) = expires {
|
|
conn.set_ex(key, value, expires).await
|
|
} else {
|
|
conn.set(key, value).await
|
|
}
|
|
}
|
|
|
|
async fn key_incr_(
|
|
&self,
|
|
conn: &mut impl AsyncCommands,
|
|
key: &[u8],
|
|
value: i64,
|
|
expires: Option<u64>,
|
|
) -> RedisResult<i64> {
|
|
if let Some(expires) = expires {
|
|
self.incr_expire
|
|
.key(key)
|
|
.arg(value)
|
|
.arg(expires as i64)
|
|
.invoke_async(conn)
|
|
.await
|
|
} else {
|
|
conn.incr(key, value).await
|
|
}
|
|
}
|
|
|
|
async fn try_lock_(
|
|
conn: &mut impl AsyncCommands,
|
|
key: &[u8],
|
|
expires: u64,
|
|
) -> RedisResult<bool> {
|
|
redis::cmd("SET")
|
|
.arg(key)
|
|
.arg(now() + expires)
|
|
.arg("NX")
|
|
.arg("EX")
|
|
.arg(expires as i64)
|
|
.query_async::<Option<String>>(conn)
|
|
.await
|
|
.map(|reply| reply.is_some())
|
|
}
|
|
|
|
async fn renew_lock_(
|
|
conn: &mut impl AsyncCommands,
|
|
key: &[u8],
|
|
expires: u64,
|
|
) -> RedisResult<bool> {
|
|
redis::cmd("SET")
|
|
.arg(key)
|
|
.arg(now() + expires)
|
|
.arg("XX")
|
|
.arg("EX")
|
|
.arg(expires as i64)
|
|
.query_async::<Option<String>>(conn)
|
|
.await
|
|
.map(|reply| reply.is_some())
|
|
}
|
|
|
|
async fn key_delete_(conn: &mut impl AsyncCommands, key: &[u8]) -> RedisResult<()> {
|
|
conn.del(key).await
|
|
}
|
|
|
|
async fn key_delete_prefix_(conn: &mut impl AsyncCommands, prefix: &[u8]) -> RedisResult<()> {
|
|
let mut pattern = Vec::with_capacity(prefix.len() + 1);
|
|
pattern.extend_from_slice(prefix);
|
|
pattern.push(b'*');
|
|
|
|
let mut cursor = 0;
|
|
loop {
|
|
let (new_cursor, keys): (u64, Vec<Vec<u8>>) = redis::cmd("SCAN")
|
|
.cursor_arg(cursor)
|
|
.arg("MATCH")
|
|
.arg(&pattern)
|
|
.arg("COUNT")
|
|
.arg(100)
|
|
.query_async(conn)
|
|
.await?;
|
|
|
|
if !keys.is_empty() {
|
|
conn.del::<_, ()>(&keys).await?;
|
|
}
|
|
|
|
if new_cursor != 0 {
|
|
cursor = new_cursor;
|
|
} else {
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn with_conn<M, T>(
|
|
pool: &Pool<M>,
|
|
operation: impl AsyncFnOnce(&mut M::Type) -> RedisResult<T>,
|
|
) -> trc::Result<T>
|
|
where
|
|
M: Manager<Error = trc::Error>,
|
|
{
|
|
let mut conn = pool.get().await.map_err(into_error)?;
|
|
|
|
match operation(conn.as_mut()).await {
|
|
Ok(value) => Ok(value),
|
|
Err(err) => {
|
|
if is_stale_connection(&err) {
|
|
drop(Object::take(conn));
|
|
}
|
|
Err(into_error(err))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn is_stale_connection(err: &RedisError) -> bool {
|
|
matches!(
|
|
err.retry_method(),
|
|
RetryMethod::Reconnect
|
|
| RetryMethod::ReconnectFromInitialConnections
|
|
| RetryMethod::RefreshSlotsAndRetry
|
|
| RetryMethod::MovedRedirect
|
|
| RetryMethod::AskRedirect
|
|
)
|
|
}
|