h10 0.6.10

Simple HTTP/1.0 Server
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

use std::{
    error::Error,
    fmt::Display,
    io::Error as IoError,
    num::{ParseFloatError, ParseIntError},
    str::Utf8Error,
    string::FromUtf8Error,
    sync::mpsc::SendError,
    time::SystemTimeError,
};

use super::status_code::StatusCode;

pub type H10LibResult<T> = Result<T, H10LibError>;

#[derive(Debug)]
pub enum H10LibError {
    VersionNotSupported,
    MethodNotSupported,
    StatusCodeNotSupported,
    InvalidInputData(String),
    ParseFloatError(ParseFloatError),
    SystemTimeError(SystemTimeError),
    ParseIntError(ParseIntError),
    FromUtf8Error,
    Utf8Error,
    RequestParser(String),
    HeadersParser(String),
    QueryStringParser(String),
    ResponseParser(String),
    IoError(IoError),
    StrFromAscii(String),
    ClientError(H10ClientError),
    MpscSendError,
    Custom(String),
}

impl H10LibError {
    pub fn custom(msg: &str) -> Self {
        Self::Custom(msg.to_owned())
    }
}

#[derive(Debug)]
pub enum H10ClientError {
    Timeout,
    InternalError(String),
}

impl<T: ToString> From<SendError<T>> for H10LibError {
    fn from(_: SendError<T>) -> Self {
        Self::MpscSendError
    }
}

impl From<FromUtf8Error> for H10LibError {
    fn from(_: FromUtf8Error) -> Self {
        Self::FromUtf8Error
    }
}

impl From<Utf8Error> for H10LibError {
    fn from(_: Utf8Error) -> Self {
        Self::Utf8Error
    }
}

impl From<ParseFloatError> for H10LibError {
    fn from(error: ParseFloatError) -> Self {
        Self::ParseFloatError(error)
    }
}

impl From<SystemTimeError> for H10LibError {
    fn from(error: SystemTimeError) -> Self {
        Self::SystemTimeError(error)
    }
}

impl From<ParseIntError> for H10LibError {
    fn from(error: ParseIntError) -> Self {
        Self::ParseIntError(error)
    }
}

impl From<IoError> for H10LibError {
    fn from(error: IoError) -> Self {
        Self::IoError(error)
    }
}

impl Display for H10LibError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl Error for H10LibError {}

impl From<H10LibError> for StatusCode {
    fn from(value: H10LibError) -> Self {
        match value {
            H10LibError::VersionNotSupported
            | H10LibError::StatusCodeNotSupported
            | H10LibError::MethodNotSupported
            | H10LibError::RequestParser(_)
            | H10LibError::HeadersParser(_)
            | H10LibError::QueryStringParser(_)
            | H10LibError::ResponseParser(_)
            | H10LibError::InvalidInputData(_)
            | H10LibError::StrFromAscii(_)
            | H10LibError::Utf8Error => StatusCode::BadRequest,
            H10LibError::ParseFloatError(_)
            | H10LibError::SystemTimeError(_)
            | H10LibError::ParseIntError(_)
            | H10LibError::IoError(_)
            | H10LibError::Custom(_)
            | H10LibError::ClientError(_)
            | H10LibError::MpscSendError
            | H10LibError::FromUtf8Error => StatusCode::InternalServerError,
        }
    }
}