introduce response and builder types to web

actix · Apr 8, 2021 · a811494 · a811494
1 parent d1e5025
commit a811494
Show file tree

Hide file tree

Showing 24 changed files with 861 additions and 326 deletions.
diff --git a/actix-files/src/error.rs b/actix-files/src/error.rs
@@ -1,4 +1,4 @@
-use actix_web::{http::StatusCode, HttpResponse, ResponseError};
+use actix_web::{http::StatusCode, ResponseError};
 use derive_more::Display;
 
 /// Errors which can occur when serving static files.
@@ -16,8 +16,8 @@ pub enum FilesError {
 
 /// Return `NotFound` for `FilesError`
 impl ResponseError for FilesError {
-    fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::NOT_FOUND)
+    fn status_code(&self) -> StatusCode {
+        StatusCode::NOT_FOUND
     }
 }
 

diff --git a/actix-http/examples/ws.rs b/actix-http/examples/ws.rs
@@ -11,7 +11,7 @@ use std::{
 };
 
 use actix_codec::Encoder;
-use actix_http::{error::Error, ws, HttpService, Request, Response};
+use actix_http::{body::BodyStream, error::Error, ws, HttpService, Request, Response};
 use actix_rt::time::{interval, Interval};
 use actix_server::Server;
 use bytes::{Bytes, BytesMut};
@@ -34,14 +34,14 @@ async fn main() -> io::Result<()> {
         .await
 }
 
-async fn handler(req: Request) -> Result<Response, Error> {
+async fn handler(req: Request) -> Result<Response<BodyStream<Heartbeat>>, Error> {
     log::info!("handshaking");
-    let mut res = ws::handshake(req.head())?;
+    let res = ws::handshake(req.head())?;
 
     // handshake will always fail under HTTP/2
 
     log::info!("responding");
-    Ok(res.streaming(Heartbeat::new(ws::Codec::new())))
+    Ok(res.set_body(BodyStream::new(Heartbeat::new(ws::Codec::new()))))
 }
 
 struct Heartbeat {

diff --git a/actix-http/src/error.rs b/actix-http/src/error.rs
@@ -16,7 +16,7 @@ use serde_urlencoded::ser::Error as FormError;
 
 use crate::body::Body;
 use crate::helpers::Writer;
-use crate::response::{Response, ResponseBuilder};
+use crate::response::Response;
 
 /// A specialized [`std::result::Result`]
 /// for actix web operations
@@ -135,12 +135,12 @@ impl From<Response> for Error {
     }
 }
 
-/// Convert ResponseBuilder to a Error
-impl From<ResponseBuilder> for Error {
-    fn from(mut res: ResponseBuilder) -> Error {
-        InternalError::from_response("", res.finish()).into()
-    }
-}
+// /// Convert ResponseBuilder to a Error
+// impl From<ResponseBuilder> for Error {
+//     fn from(mut res: ResponseBuilder) -> Error {
+//         InternalError::from_response("", res.finish()).into()
+//     }
+// }
 
 #[derive(Debug, Display)]
 #[display(fmt = "UnknownError")]

diff --git a/actix-http/src/h1/dispatcher.rs b/actix-http/src/h1/dispatcher.rs
@@ -340,13 +340,15 @@ where
                 StateProj::ServiceCall(fut) => match fut.poll(cx) {
                     // service call resolved. send response.
                     Poll::Ready(Ok(res)) => {
+                        eprintln!("dispatcher ok!");
                         let (res, body) = res.into().replace_body(());
                         self.as_mut().send_response(res, body)?;
                     }
 
                     // send service call error as response
                     Poll::Ready(Err(err)) => {
-                        let res: Response = err.into().into();
+                        eprintln!("dispatcher err");
+                        let res = Response::from_error(err.into());
                         let (res, body) = res.replace_body(());
                         self.as_mut().send_response(res, body.into_body())?;
                     }

diff --git a/actix-http/src/message.rs b/actix-http/src/message.rs
@@ -345,8 +345,8 @@ impl ResponseHead {
 }
 
 pub struct Message<T: Head> {
-    // Rc here should not be cloned by anyone.
-    // It's used to reuse allocation of T and no shared ownership is allowed.
+    /// Rc here should not be cloned by anyone.
+    /// It's used to reuse allocation of T and no shared ownership is allowed.
     head: Rc<T>,
 }
 

diff --git a/actix-http/src/request.rs b/actix-http/src/request.rs
@@ -9,7 +9,6 @@ use std::{
 use cookie::{Cookie, ParseError as CookieParseError};
 use http::{header, Method, Uri, Version};
 
-
 use crate::{
     extensions::Extensions,
     header::HeaderMap,

diff --git a/actix-http/src/response.rs b/actix-http/src/response.rs
@@ -39,18 +39,6 @@ pub struct Response<B = Body> {
 }
 
 impl Response<Body> {
-    /// Create HTTP response builder with specific status.
-    #[inline]
-    pub fn build(status: StatusCode) -> ResponseBuilder {
-        ResponseBuilder::new(status)
-    }
-
-    /// Create HTTP response builder
-    #[inline]
-    pub fn build_from<T: Into<ResponseBuilder>>(source: T) -> ResponseBuilder {
-        source.into()
-    }
-
     /// Constructs a response
     #[inline]
     pub fn new(status: StatusCode) -> Response {
@@ -139,54 +127,6 @@ impl<B> Response<B> {
         &mut self.head.headers
     }
 
-    /// Get an iterator for the cookies set by this response
-    #[cfg(feature = "cookies")]
-    #[inline]
-    pub fn cookies(&self) -> CookieIter<'_> {
-        CookieIter {
-            iter: self.head.headers.get_all(header::SET_COOKIE),
-        }
-    }
-
-    /// Add a cookie to this response
-    #[cfg(feature = "cookies")]
-    #[inline]
-    pub fn add_cookie(&mut self, cookie: &Cookie<'_>) -> Result<(), HttpError> {
-        let h = &mut self.head.headers;
-        HeaderValue::from_str(&cookie.to_string())
-            .map(|c| {
-                h.append(header::SET_COOKIE, c);
-            })
-            .map_err(|e| e.into())
-    }
-
-    /// Remove all cookies with the given name from this response. Returns
-    /// the number of cookies removed.
-    #[cfg(feature = "cookies")]
-    #[inline]
-    pub fn del_cookie(&mut self, name: &str) -> usize {
-        let h = &mut self.head.headers;
-        let vals: Vec<HeaderValue> = h
-            .get_all(header::SET_COOKIE)
-            .map(|v| v.to_owned())
-            .collect();
-        h.remove(header::SET_COOKIE);
-
-        let mut count: usize = 0;
-        for v in vals {
-            if let Ok(s) = v.to_str() {
-                if let Ok(c) = Cookie::parse_encoded(s) {
-                    if c.name() == name {
-                        count += 1;
-                        continue;
-                    }
-                }
-            }
-            h.append(header::SET_COOKIE, v);
-        }
-        count
-    }
-
     /// Connection upgrade status
     #[inline]
     pub fn upgrade(&self) -> bool {
@@ -732,7 +672,7 @@ impl<B> From<Response<B>> for ResponseBuilder {
             head: Some(res.head),
             err: None,
             #[cfg(feature = "cookies")]
-            cookies: None
+            cookies: None,
         }
     }
 }
@@ -876,7 +816,7 @@ mod tests {
 
     #[test]
     fn test_upgrade() {
-        let resp = Response::build(StatusCode::OK)
+        let resp = ResponseBuilder::new(StatusCode::OK)
             .upgrade("websocket")
             .finish();
         assert!(resp.upgrade());
@@ -888,13 +828,13 @@ mod tests {
 
     #[test]
     fn test_force_close() {
-        let resp = Response::build(StatusCode::OK).force_close().finish();
+        let resp = ResponseBuilder::new(StatusCode::OK).force_close().finish();
         assert!(!resp.keep_alive())
     }
 
     #[test]
     fn test_content_type() {
-        let resp = Response::build(StatusCode::OK)
+        let resp = ResponseBuilder::new(StatusCode::OK)
             .content_type("text/plain")
             .body(Body::Empty);
         assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "text/plain")
@@ -915,7 +855,7 @@ mod tests {
 
     #[test]
     fn test_json_ct() {
-        let resp = Response::build(StatusCode::OK)
+        let resp = ResponseBuilder::new(StatusCode::OK)
             .insert_header((CONTENT_TYPE, "text/json"))
             .json(&vec!["v1", "v2", "v3"]);
         let ct = resp.headers().get(CONTENT_TYPE).unwrap();
@@ -927,7 +867,7 @@ mod tests {
     fn test_serde_json_in_body() {
         use serde_json::json;
         let resp =
-            Response::build(StatusCode::OK).body(json!({"test-key":"test-value"}));
+            ResponseBuilder::new(StatusCode::OK).body(json!({"test-key":"test-value"}));
         assert_eq!(resp.body().get_ref(), br#"{"test-key":"test-value"}"#);
     }
 

diff --git a/actix-http/src/ws/mod.rs b/actix-http/src/ws/mod.rs
@@ -11,8 +11,8 @@ use http::{header, Method, StatusCode};
 use crate::{
     error::ResponseError,
     header::HeaderValue,
-    message::RequestHead,
-    response::{Response, ResponseBuilder},
+    message::{ConnectionType, RequestHead},
+    response::Response,
 };
 
 mod codec;
@@ -131,7 +131,7 @@ impl ResponseError for HandshakeError {
 }
 
 /// Verify WebSocket handshake request and create handshake response.
-pub fn handshake(req: &RequestHead) -> Result<ResponseBuilder, HandshakeError> {
+pub fn handshake(req: &RequestHead) -> Result<Response, HandshakeError> {
     verify_handshake(req)?;
     Ok(handshake_response(req))
 }
@@ -187,21 +187,39 @@ pub fn verify_handshake(req: &RequestHead) -> Result<(), HandshakeError> {
 /// Create WebSocket handshake response.
 ///
 /// This function returns handshake `Response`, ready to send to peer.
-pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
+pub fn handshake_response(req: &RequestHead) -> Response {
     let key = {
         let key = req.headers().get(header::SEC_WEBSOCKET_KEY).unwrap();
         proto::hash_key(key.as_ref())
     };
 
-    Response::build(StatusCode::SWITCHING_PROTOCOLS)
-        .upgrade("websocket")
-        .insert_header((header::TRANSFER_ENCODING, "chunked"))
-        .insert_header((
-            header::SEC_WEBSOCKET_ACCEPT,
-            // key is known to be header value safe ascii
-            HeaderValue::from_bytes(&key).unwrap(),
-        ))
-        .take()
+    let mut res = Response::new(StatusCode::SWITCHING_PROTOCOLS);
+
+    res.head_mut().set_connection_type(ConnectionType::Upgrade);
+    let headers = res.headers_mut();
+
+    headers.insert(header::UPGRADE, HeaderValue::from_static("websocket"));
+
+    headers.insert(
+        header::TRANSFER_ENCODING,
+        HeaderValue::from_static("chunked"),
+    );
+    headers.insert(
+        header::SEC_WEBSOCKET_ACCEPT,
+        // key is known to be header value safe ascii
+        HeaderValue::from_bytes(&key).unwrap(),
+    );
+
+    res
+
+    // Response::build(StatusCode::SWITCHING_PROTOCOLS)
+    //     .upgrade("websocket")
+    //     .insert_header((header::TRANSFER_ENCODING, "chunked"))
+    //     .insert_header((
+    //         header::SEC_WEBSOCKET_ACCEPT,
+    //         // key is known to be header value safe ascii
+    //         HeaderValue::from_bytes(&key).unwrap(),
+    //     ))
 }
 
 #[cfg(test)]
@@ -316,7 +334,7 @@ mod tests {
             .finish();
         assert_eq!(
             StatusCode::SWITCHING_PROTOCOLS,
-            handshake_response(req.head()).finish().status()
+            handshake_response(req.head()).status()
         );
     }
 

diff --git a/actix-http/tests/test_ws.rs b/actix-http/tests/test_ws.rs
@@ -52,7 +52,7 @@ where
 
     fn call(&self, (req, mut framed): (Request, Framed<T, h1::Codec>)) -> Self::Future {
         let fut = async move {
-            let res = ws::handshake(req.head()).unwrap().message_body(());
+            let res = ws::handshake(req.head()).unwrap().set_body(());
 
             framed
                 .send((res, body::BodySize::None).into())

diff --git a/actix-multipart/src/error.rs b/actix-multipart/src/error.rs
@@ -45,11 +45,10 @@ impl ResponseError for MultipartError {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use actix_web::HttpResponse;
 
     #[test]
     fn test_multipart_error() {
-        let resp: HttpResponse = MultipartError::Boundary.error_response();
+        let resp = MultipartError::Boundary.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
     }
 }
diff --git a/actix-test/src/lib.rs b/actix-test/src/lib.rs
@@ -37,12 +37,12 @@ use actix_codec::{AsyncRead, AsyncWrite, Framed};
 pub use actix_http::test::TestBuffer;
 use actix_http::{
     http::{HeaderMap, Method},
-    ws, HttpService, Request,
+    ws, HttpService, Request, Response,
 };
 use actix_service::{map_config, IntoServiceFactory, ServiceFactory};
 use actix_web::{
     dev::{AppConfig, MessageBody, Server, Service},
-    rt, web, Error, HttpResponse,
+    rt, web, Error,
 };
 use awc::{error::PayloadError, Client, ClientRequest, ClientResponse, Connector};
 use futures_core::Stream;
@@ -83,7 +83,7 @@ where
     S: ServiceFactory<Request, Config = AppConfig> + 'static,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
-    S::Response: Into<HttpResponse<B>> + 'static,
+    S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
@@ -122,7 +122,7 @@ where
     S: ServiceFactory<Request, Config = AppConfig> + 'static,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
-    S::Response: Into<HttpResponse<B>> + 'static,
+    S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {

diff --git a/actix-web-actors/src/ws.rs b/actix-web-actors/src/ws.rs
@@ -22,9 +22,9 @@ use actix_http::{
     http::HeaderValue,
     ws::{hash_key, Codec},
 };
-use actix_web::HttpResponseBuilder;
 use actix_web::error::{Error, PayloadError};
 use actix_web::http::{header, Method, StatusCode};
+use actix_web::HttpResponseBuilder;
 use actix_web::{HttpRequest, HttpResponse};
 use bytes::{Bytes, BytesMut};
 use bytestring::ByteString;