From 226631ae628561cdb8474f4022f07539b0f42adf Mon Sep 17 00:00:00 2001 From: StefanSa Date: Fri, 13 Nov 2026 09:42:33 -0700 Subject: [PATCH] Automatic DNS: publish record types newly added to publishRecords With DNS management already Automatic, adding a record type to publishRecords was saved but queued no DNS task, so the new records were never published (the workaround was Manual and back to Automatic). An Automatic to Automatic save now queues one DNS task for the record types that are newly enabled. Removing a type deletes nothing, and the same set in another order queues nothing. New domains, Manual to Automatic, and the DKIM paths behave as before. Task planning moves into schedule_dns_tasks, with unit tests for each transition. Ported to main: keeps the #304 guard, so a domain with nothing to publish and no certificate to order still queues no DNS task, with a test for it. Fixes #372 --- crates/jmap/src/registry/mapping/domain.rs | 286 +++++++++++++++++---- 1 file changed, 233 insertions(+), 53 deletions(-) diff --git a/crates/jmap/src/registry/mapping/domain.rs b/crates/jmap/src/registry/mapping/domain.rs index e937887e..a6ccd4d8 100644 --- a/crates/jmap/src/registry/mapping/domain.rs +++ b/crates/jmap/src/registry/mapping/domain.rs @@ -102,58 +102,7 @@ pub(crate) async fn validate_domain( } } - // Schedule DNS update task - let will_trigger_dkim = matches!(domain.dkim_management, DkimManagement::Automatic(_)) - && old_domain - .is_none_or(|old| !matches!(old.dkim_management, DkimManagement::Automatic(_))); - let will_schedule_dkim = !will_trigger_dkim - && matches!(domain.dkim_management, DkimManagement::Automatic(_)) - && publishes_dkim(domain) - && old_domain.is_some_and(|old| !publishes_dkim(old)); - let will_trigger_acme = if let DnsManagement::Automatic(details) = &domain.dns_management - && old_domain.is_none_or(|old| !matches!(old.dns_management, DnsManagement::Automatic(_))) - { - let on_success_renew_certificate = old_domain.is_none() - && matches!( - domain.certificate_management, - CertificateManagement::Automatic(_) - ); - let update_records: Vec = details - .publish_records - .iter() - .filter(|&&r| r != DnsRecordType::Dkim || !will_trigger_dkim) - .copied() - .collect(); - // inbuxa: with nothing to publish and no certificate to order after, - // the task would only end as a failure (#304) - if !update_records.is_empty() || on_success_renew_certificate { - tasks.push(Task::DnsManagement(TaskDnsManagement { - domain_id: Id::default(), - update_records: Map::new(update_records), - on_success_renew_certificate, - status: TaskStatus::now(), - })); - } - on_success_renew_certificate - } else { - if will_schedule_dkim { - tasks.push(Task::DnsManagement(TaskDnsManagement { - domain_id: Id::default(), - update_records: Map::new(vec![DnsRecordType::Dkim]), - on_success_renew_certificate: false, - status: TaskStatus::now(), - })); - } - false - }; - - // Schedule DKIM key rotation task - if will_trigger_dkim || will_schedule_dkim { - tasks.push(Task::DkimManagement(TaskDomainManagement { - domain_id: Id::default(), - status: TaskStatus::now(), - })); - } + let will_trigger_acme = schedule_dns_tasks(domain, old_domain, tasks); // Schedule ACME renewal task if needed if !will_trigger_acme @@ -297,6 +246,65 @@ fn acme_records_outdated(domain: &Domain, old_domain: Option<&Domain>) -> bool { || old.subject_alternative_names.is_empty() != new.subject_alternative_names.is_empty() } +// Keep task planning independent of registry I/O so update transitions can be +// checked without contacting a DNS provider or starting a task manager. +fn schedule_dns_tasks(domain: &Domain, old_domain: Option<&Domain>, tasks: &mut Vec) -> bool { + let will_trigger_dkim = matches!(domain.dkim_management, DkimManagement::Automatic(_)) + && old_domain + .is_none_or(|old| !matches!(old.dkim_management, DkimManagement::Automatic(_))); + let will_schedule_dkim = !will_trigger_dkim + && matches!(domain.dkim_management, DkimManagement::Automatic(_)) + && publishes_dkim(domain) + && old_domain.is_some_and(|old| !publishes_dkim(old)); + let mut will_trigger_acme = false; + if let DnsManagement::Automatic(details) = &domain.dns_management { + let old_records = old_domain.and_then(|old| match &old.dns_management { + DnsManagement::Automatic(details) => Some(&details.publish_records), + DnsManagement::Manual => None, + }); + // Only publish newly enabled families on Automatic -> Automatic updates. + // The DNS task does not delete records for disabled families. Compare + // membership rather than Map equality: JSON key order is not a change. + let update_records = Map::new( + details + .publish_records + .iter() + .filter(|&&record| { + old_records.is_none_or(|old| !old.contains(&record)) + && (record != DnsRecordType::Dkim || !will_trigger_dkim) + }) + .copied() + .collect(), + ); + let on_success_renew_certificate = old_domain.is_none() + && matches!( + domain.certificate_management, + CertificateManagement::Automatic(_) + ); + // inbuxa: with nothing to publish and no certificate to order after, + // the task would only end as a failure (#304) + if !update_records.is_empty() || on_success_renew_certificate { + will_trigger_acme = on_success_renew_certificate; + tasks.push(Task::DnsManagement(TaskDnsManagement { + domain_id: Id::default(), + update_records, + on_success_renew_certificate, + status: TaskStatus::now(), + })); + } + } + + // Schedule DKIM key rotation task + if will_trigger_dkim || will_schedule_dkim { + tasks.push(Task::DkimManagement(TaskDomainManagement { + domain_id: Id::default(), + status: TaskStatus::now(), + })); + } + + will_trigger_acme +} + fn publishes_dkim(domain: &Domain) -> bool { matches!( &domain.dns_management, @@ -339,7 +347,7 @@ pub(crate) async fn validate_dns_server( #[cfg(test)] mod tests { use super::*; - use registry::schema::structs::CertificateManagementProperties; + use registry::schema::structs::{CertificateManagementProperties, DnsManagementProperties}; fn domain(name: &str, provider: u64, names: &[&str]) -> Domain { Domain { @@ -419,4 +427,176 @@ mod tests { Some(&old) )); } + + fn automatic(records: &[DnsRecordType]) -> Domain { + Domain { + dns_management: DnsManagement::Automatic(DnsManagementProperties { + publish_records: Map::new(records.to_vec()), + ..Default::default() + }), + dkim_management: DkimManagement::Automatic(Default::default()), + ..Default::default() + } + } + + fn plan(old: Option<&Domain>, new: &Domain) -> (Vec, bool) { + let mut tasks = Vec::new(); + let renew = schedule_dns_tasks(new, old, &mut tasks); + (tasks, renew) + } + + fn dns_tasks(tasks: &[Task]) -> Vec<&TaskDnsManagement> { + tasks + .iter() + .filter_map(|task| match task { + Task::DnsManagement(task) => Some(task), + _ => None, + }) + .collect() + } + + #[test] + fn automatic_enabling_dmarc_queues_only_new_families() { + let old = automatic(&[DnsRecordType::Dkim, DnsRecordType::Spf, DnsRecordType::Mx]); + let new = automatic(&[ + DnsRecordType::Dkim, + DnsRecordType::Spf, + DnsRecordType::Mx, + DnsRecordType::Dmarc, + ]); + let (tasks, renew) = plan(Some(&old), &new); + assert_eq!(tasks.len(), 1); + let dns = dns_tasks(&tasks); + assert_eq!(dns[0].update_records.as_slice(), &[DnsRecordType::Dmarc]); + assert!(!dns[0].on_success_renew_certificate); + assert!(!renew); + } + + #[test] + fn automatic_unchanged_or_reordered_records_do_not_queue() { + let old = automatic(&[DnsRecordType::Dkim, DnsRecordType::Spf]); + assert!(plan(Some(&old), &old).0.is_empty()); + let mut new = automatic(&[]); + let DnsManagement::Automatic(details) = &mut new.dns_management else { + unreachable!(); + }; + details.publish_records = + serde_json::from_str(r#"{"spf":true,"dmarc":false,"mx":null,"dkim":true}"#).unwrap(); + assert!(plan(Some(&old), &new).0.is_empty()); + } + + #[test] + fn manual_record_changes_do_not_queue_automatic_dns() { + // Manual has no publishRecords field in the typed schema; any such + // input is discarded by deserialization before task planning. + let old = Domain::default(); + let new = Domain { + dns_management: serde_json::from_str( + r#"{"@type":"Manual","publishRecords":{"dmarc":true}}"#, + ) + .unwrap(), + ..Default::default() + }; + assert!(plan(Some(&old), &new).0.is_empty()); + } + + #[test] + fn manual_to_automatic_keeps_initial_publication() { + let old = Domain::default(); + let mut new = automatic(&[DnsRecordType::Spf, DnsRecordType::Dmarc]); + new.dkim_management = DkimManagement::Manual; + let (tasks, renew) = plan(Some(&old), &new); + assert_eq!(tasks.len(), 1); + assert_eq!( + dns_tasks(&tasks)[0].update_records.as_slice(), + &[DnsRecordType::Spf, DnsRecordType::Dmarc] + ); + assert!(!renew); + } + + #[test] + fn newly_published_dkim_is_combined_with_other_new_families() { + let old = automatic(&[DnsRecordType::Spf]); + let new = automatic(&[ + DnsRecordType::Spf, + DnsRecordType::Dkim, + DnsRecordType::Dmarc, + ]); + let (tasks, _) = plan(Some(&old), &new); + let dns = dns_tasks(&tasks); + assert_eq!(dns.len(), 1); + assert_eq!( + dns[0].update_records.as_slice(), + &[DnsRecordType::Dkim, DnsRecordType::Dmarc] + ); + assert_eq!(tasks.len(), 2); + assert!(matches!(tasks[1], Task::DkimManagement(_))); + } + + #[test] + fn newly_automatic_dkim_keeps_its_own_publication_path() { + let mut old = automatic(&[DnsRecordType::Spf]); + old.dkim_management = DkimManagement::Manual; + let new = automatic(&[ + DnsRecordType::Spf, + DnsRecordType::Dkim, + DnsRecordType::Dmarc, + ]); + let (tasks, _) = plan(Some(&old), &new); + assert_eq!(tasks.len(), 2); + let dns = dns_tasks(&tasks); + assert_eq!(dns.len(), 1); + assert_eq!(dns[0].update_records.as_slice(), &[DnsRecordType::Dmarc]); + assert!(matches!(tasks[1], Task::DkimManagement(_))); + let dkim_only = automatic(&[DnsRecordType::Spf, DnsRecordType::Dkim]); + let (tasks, _) = plan(Some(&old), &dkim_only); + assert_eq!(tasks.len(), 1); + assert!(matches!(tasks[0], Task::DkimManagement(_))); + } + + #[test] + fn removing_families_does_not_delete_or_republish_records() { + let old = automatic(&[DnsRecordType::Spf, DnsRecordType::Dmarc]); + let new = automatic(&[DnsRecordType::Spf]); + assert!(plan(Some(&old), &new).0.is_empty()); + let replaced = automatic(&[DnsRecordType::Mx]); + let (tasks, _) = plan(Some(&old), &replaced); + assert_eq!(tasks.len(), 1); + assert_eq!( + dns_tasks(&tasks)[0].update_records.as_slice(), + &[DnsRecordType::Mx] + ); + } + + #[test] + fn automatic_to_manual_does_not_queue_dns() { + let old = automatic(&[DnsRecordType::Spf, DnsRecordType::Dmarc]); + let mut new = old.clone(); + new.dns_management = DnsManagement::Manual; + assert!(plan(Some(&old), &new).0.is_empty()); + } + + #[test] + fn new_automatic_domain_keeps_certificate_handoff() { + let mut new = automatic(&[DnsRecordType::Spf, DnsRecordType::Dkim]); + new.certificate_management = CertificateManagement::Automatic(Default::default()); + let (tasks, renew) = plan(None, &new); + assert_eq!(tasks.len(), 2); + let dns = dns_tasks(&tasks); + assert_eq!(dns.len(), 1); + assert_eq!(dns[0].update_records.as_slice(), &[DnsRecordType::Spf]); + assert!(dns[0].on_success_renew_certificate); + assert!(renew); + assert!(matches!(tasks[1], Task::DkimManagement(_))); + } + + #[test] + fn automatic_with_nothing_to_publish_queues_nothing() { + // #304: no records and no certificate to order would only fail + let old = Domain::default(); + let mut new = automatic(&[]); + new.dkim_management = DkimManagement::Manual; + assert!(plan(Some(&old), &new).0.is_empty()); + assert!(plan(None, &new).0.is_empty()); + } } -- 2.54.0