Simply bounds

Author: rklaehn

src/rpc.rs

@@ -30,7 +30,7 @@ use proto::{
         CreateRequest as TagsCreateRequest, DeleteRequest as TagDeleteRequest,
         ListRequest as TagListRequest, SetRequest as TagsSetRequest, SyncMode,
     },
-    RpcError, RpcResult,
+    RpcError, RpcResult, RpcService,
 };
 use quic_rpc::server::{RpcChannel, RpcServerError};
 
@@ -60,10 +60,10 @@ impl<D: crate::store::Store> Blobs<D> {
     pub async fn handle_rpc_request<C>(
         self: Arc<Self>,
         msg: crate::rpc::proto::Request,
-        chan: RpcChannel<crate::rpc::proto::RpcService, C>,
+        chan: RpcChannel<RpcService, C>,
     ) -> std::result::Result<(), RpcServerError<C>>
     where
-        C: quic_rpc::ServiceEndpoint<crate::rpc::proto::RpcService>,
+        C: quic_rpc::ServiceEndpoint<RpcService>,
     {
         use crate::rpc::proto::Request::*;
         match msg {

src/rpc/client/blobs.rs

@@ -74,7 +74,7 @@ use iroh_net::NodeAddr;
 use portable_atomic::{AtomicU64, Ordering};
 use quic_rpc::{
     client::{BoxStreamSync, BoxedServiceConnection},
-    RpcClient,
+    RpcClient, ServiceConnection,
 };
 use serde::{Deserialize, Serialize};
 use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
@@ -87,6 +87,7 @@ use crate::{
     format::collection::{Collection, SimpleStore},
     get::db::DownloadProgress as BytesDownloadProgress,
     net_protocol::BlobDownloadRequest,
+    rpc::proto::RpcService,
     store::{BaoBlobSize, ConsistencyCheckProgress, ExportFormat, ExportMode, ValidateProgress},
     util::SetTagOption,
     BlobFormat, Hash, Tag,
@@ -105,16 +106,16 @@ use crate::rpc::proto::blobs::{
 
 /// Iroh blobs client.
 #[derive(Debug, Clone)]
-pub struct Client<C = BoxedServiceConnection<crate::rpc::proto::RpcService>> {
-    pub(super) rpc: RpcClient<crate::rpc::proto::RpcService, C>,
+pub struct Client<C = BoxedServiceConnection<RpcService>> {
+    pub(super) rpc: RpcClient<RpcService, C>,
 }
 
 impl<C> Client<C>
 where
-    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
+    C: ServiceConnection<RpcService>,
 {
     /// Create a new client
-    pub fn new(rpc: RpcClient<crate::rpc::proto::RpcService, C>) -> Self {
+    pub fn new(rpc: RpcClient<RpcService, C>) -> Self {
         Self { rpc }
     }
 
@@ -460,7 +461,7 @@ where
 
 impl<C> SimpleStore for Client<C>
 where
-    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
+    C: ServiceConnection<RpcService>,
 {
     async fn load(&self, hash: Hash) -> anyhow::Result<Bytes> {
         self.read_to_bytes(hash).await
@@ -878,23 +879,23 @@ impl Reader {
 
     /// todo make private again
     pub async fn from_rpc_read<C>(
-        rpc: &RpcClient<crate::rpc::proto::RpcService, C>,
+        rpc: &RpcClient<RpcService, C>,
         hash: Hash,
     ) -> anyhow::Result<Self>
     where
-        C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
+        C: ServiceConnection<RpcService>,
     {
         Self::from_rpc_read_at(rpc, hash, 0, ReadAtLen::All).await
     }
 
     async fn from_rpc_read_at<C>(
-        rpc: &RpcClient<crate::rpc::proto::RpcService, C>,
+        rpc: &RpcClient<RpcService, C>,
         hash: Hash,
         offset: u64,
         len: ReadAtLen,
     ) -> anyhow::Result<Self>
     where
-        C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
+        C: ServiceConnection<RpcService>,
     {
         let stream = rpc
             .server_streaming(ReadAtRequest { hash, offset, len })
@@ -1001,10 +1002,9 @@ mod tests {
             util::local_pool::LocalPool,
         };
 
-        type RpcClient = quic_rpc::RpcClient<
-            crate::rpc::proto::RpcService,
-            BoxedServiceConnection<crate::rpc::proto::RpcService>,
-        >;
+        use super::RpcService;
+
+        type RpcClient = quic_rpc::RpcClient<RpcService>;
 
         /// An iroh node that just has the blobs transport
         #[derive(Debug)]
@@ -1122,7 +1122,7 @@ mod tests {
 
             // Setup RPC
             let (internal_rpc, controller) =
-                quic_rpc::transport::flume::service_connection::<crate::rpc::proto::RpcService>(32);
+                quic_rpc::transport::flume::service_connection::<RpcService>(32);
             let controller = quic_rpc::transport::boxed::Connection::new(controller);
             let internal_rpc = quic_rpc::transport::boxed::ServerEndpoint::new(internal_rpc);
             let internal_rpc = quic_rpc::RpcServer::new(internal_rpc);

src/rpc/client/blobs/batch.rs

@@ -9,7 +9,7 @@ use bytes::Bytes;
 use futures_buffered::BufferedStreamExt;
 use futures_lite::StreamExt;
 use futures_util::{sink::Buffer, FutureExt, SinkExt, Stream};
-use quic_rpc::{client::UpdateSink, RpcClient};
+use quic_rpc::{client::UpdateSink, RpcClient, ServiceConnection};
 use tokio::io::AsyncRead;
 use tokio_util::io::ReaderStream;
 use tracing::{debug, warn};
@@ -25,6 +25,7 @@ use crate::{
             BatchAddStreamUpdate, BatchCreateTempTagRequest, BatchUpdate,
         },
         tags::{self, SyncMode},
+        RpcService,
     },
     store::ImportMode,
     util::{SetTagOption, TagDrop},
@@ -35,12 +36,12 @@ use crate::{
 #[derive(derive_more::Debug)]
 struct BatchInner<C>
 where
-    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
+    C: ServiceConnection<RpcService>,
 {
     /// The id of the scope.
     batch: BatchId,
     /// The rpc client.
-    rpc: RpcClient<crate::rpc::proto::RpcService, C>,
+    rpc: RpcClient<RpcService, C>,
     /// The stream to send drop
     #[debug(skip)]
     updates: Mutex<Buffer<UpdateSink<C, BatchUpdate>, BatchUpdate>>,
@@ -55,11 +56,11 @@ where
 #[derive(derive_more::Debug)]
 pub struct Batch<C>(Arc<BatchInner<C>>)
 where
-    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>;
+    C: ServiceConnection<RpcService>;
 
 impl<C> TagDrop for BatchInner<C>
 where
-    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
+    C: ServiceConnection<RpcService>,
 {
     fn on_drop(&self, content: &HashAndFormat) {
         let mut updates = self.updates.lock().unwrap();
@@ -129,11 +130,11 @@ impl Default for AddReaderOpts {
 
 impl<C> Batch<C>
 where
-    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
+    C: ServiceConnection<RpcService>,
 {
     pub(super) fn new(
         batch: BatchId,
-        rpc: RpcClient<crate::rpc::proto::RpcService, C>,
+        rpc: RpcClient<RpcService, C>,
         updates: UpdateSink<C, BatchUpdate>,
         buffer_size: usize,
     ) -> Self {

src/rpc/client/tags.rs

@@ -12,27 +12,30 @@
 //! [`Client::delete`] can be used to delete a tag.
 use anyhow::Result;
 use futures_lite::{Stream, StreamExt};
-use quic_rpc::{client::BoxedServiceConnection, RpcClient};
+use quic_rpc::{client::BoxedServiceConnection, RpcClient, ServiceConnection};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    rpc::proto::tags::{DeleteRequest, ListRequest},
+    rpc::proto::{
+        tags::{DeleteRequest, ListRequest},
+        RpcService,
+    },
     BlobFormat, Hash, Tag,
 };
 
 /// Iroh tags client.
 #[derive(Debug, Clone)]
 #[repr(transparent)]
-pub struct Client<C = BoxedServiceConnection<crate::rpc::proto::RpcService>> {
-    pub(super) rpc: RpcClient<crate::rpc::proto::RpcService, C>,
+pub struct Client<C = BoxedServiceConnection<RpcService>> {
+    pub(super) rpc: RpcClient<RpcService, C>,
 }
 
 impl<C> Client<C>
 where
-    C: quic_rpc::ServiceConnection<crate::rpc::proto::RpcService>,
+    C: ServiceConnection<RpcService>,
 {
     /// Creates a new client
-    pub fn new(rpc: RpcClient<crate::rpc::proto::RpcService, C>) -> Self {
+    pub fn new(rpc: RpcClient<RpcService, C>) -> Self {
         Self { rpc }
     }