Move the simple node from test scope to behind a feature flag

and use it not just from tests but also from examples

Author: rklaehn

Cargo.lock

@@ -97,7 +97,7 @@ futures-util = "0.3.30"
 testdir = "0.9.1"
 
 [features]
-default = ["fs-store", "rpc", "net_protocol"]
+default = ["fs-store", "rpc", "net_protocol", "example-iroh"]
 downloader = ["dep:parking_lot", "tokio-util/time", "dep:hashlink"]
 net_protocol = ["downloader"]
 fs-store = ["dep:reflink-copy", "redb", "dep:redb_v1", "dep:tempfile"]
@@ -115,8 +115,9 @@ rpc = [
     "dep:walkdir",
     "downloader",
 ]
+test-utils = ["rpc"]
 
-example-iroh = ["dep:iroh", "dep:clap", "dep:indicatif", "dep:console"]
+example-iroh = ["dep:iroh", "dep:clap", "dep:indicatif", "dep:console", "test-utils"]
 
 [package.metadata.docs.rs]
 all-features = true

Cargo.toml

@@ -3,13 +3,11 @@
 //!
 //! This is using an in memory database and a random node id.
 //! Run the `provide` example, which will give you instructions on how to run this example.
-use std::{env, str::FromStr, sync::Arc};
+use std::{env, str::FromStr};
 
 use anyhow::{bail, ensure, Context, Result};
 use iroh::base::ticket::BlobTicket;
-use iroh_blobs::{
-    downloader::Downloader, net_protocol::Blobs, util::local_pool::LocalPool, BlobFormat,
-};
+use iroh_blobs::{test_utils::Node, BlobFormat};
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 // set the RUST_LOG env var to one of {debug,info,warn} to see logging info
@@ -37,35 +35,19 @@ 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 local_pool = LocalPool::default();
-    let store = iroh_blobs::store::mem::Store::new();
-    let downloader = Downloader::new(
-        store.clone(),
-        builder.endpoint().clone(),
-        local_pool.handle().clone(),
-    );
-    let blobs = Arc::new(Blobs::new_with_events(
-        store,
-        local_pool.handle().clone(),
-        Default::default(),
-        downloader,
-        builder.endpoint().clone(),
-    ));
-    let blobs_client = blobs.clone().client();
-    builder = builder.accept(iroh_blobs::protocol::ALPN.to_vec(), blobs);
-    let node = builder.spawn().await?;
+    let node = Node::memory().spawn().await?;
 
     println!("fetching hash:  {}", ticket.hash());
     println!("node id:        {}", node.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()
     );
@@ -78,7 +60,8 @@ async fn main() -> Result<()> {
 
     // `download` returns a stream of `DownloadProgress` events. You can iterate through these updates to get progress
     // on the state of your download.
-    let download_stream = blobs_client
+    let download_stream = node
+        .blobs()
         .download(ticket.hash(), ticket.node_addr().clone())
         .await?;
 
@@ -93,7 +76,7 @@ async fn main() -> Result<()> {
 
     // Get the content we have just fetched from the iroh database.
 
-    let bytes = blobs_client.read_to_bytes(ticket.hash()).await?;
+    let bytes = node.blobs().read_to_bytes(ticket.hash()).await?;
     let s = std::str::from_utf8(&bytes).context("unable to parse blob as as utf-8 string")?;
     println!("{s}");
 

examples/hello-world-fetch.rs

@@ -3,10 +3,7 @@
 //! This is using an in memory database and a random node id.
 //! run this example from the project root:
 //!     $ cargo run --example hello-world-provide
-use std::sync::Arc;
-
 use iroh_base::{node_addr::AddrInfoOptions, ticket::BlobTicket};
-use iroh_blobs::{downloader::Downloader, net_protocol::Blobs, util::local_pool::LocalPool};
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 // set the RUST_LOG env var to one of {debug,info,warn} to see logging info
@@ -24,30 +21,13 @@ async fn main() -> anyhow::Result<()> {
     println!("'Hello World' provide example!");
 
     // create a new node
-    let mut builder = iroh::node::Node::memory().build().await?;
-    let local_pool = LocalPool::default();
-    let store = iroh_blobs::store::mem::Store::new();
-    let downloader = Downloader::new(
-        store.clone(),
-        builder.endpoint().clone(),
-        local_pool.handle().clone(),
-    );
-    let blobs = Arc::new(Blobs::new_with_events(
-        store,
-        local_pool.handle().clone(),
-        Default::default(),
-        downloader,
-        builder.endpoint().clone(),
-    ));
-    let blobs_client = blobs.clone().client();
-    builder = builder.accept(iroh_blobs::protocol::ALPN.to_vec(), blobs);
-    let node = builder.spawn().await?;
+    let node = iroh_blobs::test_utils::Node::memory().spawn().await?;
 
     // add some data and remember the hash
-    let res = blobs_client.add_bytes("Hello, world!").await?;
+    let res = node.blobs().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)?;
 
@@ -71,6 +51,7 @@ async fn main() -> anyhow::Result<()> {
     println!("\t cargo run --example hello-world-fetch {}", ticket);
     // block until SIGINT is received (ctrl+c)
     tokio::signal::ctrl_c().await?;
+    println!("shutting down node");
     node.shutdown().await?;
     Ok(())
 }

examples/hello-world-provide.rs

@@ -5,19 +5,15 @@
 //! Wait for output that looks like the following:
 //!  $ cargo run --example local_swarm_discovery --features="discovery-local-network" -- connect [NODE_ID] [HASH] -o [FILE_PATH]
 //! Run that command on another machine in the same local network, replacing [FILE_PATH] to the path on which you want to save the transferred content.
-use std::{path::PathBuf, sync::Arc};
+use std::path::PathBuf;
 
 use anyhow::ensure;
 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::{
-    downloader::Downloader, net_protocol::Blobs, rpc::client::blobs::WrapOption,
-    util::local_pool::LocalPool,
 };
+use iroh_blobs::{rpc::client::blobs::WrapOption, test_utils::Node};
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 use self::progress::show_download_progress;
@@ -65,33 +61,14 @@ 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 = iroh_net::Endpoint::builder()
         .secret_key(key)
-        .node_discovery(cfg)
-        .relay_mode(iroh_net::RelayMode::Disabled)
-        .build()
-        .await?;
-    let local_pool = LocalPool::default();
-    let store = iroh_blobs::store::mem::Store::new();
-    let downloader = Downloader::new(
-        store.clone(),
-        builder.endpoint().clone(),
-        local_pool.handle().clone(),
-    );
-    let blobs = Arc::new(Blobs::new_with_events(
-        store,
-        local_pool.handle().clone(),
-        Default::default(),
-        downloader,
-        builder.endpoint().clone(),
-    ));
-    let blobs_client = blobs.clone().client();
-    builder = builder.accept(iroh_blobs::protocol::ALPN.to_vec(), blobs);
-    let node = builder.spawn().await?;
+        .discovery(Box::new(discovery))
+        .relay_mode(iroh_net::RelayMode::Disabled);
+    // create a new node
+    let node = Node::memory().endpoint(endpoint).spawn().await?;
 
     match &cli.command {
         Commands::Accept { path } => {
@@ -102,7 +79,8 @@ async fn main() -> anyhow::Result<()> {
             }
             let absolute = path.canonicalize()?;
             println!("Adding {} as {}...", path.display(), absolute.display());
-            let stream = blobs_client
+            let stream = node
+                .blobs()
                 .add_from_path(
                     absolute,
                     true,
@@ -118,7 +96,8 @@ async fn main() -> anyhow::Result<()> {
         }
         Commands::Connect { node_id, hash, out } => {
             println!("NodeID: {}", node.node_id());
-            let mut stream = blobs_client
+            let mut stream = node
+                .blobs()
                 .download(*hash, NodeAddr::new(*node_id))
                 .await?;
             show_download_progress(*hash, &mut stream).await?;
@@ -130,7 +109,8 @@ async fn main() -> anyhow::Result<()> {
                     path.display(),
                     absolute.display()
                 );
-                let stream = blobs_client
+                let stream = node
+                    .blobs()
                     .export(
                         *hash,
                         absolute,

examples/local-swarm-discovery.rs

@@ -47,6 +47,9 @@ pub mod provider;
 #[cfg_attr(iroh_docsrs, doc(cfg(feature = "rpc")))]
 pub mod rpc;
 pub mod store;
+#[cfg(any(test, feature = "test-utils"))]
+#[cfg_attr(iroh_docsrs, doc(cfg(any(test, feature = "test-utils"))))]
+pub mod test_utils;
 pub mod util;
 
 use bao_tree::BlockSize;