rhodium 1.0.3

Hyper wrapper
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

use std::fmt;
use std::fmt::Debug;
use std::fmt::Display;
use std::fmt::Formatter;

pub type RhodResult<T> = Result<T, RhodError>;

// Represents an error while handling a request/response.
// Used to communication between Handlers.
// RhodErrors are thrown by users of the library in their implementations of handle_request/handle_response/serve functions

#[derive(Debug)]
pub enum RhodErrorLevel {
    Debug,
    Warning,
    Error,
    Critical,
}

#[derive(Debug)]
pub struct RhodError {
    msg: String,
    level: RhodErrorLevel,
}

impl RhodError {
    pub fn from_string(msg: String, level: RhodErrorLevel) -> RhodError {
        RhodError { msg, level }
    }

    pub fn from_str(msg: &str, level: RhodErrorLevel) -> RhodError {
        RhodError {
            msg: String::from(msg),
            level,
        }
    }

    pub fn log(&self) {
        match self.level {
            RhodErrorLevel::Warning => warn!("{}", self),
            RhodErrorLevel::Error => error!("{}", self),
            RhodErrorLevel::Critical => error!("{}", self),
            RhodErrorLevel::Debug => info!("{}", self),
        }
    }
}

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

impl std::error::Error for RhodError {}

//Represents server errors (Hyper errors, bad certificates, etc)
#[derive(Debug)]
pub enum RhodHyperError {
    HyperError(hyper::Error),
    ConfigError(String),
}

impl RhodHyperError {
    pub fn from_hyper_error_result(result: Result<(), hyper::Error>) -> Result<(), RhodHyperError> {
        match result {
            Ok(_) => Ok(()),
            Err(e) => Err(RhodHyperError::HyperError(e)),
        }
    }
}

impl Display for RhodHyperError {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match &self {
            RhodHyperError::HyperError(e) => write!(f, "HYPER ERROR: {}", e),
            RhodHyperError::ConfigError(e) => write!(f, "CONFIG ERROR: {}", e),
        }
    }
}

impl std::error::Error for RhodHyperError {}