ckb-network 0.105.0

ckb network implementation
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
132
133
134
135
136
137
138
139
140
141
142
143

//! Error module
use p2p::{
    error::{
        DialerErrorKind, ListenErrorKind, ProtocolHandleErrorKind, SendErrorKind,
        TransportErrorKind,
    },
    secio::PeerId,
    SessionId,
};
use std::fmt;
use std::fmt::Display;
use std::io::Error as IoError;

/// Alias result on network module
pub type Result<T> = ::std::result::Result<T, Error>;

/// All error on network module
#[derive(Debug)]
pub enum Error {
    /// Peer error
    Peer(PeerError),
    /// Io error
    Io(IoError),
    /// Error from tentacle
    P2P(P2PError),
    /// Dail error
    Dial(String),
    /// Peer store error
    PeerStore(PeerStoreError),
}

/// Error from tentacle
#[derive(Debug)]
pub enum P2PError {
    /// Not support transport or some other error
    Transport(TransportErrorKind),
    /// Handle panic or other error
    Protocol(ProtocolHandleErrorKind),
    /// Dail error
    Dail(DialerErrorKind),
    /// Listen error
    Listen(ListenErrorKind),
    /// Net shutdown or too many messages blocked on
    Send(SendErrorKind),
}

/// Peer store error
#[derive(Debug)]
pub enum PeerStoreError {
    /// Indicate the peer store is full
    EvictionFailed,
    /// File data is not json format
    Serde(serde_json::Error),
}

/// Peer error
#[derive(Debug, Eq, PartialEq)]
pub enum PeerError {
    /// Session already exists
    SessionExists(SessionId),
    /// Peer id exist
    PeerIdExists(PeerId),
    /// Non-reserved peers
    NonReserved,
    /// Peer is banned
    Banned,
    /// Reach max inbound limit
    ReachMaxInboundLimit,
    /// Reach max outbound limit
    ReachMaxOutboundLimit,
}

impl From<PeerStoreError> for Error {
    fn from(err: PeerStoreError) -> Error {
        Error::PeerStore(err)
    }
}

impl From<PeerError> for Error {
    fn from(err: PeerError) -> Error {
        Error::Peer(err)
    }
}

impl From<IoError> for Error {
    fn from(err: IoError) -> Error {
        Error::Io(err)
    }
}

impl From<P2PError> for Error {
    fn from(err: P2PError) -> Error {
        Error::P2P(err)
    }
}

impl From<TransportErrorKind> for Error {
    fn from(err: TransportErrorKind) -> Error {
        Error::P2P(P2PError::Transport(err))
    }
}

impl From<ProtocolHandleErrorKind> for Error {
    fn from(err: ProtocolHandleErrorKind) -> Error {
        Error::P2P(P2PError::Protocol(err))
    }
}

impl From<DialerErrorKind> for Error {
    fn from(err: DialerErrorKind) -> Error {
        Error::P2P(P2PError::Dail(err))
    }
}

impl From<ListenErrorKind> for Error {
    fn from(err: ListenErrorKind) -> Error {
        Error::P2P(P2PError::Listen(err))
    }
}

impl From<SendErrorKind> for Error {
    fn from(err: SendErrorKind) -> Error {
        Error::P2P(P2PError::Send(err))
    }
}

impl Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl Display for PeerError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl Display for P2PError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}