bluefin 0.1.6

An experimental, secure, P2P, transport-layer protocol.
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

use thiserror::Error;

#[derive(Error, Debug, PartialEq)]
pub enum BluefinError {
    #[error("Unable to serialise data")]
    SerialiseError,

    #[error("`{0}`")]
    DeserialiseError(String),

    #[error("Connection buffer does not exist")]
    BufferDoesNotExist,

    #[error("Current buffer is full: `{0}`")]
    BufferFullError(String),

    #[error("Current buffer is empty.")]
    BufferEmptyError,

    #[error("Unable to accept new connection: `{0}`")]
    CouldNotAcceptConnectionError(String),

    #[error("Unable to complete handshake: `{0}`")]
    HandshakeError(String),

    #[error("`{0}`")]
    InvalidHeaderError(String),

    #[error("`Payload size of {0} bytes is too large`")]
    LargePayloadError(String),

    #[error("Encountered error while reading from socket: `{0}`")]
    ReadError(String),

    #[error("Encountered error while writing to socket: `{0}`")]
    WriteError(String),

    #[error("Cannot currently open stream for given connection")]
    CannotOpenStreamError,

    #[error("Cannot currently accept new connection due to too many connections opened")]
    TooManyOpenConnectionsError,

    #[error("No such connection found")]
    NoSuchConnectionError,

    #[error("Connection already exists. Nothing done.")]
    ConnectionAlreadyExists,

    #[error("Stream already exists. Nothing done.")]
    StreamAlreadyExists,

    #[error("No such waker.")]
    NoSuchWakerError,

    #[error("Socket is not valid.")]
    InvalidSocketError,

    #[error("Encountered packet with unexpected packet number.")]
    UnexpectedPacketNumberError,

    #[error("Could not buffer data: `{0}`")]
    CannotBufferError(String),

    #[error("No such stream buffered")]
    NoSuchStreamError,

    #[error("std::io::Error: `{0}`")]
    StdIoError(String),

    #[error("`{0}`")]
    Unexpected(String),

    #[error("`{0}`")]
    TimedOut(String),
}

/// Allows us to convert from std::io::Error to Bluefin errors. This is mostly a quality
/// of life requirement since this let's use the `?` operator with greater ease.
impl From<std::io::Error> for BluefinError {
    fn from(error: std::io::Error) -> Self {
        BluefinError::StdIoError(error.to_string())
    }
}