Rename node id and node addr to endpoint id and endpoint addr everywhere

Also use latest way to configure n0 discovery

Test failing: connection_pool_errors

Author: rklaehn

examples/compression.rs

@@ -8,7 +8,7 @@ use std::{fmt::Debug, path::PathBuf};
 use anyhow::Result;
 use clap::Parser;
 use common::setup_logging;
-use iroh::protocol::ProtocolHandler;
+use iroh::{endpoint::presets, protocol::ProtocolHandler};
 use iroh_blobs::{
     api::Store,
     get::StreamPair,
@@ -27,7 +27,7 @@ use crate::common::get_or_generate_secret_key;
 #[derive(Debug, Parser)]
 #[command(version, about)]
 pub enum Args {
-    /// Limit requests by node id
+    /// Limit requests by endpoint id
     Provide {
         /// Path for files to add.
         path: PathBuf,
@@ -160,7 +160,7 @@ impl<C: Compression> ProtocolHandler for CompressedBlobsProtocol<C> {
             .events
             .client_connected(|| ClientConnected {
                 connection_id,
-                node_id: connection.remote_node_id().ok(),
+                endpoint_id: connection.remote_id().ok(),
             })
             .await
         {
@@ -186,7 +186,7 @@ async fn main() -> Result<()> {
     let secret = get_or_generate_secret_key()?;
     let endpoint = iroh::Endpoint::builder()
         .secret_key(secret)
-        .discovery_n0()
+        .preset(presets::N0)
         .bind()
         .await?;
     let compression = lz4::Compression;
@@ -198,7 +198,7 @@ async fn main() -> Result<()> {
             let router = iroh::protocol::Router::builder(endpoint.clone())
                 .accept(lz4::Compression::ALPN, blobs)
                 .spawn();
-            let ticket = BlobTicket::new(endpoint.node_id().into(), tag.hash, tag.format);
+            let ticket = BlobTicket::new(endpoint.id().into(), tag.hash, tag.format);
             println!("Serving blob with hash {}", tag.hash);
             println!("Ticket: {ticket}");
             println!("Node is running. Press Ctrl-C to exit.");
@@ -209,7 +209,7 @@ async fn main() -> Result<()> {
         Args::Get { ticket, target } => {
             let store = MemStore::new();
             let conn = endpoint
-                .connect(ticket.node_addr().clone(), lz4::Compression::ALPN)
+                .connect(ticket.addr().clone(), lz4::Compression::ALPN)
                 .await?;
             let connection_id = conn.stable_id() as u64;
             let (send, recv) = conn.open_bi().await?;

examples/custom-protocol.rs

@@ -17,13 +17,13 @@
 //!
 //!     cargo run --example custom-protocol -- listen "hello-world" "foo-bar" "hello-moon"
 //!
-//! This spawns an iroh nodes with three blobs. It will print the node's node id.
+//! This spawns an iroh node with three blobs. It will print the node's endpoint id.
 //!
 //! In another terminal, run
 //!
-//!     cargo run --example custom-protocol -- query <node-id> hello
+//!     cargo run --example custom-protocol -- query <endpoint-id> hello
 //!
-//! Replace <node-id> with the node id from above. This will connect to the listening node with our
+//! Replace <endpoint-id> with the endpoint id from above. This will connect to the listening node with our
 //! custom protocol and query for the string `hello`. The listening node will return a list of
 //! blob hashes that contain `hello`. We will then download all these blobs with iroh-blobs,
 //! and then print a list of the hashes with their content.
@@ -44,9 +44,9 @@ use anyhow::Result;
 use clap::Parser;
 use iroh::{
     discovery::pkarr::PkarrResolver,
-    endpoint::Connection,
+    endpoint::{presets, Connection},
     protocol::{AcceptError, ProtocolHandler, Router},
-    Endpoint, NodeId,
+    Endpoint, EndpointId,
 };
 use iroh_blobs::{api::Store, store::mem::MemStore, BlobsProtocol, Hash};
 mod common;
@@ -67,8 +67,8 @@ pub enum Command {
     },
     /// Query a remote node for data and print the results.
     Query {
-        /// The node id of the node we want to query.
-        node_id: NodeId,
+        /// The endpoint id of the node we want to query.
+        endpoint_id: EndpointId,
         /// The text we want to match.
         query: String,
     },
@@ -81,15 +81,15 @@ pub enum Command {
 const ALPN: &[u8] = b"iroh-example/text-search/0";
 
 async fn listen(text: Vec<String>) -> Result<()> {
-    // allow the user to provide a secret so we can have a stable node id.
+    // allow the user to provide a secret so we can have a stable endpoint id.
     // This is only needed for the listen side.
     let secret_key = get_or_generate_secret_key()?;
     // Use an in-memory store for this example. You would use a persistent store in production code.
     let store = MemStore::new();
     // Create an endpoint with the secret key and discovery publishing to the n0 dns server enabled.
     let endpoint = Endpoint::builder()
         .secret_key(secret_key)
-        .discovery_n0()
+        .preset(presets::N0)
         .bind()
         .await?;
     // Build our custom protocol handler. The `builder` exposes access to various subsystems in the
@@ -108,30 +108,27 @@ async fn listen(text: Vec<String>) -> Result<()> {
         .accept(iroh_blobs::ALPN, blobs.clone())
         .spawn();
 
-    // Print our node id, so clients know how to connect to us.
-    let node_id = node.endpoint().node_id();
-    println!("our node id: {node_id}");
+    // Print our endpoint id, so clients know how to connect to us.
+    let node_id = node.endpoint().id();
+    println!("our endpoint id: {node_id}");
 
     // Wait for Ctrl-C to be pressed.
     tokio::signal::ctrl_c().await?;
     node.shutdown().await?;
     Ok(())
 }
 
-async fn query(node_id: NodeId, query: String) -> Result<()> {
+async fn query(endpoint_id: EndpointId, query: String) -> Result<()> {
     // Build a in-memory node. For production code, you'd want a persistent node instead usually.
     let store = MemStore::new();
     // Create an endpoint with a random secret key and no discovery publishing.
     // For a client we just need discovery resolution via the n0 dns server, which
     // the PkarrResolver provides.
-    let endpoint = Endpoint::builder()
-        .add_discovery(PkarrResolver::n0_dns())
-        .bind()
-        .await?;
+    let endpoint = Endpoint::builder().preset(presets::N0).bind().await?;
     // Query the remote node.
     // This will send the query over our custom protocol, read hashes on the reply stream,
     // and download each hash over iroh-blobs.
-    let hashes = query_remote(&endpoint, &store, node_id, &query).await?;
+    let hashes = query_remote(&endpoint, &store, endpoint_id, &query).await?;
 
     // Print out our query results.
     for hash in hashes {
@@ -157,10 +154,10 @@ async fn main() -> Result<()> {
             listen(text).await?;
         }
         Command::Query {
-            node_id,
+            endpoint_id,
             query: query_text,
         } => {
-            query(node_id, query_text).await?;
+            query(endpoint_id, query_text).await?;
         }
     }
 
@@ -180,8 +177,8 @@ impl ProtocolHandler for BlobSearch {
     /// the connection lasts.
     async fn accept(&self, connection: Connection) -> std::result::Result<(), AcceptError> {
         let this = self.clone();
-        // We can get the remote's node id from the connection.
-        let node_id = connection.remote_node_id()?;
+        // We can get the remote's endpoint id from the connection.
+        let node_id = connection.remote_id()?;
         println!("accepted connection from {node_id}");
 
         // Our protocol is a simple request-response protocol, so we expect the
@@ -269,14 +266,14 @@ impl BlobSearch {
 pub async fn query_remote(
     endpoint: &Endpoint,
     store: &Store,
-    node_id: NodeId,
+    endpoint_id: EndpointId,
     query: &str,
 ) -> Result<Vec<Hash>> {
     // Establish a connection to our node.
-    // We use the default node discovery in iroh, so we can connect by node id without
+    // We use the default node discovery in iroh, so we can connect by endpoint id without
     // providing further information.
-    let conn = endpoint.connect(node_id, ALPN).await?;
-    let blobs_conn = endpoint.connect(node_id, iroh_blobs::ALPN).await?;
+    let conn = endpoint.connect(endpoint_id, ALPN).await?;
+    let blobs_conn = endpoint.connect(endpoint_id, iroh_blobs::ALPN).await?;
 
     // Open a bi-directional in our connection.
     let (mut send, mut recv) = conn.open_bi().await?;

examples/get-blob.rs

@@ -38,7 +38,7 @@ async fn main() -> anyhow::Result<()> {
         "This example only supports raw blobs."
     );
     let connection = endpoint
-        .connect(ticket.node_addr().node_id, iroh_blobs::ALPN)
+        .connect(ticket.addr().endpoint_id, iroh_blobs::ALPN)
         .await?;
     let mut progress = iroh_blobs::get::request::get_blob(connection, ticket.hash());
     let stats = if cli.progress {

examples/limit.rs

@@ -1,4 +1,4 @@
-/// Example how to limit blob requests by hash and node id, and to add
+/// Example how to limit blob requests by hash and endpoint id, and to add
 /// throttling or limiting the maximum number of connections.
 ///
 /// Limiting is done via a fn that returns an EventSender and internally
@@ -21,7 +21,7 @@ use std::{
 use anyhow::Result;
 use clap::Parser;
 use common::setup_logging;
-use iroh::{protocol::Router, NodeAddr, NodeId, SecretKey};
+use iroh::{endpoint::presets, protocol::Router, EndpointAddr, EndpointId, SecretKey};
 use iroh_blobs::{
     provider::events::{
         AbortReason, ConnectMode, EventMask, EventSender, ProviderMessage, RequestMode,
@@ -38,14 +38,14 @@ use crate::common::get_or_generate_secret_key;
 #[derive(Debug, Parser)]
 #[command(version, about)]
 pub enum Args {
-    /// Limit requests by node id
-    ByNodeId {
+    /// Limit requests by endpoint id
+    ByEndpointId {
         /// Path for files to add.
         paths: Vec<PathBuf>,
         #[clap(long("allow"))]
-        /// Nodes that are allowed to download content.
-        allowed_nodes: Vec<NodeId>,
-        /// Number of secrets to generate for allowed node ids.
+        /// Endpoints that are allowed to download content.
+        allowed_endpoints: Vec<EndpointId>,
+        /// Number of secrets to generate for allowed endpoint ids.
         #[clap(long, default_value_t = 1)]
         secrets: usize,
     },
@@ -77,7 +77,7 @@ pub enum Args {
     },
 }
 
-fn limit_by_node_id(allowed_nodes: HashSet<NodeId>) -> EventSender {
+fn limit_by_node_id(allowed_nodes: HashSet<EndpointId>) -> EventSender {
     let mask = EventMask {
         // We want a request for each incoming connection so we can accept
         // or reject them. We don't need any other events.
@@ -88,17 +88,17 @@ fn limit_by_node_id(allowed_nodes: HashSet<NodeId>) -> EventSender {
     n0_future::task::spawn(async move {
         while let Some(msg) = rx.recv().await {
             if let ProviderMessage::ClientConnected(msg) = msg {
-                let res = match msg.node_id {
-                    Some(node_id) if allowed_nodes.contains(&node_id) => {
-                        println!("Client connected: {node_id}");
+                let res: std::result::Result<(), AbortReason> = match msg.endpoint_id {
+                    Some(endpoint_id) if allowed_nodes.contains(&endpoint_id) => {
+                        println!("Client connected: {endpoint_id}");
                         Ok(())
                     }
-                    Some(node_id) => {
-                        println!("Client rejected: {node_id}");
+                    Some(endpoint_id) => {
+                        println!("Client rejected: {endpoint_id}");
                         Err(AbortReason::Permission)
                     }
                     None => {
-                        println!("Client rejected: no node id");
+                        println!("Client rejected: no endpoint id");
                         Err(AbortReason::Permission)
                     }
                 };
@@ -206,7 +206,7 @@ fn limit_max_connections(max_connections: usize) -> EventSender {
             match msg {
                 ProviderMessage::ClientConnected(msg) => {
                     let connection_id = msg.connection_id;
-                    let node_id = msg.node_id;
+                    let node_id = msg.endpoint_id;
                     let res = if let Ok(n) = requests.inc() {
                         println!("Accepting connection {n}, node_id {node_id:?}, connection_id {connection_id}");
                         Ok(())
@@ -233,50 +233,50 @@ async fn main() -> Result<()> {
     let secret = get_or_generate_secret_key()?;
     let endpoint = iroh::Endpoint::builder()
         .secret_key(secret)
-        .discovery_n0()
+        .preset(presets::N0)
         .bind()
         .await?;
     match args {
         Args::Get { ticket } => {
             let connection = endpoint
-                .connect(ticket.node_addr().clone(), iroh_blobs::ALPN)
+                .connect(ticket.addr().clone(), iroh_blobs::ALPN)
                 .await?;
             let (data, stats) = iroh_blobs::get::request::get_blob(connection, ticket.hash())
                 .bytes_and_stats()
                 .await?;
             println!("Downloaded {} bytes", data.len());
             println!("Stats: {stats:?}");
         }
-        Args::ByNodeId {
+        Args::ByEndpointId {
             paths,
-            allowed_nodes,
+            allowed_endpoints,
             secrets,
         } => {
-            let mut allowed_nodes = allowed_nodes.into_iter().collect::<HashSet<_>>();
+            let mut allowed_endpoints = allowed_endpoints.into_iter().collect::<HashSet<_>>();
             if secrets > 0 {
-                println!("Generating {secrets} new secret keys for allowed nodes:");
+                println!("Generating {secrets} new secret keys for allowed endpoints:");
                 let mut rand = rng();
                 for _ in 0..secrets {
                     let secret = SecretKey::generate(&mut rand);
                     let public = secret.public();
-                    allowed_nodes.insert(public);
+                    allowed_endpoints.insert(public);
                     println!("IROH_SECRET={}", hex::encode(secret.to_bytes()));
                 }
             }
 
             let store = MemStore::new();
             let hashes = add_paths(&store, paths).await?;
-            let events = limit_by_node_id(allowed_nodes.clone());
+            let events = limit_by_node_id(allowed_endpoints.clone());
             let (router, addr) = setup(store, events).await?;
 
             for (path, hash) in hashes {
                 let ticket = BlobTicket::new(addr.clone(), hash, BlobFormat::Raw);
                 println!("{}: {ticket}", path.display());
             }
             println!();
-            println!("Node id: {}\n", router.endpoint().node_id());
-            for id in &allowed_nodes {
-                println!("Allowed node: {id}");
+            println!("Endpoint id: {}\n", router.endpoint().id());
+            for id in &allowed_endpoints {
+                println!("Allowed endpoint: {id}");
             }
 
             tokio::signal::ctrl_c().await?;
@@ -350,15 +350,15 @@ async fn add_paths(store: &MemStore, paths: Vec<PathBuf>) -> Result<HashMap<Path
     Ok(hashes)
 }
 
-async fn setup(store: MemStore, events: EventSender) -> Result<(Router, NodeAddr)> {
+async fn setup(store: MemStore, events: EventSender) -> Result<(Router, EndpointAddr)> {
     let secret = get_or_generate_secret_key()?;
     let endpoint = iroh::Endpoint::builder()
-        .discovery_n0()
+        .preset(presets::N0)
         .secret_key(secret)
         .bind()
         .await?;
     endpoint.online().await;
-    let addr = endpoint.node_addr();
+    let addr = endpoint.addr();
     let blobs = BlobsProtocol::new(&store, Some(events));
     let router = Router::builder(endpoint)
         .accept(iroh_blobs::ALPN, blobs)