zblob 0.3.0

Resumable verified-streaming blob & directory transfer over Zenoh (BLAKE3/bao, range resume, content-addressed dedup)
Documentation
//! End-to-end Tier-2 directory sync in one process: snapshot a tree, serve
//! it, sync it (twice — the second pull after an edit transfers only the
//! changed chunks).
//!
//! ```bash
//! cargo run --example tree_sync
//! ```

use std::sync::Arc;

use zblob::{
    CdcParams, ContentStore, DownloadRequest, MemoryStore, QueryPrefix, ServePrefix, TreeClient,
    TreeServer, build_tree,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let session = Arc::new(
        zenoh::open(zenoh::Config::default())
            .await
            .map_err(|e| e.to_string())?,
    );
    // Prefixes are typed by role; a server's converts to a client's for free.
    let store_serve = ServePrefix::new("demo/store")?;
    let tree_serve = ServePrefix::new("demo/tree")?;
    let (store_query, tree_query) = (
        QueryPrefix::from(&store_serve),
        QueryPrefix::from(&tree_serve),
    );

    // --- producer: build + serve a snapshot ---------------------------------
    let src = tempfile::tempdir()?;
    std::fs::create_dir_all(src.path().join("sub"))?;
    std::fs::write(src.path().join("big.bin"), vec![7u8; 2 * 1024 * 1024])?;
    std::fs::write(src.path().join("sub/notes.md"), b"# hello\n")?;

    let server_store: Arc<dyn ContentStore> = Arc::new(MemoryStore::new());
    let cdc = CdcParams::default();
    let index = build_tree(src.path(), "snap-1", &cdc, &*server_store)?;
    println!(
        "snapshot snap-1: {} files, {} chunks, root {}",
        index.file_count(),
        index.needed_chunks().len(),
        index.root_hash
    );

    let server = TreeServer::new(&session, store_serve, tree_serve, server_store.clone());
    server.register(index.clone()).await.unwrap();
    let handle = server.clone().spawn().await?;

    // --- consumer: sync (pinned), then re-sync after an edit ----------------
    let dest = tempfile::tempdir()?;
    let client = TreeClient::new(&session, store_query, tree_query);
    let client_store: Arc<dyn ContentStore> = Arc::new(MemoryStore::new());

    let stats = client
        .download_tree(
            &DownloadRequest::pinned("snap-1", index.root_hash),
            dest.path(),
            &client_store,
        )
        .await?;
    println!("first sync: fetched {} chunks", stats.chunks_fetched);

    // Edit one file, snapshot again, re-sync: only the delta moves.
    std::fs::write(src.path().join("sub/notes.md"), b"# hello, edited\n")?;
    let index2 = build_tree(src.path(), "snap-2", &cdc, &*server_store)?;
    server.register(index2.clone()).await.unwrap();

    let stats = client
        .download_tree(
            &DownloadRequest::pinned("snap-2", index2.root_hash),
            dest.path(),
            &client_store,
        )
        .await?;
    println!(
        "re-sync after edit: fetched {} chunks, reused {}",
        stats.chunks_fetched, stats.chunks_resumed
    );
    assert_eq!(
        std::fs::read(dest.path().join("sub/notes.md"))?,
        b"# hello, edited\n"
    );

    handle.shutdown().await?;
    session.close().await.map_err(|e| e.to_string())?;
    Ok(())
}