Merge branch 'master' of github.com:actix/actix-web

* Add `std::convert::Infallible` implementantion for `ResponseError`

* Add from `std::convert::Infallible` to `Error`

* Remove `ResponseError` implementantion for `Infallible`

* Remove useless docs

* Better comment

* Update changelog

* Update actix_http::changelog

.travis.yml

@@ -10,9 +10,9 @@ matrix:
   include:
     - rust: stable
     - rust: beta
-    - rust: nightly-2019-04-02
+    - rust: nightly-2019-08-10
   allow_failures:
-    - rust: nightly-2019-04-02
+    - rust: nightly-2019-08-10
 
 env:
   global:
@@ -25,7 +25,7 @@ before_install:
   - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
 
 before_cache: |
-  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-04-02" ]]; then
+  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-08-10" ]]; then
     RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
   fi
 
@@ -37,6 +37,8 @@ script:
   - cargo update
   - cargo check --all --no-default-features
   - cargo test --all-features --all -- --nocapture
+  - cd actix-http; cargo test --no-default-features --features="rust-tls" -- --nocapture; cd ..
+  - cd awc; cargo test --no-default-features --features="rust-tls" -- --nocapture; cd ..
 
 # Upload docs
 after_success:
@@ -49,7 +51,7 @@ after_success:
       echo "Uploaded documentation"
     fi
   - |
-    if [[ "$TRAVIS_RUST_VERSION" ==  "nightly-2019-04-02" ]]; then
+    if [[ "$TRAVIS_RUST_VERSION" ==  "nightly-2019-08-10" ]]; then
         taskset -c 0 cargo tarpaulin --out Xml --all --all-features
         bash <(curl -s https://codecov.io/bash)
         echo "Uploaded code coverage"

CHANGES.md

@@ -1,6 +1,23 @@
 # Changes
 
-## [1.0.6] - 2019-xx-xx
+## [1.0.8] - 2019-09-xx
+
+### Added
+
+* Add `middleware::Conditon` that conditionally enables another middleware
+
+* Allow to re-construct `ServiceRequest` from `HttpRequest` and `Payload`
+
+* Make UrlEncodedError::Overflow more informativve
+
+## [1.0.7] - 2019-08-29
+
+### Fixed
+
+* Request Extensions leak #1062
+
+
+## [1.0.6] - 2019-08-28
 
 ### Added
 
@@ -8,10 +25,21 @@
 
 * Form immplements Responder, returning a `application/x-www-form-urlencoded` response
 
+* Add `into_inner` to `Data`
+
+* Add `test::TestRequest::set_form()` convenience method to automatically serialize data and set
+  the header in test requests.
+
 ### Changed
 
 * `Query` payload made `pub`. Allows user to pattern-match the payload.
 
+* Enable `rust-tls` feature for client #1045
+
+* Update serde_urlencoded to 0.6.1
+
+* Update url to 2.1
+
 
 ## [1.0.5] - 2019-07-18
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "1.0.5"
+version = "1.0.7"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
@@ -66,7 +66,7 @@ fail = ["actix-http/fail"]
 ssl = ["openssl", "actix-server/ssl", "awc/ssl"]
 
 # rustls
-rust-tls = ["rustls", "actix-server/rust-tls"]
+rust-tls = ["rustls", "actix-server/rust-tls", "awc/rust-tls"]
 
 # unix domain sockets support
 uds = ["actix-server/uds"]
@@ -78,11 +78,11 @@ actix-utils = "0.4.4"
 actix-router = "0.1.5"
 actix-rt = "0.2.4"
 actix-web-codegen = "0.1.2"
-actix-http = "0.2.7"
+actix-http = "0.2.9"
 actix-server = "0.6.0"
 actix-server-config = "0.1.2"
 actix-threadpool = "0.1.1"
-awc = { version = "0.2.2", optional = true }
+awc = { version = "0.2.4", optional = true }
 
 bytes = "0.4"
 derive_more = "0.15.0"
@@ -96,9 +96,9 @@ parking_lot = "0.9"
 regex = "1.0"
 serde = { version = "1.0", features=["derive"] }
 serde_json = "1.0"
-serde_urlencoded = "0.5.3"
+serde_urlencoded = "0.6.1"
 time = "0.1.42"
-url = { version="1.7", features=["query_encoding"] }
+url = "2.1"
 
 # ssl support
 openssl = { version="0.10", optional = true }

actix-cors/README.md

@@ -1,4 +1,4 @@
-# Identity service for actix web framework [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-identity)](https://crates.io/crates/actix-identity) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Cors Middleware for actix web framework [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-cors)](https://crates.io/crates/actix-cors) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Documentation & community resources
 

actix-files/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [0.1.5] - unreleased
+
+* Bump up `mime_guess` crate version to 2.0.1
+
+* Bump up `percent-encoding` crate version to 2.1
+
 ## [0.1.4] - 2019-07-20
 
 * Allow to disable `Content-Disposition` header #686

actix-files/Cargo.toml

@@ -19,7 +19,7 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-web = { version = "1.0.2", default-features = false }
-actix-http = "0.2.4"
+actix-http = "0.2.9"
 actix-service = "0.4.1"
 bitflags = "1"
 bytes = "0.4"
@@ -27,8 +27,8 @@ futures = "0.1.25"
 derive_more = "0.15.0"
 log = "0.4"
 mime = "0.3"
-mime_guess = "2.0.0-alpha"
-percent-encoding = "1.0"
+mime_guess = "2.0.1"
+percent-encoding = "2.1"
 v_htmlescape = "0.4"
 
 [dev-dependencies]

actix-files/src/lib.rs

@@ -22,8 +22,8 @@ use bytes::Bytes;
 use futures::future::{ok, Either, FutureResult};
 use futures::{Async, Future, Poll, Stream};
 use mime;
-use mime_guess::get_mime_type;
-use percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET};
+use mime_guess::from_ext;
+use percent_encoding::{utf8_percent_encode, CONTROLS};
 use v_htmlescape::escape as escape_html_entity;
 
 mod error;
@@ -42,7 +42,7 @@ type HttpNewService = BoxedNewService<(), ServiceRequest, ServiceResponse, Error
 /// the type `application/octet-stream`.
 #[inline]
 pub fn file_extension_to_mime(ext: &str) -> mime::Mime {
-    get_mime_type(ext)
+    from_ext(ext).first_or_octet_stream()
 }
 
 #[doc(hidden)]
@@ -144,7 +144,7 @@ impl Directory {
 // show file url as relative to static path
 macro_rules! encode_file_url {
     ($path:ident) => {
-        utf8_percent_encode(&$path.to_string_lossy(), DEFAULT_ENCODE_SET)
+        utf8_percent_encode(&$path.to_string_lossy(), CONTROLS)
     };
 }
 

actix-files/src/named.rs

@@ -9,7 +9,7 @@ use std::os::unix::fs::MetadataExt;
 
 use bitflags::bitflags;
 use mime;
-use mime_guess::guess_mime_type;
+use mime_guess::from_path;
 
 use actix_http::body::SizedStream;
 use actix_web::http::header::{
@@ -88,7 +88,7 @@ impl NamedFile {
                 }
             };
 
-            let ct = guess_mime_type(&path);
+            let ct = from_path(&path).first_or_octet_stream();
             let disposition_type = match ct.type_() {
                 mime::IMAGE | mime::TEXT | mime::VIDEO => DispositionType::Inline,
                 _ => DispositionType::Attachment,

actix-http/CHANGES.md

@@ -1,5 +1,36 @@
 # Changes
 
+## [0.2.11] - 2019-09-11
+
+### Added
+
+* Add support for sending HTTP requests with `Rc<RequestHead>` in addition to sending HTTP requests with `RequestHead`
+
+* Allow to use `std::convert::Infallible` as `actix_http::error::Error`
+
+
+### Fixed
+
+* h2 will use error response #1080
+
+* on_connect result isn't added to request extensions for http2 requests #1009
+
+
+## [0.2.9] - 2019-08-13
+
+### Changed
+
+* Dropped the `byteorder`-dependency in favor of `stdlib`-implementation
+
+* Update percent-encoding to 2.1
+
+* Update serde_urlencoded to 0.6.1
+
+### Fixed
+
+* Fixed a panic in the HTTP2 handshake in client HTTP requests (#1031)
+
+
 ## [0.2.8] - 2019-08-01
 
 ### Added

actix-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "0.2.8"
+version = "0.2.10"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http primitives"
 readme = "README.md"
@@ -49,7 +49,7 @@ secure-cookies = ["ring"]
 [dependencies]
 actix-service = "0.4.1"
 actix-codec = "0.1.2"
-actix-connect = "0.2.2"
+actix-connect = "0.2.4"
 actix-utils = "0.4.4"
 actix-server-config = "0.1.2"
 actix-threadpool = "0.1.1"
@@ -57,7 +57,6 @@ actix-threadpool = "0.1.1"
 base64 = "0.10"
 bitflags = "1.0"
 bytes = "0.4"
-byteorder = "1.2"
 copyless = "0.1.4"
 derive_more = "0.15.0"
 either = "1.5.2"
@@ -67,19 +66,19 @@ hashbrown = "0.5.0"
 h2 = "0.1.16"
 http = "0.1.17"
 httparse = "1.3"
-indexmap = "1.0"
+indexmap = "1.2"
 lazy_static = "1.0"
 language-tags = "0.2"
 log = "0.4"
 mime = "0.3"
-percent-encoding = "1.0"
+percent-encoding = "2.1"
 rand = "0.7"
 regex = "1.0"
 serde = "1.0"
 serde_json = "1.0"
 sha1 = "0.6"
 slab = "0.4"
-serde_urlencoded = "0.5.5"
+serde_urlencoded = "0.6.1"
 time = "0.1.42"
 tokio-tcp = "0.1.3"
 tokio-timer = "0.2.8"
@@ -102,7 +101,7 @@ chrono = "0.4.6"
 
 [dev-dependencies]
 actix-rt = "0.2.2"
-actix-server = { version = "0.6.0", features=["ssl"] }
+actix-server = { version = "0.6.0", features=["ssl", "rust-tls"] }
 actix-connect = { version = "0.2.0", features=["ssl"] }
 actix-http-test = { version = "0.2.4", features=["ssl"] }
 env_logger = "0.6"

actix-http/src/builder.rs

@@ -199,6 +199,7 @@ where
             self.client_disconnect,
         );
         H2Service::with_config(cfg, service.into_new_service())
+            .on_connect(self.on_connect)
     }
 
     /// Finish service configuration and create `HttpService` instance.

actix-http/src/client/connection.rs

@@ -8,7 +8,7 @@ use h2::client::SendRequest;
 
 use crate::body::MessageBody;
 use crate::h1::ClientCodec;
-use crate::message::{RequestHead, ResponseHead};
+use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
 
 use super::error::SendRequestError;
@@ -27,9 +27,9 @@ pub trait Connection {
     fn protocol(&self) -> Protocol;
 
     /// Send request and body
-    fn send_request<B: MessageBody + 'static>(
+    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
         self,
-        head: RequestHead,
+        head: H,
         body: B,
     ) -> Self::Future;
 
@@ -39,7 +39,7 @@ pub trait Connection {
     >;
 
     /// Send request, returns Response and Framed
-    fn open_tunnel(self, head: RequestHead) -> Self::TunnelFuture;
+    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture;
 }
 
 pub(crate) trait ConnectionLifetime: AsyncRead + AsyncWrite + 'static {
@@ -105,22 +105,22 @@ where
         }
     }
 
-    fn send_request<B: MessageBody + 'static>(
+    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
         mut self,
-        head: RequestHead,
+        head: H,
         body: B,
     ) -> Self::Future {
         match self.io.take().unwrap() {
             ConnectionType::H1(io) => Box::new(h1proto::send_request(
                 io,
-                head,
+                head.into(),
                 body,
                 self.created,
                 self.pool,
             )),
             ConnectionType::H2(io) => Box::new(h2proto::send_request(
                 io,
-                head,
+                head.into(),
                 body,
                 self.created,
                 self.pool,
@@ -139,10 +139,10 @@ where
     >;
 
     /// Send request, returns Response and Framed
-    fn open_tunnel(mut self, head: RequestHead) -> Self::TunnelFuture {
+    fn open_tunnel<H: Into<RequestHeadType>>(mut self, head: H) -> Self::TunnelFuture {
         match self.io.take().unwrap() {
             ConnectionType::H1(io) => {
-                Either::A(Box::new(h1proto::open_tunnel(io, head)))
+                Either::A(Box::new(h1proto::open_tunnel(io, head.into())))
             }
             ConnectionType::H2(io) => {
                 if let Some(mut pool) = self.pool.take() {
@@ -180,9 +180,9 @@ where
         }
     }
 
-    fn send_request<RB: MessageBody + 'static>(
+    fn send_request<RB: MessageBody + 'static, H: Into<RequestHeadType>>(
         self,
-        head: RequestHead,
+        head: H,
         body: RB,
     ) -> Self::Future {
         match self {
@@ -199,7 +199,7 @@ where
     >;
 
     /// Send request, returns Response and Framed
-    fn open_tunnel(self, head: RequestHead) -> Self::TunnelFuture {
+    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture {
         match self {
             EitherConnection::A(con) => Box::new(
                 con.open_tunnel(head)

actix-http/src/client/connector.rs

@@ -212,7 +212,7 @@ where
     pub fn finish(
         self,
     ) -> impl Service<Request = Connect, Response = impl Connection, Error = ConnectError>
-                 + Clone {
+           + Clone {
         #[cfg(not(any(feature = "ssl", feature = "rust-tls")))]
         {
             let connector = TimeoutService::new(
@@ -269,9 +269,9 @@ where
                                     .map(|protos| protos.windows(2).any(|w| w == H2))
                                     .unwrap_or(false);
                                 if h2 {
-                                    (Box::new(sock) as Box<Io>, Protocol::Http2)
+                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http2)
                                 } else {
-                                    (Box::new(sock) as Box<Io>, Protocol::Http1)
+                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http1)
                                 }
                             }),
                     ),
@@ -288,9 +288,9 @@ where
                                     .map(|protos| protos.windows(2).any(|w| w == H2))
                                     .unwrap_or(false);
                                 if h2 {
-                                    (Box::new(sock) as Box<Io>, Protocol::Http2)
+                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http2)
                                 } else {
-                                    (Box::new(sock) as Box<Io>, Protocol::Http1)
+                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http1)
                                 }
                             }),
                     ),

actix-http/src/client/error.rs

@@ -128,3 +128,23 @@ impl ResponseError for SendRequestError {
         .into()
     }
 }
+
+/// A set of errors that can occur during freezing a request
+#[derive(Debug, Display, From)]
+pub enum FreezeRequestError {
+    /// Invalid URL
+    #[display(fmt = "Invalid URL: {}", _0)]
+    Url(InvalidUrl),
+    /// Http error
+    #[display(fmt = "{}", _0)]
+    Http(HttpError),
+}
+
+impl From<FreezeRequestError> for SendRequestError {
+    fn from(e: FreezeRequestError) -> Self {
+        match e {
+            FreezeRequestError::Url(e) => e.into(),
+            FreezeRequestError::Http(e) => e.into(),
+        }
+    }
+}

actix-http/src/client/h1proto.rs

@@ -8,8 +8,9 @@ use futures::{Async, Future, Poll, Sink, Stream};
 
 use crate::error::PayloadError;
 use crate::h1;
+use crate::header::HeaderMap;
 use crate::http::header::{IntoHeaderValue, HOST};
-use crate::message::{RequestHead, ResponseHead};
+use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::{Payload, PayloadStream};
 
 use super::connection::{ConnectionLifetime, ConnectionType, IoConnection};
@@ -19,7 +20,7 @@ use crate::body::{BodySize, MessageBody};
 
 pub(crate) fn send_request<T, B>(
     io: T,
-    mut head: RequestHead,
+    mut head: RequestHeadType,
     body: B,
     created: time::Instant,
     pool: Option<Acquired<T>>,
@@ -29,22 +30,28 @@ where
     B: MessageBody,
 {
     // set request host header
-    if !head.headers.contains_key(HOST) {
-        if let Some(host) = head.uri.host() {
+    if !head.as_ref().headers.contains_key(HOST)
+        && !head.extra_headers().iter().any(|h| h.contains_key(HOST))
+    {
+        if let Some(host) = head.as_ref().uri.host() {
             let mut wrt = BytesMut::with_capacity(host.len() + 5).writer();
 
-            let _ = match head.uri.port_u16() {
+            let _ = match head.as_ref().uri.port_u16() {
                 None | Some(80) | Some(443) => write!(wrt, "{}", host),
                 Some(port) => write!(wrt, "{}:{}", host, port),
             };
 
             match wrt.get_mut().take().freeze().try_into() {
-                Ok(value) => {
-                    head.headers.insert(HOST, value);
-                }
-                Err(e) => {
-                    log::error!("Can not set HOST header {}", e);
-                }
+                Ok(value) => match head {
+                    RequestHeadType::Owned(ref mut head) => {
+                        head.headers.insert(HOST, value)
+                    }
+                    RequestHeadType::Rc(_, ref mut extra_headers) => {
+                        let headers = extra_headers.get_or_insert(HeaderMap::new());
+                        headers.insert(HOST, value)
+                    }
+                },
+                Err(e) => log::error!("Can not set HOST header {}", e),
             }
         }
     }
@@ -57,7 +64,7 @@ where
 
     let len = body.size();
 
-    // create Framed and send reqest
+    // create Framed and send request
     Framed::new(io, h1::ClientCodec::default())
         .send((head, len).into())
         .from_err()
@@ -95,12 +102,12 @@ where
 
 pub(crate) fn open_tunnel<T>(
     io: T,
-    head: RequestHead,
+    head: RequestHeadType,
 ) -> impl Future<Item = (ResponseHead, Framed<T, h1::ClientCodec>), Error = SendRequestError>
 where
     T: AsyncRead + AsyncWrite + 'static,
 {
-    // create Framed and send reqest
+    // create Framed and send request
     Framed::new(io, h1::ClientCodec::default())
         .send((head, BodySize::None).into())
         .from_err()

actix-http/src/client/h2proto.rs

@@ -9,7 +9,8 @@ use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, HttpTryFrom, Method, Version};
 
 use crate::body::{BodySize, MessageBody};
-use crate::message::{RequestHead, ResponseHead};
+use crate::header::HeaderMap;
+use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
 
 use super::connection::{ConnectionType, IoConnection};
@@ -18,7 +19,7 @@ use super::pool::Acquired;
 
 pub(crate) fn send_request<T, B>(
     io: SendRequest<Bytes>,
-    head: RequestHead,
+    head: RequestHeadType,
     body: B,
     created: time::Instant,
     pool: Option<Acquired<T>>,
@@ -28,7 +29,7 @@ where
     B: MessageBody,
 {
     trace!("Sending client request: {:?} {:?}", head, body.size());
-    let head_req = head.method == Method::HEAD;
+    let head_req = head.as_ref().method == Method::HEAD;
     let length = body.size();
     let eof = match length {
         BodySize::None | BodySize::Empty | BodySize::Sized(0) => true,
@@ -39,8 +40,8 @@ where
         .map_err(SendRequestError::from)
         .and_then(move |mut io| {
             let mut req = Request::new(());
-            *req.uri_mut() = head.uri;
-            *req.method_mut() = head.method;
+            *req.uri_mut() = head.as_ref().uri.clone();
+            *req.method_mut() = head.as_ref().method.clone();
             *req.version_mut() = Version::HTTP_2;
 
             let mut skip_len = true;
@@ -66,8 +67,27 @@ where
                 ),
             };
 
+            // Extracting extra headers from RequestHeadType. HeaderMap::new() does not allocate.
+            let (head, extra_headers) = match head {
+                RequestHeadType::Owned(head) => {
+                    (RequestHeadType::Owned(head), HeaderMap::new())
+                }
+                RequestHeadType::Rc(head, extra_headers) => (
+                    RequestHeadType::Rc(head, None),
+                    extra_headers.unwrap_or_else(HeaderMap::new),
+                ),
+            };
+
+            // merging headers from head and extra headers.
+            let headers = head
+                .as_ref()
+                .headers
+                .iter()
+                .filter(|(name, _)| !extra_headers.contains_key(*name))
+                .chain(extra_headers.iter());
+
             // copy headers
-            for (key, value) in head.headers.iter() {
+            for (key, value) in headers {
                 match *key {
                     CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
                     CONTENT_LENGTH if skip_len => continue,

actix-http/src/client/mod.rs

@@ -10,7 +10,7 @@ mod pool;
 
 pub use self::connection::Connection;
 pub use self::connector::Connector;
-pub use self::error::{ConnectError, InvalidUrl, SendRequestError};
+pub use self::error::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};
 pub use self::pool::Protocol;
 
 #[derive(Clone)]

actix-http/src/client/pool.rs

@@ -326,7 +326,7 @@ impl<Io> Inner<Io> {
 
     fn release_waiter(&mut self, key: &Key, token: usize) {
         self.waiters.remove(token);
-        self.waiters_queue.remove(&(key.clone(), token));
+        let _ = self.waiters_queue.shift_remove(&(key.clone(), token));
     }
 }
 
@@ -590,6 +590,29 @@ where
     type Error = ();
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut h2) = self.h2 {
+            return match h2.poll() {
+                Ok(Async::Ready((snd, connection))) => {
+                    tokio_current_thread::spawn(connection.map_err(|_| ()));
+                    let rx = self.rx.take().unwrap();
+                    let _ = rx.send(Ok(IoConnection::new(
+                        ConnectionType::H2(snd),
+                        Instant::now(),
+                        Some(Acquired(self.key.clone(), self.inner.take())),
+                    )));
+                    Ok(Async::Ready(()))
+                }
+                Ok(Async::NotReady) => Ok(Async::NotReady),
+                Err(err) => {
+                    let _ = self.inner.take();
+                    if let Some(rx) = self.rx.take() {
+                        let _ = rx.send(Err(ConnectError::H2(err)));
+                    }
+                    Err(())
+                }
+            };
+        }
+
         match self.fut.poll() {
             Err(err) => {
                 let _ = self.inner.take();

actix-http/src/cookie/mod.rs

@@ -66,7 +66,7 @@ use std::fmt;
 use std::str::FromStr;
 
 use chrono::Duration;
-use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};
+use percent_encoding::{percent_encode, AsciiSet, CONTROLS};
 use time::Tm;
 
 pub use self::builder::CookieBuilder;
@@ -75,6 +75,25 @@ pub use self::jar::{CookieJar, Delta, Iter};
 use self::parse::parse_cookie;
 pub use self::parse::ParseError;
 
+/// https://url.spec.whatwg.org/#fragment-percent-encode-set
+const FRAGMENT: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');
+
+/// https://url.spec.whatwg.org/#path-percent-encode-set
+const PATH: &AsciiSet = &FRAGMENT.add(b'#').add(b'?').add(b'{').add(b'}');
+
+/// https://url.spec.whatwg.org/#userinfo-percent-encode-set
+pub const USERINFO: &AsciiSet = &PATH
+    .add(b'/')
+    .add(b':')
+    .add(b';')
+    .add(b'=')
+    .add(b'@')
+    .add(b'[')
+    .add(b'\\')
+    .add(b']')
+    .add(b'^')
+    .add(b'|');
+
 #[derive(Debug, Clone)]
 enum CookieStr {
     /// An string derived from indexes (start, end).
@@ -910,8 +929,8 @@ pub struct EncodedCookie<'a, 'c: 'a>(&'a Cookie<'c>);
 impl<'a, 'c: 'a> fmt::Display for EncodedCookie<'a, 'c> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // Percent-encode the name and value.
-        let name = percent_encode(self.0.name().as_bytes(), USERINFO_ENCODE_SET);
-        let value = percent_encode(self.0.value().as_bytes(), USERINFO_ENCODE_SET);
+        let name = percent_encode(self.0.name().as_bytes(), USERINFO);
+        let value = percent_encode(self.0.value().as_bytes(), USERINFO);
 
         // Write out the name/value pair and the cookie's parameters.
         write!(f, "{}={}", name, value)?;

actix-http/src/error.rs

@@ -132,6 +132,14 @@ impl std::error::Error for Error {
     }
 }
 
+impl From<std::convert::Infallible> for Error {
+    fn from(_: std::convert::Infallible) -> Self {
+        // `std::convert::Infallible` indicates an error
+        // that will never happen
+        unreachable!()
+    }
+}
+
 /// Convert `Error` to a `Response` instance
 impl From<Error> for Response {
     fn from(err: Error) -> Self {
@@ -1072,7 +1080,7 @@ mod tests {
     #[test]
     fn test_error_casting() {
         let err = PayloadError::Overflow;
-        let resp_err: &ResponseError = &err;
+        let resp_err: &dyn ResponseError = &err;
         let err = resp_err.downcast_ref::<PayloadError>().unwrap();
         assert_eq!(err.to_string(), "A payload reached size limit.");
         let not_err = resp_err.downcast_ref::<ContentTypeError>();

actix-http/src/h1/client.rs

@@ -1,5 +1,6 @@
 #![allow(unused_imports, unused_variables, dead_code)]
 use std::io::{self, Write};
+use std::rc::Rc;
 
 use actix_codec::{Decoder, Encoder};
 use bitflags::bitflags;
@@ -15,8 +16,11 @@ use super::{Message, MessageType};
 use crate::body::BodySize;
 use crate::config::ServiceConfig;
 use crate::error::{ParseError, PayloadError};
+use crate::header::HeaderMap;
 use crate::helpers;
-use crate::message::{ConnectionType, Head, MessagePool, RequestHead, ResponseHead};
+use crate::message::{
+    ConnectionType, Head, MessagePool, RequestHead, RequestHeadType, ResponseHead,
+};
 
 bitflags! {
     struct Flags: u8 {
@@ -48,7 +52,7 @@ struct ClientCodecInner {
     // encoder part
     flags: Flags,
     headers_size: u32,
-    encoder: encoder::MessageEncoder<RequestHead>,
+    encoder: encoder::MessageEncoder<RequestHeadType>,
 }
 
 impl Default for ClientCodec {
@@ -183,7 +187,7 @@ impl Decoder for ClientPayloadCodec {
 }
 
 impl Encoder for ClientCodec {
-    type Item = Message<(RequestHead, BodySize)>;
+    type Item = Message<(RequestHeadType, BodySize)>;
     type Error = io::Error;
 
     fn encode(
@@ -192,13 +196,15 @@ impl Encoder for ClientCodec {
         dst: &mut BytesMut,
     ) -> Result<(), Self::Error> {
         match item {
-            Message::Item((mut msg, length)) => {
+            Message::Item((mut head, length)) => {
                 let inner = &mut self.inner;
-                inner.version = msg.version;
-                inner.flags.set(Flags::HEAD, msg.method == Method::HEAD);
+                inner.version = head.as_ref().version;
+                inner
+                    .flags
+                    .set(Flags::HEAD, head.as_ref().method == Method::HEAD);
 
                 // connection status
-                inner.ctype = match msg.connection_type() {
+                inner.ctype = match head.as_ref().connection_type() {
                     ConnectionType::KeepAlive => {
                         if inner.flags.contains(Flags::KEEPALIVE_ENABLED) {
                             ConnectionType::KeepAlive
@@ -212,7 +218,7 @@ impl Encoder for ClientCodec {
 
                 inner.encoder.encode(
                     dst,
-                    &mut msg,
+                    &mut head,
                     false,
                     false,
                     inner.version,

actix-http/src/h1/decoder.rs

@@ -1,5 +1,6 @@
+use std::io;
 use std::marker::PhantomData;
-use std::{io, mem};
+use std::mem::MaybeUninit;
 
 use actix_codec::Decoder;
 use bytes::{Bytes, BytesMut};
@@ -186,11 +187,12 @@ impl MessageType for Request {
     fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, ParseError> {
         // Unsafe: we read only this data only after httparse parses headers into.
         // performance bump for pipeline benchmarks.
-        let mut headers: [HeaderIndex; MAX_HEADERS] = unsafe { mem::uninitialized() };
+        let mut headers: [HeaderIndex; MAX_HEADERS] =
+            unsafe { MaybeUninit::uninit().assume_init() };
 
         let (len, method, uri, ver, h_len) = {
             let mut parsed: [httparse::Header; MAX_HEADERS] =
-                unsafe { mem::uninitialized() };
+                unsafe { MaybeUninit::uninit().assume_init() };
 
             let mut req = httparse::Request::new(&mut parsed);
             match req.parse(src)? {
@@ -260,11 +262,12 @@ impl MessageType for ResponseHead {
     fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, ParseError> {
         // Unsafe: we read only this data only after httparse parses headers into.
         // performance bump for pipeline benchmarks.
-        let mut headers: [HeaderIndex; MAX_HEADERS] = unsafe { mem::uninitialized() };
+        let mut headers: [HeaderIndex; MAX_HEADERS] =
+            unsafe { MaybeUninit::uninit().assume_init() };
 
         let (len, ver, status, h_len) = {
             let mut parsed: [httparse::Header; MAX_HEADERS] =
-                unsafe { mem::uninitialized() };
+                unsafe { MaybeUninit::uninit().assume_init() };
 
             let mut res = httparse::Response::new(&mut parsed);
             match res.parse(src)? {

actix-http/src/h1/dispatcher.rs

@@ -502,7 +502,7 @@ where
                             let pl = self.codec.message_type();
                             req.head_mut().peer_addr = self.peer_addr;
 
-                            // on_connect data
+                            // set on_connect data
                             if let Some(ref on_connect) = self.on_connect {
                                 on_connect.set(&mut req.extensions_mut());
                             }

actix-http/src/h1/encoder.rs

@@ -2,6 +2,7 @@
 use std::fmt::Write as FmtWrite;
 use std::io::Write;
 use std::marker::PhantomData;
+use std::rc::Rc;
 use std::str::FromStr;
 use std::{cmp, fmt, io, mem};
 
@@ -15,7 +16,7 @@ use crate::http::header::{
     HeaderValue, ACCEPT_ENCODING, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING,
 };
 use crate::http::{HeaderMap, Method, StatusCode, Version};
-use crate::message::{ConnectionType, Head, RequestHead, ResponseHead};
+use crate::message::{ConnectionType, Head, RequestHead, RequestHeadType, ResponseHead};
 use crate::request::Request;
 use crate::response::Response;
 
@@ -43,6 +44,8 @@ pub(crate) trait MessageType: Sized {
 
     fn headers(&self) -> &HeaderMap;
 
+    fn extra_headers(&self) -> Option<&HeaderMap>;
+
     fn camel_case(&self) -> bool {
         false
     }
@@ -128,12 +131,22 @@ pub(crate) trait MessageType: Sized {
             _ => (),
         }
 
+        // merging headers from head and extra headers. HeaderMap::new() does not allocate.
+        let empty_headers = HeaderMap::new();
+        let extra_headers = self.extra_headers().unwrap_or(&empty_headers);
+        let headers = self
+            .headers()
+            .inner
+            .iter()
+            .filter(|(name, _)| !extra_headers.contains_key(*name))
+            .chain(extra_headers.inner.iter());
+
         // write headers
         let mut pos = 0;
         let mut has_date = false;
         let mut remaining = dst.remaining_mut();
         let mut buf = unsafe { &mut *(dst.bytes_mut() as *mut [u8]) };
-        for (key, value) in self.headers().inner.iter() {
+        for (key, value) in headers {
             match *key {
                 CONNECTION => continue,
                 TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => continue,
@@ -235,6 +248,10 @@ impl MessageType for Response<()> {
         &self.head().headers
     }
 
+    fn extra_headers(&self) -> Option<&HeaderMap> {
+        None
+    }
+
     fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
         let head = self.head();
         let reason = head.reason().as_bytes();
@@ -247,31 +264,36 @@ impl MessageType for Response<()> {
     }
 }
 
-impl MessageType for RequestHead {
+impl MessageType for RequestHeadType {
     fn status(&self) -> Option<StatusCode> {
         None
     }
 
     fn chunked(&self) -> bool {
-        self.chunked()
+        self.as_ref().chunked()
     }
 
     fn camel_case(&self) -> bool {
-        RequestHead::camel_case_headers(self)
+        self.as_ref().camel_case_headers()
     }
 
     fn headers(&self) -> &HeaderMap {
-        &self.headers
+        self.as_ref().headers()
+    }
+
+    fn extra_headers(&self) -> Option<&HeaderMap> {
+        self.extra_headers()
     }
 
     fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
-        dst.reserve(256 + self.headers.len() * AVERAGE_HEADER_SIZE);
+        let head = self.as_ref();
+        dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE);
         write!(
             Writer(dst),
             "{} {} {}",
-            self.method,
-            self.uri.path_and_query().map(|u| u.as_str()).unwrap_or("/"),
-            match self.version {
+            head.method,
+            head.uri.path_and_query().map(|u| u.as_str()).unwrap_or("/"),
+            match head.version {
                 Version::HTTP_09 => "HTTP/0.9",
                 Version::HTTP_10 => "HTTP/1.0",
                 Version::HTTP_11 => "HTTP/1.1",
@@ -488,9 +510,11 @@ fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
 #[cfg(test)]
 mod tests {
     use bytes::Bytes;
+    //use std::rc::Rc;
 
     use super::*;
     use crate::http::header::{HeaderValue, CONTENT_TYPE};
+    use http::header::AUTHORIZATION;
 
     #[test]
     fn test_chunked_te() {
@@ -515,6 +539,8 @@ mod tests {
         head.headers
             .insert(CONTENT_TYPE, HeaderValue::from_static("plain/text"));
 
+        let mut head = RequestHeadType::Owned(head);
+
         let _ = head.encode_headers(
             &mut bytes,
             Version::HTTP_11,
@@ -551,21 +577,16 @@ mod tests {
             Bytes::from_static(b"\r\nContent-Length: 100\r\nDate: date\r\nContent-Type: plain/text\r\n\r\n")
         );
 
+        let mut head = RequestHead::default();
+        head.set_camel_case_headers(false);
+        head.headers.insert(DATE, HeaderValue::from_static("date"));
+        head.headers
+            .insert(CONTENT_TYPE, HeaderValue::from_static("plain/text"));
         head.headers
             .append(CONTENT_TYPE, HeaderValue::from_static("xml"));
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Stream,
-            ConnectionType::KeepAlive,
-            &ServiceConfig::default(),
-        );
-        assert_eq!(
-            bytes.take().freeze(),
-            Bytes::from_static(b"\r\nTransfer-Encoding: chunked\r\nDate: date\r\nContent-Type: xml\r\nContent-Type: plain/text\r\n\r\n")
-        );
 
-        head.set_camel_case_headers(false);
+        let mut head = RequestHeadType::Owned(head);
+
         let _ = head.encode_headers(
             &mut bytes,
             Version::HTTP_11,
@@ -578,4 +599,36 @@ mod tests {
             Bytes::from_static(b"\r\ntransfer-encoding: chunked\r\ndate: date\r\ncontent-type: xml\r\ncontent-type: plain/text\r\n\r\n")
         );
     }
+
+    #[test]
+    fn test_extra_headers() {
+        let mut bytes = BytesMut::with_capacity(2048);
+
+        let mut head = RequestHead::default();
+        head.headers.insert(
+            AUTHORIZATION,
+            HeaderValue::from_static("some authorization"),
+        );
+
+        let mut extra_headers = HeaderMap::new();
+        extra_headers.insert(
+            AUTHORIZATION,
+            HeaderValue::from_static("another authorization"),
+        );
+        extra_headers.insert(DATE, HeaderValue::from_static("date"));
+
+        let mut head = RequestHeadType::Rc(Rc::new(head), Some(extra_headers));
+
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Empty,
+            ConnectionType::Close,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\ncontent-length: 0\r\nconnection: close\r\nauthorization: another authorization\r\ndate: date\r\n\r\n")
+        );
+    }
 }

actix-http/src/h2/dispatcher.rs

@@ -23,6 +23,7 @@ use crate::cloneable::CloneableService;
 use crate::config::ServiceConfig;
 use crate::error::{DispatchError, Error, ParseError, PayloadError, ResponseError};
 use crate::helpers::DataFactory;
+use crate::httpmessage::HttpMessage;
 use crate::message::ResponseHead;
 use crate::payload::Payload;
 use crate::request::Request;
@@ -122,6 +123,12 @@ where
                     head.version = parts.version;
                     head.headers = parts.headers.into();
                     head.peer_addr = self.peer_addr;
+
+                    // set on_connect data
+                    if let Some(ref on_connect) = self.on_connect {
+                        on_connect.set(&mut req.extensions_mut());
+                    }
+
                     tokio_current_thread::spawn(ServiceResponse::<S::Future, B> {
                         state: ServiceResponseState::ServiceCall(
                             self.service.call(req),
@@ -250,8 +257,8 @@ where
                         }
                     }
                     Ok(Async::NotReady) => Ok(Async::NotReady),
-                    Err(_e) => {
-                        let res: Response = Response::InternalServerError().finish();
+                    Err(e) => {
+                        let res: Response = e.into().into();
                         let (res, body) = res.replace_body(());
 
                         let mut send = send.take().unwrap();

actix-http/src/header/mod.rs

@@ -6,6 +6,7 @@ use std::{fmt, str::FromStr};
 use bytes::{Bytes, BytesMut};
 use http::Error as HttpError;
 use mime::Mime;
+use percent_encoding::{AsciiSet, CONTROLS};
 
 pub use http::header::*;
 
@@ -361,10 +362,8 @@ pub fn parse_extended_value(
 
 impl fmt::Display for ExtendedValue {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let encoded_value = percent_encoding::percent_encode(
-            &self.value[..],
-            self::percent_encoding_http::HTTP_VALUE,
-        );
+        let encoded_value =
+            percent_encoding::percent_encode(&self.value[..], HTTP_VALUE);
         if let Some(ref lang) = self.language_tag {
             write!(f, "{}'{}'{}", self.charset, lang, encoded_value)
         } else {
@@ -378,8 +377,7 @@ impl fmt::Display for ExtendedValue {
 ///
 /// [url]: https://tools.ietf.org/html/rfc5987#section-3.2
 pub fn http_percent_encode(f: &mut fmt::Formatter, bytes: &[u8]) -> fmt::Result {
-    let encoded =
-        percent_encoding::percent_encode(bytes, self::percent_encoding_http::HTTP_VALUE);
+    let encoded = percent_encoding::percent_encode(bytes, HTTP_VALUE);
     fmt::Display::fmt(&encoded, f)
 }
 
@@ -394,20 +392,29 @@ impl From<http::HeaderMap> for HeaderMap {
     }
 }
 
-mod percent_encoding_http {
-    use percent_encoding::{self, define_encode_set};
-
-    // internal module because macro is hard-coded to make a public item
-    // but we don't want to public export this item
-    define_encode_set! {
-        // This encode set is used for HTTP header values and is defined at
-        // https://tools.ietf.org/html/rfc5987#section-3.2
-        pub HTTP_VALUE = [percent_encoding::SIMPLE_ENCODE_SET] | {
-            ' ', '"', '%', '\'', '(', ')', '*', ',', '/', ':', ';', '<', '-', '>', '?',
-            '[', '\\', ']', '{', '}'
-        }
-    }
-}
+// This encode set is used for HTTP header values and is defined at
+// https://tools.ietf.org/html/rfc5987#section-3.2
+pub(crate) const HTTP_VALUE: &AsciiSet = &CONTROLS
+    .add(b' ')
+    .add(b'"')
+    .add(b'%')
+    .add(b'\'')
+    .add(b'(')
+    .add(b')')
+    .add(b'*')
+    .add(b',')
+    .add(b'/')
+    .add(b':')
+    .add(b';')
+    .add(b'<')
+    .add(b'-')
+    .add(b'>')
+    .add(b'?')
+    .add(b'[')
+    .add(b'\\')
+    .add(b']')
+    .add(b'{')
+    .add(b'}');
 
 #[cfg(test)]
 mod tests {

actix-http/src/helpers.rs

@@ -115,7 +115,7 @@ pub fn write_content_length(mut n: usize, bytes: &mut BytesMut) {
 
 pub(crate) fn convert_usize(mut n: usize, bytes: &mut BytesMut) {
     let mut curr: isize = 39;
-    let mut buf: [u8; 41] = unsafe { mem::uninitialized() };
+    let mut buf: [u8; 41] = unsafe { mem::MaybeUninit::uninit().assume_init() };
     buf[39] = b'\r';
     buf[40] = b'\n';
     let buf_ptr = buf.as_mut_ptr();

actix-http/src/lib.rs

@@ -39,7 +39,7 @@ pub use self::config::{KeepAlive, ServiceConfig};
 pub use self::error::{Error, ResponseError, Result};
 pub use self::extensions::Extensions;
 pub use self::httpmessage::HttpMessage;
-pub use self::message::{Message, RequestHead, ResponseHead};
+pub use self::message::{Message, RequestHead, RequestHeadType, ResponseHead};
 pub use self::payload::{Payload, PayloadStream};
 pub use self::request::Request;
 pub use self::response::{Response, ResponseBuilder};

actix-http/src/message.rs

@@ -181,6 +181,36 @@ impl RequestHead {
     }
 }
 
+#[derive(Debug)]
+pub enum RequestHeadType {
+    Owned(RequestHead),
+    Rc(Rc<RequestHead>, Option<HeaderMap>),
+}
+
+impl RequestHeadType {
+    pub fn extra_headers(&self) -> Option<&HeaderMap> {
+        match self {
+            RequestHeadType::Owned(_) => None,
+            RequestHeadType::Rc(_, headers) => headers.as_ref(),
+        }
+    }
+}
+
+impl AsRef<RequestHead> for RequestHeadType {
+    fn as_ref(&self) -> &RequestHead {
+        match self {
+            RequestHeadType::Owned(head) => &head,
+            RequestHeadType::Rc(head, _) => head.as_ref(),
+        }
+    }
+}
+
+impl From<RequestHead> for RequestHeadType {
+    fn from(head: RequestHead) -> Self {
+        RequestHeadType::Owned(head)
+    }
+}
+
 #[derive(Debug)]
 pub struct ResponseHead {
     pub version: Version,

actix-http/src/test.rs

@@ -9,9 +9,9 @@ use bytes::{Buf, Bytes, BytesMut};
 use futures::{Async, Poll};
 use http::header::{self, HeaderName, HeaderValue};
 use http::{HttpTryFrom, Method, Uri, Version};
-use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};
+use percent_encoding::percent_encode;
 
-use crate::cookie::{Cookie, CookieJar};
+use crate::cookie::{Cookie, CookieJar, USERINFO};
 use crate::header::HeaderMap;
 use crate::header::{Header, IntoHeaderValue};
 use crate::payload::Payload;
@@ -150,7 +150,7 @@ impl TestRequest {
 
     /// Complete request creation and generate `Request` instance
     pub fn finish(&mut self) -> Request {
-        let inner = self.0.take().expect("cannot reuse test request builder");;
+        let inner = self.0.take().expect("cannot reuse test request builder");
 
         let mut req = if let Some(pl) = inner.payload {
             Request::with_payload(pl)
@@ -166,8 +166,8 @@ impl TestRequest {
 
         let mut cookie = String::new();
         for c in inner.cookies.delta() {
-            let name = percent_encode(c.name().as_bytes(), USERINFO_ENCODE_SET);
-            let value = percent_encode(c.value().as_bytes(), USERINFO_ENCODE_SET);
+            let name = percent_encode(c.name().as_bytes(), USERINFO);
+            let value = percent_encode(c.value().as_bytes(), USERINFO);
             let _ = write!(&mut cookie, "; {}={}", name, value);
         }
         if !cookie.is_empty() {

actix-http/src/ws/frame.rs

@@ -1,4 +1,5 @@
-use byteorder::{ByteOrder, LittleEndian, NetworkEndian};
+use std::convert::TryFrom;
+
 use bytes::{BufMut, Bytes, BytesMut};
 use log::debug;
 use rand;
@@ -48,14 +49,16 @@ impl Parser {
             if chunk_len < 4 {
                 return Ok(None);
             }
-            let len = NetworkEndian::read_uint(&src[idx..], 2) as usize;
+            let len = usize::from(u16::from_be_bytes(
+                TryFrom::try_from(&src[idx..idx + 2]).unwrap(),
+            ));
             idx += 2;
             len
         } else if len == 127 {
             if chunk_len < 10 {
                 return Ok(None);
             }
-            let len = NetworkEndian::read_uint(&src[idx..], 8);
+            let len = u64::from_be_bytes(TryFrom::try_from(&src[idx..idx + 8]).unwrap());
             if len > max_size as u64 {
                 return Err(ProtocolError::Overflow);
             }
@@ -75,10 +78,10 @@ impl Parser {
                 return Ok(None);
             }
 
-            let mask: &[u8] = &src[idx..idx + 4];
-            let mask_u32 = LittleEndian::read_u32(mask);
+            let mask =
+                u32::from_le_bytes(TryFrom::try_from(&src[idx..idx + 4]).unwrap());
             idx += 4;
-            Some(mask_u32)
+            Some(mask)
         } else {
             None
         };
@@ -137,7 +140,7 @@ impl Parser {
     /// Parse the payload of a close frame.
     pub fn parse_close_payload(payload: &[u8]) -> Option<CloseReason> {
         if payload.len() >= 2 {
-            let raw_code = NetworkEndian::read_u16(payload);
+            let raw_code = u16::from_be_bytes(TryFrom::try_from(&payload[..2]).unwrap());
             let code = CloseCode::from(raw_code);
             let description = if payload.len() > 2 {
                 Some(String::from_utf8_lossy(&payload[2..]).into())
@@ -201,10 +204,7 @@ impl Parser {
         let payload = match reason {
             None => Vec::new(),
             Some(reason) => {
-                let mut code_bytes = [0; 2];
-                NetworkEndian::write_u16(&mut code_bytes, reason.code.into());
-
-                let mut payload = Vec::from(&code_bytes[..]);
+                let mut payload = Into::<u16>::into(reason.code).to_be_bytes().to_vec();
                 if let Some(description) = reason.description {
                     payload.extend(description.as_bytes());
                 }

actix-http/src/ws/mask.rs

@@ -105,7 +105,6 @@ fn align_buf(buf: &mut [u8]) -> (ShortSlice, &mut [u64], ShortSlice) {
 #[cfg(test)]
 mod tests {
     use super::apply_mask;
-    use byteorder::{ByteOrder, LittleEndian};
 
     /// A safe unoptimized mask application.
     fn apply_mask_fallback(buf: &mut [u8], mask: &[u8; 4]) {
@@ -117,7 +116,7 @@ mod tests {
     #[test]
     fn test_apply_mask() {
         let mask = [0x6d, 0xb6, 0xb2, 0x80];
-        let mask_u32: u32 = LittleEndian::read_u32(&mask);
+        let mask_u32 = u32::from_le_bytes(mask);
 
         let unmasked = vec![
             0xf3, 0x00, 0x01, 0x02, 0x03, 0x80, 0x81, 0x82, 0xff, 0xfe, 0x00, 0x17,

actix-http/tests/test_rustls_server.rs

@@ -454,9 +454,9 @@ fn test_h2_service_error() {
     });
 
     let response = srv.block_on(srv.sget("/").send()).unwrap();
-    assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
+    assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
 
     // read response
     let bytes = srv.load_body(response).unwrap();
-    assert!(bytes.is_empty());
+    assert_eq!(bytes, Bytes::from_static(b"error"));
 }

actix-http/tests/test_server.rs

@@ -11,6 +11,7 @@ use futures::stream::{once, Stream};
 use regex::Regex;
 use tokio_timer::sleep;
 
+use actix_http::httpmessage::HttpMessage;
 use actix_http::{
     body, error, http, http::header, Error, HttpService, KeepAlive, Request, Response,
 };
@@ -602,3 +603,18 @@ fn test_h1_service_error() {
     let bytes = srv.load_body(response).unwrap();
     assert_eq!(bytes, Bytes::from_static(b"error"));
 }
+
+#[test]
+fn test_h1_on_connect() {
+    let mut srv = TestServer::new(|| {
+        HttpService::build()
+            .on_connect(|_| 10usize)
+            .h1(|req: Request| {
+                assert!(req.extensions().contains::<usize>());
+                future::ok::<_, ()>(Response::Ok().finish())
+            })
+    });
+
+    let response = srv.block_on(srv.get("/").send()).unwrap();
+    assert!(response.status().is_success());
+}

actix-http/tests/test_ssl_server.rs

@@ -1,9 +1,5 @@
 #![cfg(feature = "ssl")]
 use actix_codec::{AsyncRead, AsyncWrite};
-use actix_http::error::{ErrorBadRequest, PayloadError};
-use actix_http::http::header::{self, HeaderName, HeaderValue};
-use actix_http::http::{Method, StatusCode, Version};
-use actix_http::{body, Error, HttpService, Request, Response};
 use actix_http_test::TestServer;
 use actix_server::ssl::OpensslAcceptor;
 use actix_server_config::ServerConfig;
@@ -15,6 +11,12 @@ use futures::stream::{once, Stream};
 use openssl::ssl::{AlpnError, SslAcceptor, SslFiletype, SslMethod};
 use std::io::Result;
 
+use actix_http::error::{ErrorBadRequest, PayloadError};
+use actix_http::http::header::{self, HeaderName, HeaderValue};
+use actix_http::http::{Method, StatusCode, Version};
+use actix_http::httpmessage::HttpMessage;
+use actix_http::{body, Error, HttpService, Request, Response};
+
 fn load_body<S>(stream: S) -> impl Future<Item = BytesMut, Error = PayloadError>
 where
     S: Stream<Item = Bytes, Error = PayloadError>,
@@ -447,9 +449,32 @@ fn test_h2_service_error() {
     });
 
     let response = srv.block_on(srv.sget("/").send()).unwrap();
-    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 
     // read response
     let bytes = srv.load_body(response).unwrap();
-    assert!(bytes.is_empty());
+    assert_eq!(bytes, Bytes::from_static(b"error"));
+}
+
+#[test]
+fn test_h2_on_connect() {
+    let openssl = ssl_acceptor().unwrap();
+
+    let mut srv = TestServer::new(move || {
+        openssl
+            .clone()
+            .map_err(|e| println!("Openssl error: {}", e))
+            .and_then(
+                HttpService::build()
+                    .on_connect(|_| 10usize)
+                    .h2(|req: Request| {
+                        assert!(req.extensions().contains::<usize>());
+                        ok::<_, ()>(Response::Ok().finish())
+                    })
+                    .map_err(|_| ()),
+            )
+    });
+
+    let response = srv.block_on(srv.sget("/").send()).unwrap();
+    assert!(response.status().is_success());
 }

actix-multipart/CHANGES.md

@@ -1,6 +1,10 @@
 # Changes
 
-## [0.1.3] - 2019-06-06
+## [0.1.4] - 2019-09-12
+
+* Multipart handling now parses requests which do not end in CRLF #1038
+
+## [0.1.3] - 2019-08-18
 
 * Fix ring dependency from actix-web default features for #741.
 

actix-multipart/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-multipart"
-version = "0.1.3"
+version = "0.1.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Multipart support for actix web framework."
 readme = "README.md"

actix-multipart/src/server.rs

@@ -167,7 +167,7 @@ impl InnerMultipart {
         boundary: &str,
     ) -> Result<Option<bool>, MultipartError> {
         // TODO: need to read epilogue
-        match payload.readline()? {
+        match payload.readline_or_eof()? {
             None => {
                 if payload.eof {
                     Ok(Some(true))
@@ -176,15 +176,16 @@ impl InnerMultipart {
                 }
             }
             Some(chunk) => {
-                if chunk.len() == boundary.len() + 4
-                    && &chunk[..2] == b"--"
-                    && &chunk[2..boundary.len() + 2] == boundary.as_bytes()
+                if chunk.len() < boundary.len() + 4
+                    || &chunk[..2] != b"--"
+                    || &chunk[2..boundary.len() + 2] != boundary.as_bytes()
                 {
+                    Err(MultipartError::Boundary)
+                } else if &chunk[boundary.len() + 2..] == b"\r\n" {
                     Ok(Some(false))
-                } else if chunk.len() == boundary.len() + 6
-                    && &chunk[..2] == b"--"
-                    && &chunk[2..boundary.len() + 2] == boundary.as_bytes()
-                    && &chunk[boundary.len() + 2..boundary.len() + 4] == b"--"
+                } else if &chunk[boundary.len() + 2..boundary.len() + 4] == b"--"
+                    && (chunk.len() == boundary.len() + 4
+                        || &chunk[boundary.len() + 4..] == b"\r\n")
                 {
                     Ok(Some(true))
                 } else {
@@ -779,6 +780,16 @@ impl PayloadBuffer {
         self.read_until(b"\n")
     }
 
+    /// Read bytes until new line delimiter or eof
+    pub fn readline_or_eof(&mut self) -> Result<Option<Bytes>, MultipartError> {
+        match self.readline() {
+            Err(MultipartError::Incomplete) if self.eof => {
+                Ok(Some(self.buf.take().freeze()))
+            }
+            line => line,
+        }
+    }
+
     /// Put unprocessed data back to the buffer
     pub fn unprocessed(&mut self, data: Bytes) {
         let buf = BytesMut::from(data);
@@ -849,32 +860,65 @@ mod tests {
         (tx, rx.map_err(|_| panic!()).and_then(|res| res))
     }
 
+    fn create_simple_request_with_header() -> (Bytes, HeaderMap) {
+        let bytes = Bytes::from(
+            "testasdadsad\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+             Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
+             Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
+             test\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+             Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
+             data\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0--\r\n",
+        );
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static(
+                "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
+            ),
+        );
+        (bytes, headers)
+    }
+
+    #[test]
+    fn test_multipart_no_end_crlf() {
+        run_on(|| {
+            let (sender, payload) = create_stream();
+            let (bytes, headers) = create_simple_request_with_header();
+            let bytes_stripped = bytes.slice_to(bytes.len()); // strip crlf
+
+            sender.unbounded_send(Ok(bytes_stripped)).unwrap();
+            drop(sender); // eof
+
+            let mut multipart = Multipart::new(&headers, payload);
+
+            match multipart.poll().unwrap() {
+                Async::Ready(Some(_)) => (),
+                _ => unreachable!(),
+            }
+
+            match multipart.poll().unwrap() {
+                Async::Ready(Some(_)) => (),
+                _ => unreachable!(),
+            }
+
+            match multipart.poll().unwrap() {
+                Async::Ready(None) => (),
+                _ => unreachable!(),
+            }
+        })
+    }
+
     #[test]
     fn test_multipart() {
         run_on(|| {
             let (sender, payload) = create_stream();
+            let (bytes, headers) = create_simple_request_with_header();
 
-            let bytes = Bytes::from(
-                "testasdadsad\r\n\
-                 --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
-                 Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
-                 Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
-                 test\r\n\
-                 --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
-                 Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
-                 data\r\n\
-                 --abbc761f78ff4d7cb7573b5a23f96ef0--\r\n",
-            );
             sender.unbounded_send(Ok(bytes)).unwrap();
 
-            let mut headers = HeaderMap::new();
-            headers.insert(
-                header::CONTENT_TYPE,
-                header::HeaderValue::from_static(
-                    "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
-                ),
-            );
-
             let mut multipart = Multipart::new(&headers, payload);
             match multipart.poll().unwrap() {
                 Async::Ready(Some(mut field)) => {
@@ -925,28 +969,10 @@ mod tests {
     fn test_stream() {
         run_on(|| {
             let (sender, payload) = create_stream();
+            let (bytes, headers) = create_simple_request_with_header();
 
-            let bytes = Bytes::from(
-                "testasdadsad\r\n\
-                 --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
-                 Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
-                 Content-Type: text/plain; charset=utf-8\r\n\r\n\
-                 test\r\n\
-                 --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
-                 Content-Type: text/plain; charset=utf-8\r\n\r\n\
-                 data\r\n\
-                 --abbc761f78ff4d7cb7573b5a23f96ef0--\r\n",
-            );
             sender.unbounded_send(Ok(bytes)).unwrap();
 
-            let mut headers = HeaderMap::new();
-            headers.insert(
-                header::CONTENT_TYPE,
-                header::HeaderValue::from_static(
-                    "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
-                ),
-            );
-
             let mut multipart = Multipart::new(&headers, payload);
             match multipart.poll().unwrap() {
                 Async::Ready(Some(mut field)) => {

awc/CHANGES.md

@@ -1,9 +1,39 @@
 # Changes
 
-## [0.2.3] - 2019-07-xx
+## [0.2.6] - 2019-09-12
+
+### Added
+
+* Export frozen request related types.
+
+
+## [0.2.5] - 2019-09-11
+
+### Added
+
+* Add `FrozenClientRequest` to support retries for sending HTTP requests
+
+### Changed
+
+* Ensure that the `Host` header is set when initiating a WebSocket client connection.
+
+
+## [0.2.4] - 2019-08-13
+
+### Changed
+
+* Update percent-encoding to "2.1"
+
+* Update serde_urlencoded to "0.6.1"
+
+
+## [0.2.3] - 2019-08-01
+
+### Added
 
 * Add `rustls` support
 
+
 ## [0.2.2] - 2019-07-01
 
 ### Changed

awc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "awc"
-version = "0.2.3"
+version = "0.2.6"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http client."
 readme = "README.md"
@@ -44,18 +44,18 @@ flate2-rust = ["actix-http/flate2-rust"]
 [dependencies]
 actix-codec = "0.1.2"
 actix-service = "0.4.1"
-actix-http = "0.2.8"
+actix-http = "0.2.10"
 base64 = "0.10.1"
 bytes = "0.4"
 derive_more = "0.15.0"
 futures = "0.1.25"
 log =" 0.4"
 mime = "0.3"
-percent-encoding = "1.0"
+percent-encoding = "2.1"
 rand = "0.7"
 serde = "1.0"
 serde_json = "1.0"
-serde_urlencoded = "0.5.3"
+serde_urlencoded = "0.6.1"
 tokio-timer = "0.2.8"
 openssl = { version="0.10", optional = true }
 rustls = { version = "0.15.2", optional = true }
@@ -63,7 +63,7 @@ rustls = { version = "0.15.2", optional = true }
 [dev-dependencies]
 actix-rt = "0.2.2"
 actix-web = { version = "1.0.0", features=["ssl"] }
-actix-http = { version = "0.2.4", features=["ssl"] }
+actix-http = { version = "0.2.10", features=["ssl"] }
 actix-http-test = { version = "0.2.0", features=["ssl"] }
 actix-utils = "0.4.1"
 actix-server = { version = "0.6.0", features=["ssl", "rust-tls"] }

awc/src/connect.rs

@@ -1,3 +1,4 @@
+use std::rc::Rc;
 use std::{fmt, io, net};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
@@ -6,7 +7,8 @@ use actix_http::client::{
     Connect as ClientConnect, ConnectError, Connection, SendRequestError,
 };
 use actix_http::h1::ClientCodec;
-use actix_http::{RequestHead, ResponseHead};
+use actix_http::http::HeaderMap;
+use actix_http::{RequestHead, RequestHeadType, ResponseHead};
 use actix_service::Service;
 use futures::{Future, Poll};
 
@@ -22,6 +24,14 @@ pub(crate) trait Connect {
         addr: Option<net::SocketAddr>,
     ) -> Box<dyn Future<Item = ClientResponse, Error = SendRequestError>>;
 
+    fn send_request_extra(
+        &mut self,
+        head: Rc<RequestHead>,
+        extra_headers: Option<HeaderMap>,
+        body: Body,
+        addr: Option<net::SocketAddr>,
+    ) -> Box<dyn Future<Item = ClientResponse, Error = SendRequestError>>;
+
     /// Send request, returns Response and Framed
     fn open_tunnel(
         &mut self,
@@ -33,6 +43,19 @@ pub(crate) trait Connect {
             Error = SendRequestError,
         >,
     >;
+
+    /// Send request and extra headers, returns Response and Framed
+    fn open_tunnel_extra(
+        &mut self,
+        head: Rc<RequestHead>,
+        extra_headers: Option<HeaderMap>,
+        addr: Option<net::SocketAddr>,
+    ) -> Box<
+        dyn Future<
+            Item = (ResponseHead, Framed<BoxedSocket, ClientCodec>),
+            Error = SendRequestError,
+        >,
+    >;
 }
 
 impl<T> Connect for ConnectorWrapper<T>
@@ -59,7 +82,33 @@ where
                 })
                 .from_err()
                 // send request
-                .and_then(move |connection| connection.send_request(head, body))
+                .and_then(move |connection| {
+                    connection.send_request(RequestHeadType::from(head), body)
+                })
+                .map(|(head, payload)| ClientResponse::new(head, payload)),
+        )
+    }
+
+    fn send_request_extra(
+        &mut self,
+        head: Rc<RequestHead>,
+        extra_headers: Option<HeaderMap>,
+        body: Body,
+        addr: Option<net::SocketAddr>,
+    ) -> Box<dyn Future<Item = ClientResponse, Error = SendRequestError>> {
+        Box::new(
+            self.0
+                // connect to the host
+                .call(ClientConnect {
+                    uri: head.uri.clone(),
+                    addr,
+                })
+                .from_err()
+                // send request
+                .and_then(move |connection| {
+                    connection
+                        .send_request(RequestHeadType::Rc(head, extra_headers), body)
+                })
                 .map(|(head, payload)| ClientResponse::new(head, payload)),
         )
     }
@@ -83,7 +132,39 @@ where
                 })
                 .from_err()
                 // send request
-                .and_then(move |connection| connection.open_tunnel(head))
+                .and_then(move |connection| {
+                    connection.open_tunnel(RequestHeadType::from(head))
+                })
+                .map(|(head, framed)| {
+                    let framed = framed.map_io(|io| BoxedSocket(Box::new(Socket(io))));
+                    (head, framed)
+                }),
+        )
+    }
+
+    fn open_tunnel_extra(
+        &mut self,
+        head: Rc<RequestHead>,
+        extra_headers: Option<HeaderMap>,
+        addr: Option<net::SocketAddr>,
+    ) -> Box<
+        dyn Future<
+            Item = (ResponseHead, Framed<BoxedSocket, ClientCodec>),
+            Error = SendRequestError,
+        >,
+    > {
+        Box::new(
+            self.0
+                // connect to the host
+                .call(ClientConnect {
+                    uri: head.uri.clone(),
+                    addr,
+                })
+                .from_err()
+                // send request
+                .and_then(move |connection| {
+                    connection.open_tunnel(RequestHeadType::Rc(head, extra_headers))
+                })
                 .map(|(head, framed)| {
                     let framed = framed.map_io(|io| BoxedSocket(Box::new(Socket(io))));
                     (head, framed)

awc/src/error.rs

@@ -1,5 +1,7 @@
 //! Http client errors
-pub use actix_http::client::{ConnectError, InvalidUrl, SendRequestError};
+pub use actix_http::client::{
+    ConnectError, FreezeRequestError, InvalidUrl, SendRequestError,
+};
 pub use actix_http::error::PayloadError;
 pub use actix_http::ws::HandshakeError as WsHandshakeError;
 pub use actix_http::ws::ProtocolError as WsProtocolError;

awc/src/frozen.rs

@@ -0,0 +1,235 @@
+use std::net;
+use std::rc::Rc;
+use std::time::Duration;
+
+use bytes::Bytes;
+use futures::Stream;
+use serde::Serialize;
+
+use actix_http::body::Body;
+use actix_http::http::header::IntoHeaderValue;
+use actix_http::http::{
+    Error as HttpError, HeaderMap, HeaderName, HttpTryFrom, Method, Uri,
+};
+use actix_http::{Error, RequestHead};
+
+use crate::sender::{RequestSender, SendClientRequest};
+use crate::ClientConfig;
+
+/// `FrozenClientRequest` struct represents clonable client request.
+/// It could be used to send same request multiple times.
+#[derive(Clone)]
+pub struct FrozenClientRequest {
+    pub(crate) head: Rc<RequestHead>,
+    pub(crate) addr: Option<net::SocketAddr>,
+    pub(crate) response_decompress: bool,
+    pub(crate) timeout: Option<Duration>,
+    pub(crate) config: Rc<ClientConfig>,
+}
+
+impl FrozenClientRequest {
+    /// Get HTTP URI of request
+    pub fn get_uri(&self) -> &Uri {
+        &self.head.uri
+    }
+
+    /// Get HTTP method of this request
+    pub fn get_method(&self) -> &Method {
+        &self.head.method
+    }
+
+    /// Returns request's headers.
+    pub fn headers(&self) -> &HeaderMap {
+        &self.head.headers
+    }
+
+    /// Send a body.
+    pub fn send_body<B>(&self, body: B) -> SendClientRequest
+    where
+        B: Into<Body>,
+    {
+        RequestSender::Rc(self.head.clone(), None).send_body(
+            self.addr,
+            self.response_decompress,
+            self.timeout,
+            self.config.as_ref(),
+            body,
+        )
+    }
+
+    /// Send a json body.
+    pub fn send_json<T: Serialize>(&self, value: &T) -> SendClientRequest {
+        RequestSender::Rc(self.head.clone(), None).send_json(
+            self.addr,
+            self.response_decompress,
+            self.timeout,
+            self.config.as_ref(),
+            value,
+        )
+    }
+
+    /// Send an urlencoded body.
+    pub fn send_form<T: Serialize>(&self, value: &T) -> SendClientRequest {
+        RequestSender::Rc(self.head.clone(), None).send_form(
+            self.addr,
+            self.response_decompress,
+            self.timeout,
+            self.config.as_ref(),
+            value,
+        )
+    }
+
+    /// Send a streaming body.
+    pub fn send_stream<S, E>(&self, stream: S) -> SendClientRequest
+    where
+        S: Stream<Item = Bytes, Error = E> + 'static,
+        E: Into<Error> + 'static,
+    {
+        RequestSender::Rc(self.head.clone(), None).send_stream(
+            self.addr,
+            self.response_decompress,
+            self.timeout,
+            self.config.as_ref(),
+            stream,
+        )
+    }
+
+    /// Send an empty body.
+    pub fn send(&self) -> SendClientRequest {
+        RequestSender::Rc(self.head.clone(), None).send(
+            self.addr,
+            self.response_decompress,
+            self.timeout,
+            self.config.as_ref(),
+        )
+    }
+
+    /// Create a `FrozenSendBuilder` with extra headers
+    pub fn extra_headers(&self, extra_headers: HeaderMap) -> FrozenSendBuilder {
+        FrozenSendBuilder::new(self.clone(), extra_headers)
+    }
+
+    /// Create a `FrozenSendBuilder` with an extra header
+    pub fn extra_header<K, V>(&self, key: K, value: V) -> FrozenSendBuilder
+    where
+        HeaderName: HttpTryFrom<K>,
+        V: IntoHeaderValue,
+    {
+        self.extra_headers(HeaderMap::new())
+            .extra_header(key, value)
+    }
+}
+
+/// Builder that allows to modify extra headers.
+pub struct FrozenSendBuilder {
+    req: FrozenClientRequest,
+    extra_headers: HeaderMap,
+    err: Option<HttpError>,
+}
+
+impl FrozenSendBuilder {
+    pub(crate) fn new(req: FrozenClientRequest, extra_headers: HeaderMap) -> Self {
+        Self {
+            req,
+            extra_headers,
+            err: None,
+        }
+    }
+
+    /// Insert a header, it overrides existing header in `FrozenClientRequest`.
+    pub fn extra_header<K, V>(mut self, key: K, value: V) -> Self
+    where
+        HeaderName: HttpTryFrom<K>,
+        V: IntoHeaderValue,
+    {
+        match HeaderName::try_from(key) {
+            Ok(key) => match value.try_into() {
+                Ok(value) => self.extra_headers.insert(key, value),
+                Err(e) => self.err = Some(e.into()),
+            },
+            Err(e) => self.err = Some(e.into()),
+        }
+        self
+    }
+
+    /// Complete request construction and send a body.
+    pub fn send_body<B>(self, body: B) -> SendClientRequest
+    where
+        B: Into<Body>,
+    {
+        if let Some(e) = self.err {
+            return e.into();
+        }
+
+        RequestSender::Rc(self.req.head, Some(self.extra_headers)).send_body(
+            self.req.addr,
+            self.req.response_decompress,
+            self.req.timeout,
+            self.req.config.as_ref(),
+            body,
+        )
+    }
+
+    /// Complete request construction and send a json body.
+    pub fn send_json<T: Serialize>(self, value: &T) -> SendClientRequest {
+        if let Some(e) = self.err {
+            return e.into();
+        }
+
+        RequestSender::Rc(self.req.head, Some(self.extra_headers)).send_json(
+            self.req.addr,
+            self.req.response_decompress,
+            self.req.timeout,
+            self.req.config.as_ref(),
+            value,
+        )
+    }
+
+    /// Complete request construction and send an urlencoded body.
+    pub fn send_form<T: Serialize>(self, value: &T) -> SendClientRequest {
+        if let Some(e) = self.err {
+            return e.into();
+        }
+
+        RequestSender::Rc(self.req.head, Some(self.extra_headers)).send_form(
+            self.req.addr,
+            self.req.response_decompress,
+            self.req.timeout,
+            self.req.config.as_ref(),
+            value,
+        )
+    }
+
+    /// Complete request construction and send a streaming body.
+    pub fn send_stream<S, E>(self, stream: S) -> SendClientRequest
+    where
+        S: Stream<Item = Bytes, Error = E> + 'static,
+        E: Into<Error> + 'static,
+    {
+        if let Some(e) = self.err {
+            return e.into();
+        }
+
+        RequestSender::Rc(self.req.head, Some(self.extra_headers)).send_stream(
+            self.req.addr,
+            self.req.response_decompress,
+            self.req.timeout,
+            self.req.config.as_ref(),
+            stream,
+        )
+    }
+
+    /// Complete request construction and send an empty body.
+    pub fn send(self) -> SendClientRequest {
+        if let Some(e) = self.err {
+            return e.into();
+        }
+
+        RequestSender::Rc(self.req.head, Some(self.extra_headers)).send(
+            self.req.addr,
+            self.req.response_decompress,
+            self.req.timeout,
+            self.req.config.as_ref(),
+        )
+    }
+}

awc/src/lib.rs

@@ -33,15 +33,19 @@ use actix_http::RequestHead;
 mod builder;
 mod connect;
 pub mod error;
+mod frozen;
 mod request;
 mod response;
+mod sender;
 pub mod test;
 pub mod ws;
 
 pub use self::builder::ClientBuilder;
 pub use self::connect::BoxedSocket;
+pub use self::frozen::{FrozenClientRequest, FrozenSendBuilder};
 pub use self::request::ClientRequest;
 pub use self::response::{ClientResponse, JsonBody, MessageBody};
+pub use self::sender::SendClientRequest;
 
 use self::connect::{Connect, ConnectorWrapper};
 

awc/src/request.rs

@@ -5,25 +5,22 @@ use std::time::Duration;
 use std::{fmt, net};
 
 use bytes::{BufMut, Bytes, BytesMut};
-use futures::future::{err, Either};
-use futures::{Future, Stream};
-use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};
+use futures::Stream;
+use percent_encoding::percent_encode;
 use serde::Serialize;
-use serde_json;
-use tokio_timer::Timeout;
 
-use actix_http::body::{Body, BodyStream};
-use actix_http::cookie::{Cookie, CookieJar};
-use actix_http::encoding::Decoder;
-use actix_http::http::header::{self, ContentEncoding, Header, IntoHeaderValue};
+use actix_http::body::Body;
+use actix_http::cookie::{Cookie, CookieJar, USERINFO};
+use actix_http::http::header::{self, Header, IntoHeaderValue};
 use actix_http::http::{
     uri, ConnectionType, Error as HttpError, HeaderMap, HeaderName, HeaderValue,
     HttpTryFrom, Method, Uri, Version,
 };
-use actix_http::{Error, Payload, RequestHead};
+use actix_http::{Error, RequestHead};
 
-use crate::error::{InvalidUrl, PayloadError, SendRequestError};
-use crate::response::ClientResponse;
+use crate::error::{FreezeRequestError, InvalidUrl};
+use crate::frozen::FrozenClientRequest;
+use crate::sender::{PrepForSendingError, RequestSender, SendClientRequest};
 use crate::ClientConfig;
 
 #[cfg(any(feature = "brotli", feature = "flate2-zlib", feature = "flate2-rust"))]
@@ -99,6 +96,11 @@ impl ClientRequest {
         self
     }
 
+    /// Get HTTP URI of request
+    pub fn get_uri(&self) -> &Uri {
+        &self.head.uri
+    }
+
     /// Set socket address of the server.
     ///
     /// This address is used for connection. If address is not
@@ -115,6 +117,11 @@ impl ClientRequest {
         self
     }
 
+    /// Get HTTP method of this request
+    pub fn get_method(&self) -> &Method {
+        &self.head.method
+    }
+
     #[doc(hidden)]
     /// Set HTTP version of this request.
     ///
@@ -365,42 +372,139 @@ impl ClientRequest {
         }
     }
 
+    /// Freeze request builder and construct `FrozenClientRequest`,
+    /// which could be used for sending same request multiple times.
+    pub fn freeze(self) -> Result<FrozenClientRequest, FreezeRequestError> {
+        let slf = match self.prep_for_sending() {
+            Ok(slf) => slf,
+            Err(e) => return Err(e.into()),
+        };
+
+        let request = FrozenClientRequest {
+            head: Rc::new(slf.head),
+            addr: slf.addr,
+            response_decompress: slf.response_decompress,
+            timeout: slf.timeout,
+            config: slf.config,
+        };
+
+        Ok(request)
+    }
+
     /// Complete request construction and send body.
-    pub fn send_body<B>(
-        mut self,
-        body: B,
-    ) -> impl Future<
-        Item = ClientResponse<impl Stream<Item = Bytes, Error = PayloadError>>,
-        Error = SendRequestError,
-    >
+    pub fn send_body<B>(self, body: B) -> SendClientRequest
     where
         B: Into<Body>,
     {
-        if let Some(e) = self.err.take() {
-            return Either::A(err(e.into()));
+        let slf = match self.prep_for_sending() {
+            Ok(slf) => slf,
+            Err(e) => return e.into(),
+        };
+
+        RequestSender::Owned(slf.head).send_body(
+            slf.addr,
+            slf.response_decompress,
+            slf.timeout,
+            slf.config.as_ref(),
+            body,
+        )
+    }
+
+    /// Set a JSON body and generate `ClientRequest`
+    pub fn send_json<T: Serialize>(self, value: &T) -> SendClientRequest {
+        let slf = match self.prep_for_sending() {
+            Ok(slf) => slf,
+            Err(e) => return e.into(),
+        };
+
+        RequestSender::Owned(slf.head).send_json(
+            slf.addr,
+            slf.response_decompress,
+            slf.timeout,
+            slf.config.as_ref(),
+            value,
+        )
+    }
+
+    /// Set a urlencoded body and generate `ClientRequest`
+    ///
+    /// `ClientRequestBuilder` can not be used after this call.
+    pub fn send_form<T: Serialize>(self, value: &T) -> SendClientRequest {
+        let slf = match self.prep_for_sending() {
+            Ok(slf) => slf,
+            Err(e) => return e.into(),
+        };
+
+        RequestSender::Owned(slf.head).send_form(
+            slf.addr,
+            slf.response_decompress,
+            slf.timeout,
+            slf.config.as_ref(),
+            value,
+        )
+    }
+
+    /// Set an streaming body and generate `ClientRequest`.
+    pub fn send_stream<S, E>(self, stream: S) -> SendClientRequest
+    where
+        S: Stream<Item = Bytes, Error = E> + 'static,
+        E: Into<Error> + 'static,
+    {
+        let slf = match self.prep_for_sending() {
+            Ok(slf) => slf,
+            Err(e) => return e.into(),
+        };
+
+        RequestSender::Owned(slf.head).send_stream(
+            slf.addr,
+            slf.response_decompress,
+            slf.timeout,
+            slf.config.as_ref(),
+            stream,
+        )
+    }
+
+    /// Set an empty body and generate `ClientRequest`.
+    pub fn send(self) -> SendClientRequest {
+        let slf = match self.prep_for_sending() {
+            Ok(slf) => slf,
+            Err(e) => return e.into(),
+        };
+
+        RequestSender::Owned(slf.head).send(
+            slf.addr,
+            slf.response_decompress,
+            slf.timeout,
+            slf.config.as_ref(),
+        )
+    }
+
+    fn prep_for_sending(mut self) -> Result<Self, PrepForSendingError> {
+        if let Some(e) = self.err {
+            return Err(e.into());
         }
 
         // validate uri
         let uri = &self.head.uri;
         if uri.host().is_none() {
-            return Either::A(err(InvalidUrl::MissingHost.into()));
+            return Err(InvalidUrl::MissingHost.into());
         } else if uri.scheme_part().is_none() {
-            return Either::A(err(InvalidUrl::MissingScheme.into()));
+            return Err(InvalidUrl::MissingScheme.into());
         } else if let Some(scheme) = uri.scheme_part() {
             match scheme.as_str() {
                 "http" | "ws" | "https" | "wss" => (),
-                _ => return Either::A(err(InvalidUrl::UnknownScheme.into())),
+                _ => return Err(InvalidUrl::UnknownScheme.into()),
             }
         } else {
-            return Either::A(err(InvalidUrl::UnknownScheme.into()));
+            return Err(InvalidUrl::UnknownScheme.into());
         }
 
         // set cookies
         if let Some(ref mut jar) = self.cookies {
             let mut cookie = String::new();
             for c in jar.delta() {
-                let name = percent_encode(c.name().as_bytes(), USERINFO_ENCODE_SET);
-                let value = percent_encode(c.value().as_bytes(), USERINFO_ENCODE_SET);
+                let name = percent_encode(c.name().as_bytes(), USERINFO);
+                let value = percent_encode(c.value().as_bytes(), USERINFO);
                 let _ = write!(&mut cookie, "; {}={}", name, value);
             }
             self.head.headers.insert(
@@ -438,104 +542,7 @@ impl ClientRequest {
             }
         }
 
-        let head = slf.head;
-        let config = slf.config.as_ref();
-        let response_decompress = slf.response_decompress;
-
-        let fut = config
-            .connector
-            .borrow_mut()
-            .send_request(head, body.into(), slf.addr)
-            .map(move |res| {
-                res.map_body(|head, payload| {
-                    if response_decompress {
-                        Payload::Stream(Decoder::from_headers(payload, &head.headers))
-                    } else {
-                        Payload::Stream(Decoder::new(payload, ContentEncoding::Identity))
-                    }
-                })
-            });
-
-        // set request timeout
-        if let Some(timeout) = slf.timeout.or_else(|| config.timeout) {
-            Either::B(Either::A(Timeout::new(fut, timeout).map_err(|e| {
-                if let Some(e) = e.into_inner() {
-                    e
-                } else {
-                    SendRequestError::Timeout
-                }
-            })))
-        } else {
-            Either::B(Either::B(fut))
-        }
-    }
-
-    /// Set a JSON body and generate `ClientRequest`
-    pub fn send_json<T: Serialize>(
-        self,
-        value: &T,
-    ) -> impl Future<
-        Item = ClientResponse<impl Stream<Item = Bytes, Error = PayloadError>>,
-        Error = SendRequestError,
-    > {
-        let body = match serde_json::to_string(value) {
-            Ok(body) => body,
-            Err(e) => return Either::A(err(Error::from(e).into())),
-        };
-
-        // set content-type
-        let slf = self.set_header_if_none(header::CONTENT_TYPE, "application/json");
-
-        Either::B(slf.send_body(Body::Bytes(Bytes::from(body))))
-    }
-
-    /// Set a urlencoded body and generate `ClientRequest`
-    ///
-    /// `ClientRequestBuilder` can not be used after this call.
-    pub fn send_form<T: Serialize>(
-        self,
-        value: &T,
-    ) -> impl Future<
-        Item = ClientResponse<impl Stream<Item = Bytes, Error = PayloadError>>,
-        Error = SendRequestError,
-    > {
-        let body = match serde_urlencoded::to_string(value) {
-            Ok(body) => body,
-            Err(e) => return Either::A(err(Error::from(e).into())),
-        };
-
-        // set content-type
-        let slf = self.set_header_if_none(
-            header::CONTENT_TYPE,
-            "application/x-www-form-urlencoded",
-        );
-
-        Either::B(slf.send_body(Body::Bytes(Bytes::from(body))))
-    }
-
-    /// Set an streaming body and generate `ClientRequest`.
-    pub fn send_stream<S, E>(
-        self,
-        stream: S,
-    ) -> impl Future<
-        Item = ClientResponse<impl Stream<Item = Bytes, Error = PayloadError>>,
-        Error = SendRequestError,
-    >
-    where
-        S: Stream<Item = Bytes, Error = E> + 'static,
-        E: Into<Error> + 'static,
-    {
-        self.send_body(Body::from_message(BodyStream::new(stream)))
-    }
-
-    /// Set an empty body and generate `ClientRequest`.
-    pub fn send(
-        self,
-    ) -> impl Future<
-        Item = ClientResponse<impl Stream<Item = Bytes, Error = PayloadError>>,
-        Error = SendRequestError,
-    > {
-        self.send_body(Body::Empty)
+        Ok(slf)
     }
 }
 

awc/src/sender.rs

@@ -0,0 +1,282 @@
+use std::net;
+use std::rc::Rc;
+use std::time::{Duration, Instant};
+
+use bytes::Bytes;
+use derive_more::From;
+use futures::{try_ready, Async, Future, Poll, Stream};
+use serde::Serialize;
+use serde_json;
+use tokio_timer::Delay;
+
+use actix_http::body::{Body, BodyStream};
+use actix_http::encoding::Decoder;
+use actix_http::http::header::{self, ContentEncoding, IntoHeaderValue};
+use actix_http::http::{Error as HttpError, HeaderMap, HeaderName};
+use actix_http::{Error, Payload, PayloadStream, RequestHead};
+
+use crate::error::{FreezeRequestError, InvalidUrl, SendRequestError};
+use crate::response::ClientResponse;
+use crate::ClientConfig;
+
+#[derive(Debug, From)]
+pub(crate) enum PrepForSendingError {
+    Url(InvalidUrl),
+    Http(HttpError),
+}
+
+impl Into<FreezeRequestError> for PrepForSendingError {
+    fn into(self) -> FreezeRequestError {
+        match self {
+            PrepForSendingError::Url(e) => FreezeRequestError::Url(e),
+            PrepForSendingError::Http(e) => FreezeRequestError::Http(e),
+        }
+    }
+}
+
+impl Into<SendRequestError> for PrepForSendingError {
+    fn into(self) -> SendRequestError {
+        match self {
+            PrepForSendingError::Url(e) => SendRequestError::Url(e),
+            PrepForSendingError::Http(e) => SendRequestError::Http(e),
+        }
+    }
+}
+
+/// Future that sends request's payload and resolves to a server response.
+#[must_use = "futures do nothing unless polled"]
+pub enum SendClientRequest {
+    Fut(
+        Box<dyn Future<Item = ClientResponse, Error = SendRequestError>>,
+        Option<Delay>,
+        bool,
+    ),
+    Err(Option<SendRequestError>),
+}
+
+impl SendClientRequest {
+    pub(crate) fn new(
+        send: Box<dyn Future<Item = ClientResponse, Error = SendRequestError>>,
+        response_decompress: bool,
+        timeout: Option<Duration>,
+    ) -> SendClientRequest {
+        let delay = timeout.map(|t| Delay::new(Instant::now() + t));
+        SendClientRequest::Fut(send, delay, response_decompress)
+    }
+}
+
+impl Future for SendClientRequest {
+    type Item = ClientResponse<Decoder<Payload<PayloadStream>>>;
+    type Error = SendRequestError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self {
+            SendClientRequest::Fut(send, delay, response_decompress) => {
+                if delay.is_some() {
+                    match delay.poll() {
+                        Ok(Async::NotReady) => (),
+                        _ => return Err(SendRequestError::Timeout),
+                    }
+                }
+
+                let res = try_ready!(send.poll()).map_body(|head, payload| {
+                    if *response_decompress {
+                        Payload::Stream(Decoder::from_headers(payload, &head.headers))
+                    } else {
+                        Payload::Stream(Decoder::new(payload, ContentEncoding::Identity))
+                    }
+                });
+
+                Ok(Async::Ready(res))
+            }
+            SendClientRequest::Err(ref mut e) => match e.take() {
+                Some(e) => Err(e),
+                None => panic!("Attempting to call completed future"),
+            },
+        }
+    }
+}
+
+impl From<SendRequestError> for SendClientRequest {
+    fn from(e: SendRequestError) -> Self {
+        SendClientRequest::Err(Some(e))
+    }
+}
+
+impl From<Error> for SendClientRequest {
+    fn from(e: Error) -> Self {
+        SendClientRequest::Err(Some(e.into()))
+    }
+}
+
+impl From<HttpError> for SendClientRequest {
+    fn from(e: HttpError) -> Self {
+        SendClientRequest::Err(Some(e.into()))
+    }
+}
+
+impl From<PrepForSendingError> for SendClientRequest {
+    fn from(e: PrepForSendingError) -> Self {
+        SendClientRequest::Err(Some(e.into()))
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum RequestSender {
+    Owned(RequestHead),
+    Rc(Rc<RequestHead>, Option<HeaderMap>),
+}
+
+impl RequestSender {
+    pub(crate) fn send_body<B>(
+        self,
+        addr: Option<net::SocketAddr>,
+        response_decompress: bool,
+        timeout: Option<Duration>,
+        config: &ClientConfig,
+        body: B,
+    ) -> SendClientRequest
+    where
+        B: Into<Body>,
+    {
+        let mut connector = config.connector.borrow_mut();
+
+        let fut = match self {
+            RequestSender::Owned(head) => {
+                connector.send_request(head, body.into(), addr)
+            }
+            RequestSender::Rc(head, extra_headers) => {
+                connector.send_request_extra(head, extra_headers, body.into(), addr)
+            }
+        };
+
+        SendClientRequest::new(
+            fut,
+            response_decompress,
+            timeout.or_else(|| config.timeout),
+        )
+    }
+
+    pub(crate) fn send_json<T: Serialize>(
+        mut self,
+        addr: Option<net::SocketAddr>,
+        response_decompress: bool,
+        timeout: Option<Duration>,
+        config: &ClientConfig,
+        value: &T,
+    ) -> SendClientRequest {
+        let body = match serde_json::to_string(value) {
+            Ok(body) => body,
+            Err(e) => return Error::from(e).into(),
+        };
+
+        if let Err(e) = self.set_header_if_none(header::CONTENT_TYPE, "application/json")
+        {
+            return e.into();
+        }
+
+        self.send_body(
+            addr,
+            response_decompress,
+            timeout,
+            config,
+            Body::Bytes(Bytes::from(body)),
+        )
+    }
+
+    pub(crate) fn send_form<T: Serialize>(
+        mut self,
+        addr: Option<net::SocketAddr>,
+        response_decompress: bool,
+        timeout: Option<Duration>,
+        config: &ClientConfig,
+        value: &T,
+    ) -> SendClientRequest {
+        let body = match serde_urlencoded::to_string(value) {
+            Ok(body) => body,
+            Err(e) => return Error::from(e).into(),
+        };
+
+        // set content-type
+        if let Err(e) = self.set_header_if_none(
+            header::CONTENT_TYPE,
+            "application/x-www-form-urlencoded",
+        ) {
+            return e.into();
+        }
+
+        self.send_body(
+            addr,
+            response_decompress,
+            timeout,
+            config,
+            Body::Bytes(Bytes::from(body)),
+        )
+    }
+
+    pub(crate) fn send_stream<S, E>(
+        self,
+        addr: Option<net::SocketAddr>,
+        response_decompress: bool,
+        timeout: Option<Duration>,
+        config: &ClientConfig,
+        stream: S,
+    ) -> SendClientRequest
+    where
+        S: Stream<Item = Bytes, Error = E> + 'static,
+        E: Into<Error> + 'static,
+    {
+        self.send_body(
+            addr,
+            response_decompress,
+            timeout,
+            config,
+            Body::from_message(BodyStream::new(stream)),
+        )
+    }
+
+    pub(crate) fn send(
+        self,
+        addr: Option<net::SocketAddr>,
+        response_decompress: bool,
+        timeout: Option<Duration>,
+        config: &ClientConfig,
+    ) -> SendClientRequest {
+        self.send_body(addr, response_decompress, timeout, config, Body::Empty)
+    }
+
+    fn set_header_if_none<V>(
+        &mut self,
+        key: HeaderName,
+        value: V,
+    ) -> Result<(), HttpError>
+    where
+        V: IntoHeaderValue,
+    {
+        match self {
+            RequestSender::Owned(head) => {
+                if !head.headers.contains_key(&key) {
+                    match value.try_into() {
+                        Ok(value) => head.headers.insert(key, value),
+                        Err(e) => return Err(e.into()),
+                    }
+                }
+            }
+            RequestSender::Rc(head, extra_headers) => {
+                if !head.headers.contains_key(&key)
+                    && !extra_headers.iter().any(|h| h.contains_key(&key))
+                {
+                    match value.try_into() {
+                        Ok(v) => {
+                            let h = extra_headers.get_or_insert(HeaderMap::new());
+                            h.insert(key, v)
+                        }
+                        Err(e) => return Err(e.into()),
+                    };
+                }
+            }
+        }
+
+        Ok(())
+    }
+}

awc/src/test.rs

@@ -1,12 +1,12 @@
 //! Test helpers for actix http client to use during testing.
 use std::fmt::Write as FmtWrite;
 
-use actix_http::cookie::{Cookie, CookieJar};
+use actix_http::cookie::{Cookie, CookieJar, USERINFO};
 use actix_http::http::header::{self, Header, HeaderValue, IntoHeaderValue};
 use actix_http::http::{HeaderName, HttpTryFrom, StatusCode, Version};
 use actix_http::{h1, Payload, ResponseHead};
 use bytes::Bytes;
-use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};
+use percent_encoding::percent_encode;
 
 use crate::ClientResponse;
 
@@ -87,8 +87,8 @@ impl TestResponse {
 
         let mut cookie = String::new();
         for c in self.cookies.delta() {
-            let name = percent_encode(c.name().as_bytes(), USERINFO_ENCODE_SET);
-            let value = percent_encode(c.value().as_bytes(), USERINFO_ENCODE_SET);
+            let name = percent_encode(c.name().as_bytes(), USERINFO);
+            let value = percent_encode(c.value().as_bytes(), USERINFO);
             let _ = write!(&mut cookie, "; {}={}", name, value);
         }
         if !cookie.is_empty() {

awc/src/ws.rs

@@ -8,9 +8,10 @@ use actix_codec::Framed;
 use actix_http::cookie::{Cookie, CookieJar};
 use actix_http::{ws, Payload, RequestHead};
 use futures::future::{err, Either, Future};
-use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};
+use percent_encoding::percent_encode;
 use tokio_timer::Timeout;
 
+use actix_http::cookie::USERINFO;
 pub use actix_http::ws::{CloseCode, CloseReason, Codec, Frame, Message};
 
 use crate::connect::BoxedSocket;
@@ -232,12 +233,19 @@ impl WebsocketsRequest {
             return Either::A(err(InvalidUrl::UnknownScheme.into()));
         }
 
+        if !self.head.headers.contains_key(header::HOST) {
+            self.head.headers.insert(
+                header::HOST,
+                HeaderValue::from_str(uri.host().unwrap()).unwrap(),
+            );
+        }
+
         // set cookies
         if let Some(ref mut jar) = self.cookies {
             let mut cookie = String::new();
             for c in jar.delta() {
-                let name = percent_encode(c.name().as_bytes(), USERINFO_ENCODE_SET);
-                let value = percent_encode(c.value().as_bytes(), USERINFO_ENCODE_SET);
+                let name = percent_encode(c.name().as_bytes(), USERINFO);
+                let value = percent_encode(c.value().as_bytes(), USERINFO);
                 let _ = write!(&mut cookie, "; {}={}", name, value);
             }
             self.head.headers.insert(

src/app_service.rs

@@ -169,7 +169,7 @@ where
             match self.data_factories_fut[idx].poll()? {
                 Async::Ready(f) => {
                     self.data_factories.push(f);
-                    self.data_factories_fut.remove(idx);
+                    let _ = self.data_factories_fut.remove(idx);
                 }
                 Async::NotReady => idx += 1,
             }

src/data.rs

@@ -77,6 +77,11 @@ impl<T> Data<T> {
     pub fn get_ref(&self) -> &T {
         self.0.as_ref()
     }
+
+    /// Convert to the internal Arc<T>
+    pub fn into_inner(self) -> Arc<T> {
+        self.0
+    }
 }
 
 impl<T> Deref for Data<T> {

src/error.rs

@@ -32,8 +32,12 @@ pub enum UrlencodedError {
     #[display(fmt = "Can not decode chunked transfer encoding")]
     Chunked,
     /// Payload size is bigger than allowed. (default: 256kB)
-    #[display(fmt = "Urlencoded payload size is bigger than allowed (default: 256kB)")]
-    Overflow,
+    #[display(
+        fmt = "Urlencoded payload size is bigger ({} bytes) than allowed (default: {} bytes)",
+        size,
+        limit
+    )]
+    Overflow { size: usize, limit: usize },
     /// Payload size is now known
     #[display(fmt = "Payload size is now known")]
     UnknownLength,
@@ -52,7 +56,7 @@ pub enum UrlencodedError {
 impl ResponseError for UrlencodedError {
     fn error_response(&self) -> HttpResponse {
         match *self {
-            UrlencodedError::Overflow => {
+            UrlencodedError::Overflow { .. } => {
                 HttpResponse::new(StatusCode::PAYLOAD_TOO_LARGE)
             }
             UrlencodedError::UnknownLength => {
@@ -164,7 +168,8 @@ mod tests {
 
     #[test]
     fn test_urlencoded_error() {
-        let resp: HttpResponse = UrlencodedError::Overflow.error_response();
+        let resp: HttpResponse =
+            UrlencodedError::Overflow { size: 0, limit: 0 }.error_response();
         assert_eq!(resp.status(), StatusCode::PAYLOAD_TOO_LARGE);
         let resp: HttpResponse = UrlencodedError::UnknownLength.error_response();
         assert_eq!(resp.status(), StatusCode::LENGTH_REQUIRED);

src/middleware/condition.rs

@@ -0,0 +1,143 @@
+//! `Middleware` for conditionally enables another middleware.
+use actix_service::{Service, Transform};
+use futures::future::{ok, Either, FutureResult, Map};
+use futures::{Future, Poll};
+
+/// `Middleware` for conditionally enables another middleware.
+/// The controled middleware must not change the `Service` interfaces.
+/// This means you cannot control such middlewares like `Logger` or `Compress`.
+///
+/// ## Usage
+///
+/// ```rust
+/// use actix_web::middleware::{Condition, NormalizePath};
+/// use actix_web::App;
+///
+/// fn main() {
+///     let enable_normalize = std::env::var("NORMALIZE_PATH") == Ok("true".into());
+///     let app = App::new()
+///         .wrap(Condition::new(enable_normalize, NormalizePath));
+/// }
+/// ```
+pub struct Condition<T> {
+    trans: T,
+    enable: bool,
+}
+
+impl<T> Condition<T> {
+    pub fn new(enable: bool, trans: T) -> Self {
+        Self { trans, enable }
+    }
+}
+
+impl<S, T> Transform<S> for Condition<T>
+where
+    S: Service,
+    T: Transform<S, Request = S::Request, Response = S::Response, Error = S::Error>,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type InitError = T::InitError;
+    type Transform = ConditionMiddleware<T::Transform, S>;
+    type Future = Either<
+        Map<T::Future, fn(T::Transform) -> Self::Transform>,
+        FutureResult<Self::Transform, Self::InitError>,
+    >;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        if self.enable {
+            let f = self
+                .trans
+                .new_transform(service)
+                .map(ConditionMiddleware::Enable as fn(T::Transform) -> Self::Transform);
+            Either::A(f)
+        } else {
+            Either::B(ok(ConditionMiddleware::Disable(service)))
+        }
+    }
+}
+
+pub enum ConditionMiddleware<E, D> {
+    Enable(E),
+    Disable(D),
+}
+
+impl<E, D> Service for ConditionMiddleware<E, D>
+where
+    E: Service,
+    D: Service<Request = E::Request, Response = E::Response, Error = E::Error>,
+{
+    type Request = E::Request;
+    type Response = E::Response;
+    type Error = E::Error;
+    type Future = Either<E::Future, D::Future>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        use ConditionMiddleware::*;
+        match self {
+            Enable(service) => service.poll_ready(),
+            Disable(service) => service.poll_ready(),
+        }
+    }
+
+    fn call(&mut self, req: E::Request) -> Self::Future {
+        use ConditionMiddleware::*;
+        match self {
+            Enable(service) => Either::A(service.call(req)),
+            Disable(service) => Either::B(service.call(req)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use actix_service::IntoService;
+
+    use super::*;
+    use crate::dev::{ServiceRequest, ServiceResponse};
+    use crate::error::Result;
+    use crate::http::{header::CONTENT_TYPE, HeaderValue, StatusCode};
+    use crate::middleware::errhandlers::*;
+    use crate::test::{self, TestRequest};
+    use crate::HttpResponse;
+
+    fn render_500<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
+        res.response_mut()
+            .headers_mut()
+            .insert(CONTENT_TYPE, HeaderValue::from_static("0001"));
+        Ok(ErrorHandlerResponse::Response(res))
+    }
+
+    #[test]
+    fn test_handler_enabled() {
+        let srv = |req: ServiceRequest| {
+            req.into_response(HttpResponse::InternalServerError().finish())
+        };
+
+        let mw =
+            ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, render_500);
+
+        let mut mw =
+            test::block_on(Condition::new(true, mw).new_transform(srv.into_service()))
+                .unwrap();
+        let resp = test::call_service(&mut mw, TestRequest::default().to_srv_request());
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
+    }
+    #[test]
+    fn test_handler_disabled() {
+        let srv = |req: ServiceRequest| {
+            req.into_response(HttpResponse::InternalServerError().finish())
+        };
+
+        let mw =
+            ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, render_500);
+
+        let mut mw =
+            test::block_on(Condition::new(false, mw).new_transform(srv.into_service()))
+                .unwrap();
+
+        let resp = test::call_service(&mut mw, TestRequest::default().to_srv_request());
+        assert_eq!(resp.headers().get(CONTENT_TYPE), None);
+    }
+}

src/middleware/mod.rs

@@ -2,11 +2,13 @@
 mod compress;
 pub use self::compress::{BodyEncoding, Compress};
 
+mod condition;
 mod defaultheaders;
 pub mod errhandlers;
 mod logger;
 mod normalize;
 
+pub use self::condition::Condition;
 pub use self::defaultheaders::DefaultHeaders;
 pub use self::logger::Logger;
 pub use self::normalize::NormalizePath;

src/middleware/normalize.rs

@@ -151,5 +151,4 @@ mod tests {
         let res = block_on(normalize.call(req)).unwrap();
         assert!(res.status().is_success());
     }
-
 }

src/request.rs

@@ -259,6 +259,7 @@ impl Drop for HttpRequest {
         if Rc::strong_count(&self.0) == 1 {
             let v = &mut self.0.pool.0.borrow_mut();
             if v.len() < 128 {
+                self.extensions_mut().clear();
                 v.push(self.0.clone());
             }
         }
@@ -494,4 +495,38 @@ mod tests {
         let resp = call_service(&mut srv, req);
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
     }
+
+    #[test]
+    fn test_extensions_dropped() {
+        struct Tracker {
+            pub dropped: bool,
+        }
+        struct Foo {
+            tracker: Rc<RefCell<Tracker>>,
+        }
+        impl Drop for Foo {
+            fn drop(&mut self) {
+                self.tracker.borrow_mut().dropped = true;
+            }
+        }
+
+        let tracker = Rc::new(RefCell::new(Tracker { dropped: false }));
+        {
+            let tracker2 = Rc::clone(&tracker);
+            let mut srv = init_service(App::new().data(10u32).service(
+                web::resource("/").to(move |req: HttpRequest| {
+                    req.extensions_mut().insert(Foo {
+                        tracker: Rc::clone(&tracker2),
+                    });
+                    HttpResponse::Ok()
+                }),
+            ));
+
+            let req = TestRequest::default().to_request();
+            let resp = call_service(&mut srv, req);
+            assert_eq!(resp.status(), StatusCode::OK);
+        }
+
+        assert!(tracker.borrow().dropped);
+    }
 }

src/resource.rs

@@ -763,5 +763,4 @@ mod tests {
         let resp = call_service(&mut srv, req);
         assert_eq!(resp.status(), StatusCode::NO_CONTENT);
     }
-
 }

src/service.rs

@@ -68,6 +68,34 @@ impl ServiceRequest {
         (self.0, pl)
     }
 
+    /// Construct request from parts.
+    ///
+    /// `ServiceRequest` can be re-constructed only if `req` hasnt been cloned.
+    pub fn from_parts(
+        mut req: HttpRequest,
+        pl: Payload,
+    ) -> Result<Self, (HttpRequest, Payload)> {
+        if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
+            Rc::get_mut(&mut req.0).unwrap().payload = pl;
+            Ok(ServiceRequest(req))
+        } else {
+            Err((req, pl))
+        }
+    }
+
+    /// Construct request from request.
+    ///
+    /// `HttpRequest` implements `Clone` trait via `Rc` type. `ServiceRequest`
+    /// can be re-constructed only if rc's strong pointers count eq 1 and
+    /// weak pointers count is 0.
+    pub fn from_request(req: HttpRequest) -> Result<Self, HttpRequest> {
+        if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
+            Ok(ServiceRequest(req))
+        } else {
+            Err(req)
+        }
+    }
+
     /// Create service response
     #[inline]
     pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> ServiceResponse<B> {
@@ -514,6 +542,27 @@ mod tests {
     use crate::test::{call_service, init_service, TestRequest};
     use crate::{guard, http, web, App, HttpResponse};
 
+    #[test]
+    fn test_service_request() {
+        let req = TestRequest::default().to_srv_request();
+        let (r, pl) = req.into_parts();
+        assert!(ServiceRequest::from_parts(r, pl).is_ok());
+
+        let req = TestRequest::default().to_srv_request();
+        let (r, pl) = req.into_parts();
+        let _r2 = r.clone();
+        assert!(ServiceRequest::from_parts(r, pl).is_err());
+
+        let req = TestRequest::default().to_srv_request();
+        let (r, _pl) = req.into_parts();
+        assert!(ServiceRequest::from_request(r).is_ok());
+
+        let req = TestRequest::default().to_srv_request();
+        let (r, _pl) = req.into_parts();
+        let _r2 = r.clone();
+        assert!(ServiceRequest::from_request(r).is_err());
+    }
+
     #[test]
     fn test_service() {
         let mut srv = init_service(

src/test.rs

@@ -478,6 +478,16 @@ impl TestRequest {
         self
     }
 
+    /// Serialize `data` to a URL encoded form and set it as the request payload. The `Content-Type`
+    /// header is set to `application/x-www-form-urlencoded`.
+    pub fn set_form<T: Serialize>(mut self, data: &T) -> Self {
+        let bytes = serde_urlencoded::to_string(data)
+            .expect("Failed to serialize test data as a urlencoded form");
+        self.req.set_payload(bytes);
+        self.req.set(ContentType::form_url_encoded());
+        self
+    }
+
     /// Serialize `data` to JSON and set it as the request payload. The `Content-Type` header is
     /// set to `application/json`.
     pub fn set_json<T: Serialize>(mut self, data: &T) -> Self {
@@ -670,6 +680,31 @@ mod tests {
         assert_eq!(&result.id, "12345");
     }
 
+    #[test]
+    fn test_request_response_form() {
+        let mut app = init_service(App::new().service(web::resource("/people").route(
+            web::post().to(|person: web::Form<Person>| {
+                HttpResponse::Ok().json(person.into_inner())
+            }),
+        )));
+
+        let payload = Person {
+            id: "12345".to_string(),
+            name: "User name".to_string(),
+        };
+
+        let req = TestRequest::post()
+            .uri("/people")
+            .set_form(&payload)
+            .to_request();
+
+        assert_eq!(req.content_type(), "application/x-www-form-urlencoded");
+
+        let result: Person = read_response_json(&mut app, req);
+        assert_eq!(&result.id, "12345");
+        assert_eq!(&result.name, "User name");
+    }
+
     #[test]
     fn test_request_response_json() {
         let mut app = init_service(App::new().service(web::resource("/people").route(

src/types/form.rs

@@ -318,7 +318,7 @@ where
         let limit = self.limit;
         if let Some(len) = self.length.take() {
             if len > limit {
-                return Err(UrlencodedError::Overflow);
+                return Err(UrlencodedError::Overflow { size: len, limit });
             }
         }
 
@@ -331,7 +331,10 @@ where
             .from_err()
             .fold(BytesMut::with_capacity(8192), move |mut body, chunk| {
                 if (body.len() + chunk.len()) > limit {
-                    Err(UrlencodedError::Overflow)
+                    Err(UrlencodedError::Overflow {
+                        size: body.len() + chunk.len(),
+                        limit,
+                    })
                 } else {
                     body.extend_from_slice(&chunk);
                     Ok(body)
@@ -390,8 +393,8 @@ mod tests {
 
     fn eq(err: UrlencodedError, other: UrlencodedError) -> bool {
         match err {
-            UrlencodedError::Overflow => match other {
-                UrlencodedError::Overflow => true,
+            UrlencodedError::Overflow { .. } => match other {
+                UrlencodedError::Overflow { .. } => true,
                 _ => false,
             },
             UrlencodedError::UnknownLength => match other {
@@ -420,7 +423,10 @@ mod tests {
                 .header(CONTENT_LENGTH, "1000000")
                 .to_http_parts();
         let info = block_on(UrlEncoded::<Info>::new(&req, &mut pl));
-        assert!(eq(info.err().unwrap(), UrlencodedError::Overflow));
+        assert!(eq(
+            info.err().unwrap(),
+            UrlencodedError::Overflow { size: 0, limit: 0 }
+        ));
 
         let (req, mut pl) = TestRequest::with_header(CONTENT_TYPE, "text/plain")
             .header(CONTENT_LENGTH, "10")
@@ -482,5 +488,4 @@ mod tests {
         use crate::responder::tests::BodyTest;
         assert_eq!(resp.body().bin_ref(), b"hello=world&counter=123");
     }
-
 }

test-server/CHANGES.md

@@ -1,5 +1,16 @@
 # Changes
 
+## [0.2.5] - 2019-0917
+
+### Changed
+
+* Update serde_urlencoded to "0.6.1"
+
+### Fixed
+
+* Do not override current `System`
+
+
 ## [0.2.4] - 2019-07-18
 
 * Update actix-server to 0.6

test-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http-test"
-version = "0.2.4"
+version = "0.2.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http test server"
 readme = "README.md"
@@ -35,7 +35,7 @@ actix-rt = "0.2.2"
 actix-service = "0.4.1"
 actix-server = "0.6.0"
 actix-utils = "0.4.1"
-awc = "0.2.2"
+awc = "0.2.6"
 actix-connect = "0.2.2"
 
 base64 = "0.10"
@@ -49,12 +49,12 @@ serde = "1.0"
 serde_json = "1.0"
 sha1 = "0.6"
 slab = "0.4"
-serde_urlencoded = "0.5.3"
+serde_urlencoded = "0.6.1"
 time = "0.1"
 tokio-tcp = "0.1"
 tokio-timer = "0.2"
 openssl = { version="0.10", optional = true }
 
 [dev-dependencies]
-actix-web = "1.0.0"
-actix-http = "0.2.4"
+actix-web = "1.0.7"
+actix-http = "0.2.9"

test-server/src/lib.rs

@@ -103,8 +103,8 @@ pub struct TestServer;
 /// Test server controller
 pub struct TestServerRuntime {
     addr: net::SocketAddr,
-    rt: Runtime,
     client: Client,
+    system: System,
 }
 
 impl TestServer {
@@ -130,45 +130,47 @@ impl TestServer {
         });
 
         let (system, addr) = rx.recv().unwrap();
-        let mut rt = Runtime::new().unwrap();
 
-        let client = rt
-            .block_on(lazy(move || {
-                let connector = {
-                    #[cfg(feature = "ssl")]
-                    {
-                        use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
+        let client = block_on(lazy(move || {
+            let connector = {
+                #[cfg(feature = "ssl")]
+                {
+                    use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
 
-                        let mut builder =
-                            SslConnector::builder(SslMethod::tls()).unwrap();
-                        builder.set_verify(SslVerifyMode::NONE);
-                        let _ = builder.set_alpn_protos(b"\x02h2\x08http/1.1").map_err(
-                            |e| log::error!("Can not set alpn protocol: {:?}", e),
-                        );
-                        Connector::new()
-                            .conn_lifetime(time::Duration::from_secs(0))
-                            .timeout(time::Duration::from_millis(500))
-                            .ssl(builder.build())
-                            .finish()
-                    }
-                    #[cfg(not(feature = "ssl"))]
-                    {
-                        Connector::new()
-                            .conn_lifetime(time::Duration::from_secs(0))
-                            .timeout(time::Duration::from_millis(500))
-                            .finish()
-                    }
-                };
+                    let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
+                    builder.set_verify(SslVerifyMode::NONE);
+                    let _ = builder
+                        .set_alpn_protos(b"\x02h2\x08http/1.1")
+                        .map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
+                    Connector::new()
+                        .conn_lifetime(time::Duration::from_secs(0))
+                        .timeout(time::Duration::from_millis(500))
+                        .ssl(builder.build())
+                        .finish()
+                }
+                #[cfg(not(feature = "ssl"))]
+                {
+                    Connector::new()
+                        .conn_lifetime(time::Duration::from_secs(0))
+                        .timeout(time::Duration::from_millis(500))
+                        .finish()
+                }
+            };
 
-                Ok::<Client, ()>(Client::build().connector(connector).finish())
-            }))
-            .unwrap();
-        rt.block_on(lazy(
+            Ok::<Client, ()>(Client::build().connector(connector).finish())
+        }))
+        .unwrap();
+
+        block_on(lazy(
             || Ok::<_, ()>(actix_connect::start_default_resolver()),
         ))
         .unwrap();
-        System::set_current(system);
-        TestServerRuntime { addr, rt, client }
+
+        TestServerRuntime {
+            addr,
+            client,
+            system,
+        }
     }
 
     /// Get first available unused address
@@ -188,7 +190,7 @@ impl TestServerRuntime {
     where
         F: Future<Item = I, Error = E>,
     {
-        self.rt.block_on(fut)
+        block_on(fut)
     }
 
     /// Execute future on current core
@@ -197,7 +199,7 @@ impl TestServerRuntime {
         F: FnOnce() -> R,
         R: Future,
     {
-        self.rt.block_on(lazy(f))
+        block_on(lazy(f))
     }
 
     /// Execute function on current core
@@ -205,7 +207,7 @@ impl TestServerRuntime {
     where
         F: FnOnce() -> R,
     {
-        self.rt.block_on(lazy(|| Ok::<_, ()>(fut()))).unwrap()
+        block_on(lazy(|| Ok::<_, ()>(fut()))).unwrap()
     }
 
     /// Construct test server url
@@ -324,8 +326,7 @@ impl TestServerRuntime {
     {
         let url = self.url(path);
         let connect = self.client.ws(url).connect();
-        self.rt
-            .block_on(lazy(move || connect.map(|(_, framed)| framed)))
+        block_on(lazy(move || connect.map(|(_, framed)| framed)))
     }
 
     /// Connect to a websocket server
@@ -338,7 +339,7 @@ impl TestServerRuntime {
 
     /// Stop http server
     fn stop(&mut self) {
-        System::current().stop();
+        self.system.stop();
     }
 }