deps!: update pkarr to v3

iroh-dns-server/Cargo.toml

@@ -31,7 +31,7 @@ humantime-serde = "1.1.1"
 iroh-metrics = { version = "0.32.0", features = ["metrics", "service"] }
 lru = "0.12.3"
 n0-future = "0.1.2"
-pkarr = { version = "2.3.1", features = [ "async", "relay", "dht"], default-features = false }
+pkarr = { version = "3.7", features = ["relays", "dht"], default-features = false }
 rcgen = "0.13"
 redb = "2.0.0"
 regex = "1.10.3"
@@ -61,7 +61,6 @@ z32 = "1.1.1"
 criterion = "0.5.1"
 hickory-resolver = "0.25.0"
 iroh = { path = "../iroh" }
-pkarr = { version = "2.3.1", features = ["rand"] }
 rand = "0.8"
 rand_chacha = "0.3.1"
 testresult = "0.4.1"

iroh-dns-server/src/lib.rs

@@ -26,7 +26,7 @@ mod tests {
         discovery::pkarr::PkarrRelayClient, dns::DnsResolver, node_info::NodeInfo, RelayUrl,
         SecretKey,
     };
-    use pkarr::{PkarrClient, SignedPacket};
+    use pkarr::{SignedPacket, Timestamp};
     use testresult::TestResult;
     use tracing_test::traced_test;
 
@@ -101,13 +101,13 @@ mod tests {
                 30,
                 dns::rdata::RData::AAAA(Ipv6Addr::LOCALHOST.into()),
             ));
-            SignedPacket::from_packet(&keypair, &packet)?
+            SignedPacket::new(&keypair, &packet.answers, Timestamp::now())?
         };
-        let pkarr_client = pkarr::PkarrRelayClient::new(pkarr::RelaySettings {
-            relays: vec![pkarr_relay_url.to_string()],
-            ..Default::default()
-        })?;
-        pkarr_client.as_async().publish(&signed_packet).await?;
+        let pkarr_client = pkarr::Client::builder()
+            .no_default_network()
+            .relays(&[pkarr_relay_url])?
+            .build()?;
+        pkarr_client.publish(&signed_packet, None).await?;
 
         use hickory_server::proto::rr::Name;
         let pubkey = signed_packet.public_key().to_z32();
@@ -219,7 +219,7 @@ mod tests {
     #[traced_test]
     async fn integration_mainline() -> Result<()> {
         // run a mainline testnet
-        let testnet = pkarr::mainline::dht::Testnet::new(5);
+        let testnet = pkarr::mainline::Testnet::new_async(5).await?;
         let bootstrap = testnet.bootstrap.clone();
 
         // spawn our server with mainline support
@@ -237,13 +237,11 @@ mod tests {
         let signed_packet = node_info.to_pkarr_signed_packet(&secret_key, 30)?;
 
         // publish the signed packet to our DHT
-        let pkarr = PkarrClient::builder()
-            .dht_settings(pkarr::mainline::dht::DhtSettings {
-                bootstrap: Some(testnet.bootstrap),
-                ..Default::default()
-            })
+        let pkarr = pkarr::Client::builder()
+            .no_default_network()
+            .dht(|builder| builder.bootstrap(&testnet.bootstrap))
             .build()?;
-        pkarr.publish(&signed_packet)?;
+        pkarr.publish(&signed_packet, None).await?;
 
         // resolve via DNS from our server, which will lookup from our DHT
         let resolver = test_resolver(nameserver);
@@ -253,9 +251,6 @@ mod tests {
         assert_eq!(res.relay_url(), Some(&relay_url));
 
         server.shutdown().await?;
-        for mut node in testnet.nodes {
-            node.shutdown()?;
-        }
         Ok(())
     }
 

iroh-dns-server/src/store.rs

@@ -6,7 +6,7 @@ use anyhow::Result;
 use hickory_server::proto::rr::{Name, RecordSet, RecordType, RrKey};
 use iroh_metrics::inc;
 use lru::LruCache;
-use pkarr::{mainline::dht::DhtSettings, PkarrClient, SignedPacket};
+use pkarr::{Client as PkarrClient, SignedPacket};
 use tokio::sync::Mutex;
 use tracing::{debug, trace};
 use ttl_cache::TtlCache;
@@ -66,10 +66,7 @@ impl ZoneStore {
         let pkarr_client = match bootstrap {
             BootstrapOption::Default => PkarrClient::builder().build().unwrap(),
             BootstrapOption::Custom(bootstrap) => PkarrClient::builder()
-                .dht_settings(DhtSettings {
-                    bootstrap: Some(bootstrap),
-                    ..Default::default()
-                })
+                .dht(|builder| builder.bootstrap(&bootstrap))
                 .build()
                 .unwrap(),
         };
@@ -116,9 +113,9 @@ impl ZoneStore {
             //
             // it will be cached for some time.
             debug!("DHT resolve {}", key.to_z32());
-            let packet_opt = pkarr.as_ref().clone().as_async().resolve(&key).await?;
+            let packet_opt = pkarr.resolve(&key).await;
             if let Some(packet) = packet_opt {
-                debug!("DHT resolve successful {:?}", packet.packet());
+                debug!("DHT resolve successful {:?}", packet);
                 return self
                     .cache
                     .lock()
@@ -249,12 +246,12 @@ impl CachedZone {
             signed_packet_to_hickory_records_without_origin(signed_packet, |_| true)?;
         Ok(Self {
             records,
-            timestamp: signed_packet.timestamp(),
+            timestamp: signed_packet.timestamp().into(),
         })
     }
 
     fn is_newer_than(&self, signed_packet: &SignedPacket) -> bool {
-        self.timestamp > signed_packet.timestamp()
+        self.timestamp > signed_packet.timestamp().into()
     }
 
     fn resolve(&self, name: &Name, record_type: RecordType) -> Option<Arc<RecordSet>> {