响应结构调整

hubertshelley · hubertshelley · commit 12bffeeb31c9 · 2023-06-12T13:52:11.000+08:00
diff --git a/silent/src/core/response.rs b/silent/src/core/response.rs
@@ -1,24 +1,27 @@
 use crate::core::res_body::{full, ResBody};
+use crate::{HeaderMap, StatusCode};
 use bytes::Bytes;
 use headers::{Header, HeaderMapExt};
-use hyper::Response as HyperResponse;
 use std::fmt;
 use std::fmt::{Display, Formatter};
-use std::ops::{Deref, DerefMut};
 
 /// 响应体
 /// ```
 /// use silent::Response;
 /// let req = Response::empty();
 /// ```
 pub struct Response {
-    pub(crate) res: HyperResponse<ResBody>,
+    /// The HTTP status code.
+    pub(crate) status_code: StatusCode,
+    /// The HTTP headers.
+    pub(crate) headers: HeaderMap,
+    pub(crate) body: ResBody,
 }
 
 impl fmt::Debug for Response {
     #[inline]
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        writeln!(f, "HTTP/1.1 {}\n{:?}", self.status(), self.headers())
+        writeln!(f, "HTTP/1.1 {}\n{:?}", self.status_code, self.headers)
     }
 }
 
@@ -32,53 +35,58 @@ impl Display for Response {
 impl Response {
     /// 创建空响应体
     pub fn empty() -> Self {
-        Response::from(Bytes::new())
+        Self {
+            status_code: StatusCode::OK,
+            headers: HeaderMap::new(),
+            body: ResBody::None,
+        }
     }
     /// 设置响应状态
-    pub fn set_status(&mut self, status: hyper::StatusCode) {
-        *self.res.status_mut() = status;
+    pub fn set_status(&mut self, status: StatusCode) {
+        self.status_code = status;
     }
     /// 设置响应body
-    pub fn set_body(mut self, body: ResBody) -> Self {
-        *self.res.body_mut() = body;
-        self
+    pub fn set_body(&mut self, body: ResBody) {
+        self.body = body;
     }
     /// 设置响应header
     pub fn set_header(
         mut self,
         key: hyper::header::HeaderName,
         value: hyper::header::HeaderValue,
     ) -> Self {
-        self.headers_mut().insert(key, value);
+        self.headers.insert(key, value);
         self
     }
     /// 设置响应header
     pub fn set_typed_header<H>(&mut self, header: H)
     where
         H: Header,
     {
-        self.headers_mut().typed_insert(header);
+        self.headers.typed_insert(header);
     }
-}
 
-impl<T: Into<Bytes>> From<T> for Response {
-    fn from(chunk: T) -> Self {
-        Self {
-            res: HyperResponse::new(full(chunk)),
-        }
-    }
-}
+    #[inline]
+    pub(crate) fn into_hyper(self) -> hyper::Response<ResBody> {
+        let Self {
+            status_code,
+            headers,
+            body,
+        } = self;
 
-impl Deref for Response {
-    type Target = HyperResponse<ResBody>;
+        let mut res = hyper::Response::new(body);
+        *res.headers_mut() = headers;
+        // Default to a 404 if no response code was set
+        *res.status_mut() = status_code;
 
-    fn deref(&self) -> &Self::Target {
-        &self.res
+        res
     }
 }
 
-impl DerefMut for Response {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.res
+impl<T: Into<Bytes>> From<T> for Response {
+    fn from(chunk: T) -> Self {
+        let mut res = Response::empty();
+        res.set_body(full(chunk.into()));
+        res
     }
 }
diff --git a/silent/src/handler/handler_wrapper_response.rs b/silent/src/handler/handler_wrapper_response.rs
@@ -71,6 +71,6 @@ mod tests {
         assert!(handler_wrapper.match_req(&req).await);
         let res = handler_wrapper.call(req).await;
         assert!(res.is_ok());
-        assert_eq!(res.unwrap().status(), StatusCode::OK);
+        assert_eq!(res.unwrap().status_code, StatusCode::OK);
     }
 }
diff --git a/silent/src/handler/handler_wrapper_static.rs b/silent/src/handler/handler_wrapper_static.rs
@@ -98,9 +98,9 @@ mod tests {
         req.set_path_params("path".to_owned(), PathParam::Path("index.html".to_string()));
         let mut res = handler.call(req).await.unwrap();
         clean_static(path);
-        assert_eq!(res.status(), StatusCode::OK);
+        assert_eq!(res.status_code, StatusCode::OK);
         assert_eq!(
-            res.frame().await.unwrap().unwrap().data_ref().unwrap(),
+            res.body.frame().await.unwrap().unwrap().data_ref().unwrap(),
             &Bytes::from(CONTENT)
         );
     }
@@ -114,9 +114,9 @@ mod tests {
         req.set_path_params("path".to_owned(), PathParam::Path("".to_string()));
         let mut res = handler.call(req).await.unwrap();
         clean_static(path);
-        assert_eq!(res.status(), StatusCode::OK);
+        assert_eq!(res.status_code, StatusCode::OK);
         assert_eq!(
-            res.frame().await.unwrap().unwrap().data_ref().unwrap(),
+            res.body.frame().await.unwrap().unwrap().data_ref().unwrap(),
             &Bytes::from(CONTENT)
         );
     }
diff --git a/silent/src/route/handler_match.rs b/silent/src/route/handler_match.rs
@@ -236,6 +236,7 @@ mod tests {
                 .handle(req, "127.0.0.1:8000".parse().unwrap())
                 .await
                 .unwrap()
+                .body
                 .frame()
                 .await
                 .unwrap()
@@ -260,6 +261,7 @@ mod tests {
                 .handle(req, "127.0.0.1:8000".parse().unwrap())
                 .await
                 .unwrap()
+                .body
                 .frame()
                 .await
                 .unwrap()
diff --git a/silent/src/route/mod.rs b/silent/src/route/mod.rs
@@ -137,14 +137,13 @@ impl Routes {
                     }
                     match handler.call(req).await {
                         Ok(res) => {
-                            let (parts, body) = res.res.into_parts();
-                            let mut pre_res = pre_res.set_body(body);
-                            for (header_key, header_value) in parts.headers.into_iter() {
+                            for (header_key, header_value) in res.headers.clone().into_iter() {
                                 if let Some(key) = header_key {
                                     pre_res = pre_res.set_header(key, header_value);
                                 }
                             }
-                            *pre_res.status_mut() = parts.status;
+                            pre_res.status_code = res.status_code;
+                            pre_res.set_body(res.body);
                             for i in active_middlewares {
                                 if let Err(e) =
                                     route.middlewares[i].after_response(&mut pre_res).await
@@ -170,8 +169,8 @@ impl Routes {
                     method,
                     url,
                     http_version,
-                    res.status(),
-                    res.headers().get(header::CONTENT_LENGTH),
+                    res.status_code,
+                    res.headers.get(header::CONTENT_LENGTH),
                     req_time.num_nanoseconds().unwrap_or(0) as f64 / 1000000.0
                 );
                 Ok(res)
diff --git a/silent/src/service/hyper_service.rs b/silent/src/service/hyper_service.rs
@@ -0,0 +1,63 @@
+use crate::core::res_body::ResBody;
+use crate::route::Routes;
+use crate::{Request, Response};
+use hyper::body::Incoming;
+use hyper::service::Service as HyperService;
+use hyper::{Request as HyperRequest, Response as HyperResponse};
+use std::future::Future;
+use std::net::SocketAddr;
+use std::pin::Pin;
+
+#[doc(hidden)]
+#[derive(Clone)]
+pub struct HyperHandler {
+    pub(crate) remote_addr: SocketAddr,
+    pub(crate) routes: Routes,
+}
+
+impl HyperHandler {
+    #[inline]
+    pub fn new(remote_addr: SocketAddr, routes: Routes) -> Self {
+        Self {
+            remote_addr,
+            routes,
+        }
+    }
+    /// Handle [`Request`] and returns [`Response`].
+    #[inline]
+    pub fn handle(&self, req: Request) -> impl Future<Output = Response> {
+        let mut response = Response::empty();
+        let Self {
+            remote_addr,
+            routes,
+        } = self.clone();
+        async move {
+            match routes.clone().handle(req, remote_addr).await {
+                Ok(res) => {
+                    response.set_status(res.status_code);
+                    response.set_body(res.body);
+                }
+                Err((mes, code)) => {
+                    tracing::error!("Failed to handle request: {:?}", mes);
+                    response.set_body(mes.into());
+                    response.set_status(code);
+                }
+            }
+            response
+        }
+    }
+}
+
+impl HyperService<HyperRequest<Incoming>> for HyperHandler {
+    type Response = HyperResponse<ResBody>;
+    type Error = hyper::Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
+
+    #[inline]
+    fn call(&mut self, req: HyperRequest<Incoming>) -> Self::Future {
+        let (parts, body) = req.into_parts();
+        let req = HyperRequest::from_parts(parts, body.into()).into();
+        let response = self.handle(req);
+        Box::pin(async move { Ok(response.await.into_hyper()) })
+    }
+}
diff --git a/silent/src/service/mod.rs b/silent/src/service/mod.rs
@@ -1,3 +1,4 @@
+mod hyper_service;
 mod serve;
 
 use crate::conn::SilentConnection;
diff --git a/silent/src/service/serve.rs b/silent/src/service/serve.rs
@@ -1,10 +1,6 @@
 use crate::conn::SilentConnection;
-use crate::core::res_body::ResBody;
-use crate::core::response::Response;
 use crate::route::Routes;
-use hyper::body::Incoming;
-use hyper::service::service_fn;
-use hyper::{Request as HyperRequest, Response as HyperResponse};
+use crate::service::hyper_service::HyperHandler;
 use std::net::SocketAddr;
 use std::sync::Arc;
 use tokio::net::TcpStream;
@@ -23,29 +19,10 @@ impl Serve {
         stream: TcpStream,
         peer_addr: SocketAddr,
     ) -> Result<(), hyper::Error> {
-        let service = service_fn(move |req| self.handle(req, peer_addr));
         self.conn
             .http1
-            .serve_connection(stream, service)
+            .serve_connection(stream, HyperHandler::new(peer_addr, self.routes.clone()))
             .with_upgrades()
             .await
     }
-
-    async fn handle(
-        &self,
-        req: HyperRequest<Incoming>,
-        peer_addr: SocketAddr,
-    ) -> Result<HyperResponse<ResBody>, hyper::Error> {
-        let (parts, body) = req.into_parts();
-        let req = HyperRequest::from_parts(parts, body.into()).into();
-        match self.routes.handle(req, peer_addr).await {
-            Ok(res) => Ok(res.res),
-            Err((mes, code)) => {
-                tracing::error!("Failed to handle request: {:?}", mes);
-                let mut res = Response::from(mes);
-                res.set_status(code);
-                Ok(res.res)
-            }
-        }
-    }
 }
diff --git a/silent/src/ws/handler.rs b/silent/src/ws/handler.rs
@@ -30,9 +30,9 @@ pub fn websocket_handler(req: &Request) -> Result<Response> {
         });
     };
     res.set_status(StatusCode::SWITCHING_PROTOCOLS);
-    res.headers_mut().typed_insert(Connection::upgrade());
-    res.headers_mut().typed_insert(Upgrade::websocket());
-    res.headers_mut()
+    res.headers.typed_insert(Connection::upgrade());
+    res.headers.typed_insert(Upgrade::websocket());
+    res.headers
         .typed_insert(SecWebsocketAccept::from(sec_ws_key));
     Ok(res)
 }

Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,6 @@ mod tests {`
`71`	`71`	`assert!(handler_wrapper.match_req(&req).await);`
`72`	`72`	`let res = handler_wrapper.call(req).await;`
`73`	`73`	`assert!(res.is_ok());`
`74`		`- assert_eq!(res.unwrap().status(), StatusCode::OK);`
	`74`	`+ assert_eq!(res.unwrap().status_code, StatusCode::OK);`
`75`	`75`	`}`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+mod hyper_service;`
`1`	`2`	`mod serve;`
`2`	`3`
`3`	`4`	`use crate::conn::SilentConnection;`