oxidized 0.1.0

A hyper-performant, modular, and asynchronous web framework for Rust, built on hyper and tokio. Featuring a Tower-inspired, Service-based architecture for maximum performance and composability.
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

use crate::{
    http_request::Request,
    middleware::Layer,
    service::Service,
    Error,
    Response,
    Result,
};
use std::future::Future;
use std::pin::Pin;

#[derive(Clone)]
pub struct LogLayer;

impl<S> Layer<S> for LogLayer {
    type Service = LogService<S>;

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

#[derive(Clone)]
pub struct LogService<S> {
    inner: S,
}

impl<S> Service<Request> for LogService<S>
where
    S: Service<Request, Response = Response, Error = Error> + Clone + Send + Sync + 'static,
    S::Future: Send,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = Pin<Box<dyn Future<Output = Result<Self::Response>> + Send>>;

    fn call(&self, req: Request) -> Self::Future {
        let inner = self.inner.clone();
        Box::pin(async move {
            let method = req.inner().method().clone();
            let uri = req.inner().uri().clone();

            println!("request: {} {}", method, uri);

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