Bump to dns-update 0.5.0

crates/services/src/task_manager/dkim.rs

@@ -191,10 +191,25 @@ async fn dkim_management(server: &Server, task: &TaskDomainManagement) -> trc::R
         // Publish key
         if let Some((updater, origin)) = &dns_updater {
             let record = generate_dkim_dns_record(&signature, &domain.name).await?;
-            let signature_transition = if updater
-                .create(origin, &record.name, record.record, true, true)
+            let dns_update::DnsRecord::TXT(txt_value) = &record.record else {
+                return Ok(TaskResult::permanent(
+                    "DKIM record must be a TXT record".to_string(),
+                ));
+            };
+            let propagation_target = txt_value.clone();
+            let published = updater
+                .set_rrset(
+                    origin,
+                    &record.name,
+                    dns_update::DnsRecordType::TXT,
+                    vec![record.record.clone()],
+                )
                 .await
-                .is_ok_and(|did_propagate| did_propagate)
+                .is_ok();
+            let signature_transition = if published
+                && updater
+                    .wait_for_txt_propagation(&record.name, origin, &propagation_target)
+                    .await
             {
                 trc::event!(
                     Dkim(DkimEvent::SignaturePublished),
@@ -243,10 +258,27 @@ async fn dkim_management(server: &Server, task: &TaskDomainManagement) -> trc::R
     for signature in publish_signatures {
         let record = generate_dkim_dns_record(&signature.object, &domain.name).await?;
         if let Some((updater, origin)) = &dns_updater {
-            match updater
-                .create(origin, &record.name, record.record, true, true)
-                .await
-            {
+            let dns_update::DnsRecord::TXT(txt_value) = &record.record else {
+                return Ok(TaskResult::permanent(
+                    "DKIM record must be a TXT record".to_string(),
+                ));
+            };
+            let propagation_target = txt_value.clone();
+            let publish_result = updater
+                .set_rrset(
+                    origin,
+                    &record.name,
+                    dns_update::DnsRecordType::TXT,
+                    vec![record.record.clone()],
+                )
+                .await;
+            let propagation_result = match &publish_result {
+                Ok(_) => Ok(updater
+                    .wait_for_txt_propagation(&record.name, origin, &propagation_target)
+                    .await),
+                Err(err) => Err(err.clone()),
+            };
+            match propagation_result {
                 Ok(true) => {
                     let signature_transition =
                         UTCDateTime::from_timestamp((now + dkim.rotate_after.as_secs()) as i64);
@@ -354,7 +386,12 @@ async fn dkim_management(server: &Server, task: &TaskDomainManagement) -> trc::R
         let record = generate_dkim_dns_record_name(&signature.object, &domain.name);
         if let Some((updater, origin)) = &dns_updater {
             match updater
-                .delete(origin, &record, dns_update::DnsRecordType::TXT)
+                .set_rrset(
+                    origin,
+                    &record,
+                    dns_update::DnsRecordType::TXT,
+                    Vec::new(),
+                )
                 .await
             {
                 Ok(_) => {

crates/services/src/task_manager/dns.rs

@@ -6,11 +6,11 @@
 
 use crate::task_manager::TaskResult;
 use common::Server;
+use dns_update::{DnsRecord, DnsRecordType};
 use registry::schema::structs::{
     DnsManagement, Domain, Task, TaskDnsManagement, TaskDomainManagement, TaskStatus,
 };
-use std::fmt::Write;
-use store::ahash::AHashSet;
+use std::{collections::HashMap, fmt::Write};
 
 pub(crate) trait DnsManagementTask: Sync + Send {
     fn dns_management(&self, task: &TaskDnsManagement) -> impl Future<Output = TaskResult> + Send;
@@ -60,20 +60,19 @@ async fn dns_management(server: &Server, task: &TaskDnsManagement) -> trc::Resul
         .build_dns_records(task.domain_id, &domain, task.update_records.as_slice())
         .await?;
 
-    // Delete any previous records
-    let delete_records = records
-        .iter()
-        .map(|record| (&record.name, record.record.as_type()))
-        .collect::<AHashSet<_>>();
-    for (name, record_type) in delete_records {
-        let _ = dns_updater.delete(origin, name, record_type).await;
+    // Group records by (name, type) so each RRSet is published in one call.
+    let mut by_owner: HashMap<(String, DnsRecordType), Vec<DnsRecord>> = HashMap::new();
+    for record in records {
+        by_owner
+            .entry((record.name, record.record.as_type()))
+            .or_default()
+            .push(record.record);
     }
 
-    // Add new records
     let mut errors = String::new();
-    for record in records {
+    for ((name, record_type), recs) in by_owner {
         if let Err(err) = dns_updater
-            .create(origin, &record.name, record.record, false, false)
+            .set_rrset(origin, &name, record_type, recs)
             .await
         {
             if !errors.is_empty() {
@@ -81,8 +80,10 @@ async fn dns_management(server: &Server, task: &TaskDnsManagement) -> trc::Resul
             }
             let _ = write!(
                 &mut errors,
-                "Failed to create DNS record for {}: {}",
-                record.name, err
+                "Failed to set DNS RRSet for {}/{}: {}",
+                name,
+                record_type.as_str(),
+                err
             );
         }
     }