Completed skeleton for DNS challenge, added Cloudflare DNS integration.

src/tls/acme/account.rs

@@ -30,8 +30,8 @@ async fn create_account(file: &str) -> Result<(), Box<dyn std::error::Error>> {
         only_return_existing: false,
     };
     let acc_builder = Account::builder()?;
-    // let (account, credentials) = acc_builder.create(&new_account, LetsEncrypt::Production.url().to_string(), None).await?;
-    let (account, credentials) = acc_builder.create(&new_account, LetsEncrypt::Staging.url().to_string(), None).await?;
+    let (account, credentials) = acc_builder.create(&new_account, LetsEncrypt::Production.url().to_string(), None).await?;
+    // let (account, credentials) = acc_builder.create(&new_account, LetsEncrypt::Staging.url().to_string(), None).await?;
     info!("Account created: {:?}", account.id());
     save_credentials(&credentials, file)?;
     let _ = ACCOUNT.set(account);

src/tls/acme/dns/cloudflare.rs

@@ -1,4 +1,6 @@
-use crate::tls::acme::types::DnsProvider;
+use crate::tls::acme::lookup::lookup_wait;
+use crate::tls::acme::types::{DnsBackendPlugin, DnsProvider};
+use log::info;
 use reqwest::Client;
 use serde_json::json;
 
@@ -45,11 +47,12 @@ impl DnsProvider for CloudflareProvider {
         }
 
         let record_id = res_json["result"]["id"].as_str().ok_or("missing id")?.to_string();
-        println!(" ====> Created DNS Record ID: {}", record_id);
+        info!("Created TXT record name: {}, id: {}", name, record_id);
+        lookup_wait(name, "1.1.1.1", 60).await;
         Ok(record_id)
     }
 
-    async fn delete_txt_record(&self, record_id: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    async fn delete_txt_record(&self, record_id: &str, record_name: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let url = format!("https://api.cloudflare.com/client/v4/zones/{}/dns_records/{}", self.zone_id, record_id);
 
         let response = self.client.delete(&url).bearer_auth(&self.api_token).send().await?;
@@ -58,8 +61,14 @@ impl DnsProvider for CloudflareProvider {
         if !res_json["success"].as_bool().unwrap_or(false) {
             return Err(format!("Cloudflare API error deleting record: {:?}", res_json["errors"]).into());
         }
-
-        println!(" ====> Successfully deleted DNS record: {}", record_id);
+        info!("Deleted TXT record name: {}, id: {}", record_name, record_id);
         Ok(())
     }
 }
+
+inventory::submit! {
+    DnsBackendPlugin {
+        name: "cloudflare",
+        factory: || Box::new(CloudflareProvider::new()),
+    }
+}

src/tls/acme/dns/route53.rs

@@ -1,4 +1,4 @@
-use crate::tls::acme::types::DnsProvider;
+use crate::tls::acme::types::{DnsBackendPlugin, DnsProvider};
 
 pub struct Route53Provider {
     pub hosted_zone_id: String,
@@ -12,14 +12,22 @@ impl Route53Provider {
     }
 }
 
+// Not working, just a placeholder.
 #[async_trait::async_trait]
 impl DnsProvider for Route53Provider {
-    async fn create_txt_record(&self, domain: &str, name: &str, value: &str) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
-        println!(" ====> Route53 Created TXT Record for {}: {}: {}", name, domain, value);
+    async fn create_txt_record(&self, _domain: &str, _name: &str, _value: &str) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+        println!(" ====> Route53 Created TXT Record for {}: {}: {}", _name, _domain, _value);
         Ok("route53_change_id".to_string())
     }
-    async fn delete_txt_record(&self, record_id: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-        println!(" ====> Route53 Deleted TXT Record {}", record_id);
+    async fn delete_txt_record(&self, _record_id: &str, _record_name: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        println!(" ====> Route53 Deleted TXT Record for {}: {}", _record_name, _record_id);
         Ok(())
     }
 }
+
+inventory::submit! {
+    DnsBackendPlugin {
+        name: "route53",
+        factory: || Box::new(Route53Provider::new()),
+    }
+}

src/tls/acme/lookup.rs

@@ -0,0 +1,47 @@
+use hickory_resolver::TokioResolver;
+use hickory_resolver::config::{NameServerConfig, ResolverConfig, ResolverOpts};
+use hickory_resolver::net::runtime::TokioRuntimeProvider;
+use hickory_resolver::proto::rr::RData;
+use log::info;
+use std::net::IpAddr;
+use std::str::FromStr;
+use std::time::Duration;
+
+pub async fn lookup_wait(record_name: &str, dns_server_ip: &str, max_wait_secs: u64) -> bool {
+    let ip = IpAddr::from_str(dns_server_ip).unwrap_or_else(|_| IpAddr::from([1, 1, 1, 1]));
+    let name_server = NameServerConfig::udp(ip);
+    let config = ResolverConfig::from_name_servers(vec![name_server]);
+    let mut opts = ResolverOpts::default();
+    opts.cache_size = 0;
+
+    let resolver = TokioResolver::builder_with_config(config, TokioRuntimeProvider::default())
+        .with_options(opts)
+        .build()
+        .expect("failed to build DNS resolver");
+
+    let start = std::time::Instant::now();
+    let poll_interval = Duration::from_secs(3);
+    while start.elapsed().as_secs() < max_wait_secs {
+        match resolver.txt_lookup(record_name).await {
+            Ok(txt_lookup) => {
+                for record in txt_lookup.answers() {
+                    if let RData::TXT(txt) = &record.data {
+                        for data in &txt.txt_data {
+                            if let Ok(txt_str) = std::str::from_utf8(data) {
+                                info!("DNS record propagated successfully for {} : {}", record_name, txt_str);
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+            Err(_) => {
+                info!("Waiting for TXT record {}", record_name);
+            }
+        }
+
+        tokio::time::sleep(poll_interval).await;
+    }
+
+    false
+}

src/tls/acme/mod.rs

@@ -1,6 +1,7 @@
 pub mod account;
 pub mod dns;
 pub mod http01;
+pub mod lookup;
 pub mod order;
 pub mod types;
 

src/tls/acme/order.rs

@@ -54,9 +54,6 @@ pub async fn order(domain: &str, credsfile: &str, certs_dir: String, provider: O
     let mut order = account.new_order(&NewOrder::new(&[Identifier::Dns(domain.to_string())])).await?;
 
     let mut authorizations = order.authorizations();
-    // let dns_provider = CloudflareProvider::new();
-
-    let dns_provider = get_provider();
 
     while let Some(auth) = authorizations.next().await {
         let mut auth = auth?;
@@ -68,17 +65,16 @@ pub async fn order(domain: &str, credsfile: &str, certs_dir: String, provider: O
         let key_auth_str = key_auth.as_str().to_string();
 
         if let Some(prov) = provider.clone() {
-            println!("============================== {:?}", prov);
+            let dns_provider = get_provider(prov.clone());
             let dns_value = calculate_dns_value(&key_auth_str);
             let clean_domain = domain.trim_start_matches("*.").to_string();
             let record_name = format!("_acme-challenge.{}", clean_domain);
-            // Works identically for Cloudflare, Route53, or any future provider!
+
             match dns_provider.create_txt_record(&clean_domain, &record_name, &dns_value).await {
                 Ok(record_id) => {
-                    info!("Waiting 30 seconds for DNS propagation: {}", record_name);
-                    tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
-                    challenge_handle.set_ready().await?;
-                    let _ = dns_provider.delete_txt_record(&record_id).await;
+                    let ready_res = challenge_handle.set_ready().await;
+                    let _ = dns_provider.delete_txt_record(&record_id, &record_name).await;
+                    ready_res?;
                 }
                 Err(e) => {
                     eprintln!("Failed to create DNS record: {}", e);

src/tls/acme/types.rs

@@ -1,23 +1,32 @@
-use crate::tls::acme::dns::cloudflare::CloudflareProvider;
-use crate::tls::acme::dns::route53::Route53Provider;
+use async_trait::async_trait;
+use std::collections::HashMap;
+use std::sync::LazyLock;
 
-#[async_trait::async_trait]
+pub struct DnsBackendPlugin {
+    pub name: &'static str,
+    pub factory: fn() -> Box<dyn DnsProvider>,
+}
+
+inventory::collect!(DnsBackendPlugin);
+
+static PROVIDERS: LazyLock<HashMap<&'static str, Box<dyn DnsProvider>>> = LazyLock::new(|| {
+    let mut map = HashMap::new();
+    for plugin in inventory::iter::<DnsBackendPlugin> {
+        map.insert(plugin.name, (plugin.factory)());
+    }
+    map
+});
+
+#[async_trait]
 pub trait DnsProvider: Send + Sync {
     async fn create_txt_record(&self, domain: &str, name: &str, value: &str) -> Result<String, Box<dyn std::error::Error + Send + Sync>>;
 
-    async fn delete_txt_record(&self, record_id: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>>;
+    async fn delete_txt_record(&self, record_id: &str, record_name: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>>;
 }
 
-// pub enum ProviderType {
-//     Cloudflare,
-//     Route53,
-// }
-
-pub fn get_provider() -> Box<dyn DnsProvider> {
-    let provider_choice: Option<Box<dyn DnsProvider>> = match std::env::var("DNS_PROVIDER").as_deref() {
-        Ok("cloudflare") => Some(Box::new(CloudflareProvider::new())),
-        Ok("route53") => Some(Box::new(Route53Provider::new())),
-        _ => None,
-    };
-    provider_choice.expect("No provider choice provided!")
+pub fn get_provider(provider: String) -> &'static dyn DnsProvider {
+    PROVIDERS
+        .get(provider.as_str())
+        .map(|boxed| boxed.as_ref())
+        .unwrap_or_else(|| panic!("Unknown DNS provider '{}'. Available providers: {:?}", provider, PROVIDERS.keys().collect::<Vec<_>>()))
 }