ringdrop 0.15.0

P2P streamed file transfer with ring-based access control, built on iroh and bao protocols
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

mod common;

use std::sync::{Arc, Mutex};

use iroh_blobs::BlobFormat;
use iroh_rings::{Permission, Registry, OPEN_RING_NAME};
use ringdrop::core::ProgressEvent;
use tempfile::TempDir;

#[tokio::test]
async fn file_content_matches_after_transfer() {
    let sender = common::TestNode::start().await;
    let receiver = common::TestNode::start().await;

    let content = b"the quick brown fox jumps over the lazy dog";
    let src = TempDir::new().unwrap();
    let file = common::write_file(src.path(), "fox.txt", content).await;

    let (hash, format) = sender.node.import_file(&file).await.unwrap();
    sender
        .node
        .registry
        .add_ring_to_resource(*hash.as_bytes(), OPEN_RING_NAME, &[Permission::Read])
        .unwrap();

    let ticket = sender
        .node
        .make_ticket(hash, format, Some("fox.txt".into()));
    let dest = TempDir::new().unwrap();
    receiver.node.download(&ticket, dest.path()).await.unwrap();

    assert_eq!(
        tokio::fs::read(dest.path().join("fox.txt")).await.unwrap(),
        content
    );

    sender.shutdown().await;
    receiver.shutdown().await;
}

#[tokio::test]
async fn directory_contents_match_after_transfer() {
    let sender = common::TestNode::start().await;
    let receiver = common::TestNode::start().await;

    let src = TempDir::new().unwrap();
    let dir = src.path().join("mydir");
    tokio::fs::create_dir_all(&dir).await.unwrap();
    common::write_file(&dir, "hello.txt", b"hello world").await;
    common::write_file(&dir, "data.bin", b"\x00\x01\x02\x03").await;

    let (hash, format) = sender.node.import_directory(&dir).await.unwrap();
    sender
        .node
        .registry
        .add_ring_to_resource(*hash.as_bytes(), OPEN_RING_NAME, &[Permission::Read])
        .unwrap();

    let ticket = sender.node.make_ticket(hash, format, Some("mydir".into()));
    let dest = TempDir::new().unwrap();
    receiver.node.download(&ticket, dest.path()).await.unwrap();

    let out = dest.path().join("mydir");
    assert_eq!(
        tokio::fs::read(out.join("hello.txt")).await.unwrap(),
        b"hello world"
    );
    assert_eq!(
        tokio::fs::read(out.join("data.bin")).await.unwrap(),
        b"\x00\x01\x02\x03"
    );

    sender.shutdown().await;
    receiver.shutdown().await;
}

#[tokio::test]
async fn directory_transfer_emits_file_start_events_per_member() {
    let sender = common::TestNode::start().await;
    let receiver = common::TestNode::start().await;

    let src = TempDir::new().unwrap();
    let dir = src.path().join("photos");
    tokio::fs::create_dir_all(&dir).await.unwrap();
    common::write_file(&dir, "a.jpg", b"img-a").await;
    common::write_file(&dir, "b.jpg", b"img-b").await;

    let (hash, format) = sender.node.import_directory(&dir).await.unwrap();
    assert_eq!(format, BlobFormat::HashSeq);
    sender
        .node
        .registry
        .add_ring_to_resource(*hash.as_bytes(), OPEN_RING_NAME, &[Permission::Read])
        .unwrap();

    let ticket = sender.node.make_ticket(hash, format, Some("photos".into()));
    let dest = TempDir::new().unwrap();

    let file_starts: Arc<Mutex<Vec<(usize, usize, String)>>> = Arc::new(Mutex::new(Vec::new()));
    let file_starts_clone = Arc::clone(&file_starts);

    receiver
        .node
        .download_with_progress(&ticket, dest.path(), move |ev| {
            if let ProgressEvent::FileStart { index, total, name } = ev {
                file_starts_clone.lock().unwrap().push((index, total, name));
            }
        })
        .await
        .unwrap();

    {
        let starts = file_starts.lock().unwrap();
        assert_eq!(starts.len(), 2, "expected one FileStart per member file");
        assert!(starts.iter().all(|(_, t, _)| *t == 2));
        let names: Vec<&str> = starts.iter().map(|(_, _, n)| n.as_str()).collect();
        assert!(names.contains(&"a.jpg"));
        assert!(names.contains(&"b.jpg"));
    }

    sender.shutdown().await;
    receiver.shutdown().await;
}

#[tokio::test]
async fn already_complete_blob_skips_transfer() {
    let sender = common::TestNode::start().await;
    let receiver = common::TestNode::start().await;

    let content = b"cached content";
    let src = TempDir::new().unwrap();
    let file = common::write_file(src.path(), "cached.txt", content).await;

    let (hash, format) = sender.node.import_file(&file).await.unwrap();
    sender
        .node
        .registry
        .add_ring_to_resource(*hash.as_bytes(), OPEN_RING_NAME, &[Permission::Read])
        .unwrap();

    let ticket = sender
        .node
        .make_ticket(hash, format, Some("cached.txt".into()));

    let dest1 = TempDir::new().unwrap();
    receiver.node.download(&ticket, dest1.path()).await.unwrap();
    assert_eq!(
        tokio::fs::read(dest1.path().join("cached.txt"))
            .await
            .unwrap(),
        content
    );

    // sender is gone — second download must succeed from local store only
    sender.shutdown().await;

    let dest2 = TempDir::new().unwrap();
    receiver.node.download(&ticket, dest2.path()).await.unwrap();
    assert_eq!(
        tokio::fs::read(dest2.path().join("cached.txt"))
            .await
            .unwrap(),
        content
    );

    receiver.shutdown().await;
}