thruster 1.3.13

A middleware based http async web 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

use bytes::Bytes;
use http::header::{HeaderName, HeaderValue, SERVER};
use hyper::{Body, Response, StatusCode};
use std::str;

pub use crate::context::hyper_request::HyperRequest;
use crate::core::context::Context;

pub fn generate_context<S>(request: HyperRequest, _state: &S, _path: &str) -> FastHyperContext {
    FastHyperContext::new(request)
}

pub fn fast_generate_context<S>(
    request: HyperRequest,
    _state: &S,
    _path: &str,
) -> FastHyperContext {
    FastHyperContext {
        body: None,
        status: 200,
        hyper_request: Some(request),
        http_version: hyper::Version::HTTP_11,
    }
}

#[derive(Default)]
pub struct FastHyperContext {
    pub body: Option<Body>,
    pub status: u16,
    pub hyper_request: Option<HyperRequest>,
    pub http_version: hyper::Version,
}

impl Clone for FastHyperContext {
    fn clone(&self) -> Self {
        warn!("You should not be calling this method -- it just returns a default context.");
        FastHyperContext::default()
    }
}

const SERVER_HEADER_NAME: HeaderName = SERVER;
impl FastHyperContext {
    pub fn new(req: HyperRequest) -> FastHyperContext {
        FastHyperContext {
            body: None,
            status: 200,
            hyper_request: Some(req),
            http_version: hyper::Version::HTTP_11,
        }
    }
}

impl Context for FastHyperContext {
    type Response = Response<Body>;

    fn get_response(self) -> Self::Response {
        let mut response = Response::new(self.body.unwrap());

        *response.status_mut() = StatusCode::from_u16(self.status).unwrap();
        *response.version_mut() = self.http_version;
        *response.headers_mut() = self.hyper_request.unwrap().request.into_parts().0.headers;
        response
            .headers_mut()
            .insert(SERVER_HEADER_NAME, HeaderValue::from_static("thruster"));

        response
    }

    fn set_body(&mut self, body: Vec<u8>) {
        self.body = Some(Body::from(body));
    }

    fn set_body_bytes(&mut self, bytes: Bytes) {
        self.body = Some(Body::from(bytes));
    }

    fn route(&self) -> &str {
        let uri = self.hyper_request.as_ref().unwrap().request.uri();

        match uri.path_and_query() {
            Some(val) => val.as_str(),
            None => uri.path(),
        }
    }

    fn set(&mut self, key: &str, value: &str) {
        self.hyper_request
            .as_mut()
            .unwrap()
            .request
            .headers_mut()
            .insert(
                HeaderName::from_bytes(key.as_bytes()).unwrap(),
                HeaderValue::from_str(value).unwrap(),
            );
    }

    fn remove(&mut self, key: &str) {
        self.hyper_request
            .as_mut()
            .unwrap()
            .request
            .headers_mut()
            .remove(key);
    }

    fn status(&mut self, code: u16) {
        self.status = code;
    }
}