routerify/service/
request_service.rs

1use crate::helpers;
2use crate::router::Router;
3use crate::types::{RequestContext, RequestInfo, RequestMeta};
4use crate::Error;
5use hyper::{body::HttpBody, service::Service, Request, Response};
6use std::future::Future;
7use std::net::SocketAddr;
8use std::pin::Pin;
9use std::sync::Arc;
10use std::task::{Context, Poll};
11
12pub struct RequestService<B, E> {
13    pub(crate) router: Arc<Router<B, E>>,
14    pub(crate) remote_addr: SocketAddr,
15}
16
17impl<B: HttpBody + Send + Sync + 'static, E: Into<Box<dyn std::error::Error + Send + Sync>> + 'static>
18    Service<Request<hyper::Body>> for RequestService<B, E>
19{
20    type Response = Response<B>;
21    type Error = crate::RouteError;
22    #[allow(clippy::type_complexity)]
23    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send + 'static>>;
24
25    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
26        Poll::Ready(Ok(()))
27    }
28
29    fn call(&mut self, mut req: Request<hyper::Body>) -> Self::Future {
30        let router = self.router.clone();
31        let remote_addr = self.remote_addr;
32
33        let fut = async move {
34            helpers::update_req_meta_in_extensions(req.extensions_mut(), RequestMeta::with_remote_addr(remote_addr));
35
36            let mut target_path = helpers::percent_decode_request_path(req.uri().path())
37                .map_err(|e| Error::new(format!("Couldn't percent decode request path: {}", e)))?;
38
39            if target_path.is_empty() || target_path.as_bytes()[target_path.len() - 1] != b'/' {
40                target_path.push('/');
41            }
42
43            let mut req_info = None;
44            let should_gen_req_info = router
45                .should_gen_req_info
46                .expect("The `should_gen_req_info` flag in Router is not initialized");
47
48            let context = RequestContext::new();
49
50            if should_gen_req_info {
51                req_info = Some(RequestInfo::new_from_req(&req, context.clone()));
52            }
53
54            req.extensions_mut().insert(context);
55
56            router.process(target_path.as_str(), req, req_info.clone()).await
57        };
58
59        Box::pin(fut)
60    }
61}
62
63#[derive(Debug)]
64pub struct RequestServiceBuilder<B, E> {
65    router: Arc<Router<B, E>>,
66}
67
68impl<B: HttpBody + Send + Sync + 'static, E: Into<Box<dyn std::error::Error + Send + Sync>> + 'static>
69    RequestServiceBuilder<B, E>
70{
71    pub fn new(mut router: Router<B, E>) -> crate::Result<Self> {
72        // router.init_keep_alive_middleware();
73
74        router.init_global_options_route();
75        router.init_default_404_route();
76
77        router.init_err_handler();
78
79        router.init_regex_set()?;
80        router.init_req_info_gen();
81        Ok(Self {
82            router: Arc::from(router),
83        })
84    }
85
86    pub fn build(&self, remote_addr: SocketAddr) -> RequestService<B, E> {
87        RequestService {
88            router: self.router.clone(),
89            remote_addr,
90        }
91    }
92}
93
94#[cfg(test)]
95mod tests {
96    use crate::{Error, RequestServiceBuilder, RouteError, Router};
97    use futures::future::poll_fn;
98    use http::Method;
99    use hyper::service::Service;
100    use hyper::{Body, Request, Response};
101    use std::net::SocketAddr;
102    use std::str::FromStr;
103    use std::task::Poll;
104
105    #[tokio::test]
106    async fn should_route_request() {
107        const RESPONSE_TEXT: &str = "Hello world!";
108        let remote_addr = SocketAddr::from_str("0.0.0.0:8080").unwrap();
109        let router: Router<hyper::body::Body, Error> = Router::builder()
110            .get("/", |_| async move { Ok(Response::new(Body::from(RESPONSE_TEXT))) })
111            .build()
112            .unwrap();
113        let req = Request::builder()
114            .method(Method::GET)
115            .uri("/")
116            .body(hyper::Body::empty())
117            .unwrap();
118        let builder = RequestServiceBuilder::new(router).unwrap();
119        let mut service = builder.build(remote_addr);
120        poll_fn(|ctx| -> Poll<Result<(), RouteError>> { service.poll_ready(ctx) })
121            .await
122            .expect("request service is not ready");
123        let resp: Response<hyper::body::Body> = service.call(req).await.unwrap();
124        let body = resp.into_body();
125        let body = String::from_utf8(hyper::body::to_bytes(body).await.unwrap().to_vec()).unwrap();
126        assert_eq!(RESPONSE_TEXT, body)
127    }
128}
routerify/service/request_service.rs

routerify/service/
request_service.rs
