Merge branch 'master' into handler-macro

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-files/src/service.rs

@@ -1,4 +1,4 @@
-use std::{fmt, io, path::PathBuf, rc::Rc, task::Poll};
+use std::{fmt, io, path::PathBuf, rc::Rc};
 
 use actix_service::Service;
 use actix_web::{

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()
 }
 

actix-http/src/client/connection.rs

@@ -325,7 +325,7 @@ where
     }
 }
 
-const H2_UNREACHABLE_WRITE: &'static str = "H2Connection can not impl AsyncWrite trait";
+const H2_UNREACHABLE_WRITE: &str = "H2Connection can not impl AsyncWrite trait";
 
 impl<A, B> AsyncWrite for Connection<A, B>
 where

actix-http/src/config.rs

@@ -126,9 +126,7 @@ impl ServiceConfig {
     pub fn client_timer(&self) -> Option<Sleep> {
         let delay_time = self.0.client_timeout;
         if delay_time != 0 {
-            Some(sleep_until(
+            Some(sleep_until(self.now() + Duration::from_millis(delay_time)))
-                self.0.date_service.now() + Duration::from_millis(delay_time),
-            ))
         } else {
             None
         }
@@ -138,7 +136,7 @@ impl ServiceConfig {
     pub fn client_timer_expire(&self) -> Option<Instant> {
         let delay = self.0.client_timeout;
         if delay != 0 {
-            Some(self.0.date_service.now() + Duration::from_millis(delay))
+            Some(self.now() + Duration::from_millis(delay))
         } else {
             None
         }
@@ -148,7 +146,7 @@ impl ServiceConfig {
     pub fn client_disconnect_timer(&self) -> Option<Instant> {
         let delay = self.0.client_disconnect;
         if delay != 0 {
-            Some(self.0.date_service.now() + Duration::from_millis(delay))
+            Some(self.now() + Duration::from_millis(delay))
         } else {
             None
         }
@@ -157,20 +155,12 @@ impl ServiceConfig {
     #[inline]
     /// Return keep-alive timer delay is configured.
     pub fn keep_alive_timer(&self) -> Option<Sleep> {
-        if let Some(ka) = self.0.keep_alive {
+        self.keep_alive().map(|ka| sleep_until(self.now() + ka))
-            Some(sleep_until(self.0.date_service.now() + ka))
-        } else {
-            None
-        }
     }
 
     /// Keep-alive expire time
     pub fn keep_alive_expire(&self) -> Option<Instant> {
-        if let Some(ka) = self.0.keep_alive {
+        self.keep_alive().map(|ka| self.now() + ka)
-            Some(self.0.date_service.now() + ka)
-        } else {
-            None
-        }
     }
 
     #[inline]

actix-http/src/header/shared/entity.rs

@@ -127,9 +127,8 @@ impl Display for EntityTag {
 impl FromStr for EntityTag {
     type Err = crate::error::ParseError;
 
-    fn from_str(s: &str) -> Result<EntityTag, crate::error::ParseError> {
+    fn from_str(slice: &str) -> Result<EntityTag, crate::error::ParseError> {
-        let length: usize = s.len();
+        let length = slice.len();
-        let slice = &s[..];
         // Early exits if it doesn't terminate in a DQUOTE.
         if !slice.ends_with('"') || slice.len() < 2 {
             return Err(crate::error::ParseError::Header);

actix-http/src/header/shared/extended.rs

@@ -88,9 +88,9 @@ pub fn parse_extended_value(
     };
 
     Ok(ExtendedValue {
-        value,
         charset,
         language_tag,
+        value,
     })
 }
 

src/config.rs

@@ -113,7 +113,7 @@ pub struct AppConfig {
 
 impl AppConfig {
     pub(crate) fn new(secure: bool, addr: SocketAddr, host: String) -> Self {
-        AppConfig { secure, addr, host }
+        AppConfig { secure, host, addr }
     }
 
     /// Server host name.

src/extract.rs

@@ -302,13 +302,13 @@ macro_rules! tuple_from_req ({$fut_type:ident, $(($n:tt, $T:ident)),+} => {
                     }
                 )+
 
-                    if ready {
+                if ready {
-                        Poll::Ready(Ok(
+                    Poll::Ready(Ok(
-                            ($(this.items.$n.take().unwrap(),)+)
+                        ($(this.items.$n.take().unwrap(),)+)
-                        ))
+                    ))
-                    } else {
+                } else {
-                        Poll::Pending
+                    Poll::Pending
-                    }
+                }
             }
         }
     }
@@ -318,16 +318,16 @@ macro_rules! tuple_from_req ({$fut_type:ident, $(($n:tt, $T:ident)),+} => {
 mod m {
     use super::*;
 
-tuple_from_req!(TupleFromRequest1, (0, A));
+    tuple_from_req!(TupleFromRequest1, (0, A));
-tuple_from_req!(TupleFromRequest2, (0, A), (1, B));
+    tuple_from_req!(TupleFromRequest2, (0, A), (1, B));
-tuple_from_req!(TupleFromRequest3, (0, A), (1, B), (2, C));
+    tuple_from_req!(TupleFromRequest3, (0, A), (1, B), (2, C));
-tuple_from_req!(TupleFromRequest4, (0, A), (1, B), (2, C), (3, D));
+    tuple_from_req!(TupleFromRequest4, (0, A), (1, B), (2, C), (3, D));
-tuple_from_req!(TupleFromRequest5, (0, A), (1, B), (2, C), (3, D), (4, E));
+    tuple_from_req!(TupleFromRequest5, (0, A), (1, B), (2, C), (3, D), (4, E));
-tuple_from_req!(TupleFromRequest6, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F));
+    tuple_from_req!(TupleFromRequest6, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F));
-tuple_from_req!(TupleFromRequest7, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G));
+    tuple_from_req!(TupleFromRequest7, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G));
-tuple_from_req!(TupleFromRequest8, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H));
+    tuple_from_req!(TupleFromRequest8, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H));
-tuple_from_req!(TupleFromRequest9, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I));
+    tuple_from_req!(TupleFromRequest9, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I));
-tuple_from_req!(TupleFromRequest10, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I), (9, J));
+    tuple_from_req!(TupleFromRequest10, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I), (9, J));
 }
 
 #[cfg(test)]

src/lib.rs

@@ -173,11 +173,7 @@ pub mod dev {
 
     impl BodyEncoding for ResponseBuilder {
         fn get_encoding(&self) -> Option<ContentEncoding> {
-            if let Some(ref enc) = self.extensions().get::<Enc>() {
+            self.extensions().get::<Enc>().map(|enc| enc.0)
-                Some(enc.0)
-            } else {
-                None
-            }
         }
 
         fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {
@@ -188,11 +184,7 @@ pub mod dev {
 
     impl<B> BodyEncoding for Response<B> {
         fn get_encoding(&self) -> Option<ContentEncoding> {
-            if let Some(ref enc) = self.extensions().get::<Enc>() {
+            self.extensions().get::<Enc>().map(|enc| enc.0)
-                Some(enc.0)
-            } else {
-                None
-            }
         }
 
         fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {

src/middleware/compress.rs

@@ -197,22 +197,23 @@ impl AcceptEncoding {
 
     /// Parse a raw Accept-Encoding header value into an ordered list.
     pub fn parse(raw: &str, encoding: ContentEncoding) -> ContentEncoding {
-        let mut encodings: Vec<_> = raw
+        let mut encodings = raw
             .replace(' ', "")
             .split(',')
             .map(|l| AcceptEncoding::new(l))
-            .collect();
+            .flatten()
+            .collect::<Vec<_>>();
+
         encodings.sort();
 
         for enc in encodings {
-            if let Some(enc) = enc {
+            if encoding == ContentEncoding::Auto {
-                if encoding == ContentEncoding::Auto {
+                return enc.encoding;
-                    return enc.encoding;
+            } else if encoding == enc.encoding {
-                } else if encoding == enc.encoding {
+                return encoding;
-                    return encoding;
-                }
             }
         }
+
         ContentEncoding::Identity
     }
 }

src/resource.rs

@@ -449,9 +449,9 @@ impl ServiceFactory<ServiceRequest> for ResourceFactory {
                 .collect::<Result<Vec<_>, _>>()?;
 
             Ok(ResourceService {
+                routes,
                 app_data,
                 default,
-                routes,
             })
         })
     }

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

@@ -774,10 +774,10 @@ where
     };
 
     TestServer {
-        ssl,
         addr,
         client,
         system,
+        ssl,
         server,
     }
 }
@@ -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()
 }
 

tests/test_httpserver.rs

@@ -1,15 +1,11 @@
-use std::sync::mpsc;
-use std::{thread, time::Duration};
-
 #[cfg(feature = "openssl")]
 extern crate tls_openssl as openssl;
-#[cfg(feature = "rustls")]
-extern crate tls_rustls as rustls;
 
-#[cfg(feature = "openssl")]
+#[cfg(any(unix, feature = "openssl"))]
-use openssl::ssl::SslAcceptorBuilder;
+use {
-
+    actix_web::{test, web, App, HttpResponse, HttpServer},
-use actix_web::{test, web, App, HttpResponse, HttpServer};
+    std::{sync::mpsc, thread, time::Duration},
+};
 
 #[cfg(unix)]
 #[actix_rt::test]
@@ -72,7 +68,7 @@ async fn test_start() {
 }
 
 #[cfg(feature = "openssl")]
-fn ssl_acceptor() -> SslAcceptorBuilder {
+fn ssl_acceptor() -> openssl::ssl::SslAcceptorBuilder {
     use openssl::{
         pkey::PKey,
         ssl::{SslAcceptor, SslMethod},