spawn_rpc should make it sufficiently clear that this is a thing you need to put away somewhere.

Or maybe spawn_client?

Author: rklaehn

examples/custom-protocol.rs

@@ -91,7 +91,7 @@ async fn main() -> Result<()> {
     let local_pool = LocalPool::default();
     let blobs = Blobs::memory().build(local_pool.handle(), builder.endpoint());
     let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
-    let blobs_client = blobs.client();
+    let blobs_client = blobs.spawn_rpc();
 
     // Build our custom protocol handler. The `builder` exposes access to various subsystems in the
     // iroh node. In our case, we need a blobs client and the endpoint.

examples/hello-world-fetch.rs

@@ -42,7 +42,7 @@ async fn main() -> Result<()> {
     let blobs = Blobs::memory().build(local_pool.handle(), builder.endpoint());
     let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
     let node = builder.spawn().await?;
-    let blobs_client = blobs.client();
+    let blobs_client = blobs.spawn_rpc();
 
     println!("fetching hash:  {}", ticket.hash());
     println!("node id:        {}", node.endpoint().node_id());

examples/hello-world-provide.rs

@@ -28,7 +28,7 @@ async fn main() -> anyhow::Result<()> {
     let local_pool = LocalPool::default();
     let blobs = Blobs::memory().build(local_pool.handle(), builder.endpoint());
     let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
-    let blobs_client = blobs.client();
+    let blobs_client = blobs.spawn_rpc();
     let node = builder.spawn().await?;
 
     // add some data and remember the hash

examples/local-swarm-discovery.rs

@@ -78,7 +78,7 @@ async fn main() -> anyhow::Result<()> {
     let blobs = Blobs::memory().build(local_pool.handle(), builder.endpoint());
     let builder = builder.accept(iroh_blobs::ALPN, blobs.clone());
     let node = builder.spawn().await?;
-    let blobs_client = blobs.client();
+    let blobs_client = blobs.spawn_rpc();
 
     match &cli.command {
         Commands::Accept { path } => {

examples/transfer.rs

@@ -26,7 +26,7 @@ async fn main() -> Result<()> {
         .spawn()
         .await?;
 
-    let blobs = blobs.client();
+    let blobs = blobs.spawn_rpc();
 
     let args = std::env::args().collect::<Vec<_>>();
     match &args.iter().map(String::as_str).collect::<Vec<_>>()[..] {

src/rpc.rs

@@ -62,8 +62,9 @@ const RPC_BLOB_GET_CHUNK_SIZE: usize = 1024 * 64;
 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) -> RpcHandler {
+    /// Spawns an in-memory RPC client and server pair.
+    #[must_use = "Dropping the RpcHandler will stop the client"]
+    pub fn spawn_rpc(&self) -> RpcHandler {
         RpcHandler::new(self)
     }
 
@@ -870,11 +871,14 @@ impl<D: crate::store::Store> Blobs<D> {
     }
 }
 
-/// A rpc handler for the blobs rpc protocol
+/// An in memory 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.
+/// 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. This struct will capture a copy of
+/// [`crate::net_protocol::Blobs`] and keep it alive.
 #[derive(Debug)]
 pub struct RpcHandler {
     /// Client to hand out
@@ -902,4 +906,9 @@ impl RpcHandler {
             .spawn_accept_loop(move |req, chan| blobs.clone().handle_rpc_request(req, chan));
         Self { client, _handler }
     }
+
+    /// Get a reference to the rpc client api
+    pub fn client(&self) -> &MemClient {
+        &self.client
+    }
 }

tests/blobs.rs

@@ -13,7 +13,7 @@ async fn blobs_gc_smoke() -> TestResult<()> {
     let pool = LocalPool::default();
     let endpoint = Endpoint::builder().bind().await?;
     let blobs = Blobs::memory().build(pool.handle(), &endpoint);
-    let client = blobs.clone().client();
+    let client = blobs.spawn_rpc();
     blobs.start_gc(GcConfig {
         period: Duration::from_millis(1),
         done_callback: None,
@@ -32,7 +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 = blobs.clone().client();
+    let client = blobs.spawn_rpc();
     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

@@ -67,7 +67,7 @@ impl<S: Store> Node<S> {
 
     /// Returns an in-memory blobs client
     pub fn blobs(&self) -> RpcHandler {
-        self.blobs.client()
+        self.blobs.spawn_rpc()
     }
 
     /// Returns an in-memory tags client