docs(examples): add transfer-collection example

Author: b5

examples/transfer-collection.rs

@@ -0,0 +1,87 @@
+use anyhow::Result;
+use iroh::{protocol::Router, Endpoint, NodeId, Watcher};
+use iroh_blobs::{
+    api::{blobs::Blobs, downloader::Shuffled, Store},
+    format::collection::Collection,
+    store::mem::MemStore,
+    BlobsProtocol, Hash, HashAndFormat,
+};
+
+struct Node {
+    store: Store,
+    blobs: Blobs,
+    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.clone())
+            .spawn();
+
+        Ok(Self {
+            store,
+            blobs: blobs.blobs().clone(),
+            router,
+        })
+    }
+
+    async fn node_id(&self) -> Result<NodeId> {
+        let addr = self.router.endpoint().node_addr().initialized().await;
+        Ok(addr.node_id)
+    }
+
+    async fn list_hashes(&self) -> Result<Vec<Hash>> {
+        todo!();
+    }
+
+    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 tag = self.store.tags().create(collection).await?;
+        Ok(tag.hash())
+    }
+
+    async fn get_collection(&self, hash: Hash, provider: NodeId) -> Result<()> {
+        let req = HashAndFormat::hash_seq(hash);
+        let addrs = Shuffled::new(vec![provider]);
+        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_id = send_node.node_id().await?;
+    let hash = send_node.create_collection().await?;
+
+    let recv_node = Node::new().await?;
+    recv_node.get_collection(hash, send_node_id).await?;
+
+    let send_hashes = send_node.list_hashes().await?;
+    let recv_hashes = recv_node.list_hashes().await?;
+    assert_eq!(send_hashes, recv_hashes);
+
+    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.