noosphere-ns 0.7.2

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
122
123
124
125
126
127
128
129
130
131

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>,
        quorum: usize,
    },
    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, quorum } => write!(
                fmt,
                "DHTRequest::PutRecord {{ key={:?}, value={:?}, quorum={:?} }}",
                str::from_utf8(key),
                str::from_utf8(value),
                quorum,
            ),
            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>;