simple_proxy 1.3.4

Simple proxy with middlewares, easy to customize, easy to use.
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

use hyper::{Body, Response, StatusCode};
use std::error::Error;

#[derive(Debug)]
pub struct MiddlewareError {
    pub description: String,
    pub body: String,
    pub status: StatusCode,
}

impl From<MiddlewareError> for Response<Body> {
    fn from(err: MiddlewareError) -> Response<Body> {
        err.to_json_response()
    }
}

impl MiddlewareError {
    pub fn new(description: String, body: Option<String>, status: StatusCode) -> MiddlewareError {
        let body = match body {
            Some(body) => body,
            None => {
                // Uncatched error
                let err = format!("Internal proxy server error: {}", &description);
                error!("{}", &err);
                err
            }
        };

        debug!("Middleware error: {}", &description);

        MiddlewareError {
            description,
            status,
            body,
        }
    }

    pub fn to_json_response(&self) -> Response<Body> {
        Response::builder()
            .header("Content-Type", "application/json")
            .status(self.status)
            .body(Body::from(format!("{{\"error\":\"{}\"}}", self.body)))
            .unwrap()
    }
}

impl<E> From<E> for MiddlewareError
where
    E: Error,
{
    fn from(err: E) -> MiddlewareError {
        MiddlewareError::new(err.to_string(), None, StatusCode::INTERNAL_SERVER_ERROR)
    }
}