noosphere-ns 0.5.1

A P2P name system for Noosphere
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

use crate::dht::channel::{Message, MessageClient, MessageProcessor};
use crate::dht::errors::DhtError;
use crate::dht::types::{DhtRecord, NetworkInfo, Peer};
use libp2p::Multiaddr;

use std::{fmt, str};

#[derive(Debug)]
pub enum DhtRequest {
    AddPeers { peers: Vec<Multiaddr> },
    StartListening { address: Multiaddr },
    StopListening,
    Bootstrap,
    //WaitForPeers(usize),
    GetAddresses { external: bool },
    GetPeers,
    GetNetworkInfo,
    GetRecord { key: Vec<u8> },
    PutRecord { key: Vec<u8>, value: Vec<u8> },
    StartProviding { key: Vec<u8> },
    GetProviders { key: Vec<u8> },
}

impl fmt::Display for DhtRequest {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            //DHTRequest::WaitForPeers(peers) => write!(fmt, "DHTRequest::WaitForPeers({})", peers),
            DhtRequest::AddPeers { peers } => {
                write!(fmt, "DHTRequest::AddPeers {{ peers={:?} }}", peers)
            }
            DhtRequest::StartListening { address } => {
                write!(
                    fmt,
                    "DHTRequest::StartListening {{ address={:?} }}",
                    address
                )
            }
            DhtRequest::StopListening => {
                write!(fmt, "DHTRequest::StopListening")
            }
            DhtRequest::Bootstrap => write!(fmt, "DHTRequest::Bootstrap"),
            DhtRequest::GetAddresses { external } => write!(
                fmt,
                "DHTRequest::GetAddresses {{ external={:?} }}",
                external
            ),
            DhtRequest::GetPeers => write!(fmt, "DHTRequest::GetPeers"),
            DhtRequest::GetNetworkInfo => write!(fmt, "DHTRequest::GetNetworkInfo"),
            DhtRequest::GetRecord { key } => write!(
                fmt,
                "DHTRequest::GetRecord {{ key={:?} }}",
                str::from_utf8(key)
            ),
            DhtRequest::PutRecord { key, value } => write!(
                fmt,
                "DHTRequest::PutRecord {{ key={:?}, value={:?} }}",
                str::from_utf8(key),
                str::from_utf8(value)
            ),
            DhtRequest::StartProviding { key } => write!(
                fmt,
                "DHTRequest::StartProviding {{ key={:?} }}",
                str::from_utf8(key)
            ),
            DhtRequest::GetProviders { key } => write!(
                fmt,
                "DHTRequest::GetProviders {{ key={:?} }}",
                str::from_utf8(key)
            ),
        }
    }
}

#[derive(Debug)]
pub enum DhtResponse {
    Success,
    Address(Multiaddr),
    GetAddresses(Vec<Multiaddr>),
    GetNetworkInfo(NetworkInfo),
    GetPeers(Vec<Peer>),
    GetRecord(DhtRecord),
    PutRecord { key: Vec<u8> },
    GetProviders { providers: Vec<libp2p::PeerId> },
}

impl fmt::Display for DhtResponse {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DhtResponse::Success => write!(fmt, "DHTResponse::Success"),
            DhtResponse::Address(address) => {
                write!(fmt, "DHTResponse::Address {{ {:?} }}", address)
            }
            DhtResponse::GetAddresses(addresses) => {
                write!(fmt, "DHTResponse::GetAddresses {{ {:?} }}", addresses)
            }
            DhtResponse::GetPeers(peers) => {
                write!(fmt, "DHTResponse::GetPeers{:?}", peers)
            }
            DhtResponse::GetNetworkInfo(info) => {
                write!(fmt, "DHTResponse::GetNetworkInfo {:?}", info)
            }
            DhtResponse::GetRecord(record) => {
                write!(fmt, "DHTResponse::GetRecord {{ {:?} }}", record)
            }
            DhtResponse::PutRecord { key } => write!(
                fmt,
                "DHTResponse::PutRecord {{ key={:?} }}",
                str::from_utf8(key)
            ),
            DhtResponse::GetProviders { providers } => write!(
                fmt,
                "DHTResponse::GetProviders {{ providers={:?} }}",
                providers
            ),
        }
    }
}

pub type DhtMessage = Message<DhtRequest, DhtResponse, DhtError>;
pub type DhtMessageProcessor = MessageProcessor<DhtRequest, DhtResponse, DhtError>;
pub type DhtMessageClient = MessageClient<DhtRequest, DhtResponse, DhtError>;