noosphere-ns 0.1.0

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

use crate::dht::channel::{Message, MessageClient, MessageProcessor};
use crate::dht::errors::DHTError;
use libp2p::swarm::NetworkInfo;
use std::{fmt, str};

#[derive(Debug, PartialEq, Eq)]
pub struct DHTNetworkInfo {
    pub num_peers: usize,
    pub num_connections: u32,
    pub num_pending: u32,
    pub num_established: u32,
}

impl From<NetworkInfo> for DHTNetworkInfo {
    fn from(info: NetworkInfo) -> Self {
        let c = info.connection_counters();
        DHTNetworkInfo {
            num_peers: info.num_peers(),
            num_connections: c.num_connections(),
            num_pending: c.num_pending(),
            num_established: c.num_established(),
        }
    }
}

#[derive(Debug)]
pub enum DHTRequest {
    Bootstrap,
    //WaitForPeers(usize),
    GetNetworkInfo,
    GetRecord { name: Vec<u8> },
    SetRecord { name: Vec<u8>, value: Vec<u8> },
    StartProviding { name: Vec<u8> },
    GetProviders { name: 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::Bootstrap => write!(fmt, "DHTRequest::Bootstrap"),
            DHTRequest::GetNetworkInfo => write!(fmt, "DHTRequest::GetNetworkInfo"),
            DHTRequest::GetRecord { name } => write!(
                fmt,
                "DHTRequest::GetRecord {{ name={:?} }}",
                str::from_utf8(name)
            ),
            DHTRequest::SetRecord { name, value } => write!(
                fmt,
                "DHTRequest::SetRecord {{ name={:?}, value={:?} }}",
                str::from_utf8(name),
                str::from_utf8(value)
            ),
            DHTRequest::StartProviding { name } => write!(
                fmt,
                "DHTRequest::StartProviding {{ name={:?} }}",
                str::from_utf8(name)
            ),
            DHTRequest::GetProviders { name } => write!(
                fmt,
                "DHTRequest::GetProviders {{ name={:?} }}",
                str::from_utf8(name)
            ),
        }
    }
}

#[derive(Debug)]
pub enum DHTResponse {
    Success,
    GetNetworkInfo(DHTNetworkInfo),
    GetRecord {
        name: Vec<u8>,
        value: Option<Vec<u8>>,
    },
    SetRecord {
        name: Vec<u8>,
    },
    StartProviding {
        name: Vec<u8>,
    },
    GetProviders {
        name: Vec<u8>,
        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::GetNetworkInfo(info) => {
                write!(fmt, "DHTResponse::GetNetworkInfo {:?}", info)
            }
            DHTResponse::GetRecord { name, value } => write!(
                fmt,
                "DHTResponse::GetRecord {{ name={:?}, value={:?} }}",
                str::from_utf8(name),
                if value.is_some() {
                    str::from_utf8(value.as_ref().unwrap())
                } else {
                    Ok("None")
                }
            ),
            DHTResponse::SetRecord { name } => write!(
                fmt,
                "DHTResponse::SetRecord {{ name={:?} }}",
                str::from_utf8(name)
            ),
            DHTResponse::StartProviding { name } => write!(
                fmt,
                "DHTResponse::StartProviding {{ name={:?} }}",
                str::from_utf8(name)
            ),
            DHTResponse::GetProviders { name, providers } => write!(
                fmt,
                "DHTResponse::GetProviders {{ name={:?}, providers={:?} }}",
                str::from_utf8(name),
                providers
            ),
        }
    }
}

pub type DHTMessage = Message<DHTRequest, DHTResponse, DHTError>;
pub type DHTMessageProcessor = MessageProcessor<DHTRequest, DHTResponse, DHTError>;
pub type DHTMessageClient = MessageClient<DHTRequest, DHTResponse, DHTError>;