sova-core 0.1.5

Core HTTP primitives for Sova (App, Router, Request, Response)
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

use crate::app::AppInner;
use crate::error::Result;
use crate::request::{parse_query, Request};
use crate::response::{Response, ResponseBody};
use crate::state::Extensions;
use crate::upgrade::PendingUpgrade;
use bytes::Bytes;
use http::HeaderValue;
use http_body_util::{BodyExt, Full};
use hyper::body::Incoming;
use hyper::upgrade::OnUpgrade as HyperOnUpgrade;
use hyper::{Request as HyperRequest, Response as HyperResponse};
use std::convert::Infallible;
use std::net::SocketAddr;

use crate::server::forwarded::forwarded_addr;
use crate::server::ClientAddr;

pub(super) async fn to_sova_request(
    req: HyperRequest<Incoming>,
    app: &AppInner,
    peer: SocketAddr,
) -> Result<Request> {
    use crate::request::{resolve_scheme_host, ReqBody};

    let max_body = app.max_body_size;
    let state = app.state();
    let trust_proxy = app.trust_proxy;

    let (mut parts, incoming) = req.into_parts();
    let on_upgrade = parts.extensions.remove::<HyperOnUpgrade>();

    let method = parts.method;
    let uri = parts.uri;
    let path = uri.path().to_string();
    let raw_query = uri.query().unwrap_or("").to_string();
    let query = if raw_query.is_empty() {
        Default::default()
    } else {
        parse_query(&raw_query)
    };
    let headers = parts.headers;

    // Content-Length is checked after route match via `body_limit` / [`MaxBody`].

    let (scheme, host) = resolve_scheme_host(&headers, uri.scheme_str(), trust_proxy);

    let stream = incoming
        .map_err(|e| -> crate::response::BoxError { Box::new(e) })
        .boxed();

    let client = if trust_proxy {
        forwarded_addr(&headers).unwrap_or(peer)
    } else {
        peer
    };

    let mut extensions = Extensions::new();
    extensions.insert(ClientAddr(client));
    if let Some(on_upgrade) = on_upgrade {
        extensions.insert(PendingUpgrade {
            on_upgrade,
            budget: app.max_upgraded.clone(),
        });
    }

    Ok(Request {
        method,
        path,
        headers,
        params: Default::default(),
        query,
        scheme,
        host,
        raw_query,
        body: ReqBody::Stream(stream),
        body_limit: max_body,
        state,
        extensions,
    })
}

pub(super) fn to_hyper_response(
    res: Response,
    hsts: bool,
    alt_svc: Option<&str>,
) -> HyperResponse<ResponseBody> {
    let (status, mut headers, body) = res.into_parts();
    if hsts {
        headers.insert(
            http::header::STRICT_TRANSPORT_SECURITY,
            HeaderValue::from_static("max-age=31536000"),
        );
    }
    if let Some(alt_svc) = alt_svc {
        if let Ok(v) = HeaderValue::from_str(alt_svc) {
            headers.insert(http::header::HeaderName::from_static("alt-svc"), v);
        }
    }
    let mut builder = HyperResponse::builder().status(status);
    *builder.headers_mut().expect("builder") = headers;
    builder.body(body).unwrap_or_else(|_| {
        HyperResponse::builder()
            .status(500)
            .body(
                Full::new(Bytes::from_static(b"internal error"))
                    .map_err(|_: Infallible| unreachable!())
                    .boxed(),
            )
            .expect("fallback")
    })
}