iroh-node-util 0.35.0

Utilities to build binaries containing an iroh endpoint
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

//! RPC calls to control an iroh endpoint.
#![allow(missing_docs)]
use iroh::{endpoint::RemoteInfo, NodeAddr, NodeId, PublicKey, RelayUrl};
use nested_enum_utils::enum_conversions;
use quic_rpc_derive::rpc_requests;
use serde::{Deserialize, Serialize};

use super::{RpcResult, RpcService};

#[derive(strum::Display, Debug, Serialize, Deserialize)]
#[enum_conversions(super::Request)]
#[rpc_requests(RpcService)]
pub enum Request {
    #[rpc(response = RpcResult<NodeId>)]
    Id(IdRequest),
    #[rpc(response = RpcResult<NodeAddr>)]
    Addr(AddrRequest),
    #[rpc(response = RpcResult<()>)]
    AddAddr(AddAddrRequest),
    #[rpc(response = RpcResult<Option<RelayUrl>>)]
    Relay(RelayRequest),
    #[server_streaming(response = RpcResult<RemoteInfosIterResponse>)]
    RemoteInfosIter(RemoteInfosIterRequest),
    #[rpc(response = RpcResult<RemoteInfoResponse>)]
    RemoteInfo(RemoteInfoRequest),
    #[server_streaming(response = WatchResponse)]
    Watch(NodeWatchRequest),
}

#[allow(missing_docs)]
#[derive(strum::Display, Debug, Serialize, Deserialize)]
#[enum_conversions(super::Response)]
pub enum Response {
    Id(RpcResult<NodeId>),
    Addr(RpcResult<NodeAddr>),
    Relay(RpcResult<Option<RelayUrl>>),
    RemoteInfosIter(RpcResult<RemoteInfosIterResponse>),
    RemoteInfo(RpcResult<RemoteInfoResponse>),
    Watch(WatchResponse),
    Unit(RpcResult<()>),
}

/// List network path information about all the remote nodes known by this node.
///
/// There may never have been connections to these nodes, and connections may not even be
/// possible. Nodes can also become known due to discovery mechanisms
/// or be added manually.
#[derive(Debug, Serialize, Deserialize)]
pub struct RemoteInfosIterRequest;

/// A response to a [`Request::RemoteInfosIter`].
#[derive(Debug, Serialize, Deserialize)]
pub struct RemoteInfosIterResponse {
    /// Information about a node.
    pub info: RemoteInfo,
}

/// Get information about a specific remote node.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RemoteInfoRequest {
    /// The node identifier
    pub node_id: PublicKey,
}

/// A response to a [`Request::RemoteInfo`] request
#[derive(Debug, Serialize, Deserialize)]
pub struct RemoteInfoResponse {
    /// Information about a node
    pub info: Option<RemoteInfo>,
}

/// A request to get information the identity of the node.
#[derive(Serialize, Deserialize, Debug)]
pub struct IdRequest;

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

#[derive(Serialize, Deserialize, Debug)]
pub struct AddAddrRequest {
    pub addr: NodeAddr,
}

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

/// A request to watch for the node status
#[derive(Serialize, Deserialize, Debug)]
pub struct NodeWatchRequest;

/// The response to a watch request
#[derive(Serialize, Deserialize, Debug)]
pub struct WatchResponse {
    /// The version of the node
    pub version: String,
}