refactor: simplify generics in client

Cargo.toml

@@ -32,3 +32,6 @@ missing_debug_implementations = "warn"
 
 [workspace.lints.clippy]
 unused-async = "warn"
+
+[patch.crates-io]
+quic-rpc = { git = "https://github.com/n0-computer/quic-rpc.git", branch = "main" }

iroh/src/client/mem.rs

@@ -5,15 +5,15 @@
 
 use quic_rpc::transport::flume::FlumeConnection;
 
-use crate::rpc_protocol::{Request, Response, RpcService};
+use crate::rpc_protocol::RpcService;
 
 /// RPC client to an iroh node running in the same process.
-pub type RpcClient = quic_rpc::RpcClient<RpcService, FlumeConnection<Response, Request>>;
+pub type RpcClient = quic_rpc::RpcClient<RpcService, FlumeConnection<RpcService>>;
 
 /// In-memory client to an iroh node running in the same process.
 ///
 /// This is obtained from [`crate::node::Node::client`].
-pub type Iroh = super::Iroh<FlumeConnection<Response, Request>>;
+pub type Iroh = super::Iroh<FlumeConnection<RpcService>>;
 
 /// In-memory document client to an iroh node running in the same process.
-pub type Doc = super::docs::Doc<FlumeConnection<Response, Request>>;
+pub type Doc = super::docs::Doc<FlumeConnection<RpcService>>;

iroh/src/client/quic.rs

@@ -12,23 +12,23 @@ use quic_rpc::transport::quinn::QuinnConnection;
 
 use crate::{
     node::RpcStatus,
-    rpc_protocol::{NodeStatusRequest, Request, Response, RpcService},
+    rpc_protocol::{NodeStatusRequest, RpcService},
 };
 
 /// ALPN used by irohs RPC mechanism.
 // TODO: Change to "/iroh-rpc/1"
 pub(crate) const RPC_ALPN: [u8; 17] = *b"n0/provider-rpc/1";
 
 /// RPC client to an iroh node running in a separate process.
-pub type RpcClient = quic_rpc::RpcClient<RpcService, QuinnConnection<Response, Request>>;
+pub type RpcClient = quic_rpc::RpcClient<RpcService, QuinnConnection<RpcService>>;
 
 /// Client to an iroh node running in a separate process.
 ///
 /// This is obtained from [`Iroh::connect`].
-pub type Iroh = super::Iroh<QuinnConnection<Response, Request>>;
+pub type Iroh = super::Iroh<QuinnConnection<RpcService>>;
 
 /// RPC document client to an iroh node running in a separate process.
-pub type Doc = super::docs::Doc<QuinnConnection<Response, Request>>;
+pub type Doc = super::docs::Doc<QuinnConnection<RpcService>>;
 
 impl Iroh {
     /// Connect to an iroh node running on the same computer, but in a different process.
@@ -50,7 +50,7 @@ pub(crate) async fn connect_raw(rpc_port: u16) -> anyhow::Result<RpcClient> {
     let endpoint = create_quinn_client(bind_addr, vec![RPC_ALPN.to_vec()], false)?;
     let addr = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), rpc_port);
     let server_name = "localhost".to_string();
-    let connection = QuinnConnection::new(endpoint, addr, server_name);
+    let connection = QuinnConnection::<RpcService>::new(endpoint, addr, server_name);
     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(NodeStatusRequest))

iroh/src/node.rs

@@ -25,8 +25,8 @@ use tokio_util::sync::CancellationToken;
 use tokio_util::task::LocalPoolHandle;
 use tracing::debug;
 
+use crate::client::RpcService;
 use crate::docs_engine::Engine;
-use crate::rpc_protocol::{Request, Response};
 
 mod builder;
 mod rpc;
@@ -90,7 +90,7 @@ struct NodeInner<D> {
     endpoint: Endpoint,
     secret_key: SecretKey,
     cancel_token: CancellationToken,
-    controller: FlumeConnection<Response, Request>,
+    controller: FlumeConnection<RpcService>,
     #[debug("callbacks: Sender<Box<dyn Fn(Event)>>")]
     cb_sender: mpsc::Sender<Box<dyn Fn(Event) -> BoxFuture<()> + Send + Sync + 'static>>,
     callbacks: Callbacks,

iroh/src/node/builder.rs

@@ -35,7 +35,7 @@ use crate::{
     client::RPC_ALPN,
     docs_engine::Engine,
     node::{Event, NodeInner},
-    rpc_protocol::{Request, Response, RpcService},
+    rpc_protocol::RpcService,
     util::{fs::load_secret_key, path::IrohPaths},
 };
 
@@ -246,7 +246,7 @@ where
     }
 
     /// Configure the default iroh rpc endpoint.
-    pub async fn enable_rpc(self) -> Result<Builder<D, QuinnServerEndpoint<Request, Response>>> {
+    pub async fn enable_rpc(self) -> Result<Builder<D, QuinnServerEndpoint<RpcService>>> {
         let (ep, actual_rpc_port) = make_rpc_endpoint(&self.secret_key, DEFAULT_RPC_PORT)?;
         if let StorageConfig::Persistent(ref root) = self.storage {
             // store rpc endpoint
@@ -737,7 +737,7 @@ const MAX_RPC_STREAMS: u32 = 1024;
 fn make_rpc_endpoint(
     secret_key: &SecretKey,
     rpc_port: u16,
-) -> Result<(QuinnServerEndpoint<Request, Response>, u16)> {
+) -> Result<(QuinnServerEndpoint<RpcService>, u16)> {
     let rpc_addr = SocketAddrV4::new(Ipv4Addr::LOCALHOST, rpc_port);
     let mut transport_config = quinn::TransportConfig::default();
     transport_config
@@ -772,7 +772,7 @@ fn make_rpc_endpoint(
     };
 
     let actual_rpc_port = rpc_quinn_endpoint.local_addr()?.port();
-    let rpc_endpoint = QuinnServerEndpoint::<Request, Response>::new(rpc_quinn_endpoint)?;
+    let rpc_endpoint = QuinnServerEndpoint::<RpcService>::new(rpc_quinn_endpoint)?;
 
     Ok((rpc_endpoint, actual_rpc_port))
 }