volo-http 0.5.5

HTTP framework implementation of volo.
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use bytes::Bytes;
use http_body_util::{BodyExt, Full};
use motore::{layer::Layer, service::Service};

use crate::{body::Body, request::Request, response::Response};

pub struct RespBodyToFullLayer;
pub struct RespBodyToFullService<S>(S);

impl<S> Layer<S> for RespBodyToFullLayer {
    type Service = RespBodyToFullService<S>;

    fn layer(self, inner: S) -> Self::Service {
        RespBodyToFullService(inner)
    }
}

impl<Cx, ReqBody, RespBody, S> Service<Cx, Request<ReqBody>> for RespBodyToFullService<S>
where
    Cx: Send,
    S: Service<Cx, Request<ReqBody>, Response = Response<RespBody>> + Sync,
    ReqBody: Send,
    RespBody: http_body::Body + Send,
    RespBody::Data: Send,
    RespBody::Error: std::fmt::Debug + Send,
{
    type Response = Response<Full<Bytes>>;
    type Error = S::Error;

    async fn call(
        &self,
        cx: &mut Cx,
        req: Request<ReqBody>,
    ) -> Result<Self::Response, Self::Error> {
        let resp = self.0.call(cx, req).await?;
        let (parts, body) = resp.into_parts();
        let body = Full::new(BodyExt::collect(body).await.unwrap().to_bytes());
        let resp = Response::from_parts(parts, body);
        Ok(resp)
    }
}

// For request, and for testing, it should never implement `http_body::Body`
pub struct AutoBody;

pub struct AutoBodyLayer;
pub struct AutoBodyService<S>(S);

impl<S> Layer<S> for AutoBodyLayer {
    type Service = AutoBodyService<S>;

    fn layer(self, inner: S) -> Self::Service {
        AutoBodyService(inner)
    }
}

impl<Cx, RespBody, S> Service<Cx, Request<AutoBody>> for AutoBodyService<S>
where
    Cx: Send,
    S: Service<Cx, Request, Response = Response<RespBody>> + Sync,
    RespBody: Send,
{
    type Response = S::Response;
    type Error = S::Error;

    async fn call(
        &self,
        cx: &mut Cx,
        req: Request<AutoBody>,
    ) -> Result<Self::Response, Self::Error> {
        let (parts, _) = req.into_parts();
        let body = Body::from("Hello, World");
        let req = Request::from_parts(parts, body);
        self.0.call(cx, req).await
    }
}

// For request, and for testing, it should never implement `http_body::Body`
pub struct AutoFull;

pub struct AutoFullLayer;
pub struct AutoFullService<S>(S);

impl<S> Layer<S> for AutoFullLayer {
    type Service = AutoFullService<S>;

    fn layer(self, inner: S) -> Self::Service {
        AutoFullService(inner)
    }
}

impl<Cx, RespBody, S> Service<Cx, Request<AutoFull>> for AutoFullService<S>
where
    Cx: Send,
    S: Service<Cx, Request<Full<Bytes>>, Response = Response<RespBody>> + Sync,
    RespBody: Send,
{
    type Response = S::Response;
    type Error = S::Error;

    async fn call(
        &self,
        cx: &mut Cx,
        req: Request<AutoFull>,
    ) -> Result<Self::Response, Self::Error> {
        let (parts, _) = req.into_parts();
        let body = Full::new(Bytes::new());
        let req = Request::from_parts(parts, body);
        self.0.call(cx, req).await
    }
}

// For response, and for testing, it should never implement `http_body::Body`
pub struct Nothing;

pub struct DropBodyLayer;
pub struct DropBodyService<S>(S);

impl<S> Layer<S> for DropBodyLayer {
    type Service = DropBodyService<S>;

    fn layer(self, inner: S) -> Self::Service {
        DropBodyService(inner)
    }
}

impl<Cx, ReqBody, RespBody, S> Service<Cx, Request<ReqBody>> for DropBodyService<S>
where
    Cx: Send,
    S: Service<Cx, Request<ReqBody>, Response = Response<RespBody>> + Sync,
    ReqBody: Send,
    RespBody: Send,
{
    type Response = Response<Nothing>;
    type Error = S::Error;

    async fn call(
        &self,
        cx: &mut Cx,
        req: Request<ReqBody>,
    ) -> Result<Self::Response, Self::Error> {
        let resp = self.0.call(cx, req).await?;
        let (parts, _) = resp.into_parts();
        let body = Nothing;
        let resp = Response::from_parts(parts, body);
        Ok(resp)
    }
}