Add mdns discovery example

changes:
- client does not create a router
- removed progress for now

Author: rklaehn

Cargo.lock

@@ -63,6 +63,11 @@ walkdir = "2.5.0"
 hide-proto-docs = []
 metrics = []
 default = ["hide-proto-docs"]
+examples = ["iroh/discovery-local-network"]
+
+[[example]]
+name = "mdns-discovery"
+required-features = ["examples"]
 
 [patch.crates-io]
 iroh = { git = "https://github.com/n0-computer/iroh.git", branch = "main" }

Cargo.toml

@@ -0,0 +1,174 @@
+//! Example that runs and iroh node with local node discovery and no relay server.
+//!
+//! You can think of this as a local version of [sendme](https://www.iroh.computer/sendme)
+//! that only works for individual files.
+//!
+//! **This example is using a non-default feature of iroh, so you need to run it with the
+//! examples feature enabled.**
+//!
+//! Run the follow command to run the "accept" side, that hosts the content:
+//!  $ cargo run --example mdns-discovery --features examples -- accept [FILE_PATH]
+//! Wait for output that looks like the following:
+//!  $ cargo run --example mdns-discovery --features examples -- 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::{Path, PathBuf};
+
+use anyhow::{ensure, Result};
+use clap::{Parser, Subcommand};
+use iroh::{
+    discovery::mdns::MdnsDiscovery, protocol::Router, Endpoint, PublicKey, RelayMode, SecretKey,
+};
+use iroh_blobs::{store::mem::MemStore, BlobsProtocol, Hash};
+use tracing_subscriber::{prelude::*, EnvFilter};
+
+// set the RUST_LOG env var to one of {debug,info,warn} to see logging info
+pub fn setup_logging() {
+    tracing_subscriber::registry()
+        .with(tracing_subscriber::fmt::layer().with_writer(std::io::stderr))
+        .with(EnvFilter::from_default_env())
+        .try_init()
+        .ok();
+}
+
+#[derive(Debug, Parser)]
+#[command(version, about)]
+pub struct Cli {
+    #[clap(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand, Clone, Debug)]
+pub enum Commands {
+    /// Launch an iroh node and provide the content at the given path
+    Accept {
+        /// path to the file you want to provide
+        path: PathBuf,
+    },
+    /// Get the node_id and hash string from a node running accept in the local network
+    /// Download the content from that node.
+    Connect {
+        /// Node ID of a node on the local network
+        node_id: PublicKey,
+        /// Hash of content you want to download from the node
+        hash: Hash,
+        /// save the content to a file
+        #[clap(long, short)]
+        out: Option<PathBuf>,
+    },
+}
+
+async fn accept(path: &Path) -> Result<()> {
+    if !path.is_file() {
+        println!("Content must be a file.");
+        return Ok(());
+    }
+
+    let key = get_or_generate_secret_key()?;
+    let discovery = MdnsDiscovery::new(key.public())?;
+
+    println!("Starting iroh node with mdns discovery...");
+    // create a new node
+    let endpoint = Endpoint::builder()
+        .secret_key(key)
+        .add_discovery(discovery)
+        .relay_mode(RelayMode::Disabled)
+        .bind()
+        .await?;
+    let builder = Router::builder(endpoint.clone());
+    let store = MemStore::new();
+    let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
+    let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
+    let node = builder.spawn();
+
+    if !path.is_file() {
+        println!("Content must be a file.");
+        node.shutdown().await?;
+        return Ok(());
+    }
+    let absolute = path.canonicalize()?;
+    println!("Adding {} as {}...", path.display(), absolute.display());
+    let tag = store.add_path(absolute).await?;
+    println!("To fetch the blob:\n\tcargo run --example mdns-discovery --features examples -- connect {} {} -o [FILE_PATH]", node.endpoint().node_id(), tag.hash);
+    tokio::signal::ctrl_c().await?;
+    node.shutdown().await?;
+    Ok(())
+}
+
+async fn connect(node_id: PublicKey, hash: Hash, out: Option<PathBuf>) -> Result<()> {
+    let key = SecretKey::generate(rand::rngs::OsRng);
+    // todo: disable discovery publishing once https://github.com/n0-computer/iroh/issues/3401 is implemented
+    let discovery = MdnsDiscovery::new(key.public())?;
+
+    println!("Starting iroh node with mdns discovery...");
+    // create a new node
+    let endpoint = Endpoint::builder()
+        .secret_key(key)
+        .add_discovery(discovery)
+        .relay_mode(RelayMode::Disabled)
+        .bind()
+        .await?;
+    let store = MemStore::new();
+
+    println!("NodeID: {}", endpoint.node_id());
+    let conn = endpoint.connect(node_id, iroh_blobs::ALPN).await?;
+    let stats = store.remote().fetch(conn, hash).await?;
+    println!(
+        "Fetched {} bytes for hash {}",
+        stats.payload_bytes_read, hash
+    );
+    if let Some(path) = out {
+        let absolute = std::env::current_dir()?.join(&path);
+        ensure!(!absolute.is_dir(), "output must not be a directory");
+        println!(
+            "exporting {hash} to {} -> {}",
+            path.display(),
+            absolute.display()
+        );
+        let size = store.export(hash, absolute).await?;
+        println!("Exported {size} bytes");
+    }
+
+    endpoint.close().await;
+    // Shutdown the store. This is not needed for the mem store, but would be
+    // necessary for a persistent store to allow it to write any pending data to disk.
+    store.shutdown().await?;
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    setup_logging();
+    let cli = Cli::parse();
+
+    match &cli.command {
+        Commands::Accept { path } => {
+            accept(path).await?;
+        }
+        Commands::Connect { node_id, hash, out } => {
+            connect(*node_id, *hash, out.clone()).await?;
+        }
+    }
+    Ok(())
+}
+
+/// Gets a secret key from the IROH_SECRET environment variable or generates a new random one.
+/// If the environment variable is set, it must be a valid string representation of a secret key.
+pub fn get_or_generate_secret_key() -> Result<SecretKey> {
+    use std::{env, str::FromStr};
+
+    use anyhow::Context;
+    use rand::thread_rng;
+    if let Ok(secret) = env::var("IROH_SECRET") {
+        // Parse the secret key from string
+        SecretKey::from_str(&secret).context("Invalid secret key format")
+    } else {
+        // Generate a new random key
+        let secret_key = SecretKey::generate(&mut thread_rng());
+        println!(
+            "Generated new secret key: {}",
+            hex::encode(secret_key.to_bytes())
+        );
+        println!("To reuse this key, set the IROH_SECRET environment variable to this value");
+        Ok(secret_key)
+    }
+}