iroh_docs/api/
protocol.rs

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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
//! Protocol definitions for irpc-based RPC.

use std::path::PathBuf;

use bytes::Bytes;
use iroh::NodeAddr;
use iroh_blobs::{api::blobs::ExportMode, Hash};
use irpc::{
    channel::{mpsc, oneshot},
    rpc_requests, Service,
};
use serde::{Deserialize, Serialize};

use super::RpcResult;
use crate::{
    actor::OpenState,
    engine::LiveEvent,
    store::{DownloadPolicy, Query},
    Author, AuthorId, Capability, CapabilityKind, DocTicket, Entry, NamespaceId, PeerIdBytes,
    SignedEntry,
};

/// The RPC service type for the docs protocol.
#[derive(Debug, Clone, Copy)]
pub struct DocsService;

impl Service for DocsService {}

/// Progress during import operations
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ImportProgress {
    /// Found the blob
    Found { size: u64 },
    /// Progress
    Progress { offset: u64 },
    /// Done
    Done { hash: Hash },
    /// All done
    AllDone,
}

/// Mode for sharing documents
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ShareMode {
    /// Share with read access
    Read,
    /// Share with write access
    Write,
}

// Request types
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct OpenRequest {
    pub doc_id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct OpenResponse;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct CloseRequest {
    pub doc_id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct CloseResponse;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct StatusRequest {
    pub doc_id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct StatusResponse {
    pub status: OpenState,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ListRequest;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ListResponse {
    pub id: NamespaceId,
    pub capability: CapabilityKind,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct CreateRequest;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct CreateResponse {
    pub id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct DropRequest {
    pub doc_id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct DropResponse;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ImportRequest {
    pub capability: Capability,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ImportResponse {
    pub doc_id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SetRequest {
    pub doc_id: NamespaceId,
    pub author_id: AuthorId,
    pub key: Bytes,
    pub value: Bytes,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SetResponse {
    pub entry: SignedEntry,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SetHashRequest {
    pub doc_id: NamespaceId,
    pub author_id: AuthorId,
    pub key: Bytes,
    pub hash: Hash,
    pub size: u64,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SetHashResponse;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct GetManyRequest {
    pub doc_id: NamespaceId,
    pub query: Query,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct GetExactRequest {
    pub doc_id: NamespaceId,
    pub key: Bytes,
    pub author: AuthorId,
    pub include_empty: bool,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct GetExactResponse {
    pub entry: Option<SignedEntry>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ImportFileRequest {
    pub doc_id: NamespaceId,
    pub author_id: AuthorId,
    pub key: Bytes,
    pub path: PathBuf,
    pub in_place: bool,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ExportFileRequest {
    pub entry: Entry,
    pub path: PathBuf,
    pub mode: ExportMode,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct DelRequest {
    pub doc_id: NamespaceId,
    pub author_id: AuthorId,
    pub prefix: Bytes,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct DelResponse {
    pub removed: usize,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct StartSyncRequest {
    pub doc_id: NamespaceId,
    pub peers: Vec<NodeAddr>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct StartSyncResponse;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct LeaveRequest {
    pub doc_id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct LeaveResponse;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ShareRequest {
    pub doc_id: NamespaceId,
    pub mode: ShareMode,
    pub addr_options: AddrInfoOptions,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ShareResponse(pub DocTicket);

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SubscribeRequest {
    pub doc_id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SubscribeResponse {
    pub event: LiveEvent,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct GetDownloadPolicyRequest {
    pub doc_id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct GetDownloadPolicyResponse {
    pub policy: DownloadPolicy,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SetDownloadPolicyRequest {
    pub doc_id: NamespaceId,
    pub policy: DownloadPolicy,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SetDownloadPolicyResponse;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct GetSyncPeersRequest {
    pub doc_id: NamespaceId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct GetSyncPeersResponse {
    pub peers: Option<Vec<PeerIdBytes>>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorListRequest;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorListResponse {
    pub author_id: AuthorId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorCreateRequest;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorCreateResponse {
    pub author_id: AuthorId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorGetDefaultRequest;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorGetDefaultResponse {
    pub author_id: AuthorId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorSetDefaultRequest {
    pub author_id: AuthorId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorSetDefaultResponse;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorImportRequest {
    pub author: Author,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorImportResponse {
    pub author_id: AuthorId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorExportRequest {
    pub author: AuthorId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorExportResponse {
    pub author: Option<Author>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorDeleteRequest {
    pub author: AuthorId,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct AuthorDeleteResponse;

// Use the macro to generate both the DocsProtocol and DocsMessage enums
// plus implement Channels for each type
#[rpc_requests(DocsService, message = DocsMessage)]
#[derive(Serialize, Deserialize, Debug)]
pub enum DocsProtocol {
    #[rpc(tx = oneshot::Sender<RpcResult<OpenResponse>>)]
    Open(OpenRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<CloseResponse>>)]
    Close(CloseRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<StatusResponse>>)]
    Status(StatusRequest),
    #[rpc(tx = mpsc::Sender<RpcResult<ListResponse>>)]
    List(ListRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<CreateResponse>>)]
    Create(CreateRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<DropResponse>>)]
    Drop(DropRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<ImportResponse>>)]
    Import(ImportRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<SetResponse>>)]
    Set(SetRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<SetHashResponse>>)]
    SetHash(SetHashRequest),
    #[rpc(tx = mpsc::Sender<RpcResult<SignedEntry>>)]
    Get(GetManyRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<GetExactResponse>>)]
    GetExact(GetExactRequest),
    // #[rpc(tx = mpsc::Sender<ImportProgress>)]
    // ImportFile(ImportFileRequest),
    // #[rpc(tx = mpsc::Sender<ExportProgress>)]
    // ExportFile(ExportFileRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<DelResponse>>)]
    Del(DelRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<StartSyncResponse>>)]
    StartSync(StartSyncRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<LeaveResponse>>)]
    Leave(LeaveRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<ShareResponse>>)]
    Share(ShareRequest),
    #[rpc(tx = mpsc::Sender<RpcResult<SubscribeResponse>>)]
    Subscribe(SubscribeRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<GetDownloadPolicyResponse>>)]
    GetDownloadPolicy(GetDownloadPolicyRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<SetDownloadPolicyResponse>>)]
    SetDownloadPolicy(SetDownloadPolicyRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<GetSyncPeersResponse>>)]
    GetSyncPeers(GetSyncPeersRequest),
    #[rpc(tx = mpsc::Sender<RpcResult<AuthorListResponse>>)]
    AuthorList(AuthorListRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<AuthorCreateResponse>>)]
    AuthorCreate(AuthorCreateRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<AuthorGetDefaultResponse>>)]
    AuthorGetDefault(AuthorGetDefaultRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<AuthorSetDefaultResponse>>)]
    AuthorSetDefault(AuthorSetDefaultRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<AuthorImportResponse>>)]
    AuthorImport(AuthorImportRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<AuthorExportResponse>>)]
    AuthorExport(AuthorExportRequest),
    #[rpc(tx = oneshot::Sender<RpcResult<AuthorDeleteResponse>>)]
    AuthorDelete(AuthorDeleteRequest),
}

/// Options to configure what is included in a [`iroh::NodeAddr`].
#[derive(
    Copy,
    Clone,
    PartialEq,
    Eq,
    Default,
    Debug,
    derive_more::Display,
    derive_more::FromStr,
    Serialize,
    Deserialize,
)]
pub enum AddrInfoOptions {
    /// Only the Node ID is added.
    ///
    /// This usually means that iroh-dns discovery is used to find address information.
    #[default]
    Id,
    /// Includes the Node ID and both the relay URL, and the direct addresses.
    RelayAndAddresses,
    /// Includes the Node ID and the relay URL.
    Relay,
    /// Includes the Node ID and the direct addresses.
    Addresses,
}

impl AddrInfoOptions {
    /// Apply the options to the given address.
    pub fn apply(
        &self,
        iroh::NodeAddr {
            node_id,
            relay_url,
            direct_addresses,
        }: &iroh::NodeAddr,
    ) -> iroh::NodeAddr {
        match self {
            Self::Id => iroh::NodeAddr {
                node_id: *node_id,
                relay_url: None,
                direct_addresses: Default::default(),
            },
            Self::Relay => iroh::NodeAddr {
                node_id: *node_id,
                relay_url: relay_url.clone(),
                direct_addresses: Default::default(),
            },
            Self::Addresses => iroh::NodeAddr {
                node_id: *node_id,
                relay_url: None,
                direct_addresses: direct_addresses.clone(),
            },
            Self::RelayAndAddresses => iroh::NodeAddr {
                node_id: *node_id,
                relay_url: relay_url.clone(),
                direct_addresses: direct_addresses.clone(),
            },
        }
    }
}