try out the new simplified service mapping

Author: rklaehn

Cargo.lock

@@ -37,7 +37,7 @@ parking_lot = { version = "0.12.1", optional = true }
 pin-project = "1.1.5"
 portable-atomic = { version = "1", optional = true }
 postcard = { version = "1", default-features = false, features = ["alloc", "use-std", "experimental-derive"] }
-quic-rpc = { version = "0.13.0", optional = true }
+quic-rpc = { git = "https://github.com/n0-computer/quic-rpc.git", branch = "map-transports-not-services", optional = true }
 quic-rpc-derive = { version = "0.13.0", optional = true }
 quinn = { package = "iroh-quinn", version = "0.11", features = ["ring"] }
 rand = "0.8"

Cargo.toml

@@ -57,14 +57,13 @@ const RPC_BLOB_GET_CHANNEL_CAP: usize = 2;
 
 impl<D: crate::store::Store> Blobs<D> {
     /// Handle an RPC request
-    pub async fn handle_rpc_request<S, C>(
+    pub async fn handle_rpc_request<C>(
         self: Arc<Self>,
         msg: crate::rpc::proto::Request,
-        chan: RpcChannel<crate::rpc::proto::RpcService, C, S>,
+        chan: RpcChannel<crate::rpc::proto::RpcService, C>,
     ) -> std::result::Result<(), RpcServerError<C>>
     where
-        S: quic_rpc::Service,
-        C: quic_rpc::ServiceEndpoint<S>,
+        C: quic_rpc::ServiceEndpoint<crate::rpc::proto::RpcService>,
     {
         use crate::rpc::proto::Request::*;
         match msg {
@@ -74,14 +73,13 @@ impl<D: crate::store::Store> Blobs<D> {
     }
 
     /// Handle a tags request
-    pub async fn handle_tags_request<S, C>(
+    pub async fn handle_tags_request<C>(
         self: Arc<Self>,
         msg: proto::tags::Request,
-        chan: RpcChannel<proto::RpcService, C, S>,
+        chan: RpcChannel<proto::RpcService, C>,
     ) -> std::result::Result<(), RpcServerError<C>>
     where
-        S: quic_rpc::Service,
-        C: quic_rpc::ServiceEndpoint<S>,
+        C: quic_rpc::ServiceEndpoint<proto::RpcService>,
     {
         use proto::tags::Request::*;
         match msg {
@@ -93,14 +91,13 @@ impl<D: crate::store::Store> Blobs<D> {
     }
 
     /// Handle a blobs request
-    pub async fn handle_blobs_request<Sv, C>(
+    pub async fn handle_blobs_request<C>(
         self: Arc<Self>,
         msg: proto::blobs::Request,
-        chan: RpcChannel<proto::RpcService, C, Sv>,
+        chan: RpcChannel<proto::RpcService, C>,
     ) -> std::result::Result<(), RpcServerError<C>>
     where
-        Sv: quic_rpc::Service,
-        C: quic_rpc::ServiceEndpoint<Sv>,
+        C: quic_rpc::ServiceEndpoint<proto::RpcService>,
     {
         use proto::blobs::Request::*;
         match msg {

src/rpc.rs

@@ -105,20 +105,16 @@ use crate::rpc::proto::blobs::{
 
 /// Iroh blobs client.
 #[derive(Debug, Clone)]
-pub struct Client<
-    C = BoxedServiceConnection<crate::rpc::proto::RpcService>,
-    S = crate::rpc::proto::RpcService,
-> {
-    pub(super) rpc: RpcClient<crate::rpc::proto::RpcService, C, S>,
+pub struct Client<C = BoxedServiceConnection<crate::rpc::proto::RpcService>> {
+    pub(super) rpc: RpcClient<crate::rpc::proto::RpcService, C>,
 }
 
-impl<C, S> Client<C, S>
+impl<C> Client<C>
 where
-    S: quic_rpc::Service,
-    C: quic_rpc::ServiceConnection<S>,
+    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
 {
     /// Create a new client
-    pub fn new(rpc: RpcClient<crate::rpc::proto::RpcService, C, S>) -> Self {
+    pub fn new(rpc: RpcClient<crate::rpc::proto::RpcService, C>) -> Self {
         Self { rpc }
     }
 
@@ -147,7 +143,7 @@ where
     /// A batch is a context in which temp tags are created and data is added to the node. Temp tags
     /// are automatically deleted when the batch is dropped, leading to the data being garbage collected
     /// unless a permanent tag is created for it.
-    pub async fn batch(&self) -> Result<Batch<C, S>> {
+    pub async fn batch(&self) -> Result<Batch<C>> {
         let (updates, mut stream) = self.rpc.bidi(BatchCreateRequest).await?;
         let BatchCreateResponse::Id(batch) = stream.next().await.context("expected scope id")??;
         let rpc = self.rpc.clone();
@@ -457,15 +453,14 @@ where
         Ok(())
     }
 
-    fn tags_client(&self) -> tags::Client<C, S> {
+    fn tags_client(&self) -> tags::Client<C> {
         tags::Client::new(self.rpc.clone())
     }
 }
 
-impl<C, S> SimpleStore for Client<C, S>
+impl<C> SimpleStore for Client<C>
 where
-    S: quic_rpc::Service,
-    C: quic_rpc::ServiceConnection<S>,
+    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
 {
     async fn load(&self, hash: Hash) -> anyhow::Result<Bytes> {
         self.read_to_bytes(hash).await
@@ -882,26 +877,24 @@ impl Reader {
     }
 
     /// todo make private again
-    pub async fn from_rpc_read<C, S>(
-        rpc: &RpcClient<crate::rpc::proto::RpcService, C, S>,
+    pub async fn from_rpc_read<C>(
+        rpc: &RpcClient<crate::rpc::proto::RpcService, C>,
         hash: Hash,
     ) -> anyhow::Result<Self>
     where
-        C: quic_rpc::ServiceConnection<S>,
-        S: quic_rpc::Service,
+        C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
     {
         Self::from_rpc_read_at(rpc, hash, 0, ReadAtLen::All).await
     }
 
-    async fn from_rpc_read_at<C, S>(
-        rpc: &RpcClient<crate::rpc::proto::RpcService, C, S>,
+    async fn from_rpc_read_at<C>(
+        rpc: &RpcClient<crate::rpc::proto::RpcService, C>,
         hash: Hash,
         offset: u64,
         len: ReadAtLen,
     ) -> anyhow::Result<Self>
     where
-        C: quic_rpc::ServiceConnection<S>,
-        S: quic_rpc::Service,
+        C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
     {
         let stream = rpc
             .server_streaming(ReadAtRequest { hash, offset, len })
@@ -1011,7 +1004,6 @@ mod tests {
         type RpcClient = quic_rpc::RpcClient<
             crate::rpc::proto::RpcService,
             BoxedServiceConnection<crate::rpc::proto::RpcService>,
-            crate::rpc::proto::RpcService,
         >;
 
         /// An iroh node that just has the blobs transport

src/rpc/client/blobs.rs

@@ -33,19 +33,17 @@ use crate::{
 
 /// A scope in which blobs can be added.
 #[derive(derive_more::Debug)]
-struct BatchInner<C, S>
+struct BatchInner<C>
 where
-    C: quic_rpc::ServiceConnection<S>,
-    S: quic_rpc::Service,
+    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
 {
     /// The id of the scope.
     batch: BatchId,
     /// The rpc client.
-    rpc: RpcClient<crate::rpc::proto::RpcService, C, S>,
+    rpc: RpcClient<crate::rpc::proto::RpcService, C>,
     /// The stream to send drop
     #[debug(skip)]
-    updates:
-        Mutex<Buffer<UpdateSink<S, C, BatchUpdate, crate::rpc::proto::RpcService>, BatchUpdate>>,
+    updates: Mutex<Buffer<UpdateSink<C, BatchUpdate>, BatchUpdate>>,
 }
 
 /// A batch for write operations.
@@ -55,15 +53,13 @@ where
 /// It is not a transaction, so things in a batch are not atomic. Also, there is
 /// no isolation between batches.
 #[derive(derive_more::Debug)]
-pub struct Batch<C, S>(Arc<BatchInner<C, S>>)
+pub struct Batch<C>(Arc<BatchInner<C>>)
 where
-    C: quic_rpc::ServiceConnection<S>,
-    S: quic_rpc::Service;
+    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>;
 
-impl<C, S> TagDrop for BatchInner<C, S>
+impl<C> TagDrop for BatchInner<C>
 where
-    C: quic_rpc::ServiceConnection<S>,
-    S: quic_rpc::Service,
+    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
 {
     fn on_drop(&self, content: &HashAndFormat) {
         let mut updates = self.updates.lock().unwrap();
@@ -131,15 +127,14 @@ impl Default for AddReaderOpts {
     }
 }
 
-impl<C, S> Batch<C, S>
+impl<C> Batch<C>
 where
-    C: quic_rpc::ServiceConnection<S>,
-    S: quic_rpc::Service,
+    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
 {
     pub(super) fn new(
         batch: BatchId,
-        rpc: RpcClient<crate::rpc::proto::RpcService, C, S>,
-        updates: UpdateSink<S, C, BatchUpdate, crate::rpc::proto::RpcService>,
+        rpc: RpcClient<crate::rpc::proto::RpcService, C>,
+        updates: UpdateSink<C, BatchUpdate>,
         buffer_size: usize,
     ) -> Self {
         let updates = updates.buffer(buffer_size);

src/rpc/client/blobs/batch.rs

@@ -23,20 +23,16 @@ use crate::{
 /// Iroh tags client.
 #[derive(Debug, Clone)]
 #[repr(transparent)]
-pub struct Client<
-    C = BoxedServiceConnection<crate::rpc::proto::RpcService>,
-    S = crate::rpc::proto::RpcService,
-> {
-    pub(super) rpc: RpcClient<crate::rpc::proto::RpcService, C, S>,
+pub struct Client<C = BoxedServiceConnection<crate::rpc::proto::RpcService>> {
+    pub(super) rpc: RpcClient<crate::rpc::proto::RpcService, C>,
 }
 
-impl<C, S> Client<C, S>
+impl<C> Client<C>
 where
-    C: quic_rpc::ServiceConnection<S>,
-    S: quic_rpc::Service,
+    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
 {
     /// Creates a new client
-    pub fn new(rpc: RpcClient<crate::rpc::proto::RpcService, C, S>) -> Self {
+    pub fn new(rpc: RpcClient<crate::rpc::proto::RpcService, C>) -> Self {
         Self { rpc }
     }