Add a builder

this way people don't have to depend on pkarr directly if they just want
the default config.

Author: rklaehn

iroh-pkarr-node-discovery/examples/chat.rs

@@ -12,15 +12,15 @@ use std::str::FromStr;
 
 use anyhow::Context;
 use iroh_net::{magic_endpoint::get_remote_node_id, MagicEndpoint, NodeId};
-use pkarr::PkarrClient;
 
 const CHAT_ALPN: &[u8] = b"pkarr-discovery-demo-chat";
 
 async fn chat_server() -> anyhow::Result<()> {
-    let pkarr = PkarrClient::new();
     let secret_key = iroh_net::key::SecretKey::generate();
     let node_id = secret_key.public();
-    let discovery = iroh_pkarr_node_discovery::PkarrNodeDiscovery::new(pkarr, Some(&secret_key));
+    let discovery = iroh_pkarr_node_discovery::PkarrNodeDiscovery::builder()
+        .secret_key(&secret_key)
+        .build();
     let endpoint = MagicEndpoint::builder()
         .alpns(vec![CHAT_ALPN.to_vec()])
         .secret_key(secret_key)
@@ -51,11 +51,10 @@ async fn chat_server() -> anyhow::Result<()> {
 }
 
 async fn chat_client(remote_node_id: NodeId) -> anyhow::Result<()> {
-    let pkarr = PkarrClient::new();
     let secret_key = iroh_net::key::SecretKey::generate();
     let node_id = secret_key.public();
     // note: we don't pass a secret key here, because we don't need to publish our address, don't spam the DHT
-    let discovery = iroh_pkarr_node_discovery::PkarrNodeDiscovery::new(pkarr, None);
+    let discovery = iroh_pkarr_node_discovery::PkarrNodeDiscovery::builder().build();
     // we do not need to specify the alpn here, because we are not going to accept connections
     let endpoint = MagicEndpoint::builder()
         .secret_key(secret_key)

iroh-pkarr-node-discovery/src/lib.rs

@@ -40,10 +40,10 @@ const INITIAL_PUBLISH_DELAY: Duration = Duration::from_millis(500);
 /// and publishes them to the bittorrent mainline DHT.
 ///
 /// Calling publish will start a background task that periodically publishes the node address.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct PkarrNodeDiscovery(Arc<Inner>);
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 struct Inner {
     /// Pkarr client for interacting with the DHT.
     pkarr: PkarrClient,
@@ -56,12 +56,45 @@ struct Inner {
     keypair: Option<pkarr::Keypair>,
 }
 
+/// Builder for PkarrNodeDiscovery.
+#[derive(Debug, Default)]
+pub struct Builder<'a> {
+    client: Option<PkarrClient>,
+    secret_key: Option<&'a SecretKey>,
+}
+
+impl<'a> Builder<'a> {
+    /// Explicitly set the pkarr client to use.
+    pub fn client(mut self, client: PkarrClient) -> Self {
+        self.client = Some(client);
+        self
+    }
+
+    /// Set the secret key to use for signing the DNS packets.
+    ///
+    /// Without a secret key, the node will not publish its address to the DHT.
+    pub fn secret_key(mut self, secret_key: &'a SecretKey) -> Self {
+        self.secret_key = Some(secret_key);
+        self
+    }
+
+    /// Build the discovery mechanism.
+    pub fn build(self) -> PkarrNodeDiscovery {
+        let client = self.client.unwrap_or_else(PkarrClient::new);
+        PkarrNodeDiscovery::new(client, self.secret_key)
+    }
+}
+
 impl PkarrNodeDiscovery {
+    pub fn builder() -> Builder<'static> {
+        Builder::default()
+    }
+
     /// Create a new discovery mechanism.
     ///
     /// If a secret key is provided, the node will publish its address to the DHT.
     /// If no secret key is provided, publish will be a no-op, but resolving other nodes will still work.
-    pub fn new(pkarr: PkarrClient, secret_key: Option<&SecretKey>) -> Self {
+    fn new(pkarr: PkarrClient, secret_key: Option<&SecretKey>) -> Self {
         let keypair =
             secret_key.map(|secret_key| pkarr::Keypair::from_secret_key(&secret_key.to_bytes()));
         Self(Arc::new(Inner {