hashtree-cli 0.2.156

Hashtree daemon and CLI with content-addressed storage and adaptive blob routing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use super::*;

#[tokio::test]
async fn daemon_blob_resolver_discovers_other_daemons_through_pure_anchor() {
    let rendezvous = reserve_local_rendezvous_addr();
    let anchor = local_only_endpoint(rendezvous, "pure-fips-anchor").await;
    let provider = local_only_endpoint(rendezvous, "drive-provider").await;
    let consumer = local_only_endpoint(rendezvous, "htree-consumer").await;
    let temp = tempfile::tempdir().unwrap();
    let provider_store = Arc::new(HashtreeStore::new(temp.path().join("provider")).unwrap());
    let consumer_store = Arc::new(HashtreeStore::new(temp.path().join("consumer")).unwrap());
    let data = b"found without any configured peer identities".to_vec();
    let hash = Sha256::digest(&data).into();
    provider_store
        .store_arc()
        .put(hash, data.clone())
        .await
        .unwrap();
    let (provider_resolver, provider_transport) = bind_daemon_blob_resolver(
        &provider,
        provider_store.store_arc(),
        &[],
        Duration::from_secs(5),
    )
    .await
    .unwrap();
    let (consumer_resolver, consumer_transport) = bind_daemon_blob_resolver(
        &consumer,
        consumer_store.store_arc(),
        &[],
        Duration::from_secs(5),
    )
    .await
    .unwrap();
    timeout(Duration::from_secs(10), async {
        while !provider_advertised(&consumer, &provider.local_peer_id) {
            tokio::time::sleep(Duration::from_millis(20)).await;
        }
    })
    .await
    .expect("daemon provider roster converges");
    assert!(
        !consumer
            .native_endpoint
            .peers()
            .await
            .unwrap()
            .iter()
            .any(|peer| { peer.connected && peer.npub == provider.local_peer_id }),
        "the discovered provider is reachable only through the pure anchor"
    );
    assert_eq!(
        consumer_resolver.get(&hash, None).await.unwrap(),
        Some(data.clone())
    );
    assert_eq!(
        consumer_store.store_arc().get(&hash).await.unwrap(),
        Some(data)
    );
    // A mutual miss must exhaust the mesh budget instead of recursing forever.
    let missing = Sha256::digest(b"not in either daemon").into();
    let result = timeout(
        Duration::from_secs(7),
        consumer_resolver.get(&missing, None),
    )
    .await;
    assert!(
        result.is_ok(),
        "discovered daemon forwarding did not terminate"
    );
    assert!(!matches!(result.unwrap(), Ok(Some(_))));

    drop((
        consumer_resolver,
        consumer_transport,
        provider_resolver,
        provider_transport,
    ));
    consumer.native_endpoint.shutdown().await.unwrap();
    provider.native_endpoint.shutdown().await.unwrap();
    anchor.native_endpoint.shutdown().await.unwrap();
}