rastapi 0.1.0

REST API library inspired by python FastAPI/Flask
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

use std::{borrow::Cow, fmt};
#[derive(Debug)]
pub enum ApiError<'a> {
    ClientNotFound(Option<Cow<'a, str>>),
    RequestReadError(Option<Cow<'a, str>>),
    RequestDataNotUTF8(Option<Cow<'a, str>>),
    RequestNotHttp(Option<Cow<'a, str>>),
    InvalidHeader(Option<Cow<'a, str>>),
    ContentNotSupported(Option<Cow<'a, str>>),
    CannotWriteDataToDisk(Option<Cow<'a, str>>),
    RequestBodyNotRead(Option<Cow<'a, str>>),
    InvalidContentLength(Option<Cow<'a, str>>),
    ContentTypeRequired(Option<Cow<'a, str>>),
    MethodNotAllowed(Option<Cow<'a, str>>),
    MethodNotSupported(Option<Cow<'a, str>>),
    ResourceNotFound(Option<Cow<'a, str>>),
    PayloadTooLarge(Option<Cow<'a, str>>),
    RequestTimedout(Option<Cow<'a, str>>),
    ClientDisconnected(Option<Cow<'a, str>>),
}
impl<'a> fmt::Display for ApiError<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ApiError::ClientNotFound(msg) => {
                if let Some(_msg) = msg {
                    writeln!(f, "{}", _msg)
                } else {
                    writeln!(f, "Client Socket Adress not found in tcp stream.")
                }
            }
            ApiError::RequestDataNotUTF8(msg) => {
                if let Some(_msg) = msg {
                    writeln!(f, "{}", _msg)
                } else {
                    writeln!(f, "Request string data is not UTF-8 complient")
                }
            }
            ApiError::RequestReadError(msg) => {
                if let Some(_msg) = msg {
                    writeln!(f, "{}", _msg)
                } else {
                    writeln!(f, "Couldn't read request.")
                }
            }
            ApiError::RequestNotHttp(msg) => {
                if let Some(_msg) = msg {
                    writeln!(f, "{}", _msg)
                } else {
                    writeln!(f, "Request protocol is not HTTP/1.x")
                }
            }
            ApiError::InvalidHeader(msg) => {
                if let Some(_msg) = msg {
                    writeln!(f, "{}", _msg)
                } else {
                    writeln!(f, "Invalid header value.")
                }
            }
            ApiError::ContentNotSupported(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Content-Type not supported.")
                }
            }
            ApiError::CannotWriteDataToDisk(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Cannot Write data to a file on disk.")
                }
            }
            ApiError::RequestBodyNotRead(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Cannot Read body completly.")
                }
            }
            ApiError::InvalidContentLength(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Invalid content length header.")
                }
            }
            Self::ContentTypeRequired(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Content type required.")
                }
            }
            Self::MethodNotAllowed(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Method Not allowed.")
                }
            }
            Self::ResourceNotFound(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Resource Not found.")
                }
            }
            Self::MethodNotSupported(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Method Not supported.")
                }
            }
            Self::PayloadTooLarge(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Payload Too large.")
                }
            }
            Self::RequestTimedout(msg) => {
                if let Some(err_msg) = msg {
                    write!(f, "{}", err_msg)
                } else {
                    write!(f, "Request read time out reached.")
                }
            }
            Self::ClientDisconnected(msg) => {
                if let Some(_msg) = msg {
                    writeln!(f, "{}", _msg)
                } else {
                    writeln!(f, "Client disconnected prematurely.")
                }
            }
        }
    }
}