fix: wip

Author: conblem

.idea/sqldialects.xml

@@ -21,7 +21,7 @@ tracing = "0.1"
 tracing-subscriber = "0.2"
 tracing-futures = { version = "0.2.4", features = ["futures-03"]}
 sqlx = { version = "0.4.1", default-features = false, features = [ "runtime-tokio-rustls", "macros", "migrate"] }
-tokio = { version = "0.2", features = ["dns", "tcp", "udp"] }
+tokio = { version = "0.2", features = ["dns", "tcp", "udp", "signal"] }
 uuid = { version = "0.8", features = ["v4"] }
 simplelog = "0.8"
 bcrypt = "0.9"

Cargo.lock

@@ -73,9 +73,10 @@ impl Persist for DatabasePersist {
                 .await?;
 
             transaction.commit().await
-        };
+        }
+        .in_current_span();
 
-        self.handle.block_on(fut.in_current_span()).map_err(error)
+        self.handle.block_on(fut).map_err(error)
     }
 
     #[tracing::instrument(name = "DatabasePersist::get", err, skip(self))]

Cargo.toml

@@ -14,7 +14,7 @@ use trust_dns_server::authority::{
     ZoneType,
 };
 use trust_dns_server::proto::rr::dnssec::SupportedAlgorithms;
-use trust_dns_server::proto::rr::rdata::TXT;
+use trust_dns_server::proto::rr::rdata::{SOA, TXT};
 use trust_dns_server::proto::rr::record_data::RData;
 use trust_dns_server::proto::rr::{Record, RecordSet, RecordType};
 
@@ -197,6 +197,11 @@ impl AuthorityObject for DatabaseAuthority {
         span.record("name", &display(&name));
         span.record("query_type", &display(&query_type));
 
+        // not sure if this handling makes sense
+        if query_type == RecordType::SOA {
+            return span.in_scope(|| self.soa());
+        }
+
         BoxedLookupFuture::from(
             async move {
                 info!("Starting lookup");
@@ -237,6 +242,41 @@ impl AuthorityObject for DatabaseAuthority {
         )
     }
 
+    // fix handling of this as this always take self.origin
+    // also admin is always same serial numbers need to match
+    fn soa(&self) -> BoxedLookupFuture {
+        let origin: Name = self.origin().into();
+        let supported_algorithms = self.0.supported_algorithms;
+        BoxedLookupFuture::from(
+            async move {
+                let soa = SOA::new(
+                    origin.clone(),
+                    origin.clone(),
+                    1,
+                    28800,
+                    7200,
+                    604800,
+                    86400,
+                );
+                let record = Record::from_rdata(origin, 100, RData::SOA(soa));
+                let record_set = RecordSet::from(record);
+                let records =
+                    LookupRecords::new(false, supported_algorithms, Arc::from(record_set));
+                let records = Box::new(records) as Box<dyn LookupObject>;
+                Ok(records)
+            }
+            .in_current_span(),
+        )
+    }
+
+    fn soa_secure(
+        &self,
+        _is_secure: bool,
+        _supported_algorithms: SupportedAlgorithms,
+    ) -> BoxedLookupFuture {
+        self.soa()
+    }
+
     fn get_nsec_records(
         &self,
         _name: &LowerName,

src/acme.rs

@@ -6,6 +6,7 @@ use sqlx::PgPool;
 use std::env;
 use std::str::FromStr;
 use tokio::runtime::Runtime;
+use tokio::signal::ctrl_c;
 use tracing::{debug, error, info, Instrument};
 
 use crate::acme::DatabasePersist;
@@ -64,9 +65,16 @@ fn run() -> Result<()> {
                 CertManager::new(pool, persist, config.general.acme).and_then(CertManager::spawn);
 
             info!("Starting API Cert Manager and DNS");
-            tokio::try_join!(api, cert_manager, dns.spawn())?;
-
-            Ok(())
+            tokio::select! {
+                res = api => res,
+                res = cert_manager => res,
+                res = dns.spawn() => res,
+                res = ctrl_c() => {
+                    res?;
+                    info!("Ctrl C pressed");
+                    Ok(())
+                }
+            }
         }
         .in_current_span(),
     );