fix: add timeout for DNS failures

base_layer/p2p/Cargo.toml

@@ -35,7 +35,12 @@ tokio-stream = { version = "0.1.9", default-features = false, features = [
     "time",
 ] }
 tower = "0.4.11"
-hickory-resolver = { version = "=0.25.0-alpha.4", features = ["tokio-runtime", "dns-over-tls", "dns-over-rustls"] }
+hickory-resolver = { version = "=0.25.0-alpha.4", features = [
+    "tokio-runtime",
+    "dns-over-tls",
+    "dns-over-rustls",
+    "native-certs",
+] }
 hickory-proto = { version = "=0.25.0-alpha.4" }
 
 [dev-dependencies]

base_layer/p2p/src/config.rs

@@ -74,16 +74,26 @@ impl Default for PeerSeedsConfig {
         Self {
             override_from: None,
             peer_seeds: StringList::default(),
-            dns_seeds: vec![format!(
-                "seeds.{}.tari.com",
-                Network::get_current_or_user_setting_or_default().as_key_str()
-            )]
+            dns_seeds: vec![
+                format!(
+                    "seeds.{}.tari.com",
+                    Network::get_current_or_user_setting_or_default().as_key_str()
+                ),
+                format!(
+                    "ip4.seeds.{}.tari.com",
+                    Network::get_current_or_user_setting_or_default().as_key_str()
+                ),
+                format!(
+                    "ip6.seeds.{}.tari.com",
+                    Network::get_current_or_user_setting_or_default().as_key_str()
+                ),
+            ]
             .into(),
             dns_seed_name_servers: DnsNameServerList::from_str(
                 "system, 1.1.1.1:853/cloudflare-dns.com, 8.8.8.8:853/dns.google, 9.9.9.9:853/dns.quad9.net",
             )
             .expect("string is valid"),
-            dns_seeds_use_dnssec: false,
+            dns_seeds_use_dnssec: true,
         }
     }
 }

base_layer/p2p/src/dns/client.rs

@@ -76,9 +76,11 @@ impl DnsClient {
             bind_addr: None,
             tls_config: None,
         });
+
         let mut opts = ResolverOpts::default();
         opts.edns0 = true;
         opts.try_tcp_on_error = true;
+        opts.timeout = std::time::Duration::from_secs(1);
         TokioResolver::tokio(conf, opts)
     }
 

base_layer/p2p/src/initialization.rs

@@ -76,7 +76,10 @@ use tari_storage::{
     LMDBWrapper,
 };
 use thiserror::Error;
-use tokio::sync::{broadcast, mpsc};
+use tokio::{
+    sync::{broadcast, mpsc},
+    time::timeout,
+};
 use tower::ServiceBuilder;
 
 use crate::{
@@ -508,7 +511,20 @@ impl P2pInitializer {
             P2pInitializer::get_dns_seed_resolver(config.dns_seeds_use_dnssec, &config.dns_seed_name_servers).await?;
         let resolving = config.dns_seeds.iter().map(|addr| {
             let mut resolver = resolver.clone();
-            async move { (resolver.resolve(addr).await, addr) }
+            async move {
+                let timer = Instant::now();
+                let seeds_res = match timeout(Duration::from_secs(5), resolver.resolve(addr)).await {
+                    Ok(res) => res,
+                    Err(_) => {
+                        warn!(target: LOG_TARGET, "Timeout resolving DNS seed `{}`", addr);
+                        Err(DnsClientError::Timeout)
+                    },
+                };
+                // let res = (resolver.resolve(addr).await, addr);
+                let res = (seeds_res, addr.clone());
+                info!(target: LOG_TARGET, "Resolved DNS seed `{}` in {:.0?}", addr, timer.elapsed());
+                res
+            }
         });
 
         let peers = future::join_all(resolving)
@@ -549,26 +565,38 @@ impl P2pInitializer {
         }
         let mut dns_errors = Vec::new();
         for dns in dns_seed_name_servers {
+            info!(target: LOG_TARGET, "Connecting to DNS name server: {}", dns);
             let res = match (dns_seeds_use_dnssec, dns == &DnsNameServer::System) {
-                (true, false) => DnsSeedResolver::connect_secure(dns.clone()).await,
-                (_, _) => DnsSeedResolver::connect(dns.clone()).await,
+                (true, false) => timeout(Duration::from_secs(5), DnsSeedResolver::connect_secure(dns.clone())).await,
+                (_, _) => timeout(Duration::from_secs(5), DnsSeedResolver::connect(dns.clone())).await,
             };
             match res {
-                Ok(val) => {
-                    trace!(target: LOG_TARGET, "Found DNS client at '{}'", dns);
-                    return Ok(val);
-                },
-                Err(err) => {
-                    warn!(
-                        target: LOG_TARGET,
-                        "DNS entry '{}' did not respond, trying the next one. You can edit 'dns_seed_name_servers' in \
-                        the config file. (Error: {})",
-                        dns,
-                        err.to_string(),
-                    );
+                Ok(Ok(resolver)) => return Ok(resolver),
+                Ok(Err(err)) => {
+                    warn!(target: LOG_TARGET, "Failed to connect to DNS name server: {}", err);
                     dns_errors.push(err.to_string())
                 },
+                Err(_) => {
+                    warn!(target: LOG_TARGET, "Timed out connecting to DNS name server: {}", dns);
+                    dns_errors.push("Timeout".to_string())
+                },
             }
+            // match res {
+            //     Ok(val) => {
+            //         trace!(target: LOG_TARGET, "Found DNS client at '{}'", dns);
+            //         return Ok(val);
+            //     },
+            //     Err(err) => {
+            //         warn!(
+            //             target: LOG_TARGET,
+            //             "DNS entry '{}' did not respond, trying the next one. You can edit 'dns_seed_name_servers' in
+            // \             the config file. (Error: {})",
+            //             dns,
+            //             err.to_string(),
+            //         );
+            //         dns_errors.push(err.to_string())
+            //     },
+            // }
         }
         Err(ServiceInitializationError::from(DnsClientError::Connection(format!(
             "{:?}",

base_layer/p2p/src/peer_seeds.rs

@@ -80,7 +80,7 @@ impl DnsSeedResolver {
             .into_iter()
             .filter_map(|txt| {
                 txt.parse()
-                    .inspect(|err| {
+                    .inspect_err(|err| {
                         warn!(
                             target: LOG_TARGET,
                             "Failed to parse DNS seed peer string: {}. Error: {}", txt, err
@@ -124,15 +124,13 @@ impl FromStr for SeedPeer {
     type Err = anyhow::Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut parts = s.split("::").map(|s| s.trim());
-        let public_key = parts
-            .next()
-            .and_then(|s| UncompressedCommsPublicKey::from_hex(s).ok())
+        let (mut part_a, mut part_b) = s
+            .split_once("::")
+            .ok_or_else(|| anyhow!("Invalid seed peer string, missing '::' delimiter"))?;
+        let public_key = UncompressedCommsPublicKey::from_hex(part_a)
+            .ok()
             .ok_or_else(|| anyhow!("Invalid public key string"))?;
-        let addresses = parts.map(Multiaddr::from_str).collect::<Result<Vec<_>, _>>()?;
-        if addresses.is_empty() || addresses.iter().any(|a| a.is_empty()) {
-            return Err(anyhow!("Empty or invalid address in seed peer string"));
-        }
+        let addresses = vec![Multiaddr::from_str(part_b).map_err(|e| anyhow!("Invalid address string:{}", e))?];
         Ok(SeedPeer {
             public_key: CommsPublicKey::new_from_pk(public_key),
             addresses,