Merge pull request #1494 from JohnTitor/new-actors

actors: Bump up to 3.0.0-alpha.1

.github/workflows/bench.yml

@@ -16,32 +16,7 @@ jobs:
           profile: minimal
           override: true
 
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
-      - name: Cache cargo registry
-        uses: actions/cache@v1
-        with:
-          path: ~/.cargo/registry
-          key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-registry-trimmed-${{ hashFiles('**/Cargo.lock') }}
-      - name: Cache cargo index
-        uses: actions/cache@v1
-        with:
-          path: ~/.cargo/git
-          key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-index-trimmed-${{ hashFiles('**/Cargo.lock') }}
-      - name: Cache cargo build
-        uses: actions/cache@v1
-        with:
-          path: target
-          key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-build-trimmed-${{ hashFiles('**/Cargo.lock') }}
-
       - name: Check benchmark
         uses: actions-rs/cargo@v1
         with:
           command: bench
-
-      - name: Clear the cargo caches
-        run: |
-          cargo install cargo-cache --no-default-features --features ci-autoclean
-          cargo-cache

.github/workflows/linux.yml

@@ -25,26 +25,6 @@ jobs:
           profile: minimal
           override: true
 
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
-      - name: Cache cargo registry
-        uses: actions/cache@v1
-        with:
-          path: ~/.cargo/registry
-          key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-registry-trimmed-${{ hashFiles('**/Cargo.lock') }}
-      - name: Cache cargo index
-        uses: actions/cache@v1
-        with:
-          path: ~/.cargo/git
-          key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-index-trimmed-${{ hashFiles('**/Cargo.lock') }}
-      - name: Cache cargo build
-        uses: actions/cache@v1
-        with:
-          path: target
-          key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-build-trimmed-${{ hashFiles('**/Cargo.lock') }}
-
       - name: check build
         uses: actions-rs/cargo@v1
         with:
@@ -73,18 +53,12 @@ jobs:
           args: --package=awc --no-default-features --features=rustls -- --nocapture
 
       - name: Generate coverage file
-        if: matrix.version == 'stable' && github.ref == 'refs/heads/master'
+        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
         run: |
           cargo install cargo-tarpaulin
           cargo tarpaulin --out Xml
       - name: Upload to Codecov
-        if: matrix.version == 'stable' && github.ref == 'refs/heads/master'
+        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
         uses: codecov/codecov-action@v1
         with:
-          token: ${{ secrets.CODECOV_TOKEN }}
           file: cobertura.xml
-
-      - name: Clear the cargo caches
-        run: |
-          cargo install cargo-cache --no-default-features --features ci-autoclean
-          cargo-cache

.github/workflows/macos.yml

@@ -24,26 +24,6 @@ jobs:
           profile: minimal
           override: true
 
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
-      - name: Cache cargo registry
-        uses: actions/cache@v1
-        with:
-          path: ~/.cargo/registry
-          key: ${{ matrix.version }}-x86_64-apple-darwin-cargo-registry-trimmed-${{ hashFiles('**/Cargo.lock') }}
-      - name: Cache cargo index
-        uses: actions/cache@v1
-        with:
-          path: ~/.cargo/git
-          key: ${{ matrix.version }}-x86_64-apple-darwin-cargo-index-trimmed-${{ hashFiles('**/Cargo.lock') }}
-      - name: Cache cargo build
-        uses: actions/cache@v1
-        with:
-          path: target
-          key: ${{ matrix.version }}-x86_64-apple-darwin-cargo-build-trimmed-${{ hashFiles('**/Cargo.lock') }}
-
       - name: check build
         uses: actions-rs/cargo@v1
         with:
@@ -57,8 +37,3 @@ jobs:
           args: --all --all-features --no-fail-fast -- --nocapture
                 --skip=test_h2_content_length
                 --skip=test_reading_deflate_encoding_large_random_rustls
-
-      - name: Clear the cargo caches
-        run: |
-          cargo install cargo-cache --no-default-features --features ci-autoclean
-          cargo-cache

.github/workflows/upload-doc.yml

@@ -24,7 +24,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: doc
-          args: --no-deps --all-features
+          args: --no-deps --workspace --all-features
 
       - name: Tweak HTML
         run: echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html
@@ -32,4 +32,4 @@ jobs:
       - name: Upload documentation
         run: |
           git clone https://github.com/davisp/ghp-import.git
-          ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://${{ secrets.GITHUB_TOKEN }}@github.com/"${{ github.repository }}.git" target/doc
+          ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://${{ secrets.GITHUB_TOKEN }}@github.com/"${{ github.repository }}.git" target/doc

CHANGES.md

@@ -1,19 +1,32 @@
 # Changes
 
+## [Unreleased]
 
-## [2.0.NEXT] - 2020-01-xx
+### Changed
+
+* `{Resource,Scope}::default_service(f)` handlers now support app data extraction. [#1452]
+* Implement `std::error::Error` for our custom errors [#1422]
+* NormalizePath middleware now appends trailing / so that routes of form /example/ respond to /example requests.
+
+[#1422]: https://github.com/actix/actix-web/pull/1422
+[#1452]: https://github.com/actix/actix-web/pull/1452
+
+## [3.0.0-alpha.1] - 2020-03-11
 
 ### Added
 
 * Add helper function for creating routes with `TRACE` method guard `web::trace()`
+* Add convenience functions `test::read_body_json()` and `test::TestRequest::send_request()` for testing.
 
 ### Changed
 
 * Use `sha-1` crate instead of unmaintained `sha1` crate
-
+* Skip empty chunks when returning response from a `Stream` [#1308]
-* Skip empty chunks when returning response from a `Stream` #1308
-
 * Update the `time` dependency to 0.2.7
+* Update `actix-tls` dependency to 2.0.0-alpha.1
+* Update `rustls` dependency to 0.17
+
+[#1308]: https://github.com/actix/actix-web/pull/1308
 
 ## [2.0.0] - 2019-12-25
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
@@ -30,7 +30,7 @@ members = [
   ".",
   "awc",
   "actix-http",
-  "actix-cors",
+#  "actix-cors",
   "actix-files",
   "actix-framed",
 #  "actix-session",
@@ -42,7 +42,7 @@ members = [
 ]
 
 [features]
-default = ["compress", "failure"]
+default = ["compress"]
 
 # content-encoding support
 compress = ["actix-http/compress", "awc/compress"]
@@ -50,14 +50,24 @@ compress = ["actix-http/compress", "awc/compress"]
 # sessions feature, session require "ring" crate and c compiler
 secure-cookies = ["actix-http/secure-cookies"]
 
-failure = ["actix-http/failure"]
-
 # openssl
 openssl = ["actix-tls/openssl", "awc/openssl", "open-ssl"]
 
 # rustls
 rustls = ["actix-tls/rustls", "awc/rustls", "rust-tls"]
 
+[[example]]
+name = "basic"
+required-features = ["compress"]
+
+[[example]]
+name = "uds"
+required-features = ["compress"]
+
+[[test]]
+name = "test_server"
+required-features = ["compress"]
+
 [dependencies]
 actix-codec = "0.2.0"
 actix-service = "1.0.2"
@@ -68,11 +78,11 @@ actix-server = "1.0.0"
 actix-testing = "1.0.0"
 actix-macros = "0.1.0"
 actix-threadpool = "0.3.1"
-actix-tls = "1.0.0"
+actix-tls = "2.0.0-alpha.1"
 
 actix-web-codegen = "0.2.0"
-actix-http = "2.0.0-alpha.1"
+actix-http = "2.0.0-alpha.3"
-awc = { version = "1.0.1", default-features = false }
+awc = { version = "2.0.0-alpha.1", default-features = false }
 
 bytes = "0.5.3"
 derive_more = "0.99.2"
@@ -90,12 +100,12 @@ serde_urlencoded = "0.6.1"
 time = { version = "0.2.7", default-features = false, features = ["std"] }
 url = "2.1"
 open-ssl = { version="0.10", package = "openssl", optional = true }
-rust-tls = { version = "0.16.0", package = "rustls", optional = true }
+rust-tls = { version = "0.17.0", package = "rustls", optional = true }
 
 [dev-dependencies]
 actix = "0.10.0-alpha.1"
 rand = "0.7"
-env_logger = "0.6"
+env_logger = "0.7"
 serde_derive = "1.0"
 brotli2 = "0.3.2"
 flate2 = "1.0.13"
@@ -111,9 +121,6 @@ actix-web = { path = "." }
 actix-http = { path = "actix-http" }
 actix-http-test = { path = "test-server" }
 actix-web-codegen = { path = "actix-web-codegen" }
-actix-cors = { path = "actix-cors" }
-actix-identity = { path = "actix-identity" }
-actix-session = { path = "actix-session" }
 actix-files = { path = "actix-files" }
 actix-multipart = { path = "actix-multipart" }
 awc = { path = "awc" }

MIGRATION.md

@@ -360,7 +360,7 @@
 
 * `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type
 
-* StaticFiles and NamedFile has been move to separate create.
+* StaticFiles and NamedFile have been moved to a separate crate.
 
   instead of `use actix_web::fs::StaticFile`
 
@@ -370,7 +370,7 @@
 
   use `use actix_files::NamedFile`
 
-* Multipart has been move to separate create.
+* Multipart has been moved to a separate crate.
 
   instead of `use actix_web::multipart::Multipart`
 

README.md

@@ -39,6 +39,12 @@ Actix web is a simple, pragmatic and extremely fast web framework for Rust.
 * Includes an asynchronous [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
 * Supports [Actix actor framework](https://github.com/actix/actix)
 
+## Docs
+
+* [API documentation (master)](https://actix.rs/actix-web/actix_web)
+* [API documentation (docs.rs)](https://docs.rs/actix-web)
+* [User guide](https://actix.rs)
+
 ## Example
 
 Dependencies:
@@ -74,7 +80,7 @@ async fn main() -> std::io::Result<()> {
 * [Stateful](https://github.com/actix/examples/tree/master/state/)
 * [Multipart streams](https://github.com/actix/examples/tree/master/multipart/)
 * [Simple websocket](https://github.com/actix/examples/tree/master/websocket/)
-* [Tera](https://github.com/actix/examples/tree/master/template_tera/) /
+* [Tera](https://github.com/actix/examples/tree/master/template_tera/)
 * [Askama](https://github.com/actix/examples/tree/master/template_askama/) templates
 * [Diesel integration](https://github.com/actix/examples/tree/master/diesel/)
 * [r2d2](https://github.com/actix/examples/tree/master/r2d2/)

actix-cors/README.md

@@ -1,5 +1,7 @@
 # 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)
 
+**This crate moved to https://github.com/actix/actix-extras.**
+
 ## Documentation & community resources
 
 * [User Guide](https://actix.rs/docs/)

actix-files/Cargo.toml

@@ -18,8 +18,8 @@ name = "actix_files"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = { version = "2.0.0-rc", default-features = false }
+actix-web = { version = "3.0.0-alpha.1", default-features = false }
-actix-http = "2.0.0-alpha.1"
+actix-http = "2.0.0-alpha.3"
 actix-service = "1.0.1"
 bitflags = "1"
 bytes = "0.5.3"
@@ -33,4 +33,4 @@ v_htmlescape = "0.4"
 
 [dev-dependencies]
 actix-rt = "1.0.0"
-actix-web = { version = "2.0.0-rc", features=["openssl"] }
+actix-web = { version = "3.0.0-alpha.1", features=["openssl"] }

actix-files/src/lib.rs

@@ -521,7 +521,7 @@ impl Service for FilesService {
             Err(e) => return Either::Left(ok(req.error_response(e))),
         };
 
-        // full filepath
+        // full file path
         let path = match self.directory.join(&real_path.0).canonicalize() {
             Ok(path) => path,
             Err(e) => return self.handle_err(e, req),

actix-framed/Cargo.toml

@@ -23,7 +23,7 @@ actix-codec = "0.2.0"
 actix-service = "1.0.1"
 actix-router = "0.2.1"
 actix-rt = "1.0.0"
-actix-http = "2.0.0-alpha.1"
+actix-http = "2.0.0-alpha.3"
 
 bytes = "0.5.3"
 futures = "0.3.1"
@@ -32,6 +32,6 @@ log = "0.4"
 
 [dev-dependencies]
 actix-server = "1.0.0"
-actix-connect = { version = "1.0.0", features=["openssl"] }
+actix-connect = { version = "2.0.0-alpha.2", features=["openssl"] }
 actix-http-test = { version = "1.0.0", features=["openssl"] }
 actix-utils = "1.0.3"

actix-framed/src/lib.rs

@@ -7,7 +7,7 @@ mod service;
 mod state;
 pub mod test;
 
-// re-export for convinience
+// re-export for convenience
 pub use actix_http::{http, Error, HttpMessage, Response, ResponseError};
 
 pub use self::app::{FramedApp, FramedAppService};

actix-framed/src/request.rs

@@ -42,7 +42,7 @@ impl<Io, S> FramedRequest<Io, S> {
         self.req.head()
     }
 
-    /// This method returns muttable reference to the request head.
+    /// This method returns mutable reference to the request head.
     /// panics if multiple references of http request exists.
     #[inline]
     pub fn head_mut(&mut self) -> &mut RequestHead {
@@ -131,7 +131,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_reqest() {
+    fn test_request() {
         let buf = TestBuffer::empty();
         let framed = Framed::new(buf, Codec::default());
         let req = TestRequest::with_uri("/index.html?q=1")

actix-framed/tests/test_server.rs

@@ -47,7 +47,8 @@ async fn test_simple() {
             )
             .finish(|_| future::ok::<_, Error>(Response::NotFound()))
             .tcp()
-    });
+    })
+    .await;
 
     assert!(srv.ws_at("/test").await.is_err());
 
@@ -108,7 +109,8 @@ async fn test_service() {
                     .map_err(|_| ()),
             ),
         )
-    });
+    })
+    .await;
 
     // non ws request
     let res = srv.get("/index.html").send().await.unwrap();

actix-http/CHANGES.md

@@ -1,15 +1,45 @@
 # Changes
 
+## [2.0.0-alpha.3] - 2020-05-08
+
+### Fixed
+
+* Correct spelling of ConnectError::Unresolved [#1487]
+* Fix a mistake in the encoding of websocket continuation messages wherein
+  Item::FirstText and Item::FirstBinary are each encoded as the other.
+
+### Changed
+
+* Implement `std::error::Error` for our custom errors [#1422]
+* Remove `failure` support for `ResponseError` since that crate
+  will be deprecated in the near future.
+
+[#1422]: https://github.com/actix/actix-web/pull/1422
+[#1487]: https://github.com/actix/actix-web/pull/1487
+
+## [2.0.0-alpha.2] - 2020-03-07
+
+### Changed
+
+* Update `actix-connect` and `actix-tls` dependency to 2.0.0-alpha.1. [#1395]
+
+* Change default initial window size and connection window size for HTTP2 to 2MB and 1MB respectively
+  to improve download speed for awc when downloading large objects. [#1394]
+
+* client::Connector accepts initial_window_size and initial_connection_window_size HTTP2 configuration. [#1394]
+
+* client::Connector allowing to set max_http_version to limit HTTP version to be used. [#1394]
+
+[#1394]: https://github.com/actix/actix-web/pull/1394
+[#1395]: https://github.com/actix/actix-web/pull/1395
+
 ## [2.0.0-alpha.1] - 2020-02-27
 
 ### Changed
 
 * Update the `time` dependency to 0.2.7.
-
 * Moved actors messages support from actix crate, enabled with feature `actors`.
-
 * Breaking change: trait MessageBody requires Unpin and accepting Pin<&mut Self> instead of &mut self in the poll_next().
-
 * MessageBody is not implemented for &'static [u8] anymore.
 
 ### Fixed

actix-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "2.0.0-alpha.1"
+version = "2.0.0-alpha.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http primitives"
 readme = "README.md"
@@ -15,7 +15,7 @@ license = "MIT/Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
-features = ["openssl", "rustls", "failure", "compress", "secure-cookies","actors"]
+features = ["openssl", "rustls", "compress", "secure-cookies", "actors"]
 
 [lib]
 name = "actix_http"
@@ -33,9 +33,6 @@ rustls = ["actix-tls/rustls", "actix-connect/rustls"]
 # enable compressison support
 compress = ["flate2", "brotli2"]
 
-# failure integration. actix does not use failure anymore
-failure = ["fail-ure"]
-
 # support for secure cookies
 secure-cookies = ["ring"]
 
@@ -45,11 +42,11 @@ actors = ["actix"]
 [dependencies]
 actix-service = "1.0.5"
 actix-codec = "0.2.0"
-actix-connect = "1.0.2"
+actix-connect = "2.0.0-alpha.3"
 actix-utils = "1.0.6"
 actix-rt = "1.0.0"
 actix-threadpool = "0.3.1"
-actix-tls = { version = "1.0.0", optional = true }
+actix-tls = { version = "2.0.0-alpha.1", optional = true }
 actix = { version = "0.10.0-alpha.1", optional = true }
 
 base64 = "0.11"
@@ -89,21 +86,22 @@ ring = { version = "0.16.9", optional = true }
 brotli2 = { version="0.3.2", optional = true }
 flate2 = { version = "1.0.13", optional = true }
 
-# optional deps
-fail-ure = { version = "0.1.5", package="failure", optional = true }
-
 [dev-dependencies]
 actix-server = "1.0.1"
-actix-connect = { version = "1.0.2", features=["openssl"] }
+actix-connect = { version = "2.0.0-alpha.2", features=["openssl"] }
 actix-http-test = { version = "1.0.0", features=["openssl"] }
-actix-tls = { version = "1.0.0", features=["openssl"] }
+actix-tls = { version = "2.0.0-alpha.1", features=["openssl"] }
 criterion = "0.3"
 futures = "0.3.1"
 env_logger = "0.7"
 serde_derive = "1.0"
 open-ssl = { version="0.10", package = "openssl" }
-rust-tls = { version="0.16", package = "rustls" }
+rust-tls = { version="0.17", package = "rustls" }
 
 [[bench]]
 name = "content-length"
 harness = false
+
+[[bench]]
+name = "status-line"
+harness = false

actix-http/README.md

@@ -14,19 +14,34 @@ Actix http
 
 ```rust
 // see examples/framed_hello.rs for complete list of used crates.
-extern crate actix_http;
+use std::{env, io};
-use actix_http::{h1, Response, ServiceConfig};
 
-fn main() {
+use actix_http::{HttpService, Response};
-    Server::new().bind("framed_hello", "127.0.0.1:8080", || {
+use actix_server::Server;
-        IntoFramed::new(|| h1::Codec::new(ServiceConfig::default()))	// <- create h1 codec
+use futures::future;
-            .and_then(TakeItem::new().map_err(|_| ()))	                // <- read one request
+use http::header::HeaderValue;
-            .and_then(|(_req, _framed): (_, Framed<_, _>)| {	        // <- send response and close conn
+use log::info;
-                SendResponse::send(_framed, Response::Ok().body("Hello world!"))
+
-                    .map_err(|_| ())
+#[actix_rt::main]
-                    .map(|_| ())
+async fn main() -> io::Result<()> {
-            })
+    env::set_var("RUST_LOG", "hello_world=info");
-    }).unwrap().run();
+    env_logger::init();
+
+    Server::build()
+        .bind("hello-world", "127.0.0.1:8080", || {
+            HttpService::build()
+                .client_timeout(1000)
+                .client_disconnect(1000)
+                .finish(|_req| {
+                    info!("{:?}", _req);
+                    let mut res = Response::Ok();
+                    res.header("x-head", HeaderValue::from_static("dummy value!"));
+                    future::ok::<_, ()>(res.body("Hello world!"))
+                })
+                .tcp()
+        })?
+        .run()
+        .await
 }
 ```
 

actix-http/benches/status-line.rs

@@ -0,0 +1,222 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+use bytes::BytesMut;
+use http::Version;
+
+const CODES: &[u16] = &[201, 303, 404, 515];
+
+fn bench_write_status_line_11(c: &mut Criterion) {
+    let mut group = c.benchmark_group("write_status_line v1.1");
+
+    let version = Version::HTTP_11;
+
+    for i in CODES.iter() {
+        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _original::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _new::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _naive::write_status_line(version, i, &mut b);
+            })
+        });
+    }
+
+    group.finish();
+}
+
+fn bench_write_status_line_10(c: &mut Criterion) {
+    let mut group = c.benchmark_group("write_status_line v1.0");
+
+    let version = Version::HTTP_10;
+
+    for i in CODES.iter() {
+        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _original::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _new::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _naive::write_status_line(version, i, &mut b);
+            })
+        });
+    }
+
+    group.finish();
+}
+
+fn bench_write_status_line_09(c: &mut Criterion) {
+    let mut group = c.benchmark_group("write_status_line v0.9");
+
+    let version = Version::HTTP_09;
+
+    for i in CODES.iter() {
+        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _original::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _new::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _naive::write_status_line(version, i, &mut b);
+            })
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_write_status_line_11,
+    bench_write_status_line_10,
+    bench_write_status_line_09
+);
+criterion_main!(benches);
+
+mod _naive {
+    use bytes::{BufMut, BytesMut};
+    use http::Version;
+
+    pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
+        match version {
+            Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
+            Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
+            Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
+            _ => {
+                // other HTTP version handlers do not use this method
+            }
+        }
+
+        bytes.put_slice(n.to_string().as_bytes());
+    }
+}
+
+mod _new {
+    use bytes::{BufMut, BytesMut};
+    use http::Version;
+
+    const DIGITS_START: u8 = b'0';
+
+    pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
+        match version {
+            Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
+            Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
+            Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
+            _ => {
+                // other HTTP version handlers do not use this method
+            }
+        }
+
+        let d100 = (n / 100) as u8;
+        let d10 = ((n / 10) % 10) as u8;
+        let d1 = (n % 10) as u8;
+
+        bytes.put_u8(DIGITS_START + d100);
+        bytes.put_u8(DIGITS_START + d10);
+        bytes.put_u8(DIGITS_START + d1);
+
+        bytes.put_u8(b' ');
+    }
+}
+
+mod _original {
+    use std::ptr;
+
+    use bytes::{BufMut, BytesMut};
+    use http::Version;
+
+    const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
+        2021222324252627282930313233343536373839\
+        4041424344454647484950515253545556575859\
+        6061626364656667686970717273747576777879\
+        8081828384858687888990919293949596979899";
+
+    pub(crate) const STATUS_LINE_BUF_SIZE: usize = 13;
+
+    pub(crate) fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
+        let mut buf: [u8; STATUS_LINE_BUF_SIZE] = *b"HTTP/1.1     ";
+
+        match version {
+            Version::HTTP_2 => buf[5] = b'2',
+            Version::HTTP_10 => buf[7] = b'0',
+            Version::HTTP_09 => {
+                buf[5] = b'0';
+                buf[7] = b'9';
+            }
+            _ => (),
+        }
+
+        let mut curr: isize = 12;
+        let buf_ptr = buf.as_mut_ptr();
+        let lut_ptr = DEC_DIGITS_LUT.as_ptr();
+        let four = n > 999;
+
+        // decode 2 more chars, if > 2 chars
+        let d1 = (n % 100) << 1;
+        n /= 100;
+        curr -= 2;
+        unsafe {
+            ptr::copy_nonoverlapping(
+                lut_ptr.offset(d1 as isize),
+                buf_ptr.offset(curr),
+                2,
+            );
+        }
+
+        // decode last 1 or 2 chars
+        if n < 10 {
+            curr -= 1;
+            unsafe {
+                *buf_ptr.offset(curr) = (n as u8) + b'0';
+            }
+        } else {
+            let d1 = n << 1;
+            curr -= 2;
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    lut_ptr.offset(d1 as isize),
+                    buf_ptr.offset(curr),
+                    2,
+                );
+            }
+        }
+
+        bytes.put_slice(&buf);
+        if four {
+            bytes.put_u8(b' ');
+        }
+    }
+}

actix-http/src/client/config.rs

@@ -0,0 +1,39 @@
+use std::time::Duration;
+
+// These values are taken from hyper/src/proto/h2/client.rs
+const DEFAULT_H2_CONN_WINDOW: u32 = 1024 * 1024 * 2; // 2mb
+const DEFAULT_H2_STREAM_WINDOW: u32 = 1024 * 1024; // 1mb
+
+/// Connector configuration
+#[derive(Clone)]
+pub(crate) struct ConnectorConfig {
+    pub(crate) timeout: Duration,
+    pub(crate) conn_lifetime: Duration,
+    pub(crate) conn_keep_alive: Duration,
+    pub(crate) disconnect_timeout: Option<Duration>,
+    pub(crate) limit: usize,
+    pub(crate) conn_window_size: u32,
+    pub(crate) stream_window_size: u32,
+}
+
+impl Default for ConnectorConfig {
+    fn default() -> Self {
+        Self {
+            timeout: Duration::from_secs(1),
+            conn_lifetime: Duration::from_secs(75),
+            conn_keep_alive: Duration::from_secs(15),
+            disconnect_timeout: Some(Duration::from_millis(3000)),
+            limit: 100,
+            conn_window_size: DEFAULT_H2_CONN_WINDOW,
+            stream_window_size: DEFAULT_H2_STREAM_WINDOW,
+        }
+    }
+}
+
+impl ConnectorConfig {
+    pub(crate) fn no_disconnect_timeout(&self) -> Self {
+        let mut res = self.clone();
+        res.disconnect_timeout = None;
+        res
+    }
+}

actix-http/src/client/connector.rs

@@ -11,6 +11,7 @@ use actix_service::{apply_fn, Service};
 use actix_utils::timeout::{TimeoutError, TimeoutService};
 use http::Uri;
 
+use super::config::ConnectorConfig;
 use super::connection::Connection;
 use super::error::ConnectError;
 use super::pool::{ConnectionPool, Protocol};
@@ -48,11 +49,7 @@ type SslConnector = ();
 /// ```
 pub struct Connector<T, U> {
     connector: T,
-    timeout: Duration,
+    config: ConnectorConfig,
-    conn_lifetime: Duration,
-    conn_keep_alive: Duration,
-    disconnect_timeout: Duration,
-    limit: usize,
     #[allow(dead_code)]
     ssl: SslConnector,
     _t: PhantomData<U>,
@@ -71,42 +68,47 @@ impl Connector<(), ()> {
             > + Clone,
         TcpStream,
     > {
-        let ssl = {
-            #[cfg(feature = "openssl")]
-            {
-                use actix_connect::ssl::openssl::SslMethod;
-
-                let mut ssl = OpensslConnector::builder(SslMethod::tls()).unwrap();
-                let _ = ssl
-                    .set_alpn_protos(b"\x02h2\x08http/1.1")
-                    .map_err(|e| error!("Can not set alpn protocol: {:?}", e));
-                SslConnector::Openssl(ssl.build())
-            }
-            #[cfg(all(not(feature = "openssl"), feature = "rustls"))]
-            {
-                let protos = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
-                let mut config = ClientConfig::new();
-                config.set_protocols(&protos);
-                config
-                    .root_store
-                    .add_server_trust_anchors(&actix_tls::rustls::TLS_SERVER_ROOTS);
-                SslConnector::Rustls(Arc::new(config))
-            }
-            #[cfg(not(any(feature = "openssl", feature = "rustls")))]
-            {}
-        };
-
         Connector {
-            ssl,
+            ssl: Self::build_ssl(vec![b"h2".to_vec(), b"http/1.1".to_vec()]),
             connector: default_connector(),
-            timeout: Duration::from_secs(1),
+            config: ConnectorConfig::default(),
-            conn_lifetime: Duration::from_secs(75),
-            conn_keep_alive: Duration::from_secs(15),
-            disconnect_timeout: Duration::from_millis(3000),
-            limit: 100,
             _t: PhantomData,
         }
     }
+
+    // Build Ssl connector with openssl, based on supplied alpn protocols
+    #[cfg(feature = "openssl")]
+    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
+        use actix_connect::ssl::openssl::SslMethod;
+        use bytes::{BufMut, BytesMut};
+
+        let mut alpn = BytesMut::with_capacity(20);
+        for proto in protocols.iter() {
+            alpn.put_u8(proto.len() as u8);
+            alpn.put(proto.as_slice());
+        }
+
+        let mut ssl = OpensslConnector::builder(SslMethod::tls()).unwrap();
+        let _ = ssl
+            .set_alpn_protos(&alpn)
+            .map_err(|e| error!("Can not set alpn protocol: {:?}", e));
+        SslConnector::Openssl(ssl.build())
+    }
+
+    // Build Ssl connector with rustls, based on supplied alpn protocols
+    #[cfg(all(not(feature = "openssl"), feature = "rustls"))]
+    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
+        let mut config = ClientConfig::new();
+        config.set_protocols(&protocols);
+        config
+            .root_store
+            .add_server_trust_anchors(&actix_tls::rustls::TLS_SERVER_ROOTS);
+        SslConnector::Rustls(Arc::new(config))
+    }
+
+    // ssl turned off, provides empty ssl connector
+    #[cfg(not(any(feature = "openssl", feature = "rustls")))]
+    fn build_ssl(_: Vec<Vec<u8>>) -> SslConnector {}
 }
 
 impl<T, U> Connector<T, U> {
@@ -122,11 +124,7 @@ impl<T, U> Connector<T, U> {
     {
         Connector {
             connector,
-            timeout: self.timeout,
+            config: self.config,
-            conn_lifetime: self.conn_lifetime,
-            conn_keep_alive: self.conn_keep_alive,
-            disconnect_timeout: self.disconnect_timeout,
-            limit: self.limit,
             ssl: self.ssl,
             _t: PhantomData,
         }
@@ -146,7 +144,7 @@ where
     /// Connection timeout, i.e. max time to connect to remote host including dns name resolution.
     /// Set to 1 second by default.
     pub fn timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = timeout;
+        self.config.timeout = timeout;
         self
     }
 
@@ -163,12 +161,44 @@ where
         self
     }
 
+    /// Maximum supported http major version
+    /// Supported versions http/1.1, http/2
+    pub fn max_http_version(mut self, val: http::Version) -> Self {
+        let versions = match val {
+            http::Version::HTTP_11 => vec![b"http/1.1".to_vec()],
+            http::Version::HTTP_2 => vec![b"h2".to_vec(), b"http/1.1".to_vec()],
+            _ => {
+                unimplemented!("actix-http:client: supported versions http/1.1, http/2")
+            }
+        };
+        self.ssl = Connector::build_ssl(versions);
+        self
+    }
+
+    /// Indicates the initial window size (in octets) for
+    /// HTTP2 stream-level flow control for received data.
+    ///
+    /// The default value is 65,535 and is good for APIs, but not for big objects.
+    pub fn initial_window_size(mut self, size: u32) -> Self {
+        self.config.stream_window_size = size;
+        self
+    }
+
+    /// Indicates the initial window size (in octets) for
+    /// HTTP2 connection-level flow control for received data.
+    ///
+    /// The default value is 65,535 and is good for APIs, but not for big objects.
+    pub fn initial_connection_window_size(mut self, size: u32) -> Self {
+        self.config.conn_window_size = size;
+        self
+    }
+
     /// Set total number of simultaneous connections per type of scheme.
     ///
     /// If limit is 0, the connector has no limit.
     /// The default limit size is 100.
     pub fn limit(mut self, limit: usize) -> Self {
-        self.limit = limit;
+        self.config.limit = limit;
         self
     }
 
@@ -179,7 +209,7 @@ where
     /// exceeds this period, the connection is closed.
     /// Default keep-alive period is 15 seconds.
     pub fn conn_keep_alive(mut self, dur: Duration) -> Self {
-        self.conn_keep_alive = dur;
+        self.config.conn_keep_alive = dur;
         self
     }
 
@@ -189,7 +219,7 @@ where
     /// until it is closed regardless of keep-alive period.
     /// Default lifetime period is 75 seconds.
     pub fn conn_lifetime(mut self, dur: Duration) -> Self {
-        self.conn_lifetime = dur;
+        self.config.conn_lifetime = dur;
         self
     }
 
@@ -202,7 +232,7 @@ where
     ///
     /// By default disconnect timeout is set to 3000 milliseconds.
     pub fn disconnect_timeout(mut self, dur: Duration) -> Self {
-        self.disconnect_timeout = dur;
+        self.config.disconnect_timeout = Some(dur);
         self
     }
 
@@ -216,7 +246,7 @@ where
         #[cfg(not(any(feature = "openssl", feature = "rustls")))]
         {
             let connector = TimeoutService::new(
-                self.timeout,
+                self.config.timeout,
                 apply_fn(self.connector, |msg: Connect, srv| {
                     srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
                 })
@@ -231,10 +261,7 @@ where
             connect_impl::InnerConnector {
                 tcp_pool: ConnectionPool::new(
                     connector,
-                    self.conn_lifetime,
+                    self.config.no_disconnect_timeout(),
-                    self.conn_keep_alive,
-                    None,
-                    self.limit,
                 ),
             }
         }
@@ -248,7 +275,7 @@ where
             use actix_service::{boxed::service, pipeline};
 
             let ssl_service = TimeoutService::new(
-                self.timeout,
+                self.config.timeout,
                 pipeline(
                     apply_fn(self.connector.clone(), |msg: Connect, srv| {
                         srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
@@ -301,7 +328,7 @@ where
             });
 
             let tcp_service = TimeoutService::new(
-                self.timeout,
+                self.config.timeout,
                 apply_fn(self.connector, |msg: Connect, srv| {
                     srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
                 })
@@ -316,18 +343,9 @@ where
             connect_impl::InnerConnector {
                 tcp_pool: ConnectionPool::new(
                     tcp_service,
-                    self.conn_lifetime,
+                    self.config.no_disconnect_timeout(),
-                    self.conn_keep_alive,
-                    None,
-                    self.limit,
-                ),
-                ssl_pool: ConnectionPool::new(
-                    ssl_service,
-                    self.conn_lifetime,
-                    self.conn_keep_alive,
-                    Some(self.disconnect_timeout),
-                    self.limit,
                 ),
+                ssl_pool: ConnectionPool::new(ssl_service, self.config),
             }
         }
     }

actix-http/src/client/error.rs

@@ -48,20 +48,22 @@ pub enum ConnectError {
 
     /// Unresolved host name
     #[display(fmt = "Connector received `Connect` method with unresolved host")]
-    Unresolverd,
+    Unresolved,
 
     /// Connection io error
     #[display(fmt = "{}", _0)]
     Io(io::Error),
 }
 
+impl std::error::Error for ConnectError {}
+
 impl From<actix_connect::ConnectError> for ConnectError {
     fn from(err: actix_connect::ConnectError) -> ConnectError {
         match err {
             actix_connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
             actix_connect::ConnectError::NoRecords => ConnectError::NoRecords,
             actix_connect::ConnectError::InvalidInput => panic!(),
-            actix_connect::ConnectError::Unresolverd => ConnectError::Unresolverd,
+            actix_connect::ConnectError::Unresolved => ConnectError::Unresolved,
             actix_connect::ConnectError::Io(e) => ConnectError::Io(e),
         }
     }
@@ -86,6 +88,8 @@ pub enum InvalidUrl {
     HttpError(http::Error),
 }
 
+impl std::error::Error for InvalidUrl {}
+
 /// A set of errors that can occur during request sending and response reading
 #[derive(Debug, Display, From)]
 pub enum SendRequestError {
@@ -115,6 +119,8 @@ pub enum SendRequestError {
     Body(Error),
 }
 
+impl std::error::Error for SendRequestError {}
+
 /// Convert `SendRequestError` to a server `Response`
 impl ResponseError for SendRequestError {
     fn status_code(&self) -> StatusCode {
@@ -139,6 +145,8 @@ pub enum FreezeRequestError {
     Http(HttpError),
 }
 
+impl std::error::Error for FreezeRequestError {}
+
 impl From<FreezeRequestError> for SendRequestError {
     fn from(e: FreezeRequestError) -> Self {
         match e {

actix-http/src/client/h2proto.rs

@@ -1,11 +1,15 @@
 use std::convert::TryFrom;
+use std::future::Future;
 use std::time;
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use bytes::Bytes;
 use futures_util::future::poll_fn;
 use futures_util::pin_mut;
-use h2::{client::SendRequest, SendStream};
+use h2::{
+    client::{Builder, Connection, SendRequest},
+    SendStream,
+};
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, Method, Version};
 
@@ -14,6 +18,7 @@ use crate::header::HeaderMap;
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
 
+use super::config::ConnectorConfig;
 use super::connection::{ConnectionType, IoConnection};
 use super::error::SendRequestError;
 use super::pool::Acquired;
@@ -185,3 +190,18 @@ fn release<T: AsyncRead + AsyncWrite + Unpin + 'static>(
         }
     }
 }
+
+pub(crate) fn handshake<Io>(
+    io: Io,
+    config: &ConnectorConfig,
+) -> impl Future<Output = Result<(SendRequest<Bytes>, Connection<Io, Bytes>), h2::Error>>
+where
+    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+{
+    let mut builder = Builder::new();
+    builder
+        .initial_window_size(config.stream_window_size)
+        .initial_connection_window_size(config.conn_window_size)
+        .enable_push(false);
+    builder.handshake(io)
+}

actix-http/src/client/mod.rs

@@ -1,6 +1,7 @@
 //! Http client api
 use http::Uri;
 
+mod config;
 mod connection;
 mod connector;
 mod error;

actix-http/src/client/pool.rs

@@ -13,14 +13,16 @@ use actix_utils::{oneshot, task::LocalWaker};
 use bytes::Bytes;
 use futures_util::future::{poll_fn, FutureExt, LocalBoxFuture};
 use fxhash::FxHashMap;
-use h2::client::{handshake, Connection, SendRequest};
+use h2::client::{Connection, SendRequest};
 use http::uri::Authority;
 use indexmap::IndexSet;
 use pin_project::pin_project;
 use slab::Slab;
 
+use super::config::ConnectorConfig;
 use super::connection::{ConnectionType, IoConnection};
 use super::error::ConnectError;
+use super::h2proto::handshake;
 use super::Connect;
 
 #[derive(Clone, Copy, PartialEq)]
@@ -50,20 +52,11 @@ where
     T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
         + 'static,
 {
-    pub(crate) fn new(
+    pub(crate) fn new(connector: T, config: ConnectorConfig) -> Self {
-        connector: T,
-        conn_lifetime: Duration,
-        conn_keep_alive: Duration,
-        disconnect_timeout: Option<Duration>,
-        limit: usize,
-    ) -> Self {
         ConnectionPool(
             Rc::new(RefCell::new(connector)),
             Rc::new(RefCell::new(Inner {
-                conn_lifetime,
+                config,
-                conn_keep_alive,
-                disconnect_timeout,
-                limit,
                 acquired: 0,
                 waiters: Slab::new(),
                 waiters_queue: IndexSet::new(),
@@ -112,7 +105,7 @@ where
             let key = if let Some(authority) = req.uri.authority() {
                 authority.clone().into()
             } else {
-                return Err(ConnectError::Unresolverd);
+                return Err(ConnectError::Unresolved);
             };
 
             // acquire connection
@@ -129,6 +122,8 @@ where
                     // open tcp connection
                     let (io, proto) = connector.call(req).await?;
 
+                    let config = inner.borrow().config.clone();
+
                     let guard = OpenGuard::new(key, inner);
 
                     if proto == Protocol::Http1 {
@@ -138,7 +133,7 @@ where
                             Some(guard.consume()),
                         ))
                     } else {
-                        let (snd, connection) = handshake(io).await?;
+                        let (snd, connection) = handshake(io, &config).await?;
                         actix_rt::spawn(connection.map(|_| ()));
                         Ok(IoConnection::new(
                             ConnectionType::H2(snd),
@@ -200,7 +195,7 @@ where
         if let Some(i) = self.inner.take() {
             let mut inner = i.as_ref().borrow_mut();
             inner.release_waiter(&self.key, self.token);
-            inner.check_availibility();
+            inner.check_availability();
         }
     }
 }
@@ -237,7 +232,7 @@ where
         if let Some(i) = self.inner.take() {
             let mut inner = i.as_ref().borrow_mut();
             inner.release();
-            inner.check_availibility();
+            inner.check_availability();
         }
     }
 }
@@ -255,10 +250,7 @@ struct AvailableConnection<Io> {
 }
 
 pub(crate) struct Inner<Io> {
-    conn_lifetime: Duration,
+    config: ConnectorConfig,
-    conn_keep_alive: Duration,
-    disconnect_timeout: Option<Duration>,
-    limit: usize,
     acquired: usize,
     available: FxHashMap<Key, VecDeque<AvailableConnection<Io>>>,
     waiters: Slab<
@@ -311,7 +303,7 @@ where
 
     fn acquire(&mut self, key: &Key, cx: &mut Context<'_>) -> Acquire<Io> {
         // check limits
-        if self.limit > 0 && self.acquired >= self.limit {
+        if self.config.limit > 0 && self.acquired >= self.config.limit {
             return Acquire::NotAvailable;
         }
 
@@ -323,10 +315,10 @@ where
             let now = Instant::now();
             while let Some(conn) = connections.pop_back() {
                 // check if it still usable
-                if (now - conn.used) > self.conn_keep_alive
+                if (now - conn.used) > self.config.conn_keep_alive
-                    || (now - conn.created) > self.conn_lifetime
+                    || (now - conn.created) > self.config.conn_lifetime
                 {
-                    if let Some(timeout) = self.disconnect_timeout {
+                    if let Some(timeout) = self.config.disconnect_timeout {
                         if let ConnectionType::H1(io) = conn.io {
                             actix_rt::spawn(CloseConnection::new(io, timeout))
                         }
@@ -338,7 +330,7 @@ where
                         match Pin::new(s).poll_read(cx, &mut buf) {
                             Poll::Pending => (),
                             Poll::Ready(Ok(n)) if n > 0 => {
-                                if let Some(timeout) = self.disconnect_timeout {
+                                if let Some(timeout) = self.config.disconnect_timeout {
                                     if let ConnectionType::H1(io) = io {
                                         actix_rt::spawn(CloseConnection::new(
                                             io, timeout,
@@ -367,21 +359,21 @@ where
                 created,
                 used: Instant::now(),
             });
-        self.check_availibility();
+        self.check_availability();
     }
 
     fn release_close(&mut self, io: ConnectionType<Io>) {
         self.acquired -= 1;
-        if let Some(timeout) = self.disconnect_timeout {
+        if let Some(timeout) = self.config.disconnect_timeout {
             if let ConnectionType::H1(io) = io {
                 actix_rt::spawn(CloseConnection::new(io, timeout))
             }
         }
-        self.check_availibility();
+        self.check_availability();
     }
 
-    fn check_availibility(&self) {
+    fn check_availability(&self) {
-        if !self.waiters_queue.is_empty() && self.acquired < self.limit {
+        if !self.waiters_queue.is_empty() && self.acquired < self.config.limit {
             self.waker.wake();
         }
     }
@@ -480,6 +472,7 @@ where
                         tx,
                         this.inner.clone(),
                         this.connector.call(connect),
+                        inner.config.clone(),
                     );
                 }
             }
@@ -506,6 +499,7 @@ where
     >,
     rx: Option<oneshot::Sender<Result<IoConnection<Io>, ConnectError>>>,
     inner: Option<Rc<RefCell<Inner<Io>>>>,
+    config: ConnectorConfig,
 }
 
 impl<F, Io> OpenWaitingConnection<F, Io>
@@ -518,6 +512,7 @@ where
         rx: oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
         inner: Rc<RefCell<Inner<Io>>>,
         fut: F,
+        config: ConnectorConfig,
     ) {
         actix_rt::spawn(OpenWaitingConnection {
             key,
@@ -525,6 +520,7 @@ where
             h2: None,
             rx: Some(rx),
             inner: Some(inner),
+            config,
         })
     }
 }
@@ -538,7 +534,7 @@ where
         if let Some(inner) = self.project().inner.take() {
             let mut inner = inner.as_ref().borrow_mut();
             inner.release();
-            inner.check_availibility();
+            inner.check_availability();
         }
     }
 }
@@ -594,7 +590,7 @@ where
                     )));
                     Poll::Ready(())
                 } else {
-                    *this.h2 = Some(handshake(io).boxed_local());
+                    *this.h2 = Some(handshake(io, this.config).boxed_local());
                     self.poll(cx)
                 }
             }

actix-http/src/config.rs

@@ -114,7 +114,7 @@ impl ServiceConfig {
     }
 
     #[inline]
-    /// Return state of connection keep-alive funcitonality
+    /// Return state of connection keep-alive functionality
     pub fn keep_alive_enabled(&self) -> bool {
         self.0.ka_enabled
     }
@@ -214,7 +214,7 @@ impl Date {
         write!(
             self,
             "{}",
-            OffsetDateTime::now().format("%a, %d %b %Y %H:%M:%S GMT")
+            OffsetDateTime::now_utc().format("%a, %d %b %Y %H:%M:%S GMT")
         )
         .unwrap();
     }

actix-http/src/cookie/builder.rs

@@ -63,7 +63,7 @@ impl CookieBuilder {
     /// use actix_http::cookie::Cookie;
     ///
     /// let c = Cookie::build("foo", "bar")
-    ///     .expires(time::OffsetDateTime::now())
+    ///     .expires(time::OffsetDateTime::now_utc())
     ///     .finish();
     ///
     /// assert!(c.expires().is_some());

actix-http/src/cookie/jar.rs

@@ -13,7 +13,7 @@ use super::secure::{Key, PrivateJar, SignedJar};
 ///
 /// A `CookieJar` provides storage for any number of cookies. Any changes made
 /// to the jar are tracked; the changes can be retrieved via the
-/// [delta](#method.delta) method which returns an interator over the changes.
+/// [delta](#method.delta) method which returns an iterator over the changes.
 ///
 /// # Usage
 ///
@@ -221,7 +221,7 @@ impl CookieJar {
         if self.original_cookies.contains(cookie.name()) {
             cookie.set_value("");
             cookie.set_max_age(Duration::zero());
-            cookie.set_expires(OffsetDateTime::now() - Duration::days(365));
+            cookie.set_expires(OffsetDateTime::now_utc() - Duration::days(365));
             self.delta_cookies.replace(DeltaCookie::removed(cookie));
         } else {
             self.delta_cookies.remove(cookie.name());

actix-http/src/cookie/mod.rs

@@ -47,7 +47,7 @@
 //! ```
 
 #![doc(html_root_url = "https://docs.rs/cookie/0.11")]
-#![deny(missing_docs)]
+#![warn(missing_docs)]
 
 mod builder;
 mod delta;
@@ -103,7 +103,7 @@ enum CookieStr {
 
 impl CookieStr {
     /// Retrieves the string `self` corresponds to. If `self` is derived from
-    /// indexes, the corresponding subslice of `string` is returned. Otherwise,
+    /// indexes, the corresponding sub-slice of `string` is returned. Otherwise,
     /// the concrete string is returned.
     ///
     /// # Panics
@@ -733,7 +733,7 @@ impl<'c> Cookie<'c> {
     pub fn make_permanent(&mut self) {
         let twenty_years = Duration::days(365 * 20);
         self.set_max_age(twenty_years);
-        self.set_expires(OffsetDateTime::now() + twenty_years);
+        self.set_expires(OffsetDateTime::now_utc() + twenty_years);
     }
 
     fn fmt_parameters(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

actix-http/src/cookie/secure/key.rs

@@ -84,7 +84,7 @@ impl Key {
     }
 
     /// Generates signing/encryption keys from a secure, random source. Keys are
-    /// generated nondeterministically.
+    /// generated non-deterministically.
     ///
     /// # Panics
     ///
@@ -103,7 +103,7 @@ impl Key {
     }
 
     /// Attempts to generate signing/encryption keys from a secure, random
-    /// source. Keys are generated nondeterministically. If randomness cannot be
+    /// source. Keys are generated non-deterministically. If randomness cannot be
     /// retrieved from the underlying operating system, returns `None`.
     ///
     /// # Example

actix-http/src/error.rs

@@ -18,7 +18,7 @@ use serde::de::value::Error as DeError;
 use serde_json::error::Error as JsonError;
 use serde_urlencoded::ser::Error as FormError;
 
-// re-export for convinience
+// re-export for convenience
 use crate::body::Body;
 pub use crate::cookie::ParseError as CookieParseError;
 use crate::helpers::Writer;
@@ -34,7 +34,7 @@ pub type Result<T, E = Error> = result::Result<T, E>;
 
 /// General purpose actix web error.
 ///
-/// An actix web error is used to carry errors from `failure` or `std::error`
+/// An actix web error is used to carry errors from `std::error`
 /// through actix in a convenient way.  It can be created through
 /// converting errors with `into()`.
 ///
@@ -333,6 +333,8 @@ pub enum PayloadError {
     Io(io::Error),
 }
 
+impl std::error::Error for PayloadError {}
+
 impl From<h2::Error> for PayloadError {
     fn from(err: h2::Error) -> Self {
         PayloadError::Http2Payload(err)
@@ -430,7 +432,7 @@ pub enum DispatchError {
     Unknown,
 }
 
-/// A set of error that can occure during parsing content type
+/// A set of error that can occur during parsing content type
 #[derive(PartialEq, Debug, Display)]
 pub enum ContentTypeError {
     /// Can not parse content type
@@ -441,6 +443,8 @@ pub enum ContentTypeError {
     UnknownEncoding,
 }
 
+impl std::error::Error for ContentTypeError {}
+
 /// Return `BadRequest` for `ContentTypeError`
 impl ResponseError for ContentTypeError {
     fn status_code(&self) -> StatusCode {
@@ -946,10 +950,6 @@ where
     InternalError::new(err, StatusCode::NETWORK_AUTHENTICATION_REQUIRED).into()
 }
 
-#[cfg(feature = "failure")]
-/// Compatibility for `failure::Error`
-impl ResponseError for fail_ure::Error {}
-
 #[cfg(feature = "actors")]
 /// `InternalServerError` for `actix::MailboxError`
 /// This is supported on feature=`actors` only

actix-http/src/extensions.rs

@@ -6,6 +6,8 @@ use fxhash::FxHashMap;
 #[derive(Default)]
 /// A type map of request extensions.
 pub struct Extensions {
+    /// Use FxHasher with a std HashMap with for faster
+    /// lookups on the small `TypeId` (u64 equivalent) keys.
     map: FxHashMap<TypeId, Box<dyn Any>>,
 }
 
@@ -67,108 +69,113 @@ impl fmt::Debug for Extensions {
     }
 }
 
-#[test]
+#[cfg(test)]
-fn test_remove() {
+mod tests {
-    let mut map = Extensions::new();
+    use super::*;
+    
+    #[test]
+    fn test_remove() {
+        let mut map = Extensions::new();
 
-    map.insert::<i8>(123);
+        map.insert::<i8>(123);
-    assert!(map.get::<i8>().is_some());
+        assert!(map.get::<i8>().is_some());
 
-    map.remove::<i8>();
+        map.remove::<i8>();
-    assert!(map.get::<i8>().is_none());
+        assert!(map.get::<i8>().is_none());
-}
-
-#[test]
-fn test_clear() {
-    let mut map = Extensions::new();
-
-    map.insert::<i8>(8);
-    map.insert::<i16>(16);
-    map.insert::<i32>(32);
-
-    assert!(map.contains::<i8>());
-    assert!(map.contains::<i16>());
-    assert!(map.contains::<i32>());
-
-    map.clear();
-
-    assert!(!map.contains::<i8>());
-    assert!(!map.contains::<i16>());
-    assert!(!map.contains::<i32>());
-
-    map.insert::<i8>(10);
-    assert_eq!(*map.get::<i8>().unwrap(), 10);
-}
-
-#[test]
-fn test_integers() {
-    let mut map = Extensions::new();
-
-    map.insert::<i8>(8);
-    map.insert::<i16>(16);
-    map.insert::<i32>(32);
-    map.insert::<i64>(64);
-    map.insert::<i128>(128);
-    map.insert::<u8>(8);
-    map.insert::<u16>(16);
-    map.insert::<u32>(32);
-    map.insert::<u64>(64);
-    map.insert::<u128>(128);
-    assert!(map.get::<i8>().is_some());
-    assert!(map.get::<i16>().is_some());
-    assert!(map.get::<i32>().is_some());
-    assert!(map.get::<i64>().is_some());
-    assert!(map.get::<i128>().is_some());
-    assert!(map.get::<u8>().is_some());
-    assert!(map.get::<u16>().is_some());
-    assert!(map.get::<u32>().is_some());
-    assert!(map.get::<u64>().is_some());
-    assert!(map.get::<u128>().is_some());
-}
-
-#[test]
-fn test_composition() {
-    struct Magi<T>(pub T);
-
-    struct Madoka {
-        pub god: bool,
     }
 
-    struct Homura {
+    #[test]
-        pub attempts: usize,
+    fn test_clear() {
+        let mut map = Extensions::new();
+
+        map.insert::<i8>(8);
+        map.insert::<i16>(16);
+        map.insert::<i32>(32);
+
+        assert!(map.contains::<i8>());
+        assert!(map.contains::<i16>());
+        assert!(map.contains::<i32>());
+
+        map.clear();
+
+        assert!(!map.contains::<i8>());
+        assert!(!map.contains::<i16>());
+        assert!(!map.contains::<i32>());
+
+        map.insert::<i8>(10);
+        assert_eq!(*map.get::<i8>().unwrap(), 10);
     }
 
-    struct Mami {
+    #[test]
-        pub guns: usize,
+    fn test_integers() {
+        let mut map = Extensions::new();
+
+        map.insert::<i8>(8);
+        map.insert::<i16>(16);
+        map.insert::<i32>(32);
+        map.insert::<i64>(64);
+        map.insert::<i128>(128);
+        map.insert::<u8>(8);
+        map.insert::<u16>(16);
+        map.insert::<u32>(32);
+        map.insert::<u64>(64);
+        map.insert::<u128>(128);
+        assert!(map.get::<i8>().is_some());
+        assert!(map.get::<i16>().is_some());
+        assert!(map.get::<i32>().is_some());
+        assert!(map.get::<i64>().is_some());
+        assert!(map.get::<i128>().is_some());
+        assert!(map.get::<u8>().is_some());
+        assert!(map.get::<u16>().is_some());
+        assert!(map.get::<u32>().is_some());
+        assert!(map.get::<u64>().is_some());
+        assert!(map.get::<u128>().is_some());
     }
 
-    let mut map = Extensions::new();
+    #[test]
+    fn test_composition() {
+        struct Magi<T>(pub T);
 
-    map.insert(Magi(Madoka { god: false }));
+        struct Madoka {
-    map.insert(Magi(Homura { attempts: 0 }));
+            pub god: bool,
-    map.insert(Magi(Mami { guns: 999 }));
+        }
 
-    assert!(!map.get::<Magi<Madoka>>().unwrap().0.god);
+        struct Homura {
-    assert_eq!(0, map.get::<Magi<Homura>>().unwrap().0.attempts);
+            pub attempts: usize,
-    assert_eq!(999, map.get::<Magi<Mami>>().unwrap().0.guns);
+        }
-}
+
-
+        struct Mami {
-#[test]
+            pub guns: usize,
-fn test_extensions() {
+        }
-    #[derive(Debug, PartialEq)]
+
-    struct MyType(i32);
+        let mut map = Extensions::new();
-
+
-    let mut extensions = Extensions::new();
+        map.insert(Magi(Madoka { god: false }));
-
+        map.insert(Magi(Homura { attempts: 0 }));
-    extensions.insert(5i32);
+        map.insert(Magi(Mami { guns: 999 }));
-    extensions.insert(MyType(10));
+
-
+        assert!(!map.get::<Magi<Madoka>>().unwrap().0.god);
-    assert_eq!(extensions.get(), Some(&5i32));
+        assert_eq!(0, map.get::<Magi<Homura>>().unwrap().0.attempts);
-    assert_eq!(extensions.get_mut(), Some(&mut 5i32));
+        assert_eq!(999, map.get::<Magi<Mami>>().unwrap().0.guns);
-
+    }
-    assert_eq!(extensions.remove::<i32>(), Some(5i32));
+
-    assert!(extensions.get::<i32>().is_none());
+    #[test]
-
+    fn test_extensions() {
-    assert_eq!(extensions.get::<bool>(), None);
+        #[derive(Debug, PartialEq)]
-    assert_eq!(extensions.get(), Some(&MyType(10)));
+        struct MyType(i32);
+
+        let mut extensions = Extensions::new();
+
+        extensions.insert(5i32);
+        extensions.insert(MyType(10));
+
+        assert_eq!(extensions.get(), Some(&5i32));
+        assert_eq!(extensions.get_mut(), Some(&mut 5i32));
+
+        assert_eq!(extensions.remove::<i32>(), Some(5i32));
+        assert!(extensions.get::<i32>().is_none());
+
+        assert_eq!(extensions.get::<bool>(), None);
+        assert_eq!(extensions.get(), Some(&MyType(10)));
+    }
 }

actix-http/src/h1/decoder.rs

@@ -18,7 +18,7 @@ use crate::request::Request;
 const MAX_BUFFER_SIZE: usize = 131_072;
 const MAX_HEADERS: usize = 96;
 
-/// Incoming messagd decoder
+/// Incoming message decoder
 pub(crate) struct MessageDecoder<T: MessageType>(PhantomData<T>);
 
 #[derive(Debug)]

actix-http/src/h1/dispatcher.rs

@@ -73,7 +73,7 @@ where
     U::Error: fmt::Display,
 {
     Normal(#[pin] InnerDispatcher<T, S, B, X, U>),
-    Upgrade(#[pin] U::Future),
+    Upgrade(Pin<Box<U::Future>>),
 }
 
 #[pin_project]
@@ -123,8 +123,8 @@ where
     B: MessageBody,
 {
     None,
-    ExpectCall(#[pin] X::Future),
+    ExpectCall(Pin<Box<X::Future>>),
-    ServiceCall(#[pin] S::Future),
+    ServiceCall(Pin<Box<S::Future>>),
     SendPayload(#[pin] ResponseBody<B>),
 }
 
@@ -297,8 +297,8 @@ where
 
     /// Flush stream
     ///
-    /// true - got whouldblock
+    /// true - got WouldBlock
-    /// false - didnt get whouldblock
+    /// false - didn't get WouldBlock
     #[pin_project::project]
     fn poll_flush(
         self: Pin<&mut Self>,
@@ -391,11 +391,12 @@ where
                     }
                     None => None,
                 },
-                State::ExpectCall(fut) => match fut.poll(cx) {
+                State::ExpectCall(fut) => match fut.as_mut().poll(cx) {
                     Poll::Ready(Ok(req)) => {
                         self.as_mut().send_continue();
                         this = self.as_mut().project();
-                        this.state.set(State::ServiceCall(this.service.call(req)));
+                        this.state
+                            .set(State::ServiceCall(Box::pin(this.service.call(req))));
                         continue;
                     }
                     Poll::Ready(Err(e)) => {
@@ -405,7 +406,7 @@ where
                     }
                     Poll::Pending => None,
                 },
-                State::ServiceCall(fut) => match fut.poll(cx) {
+                State::ServiceCall(fut) => match fut.as_mut().poll(cx) {
                     Poll::Ready(Ok(res)) => {
                         let (res, body) = res.into().replace_body(());
                         let state = self.as_mut().send_response(res, body)?;
@@ -485,8 +486,8 @@ where
     ) -> Result<State<S, B, X>, DispatchError> {
         // Handle `EXPECT: 100-Continue` header
         let req = if req.head().expect() {
-            let mut task = self.as_mut().project().expect.call(req);
+            let mut task = Box::pin(self.as_mut().project().expect.call(req));
-            match unsafe { Pin::new_unchecked(&mut task) }.poll(cx) {
+            match task.as_mut().poll(cx) {
                 Poll::Ready(Ok(req)) => {
                     self.as_mut().send_continue();
                     req
@@ -504,8 +505,8 @@ where
         };
 
         // Call service
-        let mut task = self.as_mut().project().service.call(req);
+        let mut task = Box::pin(self.as_mut().project().service.call(req));
-        match unsafe { Pin::new_unchecked(&mut task) }.poll(cx) {
+        match task.as_mut().poll(cx) {
             Poll::Ready(Ok(res)) => {
                 let (res, body) = res.into().replace_body(());
                 self.send_response(res, body)
@@ -807,11 +808,11 @@ where
                             self.as_mut()
                                 .project()
                                 .inner
-                                .set(DispatcherState::Upgrade(upgrade));
+                                .set(DispatcherState::Upgrade(Box::pin(upgrade)));
                             return self.poll(cx);
                         }
 
-                        // we didnt get WouldBlock from write operation,
+                        // we didn't get WouldBlock from write operation,
                         // so data get written to kernel completely (OSX)
                         // and we have to write again otherwise response can get stuck
                         if inner.as_mut().poll_flush(cx)? || !drain {
@@ -855,7 +856,7 @@ where
                     }
                 }
             }
-            DispatcherState::Upgrade(fut) => fut.poll(cx).map_err(|e| {
+            DispatcherState::Upgrade(fut) => fut.as_mut().poll(cx).map_err(|e| {
                 error!("Upgrade handler error: {}", e);
                 DispatchError::Upgrade
             }),

actix-http/src/header/common/content_disposition.rs

@@ -90,40 +90,40 @@ pub enum DispositionParam {
     /// [RFC6266](https://tools.ietf.org/html/rfc6266) as *token "=" value*. Recipients should
     /// ignore unrecognizable parameters.
     Unknown(String, String),
-    /// An unrecognized extended paramater as defined in
+    /// An unrecognized extended parameter as defined in
     /// [RFC5987](https://tools.ietf.org/html/rfc5987) as *ext-parameter*, in
     /// [RFC6266](https://tools.ietf.org/html/rfc6266) as *ext-token "=" ext-value*. The single
-    /// trailling asterisk is not included. Recipients should ignore unrecognizable parameters.
+    /// trailing asterisk is not included. Recipients should ignore unrecognizable parameters.
     UnknownExt(String, ExtendedValue),
 }
 
 impl DispositionParam {
-    /// Returns `true` if the paramater is [`Name`](DispositionParam::Name).
+    /// Returns `true` if the parameter is [`Name`](DispositionParam::Name).
     #[inline]
     pub fn is_name(&self) -> bool {
         self.as_name().is_some()
     }
 
-    /// Returns `true` if the paramater is [`Filename`](DispositionParam::Filename).
+    /// Returns `true` if the parameter is [`Filename`](DispositionParam::Filename).
     #[inline]
     pub fn is_filename(&self) -> bool {
         self.as_filename().is_some()
     }
 
-    /// Returns `true` if the paramater is [`FilenameExt`](DispositionParam::FilenameExt).
+    /// Returns `true` if the parameter is [`FilenameExt`](DispositionParam::FilenameExt).
     #[inline]
     pub fn is_filename_ext(&self) -> bool {
         self.as_filename_ext().is_some()
     }
 
-    /// Returns `true` if the paramater is [`Unknown`](DispositionParam::Unknown) and the `name`
+    /// Returns `true` if the parameter is [`Unknown`](DispositionParam::Unknown) and the `name`
     #[inline]
     /// matches.
     pub fn is_unknown<T: AsRef<str>>(&self, name: T) -> bool {
         self.as_unknown(name).is_some()
     }
 
-    /// Returns `true` if the paramater is [`UnknownExt`](DispositionParam::UnknownExt) and the
+    /// Returns `true` if the parameter is [`UnknownExt`](DispositionParam::UnknownExt) and the
     /// `name` matches.
     #[inline]
     pub fn is_unknown_ext<T: AsRef<str>>(&self, name: T) -> bool {
@@ -373,7 +373,7 @@ impl ContentDisposition {
                 let param = if param_name.eq_ignore_ascii_case("name") {
                     DispositionParam::Name(value)
                 } else if param_name.eq_ignore_ascii_case("filename") {
-                    // See also comments in test_from_raw_uncessary_percent_decode.
+                    // See also comments in test_from_raw_unnecessary_percent_decode.
                     DispositionParam::Filename(value)
                 } else {
                     DispositionParam::Unknown(param_name.to_owned(), value)
@@ -529,7 +529,7 @@ impl fmt::Display for DispositionParam {
         //               ; to use within parameter values
         //
         //
-        // See also comments in test_from_raw_uncessary_percent_decode.
+        // See also comments in test_from_raw_unnecessary_percent_decode.
         lazy_static! {
             static ref RE: Regex = Regex::new("[\x00-\x08\x10-\x1F\x7F\"\\\\]").unwrap();
         }
@@ -676,7 +676,7 @@ mod tests {
     fn test_from_raw_unordered() {
         let a = HeaderValue::from_static(
             "form-data; dummy=3; filename=\"sample.png\" ; name=upload;",
-            // Actually, a trailling semolocon is not compliant. But it is fine to accept.
+            // Actually, a trailing semicolon is not compliant. But it is fine to accept.
         );
         let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
         let b = ContentDisposition {
@@ -833,7 +833,7 @@ mod tests {
     }
 
     #[test]
-    fn test_from_raw_uncessary_percent_decode() {
+    fn test_from_raw_unnecessary_percent_decode() {
         // In fact, RFC7578 (multipart/form-data) Section 2 and 4.2 suggests that filename with
         // non-ASCII characters MAY be percent-encoded.
         // On the contrary, RFC6266 or other RFCs related to Content-Disposition response header

actix-http/src/header/common/range.rs

@@ -7,7 +7,7 @@ use header::{Header, Raw};
 /// `Range` header, defined in [RFC7233](https://tools.ietf.org/html/rfc7233#section-3.1)
 ///
 /// The "Range" header field on a GET request modifies the method
-/// semantics to request transfer of only one or more subranges of the
+/// semantics to request transfer of only one or more sub-ranges of the
 /// selected representation data, rather than the entire selected
 /// representation data.
 ///
@@ -183,13 +183,13 @@ impl fmt::Display for Range {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Range::Bytes(ref ranges) => {
-                try!(write!(f, "bytes="));
+                write!(f, "bytes=")?;
 
                 for (i, range) in ranges.iter().enumerate() {
                     if i != 0 {
-                        try!(f.write_str(","));
+                        f.write_str(",")?;
                     }
-                    try!(Display::fmt(range, f));
+                    Display::fmt(range, f)?;
                 }
                 Ok(())
             }
@@ -214,9 +214,9 @@ impl FromStr for Range {
                 }
                 Ok(Range::Bytes(ranges))
             }
-            (Some(unit), Some(range_str)) if unit != "" && range_str != "" => Ok(
+            (Some(unit), Some(range_str)) if unit != "" && range_str != "" => {
-                Range::Unregistered(unit.to_owned(), range_str.to_owned()),
+                Ok(Range::Unregistered(unit.to_owned(), range_str.to_owned()))
-            ),
+            }
             _ => Err(::Error::Header),
         }
     }
@@ -229,7 +229,8 @@ impl FromStr for ByteRangeSpec {
         let mut parts = s.splitn(2, '-');
 
         match (parts.next(), parts.next()) {
-            (Some(""), Some(end)) => end.parse()
+            (Some(""), Some(end)) => end
+                .parse()
                 .or(Err(::Error::Header))
                 .map(ByteRangeSpec::Last),
             (Some(start), Some("")) => start
@@ -272,163 +273,138 @@ impl Header for Range {
     }
 }
 
-#[test]
+#[cfg(test)]
-fn test_parse_bytes_range_valid() {
+mod tests {
-    let r: Range = Header::parse_header(&"bytes=1-100".into()).unwrap();
+    use super::*;
-    let r2: Range = Header::parse_header(&"bytes=1-100,-".into()).unwrap();
-    let r3 = Range::bytes(1, 100);
-    assert_eq!(r, r2);
-    assert_eq!(r2, r3);
 
-    let r: Range = Header::parse_header(&"bytes=1-100,200-".into()).unwrap();
+    #[test]
-    let r2: Range =
+    fn test_parse_bytes_range_valid() {
-        Header::parse_header(&"bytes= 1-100 , 101-xxx,  200- ".into()).unwrap();
+        let r: Range = Header::parse_header(&"bytes=1-100".into()).unwrap();
-    let r3 = Range::Bytes(vec![
+        let r2: Range = Header::parse_header(&"bytes=1-100,-".into()).unwrap();
-        ByteRangeSpec::FromTo(1, 100),
+        let r3 = Range::bytes(1, 100);
-        ByteRangeSpec::AllFrom(200),
+        assert_eq!(r, r2);
-    ]);
+        assert_eq!(r2, r3);
-    assert_eq!(r, r2);
-    assert_eq!(r2, r3);
 
-    let r: Range = Header::parse_header(&"bytes=1-100,-100".into()).unwrap();
+        let r: Range = Header::parse_header(&"bytes=1-100,200-".into()).unwrap();
-    let r2: Range = Header::parse_header(&"bytes=1-100, ,,-100".into()).unwrap();
+        let r2: Range =
-    let r3 = Range::Bytes(vec![
+            Header::parse_header(&"bytes= 1-100 , 101-xxx,  200- ".into()).unwrap();
-        ByteRangeSpec::FromTo(1, 100),
+        let r3 = Range::Bytes(vec![
-        ByteRangeSpec::Last(100),
+            ByteRangeSpec::FromTo(1, 100),
-    ]);
+            ByteRangeSpec::AllFrom(200),
-    assert_eq!(r, r2);
+        ]);
-    assert_eq!(r2, r3);
+        assert_eq!(r, r2);
+        assert_eq!(r2, r3);
 
-    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+        let r: Range = Header::parse_header(&"bytes=1-100,-100".into()).unwrap();
-    let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+        let r2: Range = Header::parse_header(&"bytes=1-100, ,,-100".into()).unwrap();
-    assert_eq!(r, r2);
+        let r3 = Range::Bytes(vec![
-}
+            ByteRangeSpec::FromTo(1, 100),
-
+            ByteRangeSpec::Last(100),
-#[test]
+        ]);
-fn test_parse_unregistered_range_valid() {
+        assert_eq!(r, r2);
-    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+        assert_eq!(r2, r3);
-    let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+
-    assert_eq!(r, r2);
+        let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
-
+        let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
-    let r: Range = Header::parse_header(&"custom=abcd".into()).unwrap();
+        assert_eq!(r, r2);
-    let r2 = Range::Unregistered("custom".to_owned(), "abcd".to_owned());
+    }
-    assert_eq!(r, r2);
+
-
+    #[test]
-    let r: Range = Header::parse_header(&"custom=xxx-yyy".into()).unwrap();
+    fn test_parse_unregistered_range_valid() {
-    let r2 = Range::Unregistered("custom".to_owned(), "xxx-yyy".to_owned());
+        let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
-    assert_eq!(r, r2);
+        let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
-}
+        assert_eq!(r, r2);
-
+
-#[test]
+        let r: Range = Header::parse_header(&"custom=abcd".into()).unwrap();
-fn test_parse_invalid() {
+        let r2 = Range::Unregistered("custom".to_owned(), "abcd".to_owned());
-    let r: ::Result<Range> = Header::parse_header(&"bytes=1-a,-".into());
+        assert_eq!(r, r2);
-    assert_eq!(r.ok(), None);
+
-
+        let r: Range = Header::parse_header(&"custom=xxx-yyy".into()).unwrap();
-    let r: ::Result<Range> = Header::parse_header(&"bytes=1-2-3".into());
+        let r2 = Range::Unregistered("custom".to_owned(), "xxx-yyy".to_owned());
-    assert_eq!(r.ok(), None);
+        assert_eq!(r, r2);
-
+    }
-    let r: ::Result<Range> = Header::parse_header(&"abc".into());
+
-    assert_eq!(r.ok(), None);
+    #[test]
-
+    fn test_parse_invalid() {
-    let r: ::Result<Range> = Header::parse_header(&"bytes=1-100=".into());
+        let r: ::Result<Range> = Header::parse_header(&"bytes=1-a,-".into());
-    assert_eq!(r.ok(), None);
+        assert_eq!(r.ok(), None);
-
+
-    let r: ::Result<Range> = Header::parse_header(&"bytes=".into());
+        let r: ::Result<Range> = Header::parse_header(&"bytes=1-2-3".into());
-    assert_eq!(r.ok(), None);
+        assert_eq!(r.ok(), None);
-
+
-    let r: ::Result<Range> = Header::parse_header(&"custom=".into());
+        let r: ::Result<Range> = Header::parse_header(&"abc".into());
-    assert_eq!(r.ok(), None);
+        assert_eq!(r.ok(), None);
-
+
-    let r: ::Result<Range> = Header::parse_header(&"=1-100".into());
+        let r: ::Result<Range> = Header::parse_header(&"bytes=1-100=".into());
-    assert_eq!(r.ok(), None);
+        assert_eq!(r.ok(), None);
-}
+
-
+        let r: ::Result<Range> = Header::parse_header(&"bytes=".into());
-#[test]
+        assert_eq!(r.ok(), None);
-fn test_fmt() {
+
-    use header::Headers;
+        let r: ::Result<Range> = Header::parse_header(&"custom=".into());
-
+        assert_eq!(r.ok(), None);
-    let mut headers = Headers::new();
+
-
+        let r: ::Result<Range> = Header::parse_header(&"=1-100".into());
-    headers.set(Range::Bytes(vec![
+        assert_eq!(r.ok(), None);
-        ByteRangeSpec::FromTo(0, 1000),
+    }
-        ByteRangeSpec::AllFrom(2000),
+
-    ]));
+    #[test]
-    assert_eq!(&headers.to_string(), "Range: bytes=0-1000,2000-\r\n");
+    fn test_fmt() {
-
+        use header::Headers;
-    headers.clear();
+
-    headers.set(Range::Bytes(vec![]));
+        let mut headers = Headers::new();
-
+
-    assert_eq!(&headers.to_string(), "Range: bytes=\r\n");
+        headers.set(Range::Bytes(vec![
-
+            ByteRangeSpec::FromTo(0, 1000),
-    headers.clear();
+            ByteRangeSpec::AllFrom(2000),
-    headers.set(Range::Unregistered(
+        ]));
-        "custom".to_owned(),
+        assert_eq!(&headers.to_string(), "Range: bytes=0-1000,2000-\r\n");
-        "1-xxx".to_owned(),
+
-    ));
+        headers.clear();
-
+        headers.set(Range::Bytes(vec![]));
-    assert_eq!(&headers.to_string(), "Range: custom=1-xxx\r\n");
+
-}
+        assert_eq!(&headers.to_string(), "Range: bytes=\r\n");
-
+
-#[test]
+        headers.clear();
-fn test_byte_range_spec_to_satisfiable_range() {
+        headers.set(Range::Unregistered("custom".to_owned(), "1-xxx".to_owned()));
-    assert_eq!(
+
-        Some((0, 0)),
+        assert_eq!(&headers.to_string(), "Range: custom=1-xxx\r\n");
-        ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(3)
+    }
-    );
+
-    assert_eq!(
+    #[test]
-        Some((1, 2)),
+    fn test_byte_range_spec_to_satisfiable_range() {
-        ByteRangeSpec::FromTo(1, 2).to_satisfiable_range(3)
+        assert_eq!(
-    );
+            Some((0, 0)),
-    assert_eq!(
+            ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(3)
-        Some((1, 2)),
+        );
-        ByteRangeSpec::FromTo(1, 5).to_satisfiable_range(3)
+        assert_eq!(
-    );
+            Some((1, 2)),
-    assert_eq!(
+            ByteRangeSpec::FromTo(1, 2).to_satisfiable_range(3)
-        None,
+        );
-        ByteRangeSpec::FromTo(3, 3).to_satisfiable_range(3)
+        assert_eq!(
-    );
+            Some((1, 2)),
-    assert_eq!(
+            ByteRangeSpec::FromTo(1, 5).to_satisfiable_range(3)
-        None,
+        );
-        ByteRangeSpec::FromTo(2, 1).to_satisfiable_range(3)
+        assert_eq!(None, ByteRangeSpec::FromTo(3, 3).to_satisfiable_range(3));
-    );
+        assert_eq!(None, ByteRangeSpec::FromTo(2, 1).to_satisfiable_range(3));
-    assert_eq!(
+        assert_eq!(None, ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(0));
-        None,
+
-        ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(0)
+        assert_eq!(
-    );
+            Some((0, 2)),
-
+            ByteRangeSpec::AllFrom(0).to_satisfiable_range(3)
-    assert_eq!(
+        );
-        Some((0, 2)),
+        assert_eq!(
-        ByteRangeSpec::AllFrom(0).to_satisfiable_range(3)
+            Some((2, 2)),
-    );
+            ByteRangeSpec::AllFrom(2).to_satisfiable_range(3)
-    assert_eq!(
+        );
-        Some((2, 2)),
+        assert_eq!(None, ByteRangeSpec::AllFrom(3).to_satisfiable_range(3));
-        ByteRangeSpec::AllFrom(2).to_satisfiable_range(3)
+        assert_eq!(None, ByteRangeSpec::AllFrom(5).to_satisfiable_range(3));
-    );
+        assert_eq!(None, ByteRangeSpec::AllFrom(0).to_satisfiable_range(0));
-    assert_eq!(
+
-        None,
+        assert_eq!(Some((1, 2)), ByteRangeSpec::Last(2).to_satisfiable_range(3));
-        ByteRangeSpec::AllFrom(3).to_satisfiable_range(3)
+        assert_eq!(Some((2, 2)), ByteRangeSpec::Last(1).to_satisfiable_range(3));
-    );
+        assert_eq!(Some((0, 2)), ByteRangeSpec::Last(5).to_satisfiable_range(3));
-    assert_eq!(
+        assert_eq!(None, ByteRangeSpec::Last(0).to_satisfiable_range(3));
-        None,
+        assert_eq!(None, ByteRangeSpec::Last(2).to_satisfiable_range(0));
-        ByteRangeSpec::AllFrom(5).to_satisfiable_range(3)
+    }
-    );
-    assert_eq!(
-        None,
-        ByteRangeSpec::AllFrom(0).to_satisfiable_range(0)
-    );
-
-    assert_eq!(
-        Some((1, 2)),
-        ByteRangeSpec::Last(2).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        Some((2, 2)),
-        ByteRangeSpec::Last(1).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        Some((0, 2)),
-        ByteRangeSpec::Last(5).to_satisfiable_range(3)
-    );
-    assert_eq!(None, ByteRangeSpec::Last(0).to_satisfiable_range(3));
-    assert_eq!(None, ByteRangeSpec::Last(2).to_satisfiable_range(0));
 }

actix-http/src/header/map.rs

@@ -7,7 +7,7 @@ use http::header::{HeaderName, HeaderValue};
 
 /// A set of HTTP headers
 ///
-/// `HeaderMap` is an multimap of [`HeaderName`] to values.
+/// `HeaderMap` is an multi-map of [`HeaderName`] to values.
 ///
 /// [`HeaderName`]: struct.HeaderName.html
 #[derive(Debug, Clone)]

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

@@ -137,17 +137,22 @@ impl FromStr for Charset {
     }
 }
 
-#[test]
+#[cfg(test)]
-fn test_parse() {
+mod tests {
-    assert_eq!(Us_Ascii, "us-ascii".parse().unwrap());
+    use super::*;
-    assert_eq!(Us_Ascii, "US-Ascii".parse().unwrap());
-    assert_eq!(Us_Ascii, "US-ASCII".parse().unwrap());
-    assert_eq!(Shift_Jis, "Shift-JIS".parse().unwrap());
-    assert_eq!(Ext("ABCD".to_owned()), "abcd".parse().unwrap());
-}
 
-#[test]
+    #[test]
-fn test_display() {
+    fn test_parse() {
-    assert_eq!("US-ASCII", format!("{}", Us_Ascii));
+        assert_eq!(Us_Ascii, "us-ascii".parse().unwrap());
-    assert_eq!("ABCD", format!("{}", Ext("ABCD".to_owned())));
+        assert_eq!(Us_Ascii, "US-Ascii".parse().unwrap());
+        assert_eq!(Us_Ascii, "US-ASCII".parse().unwrap());
+        assert_eq!(Shift_Jis, "Shift-JIS".parse().unwrap());
+        assert_eq!(Ext("ABCD".to_owned()), "abcd".parse().unwrap());
+    }
+
+    #[test]
+    fn test_display() {
+        assert_eq!("US-ASCII", format!("{}", Us_Ascii));
+        assert_eq!("ABCD", format!("{}", Ext("ABCD".to_owned())));
+    }
 }

actix-http/src/helpers.rs

@@ -1,69 +1,34 @@
-use std::{io, ptr};
+use std::io;
 
 use bytes::{BufMut, BytesMut};
 use http::Version;
 
 use crate::extensions::Extensions;
 
-const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
-      2021222324252627282930313233343536373839\
-      4041424344454647484950515253545556575859\
-      6061626364656667686970717273747576777879\
-      8081828384858687888990919293949596979899";
-
-pub(crate) const STATUS_LINE_BUF_SIZE: usize = 13;
-
-pub(crate) fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
-    let mut buf: [u8; STATUS_LINE_BUF_SIZE] = *b"HTTP/1.1     ";
-    match version {
-        Version::HTTP_2 => buf[5] = b'2',
-        Version::HTTP_10 => buf[7] = b'0',
-        Version::HTTP_09 => {
-            buf[5] = b'0';
-            buf[7] = b'9';
-        }
-        _ => (),
-    }
-
-    let mut curr: isize = 12;
-    let buf_ptr = buf.as_mut_ptr();
-    let lut_ptr = DEC_DIGITS_LUT.as_ptr();
-    let four = n > 999;
-
-    // decode 2 more chars, if > 2 chars
-    let d1 = (n % 100) << 1;
-    n /= 100;
-    curr -= 2;
-    unsafe {
-        ptr::copy_nonoverlapping(lut_ptr.offset(d1 as isize), buf_ptr.offset(curr), 2);
-    }
-
-    // decode last 1 or 2 chars
-    if n < 10 {
-        curr -= 1;
-        unsafe {
-            *buf_ptr.offset(curr) = (n as u8) + b'0';
-        }
-    } else {
-        let d1 = n << 1;
-        curr -= 2;
-        unsafe {
-            ptr::copy_nonoverlapping(
-                lut_ptr.offset(d1 as isize),
-                buf_ptr.offset(curr),
-                2,
-            );
-        }
-    }
-
-    bytes.put_slice(&buf);
-    if four {
-        bytes.put_u8(b' ');
-    }
-}
-
 const DIGITS_START: u8 = b'0';
 
+pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
+    match version {
+        Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
+        Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
+        Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
+        _ => {
+            // other HTTP version handlers do not use this method
+        }
+    }
+
+    let d100 = (n / 100) as u8;
+    let d10 = ((n / 10) % 10) as u8;
+    let d1 = (n % 10) as u8;
+
+    bytes.put_u8(DIGITS_START + d100);
+    bytes.put_u8(DIGITS_START + d10);
+    bytes.put_u8(DIGITS_START + d1);
+
+    // trailing space before reason
+    bytes.put_u8(b' ');
+}
+
 /// NOTE: bytes object has to contain enough space
 pub fn write_content_length(n: usize, bytes: &mut BytesMut) {
     bytes.put_slice(b"\r\ncontent-length: ");
@@ -189,8 +154,28 @@ impl<T: Clone + 'static> DataFactory for Data<T> {
 
 #[cfg(test)]
 mod tests {
+    use std::str::from_utf8;
+
     use super::*;
 
+    #[test]
+    fn test_status_line() {
+        let mut bytes = BytesMut::new();
+        bytes.reserve(50);
+        write_status_line(Version::HTTP_11, 200, &mut bytes);
+        assert_eq!(from_utf8(&bytes.split().freeze()).unwrap(), "HTTP/1.1 200 ");
+
+        let mut bytes = BytesMut::new();
+        bytes.reserve(50);
+        write_status_line(Version::HTTP_09, 404, &mut bytes);
+        assert_eq!(from_utf8(&bytes.split().freeze()).unwrap(), "HTTP/0.9 404 ");
+
+        let mut bytes = BytesMut::new();
+        bytes.reserve(50);
+        write_status_line(Version::HTTP_09, 515, &mut bytes);
+        assert_eq!(from_utf8(&bytes.split().freeze()).unwrap(), "HTTP/0.9 515 ");
+    }
+
     #[test]
     fn test_write_content_length() {
         let mut bytes = BytesMut::new();

actix-http/src/lib.rs

@@ -1,5 +1,5 @@
 //! Basic http primitives for actix-net framework.
-#![deny(rust_2018_idioms, warnings)]
+#![warn(rust_2018_idioms, warnings)]
 #![allow(
     clippy::type_complexity,
     clippy::too_many_arguments,

actix-http/src/message.rs

@@ -99,13 +99,13 @@ impl RequestHead {
     }
 
     /// Is to uppercase headers with Camel-Case.
-    /// Befault is `false`
+    /// Default is `false`
     #[inline]
     pub fn camel_case_headers(&self) -> bool {
         self.flags.contains(Flags::CAMEL_CASE)
     }
 
-    /// Set `true` to send headers which are uppercased with Camel-Case.
+    /// Set `true` to send headers which are formatted as Camel-Case.
     #[inline]
     pub fn set_camel_case_headers(&mut self, val: bool) {
         if val {

actix-http/src/time_parser.rs

@@ -19,7 +19,7 @@ fn try_parse_rfc_850(time: &str) -> Option<PrimitiveDateTime> {
             // If the `time` string contains a two-digit year, then as per RFC 2616 § 19.3,
             // we consider the year as part of this century if it's within the next 50 years,
             // otherwise we consider as part of the previous century.
-            let now = OffsetDateTime::now();
+            let now = OffsetDateTime::now_utc();
             let century_start_year = (now.year() / 100) * 100;
             let mut expanded_year = century_start_year + dt.year();
 

actix-http/src/ws/codec.rs

@@ -137,7 +137,7 @@ impl Encoder for Codec {
                         Parser::write_message(
                             dst,
                             &data[..],
-                            OpCode::Binary,
+                            OpCode::Text,
                             false,
                             !self.flags.contains(Flags::SERVER),
                         )
@@ -151,7 +151,7 @@ impl Encoder for Codec {
                         Parser::write_message(
                             dst,
                             &data[..],
-                            OpCode::Text,
+                            OpCode::Binary,
                             false,
                             !self.flags.contains(Flags::SERVER),
                         )

actix-http/src/ws/mod.rs

@@ -58,6 +58,8 @@ pub enum ProtocolError {
     Io(io::Error),
 }
 
+impl std::error::Error for ProtocolError {}
+
 impl ResponseError for ProtocolError {}
 
 /// Websocket handshake errors
@@ -108,7 +110,7 @@ impl ResponseError for HandshakeError {
     }
 }
 
-/// Verify `WebSocket` handshake request and create handshake reponse.
+/// Verify `WebSocket` handshake request and create handshake response.
 // /// `protocols` is a sequence of known protocols. On successful handshake,
 // /// the returned response headers contain the first protocol in this list
 // /// which the server also knows.
@@ -168,7 +170,7 @@ pub fn verify_handshake(req: &RequestHead) -> Result<(), HandshakeError> {
     Ok(())
 }
 
-/// Create websocket's handshake response
+/// Create websocket handshake response
 ///
 /// This function returns handshake `Response`, ready to send to peer.
 pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {

actix-http/src/ws/proto.rs

@@ -203,7 +203,7 @@ impl<T: Into<String>> From<(CloseCode, T)> for CloseReason {
 
 static WS_GUID: &str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
-// TODO: hash is always same size, we dont need String
+// TODO: hash is always same size, we don't need String
 pub fn hash_key(key: &[u8]) -> String {
     use sha1::Digest;
     let mut hasher = sha1::Sha1::new();

actix-http/tests/test_client.rs

@@ -33,7 +33,8 @@ async fn test_h1_v2() {
         HttpService::build()
             .finish(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -61,7 +62,8 @@ async fn test_connection_close() {
             .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .tcp()
             .map(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.get("/").force_close().send().await.unwrap();
     assert!(response.status().is_success());
@@ -80,7 +82,8 @@ async fn test_with_query_parameter() {
             })
             .tcp()
             .map(|_| ())
-    });
+    })
+    .await;
 
     let request = srv.request(http::Method::GET, srv.url("/?qp=5"));
     let response = request.send().await.unwrap();

actix-http/tests/test_openssl.rs

@@ -67,7 +67,8 @@ async fn test_h2() -> io::Result<()> {
             .h2(|_| ok::<_, Error>(Response::Ok().finish()))
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -85,7 +86,8 @@ async fn test_h2_1() -> io::Result<()> {
             })
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -103,7 +105,8 @@ async fn test_h2_body() -> io::Result<()> {
             })
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send_body(data.clone()).await.unwrap();
     assert!(response.status().is_success());
@@ -131,7 +134,8 @@ async fn test_h2_content_length() {
             })
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let header = HeaderName::from_static("content-length");
     let value = HeaderValue::from_static("0");
@@ -192,7 +196,7 @@ async fn test_h2_headers() {
         })
             .openssl(ssl_acceptor())
                     .map_err(|_| ())
-    });
+    }).await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -231,7 +235,8 @@ async fn test_h2_body2() {
             .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -248,7 +253,8 @@ async fn test_h2_head_empty() {
             .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.shead("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -273,7 +279,8 @@ async fn test_h2_head_binary() {
             })
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.shead("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -295,7 +302,8 @@ async fn test_h2_head_binary2() {
             .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.shead("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -318,7 +326,8 @@ async fn test_h2_body_length() {
             })
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -342,7 +351,8 @@ async fn test_h2_body_chunked_explicit() {
             })
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -369,7 +379,8 @@ async fn test_h2_response_http_error_handling() {
             }))
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
@@ -386,7 +397,8 @@ async fn test_h2_service_error() {
             .h2(|_| err::<Response, Error>(ErrorBadRequest("error")))
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert_eq!(response.status(), StatusCode::BAD_REQUEST);
@@ -407,7 +419,8 @@ async fn test_h2_on_connect() {
             })
             .openssl(ssl_acceptor())
             .map_err(|_| ())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());

actix-http/tests/test_rustls.rs

@@ -45,7 +45,8 @@ async fn test_h1() -> io::Result<()> {
         HttpService::build()
             .h1(|_| future::ok::<_, Error>(Response::Ok().finish()))
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -58,7 +59,8 @@ async fn test_h2() -> io::Result<()> {
         HttpService::build()
             .h2(|_| future::ok::<_, Error>(Response::Ok().finish()))
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -75,7 +77,8 @@ async fn test_h1_1() -> io::Result<()> {
                 future::ok::<_, Error>(Response::Ok().finish())
             })
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -92,7 +95,8 @@ async fn test_h2_1() -> io::Result<()> {
                 future::ok::<_, Error>(Response::Ok().finish())
             })
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -109,7 +113,8 @@ async fn test_h2_body1() -> io::Result<()> {
                 Ok::<_, Error>(Response::Ok().body(body))
             })
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send_body(data.clone()).await.unwrap();
     assert!(response.status().is_success());
@@ -136,7 +141,8 @@ async fn test_h2_content_length() {
                 future::ok::<_, ()>(Response::new(statuses[indx]))
             })
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let header = HeaderName::from_static("content-length");
     let value = HeaderValue::from_static("0");
@@ -195,7 +201,7 @@ async fn test_h2_headers() {
             future::ok::<_, ()>(config.body(data.clone()))
         })
             .rustls(ssl_acceptor())
-    });
+    }).await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -233,7 +239,8 @@ async fn test_h2_body2() {
         HttpService::build()
             .h2(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -249,7 +256,8 @@ async fn test_h2_head_empty() {
         HttpService::build()
             .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.shead("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -276,7 +284,8 @@ async fn test_h2_head_binary() {
                 ok::<_, ()>(Response::Ok().content_length(STR.len() as u64).body(STR))
             })
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.shead("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -300,7 +309,8 @@ async fn test_h2_head_binary2() {
         HttpService::build()
             .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.shead("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -325,7 +335,8 @@ async fn test_h2_body_length() {
                 )
             })
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -348,7 +359,8 @@ async fn test_h2_body_chunked_explicit() {
                 )
             })
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -376,7 +388,8 @@ async fn test_h2_response_http_error_handling() {
                 }))
             }))
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
@@ -392,7 +405,8 @@ async fn test_h2_service_error() {
         HttpService::build()
             .h2(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
@@ -408,7 +422,8 @@ async fn test_h1_service_error() {
         HttpService::build()
             .h1(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
             .rustls(ssl_acceptor())
-    });
+    })
+    .await;
 
     let response = srv.sget("/").send().await.unwrap();
     assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);

actix-http/tests/test_server.rs

@@ -27,7 +27,8 @@ async fn test_h1() {
                 future::ok::<_, ()>(Response::Ok().finish())
             })
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -46,7 +47,8 @@ async fn test_h1_2() {
                 future::ok::<_, ()>(Response::Ok().finish())
             })
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -65,7 +67,8 @@ async fn test_expect_continue() {
             }))
             .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
@@ -95,7 +98,8 @@ async fn test_expect_continue_h1() {
             }))
             .h1(fn_service(|_| future::ok::<_, ()>(Response::Ok().finish())))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
@@ -130,7 +134,8 @@ async fn test_chunked_payload() {
                     })
             }))
             .tcp()
-    });
+    })
+    .await;
 
     let returned_size = {
         let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
@@ -172,7 +177,8 @@ async fn test_slow_request() {
             .client_timeout(100)
             .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n");
@@ -187,7 +193,8 @@ async fn test_http1_malformed_request() {
         HttpService::build()
             .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test/tests/test HTTP1.1\r\n");
@@ -202,7 +209,8 @@ async fn test_http1_keepalive() {
         HttpService::build()
             .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
@@ -223,7 +231,8 @@ async fn test_http1_keepalive_timeout() {
             .keep_alive(1)
             .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
@@ -243,7 +252,8 @@ async fn test_http1_keepalive_close() {
         HttpService::build()
             .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ =
@@ -263,7 +273,8 @@ async fn test_http10_keepalive_default_close() {
         HttpService::build()
             .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test/tests/test HTTP/1.0\r\n\r\n");
@@ -282,7 +293,8 @@ async fn test_http10_keepalive() {
         HttpService::build()
             .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream
@@ -309,7 +321,8 @@ async fn test_http1_keepalive_disabled() {
             .keep_alive(KeepAlive::Disabled)
             .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
             .tcp()
-    });
+    })
+    .await;
 
     let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
     let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
@@ -344,7 +357,8 @@ async fn test_content_length() {
                 future::ok::<_, ()>(Response::new(statuses[indx]))
             })
             .tcp()
-    });
+    })
+    .await;
 
     let header = HeaderName::from_static("content-length");
     let value = HeaderValue::from_static("0");
@@ -397,7 +411,7 @@ async fn test_h1_headers() {
             }
             future::ok::<_, ()>(builder.body(data.clone()))
         }).tcp()
-    });
+    }).await;
 
     let response = srv.get("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -435,7 +449,8 @@ async fn test_h1_body() {
         HttpService::build()
             .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -451,7 +466,8 @@ async fn test_h1_head_empty() {
         HttpService::build()
             .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.head("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -477,7 +493,8 @@ async fn test_h1_head_binary() {
                 ok::<_, ()>(Response::Ok().content_length(STR.len() as u64).body(STR))
             })
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.head("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -501,7 +518,8 @@ async fn test_h1_head_binary2() {
         HttpService::build()
             .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.head("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -526,7 +544,8 @@ async fn test_h1_body_length() {
                 )
             })
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -549,7 +568,8 @@ async fn test_h1_body_chunked_explicit() {
                 )
             })
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -579,7 +599,8 @@ async fn test_h1_body_chunked_implicit() {
                 ok::<_, ()>(Response::Ok().streaming(body))
             })
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert!(response.status().is_success());
@@ -611,7 +632,8 @@ async fn test_h1_response_http_error_handling() {
                 )
             }))
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
@@ -627,7 +649,8 @@ async fn test_h1_service_error() {
         HttpService::build()
             .h1(|_| future::err::<Response, Error>(error::ErrorBadRequest("error")))
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
@@ -647,7 +670,8 @@ async fn test_h1_on_connect() {
                 future::ok::<_, ()>(Response::Ok().finish())
             })
             .tcp()
-    });
+    })
+    .await;
 
     let response = srv.get("/").send().await.unwrap();
     assert!(response.status().is_success());

actix-http/tests/test_ws.rs

@@ -93,7 +93,8 @@ async fn test_simple() {
                 .finish(|_| future::ok::<_, ()>(Response::NotFound()))
                 .tcp()
         }
-    });
+    })
+    .await;
 
     // client service
     let mut framed = srv.ws().await.unwrap();

actix-identity/README.md

@@ -1,5 +1,7 @@
 # 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)
 
+**This crate moved to https://github.com/actix/actix-extras.**
+
 ## Documentation & community resources
 
 * [User Guide](https://actix.rs/docs/)

actix-multipart/CHANGES.md

@@ -4,6 +4,8 @@
 
 * Remove the unused `time` dependency
 
+* Fix missing `std::error::Error` implement for `MultipartError`.
+
 ## [0.2.0] - 2019-12-20
 
 * Release

actix-multipart/Cargo.toml

@@ -16,7 +16,7 @@ name = "actix_multipart"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = { version = "2.0.0", default-features = false }
+actix-web = { version = "3.0.0-alpha.1", default-features = false }
 actix-service = "1.0.1"
 actix-utils = "1.0.3"
 bytes = "0.5.3"
@@ -29,4 +29,4 @@ twoway = "0.2"
 
 [dev-dependencies]
 actix-rt = "1.0.0"
-actix-http = "2.0.0-alpha.1"
+actix-http = "2.0.0-alpha.3"

actix-multipart/src/error.rs

@@ -33,6 +33,8 @@ pub enum MultipartError {
     NotConsumed,
 }
 
+impl std::error::Error for MultipartError {}
+
 /// Return `BadRequest` for `MultipartError`
 impl ResponseError for MultipartError {
     fn status_code(&self) -> StatusCode {

actix-session/README.md

@@ -1,5 +1,7 @@
 # Session 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-session)](https://crates.io/crates/actix-session) [![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)
 
+**This crate moved to https://github.com/actix/actix-extras.**
+
 ## Documentation & community resources
 
 * [User Guide](https://actix.rs/docs/)

actix-web-actors/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+# [3.0.0-alpha.1] - 2020-05-08
+
+* Update the actix-web dependency to 3.0.0-alpha.1
+* Update the actix dependency to 0.10.0-alpha.2
+* Update the actix-http dependency to 2.0.0-alpha.3
+
 ## [2.0.0] - 2019-12-20
 
 * Release

actix-web-actors/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web-actors"
-version = "2.0.0"
+version = "3.0.0-alpha.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix actors support for actix web framework."
 readme = "README.md"
@@ -16,9 +16,9 @@ name = "actix_web_actors"
 path = "src/lib.rs"
 
 [dependencies]
-actix = "0.10.0-alpha.1"
+actix = "0.10.0-alpha.2"
-actix-web = "2.0.0"
+actix-web = "3.0.0-alpha.1"
-actix-http = "2.0.0-alpha.1"
+actix-http = "2.0.0-alpha.3"
 actix-codec = "0.2.0"
 bytes = "0.5.2"
 futures = "0.3.1"
@@ -26,4 +26,4 @@ pin-project = "0.4.6"
 
 [dev-dependencies]
 actix-rt = "1.0.0"
-env_logger = "0.6"
+env_logger = "0.7"

actix-web-actors/src/context.rs

@@ -174,7 +174,7 @@ where
 
         // frames
         if let Some(data) = self.fut.ctx().stream.pop_front() {
-            Poll::Ready(data.map(|b| Ok(b)))
+            Poll::Ready(data.map(Ok))
         } else if self.fut.alive() {
             Poll::Pending
         } else {

actix-web-codegen/Cargo.toml

@@ -18,5 +18,5 @@ proc-macro2 = "^1"
 
 [dev-dependencies]
 actix-rt = "1.0.0"
-actix-web = "2.0.0"
+actix-web = "3.0.0-alpha.1"
 futures = "0.3.1"

actix-web-codegen/src/lib.rs

@@ -21,6 +21,7 @@
 //!
 //! - `"path"` - Raw literal string with path for which to register handle. Mandatory.
 //! - `guard="function_name"` - Registers function as guard using `actix_web::guard::fn_guard`
+//! - `wrap="Middleware"` - Registers a resource middleware.
 //!
 //! ## Notes
 //!
@@ -45,7 +46,6 @@ extern crate proc_macro;
 mod route;
 
 use proc_macro::TokenStream;
-use syn::parse_macro_input;
 
 /// Creates route handler with `GET` method guard.
 ///
@@ -55,14 +55,10 @@ use syn::parse_macro_input;
 ///
 /// - `"path"` - Raw literal string with path for which to register handler. Mandatory.
 /// - `guard="function_name"` - Registers function as guard using `actix_web::guard::fn_guard`
+/// - `wrap="Middleware"` - Registers a resource middleware.
 #[proc_macro_attribute]
 pub fn get(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as syn::AttributeArgs);
+    route::generate(args, input, route::GuardType::Get)
-    let gen = match route::Route::new(args, input, route::GuardType::Get) {
-        Ok(gen) => gen,
-        Err(err) => return err.to_compile_error().into(),
-    };
-    gen.generate()
 }
 
 /// Creates route handler with `POST` method guard.
@@ -72,12 +68,7 @@ pub fn get(args: TokenStream, input: TokenStream) -> TokenStream {
 /// Attributes are the same as in [get](attr.get.html)
 #[proc_macro_attribute]
 pub fn post(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as syn::AttributeArgs);
+    route::generate(args, input, route::GuardType::Post)
-    let gen = match route::Route::new(args, input, route::GuardType::Post) {
-        Ok(gen) => gen,
-        Err(err) => return err.to_compile_error().into(),
-    };
-    gen.generate()
 }
 
 /// Creates route handler with `PUT` method guard.
@@ -87,12 +78,7 @@ pub fn post(args: TokenStream, input: TokenStream) -> TokenStream {
 /// Attributes are the same as in [get](attr.get.html)
 #[proc_macro_attribute]
 pub fn put(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as syn::AttributeArgs);
+    route::generate(args, input, route::GuardType::Put)
-    let gen = match route::Route::new(args, input, route::GuardType::Put) {
-        Ok(gen) => gen,
-        Err(err) => return err.to_compile_error().into(),
-    };
-    gen.generate()
 }
 
 /// Creates route handler with `DELETE` method guard.
@@ -102,12 +88,7 @@ pub fn put(args: TokenStream, input: TokenStream) -> TokenStream {
 /// Attributes are the same as in [get](attr.get.html)
 #[proc_macro_attribute]
 pub fn delete(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as syn::AttributeArgs);
+    route::generate(args, input, route::GuardType::Delete)
-    let gen = match route::Route::new(args, input, route::GuardType::Delete) {
-        Ok(gen) => gen,
-        Err(err) => return err.to_compile_error().into(),
-    };
-    gen.generate()
 }
 
 /// Creates route handler with `HEAD` method guard.
@@ -117,12 +98,7 @@ pub fn delete(args: TokenStream, input: TokenStream) -> TokenStream {
 /// Attributes are the same as in [head](attr.head.html)
 #[proc_macro_attribute]
 pub fn head(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as syn::AttributeArgs);
+    route::generate(args, input, route::GuardType::Head)
-    let gen = match route::Route::new(args, input, route::GuardType::Head) {
-        Ok(gen) => gen,
-        Err(err) => return err.to_compile_error().into(),
-    };
-    gen.generate()
 }
 
 /// Creates route handler with `CONNECT` method guard.
@@ -132,12 +108,7 @@ pub fn head(args: TokenStream, input: TokenStream) -> TokenStream {
 /// Attributes are the same as in [connect](attr.connect.html)
 #[proc_macro_attribute]
 pub fn connect(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as syn::AttributeArgs);
+    route::generate(args, input, route::GuardType::Connect)
-    let gen = match route::Route::new(args, input, route::GuardType::Connect) {
-        Ok(gen) => gen,
-        Err(err) => return err.to_compile_error().into(),
-    };
-    gen.generate()
 }
 
 /// Creates route handler with `OPTIONS` method guard.
@@ -147,12 +118,7 @@ pub fn connect(args: TokenStream, input: TokenStream) -> TokenStream {
 /// Attributes are the same as in [options](attr.options.html)
 #[proc_macro_attribute]
 pub fn options(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as syn::AttributeArgs);
+    route::generate(args, input, route::GuardType::Options)
-    let gen = match route::Route::new(args, input, route::GuardType::Options) {
-        Ok(gen) => gen,
-        Err(err) => return err.to_compile_error().into(),
-    };
-    gen.generate()
 }
 
 /// Creates route handler with `TRACE` method guard.
@@ -162,12 +128,7 @@ pub fn options(args: TokenStream, input: TokenStream) -> TokenStream {
 /// Attributes are the same as in [trace](attr.trace.html)
 #[proc_macro_attribute]
 pub fn trace(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as syn::AttributeArgs);
+    route::generate(args, input, route::GuardType::Trace)
-    let gen = match route::Route::new(args, input, route::GuardType::Trace) {
-        Ok(gen) => gen,
-        Err(err) => return err.to_compile_error().into(),
-    };
-    gen.generate()
 }
 
 /// Creates route handler with `PATCH` method guard.
@@ -177,10 +138,5 @@ pub fn trace(args: TokenStream, input: TokenStream) -> TokenStream {
 /// Attributes are the same as in [patch](attr.patch.html)
 #[proc_macro_attribute]
 pub fn patch(args: TokenStream, input: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(args as syn::AttributeArgs);
+    route::generate(args, input, route::GuardType::Patch)
-    let gen = match route::Route::new(args, input, route::GuardType::Patch) {
-        Ok(gen) => gen,
-        Err(err) => return err.to_compile_error().into(),
-    };
-    gen.generate()
 }

actix-web-codegen/src/route.rs

@@ -2,8 +2,8 @@ extern crate proc_macro;
 
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
-use quote::{quote, ToTokens, TokenStreamExt};
+use quote::{format_ident, quote, ToTokens, TokenStreamExt};
-use syn::{AttributeArgs, Ident, NestedMeta};
+use syn::{AttributeArgs, Ident, NestedMeta, parse_macro_input};
 
 enum ResourceType {
     Async,
@@ -12,11 +12,7 @@ enum ResourceType {
 
 impl ToTokens for ResourceType {
     fn to_tokens(&self, stream: &mut TokenStream2) {
-        let ident = match self {
+        let ident = format_ident!("to");
-            ResourceType::Async => "to",
-            ResourceType::Sync => "to",
-        };
-        let ident = Ident::new(ident, Span::call_site());
         stream.append(ident);
     }
 }
@@ -52,8 +48,7 @@ impl GuardType {
 
 impl ToTokens for GuardType {
     fn to_tokens(&self, stream: &mut TokenStream2) {
-        let ident = self.as_str();
+        let ident = Ident::new(self.as_str(), Span::call_site());
-        let ident = Ident::new(ident, Span::call_site());
         stream.append(ident);
     }
 }
@@ -61,12 +56,14 @@ impl ToTokens for GuardType {
 struct Args {
     path: syn::LitStr,
     guards: Vec<Ident>,
+    wrappers: Vec<syn::Type>,
 }
 
 impl Args {
     fn new(args: AttributeArgs) -> syn::Result<Self> {
         let mut path = None;
         let mut guards = Vec::new();
+        let mut wrappers = Vec::new();
         for arg in args {
             match arg {
                 NestedMeta::Lit(syn::Lit::Str(lit)) => match path {
@@ -90,21 +87,31 @@ impl Args {
                                 "Attribute guard expects literal string!",
                             ));
                         }
+                    } else if nv.path.is_ident("wrap") {
+                        if let syn::Lit::Str(lit) = nv.lit {
+                            wrappers.push(lit.parse()?);
+                        } else {
+                            return Err(syn::Error::new_spanned(
+                                nv.lit,
+                                "Attribute wrap expects type",
+                            ));
+                        }
                     } else {
                         return Err(syn::Error::new_spanned(
                             nv.path,
-                            "Unknown attribute key is specified. Allowed: guard",
+                            "Unknown attribute key is specified. Allowed: guard and wrap",
                         ));
                     }
                 }
                 arg => {
-                    return Err(syn::Error::new_spanned(arg, "Unknown attribute"));
+                    return Err(syn::Error::new_spanned(arg, "Unknown attribute."));
                 }
             }
         }
         Ok(Args {
             path: path.unwrap(),
             guards,
+            wrappers,
         })
     }
 }
@@ -181,15 +188,18 @@ impl Route {
             guard,
         })
     }
+}
 
-    pub fn generate(&self) -> TokenStream {
+impl ToTokens for Route {
-        let name = &self.name;
+    fn to_tokens(&self, output: &mut TokenStream2) {
+        let Self {
+            name,
+            guard,
+            ast,
+            args: Args { path, guards, wrappers },
+            resource_type,
+        } = self;
         let resource_name = name.to_string();
-        let guard = &self.guard;
-        let ast = &self.ast;
-        let path = &self.args.path;
-        let extra_guards = &self.args.guards;
-        let resource_type = &self.resource_type;
         let stream = quote! {
             #[allow(non_camel_case_types, missing_docs)]
             pub struct #name;
@@ -200,13 +210,27 @@ impl Route {
                     let __resource = actix_web::Resource::new(#path)
                         .name(#resource_name)
                         .guard(actix_web::guard::#guard())
-                        #(.guard(actix_web::guard::fn_guard(#extra_guards)))*
+                        #(.guard(actix_web::guard::fn_guard(#guards)))*
+                        #(.wrap(#wrappers))*
                         .#resource_type(#name);
 
                     actix_web::dev::HttpServiceFactory::register(__resource, __config)
                 }
             }
         };
-        stream.into()
+
+        output.extend(stream);
+    }
+}
+
+pub(crate) fn generate(
+    args: TokenStream,
+    input: TokenStream,
+    guard: GuardType,
+) -> TokenStream {
+    let args = parse_macro_input!(args as syn::AttributeArgs);
+    match Route::new(args, input, guard) {
+        Ok(route) => route.into_token_stream().into(),
+        Err(err) => err.to_compile_error().into(),
     }
 }

actix-web-codegen/tests/test_macro.rs

@@ -1,6 +1,11 @@
-use actix_web::{http, test, web::Path, App, HttpResponse, Responder};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use actix_web::{http, test, web::Path, App, HttpResponse, Responder, Error};
+use actix_web::dev::{Service, Transform, ServiceRequest, ServiceResponse};
 use actix_web_codegen::{connect, delete, get, head, options, patch, post, put, trace};
 use futures::{future, Future};
+use actix_web::http::header::{HeaderName, HeaderValue};
 
 // Make sure that we can name function as 'config'
 #[get("/config")]
@@ -73,6 +78,65 @@ async fn get_param_test(_: Path<String>) -> impl Responder {
     HttpResponse::Ok()
 }
 
+pub struct ChangeStatusCode;
+
+impl<S, B> Transform<S> for ChangeStatusCode
+where
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+    B: 'static,
+{
+    type Request = ServiceRequest;
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type InitError = ();
+    type Transform = ChangeStatusCodeMiddleware<S>;
+    type Future = future::Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        future::ok(ChangeStatusCodeMiddleware { service })
+    }
+}
+
+pub struct ChangeStatusCodeMiddleware<S> {
+    service: S,
+}
+
+impl<S, B> Service for ChangeStatusCodeMiddleware<S>
+where
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+    B: 'static,
+{
+    type Request = ServiceRequest;
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(cx)
+    }
+
+    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+
+        let fut = self.service.call(req);
+
+        Box::pin(async move {
+            let mut res = fut.await?;
+            let headers = res.headers_mut();
+            let header_name = HeaderName::from_lowercase(b"custom-header").unwrap();
+            let header_value = HeaderValue::from_str("hello").unwrap();
+            headers.insert(header_name, header_value);
+            Ok(res)
+        })
+    }
+}
+
+#[get("/test/wrap", wrap = "ChangeStatusCode")]
+async fn get_wrap(_: Path<String>) -> impl Responder {
+    HttpResponse::Ok()
+}
+
 #[actix_rt::test]
 async fn test_params() {
     let srv = test::start(|| {
@@ -155,3 +219,15 @@ async fn test_auto_async() {
     let response = request.send().await.unwrap();
     assert!(response.status().is_success());
 }
+
+#[actix_rt::test]
+async fn test_wrap() {
+    let srv = test::start(|| {
+        App::new()
+            .service(get_wrap)
+    });
+
+    let request = srv.request(http::Method::GET, srv.url("/test/wrap"));
+    let response = request.send().await.unwrap();
+    assert!(response.headers().contains_key("custom-header"));
+}

awc/CHANGES.md

@@ -1,5 +1,20 @@
 # Changes
 
+## [Unreleased]
+
+### Changed
+
+* Implement `std::error::Error` for our custom errors [#1422]
+
+[#1422]: https://github.com/actix/actix-web/pull/1422
+
+## [2.0.0-alpha.1] - 2020-03-11
+
+* Update `actix-http` dependency to 2.0.0-alpha.2
+* Update `rustls` dependency to 0.17
+* ClientBuilder accepts initial_window_size and initial_connection_window_size HTTP2 configuration
+* ClientBuilder allowing to set max_http_version to limit HTTP version to be used
+
 ## [1.0.1] - 2019-12-15
 
 * Fix compilation with default features off

awc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "awc"
-version = "1.0.1"
+version = "2.0.0-alpha.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http client."
 readme = "README.md"
@@ -36,7 +36,7 @@ compress = ["actix-http/compress"]
 [dependencies]
 actix-codec = "0.2.0"
 actix-service = "1.0.1"
-actix-http = "2.0.0-alpha.1"
+actix-http = "2.0.0-alpha.3"
 actix-rt = "1.0.0"
 
 base64 = "0.11"
@@ -51,18 +51,18 @@ serde = "1.0"
 serde_json = "1.0"
 serde_urlencoded = "0.6.1"
 open-ssl = { version="0.10", package="openssl", optional = true }
-rust-tls = { version = "0.16.0", package="rustls", optional = true, features = ["dangerous_configuration"]  }
+rust-tls = { version = "0.17.0", package="rustls", optional = true, features = ["dangerous_configuration"]  }
 
 [dev-dependencies]
-actix-connect = { version = "1.0.1", features=["openssl"] }
+actix-connect = { version = "2.0.0-alpha.2", features=["openssl"] }
-actix-web = { version = "2.0.0", features=["openssl"] }
+actix-web = { version = "3.0.0-alpha.1", features=["openssl"] }
-actix-http = { version = "2.0.0-alpha.1", features=["openssl"] }
+actix-http = { version = "2.0.0-alpha.3", features=["openssl"] }
 actix-http-test = { version = "1.0.0", features=["openssl"] }
 actix-utils = "1.0.3"
 actix-server = "1.0.0"
-actix-tls = { version = "1.0.0", features=["openssl", "rustls"] }
+actix-tls = { version = "2.0.0-alpha.1", features=["openssl", "rustls"] }
 brotli2 = "0.3.2"
 flate2 = "1.0.13"
 futures = "0.3.1"
-env_logger = "0.6"
+env_logger = "0.7"
 webpki = "0.21"

awc/src/builder.rs

@@ -4,11 +4,11 @@ use std::fmt;
 use std::rc::Rc;
 use std::time::Duration;
 
-use actix_http::client::{Connect, ConnectError, Connection, Connector};
+use actix_http::client::{Connect as HttpConnect, ConnectError, Connection, Connector};
-use actix_http::http::{header, Error as HttpError, HeaderMap, HeaderName};
+use actix_http::http::{self, header, Error as HttpError, HeaderMap, HeaderName};
 use actix_service::Service;
 
-use crate::connect::ConnectorWrapper;
+use crate::connect::{Connect, ConnectorWrapper};
 use crate::{Client, ClientConfig};
 
 /// An HTTP Client builder
@@ -16,10 +16,15 @@ use crate::{Client, ClientConfig};
 /// This type can be used to construct an instance of `Client` through a
 /// builder-like pattern.
 pub struct ClientBuilder {
-    config: ClientConfig,
     default_headers: bool,
     allow_redirects: bool,
     max_redirects: usize,
+    max_http_version: Option<http::Version>,
+    stream_window_size: Option<u32>,
+    conn_window_size: Option<u32>,
+    headers: HeaderMap,
+    timeout: Option<Duration>,
+    connector: Option<RefCell<Box<dyn Connect>>>,
 }
 
 impl Default for ClientBuilder {
@@ -34,25 +39,24 @@ impl ClientBuilder {
             default_headers: true,
             allow_redirects: true,
             max_redirects: 10,
-            config: ClientConfig {
+            headers: HeaderMap::new(),
-                headers: HeaderMap::new(),
+            timeout: Some(Duration::from_secs(5)),
-                timeout: Some(Duration::from_secs(5)),
+            connector: None,
-                connector: RefCell::new(Box::new(ConnectorWrapper(
+            max_http_version: None,
-                    Connector::new().finish(),
+            stream_window_size: None,
-                ))),
+            conn_window_size: None,
-            },
         }
     }
 
     /// Use custom connector service.
     pub fn connector<T>(mut self, connector: T) -> Self
     where
-        T: Service<Request = Connect, Error = ConnectError> + 'static,
+        T: Service<Request = HttpConnect, Error = ConnectError> + 'static,
         T::Response: Connection,
         <T::Response as Connection>::Future: 'static,
         T::Future: 'static,
     {
-        self.config.connector = RefCell::new(Box::new(ConnectorWrapper(connector)));
+        self.connector = Some(RefCell::new(Box::new(ConnectorWrapper(connector))));
         self
     }
 
@@ -61,13 +65,13 @@ impl ClientBuilder {
     /// Request timeout is the total time before a response must be received.
     /// Default value is 5 seconds.
     pub fn timeout(mut self, timeout: Duration) -> Self {
-        self.config.timeout = Some(timeout);
+        self.timeout = Some(timeout);
         self
     }
 
     /// Disable request timeout.
     pub fn disable_timeout(mut self) -> Self {
-        self.config.timeout = None;
+        self.timeout = None;
         self
     }
 
@@ -79,6 +83,31 @@ impl ClientBuilder {
         self
     }
 
+    /// Maximum supported http major version
+    /// Supported versions http/1.1, http/2
+    pub fn max_http_version(mut self, val: http::Version) -> Self {
+        self.max_http_version = Some(val);
+        self
+    }
+
+    /// Indicates the initial window size (in octets) for
+    /// HTTP2 stream-level flow control for received data.
+    ///
+    /// The default value is 65,535 and is good for APIs, but not for big objects.
+    pub fn initial_window_size(mut self, size: u32) -> Self {
+        self.stream_window_size = Some(size);
+        self
+    }
+
+    /// Indicates the initial window size (in octets) for
+    /// HTTP2 connection-level flow control for received data.
+    ///
+    /// The default value is 65,535 and is good for APIs, but not for big objects.
+    pub fn initial_connection_window_size(mut self, size: u32) -> Self {
+        self.conn_window_size = Some(size);
+        self
+    }
+
     /// Set max number of redirects.
     ///
     /// Max redirects is set to 10 by default.
@@ -106,7 +135,7 @@ impl ClientBuilder {
         match HeaderName::try_from(key) {
             Ok(key) => match value.try_into() {
                 Ok(value) => {
-                    self.config.headers.append(key, value);
+                    self.headers.append(key, value);
                 }
                 Err(e) => log::error!("Header value error: {:?}", e),
             },
@@ -140,7 +169,29 @@ impl ClientBuilder {
 
     /// Finish build process and create `Client` instance.
     pub fn finish(self) -> Client {
-        Client(Rc::new(self.config))
+        let connector = if let Some(connector) = self.connector {
+            connector
+        } else {
+            let mut connector = Connector::new();
+            if let Some(val) = self.max_http_version {
+                connector = connector.max_http_version(val)
+            };
+            if let Some(val) = self.conn_window_size {
+                connector = connector.initial_connection_window_size(val)
+            };
+            if let Some(val) = self.stream_window_size {
+                connector = connector.initial_window_size(val)
+            };
+            RefCell::new(
+                Box::new(ConnectorWrapper(connector.finish())) as Box<dyn Connect>
+            )
+        };
+        let config = ClientConfig {
+            headers: self.headers,
+            timeout: self.timeout,
+            connector,
+        };
+        Client(Rc::new(config))
     }
 }
 
@@ -153,7 +204,6 @@ mod tests {
         let client = ClientBuilder::new().basic_auth("username", Some("password"));
         assert_eq!(
             client
-                .config
                 .headers
                 .get(header::AUTHORIZATION)
                 .unwrap()
@@ -165,7 +215,6 @@ mod tests {
         let client = ClientBuilder::new().basic_auth("username", None);
         assert_eq!(
             client
-                .config
                 .headers
                 .get(header::AUTHORIZATION)
                 .unwrap()
@@ -180,7 +229,6 @@ mod tests {
         let client = ClientBuilder::new().bearer_auth("someS3cr3tAutht0k3n");
         assert_eq!(
             client
-                .config
                 .headers
                 .get(header::AUTHORIZATION)
                 .unwrap()

awc/src/error.rs

@@ -42,6 +42,8 @@ pub enum WsClientError {
     SendRequest(SendRequestError),
 }
 
+impl std::error::Error for WsClientError {}
+
 impl From<InvalidUrl> for WsClientError {
     fn from(err: InvalidUrl) -> Self {
         WsClientError::SendRequest(err.into())
@@ -68,5 +70,7 @@ pub enum JsonPayloadError {
     Payload(PayloadError),
 }
 
+impl std::error::Error for JsonPayloadError {}
+
 /// Return `InternalServerError` for `JsonPayloadError`
 impl ResponseError for JsonPayloadError {}

awc/src/lib.rs

@@ -1,4 +1,4 @@
-#![deny(rust_2018_idioms, warnings)]
+#![warn(rust_2018_idioms, warnings)]
 #![allow(
     clippy::type_complexity,
     clippy::borrow_interior_mutable_const,

awc/src/sender.rs

@@ -9,7 +9,6 @@ use bytes::Bytes;
 use derive_more::From;
 use futures_core::{Future, Stream};
 use serde::Serialize;
-use serde_json;
 
 use actix_http::body::{Body, BodyStream};
 use actix_http::http::header::{self, IntoHeaderValue};

awc/tests/test_client.rs

@@ -107,17 +107,15 @@ async fn test_form() {
 #[actix_rt::test]
 async fn test_timeout() {
     let srv = test::start(|| {
-        App::new().service(web::resource("/").route(web::to(|| {
+        App::new().service(web::resource("/").route(web::to(|| async {
-            async {
+            actix_rt::time::delay_for(Duration::from_millis(200)).await;
-                actix_rt::time::delay_for(Duration::from_millis(200)).await;
+            Ok::<_, Error>(HttpResponse::Ok().body(STR))
-                Ok::<_, Error>(HttpResponse::Ok().body(STR))
-            }
         })))
     });
 
     let connector = awc::Connector::new()
         .connector(actix_connect::new_connector(
-            actix_connect::start_default_resolver(),
+            actix_connect::start_default_resolver().await.unwrap(),
         ))
         .timeout(Duration::from_secs(15))
         .finish();
@@ -137,11 +135,9 @@ async fn test_timeout() {
 #[actix_rt::test]
 async fn test_timeout_override() {
     let srv = test::start(|| {
-        App::new().service(web::resource("/").route(web::to(|| {
+        App::new().service(web::resource("/").route(web::to(|| async {
-            async {
+            actix_rt::time::delay_for(Duration::from_millis(200)).await;
-                actix_rt::time::delay_for(Duration::from_millis(200)).await;
+            Ok::<_, Error>(HttpResponse::Ok().body(STR))
-                Ok::<_, Error>(HttpResponse::Ok().body(STR))
-            }
         })))
     });
 
@@ -177,7 +173,8 @@ async fn test_connection_reuse() {
             ))
             .tcp(),
         )
-    });
+    })
+    .await;
 
     let client = awc::Client::default();
 
@@ -214,7 +211,8 @@ async fn test_connection_force_close() {
             ))
             .tcp(),
         )
-    });
+    })
+    .await;
 
     let client = awc::Client::default();
 
@@ -253,7 +251,8 @@ async fn test_connection_server_close() {
             ))
             .tcp(),
         )
-    });
+    })
+    .await;
 
     let client = awc::Client::default();
 
@@ -291,7 +290,8 @@ async fn test_connection_wait_queue() {
             ))
             .tcp(),
         )
-    });
+    })
+    .await;
 
     let client = awc::Client::build()
         .connector(awc::Connector::new().limit(1).finish())
@@ -339,7 +339,8 @@ async fn test_connection_wait_queue_force_close() {
             ))
             .tcp(),
         )
-    });
+    })
+    .await;
 
     let client = awc::Client::build()
         .connector(awc::Connector::new().limit(1).finish())

awc/tests/test_connector.rs

@@ -0,0 +1,61 @@
+#![cfg(feature = "openssl")]
+use actix_http::HttpService;
+use actix_http_test::test_server;
+use actix_service::{map_config, ServiceFactory};
+use actix_web::http::Version;
+use actix_web::{dev::AppConfig, web, App, HttpResponse};
+use open_ssl::ssl::{SslAcceptor, SslConnector, SslFiletype, SslMethod, SslVerifyMode};
+
+fn ssl_acceptor() -> SslAcceptor {
+    // load ssl keys
+    let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
+    builder
+        .set_private_key_file("../tests/key.pem", SslFiletype::PEM)
+        .unwrap();
+    builder
+        .set_certificate_chain_file("../tests/cert.pem")
+        .unwrap();
+    builder.set_alpn_select_callback(|_, protos| {
+        const H2: &[u8] = b"\x02h2";
+        if protos.windows(3).any(|window| window == H2) {
+            Ok(b"h2")
+        } else {
+            Err(open_ssl::ssl::AlpnError::NOACK)
+        }
+    });
+    builder.set_alpn_protos(b"\x02h2").unwrap();
+    builder.build()
+}
+
+#[actix_rt::test]
+async fn test_connection_window_size() {
+    let srv = test_server(move || {
+        HttpService::build()
+            .h2(map_config(
+                App::new()
+                    .service(web::resource("/").route(web::to(|| HttpResponse::Ok()))),
+                |_| AppConfig::default(),
+            ))
+            .openssl(ssl_acceptor())
+            .map_err(|_| ())
+    })
+    .await;
+
+    // disable ssl verification
+    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));
+
+    let client = awc::Client::build()
+        .connector(awc::Connector::new().ssl(builder.build()).finish())
+        .initial_window_size(100)
+        .initial_connection_window_size(100)
+        .finish();
+
+    let request = client.get(srv.surl("/")).send();
+    let response = request.await.unwrap();
+    assert!(response.status().is_success());
+    assert_eq!(response.version(), Version::HTTP_2);
+}

awc/tests/test_rustls_client.rs

@@ -72,7 +72,8 @@ async fn _test_connection_reuse_h2() {
                 .openssl(ssl_acceptor())
                 .map_err(|_| ()),
         )
-    });
+    })
+    .await;
 
     // disable ssl verification
     let mut config = ClientConfig::new();

awc/tests/test_ssl_client.rs

@@ -53,7 +53,8 @@ async fn test_connection_reuse_h2() {
                 .openssl(ssl_acceptor())
                 .map_err(|_| ()),
         )
-    });
+    })
+    .await;
 
     // disable ssl verification
     let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();

awc/tests/test_ws.rs

@@ -38,7 +38,8 @@ async fn test_simple() {
             })
             .finish(|_| ok::<_, Error>(Response::NotFound()))
             .tcp()
-    });
+    })
+    .await;
 
     // client service
     let mut framed = srv.ws().await.unwrap();

src/app.rs

@@ -10,11 +10,11 @@ use actix_service::boxed::{self, BoxServiceFactory};
 use actix_service::{
     apply, apply_fn_factory, IntoServiceFactory, ServiceFactory, Transform,
 };
-use futures::future::{FutureExt, LocalBoxFuture};
+use futures::future::FutureExt;
 
 use crate::app_service::{AppEntry, AppInit, AppRoutingFactory};
 use crate::config::ServiceConfig;
-use crate::data::{Data, DataFactory};
+use crate::data::{Data, DataFactory, FnDataFactory};
 use crate::dev::ResourceDef;
 use crate::error::Error;
 use crate::resource::Resource;
@@ -25,8 +25,6 @@ use crate::service::{
 };
 
 type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
-type FnDataFactory =
-    Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>;
 
 /// Application builder - structure that follows the builder pattern
 /// for building application instances.
@@ -320,7 +318,7 @@ where
 
     /// Registers middleware, in the form of a middleware component (type),
     /// that runs during inbound and/or outbound processing in the request
-    /// lifecycle (request -> response), modifying request/response as
+    /// life-cycle (request -> response), modifying request/response as
     /// necessary, across all requests managed by the *Application*.
     ///
     /// Use middleware when you need to read or modify *every* request or
@@ -385,7 +383,7 @@ where
     }
 
     /// Registers middleware, in the form of a closure, that runs during inbound
-    /// and/or outbound processing in the request lifecycle (request -> response),
+    /// and/or outbound processing in the request life-cycle (request -> response),
     /// modifying request/response as necessary, across all requests managed by
     /// the *Application*.
     ///
@@ -476,13 +474,13 @@ where
 mod tests {
     use actix_service::Service;
     use bytes::Bytes;
-    use futures::future::ok;
+    use futures::future::{ok, err};
 
     use super::*;
     use crate::http::{header, HeaderValue, Method, StatusCode};
     use crate::middleware::DefaultHeaders;
     use crate::service::ServiceRequest;
-    use crate::test::{call_service, init_service, read_body, TestRequest};
+    use crate::test::{call_service, init_service, try_init_service, read_body, TestRequest};
     use crate::{web, HttpRequest, HttpResponse};
 
     #[actix_rt::test]
@@ -551,6 +549,17 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
+    #[actix_rt::test]
+    async fn test_data_factory_errors() {
+        let srv =
+            try_init_service(App::new().data_factory(|| err::<u32, _>(())).service(
+                web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
+            ))
+            .await;
+            
+        assert!(srv.is_err());
+    }
+
     #[actix_rt::test]
     async fn test_extension() {
         let mut srv = init_service(App::new().app_data(10usize).service(

src/app_service.rs

@@ -9,10 +9,10 @@ use actix_http::{Extensions, Request, Response};
 use actix_router::{Path, ResourceDef, ResourceInfo, Router, Url};
 use actix_service::boxed::{self, BoxService, BoxServiceFactory};
 use actix_service::{fn_service, Service, ServiceFactory};
-use futures::future::{ok, FutureExt, LocalBoxFuture};
+use futures::future::{join_all, ok, FutureExt, LocalBoxFuture};
 
 use crate::config::{AppConfig, AppService};
-use crate::data::DataFactory;
+use crate::data::{FnDataFactory, DataFactory};
 use crate::error::Error;
 use crate::guard::Guard;
 use crate::request::{HttpRequest, HttpRequestPool};
@@ -23,8 +23,6 @@ type Guards = Vec<Box<dyn Guard>>;
 type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
 type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
 type BoxResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
-type FnDataFactory =
-    Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>;
 
 /// Service factory to convert `Request` to a `ServiceRequest<S>`.
 /// It also executes data factories.
@@ -109,12 +107,15 @@ where
         let rmap = Rc::new(rmap);
         rmap.finish(rmap.clone());
 
+        // start all data factory futures
+        let factory_futs = join_all(self.data_factories.iter().map(|f| f()));
+
         AppInitResult {
             endpoint: None,
             endpoint_fut: self.endpoint.new_service(()),
             data: self.data.clone(),
-            data_factories: Vec::new(),
+            data_factories: None,
-            data_factories_fut: self.data_factories.iter().map(|f| f()).collect(),
+            data_factories_fut: factory_futs.boxed_local(),
             extensions: Some(
                 self.extensions
                     .borrow_mut()
@@ -133,15 +134,21 @@ pub struct AppInitResult<T, B>
 where
     T: ServiceFactory,
 {
-    endpoint: Option<T::Service>,
     #[pin]
     endpoint_fut: T::Future,
+    // a Some signals completion of endpoint creation
+    endpoint: Option<T::Service>,
+
+    #[pin]
+    data_factories_fut: LocalBoxFuture<'static, Vec<Result<Box<dyn DataFactory>, ()>>>,
+    // a Some signals completion of factory futures
+    data_factories: Option<Vec<Box<dyn DataFactory>>>,
+
     rmap: Rc<ResourceMap>,
     config: AppConfig,
     data: Rc<Vec<Box<dyn DataFactory>>>,
-    data_factories: Vec<Box<dyn DataFactory>>,
-    data_factories_fut: Vec<LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>,
     extensions: Option<Extensions>,
+
     _t: PhantomData<B>,
 }
 
@@ -161,44 +168,46 @@ where
         let this = self.project();
 
         // async data factories
-        let mut idx = 0;
+        if let Poll::Ready(factories) = this.data_factories_fut.poll(cx) {
-        while idx < this.data_factories_fut.len() {
+            let factories: Result<Vec<_>, ()> = factories.into_iter().collect();
-            match Pin::new(&mut this.data_factories_fut[idx]).poll(cx)? {
+
-                Poll::Ready(f) => {
+            if let Ok(factories) = factories {
-                    this.data_factories.push(f);
+                this.data_factories.replace(factories);
-                    let _ = this.data_factories_fut.remove(idx);
+            } else {
-                }
+                return Poll::Ready(Err(()));
-                Poll::Pending => idx += 1,
             }
         }
 
+        // app service and middleware
         if this.endpoint.is_none() {
             if let Poll::Ready(srv) = this.endpoint_fut.poll(cx)? {
                 *this.endpoint = Some(srv);
             }
         }
 
-        if this.endpoint.is_some() && this.data_factories_fut.is_empty() {
+        // not using if let so condition only needs shared ref
+        if this.endpoint.is_some() && this.data_factories.is_some() {
             // create app data container
             let mut data = this.extensions.take().unwrap();
+
             for f in this.data.iter() {
                 f.create(&mut data);
             }
 
-            for f in this.data_factories.iter() {
+            for f in this.data_factories.take().unwrap().iter() {
                 f.create(&mut data);
             }
 
-            Poll::Ready(Ok(AppInitService {
+            return Poll::Ready(Ok(AppInitService {
                 service: this.endpoint.take().unwrap(),
                 rmap: this.rmap.clone(),
                 config: this.config.clone(),
                 data: Rc::new(data),
                 pool: HttpRequestPool::create(),
-            }))
+            }));
-        } else {
-            Poll::Pending
         }
+
+        Poll::Pending
     }
 }
 

src/config.rs

@@ -50,7 +50,7 @@ impl AppService {
         }
     }
 
-    /// Check if root is beeing configured
+    /// Check if root is being configured
     pub fn is_root(&self) -> bool {
         self.root
     }
@@ -123,6 +123,7 @@ impl AppService {
     }
 }
 
+/// Application connection config
 #[derive(Clone)]
 pub struct AppConfig(Rc<AppConfigInner>);
 

src/data.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 
 use actix_http::error::{Error, ErrorInternalServerError};
 use actix_http::Extensions;
-use futures::future::{err, ok, Ready};
+use futures::future::{err, ok, LocalBoxFuture, Ready};
 
 use crate::dev::Payload;
 use crate::extract::FromRequest;
@@ -14,6 +14,9 @@ pub(crate) trait DataFactory {
     fn create(&self, extensions: &mut Extensions) -> bool;
 }
 
+pub(crate) type FnDataFactory =
+    Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>;
+
 /// Application data.
 ///
 /// Application data is an arbitrary data attached to the app.

src/error.rs

@@ -21,6 +21,8 @@ pub enum UrlGenerationError {
     ParseError(UrlParseError),
 }
 
+impl std::error::Error for UrlGenerationError {}
+
 /// `InternalServerError` for `UrlGeneratorError`
 impl ResponseError for UrlGenerationError {}
 
@@ -51,6 +53,8 @@ pub enum UrlencodedError {
     Payload(PayloadError),
 }
 
+impl std::error::Error for UrlencodedError {}
+
 /// Return `BadRequest` for `UrlencodedError`
 impl ResponseError for UrlencodedError {
     fn status_code(&self) -> StatusCode {
@@ -79,6 +83,8 @@ pub enum JsonPayloadError {
     Payload(PayloadError),
 }
 
+impl std::error::Error for JsonPayloadError {}
+
 /// Return `BadRequest` for `JsonPayloadError`
 impl ResponseError for JsonPayloadError {
     fn error_response(&self) -> HttpResponse {
@@ -99,6 +105,8 @@ pub enum PathError {
     Deserialize(serde::de::value::Error),
 }
 
+impl std::error::Error for PathError {}
+
 /// Return `BadRequest` for `PathError`
 impl ResponseError for PathError {
     fn status_code(&self) -> StatusCode {
@@ -114,6 +122,8 @@ pub enum QueryPayloadError {
     Deserialize(serde::de::value::Error),
 }
 
+impl std::error::Error for QueryPayloadError {}
+
 /// Return `BadRequest` for `QueryPayloadError`
 impl ResponseError for QueryPayloadError {
     fn status_code(&self) -> StatusCode {
@@ -139,6 +149,8 @@ pub enum ReadlinesError {
     ContentTypeError(ContentTypeError),
 }
 
+impl std::error::Error for ReadlinesError {}
+
 /// Return `BadRequest` for `ReadlinesError`
 impl ResponseError for ReadlinesError {
     fn status_code(&self) -> StatusCode {

src/guard.rs

@@ -6,7 +6,7 @@
 //! It is possible to add guards to *scopes*, *resources*
 //! and *routes*. Actix provide several guards by default, like various
 //! http methods, header, etc. To become a guard, type must implement `Guard`
-//! trait. Simple functions coulds guards as well.
+//! trait. Simple functions could be guards as well.
 //!
 //! Guards can not modify the request object. But it is possible
 //! to store extra attributes on a request by using the `Extensions` container.
@@ -100,7 +100,7 @@ pub fn Any<F: Guard + 'static>(guard: F) -> AnyGuard {
     AnyGuard(vec![Box::new(guard)])
 }
 
-/// Matches if any of supplied guards matche.
+/// Matches any of supplied guards.
 pub struct AnyGuard(Vec<Box<dyn Guard>>);
 
 impl AnyGuard {

src/lib.rs

@@ -1,4 +1,4 @@
-#![deny(rust_2018_idioms, warnings)]
+#![warn(rust_2018_idioms, warnings)]
 #![allow(
     clippy::needless_doctest_main,
     clippy::type_complexity,

src/middleware/condition.rs

@@ -5,7 +5,7 @@ use actix_service::{Service, Transform};
 use futures::future::{ok, Either, FutureExt, LocalBoxFuture};
 
 /// `Middleware` for conditionally enables another middleware.
-/// The controled middleware must not change the `Service` interfaces.
+/// The controlled middleware must not change the `Service` interfaces.
 /// This means you cannot control such middlewares like `Logger` or `Compress`.
 ///
 /// ## Usage

src/middleware/logger.rs

@@ -163,11 +163,11 @@ where
             LoggerResponse {
                 fut: self.service.call(req),
                 format: None,
-                time: OffsetDateTime::now(),
+                time: OffsetDateTime::now_utc(),
                 _t: PhantomData,
             }
         } else {
-            let now = OffsetDateTime::now();
+            let now = OffsetDateTime::now_utc();
             let mut format = self.inner.format.clone();
 
             for unit in &mut format.0 {
@@ -380,12 +380,12 @@ impl FormatText {
             FormatText::Percent => "%".fmt(fmt),
             FormatText::ResponseSize => size.fmt(fmt),
             FormatText::Time => {
-                let rt = OffsetDateTime::now() - entry_time;
+                let rt = OffsetDateTime::now_utc() - entry_time;
                 let rt = rt.as_seconds_f64();
                 fmt.write_fmt(format_args!("{:.6}", rt))
             }
             FormatText::TimeMillis => {
-                let rt = OffsetDateTime::now() - entry_time;
+                let rt = OffsetDateTime::now_utc() - entry_time;
                 let rt = (rt.whole_nanoseconds() as f64) / 1_000_000.0;
                 fmt.write_fmt(format_args!("{:.6}", rt))
             }
@@ -520,7 +520,7 @@ mod tests {
         .uri("/test/route/yeah")
         .to_srv_request();
 
-        let now = OffsetDateTime::now();
+        let now = OffsetDateTime::now_utc();
         for unit in &mut format.0 {
             unit.render_request(now, &req);
         }
@@ -551,7 +551,7 @@ mod tests {
         )
         .to_srv_request();
 
-        let now = OffsetDateTime::now();
+        let now = OffsetDateTime::now_utc();
         for unit in &mut format.0 {
             unit.render_request(now, &req);
         }
@@ -561,7 +561,7 @@ mod tests {
             unit.render_response(&resp);
         }
 
-        let entry_time = OffsetDateTime::now();
+        let entry_time = OffsetDateTime::now_utc();
         let render = |fmt: &mut Formatter<'_>| {
             for unit in &format.0 {
                 unit.render(fmt, 1024, entry_time)?;
@@ -579,7 +579,7 @@ mod tests {
         let mut format = Format::new("%t");
         let req = TestRequest::default().to_srv_request();
 
-        let now = OffsetDateTime::now();
+        let now = OffsetDateTime::now_utc();
         for unit in &mut format.0 {
             unit.render_request(now, &req);
         }

src/middleware/normalize.rs

@@ -74,9 +74,13 @@ where
 
     fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
         let head = req.head_mut();
-        let path = head.uri.path();
+        
+        // always add trailing slash, might be an extra one
+        let path = head.uri.path().to_string() + "/";
         let original_len = path.len();
-        let path = self.merge_slash.replace_all(path, "/");
+
+        // normalize multiple /'s to one /
+        let path = self.merge_slash.replace_all(&path, "/");
 
         if original_len != path.len() {
             let mut parts = head.uri.clone().into_parts();
@@ -119,6 +123,14 @@ mod tests {
         let req = TestRequest::with_uri("/v1//something////").to_request();
         let res = call_service(&mut app, req).await;
         assert!(res.status().is_success());
+
+        let req2 = TestRequest::with_uri("//v1/something").to_request();
+        let res2 = call_service(&mut app, req2).await;
+        assert!(res2.status().is_success());
+
+        let req3 = TestRequest::with_uri("//v1//////something").to_request();
+        let res3 = call_service(&mut app, req3).await;
+        assert!(res3.status().is_success());
     }
 
     #[actix_rt::test]
@@ -136,6 +148,14 @@ mod tests {
         let req = TestRequest::with_uri("/v1//something////").to_srv_request();
         let res = normalize.call(req).await.unwrap();
         assert!(res.status().is_success());
+
+        let req2 = TestRequest::with_uri("///v1/something").to_srv_request();
+        let res2 = normalize.call(req2).await.unwrap();
+        assert!(res2.status().is_success());
+
+        let req3 = TestRequest::with_uri("//v1///something").to_srv_request();
+        let res3 = normalize.call(req3).await.unwrap();
+        assert!(res3.status().is_success());
     }
 
     #[actix_rt::test]
@@ -147,6 +167,25 @@ mod tests {
             ok(req.into_response(HttpResponse::Ok().finish()))
         };
 
+        let mut normalize = NormalizePath
+            .new_transform(srv.into_service())
+            .await
+            .unwrap();
+
+        let req = TestRequest::with_uri(URI).to_srv_request();
+        let res = normalize.call(req).await.unwrap();
+        assert!(res.status().is_success());
+    }
+
+     #[actix_rt::test]
+    async fn should_normalize_nothing_notrail() {
+        const URI: &str = "/v1/something";
+
+        let srv = |req: ServiceRequest| {
+            assert_eq!(URI, req.path());
+            ok(req.into_response(HttpResponse::Ok().finish()))
+        };
+
         let mut normalize = NormalizePath
             .new_transform(srv.into_service())
             .await

src/request.rs

@@ -57,7 +57,7 @@ impl HttpRequest {
         &self.0.head
     }
 
-    /// This method returns muttable reference to the request head.
+    /// This method returns mutable reference to the request head.
     /// panics if multiple references of http request exists.
     #[inline]
     pub(crate) fn head_mut(&mut self) -> &mut RequestHead {

src/resource.rs

@@ -46,7 +46,7 @@ type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Err
 /// ```
 ///
 /// If no matching route could be found, *405* response code get returned.
-/// Default behavior could be overriden with `default_resource()` method.
+/// Default behavior could be overridden with `default_resource()` method.
 pub struct Resource<T = ResourceEndpoint> {
     endpoint: T,
     rdef: Vec<String>,
@@ -196,9 +196,11 @@ where
         self.app_data(Data::new(data))
     }
 
-    /// Set or override application data.
+    /// Add resource data.
     ///
-    /// This method overrides data stored with [`App::app_data()`](#method.app_data)
+    /// If used, this method will create a new data context used for extracting
+    /// from requests. Data added here is *not* merged with data added on App 
+    /// or containing scopes.
     pub fn app_data<U: 'static>(mut self, data: U) -> Self {
         if self.data.is_none() {
             self.data = Some(Extensions::new());
@@ -393,6 +395,7 @@ where
         if let Some(ref mut ext) = self.data {
             config.set_service_data(ext);
         }
+
         config.register_service(rdef, guards, self, None)
     }
 }
@@ -542,6 +545,9 @@ impl Service for ResourceService {
             }
         }
         if let Some(ref mut default) = self.default {
+            if let Some(ref data) = self.data {
+                req.set_data_container(data.clone());
+            }
             Either::Right(default.call(req))
         } else {
             let req = req.into_parts().0;
@@ -584,13 +590,14 @@ mod tests {
 
     use actix_rt::time::delay_for;
     use actix_service::Service;
+    use bytes::Bytes;
     use futures::future::ok;
 
     use crate::http::{header, HeaderValue, Method, StatusCode};
     use crate::middleware::DefaultHeaders;
     use crate::service::ServiceRequest;
-    use crate::test::{call_service, init_service, TestRequest};
+    use crate::test::{call_service, init_service, read_body, TestRequest};
-    use crate::{guard, web, App, Error, HttpResponse};
+    use crate::{guard, web, App, Error, HttpRequest, HttpResponse};
 
     #[actix_rt::test]
     async fn test_middleware() {
@@ -616,6 +623,79 @@ mod tests {
         );
     }
 
+    #[actix_rt::test]
+    async fn test_overwritten_data() {
+        #[allow(dead_code)]
+        fn echo_usize(req: HttpRequest) -> HttpResponse {
+            let num = req.app_data::<usize>().unwrap();
+            HttpResponse::Ok().body(format!("{}", num))
+        }
+
+        #[allow(dead_code)]
+        fn echo_u32(req: HttpRequest) -> HttpResponse {
+            let num = req.app_data::<u32>().unwrap();
+            HttpResponse::Ok().body(format!("{}", num))
+        }
+
+        #[allow(dead_code)]
+        fn echo_both(req: HttpRequest) -> HttpResponse {
+            let num = req.app_data::<usize>().unwrap();
+            let num2 = req.app_data::<u32>().unwrap();
+            HttpResponse::Ok().body(format!("{}-{}", num, num2))
+        }
+
+        let mut srv = init_service(
+            App::new()
+                .app_data(88usize)
+                .service(web::resource("/").route(web::get().to(echo_usize)))
+                .service(
+                    web::resource("/one")
+                        .app_data(1usize)
+                        .route(web::get().to(echo_usize)),
+                )
+                .service(
+                    web::resource("/two")
+                        .app_data(2usize)
+                        .route(web::get().to(echo_usize)),
+                )
+                .service(
+                    web::resource("/three")
+                        .app_data(3u32)
+                        // this doesnt work because app_data "overrides" the
+                        // entire data field potentially passed down
+                        // .route(web::get().to(echo_both)),
+                        .route(web::get().to(echo_u32)),
+                )
+                .service(web::resource("/eight").route(web::get().to(echo_usize))),
+        )
+        .await;
+
+        let req = TestRequest::get().uri("/").to_request();
+        let resp = srv.call(req).await.unwrap();
+        let body = read_body(resp).await;
+        assert_eq!(body, Bytes::from_static(b"88"));
+
+        let req = TestRequest::get().uri("/one").to_request();
+        let resp = srv.call(req).await.unwrap();
+        let body = read_body(resp).await;
+        assert_eq!(body, Bytes::from_static(b"1"));
+
+        let req = TestRequest::get().uri("/two").to_request();
+        let resp = srv.call(req).await.unwrap();
+        let body = read_body(resp).await;
+        assert_eq!(body, Bytes::from_static(b"2"));
+
+        // let req = TestRequest::get().uri("/three").to_request();
+        // let resp = srv.call(req).await.unwrap();
+        // let body = read_body(resp).await;
+        // assert_eq!(body, Bytes::from_static(b"88-3"));
+
+        let req = TestRequest::get().uri("/eight").to_request();
+        let resp = srv.call(req).await.unwrap();
+        let body = read_body(resp).await;
+        assert_eq!(body, Bytes::from_static(b"88"));
+    }
+
     #[actix_rt::test]
     async fn test_middleware_fn() {
         let mut srv = init_service(
@@ -649,11 +729,9 @@ mod tests {
     #[actix_rt::test]
     async fn test_to() {
         let mut srv =
-            init_service(App::new().service(web::resource("/test").to(|| {
+            init_service(App::new().service(web::resource("/test").to(|| async {
-                async {
+                delay_for(Duration::from_millis(100)).await;
-                    delay_for(Duration::from_millis(100)).await;
+                Ok::<_, Error>(HttpResponse::Ok())
-                    Ok::<_, Error>(HttpResponse::Ok())
-                }
             })))
             .await;
         let req = TestRequest::with_uri("/test").to_request();
@@ -793,4 +871,23 @@ mod tests {
         let resp = call_service(&mut srv, req).await;
         assert_eq!(resp.status(), StatusCode::OK);
     }
+
+    #[actix_rt::test]
+    async fn test_data_default_service() {
+        let mut srv = init_service(
+            App::new().data(1usize).service(
+                web::resource("/test")
+                    .data(10usize)
+                    .default_service(web::to(|data: web::Data<usize>| {
+                        assert_eq!(**data, 10);
+                        HttpResponse::Ok()
+                    })),
+            ),
+        )
+        .await;
+
+        let req = TestRequest::get().uri("/test").to_request();
+        let resp = call_service(&mut srv, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
 }

src/scope.rs

@@ -54,7 +54,7 @@ type BoxedResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
 /// ```
 ///
 /// In the above example three routes get registered:
-///  * /{project_id}/path1 - reponds to all http method
+///  * /{project_id}/path1 - responds to all http method
 ///  * /{project_id}/path2 - `GET` requests
 ///  * /{project_id}/path3 - `HEAD` requests
 ///
@@ -151,9 +151,11 @@ where
         self.app_data(Data::new(data))
     }
 
-    /// Set or override application data.
+    /// Add scope data.
     ///
-    /// This method overrides data stored with [`App::app_data()`](#method.app_data)
+    /// If used, this method will create a new data context used for extracting
+    /// from requests. Data added here is *not* merged with data added on App
+    /// or containing scopes.
     pub fn app_data<U: 'static>(mut self, data: U) -> Self {
         if self.data.is_none() {
             self.data = Some(Extensions::new());
@@ -303,7 +305,7 @@ where
 
     /// Registers middleware, in the form of a middleware component (type),
     /// that runs during inbound processing in the request
-    /// lifecycle (request -> response), modifying request as
+    /// life-cycle (request -> response), modifying request as
     /// necessary, across all requests managed by the *Scope*.  Scope-level
     /// middleware is more limited in what it can modify, relative to Route or
     /// Application level middleware, in that Scope-level middleware can not modify
@@ -344,7 +346,7 @@ where
     }
 
     /// Registers middleware, in the form of a closure, that runs during inbound
-    /// processing in the request lifecycle (request -> response), modifying
+    /// processing in the request life-cycle (request -> response), modifying
     /// request as necessary, across all requests managed by the *Scope*.
     /// Scope-level middleware is more limited in what it can modify, relative
     /// to Route or Application level middleware, in that Scope-level middleware
@@ -626,6 +628,9 @@ impl Service for ScopeService {
             }
             Either::Left(srv.call(req))
         } else if let Some(ref mut default) = self.default {
+            if let Some(ref data) = self.data {
+                req.set_data_container(data.clone());
+            }
             Either::Left(default.call(req))
         } else {
             let req = req.into_parts().0;
@@ -825,11 +830,9 @@ mod tests {
     async fn test_scope_variable_segment() {
         let mut srv =
             init_service(App::new().service(web::scope("/ab-{project}").service(
-                web::resource("/path1").to(|r: HttpRequest| {
+                web::resource("/path1").to(|r: HttpRequest| async move {
-                    async move {
+                    HttpResponse::Ok()
-                        HttpResponse::Ok()
+                        .body(format!("project: {}", &r.match_info()["project"]))
-                            .body(format!("project: {}", &r.match_info()["project"]))
-                    }
                 }),
             )))
             .await;
@@ -937,11 +940,9 @@ mod tests {
     async fn test_nested_scope_with_variable_segment() {
         let mut srv = init_service(App::new().service(web::scope("/app").service(
             web::scope("/{project_id}").service(web::resource("/path1").to(
-                |r: HttpRequest| {
+                |r: HttpRequest| async move {
-                    async move {
+                    HttpResponse::Created()
-                        HttpResponse::Created()
+                        .body(format!("project: {}", &r.match_info()["project_id"]))
-                            .body(format!("project: {}", &r.match_info()["project_id"]))
-                    }
                 },
             )),
         )))
@@ -964,14 +965,12 @@ mod tests {
     async fn test_nested2_scope_with_variable_segment() {
         let mut srv = init_service(App::new().service(web::scope("/app").service(
             web::scope("/{project}").service(web::scope("/{id}").service(
-                web::resource("/path1").to(|r: HttpRequest| {
+                web::resource("/path1").to(|r: HttpRequest| async move {
-                    async move {
+                    HttpResponse::Created().body(format!(
-                        HttpResponse::Created().body(format!(
+                        "project: {} - {}",
-                            "project: {} - {}",
+                        &r.match_info()["project"],
-                            &r.match_info()["project"],
+                        &r.match_info()["id"],
-                            &r.match_info()["id"],
+                    ))
-                        ))
-                    }
                 }),
             )),
         )))
@@ -1119,6 +1118,23 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
+    #[actix_rt::test]
+    async fn test_override_data_default_service() {
+        let mut srv = init_service(App::new().data(1usize).service(
+            web::scope("app").data(10usize).default_service(web::to(
+                |data: web::Data<usize>| {
+                    assert_eq!(**data, 10);
+                    HttpResponse::Ok()
+                },
+            )),
+        ))
+        .await;
+
+        let req = TestRequest::with_uri("/app/t").to_request();
+        let resp = call_service(&mut srv, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+
     #[actix_rt::test]
     async fn test_override_app_data() {
         let mut srv = init_service(App::new().app_data(web::Data::new(1usize)).service(
@@ -1177,15 +1193,11 @@ mod tests {
                     );
                     s.route(
                         "/",
-                        web::get().to(|req: HttpRequest| {
+                        web::get().to(|req: HttpRequest| async move {
-                            async move {
+                            HttpResponse::Ok().body(format!(
-                                HttpResponse::Ok().body(format!(
+                                "{}",
-                                    "{}",
+                                req.url_for("youtube", &["xxxxxx"]).unwrap().as_str()
-                                    req.url_for("youtube", &["xxxxxx"])
+                            ))
-                                        .unwrap()
-                                        .as_str()
-                                ))
-                            }
                         }),
                     );
                 }));
@@ -1203,11 +1215,9 @@ mod tests {
     async fn test_url_for_nested() {
         let mut srv = init_service(App::new().service(web::scope("/a").service(
             web::scope("/b").service(web::resource("/c/{stuff}").name("c").route(
-                web::get().to(|req: HttpRequest| {
+                web::get().to(|req: HttpRequest| async move {
-                    async move {
+                    HttpResponse::Ok()
-                        HttpResponse::Ok()
+                        .body(format!("{}", req.url_for("c", &["12345"]).unwrap()))
-                            .body(format!("{}", req.url_for("c", &["12345"]).unwrap()))
-                    }
                 }),
             )),
         )))

src/service.rs

@@ -69,7 +69,7 @@ impl ServiceRequest {
 
     /// Construct request from parts.
     ///
-    /// `ServiceRequest` can be re-constructed only if `req` hasnt been cloned.
+    /// `ServiceRequest` can be re-constructed only if `req` hasn't been cloned.
     pub fn from_parts(
         mut req: HttpRequest,
         pl: Payload,

src/test.rs

@@ -78,6 +78,26 @@ pub fn default_service(
 pub async fn init_service<R, S, B, E>(
     app: R,
 ) -> impl Service<Request = Request, Response = ServiceResponse<B>, Error = E>
+where
+    R: IntoServiceFactory<S>,
+    S: ServiceFactory<
+        Config = AppConfig,
+        Request = Request,
+        Response = ServiceResponse<B>,
+        Error = E,
+    >,
+    S::InitError: std::fmt::Debug,
+{
+    try_init_service(app).await.expect("service initilization failed")
+}
+
+/// Fallible version of init_service that allows testing data factory errors.
+pub(crate) async fn try_init_service<R, S, B, E>(
+    app: R,
+) -> Result<
+    impl Service<Request = Request, Response = ServiceResponse<B>, Error = E>,
+    S::InitError,
+>
 where
     R: IntoServiceFactory<S>,
     S: ServiceFactory<
@@ -89,7 +109,7 @@ where
     S::InitError: std::fmt::Debug,
 {
     let srv = app.into_factory();
-    srv.new_service(AppConfig::default()).await.unwrap()
+    srv.new_service(AppConfig::default()).await
 }
 
 /// Calls service and waits for response future completion.
@@ -187,7 +207,7 @@ where
 ///         .to_request();
 ///
 ///     let resp = test::call_service(&mut app, req).await;
-///     let result = test::read_body(resp);
+///     let result = test::read_body(resp).await;
 ///     assert_eq!(result, Bytes::from_static(b"welcome!"));
 /// }
 /// ```
@@ -203,6 +223,54 @@ where
     bytes.freeze()
 }
 
+/// Helper function that returns a deserialized response body of a ServiceResponse.
+///
+/// ```rust
+/// use actix_web::{App, test, web, HttpResponse, http::header};
+/// use serde::{Serialize, Deserialize};
+///
+/// #[derive(Serialize, Deserialize)]
+/// pub struct Person {
+///     id: String,
+///     name: String,
+/// }
+///
+/// #[actix_rt::test]
+/// async fn test_post_person() {
+///     let mut app = test::init_service(
+///         App::new().service(
+///             web::resource("/people")
+///                 .route(web::post().to(|person: web::Json<Person>| async {
+///                     HttpResponse::Ok()
+///                         .json(person.into_inner())})
+///                     ))
+///     ).await;
+///
+///     let payload = r#"{"id":"12345","name":"User name"}"#.as_bytes();
+///
+///     let resp = test::TestRequest::post()
+///         .uri("/people")
+///         .header(header::CONTENT_TYPE, "application/json")
+///         .set_payload(payload)
+///         .send_request(&mut app)
+///         .await;
+///
+///     assert!(resp.status().is_success());
+///
+///     let result: Person = test::read_body_json(resp).await;
+/// }
+/// ```
+pub async fn read_body_json<T, B>(res: ServiceResponse<B>) -> T
+where
+    B: MessageBody + Unpin,
+    T: DeserializeOwned,
+{
+    let body = read_body(res).await;
+
+    serde_json::from_slice(&body)
+        .unwrap_or_else(|_| panic!("read_response_json failed during deserialization"))
+}
+
 pub async fn load_stream<S>(mut stream: S) -> Result<Bytes, Error>
 where
     S: Stream<Item = Result<Bytes, Error>> + Unpin,
@@ -527,6 +595,16 @@ impl TestRequest {
 
         (req, payload)
     }
+
+    /// Complete request creation, calls service and waits for response future completion.
+    pub async fn send_request<S, B, E>(self, app: &mut S) -> S::Response
+    where
+        S: Service<Request = Request, Response = ServiceResponse<B>, Error = E>,
+        E: std::fmt::Debug,
+    {
+        let req = self.to_request();
+        call_service(app, req).await
+    }
 }
 
 /// Start test server with default configuration
@@ -1041,6 +1119,23 @@ mod tests {
         assert_eq!(result, Bytes::from_static(b"welcome!"));
     }
 
+    #[actix_rt::test]
+    async fn test_send_request() {
+        let mut app =
+            init_service(App::new().service(web::resource("/index.html").route(
+                web::get().to(|| async { HttpResponse::Ok().body("welcome!") }),
+            )))
+            .await;
+
+        let resp = TestRequest::get()
+            .uri("/index.html")
+            .send_request(&mut app)
+            .await;
+
+        let result = read_body(resp).await;
+        assert_eq!(result, Bytes::from_static(b"welcome!"));
+    }
+
     #[derive(Serialize, Deserialize)]
     pub struct Person {
         id: String,
@@ -1050,8 +1145,8 @@ mod tests {
     #[actix_rt::test]
     async fn test_response_json() {
         let mut app = init_service(App::new().service(web::resource("/people").route(
-            web::post().to(|person: web::Json<Person>| {
+            web::post().to(|person: web::Json<Person>| async {
-                async { HttpResponse::Ok().json(person.into_inner()) }
+                HttpResponse::Ok().json(person.into_inner())
             }),
         )))
         .await;
@@ -1068,11 +1163,33 @@ mod tests {
         assert_eq!(&result.id, "12345");
     }
 
+    #[actix_rt::test]
+    async fn test_body_json() {
+        let mut app = init_service(App::new().service(web::resource("/people").route(
+            web::post().to(|person: web::Json<Person>| async {
+                HttpResponse::Ok().json(person.into_inner())
+            }),
+        )))
+        .await;
+
+        let payload = r#"{"id":"12345","name":"User name"}"#.as_bytes();
+
+        let resp = TestRequest::post()
+            .uri("/people")
+            .header(header::CONTENT_TYPE, "application/json")
+            .set_payload(payload)
+            .send_request(&mut app)
+            .await;
+
+        let result: Person = read_body_json(resp).await;
+        assert_eq!(&result.name, "User name");
+    }
+
     #[actix_rt::test]
     async fn test_request_response_form() {
         let mut app = init_service(App::new().service(web::resource("/people").route(
-            web::post().to(|person: web::Form<Person>| {
+            web::post().to(|person: web::Form<Person>| async {
-                async { HttpResponse::Ok().json(person.into_inner()) }
+                HttpResponse::Ok().json(person.into_inner())
             }),
         )))
         .await;
@@ -1097,8 +1214,8 @@ mod tests {
     #[actix_rt::test]
     async fn test_request_response_json() {
         let mut app = init_service(App::new().service(web::resource("/people").route(
-            web::post().to(|person: web::Json<Person>| {
+            web::post().to(|person: web::Json<Person>| async {
-                async { HttpResponse::Ok().json(person.into_inner()) }
+                HttpResponse::Ok().json(person.into_inner())
             }),
         )))
         .await;
@@ -1162,53 +1279,53 @@ mod tests {
         assert!(res.status().is_success());
     }
 
-/*
+    /*
 
-    Comment out until actix decoupled of actix-http:
+        Comment out until actix decoupled of actix-http:
-    https://github.com/actix/actix/issues/321
+        https://github.com/actix/actix/issues/321
 
-    use futures::FutureExt;
+        use futures::FutureExt;
 
-    #[actix_rt::test]
+        #[actix_rt::test]
-    async fn test_actor() {
+        async fn test_actor() {
-        use actix::Actor;
+            use actix::Actor;
 
-        struct MyActor;
+            struct MyActor;
 
-        struct Num(usize);
+            struct Num(usize);
-        impl actix::Message for Num {
+            impl actix::Message for Num {
-            type Result = usize;
+                type Result = usize;
-        }
+            }
-        impl actix::Actor for MyActor {
+            impl actix::Actor for MyActor {
-            type Context = actix::Context<Self>;
+                type Context = actix::Context<Self>;
-        }
+            }
-        impl actix::Handler<Num> for MyActor {
+            impl actix::Handler<Num> for MyActor {
-            type Result = usize;
+                type Result = usize;
-            fn handle(&mut self, msg: Num, _: &mut Self::Context) -> Self::Result {
+                fn handle(&mut self, msg: Num, _: &mut Self::Context) -> Self::Result {
-                msg.0
+                    msg.0
+                }
             }
-        }
 
 
-        let mut app = init_service(App::new().service(web::resource("/index.html").to(
+            let mut app = init_service(App::new().service(web::resource("/index.html").to(
-            move || {
+                move || {
-                addr.send(Num(1)).map(|res| match res {
+                    addr.send(Num(1)).map(|res| match res {
-                    Ok(res) => {
+                        Ok(res) => {
-                        if res == 1 {
+                            if res == 1 {
-                            Ok(HttpResponse::Ok())
+                                Ok(HttpResponse::Ok())
-                        } else {
+                            } else {
-                            Ok(HttpResponse::BadRequest())
+                                Ok(HttpResponse::BadRequest())
+                            }
                         }
-                    }
+                        Err(err) => Err(err),
-                    Err(err) => Err(err),
+                    })
-                })
+                },
-            },
+            )))
-        )))
+            .await;
-        .await;
 
-        let req = TestRequest::post().uri("/index.html").to_request();
+            let req = TestRequest::post().uri("/index.html").to_request();
-        let res = app.call(req).await.unwrap();
+            let res = app.call(req).await.unwrap();
-        assert!(res.status().is_success());
+            assert!(res.status().is_success());
-    }
+        }
-*/
+    */
 }

src/types/json.rs

@@ -11,7 +11,6 @@ use futures::future::{err, ok, FutureExt, LocalBoxFuture, Ready};
 use futures::StreamExt;
 use serde::de::DeserializeOwned;
 use serde::Serialize;
-use serde_json;
 
 use actix_http::http::{header::CONTENT_LENGTH, StatusCode};
 use actix_http::{HttpMessage, Payload, Response};
@@ -208,8 +207,10 @@ where
 
 /// Json extractor configuration
 ///
+/// # Examples
+///
 /// ```rust
-/// use actix_web::{error, web, App, FromRequest, HttpResponse};
+/// use actix_web::{error, web, App, FromRequest, HttpRequest, HttpResponse};
 /// use serde_derive::Deserialize;
 ///
 /// #[derive(Deserialize)]
@@ -222,6 +223,19 @@ where
 ///     format!("Welcome {}!", info.username)
 /// }
 ///
+/// /// Return either a 400 or 415, and include the error message from serde
+/// /// in the response body
+/// fn json_error_handler(err: error::JsonPayloadError, _req: &HttpRequest) -> error::Error {
+///     let detail = err.to_string();
+///     let response = match &err {
+///         error::JsonPayloadError::ContentType => {
+///             HttpResponse::UnsupportedMediaType().content_type("text/plain").body(detail)
+///         }
+///         _ => HttpResponse::BadRequest().content_type("text/plain").body(detail),
+///     };
+///     error::InternalError::from_response(err, response).into()
+/// }
+///
 /// fn main() {
 ///     let app = App::new().service(
 ///         web::resource("/index.html")
@@ -232,10 +246,7 @@ where
 ///                        .content_type(|mime| {  // <- accept text/plain content type
 ///                            mime.type_() == mime::TEXT && mime.subtype() == mime::PLAIN
 ///                        })
-///                        .error_handler(|err, req| {  // <- create custom error response
+///                        .error_handler(json_error_handler)  // Use our custom error response
-///                           error::InternalError::from_response(
-///                               err, HttpResponse::Conflict().finish()).into()
-///                        })
 ///             }))
 ///             .route(web::post().to(index))
 ///     );

src/types/query.rs

@@ -6,7 +6,6 @@ use std::{fmt, ops};
 use actix_http::error::Error;
 use futures::future::{err, ok, Ready};
 use serde::de;
-use serde_urlencoded;
 
 use crate::dev::Payload;
 use crate::error::QueryPayloadError;

test-server/CHANGES.md

@@ -3,6 +3,8 @@
 ## [Unreleased] - 2020-xx-xx
 
 * Update the `time` dependency to 0.2.7
+* Update `actix-connect` dependency to 2.0.0-alpha.2
+* Make `test_server` `async` fn.
 
 ## [1.0.0] - 2019-12-13
 

test-server/Cargo.toml

@@ -32,12 +32,12 @@ openssl = ["open-ssl", "awc/openssl"]
 [dependencies]
 actix-service = "1.0.1"
 actix-codec = "0.2.0"
-actix-connect = "1.0.0"
+actix-connect = "2.0.0-alpha.2"
 actix-utils = "1.0.3"
 actix-rt = "1.0.0"
 actix-server = "1.0.0"
 actix-testing = "1.0.0"
-awc = "1.0.1"
+awc = "2.0.0-alpha.1"
 
 base64 = "0.11"
 bytes = "0.5.3"
@@ -52,8 +52,8 @@ sha1 = "0.6"
 slab = "0.4"
 serde_urlencoded = "0.6.1"
 time = { version = "0.2.7", default-features = false, features = ["std"] }
-open-ssl = { version="0.10", package="openssl", optional = true }
+open-ssl = { version="0.10", package = "openssl", optional = true }
 
 [dev-dependencies]
-actix-web = "2.0.0"
+actix-web = "3.0.0-alpha.1"
-actix-http = "2.0.0-alpha.1"
+actix-http = "2.0.0-alpha.3"

test-server/src/lib.rs

@@ -43,7 +43,7 @@ pub use actix_testing::*;
 ///     assert!(response.status().is_success());
 /// }
 /// ```
-pub fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
+pub async fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
     let (tx, rx) = mpsc::channel();
 
     // run server in separate thread
@@ -92,7 +92,7 @@ pub fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
 
         Client::build().connector(connector).finish()
     };
-    actix_connect::start_default_resolver();
+    actix_connect::start_default_resolver().await.unwrap();
 
     TestServer {
         addr,

tests/test_weird_poll.rs

@@ -1,11 +1,11 @@
 // Regression test for #/1321
 
+/*
 use futures::task::{noop_waker, Context};
 use futures::stream::once;
 use actix_http::body::{MessageBody, BodyStream};
 use bytes::Bytes;
 
-/* 
 Disable weird poll until actix-web is based on actix-http 2.0.0
 
 #[test]