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

//! The Hyper service module.
//!
//! It provides a [Hyper Service][`hyper::service::Service`] implementation intended to work with
//! the [Hyper Server Builder][`hyper::server::Builder`].
//!
//! The service allows to bind a [`Chain`][`super::Chain`] of middlewares.
//!
//! ## Example
//!
//! ```rust
//! use hyper::Server;
//! use hyper_middleware::{
//!     Body, Handler, Request, Response, Result, Service
//! };
//!
//! struct Application {}
//! impl Handler for Application {
//!     fn handle(&self, _req: &mut Request) -> Result<Response> {
//!         // Create a response and send it back to the middlewares chain
//!         Ok(Response::new(Body::from("¡Hola!")))
//!     }
//! }
//!
//! #[tokio::main(flavor = "multi_thread")]
//! async fn main() -> Result {
//!     let mut my_handler = Chain::new(Application {});
//!
//!     let my_service = Service::new(my_handler);
//!
//!     let addr = ([127, 0, 0, 1], 8787).into();
//!     let server = Server::bind(&addr).serve(my_service);
//!
//!     println!("Listening on http://{}", addr);
//!
//!     server.await?;
//!     Ok(())
//! }
//! ```

use hyper::service::Service as HyperService;
use std::convert::Infallible;
use std::future::{ready, Ready};
use std::task::{Context, Poll};

use self::handler_service::{HandlerService, HandlerServiceBuilder};
use crate::middleware::Handler;
use crate::remote_addr::RemoteAddr;

/// A [Hyper Service][`hyper::service::Service`] entry point which hosts a [`Handler`].
pub struct Service<H> {
    builder: HandlerServiceBuilder<H>,
}

impl<H> Service<H>
where
    H: Handler,
{
    /// Create a new Service instance which will be used when create a Hyper server.
    pub fn new(handler: H) -> Self {
        Self {
            builder: HandlerServiceBuilder::new(handler),
        }
    }
}

impl<H, T> HyperService<&T> for Service<H>
where
    H: Handler,
    T: RemoteAddr + Send + 'static,
{
    type Response = HandlerService<H>;
    type Error = Infallible;
    type Future = Ready<Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, conn: &T) -> Self::Future {
        ready(Ok(self.builder.build(conn.remote_addr())))
    }
}

mod handler_service {
    use std::future::Future;
    use std::net::SocketAddr;
    use std::pin::Pin;
    use std::sync::Arc;
    use std::task::{Context, Poll};

    use crate::middleware::Handler;
    use crate::service::HyperService;
    use crate::types::{Error, Request, Response, Result};

    pub struct HandlerService<H> {
        handler: Arc<H>,
        remote_addr: Option<SocketAddr>,
    }

    impl<H> HyperService<Request> for HandlerService<H>
    where
        H: Handler,
    {
        type Response = Response;
        type Error = Error;
        type Future = Pin<Box<dyn Future<Output = Result<Response>> + Send + 'static>>;

        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<()>> {
            Poll::Ready(Ok(()))
        }

        fn call(&mut self, mut req: Request) -> Self::Future {
            if let Some(remote_addr) = self.remote_addr {
                req.extensions_mut().insert(remote_addr);
            }
            let res = self.handler.handle(&mut req);
            Box::pin(async { res })
        }
    }

    pub struct HandlerServiceBuilder<H> {
        handler: Arc<H>,
    }

    impl<H> HandlerServiceBuilder<H>
    where
        H: Handler,
    {
        pub fn new(handler: H) -> Self {
            Self {
                handler: Arc::new(handler),
            }
        }

        pub fn build(&self, remote_addr: Option<SocketAddr>) -> HandlerService<H> {
            HandlerService {
                handler: self.handler.clone(),
                remote_addr,
            }
        }
    }
}