docs(examples): add transfer-collection example

Author: b5

examples/transfer-collection.rs

@@ -0,0 +1,93 @@
+use anyhow::{Context, Result};
+use iroh::{protocol::Router, Endpoint, NodeAddr, Watcher};
+use iroh_blobs::{
+    api::{downloader::Shuffled, Store},
+    format::collection::Collection,
+    store::mem::MemStore,
+    BlobsProtocol, Hash, HashAndFormat,
+};
+
+struct Node {
+    store: Store,
+    router: Router,
+}
+
+impl Node {
+    async fn new() -> Result<Self> {
+        let endpoint = Endpoint::builder().discovery_n0().bind().await?;
+
+        // We initialize an in-memory backing store for iroh-blobs
+        let store = MemStore::new();
+        // Then we initialize a struct that can accept blobs requests over iroh connections
+        let blobs = BlobsProtocol::new(&store, endpoint.clone(), None);
+
+        let router = Router::builder(endpoint)
+            .accept(iroh_blobs::ALPN, blobs)
+            .spawn();
+
+        Ok(Self {
+            store: store.into(),
+            router,
+        })
+    }
+
+    async fn node_addr(&self) -> Result<NodeAddr> {
+        let addr = self.router.endpoint().node_addr().initialized().await;
+        Ok(addr)
+    }
+
+    async fn list_hashes(&self) -> Result<Vec<Hash>> {
+        self.store
+            .blobs()
+            .list()
+            .hashes()
+            .await
+            .context("Failed to list hashes")
+    }
+
+    async fn create_collection(&self) -> Result<Hash> {
+        let tx = self.store.batch().await?;
+        let a = tx.add_slice(b"a").await?;
+        let b = tx.add_slice(b"b").await?;
+        let c = tx.add_slice(b"c").await?;
+
+        let collection = Collection::from_iter([
+            ("a", a.hash().clone()),
+            ("b", b.hash().clone()),
+            ("c", c.hash().clone()),
+        ]);
+
+        let collection = collection.store(&self.store).await?;
+        let hash = collection.hash().clone();
+        self.store.tags().create(collection).await?;
+        Ok(hash)
+    }
+
+    async fn get_collection(&self, hash: Hash, provider: NodeAddr) -> Result<()> {
+        self.router.endpoint().add_node_addr(provider.clone())?;
+        let req = HashAndFormat::hash_seq(hash);
+        let addrs = Shuffled::new(vec![provider.node_id]);
+        self.store
+            .downloader(self.router.endpoint())
+            .download(req, addrs)
+            .await?;
+        Ok(())
+    }
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let send_node = Node::new().await?;
+    let send_node_addr = send_node.node_addr().await?;
+    let hash = send_node.create_collection().await?;
+
+    let recv_node = Node::new().await?;
+    recv_node.node_addr().await?;
+    recv_node.get_collection(hash, send_node_addr).await?;
+
+    let send_hashes = send_node.list_hashes().await?;
+    let recv_hashes = recv_node.list_hashes().await?;
+    assert_eq!(send_hashes.len(), recv_hashes.len());
+
+    Ok(())
+}

src/api/blobs.rs

@@ -620,7 +620,7 @@ pub struct AddPathOptions {
 /// stream directly can be inconvenient, so this struct provides some convenience
 /// methods to work with the result.
 ///
-/// It also implements [`IntoFuture`], so you can await it to get the [`TempTag`] that
+/// It also implements [`IntoFuture`], so you can await it to get the [`TagInfo`] that
 /// contains the hash of the added content and also protects the content.
 ///
 /// If you want access to the stream, you can use the [`AddProgress::stream`] method.