predawn 0.9.0

Predawn is a Rust web framework like Spring Boot.
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

use predawn_core::{
    error::Error,
    location::Location,
    request::{BodyLimit, Request},
    response::Response,
    response_error::RequestBodyLimitError,
};

use super::Middleware;
use crate::handler::Handler;

pub struct RequestBodyLimit {
    limit: usize,
}

impl RequestBodyLimit {
    pub fn new(limit: usize) -> Self {
        Self { limit }
    }
}

impl<H: Handler> Middleware<H> for RequestBodyLimit {
    type Output = RequestBodyLimitHandler<H>;

    fn transform(self, input: H) -> Self::Output {
        RequestBodyLimitHandler {
            limit: self.limit,
            inner: input,
        }
    }
}

pub struct RequestBodyLimitHandler<H> {
    limit: usize,
    inner: H,
}

impl<H: Handler> Handler for RequestBodyLimitHandler<H> {
    async fn call(&self, mut req: Request) -> Result<Response, Error> {
        let content_length = req.head.content_length();

        let limit = match content_length {
            Some(len) => {
                if len > self.limit {
                    return Err(RequestBodyLimitError {
                        location: Location::caller(),
                        actual: Some(len),
                        expected: self.limit,
                    }
                    .into());
                } else {
                    len
                }
            }
            None => self.limit,
        };

        req.head.body_limit = BodyLimit(limit);

        self.inner.call(req).await
    }
}