WIP

Author: rklaehn

Cargo.lock

@@ -55,6 +55,9 @@ iroh-test = { path = "./iroh-test" }
 iroh-router = { path = "./iroh-router" }
 
 # iroh-blobs = { git = "https://github.com/n0-computer/iroh-blobs", branch = "main" }
-iroh-gossip = { git = "https://github.com/n0-computer/iroh-gossip", branch = "main" }
+iroh-gossip = { git = "https://github.com/n0-computer/iroh-gossip", branch = "try-out-new-quicrpc" }
 iroh-docs = { git = "https://github.com/n0-computer/iroh-docs", branch = "main" }
-iroh-blobs = { git = "https://github.com/n0-computer/iroh-blobs", branch = "add-rpc" }
+iroh-blobs = { git = "https://github.com/n0-computer/iroh-blobs", branch = "try-out-new-rpc" }
+
+quic-rpc = { git = "https://github.com/n0-computer/quic-rpc.git", branch = "map-transports-not-services", optional = true }
+quic-rpc-derive = { git = "https://github.com/n0-computer/quic-rpc.git", branch = "map-transports-not-services", optional = true }

Cargo.toml

@@ -48,7 +48,7 @@ pkarr = { version = "2.2.0", default-features = false }
 portable-atomic = "1"
 portmapper = { version = "0.1.0", path = "../net-tools/portmapper" }
 postcard = "1.0.8"
-quic-rpc = { version = "0.12", features = ["flume-transport", "quinn-transport"] }
+quic-rpc = { version = "0.15", features = ["flume-transport", "quinn-transport"] }
 rand = "0.8.5"
 ratatui = "0.26.2"
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }

iroh-cli/Cargo.toml

@@ -26,7 +26,7 @@ futures-lite = "2.3"
 futures-util = "0.3"
 genawaiter = { version = "0.99", default-features = false, features = ["futures03"] }
 hex = { version = "0.4.3" }
-iroh-blobs = { version = "0.27.0", features = ["downloader"] }
+iroh-blobs = { version = "0.28.1", features = ["downloader"] }
 iroh-base = { version = "0.27.0", features = ["key"] }
 iroh-io = { version = "0.6.0", features = ["stats"] }
 iroh-metrics = { version = "0.27.0", optional = true }
@@ -39,8 +39,8 @@ iroh-docs = { version = "0.27.0" }
 iroh-gossip = "0.27.0"
 parking_lot = "0.12.1"
 postcard = { version = "1", default-features = false, features = ["alloc", "use-std", "experimental-derive"] }
-quic-rpc = { version = "0.13", default-features = false, features = ["flume-transport", "quinn-transport"] }
-quic-rpc-derive = { version = "0.13" }
+quic-rpc = { version = "0.15", default-features = false, features = ["flume-transport", "quinn-transport"] }
+quic-rpc-derive = { version = "0.15" }
 quinn = { package = "iroh-quinn", version = "0.11" }
 rand = "0.8"
 serde = { version = "1", features = ["derive"] }

iroh/Cargo.toml

@@ -1,11 +1,11 @@
 //! Reexport of iroh-blobs rpc client
 
-use quic_rpc::client::BoxedServiceConnection;
+use quic_rpc::client::BoxedConnector;
 
 use super::RpcService;
 /// Reexport of iroh-blobs rpc client
 pub type Client =
-    iroh_blobs::rpc::client::blobs::Client<BoxedServiceConnection<RpcService>, RpcService>;
+    iroh_blobs::rpc::client::blobs::Client<BoxedConnector<RpcService>, RpcService>;
 
 pub use iroh_blobs::rpc::client::blobs::{
     AddDirOpts, AddFileOpts, AddOutcome, AddProgress, AddReaderOpts, BlobInfo, BlobStatus,

iroh/src/client/blobs.rs

@@ -476,7 +476,7 @@ impl Entry {
     /// You can pass either a [`Doc`] or the `Iroh` client by reference as `client`.
     pub async fn content_reader(&self, client: impl Into<&RpcClient>) -> Result<blobs::Reader> {
         let client: RpcClient = client.into().clone();
-        let client: quic_rpc::RpcClient<iroh_blobs::rpc::proto::RpcService, _, _> = client.map();
+        let client: quic_rpc::RpcClient<iroh_blobs::rpc::proto::RpcService, _> = client.map();
         blobs::Reader::from_rpc_read(&client, self.content_hash()).await
     }
 
@@ -485,7 +485,7 @@ impl Entry {
     /// You can pass either a [`Doc`] or the `Iroh` client by reference as `client`.
     pub async fn content_bytes(&self, client: impl Into<&RpcClient>) -> Result<Bytes> {
         let client: RpcClient = client.into().clone();
-        let client: quic_rpc::RpcClient<iroh_blobs::rpc::proto::RpcService, _, _> = client.map();
+        let client: quic_rpc::RpcClient<iroh_blobs::rpc::proto::RpcService, _> = client.map();
 
         blobs::Reader::from_rpc_read(&client, self.content_hash())
             .await?

iroh/src/client/docs.rs

@@ -8,7 +8,7 @@ use std::{
 };
 
 use anyhow::{bail, Context};
-use quic_rpc::transport::{boxed::Connection as BoxedConnection, quinn::QuinnConnection};
+use quic_rpc::transport::{boxed::BoxedConnector, quinn::QuinnConnector};
 
 use super::{Iroh, RpcClient};
 use crate::{node::RpcStatus, rpc_protocol::node::StatusRequest};
@@ -43,8 +43,8 @@ pub(crate) async fn connect_raw(addr: SocketAddr) -> anyhow::Result<RpcClient> {
     let endpoint = create_quinn_client(bind_addr, vec![RPC_ALPN.to_vec()], false)?;
 
     let server_name = "localhost".to_string();
-    let connection = QuinnConnection::new(endpoint, addr, server_name);
-    let connection = BoxedConnection::new(connection);
+    let connection = QuinnConnector::new(endpoint, addr, server_name);
+    let connection = BoxedConnector::new(connection);
     let client = RpcClient::new(connection);
     // Do a status request to check if the server is running.
     let _version = tokio::time::timeout(Duration::from_secs(1), client.rpc(StatusRequest))

iroh/src/client/quic.rs

@@ -1,9 +1,9 @@
 //! Reexport of iroh-blobs rpc client
-use quic_rpc::client::BoxedServiceConnection;
+use quic_rpc::server::BoxedListener;
 
 use super::RpcService;
 /// Reexport of iroh-blobs rpc client
 pub type Client =
-    iroh_blobs::rpc::client::tags::Client<BoxedServiceConnection<RpcService>, RpcService>;
+    iroh_blobs::rpc::client::tags::Client<BoxedListener<RpcService>, RpcService>;
 
 pub use iroh_blobs::rpc::client::tags::TagInfo;

iroh/src/client/tags.rs

@@ -692,11 +692,11 @@ where
 
         // Initialize the internal RPC connection.
         let (internal_rpc, controller) =
-            quic_rpc::transport::flume::service_connection::<RpcService>(32);
-        let internal_rpc = quic_rpc::transport::boxed::ServerEndpoint::new(internal_rpc);
+            quic_rpc::transport::flume::channel(32);
+        let internal_rpc = quic_rpc::transport::boxed::BoxedListener::new(internal_rpc);
         // box the controller. Boxing has a special case for the flume channel that avoids allocations,
         // so this has zero overhead.
-        let controller = quic_rpc::transport::boxed::Connection::new(controller);
+        let controller = quic_rpc::transport::boxed::BoxedConnector::new(controller);
         let client = crate::client::Iroh::new(quic_rpc::RpcClient::new(controller.clone()));
 
         let inner = Arc::new(NodeInner {

iroh/src/node/builder.rs

@@ -161,7 +161,6 @@ impl<D: BaoStore> Handler<D> {
         chan: RpcChannel<
             iroh_blobs::rpc::proto::RpcService,
             IrohServerEndpoint,
-            crate::rpc_protocol::RpcService,
         >,
     ) -> Result<(), RpcServerError<IrohServerEndpoint>> {
         self.blobs().handle_rpc_request(msg, chan).await