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
|
use oauth2::http::{header, Response, StatusCode};
use std::fmt::{Display, Formatter};
use std::io;
#[derive(Debug)]
#[allow(clippy::enum_variant_names)]
pub enum Error {
IoError(io::Error),
MissingToken,
InvalidToken,
ConfigurationError,
IntrospectionServerError,
AccessDenied,
}
impl Display for Error {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Error::IoError(e) => return write!(f, "IO Error: {}", e),
Error::AccessDenied => "Access denied",
Error::MissingToken => "Missing authorization token",
Error::InvalidToken => "Invalid access token",
Error::ConfigurationError => "OAuth2 client configuration error",
Error::IntrospectionServerError => {
"Introspection endpoint returned an error"
}
})
}
}
impl From<&Error> for StatusCode {
fn from(e: &Error) -> StatusCode {
match e {
Error::IoError(_) => StatusCode::INTERNAL_SERVER_ERROR,
Error::AccessDenied => StatusCode::FORBIDDEN,
Error::MissingToken => StatusCode::UNAUTHORIZED,
Error::InvalidToken => StatusCode::UNAUTHORIZED,
Error::ConfigurationError => StatusCode::INTERNAL_SERVER_ERROR,
Error::IntrospectionServerError => StatusCode::SERVICE_UNAVAILABLE,
}
}
}
impl From<Error> for Response<Option<String>> {
fn from(e: Error) -> Response<Option<String>> {
let resp = Response::builder().status(StatusCode::from(&e));
match e {
Error::IoError(_) => resp.body(None).unwrap(),
Error::AccessDenied => resp
.header(header::WWW_AUTHENTICATE, "Bearer")
.body(Some("{\"error\": \"insufficient_scope\"}".to_string()))
.unwrap(),
Error::MissingToken => resp.body(None).unwrap(),
Error::InvalidToken => resp
.header(header::WWW_AUTHENTICATE, "Bearer")
.body(Some("{\"error\": \"invalid_token\"}".to_string()))
.unwrap(),
Error::ConfigurationError => resp.body(None).unwrap(),
Error::IntrospectionServerError => resp.body(None).unwrap(),
}
}
}
impl From<io::Error> for Error {
fn from(e: io::Error) -> Self {
Error::IoError(e)
}
}
|
