chore: upgrade to iroh@main and quic-rpc@branch

“ramfox” · “ramfox” · commit 7a671486dedb · 2025-02-03T23:49:26.000-05:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -56,7 +56,7 @@ postcard = { version = "1", default-features = false, features = [
 ] }
 quic-rpc = { version = "0.18", optional = true }
 quic-rpc-derive = { version = "0.17", optional = true }
-quinn = { package = "iroh-quinn", version = "0.12", features = ["ring"] }
+quinn = { package = "iroh-quinn", version = "0.13", features = ["ring"] }
 rand = "0.8"
 range-collections = "0.4.0"
 redb = { version = "2.2.0", optional = true }
@@ -184,3 +184,8 @@ debug-assertions = false
 opt-level = 3
 panic = 'abort'
 incremental = false
+
+[patch.crates-io]
+iroh-base = { git = "https://github.com/n0-computer/iroh.git", branch = "main" }
+iroh = { git = "https://github.com/n0-computer/iroh.git", branch = "main" }
+quic-rpc = { git = "https://github.com/n0-computer/quic-rpc.git", branch = "release-prep" }
diff --git a/examples/custom-protocol.rs b/examples/custom-protocol.rs
@@ -44,7 +44,7 @@ use anyhow::Result;
 use clap::Parser;
 use futures_lite::future::Boxed as BoxedFuture;
 use iroh::{
-    endpoint::{get_remote_node_id, Connecting},
+    endpoint::Connecting,
     protocol::{ProtocolHandler, Router},
     Endpoint, NodeId,
 };
@@ -149,7 +149,7 @@ impl ProtocolHandler for BlobSearch {
             // Wait for the connection to be fully established.
             let connection = connecting.await?;
             // We can get the remote's node id from the connection.
-            let node_id = get_remote_node_id(&connection)?;
+            let node_id = connection.remote_node_id()?;
             println!("accepted connection from {node_id}");
 
             // Our protocol is a simple request-response protocol, so we expect the
diff --git a/examples/fetch-fsm.rs b/examples/fetch-fsm.rs
@@ -3,20 +3,19 @@
 //! Since this example does not use [`iroh-net::Endpoint`], it does not do any holepunching, and so will only work locally or between two processes that have public IP addresses.
 //!
 //! Run the provide-bytes example first. It will give instructions on how to run this example properly.
-use std::net::SocketAddr;
+use std::str::FromStr;
 
 use anyhow::{Context, Result};
 use iroh_blobs::{
     get::fsm::{AtInitial, ConnectedNext, EndBlobNext},
     hashseq::HashSeq,
     protocol::GetRequest,
-    Hash,
+    BlobFormat,
 };
 use iroh_io::ConcatenateSliceWriter;
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 mod connect;
-use connect::{load_certs, make_client_endpoint};
 
 // set the RUST_LOG env var to one of {debug,info,warn} to see logging info
 pub fn setup_logging() {
@@ -29,50 +28,49 @@ pub fn setup_logging() {
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    println!("\nfetch bytes example!");
+    println!("\nfetch fsm example!");
     setup_logging();
     let args: Vec<_> = std::env::args().collect();
-    if args.len() != 4 {
-        anyhow::bail!("usage: fetch-bytes [HASH] [SOCKET_ADDR] [FORMAT]");
+    if args.len() != 2 {
+        anyhow::bail!("usage: fetch-fsm [TICKET]");
     }
-    let hash: Hash = args[1].parse().context("unable to parse [HASH]")?;
-    let addr: SocketAddr = args[2].parse().context("unable to parse [SOCKET_ADDR]")?;
-    let format = {
-        if args[3] != "blob" && args[3] != "collection" {
-            anyhow::bail!(
-                "expected either 'blob' or 'collection' for FORMAT argument, got {}",
-                args[3]
-            );
-        }
-        args[3].clone()
-    };
+    let ticket =
+        iroh_blobs::ticket::BlobTicket::from_str(&args[1]).context("unable to parse [TICKET]")?;
 
-    // load tls certificates
-    // This will error if you have not run the `provide-bytes` example
-    let roots = load_certs().await?;
+    let (node, hash, format) = ticket.into_parts();
 
     // create an endpoint to listen for incoming connections
-    let endpoint = make_client_endpoint(roots)?;
-    println!("\nlistening on {}", endpoint.local_addr()?);
-    println!("fetching hash {hash} from {addr}");
+    let endpoint = iroh::Endpoint::builder()
+        .relay_mode(iroh::RelayMode::Disabled)
+        .alpns(vec![connect::EXAMPLE_ALPN.into()])
+        .bind()
+        .await?;
+    println!(
+        "\nlistening on {:?}",
+        endpoint.node_addr().await?.direct_addresses
+    );
+    println!("fetching hash {hash} from {:?}", node.node_id);
 
     // connect
-    let connection = endpoint.connect(addr, "localhost")?.await?;
-
-    if format == "collection" {
-        // create a request for a collection
-        let request = GetRequest::all(hash);
-        // create the initial state of the finite state machine
-        let initial = iroh_blobs::get::fsm::start(connection, request);
-
-        write_collection(initial).await
-    } else {
-        // create a request for a single blob
-        let request = GetRequest::single(hash);
-        // create the initial state of the finite state machine
-        let initial = iroh_blobs::get::fsm::start(connection, request);
-
-        write_blob(initial).await
+    let connection = endpoint.connect(node, connect::EXAMPLE_ALPN).await?;
+
+    match format {
+        BlobFormat::HashSeq => {
+            // create a request for a collection
+            let request = GetRequest::all(hash);
+            // create the initial state of the finite state machine
+            let initial = iroh_blobs::get::fsm::start(connection, request);
+
+            write_collection(initial).await
+        }
+        BlobFormat::Raw => {
+            // create a request for a single blob
+            let request = GetRequest::single(hash);
+            // create the initial state of the finite state machine
+            let initial = iroh_blobs::get::fsm::start(connection, request);
+
+            write_blob(initial).await
+        }
     }
 }
 
diff --git a/examples/fetch-stream.rs b/examples/fetch-stream.rs
@@ -3,7 +3,7 @@
 //! Since this example does not use [`iroh-net::Endpoint`], it does not do any holepunching, and so will only work locally or between two processes that have public IP addresses.
 //!
 //! Run the provide-bytes example first. It will give instructions on how to run this example properly.
-use std::{io, net::SocketAddr};
+use std::{io, str::FromStr};
 
 use anyhow::{Context, Result};
 use bao_tree::io::fsm::BaoContentItem;
@@ -14,13 +14,12 @@ use iroh_blobs::{
     get::fsm::{AtInitial, BlobContentNext, ConnectedNext, EndBlobNext},
     hashseq::HashSeq,
     protocol::GetRequest,
-    Hash,
+    BlobFormat,
 };
 use tokio::io::AsyncWriteExt;
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 mod connect;
-use connect::{load_certs, make_client_endpoint};
 
 // set the RUST_LOG env var to one of {debug,info,warn} to see logging info
 pub fn setup_logging() {
@@ -36,51 +35,50 @@ async fn main() -> Result<()> {
     println!("\nfetch stream example!");
     setup_logging();
     let args: Vec<_> = std::env::args().collect();
-    if args.len() != 4 {
-        anyhow::bail!("usage: fetch-bytes [HASH] [SOCKET_ADDR] [FORMAT]");
+    if args.len() != 2 {
+        anyhow::bail!("usage: fetch-stream [TICKET]");
     }
-    let hash: Hash = args[1].parse().context("unable to parse [HASH]")?;
-    let addr: SocketAddr = args[2].parse().context("unable to parse [SOCKET_ADDR]")?;
-    let format = {
-        if args[3] != "blob" && args[3] != "collection" {
-            anyhow::bail!(
-                "expected either 'blob' or 'collection' for FORMAT argument, got {}",
-                args[3]
-            );
-        }
-        args[3].clone()
-    };
+    let ticket =
+        iroh_blobs::ticket::BlobTicket::from_str(&args[1]).context("unable to parse [TICKET]")?;
 
-    // load tls certificates
-    // This will error if you have not run the `provide-bytes` example
-    let roots = load_certs().await?;
+    let (node, hash, format) = ticket.into_parts();
 
     // create an endpoint to listen for incoming connections
-    let endpoint = make_client_endpoint(roots)?;
-    println!("\nlistening on {}", endpoint.local_addr()?);
-    println!("fetching hash {hash} from {addr}");
+    let endpoint = iroh::Endpoint::builder()
+        .relay_mode(iroh::RelayMode::Disabled)
+        .alpns(vec![connect::EXAMPLE_ALPN.into()])
+        .bind()
+        .await?;
+    println!(
+        "\nlistening on {:?}",
+        endpoint.node_addr().await?.direct_addresses
+    );
+    println!("fetching hash {hash} from {:?}", node.node_id);
 
     // connect
-    let connection = endpoint.connect(addr, "localhost")?.await?;
+    let connection = endpoint.connect(node, connect::EXAMPLE_ALPN).await?;
 
-    let mut stream = if format == "collection" {
-        // create a request for a collection
-        let request = GetRequest::all(hash);
+    let mut stream = match format {
+        BlobFormat::HashSeq => {
+            // create a request for a collection
+            let request = GetRequest::all(hash);
 
-        // create the initial state of the finite state machine
-        let initial = iroh_blobs::get::fsm::start(connection, request);
+            // create the initial state of the finite state machine
+            let initial = iroh_blobs::get::fsm::start(connection, request);
 
-        // create a stream that yields all the data of the blob
-        stream_children(initial).boxed_local()
-    } else {
-        // create a request for a single blob
-        let request = GetRequest::single(hash);
+            // create a stream that yields all the data of the blob
+            stream_children(initial).boxed_local()
+        }
+        BlobFormat::Raw => {
+            // create a request for a single blob
+            let request = GetRequest::single(hash);
 
-        // create the initial state of the finite state machine
-        let initial = iroh_blobs::get::fsm::start(connection, request);
+            // create the initial state of the finite state machine
+            let initial = iroh_blobs::get::fsm::start(connection, request);
 
-        // create a stream that yields all the data of the blob
-        stream_blob(initial).boxed_local()
+            // create a stream that yields all the data of the blob
+            stream_blob(initial).boxed_local()
+        }
     };
     while let Some(item) = stream.next().await {
         let item = item?;
diff --git a/examples/provide-bytes.rs b/examples/provide-bytes.rs
@@ -10,12 +10,11 @@
 //!    cargo run --example provide-bytes collection
 //! To provide a collection (multiple blobs)
 use anyhow::Result;
-use iroh_blobs::{format::collection::Collection, util::local_pool::LocalPool, Hash};
+use iroh_blobs::{format::collection::Collection, util::local_pool::LocalPool, BlobFormat, Hash};
 use tracing::warn;
 use tracing_subscriber::{prelude::*, EnvFilter};
 
 mod connect;
-use connect::{make_and_write_certs, make_server_endpoint, CERT_PATH};
 
 // set the RUST_LOG env var to one of {debug,info,warn} to see logging info
 pub fn setup_logging() {
@@ -45,7 +44,7 @@ async fn main() -> Result<()> {
     };
     println!("\nprovide bytes {format} example!");
 
-    let (db, hash) = if format == "collection" {
+    let (db, hash, format) = if format == "collection" {
         let (mut db, names) = iroh_blobs::store::readonly_mem::Store::new([
             ("blob1", b"the first blob of bytes".to_vec()),
             ("blob2", b"the second blob of bytes".to_vec()),
@@ -56,28 +55,31 @@ async fn main() -> Result<()> {
             .collect();
         // add it to the db
         let hash = db.insert_many(collection.to_blobs()).unwrap();
-        (db, hash)
+        (db, hash, BlobFormat::HashSeq)
     } else {
         // create a new database and add a blob
         let (db, names) =
             iroh_blobs::store::readonly_mem::Store::new([("hello", b"Hello World!".to_vec())]);
 
         // get the hash of the content
         let hash = names.get("hello").unwrap();
-        (db, Hash::from(hash.as_bytes()))
+        (db, Hash::from(hash.as_bytes()), BlobFormat::Raw)
     };
 
-    // create tls certs and save to CERT_PATH
-    let (key, cert) = make_and_write_certs().await?;
-
     // create an endpoint to listen for incoming connections
-    let endpoint = make_server_endpoint(key, cert)?;
-    let addr = endpoint.local_addr()?;
-    println!("\nlistening on {addr}");
+    let endpoint = iroh::Endpoint::builder()
+        .relay_mode(iroh::RelayMode::Disabled)
+        .alpns(vec![connect::EXAMPLE_ALPN.into()])
+        .bind()
+        .await?;
+    let addr = endpoint.node_addr().await?;
+    println!("\nlistening on {:?}", addr.direct_addresses);
     println!("providing hash {hash}");
 
-    println!("\nfetch the content using a finite state machine by running the following example:\n\ncargo run --example fetch-fsm {hash} \"{addr}\" {format}");
-    println!("\nfetch the content using a stream by running the following example:\n\ncargo run --example fetch-stream {hash} \"{addr}\" {format}\n");
+    let ticket = iroh_blobs::ticket::BlobTicket::new(addr, hash, format)?;
+
+    println!("\nfetch the content using a finite state machine by running the following example:\n\ncargo run --example fetch-fsm {ticket}");
+    println!("\nfetch the content using a stream by running the following example:\n\ncargo run --example fetch-stream {ticket}\n");
 
     // create a new local pool handle with 1 worker thread
     let lp = LocalPool::single();
@@ -100,11 +102,10 @@ async fn main() -> Result<()> {
 
             // spawn a task to handle the connection
             tokio::spawn(async move {
-                let remote_addr = conn.remote_address();
                 let conn = match conn.await {
                     Ok(conn) => conn,
                     Err(err) => {
-                        warn!(%remote_addr, "Error connecting: {err:#}");
+                        warn!("Error connecting: {err:#}");
                         return;
                     }
                 };
@@ -115,7 +116,6 @@ async fn main() -> Result<()> {
 
     match tokio::signal::ctrl_c().await {
         Ok(()) => {
-            tokio::fs::remove_dir_all(std::path::PathBuf::from(CERT_PATH)).await?;
             accept_task.abort();
             Ok(())
         }
diff --git a/src/downloader.rs b/src/downloader.rs
@@ -1523,7 +1523,7 @@ impl DialerT for Dialer {
 #[derive(Debug)]
 struct Dialer {
     endpoint: Endpoint,
-    pending: JoinSet<(NodeId, anyhow::Result<quinn::Connection>)>,
+    pending: JoinSet<(NodeId, anyhow::Result<endpoint::Connection>)>,
     pending_dials: HashMap<NodeId, CancellationToken>,
 }
 
@@ -1572,7 +1572,7 @@ impl Dialer {
 }
 
 impl Stream for Dialer {
-    type Item = (NodeId, anyhow::Result<quinn::Connection>);
+    type Item = (NodeId, anyhow::Result<endpoint::Connection>);
 
     fn poll_next(
         mut self: Pin<&mut Self>,
diff --git a/src/provider.rs b/src/provider.rs
@@ -412,9 +412,8 @@ pub async fn handle_connection<D: Map>(
     events: EventSender,
     rt: LocalPoolHandle,
 ) {
-    let remote_addr = connection.remote_address();
     let connection_id = connection.stable_id() as u64;
-    let span = debug_span!("connection", connection_id, %remote_addr);
+    let span = debug_span!("connection", connection_id);
     async move {
         while let Ok((writer, reader)) = connection.accept_bi().await {
             // The stream ID index is used to identify this request.  Requests only arrive in

Original file line number	Diff line number	Diff line change
`@@ -1523,7 +1523,7 @@ impl DialerT for Dialer {`
`1523`	`1523`	`#[derive(Debug)]`
`1524`	`1524`	`struct Dialer {`
`1525`	`1525`	`endpoint: Endpoint,`
`1526`		`- pending: JoinSet<(NodeId, anyhow::Result<quinn::Connection>)>,`
	`1526`	`+ pending: JoinSet<(NodeId, anyhow::Result<endpoint::Connection>)>,`
`1527`	`1527`	`pending_dials: HashMap<NodeId, CancellationToken>,`
`1528`	`1528`	`}`
`1529`	`1529`
`@@ -1572,7 +1572,7 @@ impl Dialer {`
`1572`	`1572`	`}`
`1573`	`1573`
`1574`	`1574`	`impl Stream for Dialer {`
`1575`		`- type Item = (NodeId, anyhow::Result<quinn::Connection>);`
	`1575`	`+ type Item = (NodeId, anyhow::Result<endpoint::Connection>);`
`1576`	`1576`
`1577`	`1577`	`fn poll_next(`
`1578`	`1578`	`mut self: Pin<&mut Self>,`