Remove the lazy part.

The lazy handler kept a reference to Blobs alive. This caused both the
task and the blobs to never be dropped. To solve this you can just split
the inner part in 2 parts, one that has the handle and one that has the
logic. But that is not nice. I think it is best for the mem rpc handler
to exist completely separately, especially given that rpc is a non-default
feature.

Author: rklaehn

src/net_protocol.rs

@@ -62,8 +62,6 @@ struct BlobsInner<S> {
 #[derive(Debug, Clone)]
 pub struct Blobs<S> {
     inner: Arc<BlobsInner<S>>,
-    #[cfg(feature = "rpc")]
-    pub(crate) rpc_handler: Arc<std::sync::OnceLock<crate::rpc::RpcHandler>>,
 }
 
 /// Keeps track of all the currently active batch operations of the blobs api.
@@ -193,8 +191,6 @@ impl<S: crate::store::Store> Blobs<S> {
                 batches: Default::default(),
                 gc_state: Default::default(),
             }),
-            #[cfg(feature = "rpc")]
-            rpc_handler: Default::default(),
         }
     }
 

src/rpc.rs

@@ -2,12 +2,13 @@
 
 use std::{
     io,
+    ops::Deref,
     sync::{Arc, Mutex},
 };
 
 use anyhow::anyhow;
 use client::{
-    blobs::{self, BlobInfo, BlobStatus, IncompleteBlobInfo, WrapOption},
+    blobs::{BlobInfo, BlobStatus, IncompleteBlobInfo, MemClient, WrapOption},
     tags::TagInfo,
     MemConnector,
 };
@@ -62,13 +63,8 @@ const RPC_BLOB_GET_CHANNEL_CAP: usize = 2;
 
 impl<D: crate::store::Store> Blobs<D> {
     /// Get a client for the blobs protocol
-    pub fn client(&self) -> blobs::MemClient {
-        let client = self
-            .rpc_handler
-            .get_or_init(|| RpcHandler::new(self))
-            .client
-            .clone();
-        blobs::Client::new(client)
+    pub fn client(&self) -> RpcHandler {
+        RpcHandler::new(self)
     }
 
     /// Handle an RPC request
@@ -874,20 +870,34 @@ impl<D: crate::store::Store> Blobs<D> {
     }
 }
 
+/// A rpc handler for the blobs rpc protocol
+///
+/// This struct contains both a task that handles rpc requests and a client
+/// that can be used to send rpc requests. Dropping it will stop the handler task,
+/// so you need to put it somewhere where it will be kept alive.
 #[derive(Debug)]
-pub(crate) struct RpcHandler {
+pub struct RpcHandler {
     /// Client to hand out
-    client: RpcClient<RpcService, MemConnector>,
+    client: MemClient,
     /// Handler task
     _handler: AbortOnDropHandle<()>,
 }
 
+impl Deref for RpcHandler {
+    type Target = MemClient;
+
+    fn deref(&self) -> &Self::Target {
+        &self.client
+    }
+}
+
 impl RpcHandler {
     fn new<D: crate::store::Store>(blobs: &Blobs<D>) -> Self {
         let blobs = blobs.clone();
         let (listener, connector) = quic_rpc::transport::flume::channel(1);
         let listener = RpcServer::new(listener);
         let client = RpcClient::new(connector);
+        let client = MemClient::new(client);
         let _handler = listener
             .spawn_accept_loop(move |req, chan| blobs.clone().handle_rpc_request(req, chan));
         Self { client, _handler }

tests/blobs.rs

@@ -32,12 +32,7 @@ async fn blobs_gc_protected() -> TestResult<()> {
     let pool = LocalPool::default();
     let endpoint = Endpoint::builder().bind().await?;
     let blobs = Blobs::memory().build(pool.handle(), &endpoint);
-    let client: iroh_blobs::rpc::client::blobs::Client<
-        quic_rpc::transport::flume::FlumeConnector<
-            iroh_blobs::rpc::proto::Response,
-            iroh_blobs::rpc::proto::Request,
-        >,
-    > = blobs.clone().client();
+    let client = blobs.clone().client();
     let h1 = client.add_bytes(b"test".to_vec()).await?;
     let protected = Arc::new(Mutex::new(Vec::new()));
     blobs.add_protected(Box::new({

tests/gc.rs

@@ -20,7 +20,7 @@ use iroh::{protocol::Router, Endpoint, NodeAddr, NodeId};
 use iroh_blobs::{
     hashseq::HashSeq,
     net_protocol::Blobs,
-    rpc::client::{blobs, tags},
+    rpc::{client::tags, RpcHandler},
     store::{
         bao_tree, BaoBatchWriter, ConsistencyCheckProgress, EntryStatus, GcConfig, MapEntryMut,
         MapMut, ReportLevel, Store,
@@ -66,8 +66,8 @@ impl<S: Store> Node<S> {
     }
 
     /// Returns an in-memory blobs client
-    pub fn blobs(&self) -> blobs::MemClient {
-        self.blobs.clone().client()
+    pub fn blobs(&self) -> RpcHandler {
+        self.blobs.client()
     }
 
     /// Returns an in-memory tags client