Merge branch 'main' into pluggable-gc-with-exemptions

Author: rklaehn

Cargo.lock

@@ -177,8 +177,8 @@ panic = 'abort'
 incremental = false
 
 [patch.crates-io]
-iroh-router = { git = "https://github.com/n0-computer/iroh", branch = "refactor-drop-external-protocols" }
-iroh-net = { git = "https://github.com/n0-computer/iroh", branch = "refactor-drop-external-protocols" }
-iroh-metrics = { git = "https://github.com/n0-computer/iroh", branch = "refactor-drop-external-protocols" }
-iroh-base = { git = "https://github.com/n0-computer/iroh", branch = "refactor-drop-external-protocols" }
-iroh = { git = "https://github.com/n0-computer/iroh", branch = "refactor-drop-external-protocols" }
+iroh-router = { git = "https://github.com/n0-computer/iroh", branch = "main" }
+iroh-net = { git = "https://github.com/n0-computer/iroh", branch = "main" }
+iroh-metrics = { git = "https://github.com/n0-computer/iroh", branch = "main" }
+iroh-base = { git = "https://github.com/n0-computer/iroh", branch = "main" }
+iroh = { git = "https://github.com/n0-computer/iroh", branch = "main" }

Cargo.toml

@@ -52,6 +52,7 @@ use iroh::{
 };
 use iroh_base::hash::Hash;
 use iroh_blobs::{net_protocol::Blobs, rpc::client::blobs::MemClient, util::local_pool::LocalPool};
+use iroh_router::Router;
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 #[derive(Debug, Parser)]
@@ -88,22 +89,24 @@ async fn main() -> Result<()> {
     let args = Cli::parse();
 
     // Build a in-memory node. For production code, you'd want a persistent node instead usually.
-    let mut builder = iroh::node::Node::memory().build().await?;
+    let endpoint = Endpoint::builder().bind().await?;
+    let builder = Router::builder(endpoint);
     let local_pool = LocalPool::default();
     let blobs = Blobs::memory().build(local_pool.handle(), builder.endpoint());
-    builder = builder.accept(iroh_blobs::ALPN.to_vec(), blobs.clone());
+    let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
     let blobs_client = blobs.client();
 
     // Build our custom protocol handler. The `builder` exposes access to various subsystems in the
     // iroh node. In our case, we need a blobs client and the endpoint.
     let proto = BlobSearch::new(blobs_client.clone(), builder.endpoint().clone());
 
     // Add our protocol, identified by our ALPN, to the node, and spawn the node.
-    let node = builder.accept(ALPN.to_vec(), proto.clone()).spawn().await?;
+    let builder = builder.accept(ALPN, proto.clone());
+    let node = builder.spawn().await?;
 
     match args.command {
         Command::Listen { text } => {
-            let node_id = node.node_id();
+            let node_id = node.endpoint().node_id();
             println!("our node id: {node_id}");
 
             // Insert the text strings as blobs and index them.

examples/custom-protocol.rs

@@ -8,6 +8,8 @@ use std::{env, str::FromStr};
 use anyhow::{bail, ensure, Context, Result};
 use iroh::base::ticket::BlobTicket;
 use iroh_blobs::{net_protocol::Blobs, util::local_pool::LocalPool, BlobFormat};
+use iroh_net::Endpoint;
+use iroh_router::Router;
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 // set the RUST_LOG env var to one of {debug,info,warn} to see logging info
@@ -35,23 +37,25 @@ async fn main() -> Result<()> {
         BlobTicket::from_str(&args[1]).context("failed parsing blob ticket\n\nGet a ticket by running the follow command in a separate terminal:\n\n`cargo run --example hello-world-provide`")?;
 
     // create a new node
-    let mut builder = iroh::node::Node::memory().build().await?;
+    let endpoint = Endpoint::builder().bind().await?;
+    let builder = Router::builder(endpoint);
     let local_pool = LocalPool::default();
     let blobs = Blobs::memory().build(local_pool.handle(), builder.endpoint());
-    builder = builder.accept(iroh_blobs::ALPN.to_vec(), blobs.clone());
+    let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
     let node = builder.spawn().await?;
     let blobs_client = blobs.client();
 
     println!("fetching hash:  {}", ticket.hash());
-    println!("node id:        {}", node.node_id());
+    println!("node id:        {}", node.endpoint().node_id());
     println!("node listening addresses:");
-    let addrs = node.net().node_addr().await?;
+    let addrs = node.endpoint().node_addr().await?;
     for addr in addrs.direct_addresses() {
         println!("\t{:?}", addr);
     }
     println!(
         "node relay server url: {:?}",
-        node.home_relay()
+        node.endpoint()
+            .home_relay()
             .expect("a default relay url should be provided")
             .to_string()
     );

examples/hello-world-fetch.rs

@@ -5,6 +5,8 @@
 //!     $ cargo run --example hello-world-provide
 use iroh_base::{node_addr::AddrInfoOptions, ticket::BlobTicket};
 use iroh_blobs::{net_protocol::Blobs, util::local_pool::LocalPool};
+use iroh_net::Endpoint;
+use iroh_router::Router;
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 // set the RUST_LOG env var to one of {debug,info,warn} to see logging info
@@ -22,18 +24,19 @@ async fn main() -> anyhow::Result<()> {
     println!("'Hello World' provide example!");
 
     // create a new node
-    let mut builder = iroh::node::Node::memory().build().await?;
+    let endpoint = Endpoint::builder().bind().await?;
+    let builder = Router::builder(endpoint);
     let local_pool = LocalPool::default();
     let blobs = Blobs::memory().build(local_pool.handle(), builder.endpoint());
-    builder = builder.accept(iroh_blobs::ALPN.to_vec(), blobs.clone());
+    let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
     let blobs_client = blobs.client();
     let node = builder.spawn().await?;
 
     // add some data and remember the hash
     let res = blobs_client.add_bytes("Hello, world!").await?;
 
     // create a ticket
-    let mut addr = node.net().node_addr().await?;
+    let mut addr = node.endpoint().node_addr().await?;
     addr.apply_options(AddrInfoOptions::RelayAndAddresses);
     let ticket = BlobTicket::new(addr, res.hash, res.format)?;
 

examples/hello-world-provide.rs

@@ -12,11 +12,12 @@ use clap::{Parser, Subcommand};
 use iroh::{
     base::{hash::Hash, key::SecretKey},
     net::{discovery::local_swarm_discovery::LocalSwarmDiscovery, key::PublicKey, NodeAddr},
-    node::DiscoveryConfig,
 };
 use iroh_blobs::{
     net_protocol::Blobs, rpc::client::blobs::WrapOption, util::local_pool::LocalPool,
 };
+use iroh_net::{Endpoint, RelayMode};
+use iroh_router::Router;
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 use self::progress::show_download_progress;
@@ -64,19 +65,19 @@ async fn main() -> anyhow::Result<()> {
 
     let key = SecretKey::generate();
     let discovery = LocalSwarmDiscovery::new(key.public())?;
-    let cfg = DiscoveryConfig::Custom(Box::new(discovery));
 
     println!("Starting iroh node with local node discovery...");
     // create a new node
-    let mut builder = iroh::node::Node::memory()
+    let endpoint = Endpoint::builder()
         .secret_key(key)
-        .node_discovery(cfg)
-        .relay_mode(iroh_net::RelayMode::Disabled)
-        .build()
+        .discovery(Box::new(discovery))
+        .relay_mode(RelayMode::Disabled)
+        .bind()
         .await?;
+    let builder = Router::builder(endpoint);
     let local_pool = LocalPool::default();
     let blobs = Blobs::memory().build(local_pool.handle(), builder.endpoint());
-    builder = builder.accept(iroh_blobs::ALPN.to_vec(), blobs.clone());
+    let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
     let node = builder.spawn().await?;
     let blobs_client = blobs.client();
 
@@ -98,13 +99,13 @@ async fn main() -> anyhow::Result<()> {
                 )
                 .await?;
             let outcome = stream.finish().await?;
-            println!("To fetch the blob:\n\tcargo run --example local_swarm_discovery --features=\"local-swarm-discovery\" -- connect {} {} -o [FILE_PATH]", node.node_id(), outcome.hash);
+            println!("To fetch the blob:\n\tcargo run --example local_swarm_discovery --features=\"local-swarm-discovery\" -- connect {} {} -o [FILE_PATH]", node.endpoint().node_id(), outcome.hash);
             tokio::signal::ctrl_c().await?;
             node.shutdown().await?;
             std::process::exit(0);
         }
         Commands::Connect { node_id, hash, out } => {
-            println!("NodeID: {}", node.node_id());
+            println!("NodeID: {}", node.endpoint().node_id());
             let mut stream = blobs_client
                 .download(*hash, NodeAddr::new(*node_id))
                 .await?;

examples/local-swarm-discovery.rs

@@ -1076,7 +1076,7 @@ mod tests {
                     downloader,
                     endpoint.clone(),
                 ));
-                router = router.accept(crate::ALPN.to_vec(), blobs.clone());
+                router = router.accept(crate::ALPN, blobs.clone());
 
                 // Build the router
                 let router = router.spawn().await?;