Update v0.16.0 (#61)

* chore: update existim

* update dumbpipe-web

* update tauri todos example

* funny handle_connection issue in iroh blobs

* upgrade dumbpipe-web

* upgrade content-discovery

* upgrade extism example

* upgrade automerge

* upgrade iroh-gateway

* upgrade iroh-pkarr-node-discovery

* upgrade iroh-pkarr-naming-system

* upgrade iroh-s3-bao-store

* upgrade tauri

---------

Co-authored-by: Kasey <kasey@n0.computer>

Author: b5

content-discovery/Cargo.lock

@@ -26,6 +26,6 @@ missing_debug_implementations = "warn"
 unused-async = "warn"
 
 [workspace.dependencies]
-iroh-net = "0.15.0"
-iroh-bytes = "0.15.0"
-iroh-base = "0.15.0"
+iroh-net = "0.16"
+iroh-blobs = "0.16"
+iroh-base = "0.16"

content-discovery/Cargo.toml

@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 iroh-net = { workspace = true }
-iroh-bytes = { workspace = true }
+iroh-blobs = { workspace = true }
 iroh-base = { workspace = true }
 iroh-mainline-content-discovery = { path = "../iroh-mainline-content-discovery" }
 mainline = { version = "1.0.0" }

content-discovery/iroh-mainline-content-discovery-cli/Cargo.toml

@@ -1,7 +1,7 @@
 //! Command line arguments.
 use clap::{Parser, Subcommand};
 use iroh_base::ticket::BlobTicket;
-use iroh_bytes::{Hash, HashAndFormat};
+use iroh_blobs::{Hash, HashAndFormat};
 use iroh_net::NodeId;
 use std::{fmt::Display, net::SocketAddr, str::FromStr};
 

content-discovery/iroh-mainline-content-discovery-cli/src/args.rs

@@ -12,15 +12,15 @@ license = "MIT OR Apache-2.0"
 #
 # The protocol is using postcard, but we don't need a postcard dependency for just the type definitions
 iroh-net = { workspace = true }
-iroh-bytes = { workspace = true }
+iroh-blobs = { workspace = true }
 serde = { version = "1", features = ["derive"] }
 derive_more = { version = "1.0.0-beta.1", features = ["debug", "display", "from", "try_into"] }
 serde-big-array = "0.5.1"
 hex = "0.4.3"
 
 # Optional features for the client functionality
 tracing = { version = "0.1", optional = true }
-quinn = { version = "0.10", optional = true }
+iroh-quinn = { version = "0.10.2", optional = true }
 iroh-pkarr-node-discovery = { path = "../../iroh-pkarr-node-discovery", optional = true }
 mainline = { version = "1.0.0", optional = true }
 anyhow = { version = "1", features = ["backtrace"], optional = true }
@@ -33,5 +33,5 @@ tokio = { version = "1.36.0", optional = true }
 flume = "0.11.0"
 
 [features]
-client = ["iroh-pkarr-node-discovery", "mainline", "quinn", "tracing", "anyhow", "rcgen", "genawaiter", "rustls", "futures", "postcard", "tokio"]
+client = ["iroh-pkarr-node-discovery", "mainline", "iroh-quinn", "tracing", "anyhow", "rcgen", "genawaiter", "rustls", "futures", "postcard", "tokio"]
 default = ["client"]

content-discovery/iroh-mainline-content-discovery/Cargo.toml

@@ -14,7 +14,7 @@ use futures::{
     stream::FusedStream,
     FutureExt, Stream, StreamExt,
 };
-use iroh_bytes::HashAndFormat;
+use iroh_blobs::HashAndFormat;
 use iroh_net::{MagicEndpoint, NodeId};
 use iroh_pkarr_node_discovery::PkarrNodeDiscovery;
 
@@ -31,7 +31,7 @@ use crate::protocol::{
 /// `content` is the content to announce.
 /// `kind` is the kind of the announcement. We can claim to have the complete data or only some of it.
 pub async fn announce(
-    connection: quinn::Connection,
+    connection: iroh_net::magic_endpoint::Connection,
     signed_announce: SignedAnnounce,
 ) -> anyhow::Result<()> {
     let (mut send, mut recv) = connection.open_bi().await?;
@@ -92,14 +92,14 @@ async fn query_magic_one(
 
 /// A connection provider that can be used to connect to a tracker.
 ///
-/// This can either be a [`quinn::Endpoint`] where connections are created on demand,
+/// This can either be a [`iroh_quinn::Endpoint`] where connections are created on demand,
 /// or some sort of connection pool.
 pub trait QuinnConnectionProvider<Addr>: Clone {
-    fn connect(&self, addr: Addr) -> BoxFuture<anyhow::Result<quinn::Connection>>;
+    fn connect(&self, addr: Addr) -> BoxFuture<anyhow::Result<iroh_quinn::Connection>>;
 }
 
-impl QuinnConnectionProvider<SocketAddr> for quinn::Endpoint {
-    fn connect(&self, addr: SocketAddr) -> BoxFuture<anyhow::Result<quinn::Connection>> {
+impl QuinnConnectionProvider<SocketAddr> for iroh_quinn::Endpoint {
+    fn connect(&self, addr: SocketAddr) -> BoxFuture<anyhow::Result<iroh_quinn::Connection>> {
         async move { Ok(self.connect(addr, "localhost")?.await?) }.boxed()
     }
 }
@@ -176,7 +176,10 @@ pub fn announce_dht(
 }
 
 /// Assume an existing connection to a tracker and query it for peers for some content.
-pub async fn query(connection: quinn::Connection, args: Query) -> anyhow::Result<QueryResponse> {
+pub async fn query(
+    connection: iroh_net::magic_endpoint::Connection,
+    args: Query,
+) -> anyhow::Result<QueryResponse> {
     tracing::info!("connected to {:?}", connection.remote_address());
     let (mut send, mut recv) = connection.open_bi().await?;
     tracing::info!("opened bi stream");
@@ -197,13 +200,13 @@ pub fn create_quinn_client(
     bind_addr: SocketAddr,
     alpn_protocols: Vec<Vec<u8>>,
     keylog: bool,
-) -> anyhow::Result<quinn::Endpoint> {
+) -> anyhow::Result<iroh_quinn::Endpoint> {
     let secret_key = iroh_net::key::SecretKey::generate();
     let tls_client_config =
         iroh_net::tls::make_client_config(&secret_key, None, alpn_protocols, keylog)?;
-    let mut client_config = quinn::ClientConfig::new(Arc::new(tls_client_config));
-    let mut endpoint = quinn::Endpoint::client(bind_addr)?;
-    let mut transport_config = quinn::TransportConfig::default();
+    let mut client_config = iroh_quinn::ClientConfig::new(Arc::new(tls_client_config));
+    let mut endpoint = iroh_quinn::Endpoint::client(bind_addr)?;
+    let mut transport_config = iroh_quinn::TransportConfig::default();
     transport_config.keep_alive_interval(Some(Duration::from_secs(1)));
     client_config.transport_config(Arc::new(transport_config));
     endpoint.set_default_client_config(client_config);
@@ -267,7 +270,10 @@ impl std::str::FromStr for TrackerId {
 ///
 /// Note that this is less efficient than using an existing endpoint when doing multiple requests.
 /// It is provided as a convenience function for short lived utilities.
-pub async fn connect(tracker: &TrackerId, local_port: u16) -> anyhow::Result<quinn::Connection> {
+pub async fn connect(
+    tracker: &TrackerId,
+    local_port: u16,
+) -> anyhow::Result<iroh_net::magic_endpoint::Connection> {
     match tracker {
         TrackerId::Quinn(tracker) => connect_socket(*tracker, local_port).await,
         TrackerId::Iroh(tracker) => connect_magic(tracker, local_port).await,
@@ -276,7 +282,10 @@ pub async fn connect(tracker: &TrackerId, local_port: u16) -> anyhow::Result<qui
 }
 
 /// Create a magic endpoint and connect to a tracker using the [crate::protocol::ALPN] protocol.
-async fn connect_magic(tracker: &NodeId, local_port: u16) -> anyhow::Result<quinn::Connection> {
+async fn connect_magic(
+    tracker: &NodeId,
+    local_port: u16,
+) -> anyhow::Result<iroh_net::magic_endpoint::Connection> {
     // todo: uncomment once the connection problems are fixed
     // for now, a random node id is more reliable.
     // let key = load_secret_key(tracker_path(CLIENT_KEY)?).await?;
@@ -288,7 +297,10 @@ async fn connect_magic(tracker: &NodeId, local_port: u16) -> anyhow::Result<quin
 }
 
 /// Create a quinn endpoint and connect to a tracker using the [crate::protocol::ALPN] protocol.
-async fn connect_socket(tracker: SocketAddr, local_port: u16) -> anyhow::Result<quinn::Connection> {
+async fn connect_socket(
+    tracker: SocketAddr,
+    local_port: u16,
+) -> anyhow::Result<iroh_net::magic_endpoint::Connection> {
     let bind_addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, local_port));
     let endpoint = create_quinn_client(bind_addr, vec![ALPN.to_vec()], false)?;
     tracing::info!("trying to connect to tracker at {:?}", tracker);

content-discovery/iroh-mainline-content-discovery/src/client.rs

@@ -4,7 +4,7 @@ use std::{
     time::{Duration, SystemTime},
 };
 
-use iroh_bytes::HashAndFormat;
+use iroh_blobs::HashAndFormat;
 use iroh_net::NodeId;
 use serde::{Deserialize, Serialize};
 use serde_big_array::BigArray;

content-discovery/iroh-mainline-content-discovery/src/protocol.rs

@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 anyhow = { version = "1", features = ["backtrace"] }
-# needs to keep updated with the dep of iroh-bytes
+# needs to keep updated with the dep of iroh-blobs
 bao-tree = { version = "0.13", features = ["tokio_fsm"], default-features = false }
 bytes = "1"
 derive_more = { version = "1.0.0-beta.1", features = ["debug", "display", "from", "try_into"] }
@@ -19,12 +19,12 @@ futures = "0.3.25"
 hex = "0.4.3"
 humantime = "2.1.0"
 iroh-net = { workspace = true }
-iroh-bytes = { workspace = true }
+iroh-blobs = { workspace = true }
 iroh-pkarr-node-discovery = { path = "../../iroh-pkarr-node-discovery", default-features = false }
 mainline = { version = "1.0.0", features = ["async"] }
 pkarr = { version = "1.0.1", features = ["async"] }
 postcard = { version = "1", default-features = false, features = ["alloc", "use-std"] }
-quinn = "0.10"
+iroh-quinn = "0.10.2"
 rand = "0.8"
 rcgen = "0.12.0"
 redb = "1.5.0"

content-discovery/iroh-mainline-tracker/Cargo.toml

@@ -8,7 +8,7 @@ use std::{
 };
 
 use anyhow::Context;
-use iroh_bytes::{get::Stats, HashAndFormat};
+use iroh_blobs::{get::Stats, HashAndFormat};
 use iroh_mainline_content_discovery::protocol::{AnnounceKind, SignedAnnounce};
 use iroh_net::NodeId;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
@@ -91,7 +91,7 @@ pub fn log_connection_attempt(
     path: &Option<PathBuf>,
     host: &NodeId,
     t0: Instant,
-    outcome: &anyhow::Result<quinn::Connection>,
+    outcome: &anyhow::Result<iroh_quinn::Connection>,
 ) -> anyhow::Result<()> {
     if let Some(path) = path {
         let now = SystemTime::now()

content-discovery/iroh-mainline-tracker/src/io.rs

@@ -1,9 +1,9 @@
-//! Utilities for advanced use of iroh::bytes.
+//! Utilities for advanced use of iroh::blobs.
 use std::sync::Arc;
 
 use bao_tree::{ChunkNum, ChunkRanges};
 use bytes::Bytes;
-use iroh_bytes::{
+use iroh_blobs::{
     get::{
         fsm::{BlobContentNext, EndBlobNext},
         Stats,
@@ -19,16 +19,16 @@ use rand::Rng;
 /// This is just reading the size header and then immediately closing the connection.
 /// It can be used to check if a peer has any data at all.
 pub async fn unverified_size(
-    connection: &quinn::Connection,
+    connection: &iroh_quinn::Connection,
     hash: &Hash,
 ) -> anyhow::Result<(u64, Stats)> {
-    let request = iroh_bytes::protocol::GetRequest::new(
+    let request = iroh_blobs::protocol::GetRequest::new(
         *hash,
         RangeSpecSeq::from_ranges(vec![ChunkRanges::from(ChunkNum(u64::MAX)..)]),
     );
-    let request = iroh_bytes::get::fsm::start(connection.clone(), request);
+    let request = iroh_blobs::get::fsm::start(connection.clone(), request);
     let connected = request.next().await?;
-    let iroh_bytes::get::fsm::ConnectedNext::StartRoot(start) = connected.next().await? else {
+    let iroh_blobs::get::fsm::ConnectedNext::StartRoot(start) = connected.next().await? else {
         unreachable!("expected start root");
     };
     let at_blob_header = start.next();
@@ -42,17 +42,17 @@ pub async fn unverified_size(
 /// This asks for the last chunk of the blob and validates the response.
 /// Note that this does not validate that the peer has all the data.
 pub async fn verified_size(
-    connection: &quinn::Connection,
+    connection: &iroh_quinn::Connection,
     hash: &Hash,
 ) -> anyhow::Result<(u64, Stats)> {
     tracing::debug!("Getting verified size of {}", hash.to_hex());
-    let request = iroh_bytes::protocol::GetRequest::new(
+    let request = iroh_blobs::protocol::GetRequest::new(
         *hash,
         RangeSpecSeq::from_ranges(vec![ChunkRanges::from(ChunkNum(u64::MAX)..)]),
     );
-    let request = iroh_bytes::get::fsm::start(connection.clone(), request);
+    let request = iroh_blobs::get::fsm::start(connection.clone(), request);
     let connected = request.next().await?;
-    let iroh_bytes::get::fsm::ConnectedNext::StartRoot(start) = connected.next().await? else {
+    let iroh_blobs::get::fsm::ConnectedNext::StartRoot(start) = connected.next().await? else {
         unreachable!("expected start root");
     };
     let header = start.next();
@@ -81,22 +81,22 @@ pub async fn verified_size(
 }
 
 pub async fn get_hash_seq_and_sizes(
-    connection: &quinn::Connection,
+    connection: &iroh_quinn::Connection,
     hash: &Hash,
     max_size: u64,
 ) -> anyhow::Result<(HashSeq, Arc<[u64]>)> {
     let content = HashAndFormat::hash_seq(*hash);
     tracing::debug!("Getting hash seq and children sizes of {}", content);
-    let request = iroh_bytes::protocol::GetRequest::new(
+    let request = iroh_blobs::protocol::GetRequest::new(
         *hash,
         RangeSpecSeq::from_ranges_infinite([
             ChunkRanges::all(),
             ChunkRanges::from(ChunkNum(u64::MAX)..),
         ]),
     );
-    let at_start = iroh_bytes::get::fsm::start(connection.clone(), request);
+    let at_start = iroh_blobs::get::fsm::start(connection.clone(), request);
     let at_connected = at_start.next().await?;
-    let iroh_bytes::get::fsm::ConnectedNext::StartRoot(start) = at_connected.next().await? else {
+    let iroh_blobs::get::fsm::ConnectedNext::StartRoot(start) = at_connected.next().await? else {
         unreachable!("query includes root");
     };
     let at_start_root = start.next();
@@ -135,16 +135,16 @@ pub async fn get_hash_seq_and_sizes(
 
 /// Probe for a single chunk of a blob.
 pub async fn chunk_probe(
-    connection: &quinn::Connection,
+    connection: &iroh_quinn::Connection,
     hash: &Hash,
     chunk: ChunkNum,
 ) -> anyhow::Result<Stats> {
     let ranges = ChunkRanges::from(chunk..chunk + 1);
     let ranges = RangeSpecSeq::from_ranges([ranges]);
     let request = GetRequest::new(*hash, ranges);
-    let request = iroh_bytes::get::fsm::start(connection.clone(), request);
+    let request = iroh_blobs::get::fsm::start(connection.clone(), request);
     let connected = request.next().await?;
-    let iroh_bytes::get::fsm::ConnectedNext::StartRoot(start) = connected.next().await? else {
+    let iroh_blobs::get::fsm::ConnectedNext::StartRoot(start) = connected.next().await? else {
         unreachable!("query includes root");
     };
     let header = start.next();