From 373d47e5bdb5843fa64dbbe6b079d81ff6ef9f42 Mon Sep 17 00:00:00 2001 From: John Coffey Date: Sun, 8 Nov 2026 23:33:01 -0700 Subject: [PATCH 1/2] A domain's queued tasks follow it: deleted, set to manual, or replaced (#327) A domain's DKIM, DNS and certificate renewal tasks were left behind: - Deleting the domain left them queued. When they ran they ended as Failed ("Domain not found"), and stayed in the task list. - Setting DKIM key management to manual left the rotation task, which later failed with "not set to automatic". - Setting it back to automatic queued a new DKIM task beside the old one, so the domain had two. Now: - Deleting a domain removes its DKIM management, DNS management and certificate renewal tasks. - A save that turns DKIM, DNS or certificate management from automatic to manual removes the matching task. - A save that queues a DKIM task removes the domain's queued one first, the way a new renewal already replaces the queued one (#290). - A task whose domain is gone, or no longer manages that part itself, ends quietly instead of as Failed, so installs that already have stale tasks clear them on their next run. clear_queued_renewals is now one case of clear_queued_domain_tasks. A task that's running at that moment is left alone, as before. The DKIM automation test checks that manual removes the task, automatic again leaves one, a second save still leaves one, and deleting the domain leaves none. Reported on the forum (t/232, posts 8 and 9). --- crates/jmap/src/registry/mapping/domain.rs | 44 +++++++++- crates/jmap/src/registry/set.rs | 58 +++++++++++-- crates/services/src/task_manager/acme.rs | 17 +++- crates/services/src/task_manager/dkim.rs | 8 +- crates/services/src/task_manager/dns.rs | 8 +- .../services/src/task_manager/domain_check.rs | 29 ++++++- tests/src/automation/dkim.rs | 82 +++++++++++++++++++ 7 files changed, 227 insertions(+), 19 deletions(-) diff --git a/crates/jmap/src/registry/mapping/domain.rs b/crates/jmap/src/registry/mapping/domain.rs index 1eca4f02..e937887e 100644 --- a/crates/jmap/src/registry/mapping/domain.rs +++ b/crates/jmap/src/registry/mapping/domain.rs @@ -13,7 +13,9 @@ use common::network::{dkim::generate_dkim_selector, dns::update::DnsUpdater}; use jmap_proto::error::set::{SetError, SetErrorType}; use registry::{ schema::{ - enums::{AcmeChallengeType, DkimSignatureType, DnsRecordType, TenantStorageQuota}, + enums::{ + AcmeChallengeType, DkimSignatureType, DnsRecordType, TaskType, TenantStorageQuota, + }, prelude::{ObjectType, Property}, structs::{ AcmeProvider, CertificateManagement, DkimManagement, DkimManagementProperties, @@ -211,6 +213,46 @@ pub(crate) async fn validate_domain( Ok(Ok(response)) } +/// inbuxa: the queued tasks a saved domain should lose (#327): those for +/// something it stopped managing itself, and its DKIM task when the save +/// queues a new one, which would otherwise run alongside it for good. +pub(crate) fn domain_tasks_to_clear( + domain: &Domain, + old_domain: &Domain, + tasks: &[Task], +) -> Vec { + let mut types = Vec::new(); + let stopped = |was: bool, is: bool| was && !is; + if stopped( + matches!(old_domain.dkim_management, DkimManagement::Automatic(_)), + matches!(domain.dkim_management, DkimManagement::Automatic(_)), + ) || tasks + .iter() + .any(|task| matches!(task, Task::DkimManagement(_))) + { + types.push(TaskType::DkimManagement); + } + if stopped( + matches!(old_domain.dns_management, DnsManagement::Automatic(_)), + matches!(domain.dns_management, DnsManagement::Automatic(_)), + ) { + types.push(TaskType::DnsManagement); + } + if stopped( + matches!( + old_domain.certificate_management, + CertificateManagement::Automatic(_) + ), + matches!( + domain.certificate_management, + CertificateManagement::Automatic(_) + ), + ) { + types.push(TaskType::AcmeRenewal); + } + types +} + /// inbuxa: whether a save changed what the domain's certificate is ordered /// for. The renewal task decides what to do about it: a certificate that /// already has these names just waits for its renewal date (#290). diff --git a/crates/jmap/src/registry/set.rs b/crates/jmap/src/registry/set.rs index 8c562280..9685d0d7 100644 --- a/crates/jmap/src/registry/set.rs +++ b/crates/jmap/src/registry/set.rs @@ -15,7 +15,7 @@ use crate::registry::{ action::action_set, bootstrap::bootstrap_set, dkim::validate_dkim_signature, - domain::{validate_dns_server, validate_domain}, + domain::{domain_tasks_to_clear, validate_dns_server, validate_domain}, map_bootstrap_error, principal::{ AccountUpdate, build_set_error, schedule_account_destruction, validate_account, @@ -48,7 +48,7 @@ use jmap_tools::{JsonPointer, JsonPointerItem, Key}; use registry::{ jmap::{JmapValue, JsonPointerPatch, MaybeUnpatched, RegistryValue}, schema::{ - enums::{Permission, TenantStorageQuota}, + enums::{Permission, TaskType, TenantStorageQuota}, prelude::{ OBJ_FILTER_ACCOUNT, OBJ_FILTER_TENANT, OBJ_SINGLETON, Object, ObjectInner, ObjectType, Property, @@ -60,7 +60,10 @@ use registry::{ }, types::id::ObjectId, }; -use services::task_manager::{domain_check::clear_queued_renewals, lock::TaskLockManager}; +use services::task_manager::{ + domain_check::{clear_queued_domain_tasks, clear_queued_renewals}, + lock::TaskLockManager, +}; use std::borrow::Cow; use store::{ registry::{ @@ -776,6 +779,20 @@ impl RegistrySet for Server { } }; + // inbuxa: #327: the queued tasks this save leaves the domain + // without, cleared below once it's written + let cleared_types = match (&modification, &new_object.inner) { + (Modification::Update { object, .. }, ObjectInner::Domain(domain)) => { + match &object.inner { + ObjectInner::Domain(old_domain) => { + domain_tasks_to_clear(domain, old_domain, &tasks) + } + _ => Vec::new(), + } + } + _ => Vec::new(), + }; + let object_id = match (modification, result) { (Modification::Update { id, object }, RegistryWriteResult::Success(_)) => { cache_invalidator.process_update(id, &object, &new_object); @@ -863,14 +880,14 @@ impl RegistrySet for Server { }; // Dispatch tasks - if !tasks.is_empty() + if (!tasks.is_empty() || !cleared_types.is_empty()) && let Some(object_id) = object_id { let mut batch = BatchBuilder::new(); // inbuxa: a new renewal replaces the domain's queued // one, or both would keep renewing from here on (#290) - let replaced = if tasks.iter().any(|task| { + let mut replaced = if tasks.iter().any(|task| { matches!( task, Task::AcmeRenewal(_) @@ -884,6 +901,15 @@ impl RegistrySet for Server { } else { Vec::new() }; + replaced.extend( + clear_queued_domain_tasks( + set.server, + object_id, + &cleared_types, + &mut batch, + ) + .await?, + ); for mut task in tasks.drain(..) { match &mut task { @@ -992,6 +1018,28 @@ impl RegistrySet for Server { ); } + // inbuxa: #327: a domain's queued tasks go with it + if matches!(object.inner, ObjectInner::Domain(_)) { + let mut batch = BatchBuilder::new(); + let cleared = clear_queued_domain_tasks( + set.server, + id, + &[ + TaskType::DkimManagement, + TaskType::DnsManagement, + TaskType::AcmeRenewal, + ], + &mut batch, + ) + .await?; + if !cleared.is_empty() { + set.server.store().write(batch.build_all()).await?; + for id in cleared { + set.server.remove_index_lock(id).await; + } + } + } + // inbuxa: ME-3 if let ObjectInner::MaskedEmail(mask) = &object.inner { crate::inbuxa::masked_email::destroyed(self, id, mask).await?; diff --git a/crates/services/src/task_manager/acme.rs b/crates/services/src/task_manager/acme.rs index 662fc4c9..429457a3 100644 --- a/crates/services/src/task_manager/acme.rs +++ b/crates/services/src/task_manager/acme.rs @@ -6,7 +6,7 @@ use crate::task_manager::{TaskFailureType, TaskResult}; use common::{Server, network::acme::AcmeError}; -use registry::schema::structs::TaskDomainManagement; +use registry::schema::structs::{CertificateManagement, Domain, TaskDomainManagement}; use std::time::Duration; use store::write::now; @@ -41,6 +41,21 @@ const MAX_RETRIES: u32 = 5; #[allow(unused_variables)] async fn acme_management(server: &Server, task: &TaskDomainManagement) -> trc::Result { + // inbuxa: a domain that's gone, or no longer orders its own certificate, + // has nothing for this task to do: it goes quietly instead of failing (#327) + if !server + .registry() + .object::(task.domain_id) + .await? + .is_some_and(|domain| { + matches!( + domain.certificate_management, + CertificateManagement::Automatic(_) + ) + }) + { + return Ok(TaskResult::Ignored); + } let mut last_temporary_error = Ok(TaskResult::temporary("")); for retry in 0..MAX_RETRIES { last_temporary_error = match Box::pin(server.acme_renew(task.domain_id)).await { diff --git a/crates/services/src/task_manager/dkim.rs b/crates/services/src/task_manager/dkim.rs index 341831d8..0bb00ec9 100644 --- a/crates/services/src/task_manager/dkim.rs +++ b/crates/services/src/task_manager/dkim.rs @@ -60,13 +60,13 @@ impl DkimManagementTask for Server { } async fn dkim_management(server: &Server, task: &TaskDomainManagement) -> trc::Result { + // inbuxa: a domain that's gone, or no longer rotates its own keys, has + // nothing for this task to do: it goes quietly instead of failing (#327) let Some(domain) = server.registry().object::(task.domain_id).await? else { - return Ok(TaskResult::permanent("Domain not found".to_string())); + return Ok(TaskResult::Ignored); }; let DkimManagement::Automatic(dkim) = domain.dkim_management else { - return Ok(TaskResult::permanent( - "Domain is not set to automatic DKIM management".to_string(), - )); + return Ok(TaskResult::Ignored); }; let configured = dkim.algorithms.into_inner(); if configured.is_empty() { diff --git a/crates/services/src/task_manager/dns.rs b/crates/services/src/task_manager/dns.rs index 7675350e..8d61dd33 100644 --- a/crates/services/src/task_manager/dns.rs +++ b/crates/services/src/task_manager/dns.rs @@ -110,13 +110,13 @@ async fn dns_management(server: &Server, task: &TaskDnsManagement) -> trc::Resul "No DNS records to update".to_string(), )); } + // inbuxa: a domain that's gone, or no longer publishes its own records, + // has nothing for this task to do: it goes quietly instead of failing (#327) let Some(domain) = server.registry().object::(task.domain_id).await? else { - return Ok(TaskResult::permanent("Domain not found".to_string())); + return Ok(TaskResult::Ignored); }; let DnsManagement::Automatic(props) = &domain.dns_management else { - return Ok(TaskResult::permanent( - "Domain is not set to automatic DNS management".to_string(), - )); + return Ok(TaskResult::Ignored); }; let dns_updater = match server.build_dns_updater(props.dns_server_id).await? { Ok(updater) => updater, diff --git a/crates/services/src/task_manager/domain_check.rs b/crates/services/src/task_manager/domain_check.rs index 369bfe1e..a4e5ed92 100644 --- a/crates/services/src/task_manager/domain_check.rs +++ b/crates/services/src/task_manager/domain_check.rs @@ -166,9 +166,27 @@ pub async fn clear_queued_renewals( server: &Server, domain_id: Id, batch: &mut BatchBuilder, +) -> trc::Result> { + clear_queued_domain_tasks(server, domain_id, &[TaskType::AcmeRenewal], batch).await +} + +/// inbuxa: adds to `batch` the removal of a domain's queued tasks of the +/// given types (DKIM management, DNS management, certificate renewal), +/// whatever their state. For a domain that's gone, a task about to be +/// replaced, or one the domain no longer runs (#327). Like +/// [`clear_queued_renewals`], it returns the tasks it locked, and a task +/// running right now stays. +pub async fn clear_queued_domain_tasks( + server: &Server, + domain_id: Id, + types: &[TaskType], + batch: &mut BatchBuilder, ) -> trc::Result> { let mut locked = Vec::new(); - for (due, id) in queued_tasks(server, &[TaskType::AcmeRenewal]).await? { + if types.is_empty() { + return Ok(locked); + } + for (due, id) in queued_tasks(server, types).await? { let task = server .store() .get_value::(ValueKey::from(ValueClass::TaskQueue( @@ -176,9 +194,12 @@ pub async fn clear_queued_renewals( ))) .await .caused_by(trc::location!())?; - if matches!(task, Some(Task::AcmeRenewal(task)) if task.domain_id == domain_id) - && server.try_lock_task(id).await - { + let task_domain_id = match &task { + Some(Task::AcmeRenewal(task)) | Some(Task::DkimManagement(task)) => task.domain_id, + Some(Task::DnsManagement(task)) => task.domain_id, + _ => continue, + }; + if task_domain_id == domain_id && server.try_lock_task(id).await { batch .clear(ValueClass::TaskQueue(TaskQueueClass::Task { id })) .clear(ValueClass::TaskQueue(TaskQueueClass::Due { id, due })); diff --git a/tests/src/automation/dkim.rs b/tests/src/automation/dkim.rs index 475490fc..94295ded 100644 --- a/tests/src/automation/dkim.rs +++ b/tests/src/automation/dkim.rs @@ -43,6 +43,7 @@ pub async fn test(test: &TestServer) { .await; automatic_to_manual_dns_test(test).await; orphaned_keys_test(test).await; + domain_tasks_follow_settings_test(test).await; println!("Running DKIM Management tests..."); let account = test.account("admin@example.org"); @@ -717,6 +718,87 @@ async fn automatic_to_manual_dns_test(test: &TestServer) { account.registry_destroy_all(ObjectType::DnsServer).await; } +/// #327: a domain's DKIM task goes when DKIM is set to manual, isn't doubled +/// when it's set back to automatic, and goes with the domain. +async fn domain_tasks_follow_settings_test(test: &TestServer) { + println!("Running DKIM task lifecycle tests..."); + let account = test.account("admin@example.org"); + DNS_RECORDS.lock().unwrap().clear(); + account.dkim_signatures().await.assert_total(0, 0); + let dns_server_id = account.create_memory_dns_server().await; + + let domain_id = account + .registry_create_object(Domain { + name: "dkim-tasks.org".to_string(), + certificate_management: CertificateManagement::Manual, + dkim_management: dkim_management(LONG_ROTATION_MS), + dns_management: dns_management(dns_server_id), + ..Default::default() + }) + .await; + account + .wait_for_dkim_stages(&[(DkimRotationStage::Active, 2)]) + .await; + account.wait_for_dkim_task_count(domain_id, 1).await; + + // Manual: the queued rotation goes now, not when it's due + account + .registry_update_object( + ObjectType::Domain, + domain_id, + json!({ Property::DkimManagement: DkimManagement::Manual }), + ) + .await; + account.wait_for_dkim_task_count(domain_id, 0).await; + + // Automatic again: one task, not a second beside a leftover + account + .registry_update_object( + ObjectType::Domain, + domain_id, + json!({ Property::DkimManagement: dkim_management(LONG_ROTATION_MS) }), + ) + .await; + account.wait_for_dkim_task_count(domain_id, 1).await; + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + account.wait_for_dkim_task_count(domain_id, 1).await; + + // Saving it again, changed, still leaves one + account + .registry_update_object( + ObjectType::Domain, + domain_id, + json!({ Property::DkimManagement: dkim_management(LONG_ROTATION_MS + 1000) }), + ) + .await; + tokio::time::sleep(std::time::Duration::from_secs(2)).await; + account.wait_for_dkim_task_count(domain_id, 1).await; + + // Deleted: its tasks go with it + account + .registry_destroy(ObjectType::Domain, [domain_id]) + .await + .assert_destroyed(&[domain_id]); + account.wait_for_dkim_task_count(domain_id, 0).await; + assert!( + account + .tasks() + .await + .is_none_or(|tasks| !tasks.iter().any(|task| matches!( + &task.task, + Task::DnsManagement(task) if task.domain_id == domain_id + ))), + "a deleted domain's DNS tasks stay queued" + ); + + // Cleanup + account.registry_destroy_all(ObjectType::Task).await; + account + .registry_destroy_all(ObjectType::DkimSignature) + .await; + account.registry_destroy_all(ObjectType::DnsServer).await; +} + async fn manual_dns_pending_test(test: &TestServer) { println!("Running DKIM pending key under manual DNS tests..."); let account = test.account("admin@example.org"); -- 2.54.0 From c336b24073ca8c078ce20c4fc8ed5ad8c4db334c Mon Sep 17 00:00:00 2001 From: John Coffey Date: Sun, 8 Nov 2026 23:55:23 -0700 Subject: [PATCH 2/2] Mark acme.rs and dkim.rs as modified for INBUXA (#327) --- crates/services/src/task_manager/acme.rs | 2 ++ crates/services/src/task_manager/dkim.rs | 2 ++ 2 files changed, 4 insertions(+) diff --git a/crates/services/src/task_manager/acme.rs b/crates/services/src/task_manager/acme.rs index 429457a3..eded1a97 100644 --- a/crates/services/src/task_manager/acme.rs +++ b/crates/services/src/task_manager/acme.rs @@ -2,6 +2,8 @@ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC * * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL + * + * Modified by Coffey Labs in 2026 for INBUXA. */ use crate::task_manager::{TaskFailureType, TaskResult}; diff --git a/crates/services/src/task_manager/dkim.rs b/crates/services/src/task_manager/dkim.rs index 0bb00ec9..3f86560b 100644 --- a/crates/services/src/task_manager/dkim.rs +++ b/crates/services/src/task_manager/dkim.rs @@ -2,6 +2,8 @@ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC * * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL + * + * Modified by Coffey Labs in 2026 for INBUXA. */ use crate::task_manager::TaskResult; -- 2.54.0