Merge branch 'master' into feature/h1_pending_timer

CHANGES.md

@@ -4,11 +4,16 @@
 ### Fixed
 * Double ampersand in Logger format is escaped correctly. [#2067]
 
+### Changed
+* `CustomResponder` would return error as `HttpResponse` when `CustomResponder::with_header` failed instead of skipping.
+  (Only the first error is kept when multiple error occur) [#2093]
+
 ### Removed
 * The `client` mod was removed. Clients should now use `awc` directly.
   [871ca5e4](https://github.com/actix/actix-web/commit/871ca5e4ae2bdc22d1ea02701c2992fa8d04aed7)
 
 [#2067]: https://github.com/actix/actix-web/pull/2067
+[#2093]: https://github.com/actix/actix-web/pull/2093
 
 
 ## 4.0.0-beta.4 - 2021-03-09

Cargo.toml

@@ -105,7 +105,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.7"
 smallvec = "1.6"
-socket2 = "0.3.16"
+socket2 = "0.4.0"
 time = { version = "0.2.23", default-features = false, features = ["std"] }
 tls-openssl = { package = "openssl", version = "0.10.9", optional = true }
 tls-rustls = { package = "rustls", version = "0.19.0", optional = true }

actix-http-test/Cargo.toml

@@ -42,7 +42,7 @@ bytes = "1"
 futures-core = { version = "0.3.7", default-features = false }
 http = "0.2.2"
 log = "0.4"
-socket2 = "0.3"
+socket2 = "0.4"
 serde = "1.0"
 serde_json = "1.0"
 slab = "0.4"

actix-http-test/src/lib.rs

@@ -118,10 +118,10 @@ pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
 /// Get first available unused address
 pub fn unused_addr() -> net::SocketAddr {
     let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
-    let socket = Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap();
+    let socket = Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP)).unwrap();
     socket.bind(&addr.into()).unwrap();
     socket.set_reuse_address(true).unwrap();
-    let tcp = socket.into_tcp_listener();
+    let tcp = net::TcpListener::from(socket);
     tcp.local_addr().unwrap()
 }
 

src/handler.rs

@@ -28,17 +28,6 @@ where
     fn call(&self, param: T) -> R;
 }
 
-impl<F, R> Handler<(), R> for F
-where
-    F: Fn() -> R + Clone + 'static,
-    R: Future,
-    R::Output: Responder,
-{
-    fn call(&self, _: ()) -> R {
-        (self)()
-    }
-}
-
 #[doc(hidden)]
 /// Extract arguments from request, run factory function and make response.
 pub struct HandlerService<F, T, R>
@@ -177,30 +166,29 @@ where
 }
 
 /// FromRequest trait impl for tuples
-macro_rules! factory_tuple ({ $(($n:tt, $T:ident)),+} => {
+macro_rules! factory_tuple ({ $($param:ident)* } => {
-    impl<Func, $($T,)+ Res> Handler<($($T,)+), Res> for Func
+    impl<Func, $($param,)* Res> Handler<($($param,)*), Res> for Func
-    where Func: Fn($($T,)+) -> Res + Clone + 'static,
+    where Func: Fn($($param),*) -> Res + Clone + 'static,
           Res: Future,
           Res::Output: Responder,
     {
-        fn call(&self, param: ($($T,)+)) -> Res {
+        #[allow(non_snake_case)]
-            (self)($(param.$n,)+)
+        fn call(&self, ($($param,)*): ($($param,)*)) -> Res {
+            (self)($($param,)*)
         }
     }
 });
 
-#[rustfmt::skip]
+factory_tuple! {}
-mod m {
+factory_tuple! { A }
-    use super::*;
+factory_tuple! { A B }
-
+factory_tuple! { A B C }
-    factory_tuple!((0, A));
+factory_tuple! { A B C D }
-    factory_tuple!((0, A), (1, B));
+factory_tuple! { A B C D E }
-    factory_tuple!((0, A), (1, B), (2, C));
+factory_tuple! { A B C D E F }
-    factory_tuple!((0, A), (1, B), (2, C), (3, D));
+factory_tuple! { A B C D E F G }
-    factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E));
+factory_tuple! { A B C D E F G H }
-    factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F));
+factory_tuple! { A B C D E F G H I }
-    factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G));
+factory_tuple! { A B C D E F G H I J }
-    factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H));
+factory_tuple! { A B C D E F G H I J K }
-    factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I));
+factory_tuple! { A B C D E F G H I J K L }
-    factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I), (9, J));
-}

src/responder.rs

@@ -155,8 +155,7 @@ impl Responder for BytesMut {
 pub struct CustomResponder<T> {
     responder: T,
     status: Option<StatusCode>,
-    headers: Option<HeaderMap>,
+    headers: Result<HeaderMap, HttpError>,
-    error: Option<HttpError>,
 }
 
 impl<T: Responder> CustomResponder<T> {
@@ -164,8 +163,7 @@ impl<T: Responder> CustomResponder<T> {
         CustomResponder {
             responder,
             status: None,
-            headers: None,
+            headers: Ok(HeaderMap::new()),
-            error: None,
         }
     }
 
@@ -206,14 +204,12 @@ impl<T: Responder> CustomResponder<T> {
     where
         H: IntoHeaderPair,
     {
-        if self.headers.is_none() {
+        if let Ok(ref mut headers) = self.headers {
-            self.headers = Some(HeaderMap::new());
-        }
-
             match header.try_into_header_pair() {
-            Ok((key, value)) => self.headers.as_mut().unwrap().append(key, value),
+                Ok((key, value)) => headers.append(key, value),
-            Err(e) => self.error = Some(e.into()),
+                Err(e) => self.headers = Err(e.into()),
             };
+        }
 
         self
     }
@@ -221,17 +217,20 @@ impl<T: Responder> CustomResponder<T> {
 
 impl<T: Responder> Responder for CustomResponder<T> {
     fn respond_to(self, req: &HttpRequest) -> HttpResponse {
+        let headers = match self.headers {
+            Ok(headers) => headers,
+            Err(err) => return HttpResponse::from_error(Error::from(err)),
+        };
+
         let mut res = self.responder.respond_to(req);
 
         if let Some(status) = self.status {
             *res.status_mut() = status;
         }
 
-        if let Some(ref headers) = self.headers {
         for (k, v) in headers {
             // TODO: before v4, decide if this should be append instead
-                res.headers_mut().insert(k.clone(), v.clone());
+            res.headers_mut().insert(k, v);
-            }
         }
 
         res

src/server.rs

@@ -607,17 +607,14 @@ where
 
 fn create_tcp_listener(addr: net::SocketAddr, backlog: u32) -> io::Result<net::TcpListener> {
     use socket2::{Domain, Protocol, Socket, Type};
-    let domain = match addr {
+    let domain = Domain::for_address(addr);
-        net::SocketAddr::V4(_) => Domain::ipv4(),
+    let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP))?;
-        net::SocketAddr::V6(_) => Domain::ipv6(),
-    };
-    let socket = Socket::new(domain, Type::stream(), Some(Protocol::tcp()))?;
     socket.set_reuse_address(true)?;
     socket.bind(&addr.into())?;
     // clamp backlog to max u32 that fits in i32 range
     let backlog = cmp::min(backlog, i32::MAX as u32) as i32;
     socket.listen(backlog)?;
-    Ok(socket.into_tcp_listener())
+    Ok(net::TcpListener::from(socket))
 }
 
 #[cfg(feature = "openssl")]

src/test.rs

@@ -862,10 +862,10 @@ impl TestServerConfig {
 /// Get first available unused address
 pub fn unused_addr() -> net::SocketAddr {
     let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
-    let socket = Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap();
+    let socket = Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP)).unwrap();
     socket.bind(&addr.into()).unwrap();
     socket.set_reuse_address(true).unwrap();
-    let tcp = socket.into_tcp_listener();
+    let tcp = net::TcpListener::from(socket);
     tcp.local_addr().unwrap()
 }