prepare actix-web-actors release 4.0.0-beta.3

Co-authored-by: Rob Ede <robjtede@icloud.com>

.github/workflows/ci.yml

@@ -1,24 +1,27 @@
-name: CI (Linux)
+name: CI
 
 on:
   pull_request:
     types: [opened, synchronize, reopened]
   push:
-    branches:
+    branches: [master]
-      - master
 
 jobs:
   build_and_test:
     strategy:
       fail-fast: false
       matrix:
+        target:
+          - { name: Linux, os: ubuntu-latest, triple: x86_64-unknown-linux-gnu }
+          - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin }
+          - { name: Windows, os: windows-latest, triple: x86_64-pc-windows-msvc }
         version:
           - 1.46.0 # MSRV
           - stable
           - nightly
 
-    name: ${{ matrix.version }} - x86_64-unknown-linux-gnu
+    name: ${{ matrix.target.name }} / ${{ matrix.version }}
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.target.os }}
 
     steps:
       - uses: actions/checkout@v2
@@ -26,7 +29,7 @@ jobs:
       - name: Install ${{ matrix.version }}
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: ${{ matrix.version }}-x86_64-unknown-linux-gnu
+          toolchain: ${{ matrix.version }}-${{ matrix.target.triple }}
           profile: minimal
           override: true
 
@@ -35,20 +38,33 @@ jobs:
         with:
           command: generate-lockfile
       - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.0.1
+        uses: Swatinem/rust-cache@v1.2.0
 
-      - name: check build
+      - name: Install cargo-hack
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cargo-hack
+
+      - name: check minimal
+        uses: actions-rs/cargo@v1
+        with:
+          command: hack
+          args: --clean-per-run check --workspace --no-default-features --tests
+
+      - name: check full
         uses: actions-rs/cargo@v1
         with:
           command: check
-          args: --all --bins --examples --tests
+          args: --workspace --bins --examples --tests
 
       - name: tests
         uses: actions-rs/cargo@v1
-        timeout-minutes: 40
         with:
           command: test
-          args: --all --all-features --no-fail-fast -- --nocapture
+          args: -v --workspace --all-features --no-fail-fast -- --nocapture
+            --skip=test_h2_content_length
+            --skip=test_reading_deflate_encoding_large_random_rustls
 
       - name: tests (actix-http)
         uses: actions-rs/cargo@v1
@@ -65,12 +81,18 @@ 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.target.os == 'ubuntu-latest'
+          && matrix.version == 'stable'
+          && github.ref == 'refs/heads/master'
         run: |
           cargo install cargo-tarpaulin --vers "^0.13"
-          cargo tarpaulin --out Xml
+          cargo tarpaulin --out Xml --verbose
       - name: Upload to Codecov
-        if: matrix.version == 'stable' && github.ref == 'refs/heads/master'
+        if: >
+          matrix.target.os == 'ubuntu-latest'
+          && matrix.version == 'stable'
+          && github.ref == 'refs/heads/master'
         uses: codecov/codecov-action@v1
         with:
           file: cobertura.xml

.github/workflows/macos.yml

@@ -1,56 +0,0 @@
-name: CI (macOS)
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-  push:
-    branches:
-      - master
-
-jobs:
-  build_and_test:
-    strategy:
-      fail-fast: false
-      matrix:
-        version:
-          - stable
-          - nightly
-
-    name: ${{ matrix.version }} - x86_64-apple-darwin
-    runs-on: macOS-latest
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install ${{ matrix.version }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.version }}-x86_64-apple-darwin
-          profile: minimal
-          override: true
-
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.0.1
-
-      - name: check build
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --all --bins --examples --tests
-
-      - name: tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          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

@@ -1,14 +1,12 @@
-name: Upload documentation
+name: Upload Documentation
 
 on:
   push:
-    branches:
+    branches: [master]
-      - master
 
 jobs:
   build:
     runs-on: ubuntu-latest
-    if: github.repository == 'actix/actix-web'
 
     steps:
       - uses: actions/checkout@v2
@@ -20,14 +18,14 @@ jobs:
           profile: minimal
           override: true
 
-      - name: check build
+      - name: Build Docs
         uses: actions-rs/cargo@v1
         with:
           command: doc
           args: --workspace --all-features --no-deps
 
       - name: Tweak HTML
-        run: echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html
+        run: echo '<meta http-equiv="refresh" content="0;url=actix_web/index.html">' > target/doc/index.html
 
       - name: Deploy to GitHub Pages
         uses: JamesIves/github-pages-deploy-action@3.7.1

.github/workflows/windows.yml

@@ -1,76 +0,0 @@
-name: CI (Windows)
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-  push:
-    branches:
-      - master
-
-env:
-  VCPKGRS_DYNAMIC: 1
-
-jobs:
-  build_and_test:
-    strategy:
-      fail-fast: false
-      matrix:
-        version:
-          - stable
-          - nightly
-
-    name: ${{ matrix.version }} - x86_64-pc-windows-msvc
-    runs-on: windows-latest
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install ${{ matrix.version }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.version }}-x86_64-pc-windows-msvc
-          profile: minimal
-          override: true
-
-      - name: Install OpenSSL
-        run: |
-          vcpkg integrate install
-          vcpkg install openssl:x64-windows
-          Copy-Item C:\vcpkg\installed\x64-windows\bin\libcrypto-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libcrypto.dll
-          Copy-Item C:\vcpkg\installed\x64-windows\bin\libssl-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libssl.dll
-          Get-ChildItem C:\vcpkg\installed\x64-windows\bin
-          Get-ChildItem C:\vcpkg\installed\x64-windows\lib
-
-      - name: Generate Cargo.lock
-        uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
-      - name: Cache Dependencies
-        uses: Swatinem/rust-cache@v1.0.1
-
-      - name: check build
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --all --bins --examples --tests
-
-      - name: tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --all --all-features --no-fail-fast -- --nocapture
-                --skip=test_h2_content_length
-                --skip=test_reading_deflate_encoding_large_random_rustls
-                --skip=test_params
-                --skip=test_simple
-                --skip=test_expect_continue
-                --skip=test_http10_keepalive
-                --skip=test_slow_request
-                --skip=test_connection_force_close
-                --skip=test_connection_server_close
-                --skip=test_connection_wait_queue_force_close
-
-      - name: Clear the cargo caches
-        run: |
-          cargo install cargo-cache --no-default-features --features ci-autoclean
-          cargo-cache

CHANGES.md

@@ -3,7 +3,21 @@
 ## Unreleased - 2021-xx-xx
 
 
-## 4.0.0-beta.2 - 2021-xx-xx
+## 4.0.0-beta.4 - 2021-03-09
+### Changed
+* Feature `cookies` is now optional and enabled by default. [#1981]
+* `JsonBody::new` returns a default limit of 32kB to be consistent with `JsonConfig` and the default
+  behaviour of the `web::Json<T>` extractor. [#2010]
+
+[#1981]: https://github.com/actix/actix-web/pull/1981
+[#2010]: https://github.com/actix/actix-web/pull/2010
+
+
+## 4.0.0-beta.3 - 2021-02-10
+* Update `actix-web-codegen` to `0.5.0-beta.1`.
+
+
+## 4.0.0-beta.2 - 2021-02-10
 ### Added
 * The method `Either<web::Json<T>, web::Form<T>>::into_inner()` which returns the inner type for
   whichever variant was created. Also works for `Either<web::Form<T>, web::Json<T>>`. [#1894]
@@ -157,7 +171,7 @@
 
 ## 3.0.0-beta.4 - 2020-09-09
 ### Added
-* `middleware::NormalizePath` now has configurable behaviour for either always having a trailing
+* `middleware::NormalizePath` now has configurable behavior for either always having a trailing 
   slash, or as the new addition, always trimming trailing slashes. [#1639]
 
 ### Changed
@@ -485,7 +499,7 @@
 
 ## [1.0.0-rc] - 2019-05-18
 
-### Add
+### Added
 
 * Add `Query<T>::from_query()` to extract parameters from a query string. #846
 * `QueryConfig`, similar to `JsonConfig` for customizing error handling of query extractors.
@@ -501,7 +515,7 @@
 
 ## [1.0.0-beta.4] - 2019-05-12
 
-### Add
+### Added
 
 * Allow to set/override app data on scope level
 
@@ -527,7 +541,7 @@
 
 * CORS handling without headers #702
 
-* Allow to construct `Data` instances to avoid double `Arc` for `Send + Sync` types.
+* Allow constructing `Data` instances to avoid double `Arc` for `Send + Sync` types.
 
 ### Fixed
 
@@ -591,7 +605,7 @@
 
 ### Changed
 
-* Allow to use any service as default service.
+* Allow using any service as default service.
 
 * Remove generic type for request payload, always use default.
 
@@ -654,13 +668,13 @@
 
 ### Added
 
-* rustls support
+* Rustls support
 
 ### Changed
 
-* use forked cookie
+* Use forked cookie
 
-* multipart::Field renamed to MultipartField
+* Multipart::Field renamed to MultipartField
 
 ## [1.0.0-alpha.1] - 2019-03-28
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "4.0.0-beta.2"
+version = "4.0.0-beta.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
 readme = "README.md"
@@ -15,6 +15,7 @@ license = "MIT OR Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
+# features that docs.rs will build with
 features = ["openssl", "rustls", "compress", "secure-cookies"]
 
 [badges]
@@ -38,19 +39,22 @@ members = [
 ]
 
 [features]
-default = ["compress"]
+default = ["compress", "cookies"]
 
 # content-encoding support
 compress = ["actix-http/compress", "awc/compress"]
 
-# sessions feature
+# support for cookies
+cookies = ["actix-http/cookies", "awc/cookies"]
+
+# secure cookies feature
 secure-cookies = ["actix-http/secure-cookies"]
 
 # openssl
-openssl = ["tls_openssl", "actix-tls/accept", "actix-tls/openssl", "awc/openssl"]
+openssl = ["tls-openssl", "actix-tls/accept", "actix-tls/openssl", "awc/openssl"]
 
 # rustls
-rustls = ["tls_rustls", "actix-tls/accept", "actix-tls/rustls", "awc/rustls"]
+rustls = ["tls-rustls", "actix-tls/accept", "actix-tls/rustls", "awc/rustls"]
 
 [[example]]
 name = "basic"
@@ -62,7 +66,7 @@ required-features = ["compress"]
 
 [[test]]
 name = "test_server"
-required-features = ["compress"]
+required-features = ["compress", "cookies"]
 
 [[example]]
 name = "on_connect"
@@ -76,15 +80,15 @@ required-features = ["rustls"]
 actix-codec = "0.4.0-beta.1"
 actix-macros = "0.2.0"
 actix-router = "0.2.7"
-actix-rt = "2"
+actix-rt = "2.1"
 actix-server = "2.0.0-beta.3"
 actix-service = "2.0.0-beta.4"
 actix-utils = "3.0.0-beta.2"
-actix-tls = { version = "3.0.0-beta.3", default-features = false, optional = true }
+actix-tls = { version = "3.0.0-beta.4", default-features = false, optional = true }
 
-actix-web-codegen = "0.4.0"
+actix-web-codegen = "0.5.0-beta.2"
-actix-http = "3.0.0-beta.2"
+actix-http = "3.0.0-beta.4"
-awc = { version = "3.0.0-beta.2", default-features = false }
+awc = { version = "3.0.0-beta.3", default-features = false }
 
 ahash = "0.7"
 bytes = "1"
@@ -95,26 +99,32 @@ futures-core = { version = "0.3.7", default-features = false }
 futures-util = { version = "0.3.7", default-features = false }
 log = "0.4"
 mime = "0.3"
-socket2 = "0.3.16"
 pin-project = "1.0.0"
 regex = "1.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.7"
-time = { version = "0.2.23", default-features = false, features = ["std"] }
-url = "2.1"
-tls_openssl = { package = "openssl", version = "0.10.9", optional = true }
-tls_rustls = { package = "rustls", version = "0.19.0", optional = true }
 smallvec = "1.6"
+socket2 = "0.3.16"
+time = { version = "0.2.23", default-features = false, features = ["std"] }
+tls-openssl = { package = "openssl", version = "0.10.9", optional = true }
+tls-rustls = { package = "rustls", version = "0.19.0", optional = true }
+url = "2.1"
+
+[target.'cfg(windows)'.dependencies.tls-openssl]
+version = "0.10.9"
+package = "openssl"
+features = ["vendored"]
+optional = true
 
 [dev-dependencies]
-actix = { version = "0.11.0-beta.2", default-features = false }
-rand = "0.8"
-env_logger = "0.8"
-serde_derive = "1.0"
 brotli2 = "0.3.2"
-flate2 = "1.0.13"
 criterion = "0.3"
+env_logger = "0.8"
+flate2 = "1.0.13"
+rand = "0.8"
+rcgen = "0.8"
+serde_derive = "1.0"
 
 [profile.release]
 lto = true

README.md

@@ -6,10 +6,10 @@
   <p>
 
 [![crates.io](https://img.shields.io/crates/v/actix-web?label=latest)](https://crates.io/crates/actix-web)
-[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.2)](https://docs.rs/actix-web/4.0.0-beta.2)
+[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.4)](https://docs.rs/actix-web/4.0.0-beta.4)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-web.svg)
-[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.2/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.2)
+[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.4/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.4)
 <br />
 [![build status](https://github.com/actix/actix-web/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-web/actions)
 [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) 
@@ -31,8 +31,7 @@
 * Static assets
 * SSL support using OpenSSL or Rustls
 * Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
-* Includes an async [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
+* Includes an async [HTTP client](https://docs.rs/actix-web/latest/actix_web/client/index.html)
-* Supports [Actix actor framework](https://github.com/actix/actix)
 * Runs on stable Rust 1.46+
 
 ## Documentation
@@ -72,18 +71,18 @@ async fn main() -> std::io::Result<()> {
 
 ### More examples
 
-* [Basic Setup](https://github.com/actix/examples/tree/master/basics/)
+* [Basic Setup](https://github.com/actix/examples/tree/master/basics/basics/)
-* [Application State](https://github.com/actix/examples/tree/master/state/)
+* [Application State](https://github.com/actix/examples/tree/master/basics/state/)
-* [JSON Handling](https://github.com/actix/examples/tree/master/json/)
+* [JSON Handling](https://github.com/actix/examples/tree/master/json/json/)
-* [Multipart Streams](https://github.com/actix/examples/tree/master/multipart/)
+* [Multipart Streams](https://github.com/actix/examples/tree/master/forms/multipart/)
-* [Diesel Integration](https://github.com/actix/examples/tree/master/diesel/)
+* [Diesel Integration](https://github.com/actix/examples/tree/master/database_interactions/diesel/)
-* [r2d2 Integration](https://github.com/actix/examples/tree/master/r2d2/)
+* [r2d2 Integration](https://github.com/actix/examples/tree/master/database_interactions/r2d2/)
-* [Simple WebSocket](https://github.com/actix/examples/tree/master/websocket/)
+* [Simple WebSocket](https://github.com/actix/examples/tree/master/websockets/websocket/)
-* [Tera Templates](https://github.com/actix/examples/tree/master/template_tera/)
+* [Tera Templates](https://github.com/actix/examples/tree/master/template_engines/tera/)
-* [Askama Templates](https://github.com/actix/examples/tree/master/template_askama/)
+* [Askama Templates](https://github.com/actix/examples/tree/master/template_engines/askama/)
-* [HTTPS using Rustls](https://github.com/actix/examples/tree/master/rustls/)
+* [HTTPS using Rustls](https://github.com/actix/examples/tree/master/security/rustls/)
-* [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/openssl/)
+* [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/security/openssl/)
-* [WebSocket Chat](https://github.com/actix/examples/tree/master/websocket-chat/)
+* [WebSocket Chat](https://github.com/actix/examples/tree/master/websockets/chat/)
 
 You may consider checking out
 [this directory](https://github.com/actix/examples/tree/master/) for more examples.

actix-files/CHANGES.md

@@ -3,6 +3,10 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 0.6.0-beta.3 - 2021-03-09
+* No notable changes.
+
+
 ## 0.6.0-beta.2 - 2021-02-10
 * Fix If-Modified-Since and If-Unmodified-Since to not compare using sub-second timestamps. [#1887]
 * Replace `v_htmlescape` with `askama_escape`. [#1953]

actix-files/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.6.0-beta.2"
+version = "0.6.0-beta.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static file serving for Actix Web"
 readme = "README.md"
@@ -17,7 +17,7 @@ name = "actix_files"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = { version = "4.0.0-beta.2", default-features = false }
+actix-web = { version = "4.0.0-beta.4", default-features = false }
 actix-service = "2.0.0-beta.4"
 
 askama_escape = "0.10"
@@ -25,6 +25,7 @@ bitflags = "1"
 bytes = "1"
 futures-core = { version = "0.3.7", default-features = false }
 futures-util = { version = "0.3.7", default-features = false }
+http-range = "0.1.4"
 derive_more = "0.99.5"
 log = "0.4"
 mime = "0.3"
@@ -32,5 +33,5 @@ mime_guess = "2.0.1"
 percent-encoding = "2.1"
 
 [dev-dependencies]
-actix-rt = "2"
+actix-rt = "2.1"
-actix-web = "4.0.0-beta.2"
+actix-web = "4.0.0-beta.4"

actix-files/README.md

@@ -3,17 +3,17 @@
 > Static file serving for Actix Web
 
 [![crates.io](https://img.shields.io/crates/v/actix-files?label=latest)](https://crates.io/crates/actix-files)
-[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.5.0)](https://docs.rs/actix-files/0.5.0)
+[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.0-beta.3)](https://docs.rs/actix-files/0.6.0-beta.3)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![License](https://img.shields.io/crates/l/actix-files.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-files/0.5.0/status.svg)](https://deps.rs/crate/actix-files/0.5.0)
+[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.3/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.3)
 [![Download](https://img.shields.io/crates/d/actix-files.svg)](https://crates.io/crates/actix-files)
 [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-files/)
-- [Example Project](https://github.com/actix/examples/tree/master/static_index)
+- [Example Project](https://github.com/actix/examples/tree/master/basics/static_index)
 - [Chat on Gitter](https://gitter.im/actix/actix-web)
 - Minimum supported Rust version: 1.46 or later

actix-files/src/chunked.rs

@@ -49,10 +49,7 @@ impl fmt::Debug for ChunkedReadFile {
 impl Stream for ChunkedReadFile {
     type Item = Result<Bytes, Error>;
 
-    fn poll_next(
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
         let this = self.as_mut().get_mut();
         match this.state {
             ChunkedReadFileState::File(ref mut file) => {
@@ -68,16 +65,13 @@ impl Stream for ChunkedReadFile {
                         .expect("ChunkedReadFile polled after completion");
 
                     let fut = spawn_blocking(move || {
-                        let max_bytes =
+                        let max_bytes = cmp::min(size.saturating_sub(counter), 65_536) as usize;
-                            cmp::min(size.saturating_sub(counter), 65_536) as usize;
 
                         let mut buf = Vec::with_capacity(max_bytes);
                         file.seek(io::SeekFrom::Start(offset))?;
 
-                        let n_bytes = file
+                        let n_bytes =
-                            .by_ref()
+                            file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
-                            .take(max_bytes as u64)
-                            .read_to_end(&mut buf)?;
 
                         if n_bytes == 0 {
                             return Err(io::ErrorKind::UnexpectedEof.into());

actix-files/src/directory.rs

@@ -66,9 +66,7 @@ pub(crate) fn directory_listing(
         if dir.is_visible(&entry) {
             let entry = entry.unwrap();
             let p = match entry.path().strip_prefix(&dir.path) {
-                Ok(p) if cfg!(windows) => {
+                Ok(p) if cfg!(windows) => base.join(p).to_string_lossy().replace("\\", "/"),
-                    base.join(p).to_string_lossy().replace("\\", "/")
-                }
                 Ok(p) => base.join(p).to_string_lossy().into_owned(),
                 Err(_) => continue,
             };

actix-files/src/files.rs

@@ -2,9 +2,7 @@ use std::{cell::RefCell, fmt, io, path::PathBuf, rc::Rc};
 
 use actix_service::{boxed, IntoServiceFactory, ServiceFactory, ServiceFactoryExt};
 use actix_web::{
-    dev::{
+    dev::{AppService, HttpServiceFactory, ResourceDef, ServiceRequest, ServiceResponse},
-        AppService, HttpServiceFactory, ResourceDef, ServiceRequest, ServiceResponse,
-    },
     error::Error,
     guard::Guard,
     http::header::DispositionType,
@@ -13,8 +11,8 @@ use actix_web::{
 use futures_util::future::{ok, FutureExt, LocalBoxFuture};
 
 use crate::{
-    directory_listing, named, Directory, DirectoryRenderer, FilesService,
+    directory_listing, named, Directory, DirectoryRenderer, FilesService, HttpNewService,
-    HttpNewService, MimeOverride,
+    MimeOverride,
 };
 
 /// Static files handling service.
@@ -129,8 +127,8 @@ impl Files {
     /// Set custom directory renderer
     pub fn files_listing_renderer<F>(mut self, f: F) -> Self
     where
-        for<'r, 's> F: Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, io::Error>
+        for<'r, 's> F:
-            + 'static,
+            Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, io::Error> + 'static,
     {
         self.renderer = Rc::new(f);
         self

actix-files/src/lib.rs

@@ -98,8 +98,7 @@ mod tests {
     #[actix_rt::test]
     async fn test_if_modified_since_without_if_none_match() {
         let file = NamedFile::open("Cargo.toml").unwrap();
-        let since =
+        let since = header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
-            header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
 
         let req = TestRequest::default()
             .insert_header((header::IF_MODIFIED_SINCE, since))
@@ -123,8 +122,7 @@ mod tests {
     #[actix_rt::test]
     async fn test_if_modified_since_with_if_none_match() {
         let file = NamedFile::open("Cargo.toml").unwrap();
-        let since =
+        let since = header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
-            header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
 
         let req = TestRequest::default()
             .insert_header((header::IF_NONE_MATCH, "miss_etag"))
@@ -212,8 +210,7 @@ mod tests {
     #[actix_rt::test]
     async fn test_named_file_non_ascii_file_name() {
         let mut file =
-            NamedFile::from_file(File::open("Cargo.toml").unwrap(), "貨物.toml")
+            NamedFile::from_file(File::open("Cargo.toml").unwrap(), "貨物.toml").unwrap();
-                .unwrap();
         {
             file.file();
             let _f: &File = &file;
@@ -605,10 +602,9 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_static_files() {
-        let srv = test::init_service(
+        let srv =
-            App::new().service(Files::new("/", ".").show_files_listing()),
+            test::init_service(App::new().service(Files::new("/", ".").show_files_listing()))
-        )
+                .await;
-        .await;
         let req = TestRequest::with_uri("/missing").to_request();
 
         let resp = test::call_service(&srv, req).await;
@@ -620,10 +616,9 @@ mod tests {
         let resp = test::call_service(&srv, req).await;
         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
 
-        let srv = test::init_service(
+        let srv =
-            App::new().service(Files::new("/", ".").show_files_listing()),
+            test::init_service(App::new().service(Files::new("/", ".").show_files_listing()))
-        )
+                .await;
-        .await;
         let req = TestRequest::with_uri("/tests").to_request();
         let resp = test::call_service(&srv, req).await;
         assert_eq!(
@@ -667,8 +662,12 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_static_files_bad_directory() {
-        let _st: Files = Files::new("/", "missing");
+        let service = Files::new("/", "./missing").new_service(()).await.unwrap();
-        let _st: Files = Files::new("/", "Cargo.toml");
+
+        let req = TestRequest::with_uri("/").to_srv_request();
+        let resp = test::call_service(&service, req).await;
+
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
     }
 
     #[actix_rt::test]
@@ -681,75 +680,34 @@ mod tests {
             .await
             .unwrap();
         let req = TestRequest::with_uri("/missing").to_srv_request();
-
         let resp = test::call_service(&st, req).await;
+
         assert_eq!(resp.status(), StatusCode::OK);
         let bytes = test::read_body(resp).await;
         assert_eq!(bytes, web::Bytes::from_static(b"default content"));
     }
 
-    //     #[actix_rt::test]
+    #[actix_rt::test]
-    //     async fn test_serve_index() {
+    async fn test_serve_index_nested() {
-    //         let st = Files::new(".").index_file("test.binary");
+        let service = Files::new(".", ".")
-    //         let req = TestRequest::default().uri("/tests").finish();
+            .index_file("lib.rs")
+            .new_service(())
+            .await
+            .unwrap();
 
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
+        let req = TestRequest::default().uri("/src").to_srv_request();
-    //         let resp = resp.as_msg();
+        let resp = test::call_service(&service, req).await;
-    //         assert_eq!(resp.status(), StatusCode::OK);
-    //         assert_eq!(
-    //             resp.headers()
-    //                 .get(header::CONTENT_TYPE)
-    //                 .expect("content type"),
-    //             "application/octet-stream"
-    //         );
-    //         assert_eq!(
-    //             resp.headers()
-    //                 .get(header::CONTENT_DISPOSITION)
-    //                 .expect("content disposition"),
-    //             "attachment; filename=\"test.binary\""
-    //         );
 
-    //         let req = TestRequest::default().uri("/tests/").finish();
+        assert_eq!(resp.status(), StatusCode::OK);
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
+        assert_eq!(
-    //         let resp = resp.as_msg();
+            resp.headers().get(header::CONTENT_TYPE).unwrap(),
-    //         assert_eq!(resp.status(), StatusCode::OK);
+            "text/x-rust"
-    //         assert_eq!(
+        );
-    //             resp.headers().get(header::CONTENT_TYPE).unwrap(),
+        assert_eq!(
-    //             "application/octet-stream"
+            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-    //         );
+            "inline; filename=\"lib.rs\""
-    //         assert_eq!(
+        );
-    //             resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+    }
-    //             "attachment; filename=\"test.binary\""
-    //         );
-
-    //         // nonexistent index file
-    //         let req = TestRequest::default().uri("/tests/unknown").finish();
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
-    //         let resp = resp.as_msg();
-    //         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-
-    //         let req = TestRequest::default().uri("/tests/unknown/").finish();
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
-    //         let resp = resp.as_msg();
-    //         assert_eq!(resp.status(), StatusCode::NOT_FOUND);
-    //     }
-
-    //     #[actix_rt::test]
-    //     async fn test_serve_index_nested() {
-    //         let st = Files::new(".").index_file("mod.rs");
-    //         let req = TestRequest::default().uri("/src/client").finish();
-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
-    //         let resp = resp.as_msg();
-    //         assert_eq!(resp.status(), StatusCode::OK);
-    //         assert_eq!(
-    //             resp.headers().get(header::CONTENT_TYPE).unwrap(),
-    //             "text/x-rust"
-    //         );
-    //         assert_eq!(
-    //             resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-    //             "inline; filename=\"mod.rs\""
-    //         );
-    //     }
 
     #[actix_rt::test]
     async fn integration_serve_index() {

actix-files/src/named.rs

@@ -11,8 +11,7 @@ use actix_web::{
     dev::{BodyEncoding, SizedStream},
     http::{
         header::{
-            self, Charset, ContentDisposition, DispositionParam, DispositionType,
+            self, Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue,
-            ExtendedValue,
         },
         ContentEncoding, StatusCode,
     },
@@ -395,18 +394,10 @@ impl NamedFile {
                     resp.encoding(ContentEncoding::Identity);
                     resp.insert_header((
                         header::CONTENT_RANGE,
-                        format!(
+                        format!("bytes {}-{}/{}", offset, offset + length - 1, self.md.len()),
-                            "bytes {}-{}/{}",
-                            offset,
-                            offset + length - 1,
-                            self.md.len()
-                        ),
                     ));
                 } else {
-                    resp.insert_header((
+                    resp.insert_header((header::CONTENT_RANGE, format!("bytes */{}", length)));
-                        header::CONTENT_RANGE,
-                        format!("bytes */{}", length),
-                    ));
                     return resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish();
                 };
             } else {

actix-files/src/range.rs

@@ -10,9 +10,6 @@ pub struct HttpRange {
     pub length: u64,
 }
 
-const PREFIX: &str = "bytes=";
-const PREFIX_LEN: usize = 6;
-
 #[derive(Debug, Clone, Display, Error)]
 #[display(fmt = "Parse HTTP Range failed")]
 pub struct ParseRangeErr(#[error(not(source))] ());
@@ -23,84 +20,16 @@ impl HttpRange {
     /// `header` is HTTP Range header (e.g. `bytes=bytes=0-9`).
     /// `size` is full size of response (file).
     pub fn parse(header: &str, size: u64) -> Result<Vec<HttpRange>, ParseRangeErr> {
-        if header.is_empty() {
+        match http_range::HttpRange::parse(header, size) {
-            return Ok(Vec::new());
+            Ok(ranges) => Ok(ranges
+                .iter()
+                .map(|range| HttpRange {
+                    start: range.start,
+                    length: range.length,
+                })
+                .collect()),
+            Err(_) => Err(ParseRangeErr(())),
         }
-        if !header.starts_with(PREFIX) {
-            return Err(ParseRangeErr(()));
-        }
-
-        let size_sig = size as i64;
-        let mut no_overlap = false;
-
-        let all_ranges: Vec<Option<HttpRange>> = header[PREFIX_LEN..]
-            .split(',')
-            .map(|x| x.trim())
-            .filter(|x| !x.is_empty())
-            .map(|ra| {
-                let mut start_end_iter = ra.split('-');
-
-                let start_str = start_end_iter.next().ok_or(ParseRangeErr(()))?.trim();
-                let end_str = start_end_iter.next().ok_or(ParseRangeErr(()))?.trim();
-
-                if start_str.is_empty() {
-                    // If no start is specified, end specifies the
-                    // range start relative to the end of the file.
-                    let mut length: i64 =
-                        end_str.parse().map_err(|_| ParseRangeErr(()))?;
-
-                    if length > size_sig {
-                        length = size_sig;
-                    }
-
-                    Ok(Some(HttpRange {
-                        start: (size_sig - length) as u64,
-                        length: length as u64,
-                    }))
-                } else {
-                    let start: i64 = start_str.parse().map_err(|_| ParseRangeErr(()))?;
-
-                    if start < 0 {
-                        return Err(ParseRangeErr(()));
-                    }
-                    if start >= size_sig {
-                        no_overlap = true;
-                        return Ok(None);
-                    }
-
-                    let length = if end_str.is_empty() {
-                        // If no end is specified, range extends to end of the file.
-                        size_sig - start
-                    } else {
-                        let mut end: i64 =
-                            end_str.parse().map_err(|_| ParseRangeErr(()))?;
-
-                        if start > end {
-                            return Err(ParseRangeErr(()));
-                        }
-
-                        if end >= size_sig {
-                            end = size_sig - 1;
-                        }
-
-                        end - start + 1
-                    };
-
-                    Ok(Some(HttpRange {
-                        start: start as u64,
-                        length: length as u64,
-                    }))
-                }
-            })
-            .collect::<Result<_, _>>()?;
-
-        let ranges: Vec<HttpRange> = all_ranges.into_iter().filter_map(|x| x).collect();
-
-        if no_overlap && ranges.is_empty() {
-            return Err(ParseRangeErr(()));
-        }
-
-        Ok(ranges)
     }
 }
 

actix-files/src/service.rs

@@ -11,8 +11,8 @@ use actix_web::{
 use futures_util::future::{ok, Either, LocalBoxFuture, Ready};
 
 use crate::{
-    named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride,
+    named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride, NamedFile,
-    NamedFile, PathBufWrap,
+    PathBufWrap,
 };
 
 /// Assembled file serving service.
@@ -138,8 +138,7 @@ impl Service<ServiceRequest> for FilesService {
             match NamedFile::open(path) {
                 Ok(mut named_file) => {
                     if let Some(ref mime_override) = self.mime_override {
-                        let new_disposition =
+                        let new_disposition = mime_override(&named_file.content_type.type_());
-                            mime_override(&named_file.content_type.type_());
                         named_file.content_disposition.disposition = new_disposition;
                     }
                     named_file.flags = self.file_flags;

actix-files/tests/encoding.rs

@@ -23,10 +23,9 @@ async fn test_utf8_file_contents() {
     );
 
     // prefer UTF-8 encoding
-    let srv = test::init_service(
+    let srv =
-        App::new().service(Files::new("/", "./tests").prefer_utf8(true)),
+        test::init_service(App::new().service(Files::new("/", "./tests").prefer_utf8(true)))
-    )
+            .await;
-    .await;
 
     let req = TestRequest::with_uri("/utf8.txt").to_request();
     let res = test::call_service(&srv, req).await;

actix-http-test/CHANGES.md

@@ -3,6 +3,10 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 3.0.0-beta.3 - 2021-03-09
+* No notable changes.
+
+
 ## 3.0.0-beta.2 - 2021-02-10
 * No notable changes.
 

actix-http-test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http-test"
-version = "3.0.0-beta.2"
+version = "3.0.0-beta.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Various helpers for Actix applications to use during testing"
 readme = "README.md"
@@ -31,11 +31,11 @@ openssl = ["tls-openssl", "awc/openssl"]
 [dependencies]
 actix-service = "2.0.0-beta.4"
 actix-codec = "0.4.0-beta.1"
-actix-tls = "3.0.0-beta.3"
+actix-tls = "3.0.0-beta.4"
 actix-utils = "3.0.0-beta.2"
-actix-rt = "2"
+actix-rt = "2.1"
 actix-server = "2.0.0-beta.3"
-awc = "3.0.0-beta.2"
+awc = { version = "3.0.0-beta.3", default-features = false }
 
 base64 = "0.13"
 bytes = "1"
@@ -50,6 +50,12 @@ serde_urlencoded = "0.7"
 time = { version = "0.2.23", default-features = false, features = ["std"] }
 tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
 
+[target.'cfg(windows)'.dependencies.tls-openssl]
+version = "0.10.9"
+package = "openssl"
+features = ["vendored"]
+optional = true
+
 [dev-dependencies]
-actix-web = "4.0.0-beta.2"
+actix-web = { version = "4.0.0-beta.4", default-features = false, features = ["cookies"] }
-actix-http = "3.0.0-beta.2"
+actix-http = "3.0.0-beta.4"

actix-http-test/README.md

@@ -3,9 +3,9 @@
 > Various helpers for Actix applications to use during testing.
 
 [![crates.io](https://img.shields.io/crates/v/actix-http-test?label=latest)](https://crates.io/crates/actix-http-test)
-[![Documentation](https://docs.rs/actix-http-test/badge.svg?version=2.1.0)](https://docs.rs/actix-http-test/2.1.0)
+[![Documentation](https://docs.rs/actix-http-test/badge.svg?version=3.0.0-beta.3)](https://docs.rs/actix-http-test/3.0.0-beta.3)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http-test)
-[![Dependency Status](https://deps.rs/crate/actix-http-test/2.1.0/status.svg)](https://deps.rs/crate/actix-http-test/2.1.0)
+[![Dependency Status](https://deps.rs/crate/actix-http-test/3.0.0-beta.3/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0-beta.3)
 [![Join the chat at https://gitter.im/actix/actix-web](https://badges.gitter.im/actix/actix-web.svg)](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Documentation & Resources

actix-http-test/src/lib.rs

@@ -96,14 +96,12 @@ pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
                     .conn_lifetime(time::Duration::from_secs(0))
                     .timeout(time::Duration::from_millis(30000))
                     .ssl(builder.build())
-                    .finish()
             }
             #[cfg(not(feature = "openssl"))]
             {
                 Connector::new()
                     .conn_lifetime(time::Duration::from_secs(0))
                     .timeout(time::Duration::from_millis(30000))
-                    .finish()
             }
         };
 
@@ -120,8 +118,7 @@ pub async fn test_server_with_addr<F: ServiceFactory<TcpStream>>(
 /// Get first available unused address
 pub fn unused_addr() -> net::SocketAddr {
     let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
-    let socket =
+    let socket = Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap();
-        Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap();
     socket.bind(&addr.into()).unwrap();
     socket.set_reuse_address(true).unwrap();
     let tcp = socket.into_tcp_listener();
@@ -150,7 +147,7 @@ impl TestServer {
         }
     }
 
-    /// Construct test https server url
+    /// Construct test HTTPS server URL.
     pub fn surl(&self, uri: &str) -> String {
         if uri.starts_with('/') {
             format!("https://localhost:{}{}", self.addr.port(), uri)
@@ -164,7 +161,7 @@ impl TestServer {
         self.client.get(self.url(path.as_ref()).as_str())
     }
 
-    /// Create https `GET` request
+    /// Create HTTPS `GET` request
     pub fn sget<S: AsRef<str>>(&self, path: S) -> ClientRequest {
         self.client.get(self.surl(path.as_ref()).as_str())
     }
@@ -174,7 +171,7 @@ impl TestServer {
         self.client.post(self.url(path.as_ref()).as_str())
     }
 
-    /// Create https `POST` request
+    /// Create HTTPS `POST` request
     pub fn spost<S: AsRef<str>>(&self, path: S) -> ClientRequest {
         self.client.post(self.surl(path.as_ref()).as_str())
     }
@@ -184,7 +181,7 @@ impl TestServer {
         self.client.head(self.url(path.as_ref()).as_str())
     }
 
-    /// Create https `HEAD` request
+    /// Create HTTPS `HEAD` request
     pub fn shead<S: AsRef<str>>(&self, path: S) -> ClientRequest {
         self.client.head(self.surl(path.as_ref()).as_str())
     }
@@ -194,7 +191,7 @@ impl TestServer {
         self.client.put(self.url(path.as_ref()).as_str())
     }
 
-    /// Create https `PUT` request
+    /// Create HTTPS `PUT` request
     pub fn sput<S: AsRef<str>>(&self, path: S) -> ClientRequest {
         self.client.put(self.surl(path.as_ref()).as_str())
     }
@@ -204,7 +201,7 @@ impl TestServer {
         self.client.patch(self.url(path.as_ref()).as_str())
     }
 
-    /// Create https `PATCH` request
+    /// Create HTTPS `PATCH` request
     pub fn spatch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
         self.client.patch(self.surl(path.as_ref()).as_str())
     }
@@ -214,7 +211,7 @@ impl TestServer {
         self.client.delete(self.url(path.as_ref()).as_str())
     }
 
-    /// Create https `DELETE` request
+    /// Create HTTPS `DELETE` request
     pub fn sdelete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
         self.client.delete(self.surl(path.as_ref()).as_str())
     }
@@ -224,12 +221,12 @@ impl TestServer {
         self.client.options(self.url(path.as_ref()).as_str())
     }
 
-    /// Create https `OPTIONS` request
+    /// Create HTTPS `OPTIONS` request
     pub fn soptions<S: AsRef<str>>(&self, path: S) -> ClientRequest {
         self.client.options(self.surl(path.as_ref()).as_str())
     }
 
-    /// Connect to test http server
+    /// Connect to test HTTP server
     pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> ClientRequest {
         self.client.request(method, path.as_ref())
     }
@@ -244,26 +241,24 @@ impl TestServer {
         response.body().limit(10_485_760).await
     }
 
-    /// Connect to websocket server at a given path
+    /// Connect to WebSocket server at a given path.
     pub async fn ws_at(
         &mut self,
         path: &str,
-    ) -> Result<Framed<impl AsyncRead + AsyncWrite, ws::Codec>, awc::error::WsClientError>
+    ) -> Result<Framed<impl AsyncRead + AsyncWrite, ws::Codec>, awc::error::WsClientError> {
-    {
         let url = self.url(path);
         let connect = self.client.ws(url).connect();
         connect.await.map(|(_, framed)| framed)
     }
 
-    /// Connect to a websocket server
+    /// Connect to a WebSocket server.
     pub async fn ws(
         &mut self,
-    ) -> Result<Framed<impl AsyncRead + AsyncWrite, ws::Codec>, awc::error::WsClientError>
+    ) -> Result<Framed<impl AsyncRead + AsyncWrite, ws::Codec>, awc::error::WsClientError> {
-    {
         self.ws_at("/").await
     }
 
-    /// Stop http server
+    /// Stop HTTP server
     fn stop(&mut self) {
         self.system.stop();
     }

actix-http/CHANGES.md

@@ -3,7 +3,27 @@
 ## Unreleased - 2021-xx-xx
 
 
-## 3.0.0-beta.2 - 2021-02-19
+## 3.0.0-beta.4 - 2021-03-08
+### Changed
+* Feature `cookies` is now optional and disabled by default. [#1981]
+* `ws::hash_key` now returns array. [#2035]
+* `ResponseBuilder::json` now takes `impl Serialize`. [#2052]
+
+### Removed
+* Re-export of `futures_channel::oneshot::Canceled` is removed from `error` mod. [#1994]
+* `ResponseError` impl for `futures_channel::oneshot::Canceled` is removed. [#1994]
+
+[#1981]: https://github.com/actix/actix-web/pull/1981
+[#1994]: https://github.com/actix/actix-web/pull/1994
+[#2035]: https://github.com/actix/actix-web/pull/2035
+[#2052]: https://github.com/actix/actix-web/pull/2052
+
+
+## 3.0.0-beta.3 - 2021-02-10
+* No notable changes.
+
+
+## 3.0.0-beta.2 - 2021-02-10
 ### Added
 * `IntoHeaderPair` trait that allows using typed and untyped headers in the same methods. [#1869]
 * `ResponseBuilder::insert_header` method which allows using typed headers. [#1869]

actix-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "3.0.0-beta.2"
+version = "3.0.0-beta.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "HTTP primitives for the Actix ecosystem"
 readme = "README.md"
@@ -15,7 +15,8 @@ license = "MIT OR Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
-features = ["openssl", "rustls", "compress", "secure-cookies", "actors"]
+# features that docs.rs will build with
+features = ["openssl", "rustls", "compress", "cookies", "secure-cookies"]
 
 [lib]
 name = "actix_http"
@@ -30,11 +31,14 @@ openssl = ["actix-tls/openssl"]
 # rustls support
 rustls = ["actix-tls/rustls"]
 
-# enable compressison support
+# enable compression support
 compress = ["flate2", "brotli2"]
 
+# support for cookies
+cookies = ["cookie"]
+
 # support for secure cookies
-secure-cookies = ["cookie/secure"]
+secure-cookies = ["cookies", "cookie/secure"]
 
 # trust-dns as client dns resolver
 trust-dns = ["trust-dns-resolver"]
@@ -43,27 +47,26 @@ trust-dns = ["trust-dns-resolver"]
 actix-service = "2.0.0-beta.4"
 actix-codec = "0.4.0-beta.1"
 actix-utils = "3.0.0-beta.2"
-actix-rt = "2"
+actix-rt = "2.1"
-actix-tls = "3.0.0-beta.2"
+actix-tls = "3.0.0-beta.4"
 
+ahash = "0.7"
 base64 = "0.13"
 bitflags = "1.2"
 bytes = "1"
 bytestring = "1"
-cookie = { version = "0.14.1", features = ["percent-encode"] }
+cfg-if = "1"
+cookie = { version = "0.14.1", features = ["percent-encode"], optional = true }
 derive_more = "0.99.5"
 encoding_rs = "0.8"
-futures-channel = { version = "0.3.7", default-features = false, features = ["alloc"] }
 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
 futures-util = { version = "0.3.7", default-features = false, features = ["alloc", "sink"] }
-ahash = "0.7"
+h2 = "0.3.1"
-h2 = "0.3.0"
 http = "0.2.2"
 httparse = "1.3"
-indexmap = "1.3"
 itoa = "0.4"
-lazy_static = "1.4"
 language-tags = "0.2"
+once_cell = "1.5"
 log = "0.4"
 mime = "0.3"
 percent-encoding = "2.1"
@@ -72,11 +75,11 @@ rand = "0.8"
 regex = "1.3"
 serde = "1.0"
 serde_json = "1.0"
+serde_urlencoded = "0.7"
 sha-1 = "0.9"
 smallvec = "1.6"
-slab = "0.4"
-serde_urlencoded = "0.7"
 time = { version = "0.2.23", default-features = false, features = ["std"] }
+tokio = { version = "1.2", features = ["sync"] }
 
 # compression
 brotli2 = { version="0.3.2", optional = true }
@@ -86,14 +89,24 @@ trust-dns-resolver = { version = "0.20.0", optional = true }
 
 [dev-dependencies]
 actix-server = "2.0.0-beta.3"
-actix-http-test = { version = "3.0.0-beta.2", features = ["openssl"] }
+actix-http-test = { version = "3.0.0-beta.3", features = ["openssl"] }
-actix-tls = { version = "3.0.0-beta.2", features = ["openssl"] }
+actix-tls = { version = "3.0.0-beta.4", features = ["openssl"] }
 criterion = "0.3"
 env_logger = "0.8"
+rcgen = "0.8"
 serde_derive = "1.0"
 tls-openssl = { version = "0.10", package = "openssl" }
 tls-rustls = { version = "0.19", package = "rustls" }
 
+[target.'cfg(windows)'.dev-dependencies.tls-openssl]
+version = "0.10.9"
+package = "openssl"
+features = ["vendored"]
+
+[[example]]
+name = "ws"
+required-features = ["rustls"]
+
 [[bench]]
 name = "write-camel-case"
 harness = false

actix-http/README.md

@@ -3,11 +3,11 @@
 > HTTP primitives for the Actix ecosystem.
 
 [![crates.io](https://img.shields.io/crates/v/actix-http?label=latest)](https://crates.io/crates/actix-http)
-[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.2)](https://docs.rs/actix-http/3.0.0-beta.2)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.4)](https://docs.rs/actix-http/3.0.0-beta.4)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.2/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.2)
+[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.4/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.4)
 [![Download](https://img.shields.io/crates/d/actix-http.svg)](https://crates.io/crates/actix-http)
 [![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)
 

actix-http/examples/ws.rs

@@ -0,0 +1,107 @@
+//! Sets up a WebSocket server over TCP and TLS.
+//! Sends a heartbeat message every 4 seconds but does not respond to any incoming frames.
+
+extern crate tls_rustls as rustls;
+
+use std::{
+    env, io,
+    pin::Pin,
+    task::{Context, Poll},
+    time::Duration,
+};
+
+use actix_codec::Encoder;
+use actix_http::{error::Error, ws, HttpService, Request, Response};
+use actix_rt::time::{interval, Interval};
+use actix_server::Server;
+use bytes::{Bytes, BytesMut};
+use bytestring::ByteString;
+use futures_core::{ready, Stream};
+
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
+    env::set_var("RUST_LOG", "actix=info,h2_ws=info");
+    env_logger::init();
+
+    Server::build()
+        .bind("tcp", ("127.0.0.1", 8080), || {
+            HttpService::build().h1(handler).tcp()
+        })?
+        .bind("tls", ("127.0.0.1", 8443), || {
+            HttpService::build().finish(handler).rustls(tls_config())
+        })?
+        .run()
+        .await
+}
+
+async fn handler(req: Request) -> Result<Response, Error> {
+    log::info!("handshaking");
+    let mut res = ws::handshake(req.head())?;
+
+    // handshake will always fail under HTTP/2
+
+    log::info!("responding");
+    Ok(res.streaming(Heartbeat::new(ws::Codec::new())))
+}
+
+struct Heartbeat {
+    codec: ws::Codec,
+    interval: Interval,
+}
+
+impl Heartbeat {
+    fn new(codec: ws::Codec) -> Self {
+        Self {
+            codec,
+            interval: interval(Duration::from_secs(4)),
+        }
+    }
+}
+
+impl Stream for Heartbeat {
+    type Item = Result<Bytes, Error>;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        log::trace!("poll");
+
+        ready!(self.as_mut().interval.poll_tick(cx));
+
+        let mut buffer = BytesMut::new();
+
+        self.as_mut()
+            .codec
+            .encode(
+                ws::Message::Text(ByteString::from_static("hello world")),
+                &mut buffer,
+            )
+            .unwrap();
+
+        Poll::Ready(Some(Ok(buffer.freeze())))
+    }
+}
+
+fn tls_config() -> rustls::ServerConfig {
+    use std::io::BufReader;
+
+    use rustls::{
+        internal::pemfile::{certs, pkcs8_private_keys},
+        NoClientAuth, ServerConfig,
+    };
+
+    let cert = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();
+    let cert_file = cert.serialize_pem().unwrap();
+    let key_file = cert.serialize_private_key_pem();
+
+    let mut config = ServerConfig::new(NoClientAuth::new());
+    let cert_file = &mut BufReader::new(cert_file.as_bytes());
+    let key_file = &mut BufReader::new(key_file.as_bytes());
+
+    let cert_chain = certs(cert_file).unwrap();
+    let mut keys = pkcs8_private_keys(key_file).unwrap();
+    config.set_single_cert(cert_chain, keys.remove(0)).unwrap();
+
+    config
+}

actix-http/src/body.rs

@@ -1,710 +0,0 @@
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{fmt, mem};
-
-use bytes::{Bytes, BytesMut};
-use futures_core::{ready, Stream};
-use pin_project::pin_project;
-
-use crate::error::Error;
-
-#[derive(Debug, PartialEq, Copy, Clone)]
-/// Body size hint
-pub enum BodySize {
-    None,
-    Empty,
-    Sized(u64),
-    Stream,
-}
-
-impl BodySize {
-    pub fn is_eof(&self) -> bool {
-        matches!(self, BodySize::None | BodySize::Empty | BodySize::Sized(0))
-    }
-}
-
-/// Type that provides this trait can be streamed to a peer.
-pub trait MessageBody {
-    fn size(&self) -> BodySize;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>>;
-
-    downcast_get_type_id!();
-}
-
-downcast!(MessageBody);
-
-impl MessageBody for () {
-    fn size(&self) -> BodySize {
-        BodySize::Empty
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        Poll::Ready(None)
-    }
-}
-
-impl<T: MessageBody + Unpin> MessageBody for Box<T> {
-    fn size(&self) -> BodySize {
-        self.as_ref().size()
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        Pin::new(self.get_mut().as_mut()).poll_next(cx)
-    }
-}
-
-#[pin_project(project = ResponseBodyProj)]
-pub enum ResponseBody<B> {
-    Body(#[pin] B),
-    Other(Body),
-}
-
-impl ResponseBody<Body> {
-    pub fn into_body<B>(self) -> ResponseBody<B> {
-        match self {
-            ResponseBody::Body(b) => ResponseBody::Other(b),
-            ResponseBody::Other(b) => ResponseBody::Other(b),
-        }
-    }
-}
-
-impl<B> ResponseBody<B> {
-    pub fn take_body(&mut self) -> ResponseBody<B> {
-        std::mem::replace(self, ResponseBody::Other(Body::None))
-    }
-}
-
-impl<B: MessageBody> ResponseBody<B> {
-    pub fn as_ref(&self) -> Option<&B> {
-        if let ResponseBody::Body(ref b) = self {
-            Some(b)
-        } else {
-            None
-        }
-    }
-}
-
-impl<B: MessageBody> MessageBody for ResponseBody<B> {
-    fn size(&self) -> BodySize {
-        match self {
-            ResponseBody::Body(ref body) => body.size(),
-            ResponseBody::Other(ref body) => body.size(),
-        }
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        match self.project() {
-            ResponseBodyProj::Body(body) => body.poll_next(cx),
-            ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
-        }
-    }
-}
-
-impl<B: MessageBody> Stream for ResponseBody<B> {
-    type Item = Result<Bytes, Error>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        match self.project() {
-            ResponseBodyProj::Body(body) => body.poll_next(cx),
-            ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
-        }
-    }
-}
-
-/// Represents various types of http message body.
-pub enum Body {
-    /// Empty response. `Content-Length` header is not set.
-    None,
-    /// Zero sized response body. `Content-Length` header is set to `0`.
-    Empty,
-    /// Specific response body.
-    Bytes(Bytes),
-    /// Generic message body.
-    Message(Box<dyn MessageBody + Unpin>),
-}
-
-impl Body {
-    /// Create body from slice (copy)
-    pub fn from_slice(s: &[u8]) -> Body {
-        Body::Bytes(Bytes::copy_from_slice(s))
-    }
-
-    /// Create body from generic message body.
-    pub fn from_message<B: MessageBody + Unpin + 'static>(body: B) -> Body {
-        Body::Message(Box::new(body))
-    }
-}
-
-impl MessageBody for Body {
-    fn size(&self) -> BodySize {
-        match self {
-            Body::None => BodySize::None,
-            Body::Empty => BodySize::Empty,
-            Body::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
-            Body::Message(ref body) => body.size(),
-        }
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        match self.get_mut() {
-            Body::None => Poll::Ready(None),
-            Body::Empty => Poll::Ready(None),
-            Body::Bytes(ref mut bin) => {
-                let len = bin.len();
-                if len == 0 {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(mem::take(bin))))
-                }
-            }
-            Body::Message(body) => Pin::new(&mut **body).poll_next(cx),
-        }
-    }
-}
-
-impl PartialEq for Body {
-    fn eq(&self, other: &Body) -> bool {
-        match *self {
-            Body::None => matches!(*other, Body::None),
-            Body::Empty => matches!(*other, Body::Empty),
-            Body::Bytes(ref b) => match *other {
-                Body::Bytes(ref b2) => b == b2,
-                _ => false,
-            },
-            Body::Message(_) => false,
-        }
-    }
-}
-
-impl fmt::Debug for Body {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            Body::None => write!(f, "Body::None"),
-            Body::Empty => write!(f, "Body::Empty"),
-            Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),
-            Body::Message(_) => write!(f, "Body::Message(_)"),
-        }
-    }
-}
-
-impl From<&'static str> for Body {
-    fn from(s: &'static str) -> Body {
-        Body::Bytes(Bytes::from_static(s.as_ref()))
-    }
-}
-
-impl From<&'static [u8]> for Body {
-    fn from(s: &'static [u8]) -> Body {
-        Body::Bytes(Bytes::from_static(s))
-    }
-}
-
-impl From<Vec<u8>> for Body {
-    fn from(vec: Vec<u8>) -> Body {
-        Body::Bytes(Bytes::from(vec))
-    }
-}
-
-impl From<String> for Body {
-    fn from(s: String) -> Body {
-        s.into_bytes().into()
-    }
-}
-
-impl<'a> From<&'a String> for Body {
-    fn from(s: &'a String) -> Body {
-        Body::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
-    }
-}
-
-impl From<Bytes> for Body {
-    fn from(s: Bytes) -> Body {
-        Body::Bytes(s)
-    }
-}
-
-impl From<BytesMut> for Body {
-    fn from(s: BytesMut) -> Body {
-        Body::Bytes(s.freeze())
-    }
-}
-
-impl From<serde_json::Value> for Body {
-    fn from(v: serde_json::Value) -> Body {
-        Body::Bytes(v.to_string().into())
-    }
-}
-
-impl<S> From<SizedStream<S>> for Body
-where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin + 'static,
-{
-    fn from(s: SizedStream<S>) -> Body {
-        Body::from_message(s)
-    }
-}
-
-impl<S, E> From<BodyStream<S>> for Body
-where
-    S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-    E: Into<Error> + 'static,
-{
-    fn from(s: BodyStream<S>) -> Body {
-        Body::from_message(s)
-    }
-}
-
-impl MessageBody for Bytes {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
-        }
-    }
-}
-
-impl MessageBody for BytesMut {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
-        }
-    }
-}
-
-impl MessageBody for &'static str {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from_static(
-                mem::take(self.get_mut()).as_ref(),
-            ))))
-        }
-    }
-}
-
-impl MessageBody for Vec<u8> {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
-        }
-    }
-}
-
-impl MessageBody for String {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from(
-                mem::take(self.get_mut()).into_bytes(),
-            ))))
-        }
-    }
-}
-
-/// Type represent streaming body.
-/// Response does not contain `content-length` header and appropriate transfer encoding is used.
-pub struct BodyStream<S: Unpin> {
-    stream: S,
-}
-
-impl<S, E> BodyStream<S>
-where
-    S: Stream<Item = Result<Bytes, E>> + Unpin,
-    E: Into<Error>,
-{
-    pub fn new(stream: S) -> Self {
-        BodyStream { stream }
-    }
-}
-
-impl<S, E> MessageBody for BodyStream<S>
-where
-    S: Stream<Item = Result<Bytes, E>> + Unpin,
-    E: Into<Error>,
-{
-    fn size(&self) -> BodySize {
-        BodySize::Stream
-    }
-
-    /// Attempts to pull out the next value of the underlying [`Stream`].
-    ///
-    /// Empty values are skipped to prevent [`BodyStream`]'s transmission being
-    /// ended on a zero-length chunk, but rather proceed until the underlying
-    /// [`Stream`] ends.
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        loop {
-            let stream = &mut self.as_mut().stream;
-            return Poll::Ready(match ready!(Pin::new(stream).poll_next(cx)) {
-                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
-                opt => opt.map(|res| res.map_err(Into::into)),
-            });
-        }
-    }
-}
-
-/// Type represent streaming body. This body implementation should be used
-/// if total size of stream is known. Data get sent as is without using transfer encoding.
-pub struct SizedStream<S: Unpin> {
-    size: u64,
-    stream: S,
-}
-
-impl<S> SizedStream<S>
-where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin,
-{
-    pub fn new(size: u64, stream: S) -> Self {
-        SizedStream { size, stream }
-    }
-}
-
-impl<S> MessageBody for SizedStream<S>
-where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin,
-{
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.size as u64)
-    }
-
-    /// Attempts to pull out the next value of the underlying [`Stream`].
-    ///
-    /// Empty values are skipped to prevent [`SizedStream`]'s transmission being
-    /// ended on a zero-length chunk, but rather proceed until the underlying
-    /// [`Stream`] ends.
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        loop {
-            let stream = &mut self.as_mut().stream;
-            return Poll::Ready(match ready!(Pin::new(stream).poll_next(cx)) {
-                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
-                val => val,
-            });
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use futures_util::future::poll_fn;
-    use futures_util::pin_mut;
-    use futures_util::stream;
-
-    impl Body {
-        pub(crate) fn get_ref(&self) -> &[u8] {
-            match *self {
-                Body::Bytes(ref bin) => &bin,
-                _ => panic!(),
-            }
-        }
-    }
-
-    impl ResponseBody<Body> {
-        pub(crate) fn get_ref(&self) -> &[u8] {
-            match *self {
-                ResponseBody::Body(ref b) => b.get_ref(),
-                ResponseBody::Other(ref b) => b.get_ref(),
-            }
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_static_str() {
-        assert_eq!(Body::from("").size(), BodySize::Sized(0));
-        assert_eq!(Body::from("test").size(), BodySize::Sized(4));
-        assert_eq!(Body::from("test").get_ref(), b"test");
-
-        assert_eq!("test".size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_static_bytes() {
-        assert_eq!(Body::from(b"test".as_ref()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
-        assert_eq!(
-            Body::from_slice(b"test".as_ref()).size(),
-            BodySize::Sized(4)
-        );
-        assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
-        let sb = Bytes::from(&b"test"[..]);
-        pin_mut!(sb);
-
-        assert_eq!(sb.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_vec() {
-        assert_eq!(Body::from(Vec::from("test")).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
-        let test_vec = Vec::from("test");
-        pin_mut!(test_vec);
-
-        assert_eq!(test_vec.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| test_vec.as_mut().poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_bytes() {
-        let b = Bytes::from("test");
-        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-        pin_mut!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_bytes_mut() {
-        let b = BytesMut::from("test");
-        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-        pin_mut!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_string() {
-        let b = "test".to_owned();
-        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-        assert_eq!(Body::from(&b).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(&b).get_ref(), b"test");
-        pin_mut!(b);
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
-        );
-    }
-
-    #[actix_rt::test]
-    async fn test_unit() {
-        assert_eq!(().size(), BodySize::Empty);
-        assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
-            .await
-            .is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_box() {
-        let val = Box::new(());
-        pin_mut!(val);
-        assert_eq!(val.size(), BodySize::Empty);
-        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
-    }
-
-    #[actix_rt::test]
-    async fn test_body_eq() {
-        assert!(
-            Body::Bytes(Bytes::from_static(b"1"))
-                == Body::Bytes(Bytes::from_static(b"1"))
-        );
-        assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
-    }
-
-    #[actix_rt::test]
-    async fn test_body_debug() {
-        assert!(format!("{:?}", Body::None).contains("Body::None"));
-        assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
-        assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains('1'));
-    }
-
-    #[actix_rt::test]
-    async fn test_serde_json() {
-        use serde_json::json;
-        assert_eq!(
-            Body::from(serde_json::Value::String("test".into())).size(),
-            BodySize::Sized(6)
-        );
-        assert_eq!(
-            Body::from(json!({"test-key":"test-value"})).size(),
-            BodySize::Sized(25)
-        );
-    }
-
-    mod body_stream {
-        use super::*;
-        //use futures::task::noop_waker;
-        //use futures::stream::once;
-
-        #[actix_rt::test]
-        async fn skips_empty_chunks() {
-            let body = BodyStream::new(stream::iter(
-                ["1", "", "2"]
-                    .iter()
-                    .map(|&v| Ok(Bytes::from(v)) as Result<Bytes, ()>),
-            ));
-            pin_mut!(body);
-
-            assert_eq!(
-                poll_fn(|cx| body.as_mut().poll_next(cx))
-                    .await
-                    .unwrap()
-                    .ok(),
-                Some(Bytes::from("1")),
-            );
-            assert_eq!(
-                poll_fn(|cx| body.as_mut().poll_next(cx))
-                    .await
-                    .unwrap()
-                    .ok(),
-                Some(Bytes::from("2")),
-            );
-        }
-
-        /* Now it does not compile as it should
-        #[actix_rt::test]
-        async fn move_pinned_pointer() {
-            let (sender, receiver) = futures::channel::oneshot::channel();
-            let mut body_stream = Ok(BodyStream::new(once(async {
-                let x = Box::new(0i32);
-                let y = &x;
-                receiver.await.unwrap();
-                let _z = **y;
-                Ok::<_, ()>(Bytes::new())
-            })));
-
-            let waker = noop_waker();
-            let mut context = Context::from_waker(&waker);
-            pin_mut!(body_stream);
-
-            let _ = body_stream.as_mut().unwrap().poll_next(&mut context);
-            sender.send(()).unwrap();
-            let _ = std::mem::replace(&mut body_stream, Err([0; 32])).unwrap().poll_next(&mut context);
-        }*/
-    }
-
-    mod sized_stream {
-        use super::*;
-
-        #[actix_rt::test]
-        async fn skips_empty_chunks() {
-            let body = SizedStream::new(
-                2,
-                stream::iter(["1", "", "2"].iter().map(|&v| Ok(Bytes::from(v)))),
-            );
-            pin_mut!(body);
-            assert_eq!(
-                poll_fn(|cx| body.as_mut().poll_next(cx))
-                    .await
-                    .unwrap()
-                    .ok(),
-                Some(Bytes::from("1")),
-            );
-            assert_eq!(
-                poll_fn(|cx| body.as_mut().poll_next(cx))
-                    .await
-                    .unwrap()
-                    .ok(),
-                Some(Bytes::from("2")),
-            );
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_body_casting() {
-        let mut body = String::from("hello cast");
-        let resp_body: &mut dyn MessageBody = &mut body;
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast");
-        let body = &mut resp_body.downcast_mut::<String>().unwrap();
-        body.push('!');
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast!");
-        let not_body = resp_body.downcast_ref::<()>();
-        assert!(not_body.is_none());
-    }
-}

actix-http/src/body/body.rs

@@ -0,0 +1,158 @@
+use std::{
+    fmt, mem,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::{Bytes, BytesMut};
+use futures_core::Stream;
+
+use crate::error::Error;
+
+use super::{BodySize, BodyStream, MessageBody, SizedStream};
+
+/// Represents various types of HTTP message body.
+pub enum Body {
+    /// Empty response. `Content-Length` header is not set.
+    None,
+    /// Zero sized response body. `Content-Length` header is set to `0`.
+    Empty,
+    /// Specific response body.
+    Bytes(Bytes),
+    /// Generic message body.
+    Message(Box<dyn MessageBody + Unpin>),
+}
+
+impl Body {
+    /// Create body from slice (copy)
+    pub fn from_slice(s: &[u8]) -> Body {
+        Body::Bytes(Bytes::copy_from_slice(s))
+    }
+
+    /// Create body from generic message body.
+    pub fn from_message<B: MessageBody + Unpin + 'static>(body: B) -> Body {
+        Body::Message(Box::new(body))
+    }
+}
+
+impl MessageBody for Body {
+    fn size(&self) -> BodySize {
+        match self {
+            Body::None => BodySize::None,
+            Body::Empty => BodySize::Empty,
+            Body::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
+            Body::Message(ref body) => body.size(),
+        }
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        match self.get_mut() {
+            Body::None => Poll::Ready(None),
+            Body::Empty => Poll::Ready(None),
+            Body::Bytes(ref mut bin) => {
+                let len = bin.len();
+                if len == 0 {
+                    Poll::Ready(None)
+                } else {
+                    Poll::Ready(Some(Ok(mem::take(bin))))
+                }
+            }
+            Body::Message(body) => Pin::new(&mut **body).poll_next(cx),
+        }
+    }
+}
+
+impl PartialEq for Body {
+    fn eq(&self, other: &Body) -> bool {
+        match *self {
+            Body::None => matches!(*other, Body::None),
+            Body::Empty => matches!(*other, Body::Empty),
+            Body::Bytes(ref b) => match *other {
+                Body::Bytes(ref b2) => b == b2,
+                _ => false,
+            },
+            Body::Message(_) => false,
+        }
+    }
+}
+
+impl fmt::Debug for Body {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Body::None => write!(f, "Body::None"),
+            Body::Empty => write!(f, "Body::Empty"),
+            Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),
+            Body::Message(_) => write!(f, "Body::Message(_)"),
+        }
+    }
+}
+
+impl From<&'static str> for Body {
+    fn from(s: &'static str) -> Body {
+        Body::Bytes(Bytes::from_static(s.as_ref()))
+    }
+}
+
+impl From<&'static [u8]> for Body {
+    fn from(s: &'static [u8]) -> Body {
+        Body::Bytes(Bytes::from_static(s))
+    }
+}
+
+impl From<Vec<u8>> for Body {
+    fn from(vec: Vec<u8>) -> Body {
+        Body::Bytes(Bytes::from(vec))
+    }
+}
+
+impl From<String> for Body {
+    fn from(s: String) -> Body {
+        s.into_bytes().into()
+    }
+}
+
+impl<'a> From<&'a String> for Body {
+    fn from(s: &'a String) -> Body {
+        Body::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
+    }
+}
+
+impl From<Bytes> for Body {
+    fn from(s: Bytes) -> Body {
+        Body::Bytes(s)
+    }
+}
+
+impl From<BytesMut> for Body {
+    fn from(s: BytesMut) -> Body {
+        Body::Bytes(s.freeze())
+    }
+}
+
+impl From<serde_json::Value> for Body {
+    fn from(v: serde_json::Value) -> Body {
+        Body::Bytes(v.to_string().into())
+    }
+}
+
+impl<S> From<SizedStream<S>> for Body
+where
+    S: Stream<Item = Result<Bytes, Error>> + Unpin + 'static,
+{
+    fn from(s: SizedStream<S>) -> Body {
+        Body::from_message(s)
+    }
+}
+
+impl<S, E> From<BodyStream<S>> for Body
+where
+    S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
+    E: Into<Error> + 'static,
+{
+    fn from(s: BodyStream<S>) -> Body {
+        Body::from_message(s)
+    }
+}

actix-http/src/body/body_stream.rs

@@ -0,0 +1,59 @@
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use futures_core::{ready, Stream};
+
+use crate::error::Error;
+
+use super::{BodySize, MessageBody};
+
+/// Streaming response wrapper.
+///
+/// Response does not contain `Content-Length` header and appropriate transfer encoding is used.
+pub struct BodyStream<S: Unpin> {
+    stream: S,
+}
+
+impl<S, E> BodyStream<S>
+where
+    S: Stream<Item = Result<Bytes, E>> + Unpin,
+    E: Into<Error>,
+{
+    pub fn new(stream: S) -> Self {
+        BodyStream { stream }
+    }
+}
+
+impl<S, E> MessageBody for BodyStream<S>
+where
+    S: Stream<Item = Result<Bytes, E>> + Unpin,
+    E: Into<Error>,
+{
+    fn size(&self) -> BodySize {
+        BodySize::Stream
+    }
+
+    /// Attempts to pull out the next value of the underlying [`Stream`].
+    ///
+    /// Empty values are skipped to prevent [`BodyStream`]'s transmission being
+    /// ended on a zero-length chunk, but rather proceed until the underlying
+    /// [`Stream`] ends.
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        loop {
+            let stream = &mut self.as_mut().stream;
+
+            let chunk = match ready!(Pin::new(stream).poll_next(cx)) {
+                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
+                opt => opt.map(|res| res.map_err(Into::into)),
+            };
+
+            return Poll::Ready(chunk);
+        }
+    }
+}

actix-http/src/body/message_body.rs

@@ -0,0 +1,142 @@
+//! [`MessageBody`] trait and foreign implementations.
+
+use std::{
+    mem,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::{Bytes, BytesMut};
+
+use crate::error::Error;
+
+use super::BodySize;
+
+/// Type that implement this trait can be streamed to a peer.
+pub trait MessageBody {
+    fn size(&self) -> BodySize;
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>>;
+
+    downcast_get_type_id!();
+}
+
+downcast!(MessageBody);
+
+impl MessageBody for () {
+    fn size(&self) -> BodySize {
+        BodySize::Empty
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        Poll::Ready(None)
+    }
+}
+
+impl<T: MessageBody + Unpin> MessageBody for Box<T> {
+    fn size(&self) -> BodySize {
+        self.as_ref().size()
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        Pin::new(self.get_mut().as_mut()).poll_next(cx)
+    }
+}
+
+impl MessageBody for Bytes {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
+        }
+    }
+}
+
+impl MessageBody for BytesMut {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
+        }
+    }
+}
+
+impl MessageBody for &'static str {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(Bytes::from_static(
+                mem::take(self.get_mut()).as_ref(),
+            ))))
+        }
+    }
+}
+
+impl MessageBody for Vec<u8> {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
+        }
+    }
+}
+
+impl MessageBody for String {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len() as u64)
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(Bytes::from(
+                mem::take(self.get_mut()).into_bytes(),
+            ))))
+        }
+    }
+}

actix-http/src/body/mod.rs

@@ -0,0 +1,252 @@
+//! Traits and structures to aid consuming and writing HTTP payloads.
+
+#[allow(clippy::module_inception)]
+mod body;
+mod body_stream;
+mod message_body;
+mod response_body;
+mod size;
+mod sized_stream;
+
+pub use self::body::Body;
+pub use self::body_stream::BodyStream;
+pub use self::message_body::MessageBody;
+pub use self::response_body::ResponseBody;
+pub use self::size::BodySize;
+pub use self::sized_stream::SizedStream;
+
+#[cfg(test)]
+mod tests {
+    use std::pin::Pin;
+
+    use actix_rt::pin;
+    use bytes::{Bytes, BytesMut};
+    use futures_util::{future::poll_fn, stream};
+
+    use super::*;
+
+    impl Body {
+        pub(crate) fn get_ref(&self) -> &[u8] {
+            match *self {
+                Body::Bytes(ref bin) => &bin,
+                _ => panic!(),
+            }
+        }
+    }
+
+    impl ResponseBody<Body> {
+        pub(crate) fn get_ref(&self) -> &[u8] {
+            match *self {
+                ResponseBody::Body(ref b) => b.get_ref(),
+                ResponseBody::Other(ref b) => b.get_ref(),
+            }
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_static_str() {
+        assert_eq!(Body::from("").size(), BodySize::Sized(0));
+        assert_eq!(Body::from("test").size(), BodySize::Sized(4));
+        assert_eq!(Body::from("test").get_ref(), b"test");
+
+        assert_eq!("test".size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
+                .await
+                .unwrap()
+                .ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_static_bytes() {
+        assert_eq!(Body::from(b"test".as_ref()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
+        assert_eq!(
+            Body::from_slice(b"test".as_ref()).size(),
+            BodySize::Sized(4)
+        );
+        assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
+        let sb = Bytes::from(&b"test"[..]);
+        pin!(sb);
+
+        assert_eq!(sb.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_vec() {
+        assert_eq!(Body::from(Vec::from("test")).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
+        let test_vec = Vec::from("test");
+        pin!(test_vec);
+
+        assert_eq!(test_vec.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| test_vec.as_mut().poll_next(cx))
+                .await
+                .unwrap()
+                .ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_bytes() {
+        let b = Bytes::from("test");
+        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+        pin!(b);
+
+        assert_eq!(b.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_bytes_mut() {
+        let b = BytesMut::from("test");
+        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+        pin!(b);
+
+        assert_eq!(b.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_string() {
+        let b = "test".to_owned();
+        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+        assert_eq!(Body::from(&b).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(&b).get_ref(), b"test");
+        pin!(b);
+
+        assert_eq!(b.size(), BodySize::Sized(4));
+        assert_eq!(
+            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
+            Some(Bytes::from("test"))
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_unit() {
+        assert_eq!(().size(), BodySize::Empty);
+        assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
+            .await
+            .is_none());
+    }
+
+    #[actix_rt::test]
+    async fn test_box() {
+        let val = Box::new(());
+        pin!(val);
+        assert_eq!(val.size(), BodySize::Empty);
+        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
+    }
+
+    #[actix_rt::test]
+    async fn test_body_eq() {
+        assert!(
+            Body::Bytes(Bytes::from_static(b"1"))
+                == Body::Bytes(Bytes::from_static(b"1"))
+        );
+        assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
+    }
+
+    #[actix_rt::test]
+    async fn test_body_debug() {
+        assert!(format!("{:?}", Body::None).contains("Body::None"));
+        assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
+        assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains('1'));
+    }
+
+    #[actix_rt::test]
+    async fn test_serde_json() {
+        use serde_json::json;
+        assert_eq!(
+            Body::from(serde_json::Value::String("test".into())).size(),
+            BodySize::Sized(6)
+        );
+        assert_eq!(
+            Body::from(json!({"test-key":"test-value"})).size(),
+            BodySize::Sized(25)
+        );
+    }
+
+    #[actix_rt::test]
+    async fn body_stream_skips_empty_chunks() {
+        let body = BodyStream::new(stream::iter(
+            ["1", "", "2"]
+                .iter()
+                .map(|&v| Ok(Bytes::from(v)) as Result<Bytes, ()>),
+        ));
+        pin!(body);
+
+        assert_eq!(
+            poll_fn(|cx| body.as_mut().poll_next(cx))
+                .await
+                .unwrap()
+                .ok(),
+            Some(Bytes::from("1")),
+        );
+        assert_eq!(
+            poll_fn(|cx| body.as_mut().poll_next(cx))
+                .await
+                .unwrap()
+                .ok(),
+            Some(Bytes::from("2")),
+        );
+    }
+
+    mod sized_stream {
+        use super::*;
+
+        #[actix_rt::test]
+        async fn skips_empty_chunks() {
+            let body = SizedStream::new(
+                2,
+                stream::iter(["1", "", "2"].iter().map(|&v| Ok(Bytes::from(v)))),
+            );
+            pin!(body);
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("1")),
+            );
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("2")),
+            );
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_body_casting() {
+        let mut body = String::from("hello cast");
+        let resp_body: &mut dyn MessageBody = &mut body;
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast");
+        let body = &mut resp_body.downcast_mut::<String>().unwrap();
+        body.push('!');
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast!");
+        let not_body = resp_body.downcast_ref::<()>();
+        assert!(not_body.is_none());
+    }
+}

actix-http/src/body/response_body.rs

@@ -0,0 +1,77 @@
+use std::{
+    mem,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use futures_core::Stream;
+use pin_project::pin_project;
+
+use crate::error::Error;
+
+use super::{Body, BodySize, MessageBody};
+
+#[pin_project(project = ResponseBodyProj)]
+pub enum ResponseBody<B> {
+    Body(#[pin] B),
+    Other(Body),
+}
+
+impl ResponseBody<Body> {
+    pub fn into_body<B>(self) -> ResponseBody<B> {
+        match self {
+            ResponseBody::Body(b) => ResponseBody::Other(b),
+            ResponseBody::Other(b) => ResponseBody::Other(b),
+        }
+    }
+}
+
+impl<B> ResponseBody<B> {
+    pub fn take_body(&mut self) -> ResponseBody<B> {
+        mem::replace(self, ResponseBody::Other(Body::None))
+    }
+}
+
+impl<B: MessageBody> ResponseBody<B> {
+    pub fn as_ref(&self) -> Option<&B> {
+        if let ResponseBody::Body(ref b) = self {
+            Some(b)
+        } else {
+            None
+        }
+    }
+}
+
+impl<B: MessageBody> MessageBody for ResponseBody<B> {
+    fn size(&self) -> BodySize {
+        match self {
+            ResponseBody::Body(ref body) => body.size(),
+            ResponseBody::Other(ref body) => body.size(),
+        }
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        match self.project() {
+            ResponseBodyProj::Body(body) => body.poll_next(cx),
+            ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
+        }
+    }
+}
+
+impl<B: MessageBody> Stream for ResponseBody<B> {
+    type Item = Result<Bytes, Error>;
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        match self.project() {
+            ResponseBodyProj::Body(body) => body.poll_next(cx),
+            ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
+        }
+    }
+}

actix-http/src/body/size.rs

@@ -0,0 +1,40 @@
+/// Body size hint.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum BodySize {
+    /// Absence of body can be assumed from method or status code.
+    ///
+    /// Will skip writing Content-Length header.
+    None,
+
+    /// Zero size body.
+    ///
+    /// Will write `Content-Length: 0` header.
+    Empty,
+
+    /// Known size body.
+    ///
+    /// Will write `Content-Length: N` header. `Sized(0)` is treated the same as `Empty`.
+    Sized(u64),
+
+    /// Unknown size body.
+    ///
+    /// Will not write Content-Length header. Can be used with chunked Transfer-Encoding.
+    Stream,
+}
+
+impl BodySize {
+    /// Returns true if size hint indicates no or empty body.
+    ///
+    /// ```
+    /// # use actix_http::body::BodySize;
+    /// assert!(BodySize::None.is_eof());
+    /// assert!(BodySize::Empty.is_eof());
+    /// assert!(BodySize::Sized(0).is_eof());
+    ///
+    /// assert!(!BodySize::Sized(64).is_eof());
+    /// assert!(!BodySize::Stream.is_eof());
+    /// ```
+    pub fn is_eof(&self) -> bool {
+        matches!(self, BodySize::None | BodySize::Empty | BodySize::Sized(0))
+    }
+}

actix-http/src/body/sized_stream.rs

@@ -0,0 +1,59 @@
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use futures_core::{ready, Stream};
+
+use crate::error::Error;
+
+use super::{BodySize, MessageBody};
+
+/// Known sized streaming response wrapper.
+///
+/// This body implementation should be used if total size of stream is known. Data get sent as is
+/// without using transfer encoding.
+pub struct SizedStream<S: Unpin> {
+    size: u64,
+    stream: S,
+}
+
+impl<S> SizedStream<S>
+where
+    S: Stream<Item = Result<Bytes, Error>> + Unpin,
+{
+    pub fn new(size: u64, stream: S) -> Self {
+        SizedStream { size, stream }
+    }
+}
+
+impl<S> MessageBody for SizedStream<S>
+where
+    S: Stream<Item = Result<Bytes, Error>> + Unpin,
+{
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.size as u64)
+    }
+
+    /// Attempts to pull out the next value of the underlying [`Stream`].
+    ///
+    /// Empty values are skipped to prevent [`SizedStream`]'s transmission being
+    /// ended on a zero-length chunk, but rather proceed until the underlying
+    /// [`Stream`] ends.
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        loop {
+            let stream = &mut self.as_mut().stream;
+
+            let chunk = match ready!(Pin::new(stream).poll_next(cx)) {
+                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
+                val => val,
+            };
+
+            return Poll::Ready(chunk);
+        }
+    }
+}

actix-http/src/client/config.rs

@@ -1,3 +1,4 @@
+use std::net::IpAddr;
 use std::time::Duration;
 
 const DEFAULT_H2_CONN_WINDOW: u32 = 1024 * 1024 * 2; // 2MB
@@ -13,6 +14,7 @@ pub(crate) struct ConnectorConfig {
     pub(crate) limit: usize,
     pub(crate) conn_window_size: u32,
     pub(crate) stream_window_size: u32,
+    pub(crate) local_address: Option<IpAddr>,
 }
 
 impl Default for ConnectorConfig {
@@ -25,6 +27,7 @@ impl Default for ConnectorConfig {
             limit: 100,
             conn_window_size: DEFAULT_H2_CONN_WINDOW,
             stream_window_size: DEFAULT_H2_STREAM_WINDOW,
+            local_address: None,
         }
     }
 }

actix-http/src/client/connection.rs

@@ -1,4 +1,3 @@
-use std::future::Future;
 use std::ops::{Deref, DerefMut};
 use std::pin::Pin;
 use std::task::{Context, Poll};
@@ -8,7 +7,6 @@ use actix_codec::{AsyncRead, AsyncWrite, Framed, ReadBuf};
 use actix_rt::task::JoinHandle;
 use bytes::Bytes;
 use futures_core::future::LocalBoxFuture;
-use futures_util::future::{err, Either, FutureExt, Ready};
 use h2::client::SendRequest;
 use pin_project::pin_project;
 
@@ -18,7 +16,7 @@ use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
 
 use super::error::SendRequestError;
-use super::pool::{Acquired, Protocol};
+use super::pool::Acquired;
 use super::{h1proto, h2proto};
 
 pub(crate) enum ConnectionType<Io> {
@@ -26,9 +24,10 @@ pub(crate) enum ConnectionType<Io> {
     H2(H2Connection),
 }
 
-// h2 connection has two parts: SendRequest and Connection.
+/// `H2Connection` has two parts: `SendRequest` and `Connection`.
-// Connection is spawned as async task on runtime and H2Connection would hold a handle for
+///
-// this task. So it can wake up and quit the task when SendRequest is dropped.
+/// `Connection` is spawned as an async task on runtime and `H2Connection` holds a handle for
+/// this task. Therefore, it can wake up and quit the task when SendRequest is dropped.
 pub(crate) struct H2Connection {
     handle: JoinHandle<()>,
     sender: SendRequest<Bytes>,
@@ -50,7 +49,7 @@ impl H2Connection {
     }
 }
 
-// wake up waker when drop
+// cancel spawned connection task on drop.
 impl Drop for H2Connection {
     fn drop(&mut self) {
         self.handle.abort();
@@ -74,23 +73,25 @@ impl DerefMut for H2Connection {
 
 pub trait Connection {
     type Io: AsyncRead + AsyncWrite + Unpin;
-    type Future: Future<Output = Result<(ResponseHead, Payload), SendRequestError>>;
-
-    fn protocol(&self) -> Protocol;
 
     /// Send request and body
-    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
+    fn send_request<B, H>(
         self,
         head: H,
         body: B,
-    ) -> Self::Future;
+    ) -> LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>
-
+    where
-    type TunnelFuture: Future<
+        B: MessageBody + 'static,
-        Output = Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
+        H: Into<RequestHeadType> + 'static;
-    >;
 
     /// Send request, returns Response and Framed
-    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture;
+    fn open_tunnel<H: Into<RequestHeadType> + 'static>(
+        self,
+        head: H,
+    ) -> LocalBoxFuture<
+        'static,
+        Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
+    >;
 }
 
 pub(crate) trait ConnectionLifetime: AsyncRead + AsyncWrite + 'static {
@@ -103,7 +104,10 @@ pub(crate) trait ConnectionLifetime: AsyncRead + AsyncWrite + 'static {
 
 #[doc(hidden)]
 /// HTTP client connection
-pub struct IoConnection<T> {
+pub struct IoConnection<T>
+where
+    T: AsyncWrite + Unpin + 'static,
+{
     io: Option<ConnectionType<T>>,
     created: time::Instant,
     pool: Option<Acquired<T>>,
@@ -111,7 +115,7 @@ pub struct IoConnection<T> {
 
 impl<T> fmt::Debug for IoConnection<T>
 where
-    T: fmt::Debug,
+    T: AsyncWrite + Unpin + fmt::Debug + 'static,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.io {
@@ -138,55 +142,36 @@ impl<T: AsyncRead + AsyncWrite + Unpin> IoConnection<T> {
     pub(crate) fn into_inner(self) -> (ConnectionType<T>, time::Instant) {
         (self.io.unwrap(), self.created)
     }
-}
 
-impl<T> Connection for IoConnection<T>
+    #[cfg(test)]
-where
+    pub(crate) fn into_parts(self) -> (ConnectionType<T>, time::Instant, Acquired<T>) {
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
+        (self.io.unwrap(), self.created, self.pool.unwrap())
-{
-    type Io = T;
-    type Future =
-        LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>;
-
-    fn protocol(&self) -> Protocol {
-        match self.io {
-            Some(ConnectionType::H1(_)) => Protocol::Http1,
-            Some(ConnectionType::H2(_)) => Protocol::Http2,
-            None => Protocol::Http1,
-        }
     }
 
-    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
+    async fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
         mut self,
         head: H,
         body: B,
-    ) -> Self::Future {
+    ) -> Result<(ResponseHead, Payload), SendRequestError> {
         match self.io.take().unwrap() {
             ConnectionType::H1(io) => {
                 h1proto::send_request(io, head.into(), body, self.created, self.pool)
-                    .boxed_local()
+                    .await
             }
             ConnectionType::H2(io) => {
                 h2proto::send_request(io, head.into(), body, self.created, self.pool)
-                    .boxed_local()
+                    .await
             }
         }
     }
 
-    type TunnelFuture = Either<
-        LocalBoxFuture<
-            'static,
-            Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
-        >,
-        Ready<Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>>,
-    >;
-
     /// Send request, returns Response and Framed
-    fn open_tunnel<H: Into<RequestHeadType>>(mut self, head: H) -> Self::TunnelFuture {
+    async fn open_tunnel<H: Into<RequestHeadType>>(
+        mut self,
+        head: H,
+    ) -> Result<(ResponseHead, Framed<T, ClientCodec>), SendRequestError> {
         match self.io.take().unwrap() {
-            ConnectionType::H1(io) => {
+            ConnectionType::H1(io) => h1proto::open_tunnel(io, head.into()).await,
-                Either::Left(h1proto::open_tunnel(io, head.into()).boxed_local())
-            }
             ConnectionType::H2(io) => {
                 if let Some(mut pool) = self.pool.take() {
                     pool.release(IoConnection::new(
@@ -195,65 +180,61 @@ where
                         None,
                     ));
                 }
-                Either::Right(err(SendRequestError::TunnelNotSupported))
+                Err(SendRequestError::TunnelNotSupported)
             }
         }
     }
 }
 
 #[allow(dead_code)]
-pub(crate) enum EitherConnection<A, B> {
+pub(crate) enum EitherIoConnection<A, B>
+where
+    A: AsyncRead + AsyncWrite + Unpin + 'static,
+    B: AsyncRead + AsyncWrite + Unpin + 'static,
+{
     A(IoConnection<A>),
     B(IoConnection<B>),
 }
 
-impl<A, B> Connection for EitherConnection<A, B>
+impl<A, B> Connection for EitherIoConnection<A, B>
 where
     A: AsyncRead + AsyncWrite + Unpin + 'static,
     B: AsyncRead + AsyncWrite + Unpin + 'static,
 {
     type Io = EitherIo<A, B>;
-    type Future =
-        LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>;
 
-    fn protocol(&self) -> Protocol {
+    fn send_request<RB, H>(
-        match self {
-            EitherConnection::A(con) => con.protocol(),
-            EitherConnection::B(con) => con.protocol(),
-        }
-    }
-
-    fn send_request<RB: MessageBody + 'static, H: Into<RequestHeadType>>(
         self,
         head: H,
         body: RB,
-    ) -> Self::Future {
+    ) -> LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>
+    where
+        RB: MessageBody + 'static,
+        H: Into<RequestHeadType> + 'static,
+    {
         match self {
-            EitherConnection::A(con) => con.send_request(head, body),
+            EitherIoConnection::A(con) => Box::pin(con.send_request(head, body)),
-            EitherConnection::B(con) => con.send_request(head, body),
+            EitherIoConnection::B(con) => Box::pin(con.send_request(head, body)),
         }
     }
 
-    type TunnelFuture = LocalBoxFuture<
+    /// Send request, returns Response and Framed
+    fn open_tunnel<H: Into<RequestHeadType> + 'static>(
+        self,
+        head: H,
+    ) -> LocalBoxFuture<
         'static,
         Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
-    >;
+    > {
-
-    /// Send request, returns Response and Framed
-    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture {
         match self {
-            EitherConnection::A(con) => con
+            EitherIoConnection::A(con) => Box::pin(async {
-                .open_tunnel(head)
+                let (head, framed) = con.open_tunnel(head).await?;
-                .map(|res| {
+                Ok((head, framed.into_map_io(EitherIo::A)))
-                    res.map(|(head, framed)| (head, framed.into_map_io(EitherIo::A)))
+            }),
-                })
+            EitherIoConnection::B(con) => Box::pin(async {
-                .boxed_local(),
+                let (head, framed) = con.open_tunnel(head).await?;
-            EitherConnection::B(con) => con
+                Ok((head, framed.into_map_io(EitherIo::B)))
-                .open_tunnel(head)
+            }),
-                .map(|res| {
-                    res.map(|(head, framed)| (head, framed.into_map_io(EitherIo::B)))
-                })
-                .boxed_local(),
         }
     }
 }

actix-http/src/client/connector.rs

@@ -1,6 +1,12 @@
-use std::fmt;
+use std::{
-use std::marker::PhantomData;
+    fmt,
-use std::time::Duration;
+    future::Future,
+    marker::PhantomData,
+    net::IpAddr,
+    pin::Pin,
+    task::{Context, Poll},
+    time::Duration,
+};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::net::TcpStream;
@@ -12,7 +18,7 @@ use actix_utils::timeout::{TimeoutError, TimeoutService};
 use http::Uri;
 
 use super::config::ConnectorConfig;
-use super::connection::Connection;
+use super::connection::{Connection, EitherIoConnection};
 use super::error::ConnectError;
 use super::pool::{ConnectionPool, Protocol};
 use super::Connect;
@@ -34,7 +40,8 @@ enum SslConnector {
 #[cfg(not(any(feature = "openssl", feature = "rustls")))]
 type SslConnector = ();
 
-/// Manages http client network connectivity
+/// Manages HTTP client network connectivity.
+///
 /// The `Connector` type uses a builder-like combinator pattern for service
 /// construction that finishes by calling the `.finish()` method.
 ///
@@ -54,7 +61,7 @@ pub struct Connector<T, U> {
     _phantom: PhantomData<U>,
 }
 
-trait Io: AsyncRead + AsyncWrite + Unpin {}
+pub trait Io: AsyncRead + AsyncWrite + Unpin {}
 impl<T: AsyncRead + AsyncWrite + Unpin> Io for T {}
 
 impl Connector<(), ()> {
@@ -160,8 +167,9 @@ where
         self
     }
 
-    /// Maximum supported http major version
+    /// Maximum supported HTTP major version.
-    /// Supported versions http/1.1, http/2
+    ///
+    /// Supported versions are HTTP/1.1 and 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()],
@@ -235,6 +243,12 @@ where
         self
     }
 
+    /// Set local IP Address the connector would use for establishing connection.
+    pub fn local_address(mut self, addr: IpAddr) -> Self {
+        self.config.local_address = Some(addr);
+        self
+    }
+
     /// Finish configuration process and create connector service.
     /// The Connector builder always concludes by calling `finish()` last in
     /// its combinator chain.
@@ -242,28 +256,52 @@ where
         self,
     ) -> impl Service<Connect, Response = impl Connection, Error = ConnectError> + Clone
     {
+        let local_address = self.config.local_address;
+        let timeout = self.config.timeout;
+
+        let tcp_service = TimeoutService::new(
+            timeout,
+            apply_fn(self.connector.clone(), move |msg: Connect, srv| {
+                let mut req = TcpConnect::new(msg.uri).set_addr(msg.addr);
+
+                if let Some(local_addr) = local_address {
+                    req = req.set_local_addr(local_addr);
+                }
+
+                srv.call(req)
+            })
+            .map_err(ConnectError::from)
+            .map(|stream| (stream.into_parts().0, Protocol::Http1)),
+        )
+        .map_err(|e| match e {
+            TimeoutError::Service(e) => e,
+            TimeoutError::Timeout => ConnectError::Timeout,
+        });
+
         #[cfg(not(any(feature = "openssl", feature = "rustls")))]
         {
-            let connector = TimeoutService::new(
+            // A dummy service for annotate tls pool's type signature.
-                self.config.timeout,
+            pub type DummyService = Box<
-                apply_fn(self.connector, |msg: Connect, srv| {
+                dyn Service<
-                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
+                    Connect,
-                })
+                    Response = (Box<dyn Io>, Protocol),
-                .map_err(ConnectError::from)
+                    Error = ConnectError,
-                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
+                    Future = futures_core::future::LocalBoxFuture<
-            )
+                        'static,
-            .map_err(|e| match e {
+                        Result<(Box<dyn Io>, Protocol), ConnectError>,
-                TimeoutError::Service(e) => e,
+                    >,
-                TimeoutError::Timeout => ConnectError::Timeout,
+                >,
-            });
+            >;
 
-            connect_impl::InnerConnector {
+            InnerConnector::<_, DummyService, _, Box<dyn Io>> {
                 tcp_pool: ConnectionPool::new(
-                    connector,
+                    tcp_service,
                     self.config.no_disconnect_timeout(),
                 ),
+                tls_pool: None,
             }
         }
+
         #[cfg(any(feature = "openssl", feature = "rustls"))]
         {
             const H2: &[u8] = b"h2";
@@ -274,10 +312,16 @@ where
             use actix_tls::connect::ssl::rustls::{RustlsConnector, Session};
 
             let ssl_service = TimeoutService::new(
-                self.config.timeout,
+                timeout,
                 pipeline(
-                    apply_fn(self.connector.clone(), |msg: Connect, srv| {
+                    apply_fn(self.connector.clone(), move |msg: Connect, srv| {
-                        srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
+                        let mut req = TcpConnect::new(msg.uri).set_addr(msg.addr);
+
+                        if let Some(local_addr) = local_address {
+                            req = req.set_local_addr(local_addr);
+                        }
+
+                        srv.call(req)
                     })
                     .map_err(ConnectError::from),
                 )
@@ -326,210 +370,100 @@ where
                 TimeoutError::Timeout => ConnectError::Timeout,
             });
 
-            let tcp_service = TimeoutService::new(
+            InnerConnector {
-                self.config.timeout,
-                apply_fn(self.connector, |msg: Connect, srv| {
-                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
-                })
-                .map_err(ConnectError::from)
-                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
-            )
-            .map_err(|e| match e {
-                TimeoutError::Service(e) => e,
-                TimeoutError::Timeout => ConnectError::Timeout,
-            });
-
-            connect_impl::InnerConnector {
                 tcp_pool: ConnectionPool::new(
                     tcp_service,
                     self.config.no_disconnect_timeout(),
                 ),
-                ssl_pool: ConnectionPool::new(ssl_service, self.config),
+                tls_pool: Some(ConnectionPool::new(ssl_service, self.config)),
             }
         }
     }
 }
 
-#[cfg(not(any(feature = "openssl", feature = "rustls")))]
+struct InnerConnector<S1, S2, Io1, Io2>
-mod connect_impl {
+where
-    use std::task::{Context, Poll};
+    S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
+    S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
+    Io1: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+{
+    tcp_pool: ConnectionPool<S1, Io1>,
+    tls_pool: Option<ConnectionPool<S2, Io2>>,
+}
 
-    use futures_util::future::{err, Either, Ready};
+impl<S1, S2, Io1, Io2> Clone for InnerConnector<S1, S2, Io1, Io2>
-
+where
-    use super::*;
+    S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
-    use crate::client::connection::IoConnection;
+    S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
-
+    Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-    pub(crate) struct InnerConnector<T, Io>
+    Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-    where
+{
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    fn clone(&self) -> Self {
-        T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
+        InnerConnector {
-    {
+            tcp_pool: self.tcp_pool.clone(),
-        pub(crate) tcp_pool: ConnectionPool<T, Io>,
+            tls_pool: self.tls_pool.as_ref().cloned(),
-    }
-
-    impl<T, Io> Clone for InnerConnector<T, Io>
-    where
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
-    {
-        fn clone(&self) -> Self {
-            InnerConnector {
-                tcp_pool: self.tcp_pool.clone(),
-            }
-        }
-    }
-
-    impl<T, Io> Service<Connect> for InnerConnector<T, Io>
-    where
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
-    {
-        type Response = IoConnection<Io>;
-        type Error = ConnectError;
-        type Future = Either<
-            <ConnectionPool<T, Io> as Service<Connect>>::Future,
-            Ready<Result<IoConnection<Io>, ConnectError>>,
-        >;
-
-        fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            self.tcp_pool.poll_ready(cx)
-        }
-
-        fn call(&self, req: Connect) -> Self::Future {
-            match req.uri.scheme_str() {
-                Some("https") | Some("wss") => {
-                    Either::Right(err(ConnectError::SslIsNotSupported))
-                }
-                _ => Either::Left(self.tcp_pool.call(req)),
-            }
         }
     }
 }
 
-#[cfg(any(feature = "openssl", feature = "rustls"))]
+impl<S1, S2, Io1, Io2> Service<Connect> for InnerConnector<S1, S2, Io1, Io2>
-mod connect_impl {
+where
-    use std::future::Future;
+    S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
-    use std::marker::PhantomData;
+    S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
-    use std::pin::Pin;
+    Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-    use std::task::{Context, Poll};
+    Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+{
+    type Response = EitherIoConnection<Io1, Io2>;
+    type Error = ConnectError;
+    type Future = InnerConnectorResponse<S1, S2, Io1, Io2>;
 
-    use futures_core::ready;
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-    use futures_util::future::Either;
+        self.tcp_pool.poll_ready(cx)
-
-    use super::*;
-    use crate::client::connection::EitherConnection;
-
-    pub(crate) struct InnerConnector<T1, T2, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError>,
-        T2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError>,
-    {
-        pub(crate) tcp_pool: ConnectionPool<T1, Io1>,
-        pub(crate) ssl_pool: ConnectionPool<T2, Io2>,
     }
 
-    impl<T1, T2, Io1, Io2> Clone for InnerConnector<T1, T2, Io1, Io2>
+    fn call(&self, req: Connect) -> Self::Future {
-    where
+        match req.uri.scheme_str() {
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
+            Some("https") | Some("wss") => match self.tls_pool {
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+                None => InnerConnectorResponse::SslIsNotSupported,
-        T1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
+                Some(ref pool) => InnerConnectorResponse::Io2(pool.call(req)),
-        T2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
+            },
-    {
+            _ => InnerConnectorResponse::Io1(self.tcp_pool.call(req)),
-        fn clone(&self) -> Self {
+        }
-            InnerConnector {
+    }
-                tcp_pool: self.tcp_pool.clone(),
+}
-                ssl_pool: self.ssl_pool.clone(),
+
+#[pin_project::pin_project(project = InnerConnectorProj)]
+enum InnerConnectorResponse<S1, S2, Io1, Io2>
+where
+    S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
+    S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
+    Io1: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+{
+    Io1(#[pin] <ConnectionPool<S1, Io1> as Service<Connect>>::Future),
+    Io2(#[pin] <ConnectionPool<S2, Io2> as Service<Connect>>::Future),
+    SslIsNotSupported,
+}
+
+impl<S1, S2, Io1, Io2> Future for InnerConnectorResponse<S1, S2, Io1, Io2>
+where
+    S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
+    S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
+    Io1: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+{
+    type Output = Result<EitherIoConnection<Io1, Io2>, ConnectError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.project() {
+            InnerConnectorProj::Io1(fut) => fut.poll(cx).map_ok(EitherIoConnection::A),
+            InnerConnectorProj::Io2(fut) => fut.poll(cx).map_ok(EitherIoConnection::B),
+            InnerConnectorProj::SslIsNotSupported => {
+                Poll::Ready(Err(ConnectError::SslIsNotSupported))
             }
         }
     }
-
-    impl<T1, T2, Io1, Io2> Service<Connect> for InnerConnector<T1, T2, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
-        T2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
-    {
-        type Response = EitherConnection<Io1, Io2>;
-        type Error = ConnectError;
-        type Future = Either<
-            InnerConnectorResponseA<T1, Io1, Io2>,
-            InnerConnectorResponseB<T2, Io1, Io2>,
-        >;
-
-        fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            self.tcp_pool.poll_ready(cx)
-        }
-
-        fn call(&self, req: Connect) -> Self::Future {
-            match req.uri.scheme_str() {
-                Some("https") | Some("wss") => Either::Right(InnerConnectorResponseB {
-                    fut: self.ssl_pool.call(req),
-                    _phantom: PhantomData,
-                }),
-                _ => Either::Left(InnerConnectorResponseA {
-                    fut: self.tcp_pool.call(req),
-                    _phantom: PhantomData,
-                }),
-            }
-        }
-    }
-
-    #[pin_project::pin_project]
-    pub(crate) struct InnerConnectorResponseA<T, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
-    {
-        #[pin]
-        fut: <ConnectionPool<T, Io1> as Service<Connect>>::Future,
-        _phantom: PhantomData<Io2>,
-    }
-
-    impl<T, Io1, Io2> Future for InnerConnectorResponseA<T, Io1, Io2>
-    where
-        T: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-    {
-        type Output = Result<EitherConnection<Io1, Io2>, ConnectError>;
-
-        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-            Poll::Ready(
-                ready!(Pin::new(&mut self.get_mut().fut).poll(cx))
-                    .map(EitherConnection::A),
-            )
-        }
-    }
-
-    #[pin_project::pin_project]
-    pub(crate) struct InnerConnectorResponseB<T, Io1, Io2>
-    where
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
-    {
-        #[pin]
-        fut: <ConnectionPool<T, Io2> as Service<Connect>>::Future,
-        _phantom: PhantomData<Io1>,
-    }
-
-    impl<T, Io1, Io2> Future for InnerConnectorResponseB<T, Io1, Io2>
-    where
-        T: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-    {
-        type Output = Result<EitherConnection<Io1, Io2>, ConnectError>;
-
-        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-            Poll::Ready(
-                ready!(Pin::new(&mut self.get_mut().fut).poll(cx))
-                    .map(EitherConnection::B),
-            )
-        }
-    }
 }
 
 #[cfg(not(feature = "trust-dns"))]

actix-http/src/client/error.rs

@@ -25,7 +25,7 @@ pub enum ConnectError {
     Resolver(Box<dyn std::error::Error>),
 
     /// No dns records
-    #[display(fmt = "No dns records found for the input")]
+    #[display(fmt = "No DNS records found for the input")]
     NoRecords,
 
     /// Http2 error
@@ -65,13 +65,16 @@ impl From<actix_tls::connect::ConnectError> for ConnectError {
 
 #[derive(Debug, Display, From)]
 pub enum InvalidUrl {
-    #[display(fmt = "Missing url scheme")]
+    #[display(fmt = "Missing URL scheme")]
     MissingScheme,
-    #[display(fmt = "Unknown url scheme")]
+
+    #[display(fmt = "Unknown URL scheme")]
     UnknownScheme,
+
     #[display(fmt = "Missing host name")]
     MissingHost,
-    #[display(fmt = "Url parse error: {}", _0)]
+
+    #[display(fmt = "URL parse error: {}", _0)]
     HttpError(http::Error),
 }
 
@@ -83,25 +86,33 @@ pub enum SendRequestError {
     /// Invalid URL
     #[display(fmt = "Invalid URL: {}", _0)]
     Url(InvalidUrl),
+
     /// Failed to connect to host
     #[display(fmt = "Failed to connect to host: {}", _0)]
     Connect(ConnectError),
+
     /// Error sending request
     Send(io::Error),
+
     /// Error parsing response
     Response(ParseError),
+
     /// Http error
     #[display(fmt = "{}", _0)]
     Http(HttpError),
+
     /// Http2 error
     #[display(fmt = "{}", _0)]
     H2(h2::Error),
+
     /// Response took too long
     #[display(fmt = "Timeout while waiting for response")]
     Timeout,
-    /// Tunnels are not supported for http2 connection
+
+    /// Tunnels are not supported for HTTP/2 connection
     #[display(fmt = "Tunnels are not supported for http2 connection")]
     TunnelNotSupported,
+
     /// Error sending request body
     Body(Error),
 }
@@ -127,7 +138,8 @@ pub enum FreezeRequestError {
     /// Invalid URL
     #[display(fmt = "Invalid URL: {}", _0)]
     Url(InvalidUrl),
-    /// Http error
+
+    /// HTTP error
     #[display(fmt = "{}", _0)]
     Http(HttpError),
 }

actix-http/src/client/h1proto.rs

@@ -7,13 +7,15 @@ use actix_codec::{AsyncRead, AsyncWrite, Framed, ReadBuf};
 use bytes::buf::BufMut;
 use bytes::{Bytes, BytesMut};
 use futures_core::Stream;
-use futures_util::future::poll_fn;
+use futures_util::{future::poll_fn, SinkExt, StreamExt};
-use futures_util::{pin_mut, SinkExt, StreamExt};
 
 use crate::error::PayloadError;
 use crate::h1;
 use crate::header::HeaderMap;
-use crate::http::header::{IntoHeaderValue, HOST};
+use crate::http::{
+    header::{IntoHeaderValue, EXPECT, HOST},
+    StatusCode,
+};
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::{Payload, PayloadStream};
 
@@ -66,33 +68,72 @@ where
         io: Some(io),
     };
 
-    // create Framed and send request
+    // create Framed and prepare sending request
-    let mut framed_inner = Framed::new(io, h1::ClientCodec::default());
+    let mut framed = Framed::new(io, h1::ClientCodec::default());
-    framed_inner.send((head, body.size()).into()).await?;
 
-    // send request body
+    // Check EXPECT header and enable expect handle flag accordingly.
-    match body.size() {
+    //
-        BodySize::None | BodySize::Empty | BodySize::Sized(0) => {}
+    // RFC: https://tools.ietf.org/html/rfc7231#section-5.1.1
-        _ => send_body(body, Pin::new(&mut framed_inner)).await?,
+    let is_expect = if head.as_ref().headers.contains_key(EXPECT) {
-    };
+        match body.size() {
+            BodySize::None | BodySize::Empty | BodySize::Sized(0) => {
+                let pin_framed = Pin::new(&mut framed);
 
-    // read response and init read body
+                let force_close = !pin_framed.codec_ref().keepalive();
-    let res = Pin::new(&mut framed_inner).into_future().await;
+                release_connection(pin_framed, force_close);
-    let (head, framed) = if let (Some(result), framed) = res {
+
-        let item = result.map_err(SendRequestError::from)?;
+                // TODO: use a new variant or a new type better describing error violate
-        (item, framed)
+                // `Requirements for clients` session of above RFC
+                return Err(SendRequestError::Connect(ConnectError::Disconnected));
+            }
+            _ => true,
+        }
     } else {
-        return Err(SendRequestError::from(ConnectError::Disconnected));
+        false
     };
 
-    match framed.codec_ref().message_type() {
+    framed.send((head, body.size()).into()).await?;
+
+    let mut pin_framed = Pin::new(&mut framed);
+
+    // special handle for EXPECT request.
+    let (do_send, mut res_head) = if is_expect {
+        let head = poll_fn(|cx| pin_framed.as_mut().poll_next(cx))
+            .await
+            .ok_or(ConnectError::Disconnected)??;
+
+        // return response head in case status code is not continue
+        // and current head would be used as final response head.
+        (head.status == StatusCode::CONTINUE, Some(head))
+    } else {
+        (true, None)
+    };
+
+    if do_send {
+        // send request body
+        match body.size() {
+            BodySize::None | BodySize::Empty | BodySize::Sized(0) => {}
+            _ => send_body(body, pin_framed.as_mut()).await?,
+        };
+
+        // read response and init read body
+        let head = poll_fn(|cx| pin_framed.as_mut().poll_next(cx))
+            .await
+            .ok_or(ConnectError::Disconnected)??;
+
+        res_head = Some(head);
+    }
+
+    let head = res_head.unwrap();
+
+    match pin_framed.codec_ref().message_type() {
         h1::MessageType::None => {
-            let force_close = !framed.codec_ref().keepalive();
+            let force_close = !pin_framed.codec_ref().keepalive();
-            release_connection(framed, force_close);
+            release_connection(pin_framed, force_close);
             Ok((head, Payload::None))
         }
         _ => {
-            let pl: PayloadStream = PlStream::new(framed_inner).boxed_local();
+            let pl: PayloadStream = Box::pin(PlStream::new(framed));
             Ok((head, pl.into()))
         }
     }
@@ -127,7 +168,7 @@ where
     T: ConnectionLifetime + Unpin,
     B: MessageBody,
 {
-    pin_mut!(body);
+    actix_rt::pin!(body);
 
     let mut eof = false;
     while !eof {
@@ -165,7 +206,10 @@ where
 
 #[doc(hidden)]
 /// HTTP client connection
-pub struct H1Connection<T> {
+pub struct H1Connection<T>
+where
+    T: AsyncWrite + Unpin + 'static,
+{
     /// T should be `Unpin`
     io: Option<T>,
     created: time::Instant,

actix-http/src/client/h2proto.rs

@@ -1,11 +1,9 @@
-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::{Builder, Connection, SendRequest},
     SendStream,
@@ -36,6 +34,7 @@ where
     B: MessageBody,
 {
     trace!("Sending client request: {:?} {:?}", head, body.size());
+
     let head_req = head.as_ref().method == Method::HEAD;
     let length = body.size();
     let eof = matches!(
@@ -61,10 +60,14 @@ where
         BodySize::Empty => req
             .headers_mut()
             .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
-        BodySize::Sized(len) => req.headers_mut().insert(
+        BodySize::Sized(len) => {
-            CONTENT_LENGTH,
+            let mut buf = itoa::Buffer::new();
-            HeaderValue::try_from(format!("{}", len)).unwrap(),
+
-        ),
+            req.headers_mut().insert(
+                CONTENT_LENGTH,
+                HeaderValue::from_str(buf.format(len)).unwrap(),
+            )
+        }
     };
 
     // Extracting extra headers from RequestHeadType. HeaderMap::new() does not allocate.
@@ -87,7 +90,10 @@ where
     // copy headers
     for (key, value) in headers {
         match *key {
-            CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
+            // TODO: consider skipping other headers according to:
+            //       https://tools.ietf.org/html/rfc7540#section-8.1.2.2
+            // omit HTTP/1.x only headers
+            CONNECTION | TRANSFER_ENCODING => continue,
             CONTENT_LENGTH if skip_len => continue,
             // DATE => has_date = true,
             _ => {}
@@ -130,7 +136,7 @@ async fn send_body<B: MessageBody>(
     mut send: SendStream<Bytes>,
 ) -> Result<(), SendRequestError> {
     let mut buf = None;
-    pin_mut!(body);
+    actix_rt::pin!(body);
     loop {
         if buf.is_none() {
             match poll_fn(|cx| body.as_mut().poll_next(cx)).await {

actix-http/src/client/mod.rs

@@ -1,4 +1,5 @@
-//! Http client api
+//! HTTP client.
+
 use http::Uri;
 
 mod config;
@@ -9,6 +10,10 @@ mod h1proto;
 mod h2proto;
 mod pool;
 
+pub use actix_tls::connect::{
+    Connect as TcpConnect, ConnectError as TcpConnectError, Connection as TcpConnection,
+};
+
 pub use self::connection::Connection;
 pub use self::connector::Connector;
 pub use self::error::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};

actix-http/src/config.rs

@@ -4,9 +4,11 @@ use std::rc::Rc;
 use std::time::Duration;
 use std::{fmt, net};
 
-use actix_rt::time::{sleep, sleep_until, Instant, Sleep};
+use actix_rt::{
+    task::JoinHandle,
+    time::{interval, sleep_until, Instant, Sleep},
+};
 use bytes::BytesMut;
-use futures_util::{future, FutureExt};
 use time::OffsetDateTime;
 
 /// "Sun, 06 Nov 1994 08:49:37 GMT".len()
@@ -49,7 +51,7 @@ struct Inner {
     ka_enabled: bool,
     secure: bool,
     local_addr: Option<std::net::SocketAddr>,
-    timer: DateService,
+    date_service: DateService,
 }
 
 impl Clone for ServiceConfig {
@@ -91,41 +93,41 @@ impl ServiceConfig {
             client_disconnect,
             secure,
             local_addr,
-            timer: DateService::new(),
+            date_service: DateService::new(),
         }))
     }
 
+    /// Returns true if connection is secure (HTTPS)
     #[inline]
-    /// Returns true if connection is secure(https)
     pub fn secure(&self) -> bool {
         self.0.secure
     }
 
-    #[inline]
     /// Returns the local address that this server is bound to.
+    #[inline]
     pub fn local_addr(&self) -> Option<net::SocketAddr> {
         self.0.local_addr
     }
 
-    #[inline]
     /// Keep alive duration if configured.
+    #[inline]
     pub fn keep_alive(&self) -> Option<Duration> {
         self.0.keep_alive
     }
 
-    #[inline]
     /// Return state of connection keep-alive functionality
+    #[inline]
     pub fn keep_alive_enabled(&self) -> bool {
         self.0.ka_enabled
     }
 
-    #[inline]
     /// Client timeout for first request.
+    #[inline]
     pub fn client_timer(&self) -> Option<Sleep> {
         let delay_time = self.0.client_timeout;
         if delay_time != 0 {
             Some(sleep_until(
-                self.0.timer.now() + Duration::from_millis(delay_time),
+                self.0.date_service.now() + Duration::from_millis(delay_time),
             ))
         } else {
             None
@@ -136,7 +138,7 @@ impl ServiceConfig {
     pub fn client_timer_expire(&self) -> Option<Instant> {
         let delay = self.0.client_timeout;
         if delay != 0 {
-            Some(self.0.timer.now() + Duration::from_millis(delay))
+            Some(self.0.date_service.now() + Duration::from_millis(delay))
         } else {
             None
         }
@@ -146,7 +148,7 @@ impl ServiceConfig {
     pub fn client_disconnect_timer(&self) -> Option<Instant> {
         let delay = self.0.client_disconnect;
         if delay != 0 {
-            Some(self.0.timer.now() + Duration::from_millis(delay))
+            Some(self.0.date_service.now() + Duration::from_millis(delay))
         } else {
             None
         }
@@ -156,7 +158,7 @@ impl ServiceConfig {
     /// Return keep-alive timer delay is configured.
     pub fn keep_alive_timer(&self) -> Option<Sleep> {
         if let Some(ka) = self.0.keep_alive {
-            Some(sleep_until(self.0.timer.now() + ka))
+            Some(sleep_until(self.0.date_service.now() + ka))
         } else {
             None
         }
@@ -165,7 +167,7 @@ impl ServiceConfig {
     /// Keep-alive expire time
     pub fn keep_alive_expire(&self) -> Option<Instant> {
         if let Some(ka) = self.0.keep_alive {
-            Some(self.0.timer.now() + ka)
+            Some(self.0.date_service.now() + ka)
         } else {
             None
         }
@@ -173,7 +175,7 @@ impl ServiceConfig {
 
     #[inline]
     pub(crate) fn now(&self) -> Instant {
-        self.0.timer.now()
+        self.0.date_service.now()
     }
 
     #[doc(hidden)]
@@ -181,7 +183,7 @@ impl ServiceConfig {
         let mut buf: [u8; 39] = [0; 39];
         buf[..6].copy_from_slice(b"date: ");
         self.0
-            .timer
+            .date_service
             .set_date(|date| buf[6..35].copy_from_slice(&date.bytes));
         buf[35..].copy_from_slice(b"\r\n\r\n");
         dst.extend_from_slice(&buf);
@@ -189,7 +191,7 @@ impl ServiceConfig {
 
     pub(crate) fn set_date_header(&self, dst: &mut BytesMut) {
         self.0
-            .timer
+            .date_service
             .set_date(|date| dst.extend_from_slice(&date.bytes));
     }
 }
@@ -230,57 +232,103 @@ impl fmt::Write for Date {
     }
 }
 
-#[derive(Clone)]
+/// Service for update Date and Instant periodically at 500 millis interval.
-struct DateService(Rc<DateServiceInner>);
+struct DateService {
-
+    current: Rc<Cell<(Date, Instant)>>,
-struct DateServiceInner {
+    handle: JoinHandle<()>,
-    current: Cell<Option<(Date, Instant)>>,
 }
 
-impl DateServiceInner {
+impl Drop for DateService {
-    fn new() -> Self {
+    fn drop(&mut self) {
-        DateServiceInner {
+        // stop the timer update async task on drop.
-            current: Cell::new(None),
+        self.handle.abort();
-        }
-    }
-
-    fn reset(&self) {
-        self.current.take();
-    }
-
-    fn update(&self) {
-        let now = Instant::now();
-        let date = Date::new();
-        self.current.set(Some((date, now)));
     }
 }
 
 impl DateService {
     fn new() -> Self {
-        DateService(Rc::new(DateServiceInner::new()))
+        // shared date and timer for DateService and update async task.
-    }
+        let current = Rc::new(Cell::new((Date::new(), Instant::now())));
+        let current_clone = Rc::clone(&current);
+        // spawn an async task sleep for 500 milli and update current date/timer in a loop.
+        // handle is used to stop the task on DateService drop.
+        let handle = actix_rt::spawn(async move {
+            #[cfg(test)]
+            let _notify = notify_on_drop::NotifyOnDrop::new();
 
-    fn check_date(&self) {
+            let mut interval = interval(Duration::from_millis(500));
-        if self.0.current.get().is_none() {
+            loop {
-            self.0.update();
+                let now = interval.tick().await;
+                let date = Date::new();
+                current_clone.set((date, now));
+            }
+        });
 
-            // periodic date update
+        DateService { current, handle }
-            let s = self.clone();
-            actix_rt::spawn(sleep(Duration::from_millis(500)).then(move |_| {
-                s.0.reset();
-                future::ready(())
-            }));
-        }
     }
 
     fn now(&self) -> Instant {
-        self.check_date();
+        self.current.get().1
-        self.0.current.get().unwrap().1
     }
 
     fn set_date<F: FnMut(&Date)>(&self, mut f: F) {
-        self.check_date();
+        f(&self.current.get().0);
-        f(&self.0.current.get().unwrap().0);
+    }
+}
+
+// TODO: move to a util module for testing all spawn handle drop style tasks.
+#[cfg(test)]
+/// Test Module for checking the drop state of certain async tasks that are spawned
+/// with `actix_rt::spawn`
+///
+/// The target task must explicitly generate `NotifyOnDrop` when spawn the task
+mod notify_on_drop {
+    use std::cell::RefCell;
+
+    thread_local! {
+        static NOTIFY_DROPPED: RefCell<Option<bool>> = RefCell::new(None);
+    }
+
+    /// Check if the spawned task is dropped.
+    ///
+    /// # Panic:
+    ///
+    /// When there was no `NotifyOnDrop` instance on current thread
+    pub(crate) fn is_dropped() -> bool {
+        NOTIFY_DROPPED.with(|bool| {
+            bool.borrow()
+                .expect("No NotifyOnDrop existed on current thread")
+        })
+    }
+
+    pub(crate) struct NotifyOnDrop;
+
+    impl NotifyOnDrop {
+        /// # Panic:
+        ///
+        /// When construct multiple instances on any given thread.
+        pub(crate) fn new() -> Self {
+            NOTIFY_DROPPED.with(|bool| {
+                let mut bool = bool.borrow_mut();
+                if bool.is_some() {
+                    panic!("NotifyOnDrop existed on current thread");
+                } else {
+                    *bool = Some(false);
+                }
+            });
+
+            NotifyOnDrop
+        }
+    }
+
+    impl Drop for NotifyOnDrop {
+        fn drop(&mut self) {
+            NOTIFY_DROPPED.with(|bool| {
+                if let Some(b) = bool.borrow_mut().as_mut() {
+                    *b = true;
+                }
+            });
+        }
     }
 }
 
@@ -288,14 +336,53 @@ impl DateService {
 mod tests {
     use super::*;
 
-    // Test modifying the date from within the closure
+    use actix_rt::task::yield_now;
-    // passed to `set_date`
+
-    #[test]
+    #[actix_rt::test]
-    fn test_evil_date() {
+    async fn test_date_service_update() {
-        let service = DateService::new();
+        let settings = ServiceConfig::new(KeepAlive::Os, 0, 0, false, None);
-        // Make sure that `check_date` doesn't try to spawn a task
+
-        service.0.update();
+        yield_now().await;
-        service.set_date(|_| service.0.reset());
+
+        let mut buf1 = BytesMut::with_capacity(DATE_VALUE_LENGTH + 10);
+        settings.set_date(&mut buf1);
+        let now1 = settings.now();
+
+        sleep_until(Instant::now() + Duration::from_secs(2)).await;
+        yield_now().await;
+
+        let now2 = settings.now();
+        let mut buf2 = BytesMut::with_capacity(DATE_VALUE_LENGTH + 10);
+        settings.set_date(&mut buf2);
+
+        assert_ne!(now1, now2);
+
+        assert_ne!(buf1, buf2);
+
+        drop(settings);
+        assert!(notify_on_drop::is_dropped());
+    }
+
+    #[actix_rt::test]
+    async fn test_date_service_drop() {
+        let service = Rc::new(DateService::new());
+
+        // yield so date service have a chance to register the spawned timer update task.
+        yield_now().await;
+
+        let clone1 = service.clone();
+        let clone2 = service.clone();
+        let clone3 = service.clone();
+
+        drop(clone1);
+        assert_eq!(false, notify_on_drop::is_dropped());
+        drop(clone2);
+        assert_eq!(false, notify_on_drop::is_dropped());
+        drop(clone3);
+        assert_eq!(false, notify_on_drop::is_dropped());
+
+        drop(service);
+        assert!(notify_on_drop::is_dropped());
     }
 
     #[test]

actix-http/src/encoding/decoder.rs

@@ -1,7 +1,11 @@
-use std::future::Future;
+//! Stream decoders.
-use std::io::{self, Write};
+
-use std::pin::Pin;
+use std::{
-use std::task::{Context, Poll};
+    future::Future,
+    io::{self, Write as _},
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use actix_rt::task::{spawn_blocking, JoinHandle};
 use brotli2::write::BrotliDecoder;
@@ -9,11 +13,13 @@ use bytes::Bytes;
 use flate2::write::{GzDecoder, ZlibDecoder};
 use futures_core::{ready, Stream};
 
-use super::Writer;
+use crate::{
-use crate::error::{BlockingError, PayloadError};
+    encoding::Writer,
-use crate::http::header::{ContentEncoding, HeaderMap, CONTENT_ENCODING};
+    error::{BlockingError, PayloadError},
+    http::header::{ContentEncoding, HeaderMap, CONTENT_ENCODING},
+};
 
-const INPLACE: usize = 2049;
+const MAX_CHUNK_SIZE_DECODE_IN_PLACE: usize = 2049;
 
 pub struct Decoder<S> {
     decoder: Option<ContentDecoder>,
@@ -41,6 +47,7 @@ where
             ))),
             _ => None,
         };
+
         Decoder {
             decoder,
             stream,
@@ -53,15 +60,11 @@ where
     #[inline]
     pub fn from_headers(stream: S, headers: &HeaderMap) -> Decoder<S> {
         // check content-encoding
-        let encoding = if let Some(enc) = headers.get(&CONTENT_ENCODING) {
+        let encoding = headers
-            if let Ok(enc) = enc.to_str() {
+            .get(&CONTENT_ENCODING)
-                ContentEncoding::from(enc)
+            .and_then(|val| val.to_str().ok())
-            } else {
+            .map(ContentEncoding::from)
-                ContentEncoding::Identity
+            .unwrap_or(ContentEncoding::Identity);
-            }
-        } else {
-            ContentEncoding::Identity
-        };
 
         Self::new(stream, encoding)
     }
@@ -81,8 +84,10 @@ where
             if let Some(ref mut fut) = self.fut {
                 let (chunk, decoder) =
                     ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
+
                 self.decoder = Some(decoder);
                 self.fut.take();
+
                 if let Some(chunk) = chunk {
                     return Poll::Ready(Some(Ok(chunk)));
                 }
@@ -92,13 +97,15 @@ where
                 return Poll::Ready(None);
             }
 
-            match Pin::new(&mut self.stream).poll_next(cx) {
+            match ready!(Pin::new(&mut self.stream).poll_next(cx)) {
-                Poll::Ready(Some(Err(err))) => return Poll::Ready(Some(Err(err))),
+                Some(Err(err)) => return Poll::Ready(Some(Err(err))),
-                Poll::Ready(Some(Ok(chunk))) => {
+
+                Some(Ok(chunk)) => {
                     if let Some(mut decoder) = self.decoder.take() {
-                        if chunk.len() < INPLACE {
+                        if chunk.len() < MAX_CHUNK_SIZE_DECODE_IN_PLACE {
                             let chunk = decoder.feed_data(chunk)?;
                             self.decoder = Some(decoder);
+
                             if let Some(chunk) = chunk {
                                 return Poll::Ready(Some(Ok(chunk)));
                             }
@@ -108,13 +115,16 @@ where
                                 Ok((chunk, decoder))
                             }));
                         }
+
                         continue;
                     } else {
                         return Poll::Ready(Some(Ok(chunk)));
                     }
                 }
-                Poll::Ready(None) => {
+
+                None => {
                     self.eof = true;
+
                     return if let Some(mut decoder) = self.decoder.take() {
                         match decoder.feed_eof() {
                             Ok(Some(res)) => Poll::Ready(Some(Ok(res))),
@@ -125,10 +135,8 @@ where
                         Poll::Ready(None)
                     };
                 }
-                Poll::Pending => break,
             }
         }
-        Poll::Pending
     }
 }
 
@@ -144,6 +152,7 @@ impl ContentDecoder {
             ContentDecoder::Br(ref mut decoder) => match decoder.flush() {
                 Ok(()) => {
                     let b = decoder.get_mut().take();
+
                     if !b.is_empty() {
                         Ok(Some(b))
                     } else {
@@ -152,9 +161,11 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
+
             ContentDecoder::Gzip(ref mut decoder) => match decoder.try_finish() {
                 Ok(_) => {
                     let b = decoder.get_mut().take();
+
                     if !b.is_empty() {
                         Ok(Some(b))
                     } else {
@@ -163,6 +174,7 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
+
             ContentDecoder::Deflate(ref mut decoder) => match decoder.try_finish() {
                 Ok(_) => {
                     let b = decoder.get_mut().take();
@@ -183,6 +195,7 @@ impl ContentDecoder {
                 Ok(_) => {
                     decoder.flush()?;
                     let b = decoder.get_mut().take();
+
                     if !b.is_empty() {
                         Ok(Some(b))
                     } else {
@@ -191,10 +204,12 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
+
             ContentDecoder::Gzip(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
                     let b = decoder.get_mut().take();
+
                     if !b.is_empty() {
                         Ok(Some(b))
                     } else {
@@ -203,9 +218,11 @@ impl ContentDecoder {
                 }
                 Err(e) => Err(e),
             },
+
             ContentDecoder::Deflate(ref mut decoder) => match decoder.write_all(&data) {
                 Ok(_) => {
                     decoder.flush()?;
+
                     let b = decoder.get_mut().take();
                     if !b.is_empty() {
                         Ok(Some(b))

actix-http/src/encoding/encoder.rs

@@ -1,8 +1,11 @@
-//! Stream encoder
+//! Stream encoders.
-use std::future::Future;
+
-use std::io::{self, Write};
+use std::{
-use std::pin::Pin;
+    future::Future,
-use std::task::{Context, Poll};
+    io::{self, Write as _},
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use actix_rt::task::{spawn_blocking, JoinHandle};
 use brotli2::write::BrotliEncoder;
@@ -11,15 +14,19 @@ use flate2::write::{GzEncoder, ZlibEncoder};
 use futures_core::ready;
 use pin_project::pin_project;
 
-use crate::body::{Body, BodySize, MessageBody, ResponseBody};
+use crate::{
-use crate::http::header::{ContentEncoding, CONTENT_ENCODING};
+    body::{Body, BodySize, MessageBody, ResponseBody},
-use crate::http::{HeaderValue, StatusCode};
+    http::{
-use crate::{Error, ResponseHead};
+        header::{ContentEncoding, CONTENT_ENCODING},
+        HeaderValue, StatusCode,
+    },
+    Error, ResponseHead,
+};
 
 use super::Writer;
 use crate::error::BlockingError;
 
-const INPLACE: usize = 1024;
+const MAX_CHUNK_SIZE_ENCODE_IN_PLACE: usize = 1024;
 
 #[pin_project]
 pub struct Encoder<B> {
@@ -71,6 +78,7 @@ impl<B: MessageBody> Encoder<B> {
                 });
             }
         }
+
         ResponseBody::Body(Encoder {
             body,
             eof: false,
@@ -138,23 +146,28 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
             if let Some(ref mut fut) = this.fut {
                 let mut encoder =
                     ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
+
                 let chunk = encoder.take();
                 *this.encoder = Some(encoder);
                 this.fut.take();
+
                 if !chunk.is_empty() {
                     return Poll::Ready(Some(Ok(chunk)));
                 }
             }
 
-            let result = this.body.as_mut().poll_next(cx);
+            let result = ready!(this.body.as_mut().poll_next(cx));
 
             match result {
-                Poll::Ready(Some(Ok(chunk))) => {
+                Some(Err(err)) => return Poll::Ready(Some(Err(err))),
+
+                Some(Ok(chunk)) => {
                     if let Some(mut encoder) = this.encoder.take() {
-                        if chunk.len() < INPLACE {
+                        if chunk.len() < MAX_CHUNK_SIZE_ENCODE_IN_PLACE {
                             encoder.write(&chunk)?;
                             let chunk = encoder.take();
                             *this.encoder = Some(encoder);
+
                             if !chunk.is_empty() {
                                 return Poll::Ready(Some(Ok(chunk)));
                             }
@@ -168,7 +181,8 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
                         return Poll::Ready(Some(Ok(chunk)));
                     }
                 }
-                Poll::Ready(None) => {
+
+                None => {
                     if let Some(encoder) = this.encoder.take() {
                         let chunk = encoder.finish()?;
                         if chunk.is_empty() {
@@ -181,7 +195,6 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
                         return Poll::Ready(None);
                     }
                 }
-                val => return val,
             }
         }
     }

actix-http/src/encoding/mod.rs

@@ -1,4 +1,5 @@
-//! Content-Encoding support
+//! Content-Encoding support.
+
 use std::io;
 
 use bytes::{Bytes, BytesMut};

actix-http/src/error.rs

@@ -11,7 +11,6 @@ use actix_utils::dispatcher::DispatcherError as FramedDispatcherError;
 use actix_utils::timeout::TimeoutError;
 use bytes::BytesMut;
 use derive_more::{Display, From};
-pub use futures_channel::oneshot::Canceled;
 use http::uri::InvalidUri;
 use http::{header, Error as HttpError, StatusCode};
 use serde::de::value::Error as DeError;
@@ -19,10 +18,12 @@ use serde_json::error::Error as JsonError;
 use serde_urlencoded::ser::Error as FormError;
 
 use crate::body::Body;
-pub use crate::cookie::ParseError as CookieParseError;
 use crate::helpers::Writer;
 use crate::response::{Response, ResponseBuilder};
 
+#[cfg(feature = "cookies")]
+pub use crate::cookie::ParseError as CookieParseError;
+
 /// A specialized [`std::result::Result`]
 /// for actix web operations
 ///
@@ -38,7 +39,7 @@ pub type Result<T, E = Error> = result::Result<T, E>;
 /// converting errors with `into()`.
 ///
 /// Whenever it is created from an external object a response error is created
-/// for it that can be used to create an http response from it this means that
+/// for it that can be used to create an HTTP response from it this means that
 /// if you have access to an actix `Error` you can always get a
 /// `ResponseError` reference from it.
 pub struct Error {
@@ -184,9 +185,6 @@ impl ResponseError for DeError {
     }
 }
 
-/// Returns [`StatusCode::INTERNAL_SERVER_ERROR`] for [`Canceled`].
-impl ResponseError for Canceled {}
-
 /// Returns [`StatusCode::BAD_REQUEST`] for [`Utf8Error`].
 impl ResponseError for Utf8Error {
     fn status_code(&self) -> StatusCode {
@@ -397,6 +395,7 @@ impl ResponseError for PayloadError {
 }
 
 /// Return `BadRequest` for `cookie::ParseError`
+#[cfg(feature = "cookies")]
 impl ResponseError for crate::cookie::ParseError {
     fn status_code(&self) -> StatusCode {
         StatusCode::BAD_REQUEST
@@ -404,7 +403,7 @@ impl ResponseError for crate::cookie::ParseError {
 }
 
 #[derive(Debug, Display, From)]
-/// A set of errors that can occur during dispatching http requests
+/// A set of errors that can occur during dispatching HTTP requests
 pub enum DispatchError {
     /// Service error
     Service(Error),
@@ -984,6 +983,7 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
+    #[cfg(feature = "cookies")]
     #[test]
     fn test_cookie_parse() {
         let resp: Response = CookieParseError::EmptyName.error_response();

actix-http/src/h1/codec.rs

@@ -199,10 +199,10 @@ mod tests {
     use http::Method;
 
     use super::*;
-    use crate::httpmessage::HttpMessage;
+    use crate::HttpMessage;
 
-    #[test]
+    #[actix_rt::test]
-    fn test_http_request_chunked_payload_and_next_message() {
+    async fn test_http_request_chunked_payload_and_next_message() {
         let mut codec = Codec::default();
 
         let mut buf = BytesMut::from(

actix-http/src/h1/decoder.rs

@@ -224,7 +224,7 @@ impl MessageType for Request {
         let decoder = match length {
             PayloadLength::Payload(pl) => pl,
             PayloadLength::UpgradeWebSocket => {
-                // upgrade(websocket)
+                // upgrade (WebSocket)
                 PayloadType::Stream(PayloadDecoder::eof())
             }
             PayloadLength::None => {
@@ -652,7 +652,7 @@ mod tests {
     use super::*;
     use crate::error::ParseError;
     use crate::http::header::{HeaderName, SET_COOKIE};
-    use crate::httpmessage::HttpMessage;
+    use crate::HttpMessage;
 
     impl PayloadType {
         fn unwrap(self) -> PayloadDecoder {

actix-http/src/h1/dispatcher.rs

@@ -13,6 +13,7 @@ use actix_rt::time::{sleep_until, Instant, Sleep};
 use actix_service::Service;
 use bitflags::bitflags;
 use bytes::{Buf, BytesMut};
+use futures_core::ready;
 use log::{error, trace};
 use pin_project::pin_project;
 
@@ -37,15 +38,13 @@ bitflags! {
     pub struct Flags: u8 {
         const STARTED            = 0b0000_0001;
         const KEEPALIVE          = 0b0000_0010;
-        const POLLED             = 0b0000_0100;
+        const SHUTDOWN           = 0b0000_0100;
-        const SHUTDOWN           = 0b0000_1000;
+        const READ_DISCONNECT    = 0b0000_1000;
-        const READ_DISCONNECT    = 0b0001_0000;
+        const WRITE_DISCONNECT   = 0b0001_0000;
-        const WRITE_DISCONNECT   = 0b0010_0000;
-        const UPGRADE            = 0b0100_0000;
     }
 }
 
-#[pin_project::pin_project]
+#[pin_project]
 /// Dispatcher for HTTP/1.1 protocol
 pub struct Dispatcher<T, S, B, X, U>
 where
@@ -139,27 +138,14 @@ where
     fn is_empty(&self) -> bool {
         matches!(self, State::None)
     }
-
-    fn is_call(&self) -> bool {
-        matches!(self, State::ServiceCall(_))
-    }
 }
+
 enum PollResponse {
     Upgrade(Request),
     DoNothing,
     DrainWriteBuf,
 }
 
-impl PartialEq for PollResponse {
-    fn eq(&self, other: &PollResponse) -> bool {
-        match self {
-            PollResponse::DrainWriteBuf => matches!(other, PollResponse::DrainWriteBuf),
-            PollResponse::DoNothing => matches!(other, PollResponse::DoNothing),
-            _ => false,
-        }
-    }
-}
-
 impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
@@ -174,62 +160,35 @@ where
 {
     /// Create HTTP/1 dispatcher.
     pub(crate) fn new(
-        stream: T,
-        config: ServiceConfig,
-        services: Rc<HttpFlow<S, X, U>>,
-        on_connect_data: OnConnectData,
-        peer_addr: Option<net::SocketAddr>,
-    ) -> Self {
-        Dispatcher::with_timeout(
-            stream,
-            Codec::new(config.clone()),
-            config,
-            BytesMut::with_capacity(HW_BUFFER_SIZE),
-            None,
-            services,
-            on_connect_data,
-            peer_addr,
-        )
-    }
-
-    /// Create http/1 dispatcher with slow request timeout.
-    pub(crate) fn with_timeout(
         io: T,
-        codec: Codec,
         config: ServiceConfig,
-        read_buf: BytesMut,
+        flow: Rc<HttpFlow<S, X, U>>,
-        timeout: Option<Sleep>,
-        services: Rc<HttpFlow<S, X, U>>,
         on_connect_data: OnConnectData,
         peer_addr: Option<net::SocketAddr>,
     ) -> Self {
-        let keepalive = config.keep_alive_enabled();
+        let flags = if config.keep_alive_enabled() {
-        let flags = if keepalive {
             Flags::KEEPALIVE
         } else {
             Flags::empty()
         };
 
         // keep-alive timer
-        let (ka_expire, ka_timer) = if let Some(delay) = timeout {
+        let (ka_expire, ka_timer) = match config.keep_alive_timer() {
-            (delay.deadline(), Some(delay))
+            Some(delay) => (delay.deadline(), Some(delay)),
-        } else if let Some(delay) = config.keep_alive_timer() {
+            None => (config.now(), None),
-            (delay.deadline(), Some(delay))
-        } else {
-            (config.now(), None)
         };
 
         Dispatcher {
             inner: DispatcherState::Normal(InnerDispatcher {
+                read_buf: BytesMut::with_capacity(HW_BUFFER_SIZE),
                 write_buf: BytesMut::with_capacity(HW_BUFFER_SIZE),
                 payload: None,
                 state: State::None,
                 error: None,
                 messages: VecDeque::new(),
                 io: Some(io),
-                codec,
+                codec: Codec::new(config),
-                read_buf,
+                flow,
-                flow: services,
                 on_connect_data,
                 flags,
                 peer_addr,
@@ -256,10 +215,7 @@ where
     U::Error: fmt::Display,
 {
     fn can_read(&self, cx: &mut Context<'_>) -> bool {
-        if self
+        if self.flags.contains(Flags::READ_DISCONNECT) {
-            .flags
-            .intersects(Flags::READ_DISCONNECT | Flags::UPGRADE)
-        {
             false
         } else if let Some(ref info) = self.payload {
             info.need_read(cx) == PayloadStatus::Read
@@ -278,14 +234,10 @@ where
         }
     }
 
-    /// Flush stream
-    ///
-    /// true - got WouldBlock
-    /// false - didn't get WouldBlock
     fn poll_flush(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Result<bool, DispatchError> {
+    ) -> Poll<Result<(), io::Error>> {
         let InnerDispatcherProj { io, write_buf, .. } = self.project();
         let mut io = Pin::new(io.as_mut().unwrap());
 
@@ -293,32 +245,26 @@ where
         let mut written = 0;
 
         while written < len {
-            match io.as_mut().poll_write(cx, &write_buf[written..]) {
+            match io.as_mut().poll_write(cx, &write_buf[written..])? {
-                Poll::Ready(Ok(0)) => {
+                Poll::Ready(0) => {
-                    return Err(DispatchError::Io(io::Error::new(
+                    return Poll::Ready(Err(io::Error::new(
                         io::ErrorKind::WriteZero,
                         "",
                     )))
                 }
-                Poll::Ready(Ok(n)) => written += n,
+                Poll::Ready(n) => written += n,
                 Poll::Pending => {
                     write_buf.advance(written);
-                    return Ok(true);
+                    return Poll::Pending;
                 }
-                Poll::Ready(Err(err)) => return Err(DispatchError::Io(err)),
             }
         }
 
-        // SAFETY: setting length to 0 is safe
+        // everything has written to io. clear buffer.
-        // skips one length check vs truncate
+        write_buf.clear();
-        unsafe {
-            write_buf.set_len(0);
-        }
 
         // flush the io and check if get blocked.
-        let blocked = io.poll_flush(cx)?.is_pending();
+        io.poll_flush(cx)
-
-        Ok(blocked)
     }
 
     fn send_response(
@@ -326,9 +272,10 @@ where
         message: Response<()>,
         body: ResponseBody<B>,
     ) -> Result<(), DispatchError> {
+        let size = body.size();
         let mut this = self.project();
         this.codec
-            .encode(Message::Item((message, body.size())), &mut this.write_buf)
+            .encode(Message::Item((message, size)), &mut this.write_buf)
             .map_err(|err| {
                 if let Some(mut payload) = this.payload.take() {
                     payload.set_error(PayloadError::Incomplete(None));
@@ -337,7 +284,7 @@ where
             })?;
 
         this.flags.set(Flags::KEEPALIVE, this.codec.keepalive());
-        match body.size() {
+        match size {
             BodySize::None | BodySize::Empty => this.state.set(State::None),
             _ => this.state.set(State::SendPayload(body)),
         };
@@ -354,109 +301,121 @@ where
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Result<PollResponse, DispatchError> {
-        loop {
+        'res: loop {
             let mut this = self.as_mut().project();
-            // state is not changed on Poll::Pending.
+            match this.state.as_mut().project() {
-            // other variant and conditions always trigger a state change(or an error).
+                // no future is in InnerDispatcher state. pop next message.
-            let state_change = match this.state.project() {
                 StateProj::None => match this.messages.pop_front() {
+                    // handle request message.
                     Some(DispatcherMessage::Item(req)) => {
-                        self.as_mut().handle_request(req, cx)?;
+                        // Handle `EXPECT: 100-Continue` header
-                        true
+                        if req.head().expect() {
+                            // set InnerDispatcher state and continue loop to poll it.
+                            let task = this.flow.expect.call(req);
+                            this.state.set(State::ExpectCall(task));
+                        } else {
+                            // the same as expect call.
+                            let task = this.flow.service.call(req);
+                            this.state.set(State::ServiceCall(task));
+                        };
                     }
+
+                    // handle error message.
                     Some(DispatcherMessage::Error(res)) => {
+                        // send_response would update InnerDispatcher state to SendPayload or
+                        // None(If response body is empty).
+                        // continue loop to poll it.
                         self.as_mut()
                             .send_response(res, ResponseBody::Other(Body::Empty))?;
-                        true
                     }
+
+                    // return with upgrade request and poll it exclusively.
                     Some(DispatcherMessage::Upgrade(req)) => {
                         return Ok(PollResponse::Upgrade(req));
                     }
-                    None => false,
+
-                },
+                    // all messages are dealt with.
-                StateProj::ExpectCall(fut) => match fut.poll(cx) {
+                    None => return Ok(PollResponse::DoNothing),
-                    Poll::Ready(Ok(req)) => {
-                        self.as_mut().send_continue();
-                        this = self.as_mut().project();
-                        let fut = this.flow.service.call(req);
-                        this.state.set(State::ServiceCall(fut));
-                        continue;
-                    }
-                    Poll::Ready(Err(e)) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
-                        self.as_mut().send_response(res, body.into_body())?;
-                        true
-                    }
-                    Poll::Pending => false,
                 },
                 StateProj::ServiceCall(fut) => match fut.poll(cx) {
+                    // service call resolved. send response.
                     Poll::Ready(Ok(res)) => {
                         let (res, body) = res.into().replace_body(());
                         self.as_mut().send_response(res, body)?;
-                        continue;
                     }
-                    Poll::Ready(Err(e)) => {
+
-                        let res: Response = e.into().into();
+                    // send service call error as response
+                    Poll::Ready(Err(err)) => {
+                        let res: Response = err.into().into();
                         let (res, body) = res.replace_body(());
                         self.as_mut().send_response(res, body.into_body())?;
-                        true
                     }
-                    Poll::Pending => false,
+
-                },
+                    // service call pending and could be waiting for more chunk messages.
-                StateProj::SendPayload(mut stream) => {
+                    // (pipeline message limit and/or payload can_read limit)
-                    loop {
+                    Poll::Pending => {
-                        if this.write_buf.len() < super::payload::MAX_BUFFER_SIZE {
+                        // no new message is decoded and no new payload is feed.
-                            match stream.as_mut().poll_next(cx) {
+                        // nothing to do except waiting for new incoming data from client.
-                                Poll::Ready(Some(Ok(item))) => {
+                        if !self.as_mut().poll_request(cx)? {
-                                    this.codec.encode(
+                            return Ok(PollResponse::DoNothing);
-                                        Message::Chunk(Some(item)),
-                                        &mut this.write_buf,
-                                    )?;
-                                    continue;
-                                }
-                                Poll::Ready(None) => {
-                                    this.codec.encode(
-                                        Message::Chunk(None),
-                                        &mut this.write_buf,
-                                    )?;
-                                    this = self.as_mut().project();
-                                    this.state.set(State::None);
-                                }
-                                Poll::Ready(Some(Err(_))) => {
-                                    return Err(DispatchError::Unknown)
-                                }
-                                Poll::Pending => return Ok(PollResponse::DoNothing),
-                            }
-                        } else {
-                            return Ok(PollResponse::DrainWriteBuf);
                         }
-                        break;
+                        // otherwise keep loop.
                     }
-                    continue;
+                },
-                }
-            };
 
-            // state is changed and continue when the state is not Empty
+                StateProj::SendPayload(mut stream) => {
-            if state_change {
+                    // keep populate writer buffer until buffer size limit hit,
-                if !self.state.is_empty() {
+                    // get blocked or finished.
-                    continue;
+                    while this.write_buf.len() < super::payload::MAX_BUFFER_SIZE {
-                }
+                        match stream.as_mut().poll_next(cx) {
-            } else {
+                            Poll::Ready(Some(Ok(item))) => {
-                // if read-backpressure is enabled and we consumed some data.
+                                this.codec.encode(
-                // we may read more data and retry
+                                    Message::Chunk(Some(item)),
-                if self.state.is_call() {
+                                    &mut this.write_buf,
-                    if self.as_mut().poll_request(cx)? {
+                                )?;
-                        continue;
+                            }
+
+                            Poll::Ready(None) => {
+                                this.codec
+                                    .encode(Message::Chunk(None), &mut this.write_buf)?;
+                                // payload stream finished.
+                                // set state to None and handle next message
+                                this.state.set(State::None);
+                                continue 'res;
+                            }
+
+                            Poll::Ready(Some(Err(err))) => {
+                                return Err(DispatchError::Service(err))
+                            }
+
+                            Poll::Pending => return Ok(PollResponse::DoNothing),
+                        }
                     }
-                } else if !self.messages.is_empty() {
+                    // buffer is beyond max size.
-                    continue;
+                    // return and try to write the whole buffer to io stream.
+                    return Ok(PollResponse::DrainWriteBuf);
                 }
+
+                StateProj::ExpectCall(fut) => match fut.poll(cx) {
+                    // expect resolved. write continue to buffer and set InnerDispatcher state
+                    // to service call.
+                    Poll::Ready(Ok(req)) => {
+                        this.write_buf
+                            .extend_from_slice(b"HTTP/1.1 100 Continue\r\n\r\n");
+                        let fut = this.flow.service.call(req);
+                        this.state.set(State::ServiceCall(fut));
+                    }
+                    // send expect error as response
+                    Poll::Ready(Err(err)) => {
+                        let res: Response = err.into().into();
+                        let (res, body) = res.replace_body(());
+                        self.as_mut().send_response(res, body.into_body())?;
+                    }
+                    // expect must be solved before progress can be made.
+                    Poll::Pending => return Ok(PollResponse::DoNothing),
+                },
             }
-            break;
         }
-
-        Ok(PollResponse::DoNothing)
     }
 
     fn handle_request(
@@ -496,9 +455,9 @@ where
                         // future is error. send response and return a result. On success
                         // to notify the dispatcher a new state is set and the outer loop
                         // should be continue.
-                        Poll::Ready(Err(e)) => {
+                        Poll::Ready(Err(err)) => {
-                            let e = e.into();
+                            let err = err.into();
-                            let res: Response = e.into();
+                            let res: Response = err.into();
                             let (res, body) = res.replace_body(());
                             return self.send_response(res, body.into_body());
                         }
@@ -516,9 +475,9 @@ where
                         }
                         // see the comment on ExpectCall state branch's Pending.
                         Poll::Pending => Ok(()),
-                        // see the comment on ExpectCall state branch's Ready(Err(e)).
+                        // see the comment on ExpectCall state branch's Ready(Err(err)).
-                        Poll::Ready(Err(e)) => {
+                        Poll::Ready(Err(err)) => {
-                            let res: Response = e.into().into();
+                            let res: Response = err.into().into();
                             let (res, body) = res.replace_body(());
                             self.send_response(res, body.into_body())
                         }
@@ -532,7 +491,7 @@ where
     }
 
     /// Process one incoming request.
-    pub(self) fn poll_request(
+    fn poll_request(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Result<bool, DispatchError> {
@@ -551,25 +510,43 @@ where
 
                     match msg {
                         Message::Item(mut req) => {
-                            let pl = this.codec.message_type();
                             req.head_mut().peer_addr = *this.peer_addr;
 
                             // merge on_connect_ext data into request extensions
                             this.on_connect_data.merge_into(&mut req);
 
-                            if pl == MessageType::Stream && this.flow.upgrade.is_some() {
+                            match this.codec.message_type() {
-                                this.messages.push_back(DispatcherMessage::Upgrade(req));
+                                // Request is upgradable. add upgrade message and break.
-                                break;
+                                // everything remain in read buffer would be handed to
-                            }
+                                // upgraded Request.
-                            if pl == MessageType::Payload || pl == MessageType::Stream {
+                                MessageType::Stream if this.flow.upgrade.is_some() => {
-                                let (ps, pl) = Payload::create(false);
+                                    this.messages
-                                let (req1, _) =
+                                        .push_back(DispatcherMessage::Upgrade(req));
-                                    req.replace_payload(crate::Payload::H1(pl));
+                                    break;
-                                req = req1;
+                                }
-                                *this.payload = Some(ps);
+
+                                // Request is not upgradable.
+                                MessageType::Payload | MessageType::Stream => {
+                                    /*
+                                    PayloadSender and Payload are smart pointers share the
+                                    same state.
+                                    PayloadSender is attached to dispatcher and used to sink
+                                    new chunked request data to state.
+                                    Payload is attached to Request and passed to Service::call
+                                    where the state can be collected and consumed.
+                                    */
+                                    let (ps, pl) = Payload::create(false);
+                                    let (req1, _) =
+                                        req.replace_payload(crate::Payload::H1(pl));
+                                    req = req1;
+                                    *this.payload = Some(ps);
+                                }
+
+                                // Request has no payload.
+                                MessageType::None => {}
                             }
 
-                            // handle request early
+                            // handle request early when no future in InnerDispatcher state.
                             if this.state.is_empty() {
                                 self.as_mut().handle_request(req, cx)?;
                                 this = self.as_mut().project();
@@ -610,25 +587,25 @@ where
                 // decode is partial and buffer is not full yet.
                 // break and wait for more read.
                 Ok(None) => break,
-                Err(ParseError::Io(e)) => {
+                Err(ParseError::Io(err)) => {
                     self.as_mut().client_disconnected();
                     this = self.as_mut().project();
-                    *this.error = Some(DispatchError::Io(e));
+                    *this.error = Some(DispatchError::Io(err));
                     break;
                 }
                 Err(ParseError::TooLarge) => {
                     if let Some(mut payload) = this.payload.take() {
                         payload.set_error(PayloadError::Overflow);
                     }
-                    // Requests overflow buffer size should be responded with 413
+                    // Requests overflow buffer size should be responded with 431
                     this.messages.push_back(DispatcherMessage::Error(
-                        Response::PayloadTooLarge().finish().drop_body(),
+                        Response::RequestHeaderFieldsTooLarge().finish().drop_body(),
                     ));
                     this.flags.insert(Flags::READ_DISCONNECT);
                     *this.error = Some(ParseError::TooLarge.into());
                     break;
                 }
-                Err(e) => {
+                Err(err) => {
                     if let Some(mut payload) = this.payload.take() {
                         payload.set_error(PayloadError::EncodingCorrupted);
                     }
@@ -638,7 +615,7 @@ where
                         Response::BadRequest().finish().drop_body(),
                     ));
                     this.flags.insert(Flags::READ_DISCONNECT);
-                    *this.error = Some(e.into());
+                    *this.error = Some(err.into());
                     break;
                 }
             }
@@ -759,6 +736,53 @@ where
         let mut read_some = false;
 
         loop {
+            // Return early when read buf exceed decoder's max buffer size.
+            if this.read_buf.len() >= super::decoder::MAX_BUFFER_SIZE {
+                /*
+                 At this point it's not known IO stream is still scheduled
+                 to be waked up. so force wake up dispatcher just in case.
+
+                 Reason:
+                 AsyncRead mostly would only have guarantee wake up
+                 when the poll_read return Poll::Pending.
+
+                 Case:
+                 When read_buf is beyond max buffer size the early return
+                 could be successfully be parsed as a new Request.
+                 This case would not generate ParseError::TooLarge
+                 and at this point IO stream is not fully read to Pending
+                 and would result in dispatcher stuck until timeout (KA)
+
+                 Note:
+                 This is a perf choice to reduce branch on
+                 <Request as MessageType>::decode.
+
+                 A Request head too large to parse is only checked on
+                 httparse::Status::Partial condition.
+                */
+                if this.payload.is_none() {
+                    /*
+                    When dispatcher has a payload the responsibility of
+                    wake up it would be shift to h1::payload::Payload.
+
+                    Reason:
+                    Self wake up when there is payload would waste poll
+                    and/or result in over read.
+
+                    Case:
+                    When payload is (partial) dropped by user there is
+                    no need to do read anymore.
+                    At this case read_buf could always remain beyond
+                    MAX_BUFFER_SIZE and self wake up would be busy poll
+                    dispatcher and waste resource.
+
+                    */
+                    cx.waker().wake_by_ref();
+                }
+
+                return Ok(false);
+            }
+
             // grow buffer if necessary.
             let remaining = this.read_buf.capacity() - this.read_buf.len();
             if remaining < LW_BUFFER_SIZE {
@@ -766,30 +790,18 @@ where
             }
 
             match actix_codec::poll_read_buf(io.as_mut(), cx, this.read_buf) {
-                Poll::Pending => return Ok(false),
                 Poll::Ready(Ok(n)) => {
                     if n == 0 {
                         return Ok(true);
-                    } else {
-                        // Return early when read buf exceed decoder's max buffer size.
-                        if this.read_buf.len() >= super::decoder::MAX_BUFFER_SIZE {
-                            // at this point it's not known io is still scheduled to
-                            // be waked up. so force wake up dispatcher just in case.
-                            // TODO: figure out the overhead.
-                            cx.waker().wake_by_ref();
-                            return Ok(false);
-                        }
-
-                        read_some = true;
                     }
+                    read_some = true;
                 }
+                Poll::Pending => return Ok(false),
                 Poll::Ready(Err(err)) => {
-                    return if err.kind() == io::ErrorKind::WouldBlock {
+                    return match err.kind() {
-                        Ok(false)
+                        io::ErrorKind::WouldBlock => Ok(false),
-                    } else if err.kind() == io::ErrorKind::ConnectionReset && read_some {
+                        io::ErrorKind::ConnectionReset if read_some => Ok(true),
-                        Ok(true)
+                        _ => Err(DispatchError::Io(err)),
-                    } else {
-                        Err(DispatchError::Io(err))
                     }
                 }
             }
@@ -841,14 +853,11 @@ where
                     if inner.flags.contains(Flags::WRITE_DISCONNECT) {
                         Poll::Ready(Ok(()))
                     } else {
-                        // flush buffer and wait on block.
+                        // flush buffer and wait on blocked.
-                        if inner.as_mut().poll_flush(cx)? {
+                        ready!(inner.as_mut().poll_flush(cx))?;
-                            Poll::Pending
+                        Pin::new(inner.project().io.as_mut().unwrap())
-                        } else {
+                            .poll_shutdown(cx)
-                            Pin::new(inner.project().io.as_mut().unwrap())
+                            .map_err(DispatchError::from)
-                                .poll_shutdown(cx)
-                                .map_err(DispatchError::from)
-                        }
                     }
                 } else {
                     // read from io stream and fill read buffer.
@@ -888,7 +897,7 @@ where
                         //
                         // TODO: what? is WouldBlock good or bad?
                         // want to find a reference for this macOS behavior
-                        if inner.as_mut().poll_flush(cx)? || !drain {
+                        if inner.as_mut().poll_flush(cx)?.is_pending() || !drain {
                             break;
                         }
                     }
@@ -1011,7 +1020,7 @@ mod tests {
                 None,
             );
 
-            futures_util::pin_mut!(h1);
+            actix_rt::pin!(h1);
 
             match h1.as_mut().poll(cx) {
                 Poll::Pending => panic!(),
@@ -1051,7 +1060,7 @@ mod tests {
                 None,
             );
 
-            futures_util::pin_mut!(h1);
+            actix_rt::pin!(h1);
 
             assert!(matches!(&h1.inner, DispatcherState::Normal(_)));
 
@@ -1105,7 +1114,7 @@ mod tests {
                 None,
             );
 
-            futures_util::pin_mut!(h1);
+            actix_rt::pin!(h1);
 
             assert!(matches!(&h1.inner, DispatcherState::Normal(_)));
 
@@ -1164,7 +1173,7 @@ mod tests {
                 ",
             );
 
-            futures_util::pin_mut!(h1);
+            actix_rt::pin!(h1);
 
             assert!(h1.as_mut().poll(cx).is_pending());
             assert!(matches!(&h1.inner, DispatcherState::Normal(_)));
@@ -1236,7 +1245,7 @@ mod tests {
                 ",
             );
 
-            futures_util::pin_mut!(h1);
+            actix_rt::pin!(h1);
 
             assert!(h1.as_mut().poll(cx).is_ready());
             assert!(matches!(&h1.inner, DispatcherState::Normal(_)));
@@ -1297,7 +1306,7 @@ mod tests {
                 ",
             );
 
-            futures_util::pin_mut!(h1);
+            actix_rt::pin!(h1);
 
             assert!(h1.as_mut().poll(cx).is_ready());
             assert!(matches!(&h1.inner, DispatcherState::Upgrade(_)));

actix-http/src/h1/encoder.rs

@@ -529,8 +529,8 @@ mod tests {
         );
     }
 
-    #[test]
+    #[actix_rt::test]
-    fn test_camel_case() {
+    async fn test_camel_case() {
         let mut bytes = BytesMut::with_capacity(2048);
         let mut head = RequestHead::default();
         head.set_camel_case_headers(true);
@@ -549,7 +549,6 @@ mod tests {
         );
         let data =
             String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
-        eprintln!("{}", &data);
 
         assert!(data.contains("Content-Length: 0\r\n"));
         assert!(data.contains("Connection: close\r\n"));
@@ -593,8 +592,8 @@ mod tests {
         assert!(data.contains("date: date\r\n"));
     }
 
-    #[test]
+    #[actix_rt::test]
-    fn test_extra_headers() {
+    async fn test_extra_headers() {
         let mut bytes = BytesMut::with_capacity(2048);
 
         let mut head = RequestHead::default();
@@ -627,16 +626,15 @@ mod tests {
         assert!(data.contains("date: date\r\n"));
     }
 
-    #[test]
+    #[actix_rt::test]
-    fn test_no_content_length() {
+    async fn test_no_content_length() {
         let mut bytes = BytesMut::with_capacity(2048);
 
         let mut res: Response<()> =
             Response::new(StatusCode::SWITCHING_PROTOCOLS).into_body::<()>();
+        res.headers_mut().insert(DATE, HeaderValue::from_static(""));
         res.headers_mut()
-            .insert(DATE, HeaderValue::from_static(&""));
+            .insert(CONTENT_LENGTH, HeaderValue::from_static("0"));
-        res.headers_mut()
-            .insert(CONTENT_LENGTH, HeaderValue::from_static(&"0"));
 
         let _ = res.encode_headers(
             &mut bytes,

actix-http/src/h1/mod.rs

@@ -1,4 +1,4 @@
-//! HTTP/1 implementation
+//! HTTP/1 protocol implementation.
 use bytes::{Bytes, BytesMut};
 
 mod client;

actix-http/src/h1/payload.rs

@@ -3,9 +3,8 @@ use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::pin::Pin;
 use std::rc::{Rc, Weak};
-use std::task::{Context, Poll};
+use std::task::{Context, Poll, Waker};
 
-use actix_utils::task::LocalWaker;
 use bytes::Bytes;
 use futures_core::Stream;
 
@@ -134,7 +133,7 @@ impl PayloadSender {
             if shared.borrow().need_read {
                 PayloadStatus::Read
             } else {
-                shared.borrow_mut().io_task.register(cx.waker());
+                shared.borrow_mut().register_io(cx);
                 PayloadStatus::Pause
             }
         } else {
@@ -150,8 +149,8 @@ struct Inner {
     err: Option<PayloadError>,
     need_read: bool,
     items: VecDeque<Bytes>,
-    task: LocalWaker,
+    task: Option<Waker>,
-    io_task: LocalWaker,
+    io_task: Option<Waker>,
 }
 
 impl Inner {
@@ -162,8 +161,48 @@ impl Inner {
             err: None,
             items: VecDeque::new(),
             need_read: true,
-            task: LocalWaker::new(),
+            task: None,
-            io_task: LocalWaker::new(),
+            io_task: None,
+        }
+    }
+
+    /// Wake up future waiting for payload data to be available.
+    fn wake(&mut self) {
+        if let Some(waker) = self.task.take() {
+            waker.wake();
+        }
+    }
+
+    /// Wake up future feeding data to Payload.
+    fn wake_io(&mut self) {
+        if let Some(waker) = self.io_task.take() {
+            waker.wake();
+        }
+    }
+
+    /// Register future waiting data from payload.
+    /// Waker would be used in `Inner::wake`
+    fn register(&mut self, cx: &mut Context<'_>) {
+        if self
+            .task
+            .as_ref()
+            .map(|w| !cx.waker().will_wake(w))
+            .unwrap_or(true)
+        {
+            self.task = Some(cx.waker().clone());
+        }
+    }
+
+    // Register future feeding data to payload.
+    /// Waker would be used in `Inner::wake_io`
+    fn register_io(&mut self, cx: &mut Context<'_>) {
+        if self
+            .io_task
+            .as_ref()
+            .map(|w| !cx.waker().will_wake(w))
+            .unwrap_or(true)
+        {
+            self.io_task = Some(cx.waker().clone());
         }
     }
 
@@ -182,7 +221,7 @@ impl Inner {
         self.len += data.len();
         self.items.push_back(data);
         self.need_read = self.len < MAX_BUFFER_SIZE;
-        self.task.wake();
+        self.wake();
     }
 
     #[cfg(test)]
@@ -199,9 +238,9 @@ impl Inner {
             self.need_read = self.len < MAX_BUFFER_SIZE;
 
             if self.need_read && !self.eof {
-                self.task.register(cx.waker());
+                self.register(cx);
             }
-            self.io_task.wake();
+            self.wake_io();
             Poll::Ready(Some(Ok(data)))
         } else if let Some(err) = self.err.take() {
             Poll::Ready(Some(Err(err)))
@@ -209,8 +248,8 @@ impl Inner {
             Poll::Ready(None)
         } else {
             self.need_read = true;
-            self.task.register(cx.waker());
+            self.register(cx);
-            self.io_task.wake();
+            self.wake_io();
             Poll::Pending
         }
     }

actix-http/src/h1/service.rs

@@ -94,10 +94,10 @@ mod openssl {
     use super::*;
 
     use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, SslStream};
+    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, TlsStream};
     use actix_tls::accept::TlsError;
 
-    impl<S, B, X, U> H1Service<SslStream<TcpStream>, S, B, X, U>
+    impl<S, B, X, U> H1Service<TlsStream<TcpStream>, S, B, X, U>
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Error: Into<Error>,
@@ -108,7 +108,7 @@ mod openssl {
         X::Error: Into<Error>,
         X::InitError: fmt::Debug,
         U: ServiceFactory<
-            (Request, Framed<SslStream<TcpStream>, Codec>),
+            (Request, Framed<TlsStream<TcpStream>, Codec>),
             Config = (),
             Response = (),
         >,
@@ -131,7 +131,7 @@ mod openssl {
                     .map_err(TlsError::Tls)
                     .map_init_err(|_| panic!()),
             )
-            .and_then(|io: SslStream<TcpStream>| {
+            .and_then(|io: TlsStream<TcpStream>| {
                 let peer_addr = io.get_ref().peer_addr().ok();
                 ready(Ok((io, peer_addr)))
             })

actix-http/src/h2/dispatcher.rs

@@ -1,13 +1,7 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::net;
-use std::pin::Pin;
-use std::rc::Rc;
 use std::task::{Context, Poll};
-use std::{cmp, convert::TryFrom};
+use std::{cmp, future::Future, marker::PhantomData, net, pin::Pin, rc::Rc};
 
 use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::time::{Instant, Sleep};
 use actix_service::Service;
 use bytes::{Bytes, BytesMut};
 use futures_core::ready;
@@ -41,8 +35,6 @@ where
     on_connect_data: OnConnectData,
     config: ServiceConfig,
     peer_addr: Option<net::SocketAddr>,
-    ka_expire: Instant,
-    ka_timer: Option<Sleep>,
     _phantom: PhantomData<B>,
 }
 
@@ -59,33 +51,14 @@ where
         connection: Connection<T, Bytes>,
         on_connect_data: OnConnectData,
         config: ServiceConfig,
-        timeout: Option<Sleep>,
         peer_addr: Option<net::SocketAddr>,
     ) -> Self {
-        // let keepalive = config.keep_alive_enabled();
-        // let flags = if keepalive {
-        // Flags::KEEPALIVE | Flags::KEEPALIVE_ENABLED
-        // } else {
-        //     Flags::empty()
-        // };
-
-        // keep-alive timer
-        let (ka_expire, ka_timer) = if let Some(delay) = timeout {
-            (delay.deadline(), Some(delay))
-        } else if let Some(delay) = config.keep_alive_timer() {
-            (delay.deadline(), Some(delay))
-        } else {
-            (config.now(), None)
-        };
-
         Dispatcher {
             flow,
             config,
             peer_addr,
             connection,
             on_connect_data,
-            ka_expire,
-            ka_timer,
             _phantom: PhantomData,
         }
     }
@@ -113,19 +86,12 @@ where
                 Some(Err(err)) => return Poll::Ready(Err(err.into())),
 
                 Some(Ok((req, res))) => {
-                    // update keep-alive expire
-                    if this.ka_timer.is_some() {
-                        if let Some(expire) = this.config.keep_alive_expire() {
-                            this.ka_expire = expire;
-                        }
-                    }
-
                     let (parts, body) = req.into_parts();
                     let pl = crate::h2::Payload::new(body);
                     let pl = Payload::<crate::payload::PayloadStream>::H2(pl);
                     let mut req = Request::with_payload(pl);
 
-                    let head = &mut req.head_mut();
+                    let head = req.head_mut();
                     head.uri = parts.uri;
                     head.method = parts.method;
                     head.version = parts.version;
@@ -135,7 +101,7 @@ where
                     // merge on_connect_ext data into request extensions
                     this.on_connect_data.merge_into(&mut req);
 
-                    let svc = ServiceResponse::<S::Future, S::Response, S::Error, B> {
+                    let svc = ServiceResponse {
                         state: ServiceResponseState::ServiceCall(
                             this.flow.service.call(req),
                             Some(res),
@@ -203,16 +169,22 @@ where
             BodySize::Empty => res
                 .headers_mut()
                 .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
-            BodySize::Sized(len) => res.headers_mut().insert(
+            BodySize::Sized(len) => {
-                CONTENT_LENGTH,
+                let mut buf = itoa::Buffer::new();
-                HeaderValue::try_from(format!("{}", len)).unwrap(),
+
-            ),
+                res.headers_mut().insert(
+                    CONTENT_LENGTH,
+                    HeaderValue::from_str(buf.format(*len)).unwrap(),
+                )
+            }
         };
 
         // copy headers
         for (key, value) in head.headers.iter() {
             match *key {
-                // omit HTTP/1 only headers
+                // TODO: consider skipping other headers according to:
+                //       https://tools.ietf.org/html/rfc7540#section-8.1.2.2
+                // omit HTTP/1.x only headers
                 CONNECTION | TRANSFER_ENCODING => continue,
                 CONTENT_LENGTH if skip_len => continue,
                 DATE => has_date = true,
@@ -311,57 +283,50 @@ where
 
             ServiceResponseStateProj::SendPayload(ref mut stream, ref mut body) => {
                 loop {
-                    loop {
+                    match this.buffer {
-                        match this.buffer {
+                        Some(ref mut buffer) => match ready!(stream.poll_capacity(cx)) {
-                            Some(ref mut buffer) => {
+                            None => return Poll::Ready(()),
-                                match ready!(stream.poll_capacity(cx)) {
-                                    None => return Poll::Ready(()),
 
-                                    Some(Ok(cap)) => {
+                            Some(Ok(cap)) => {
-                                        let len = buffer.len();
+                                let len = buffer.len();
-                                        let bytes = buffer.split_to(cmp::min(cap, len));
+                                let bytes = buffer.split_to(cmp::min(cap, len));
 
-                                        if let Err(e) = stream.send_data(bytes, false) {
+                                if let Err(e) = stream.send_data(bytes, false) {
-                                            warn!("{:?}", e);
+                                    warn!("{:?}", e);
-                                            return Poll::Ready(());
+                                    return Poll::Ready(());
-                                        } else if !buffer.is_empty() {
+                                } else if !buffer.is_empty() {
-                                            let cap = cmp::min(buffer.len(), CHUNK_SIZE);
+                                    let cap = cmp::min(buffer.len(), CHUNK_SIZE);
-                                            stream.reserve_capacity(cap);
+                                    stream.reserve_capacity(cap);
-                                        } else {
+                                } else {
-                                            this.buffer.take();
+                                    this.buffer.take();
-                                        }
-                                    }
-
-                                    Some(Err(e)) => {
-                                        warn!("{:?}", e);
-                                        return Poll::Ready(());
-                                    }
                                 }
                             }
 
-                            None => match ready!(body.as_mut().poll_next(cx)) {
+                            Some(Err(e)) => {
-                                None => {
+                                warn!("{:?}", e);
-                                    if let Err(e) = stream.send_data(Bytes::new(), true)
+                                return Poll::Ready(());
-                                    {
+                            }
-                                        warn!("{:?}", e);
+                        },
-                                    }
-                                    return Poll::Ready(());
-                                }
 
-                                Some(Ok(chunk)) => {
+                        None => match ready!(body.as_mut().poll_next(cx)) {
-                                    stream.reserve_capacity(cmp::min(
+                            None => {
-                                        chunk.len(),
+                                if let Err(e) = stream.send_data(Bytes::new(), true) {
-                                        CHUNK_SIZE,
+                                    warn!("{:?}", e);
-                                    ));
-                                    *this.buffer = Some(chunk);
                                 }
+                                return Poll::Ready(());
+                            }
 
-                                Some(Err(e)) => {
+                            Some(Ok(chunk)) => {
-                                    error!("Response payload stream error: {:?}", e);
+                                stream
-                                    return Poll::Ready(());
+                                    .reserve_capacity(cmp::min(chunk.len(), CHUNK_SIZE));
-                                }
+                                *this.buffer = Some(chunk);
-                            },
+                            }
-                        }
+
+                            Some(Err(e)) => {
+                                error!("Response payload stream error: {:?}", e);
+                                return Poll::Ready(());
+                            }
+                        },
                     }
                 }
             }

actix-http/src/h2/mod.rs

@@ -1,4 +1,4 @@
-//! HTTP/2 implementation.
+//! HTTP/2 protocol.
 
 use std::{
     pin::Pin,

actix-http/src/h2/service.rs

@@ -93,12 +93,12 @@ where
 #[cfg(feature = "openssl")]
 mod openssl {
     use actix_service::{fn_factory, fn_service, ServiceFactoryExt};
-    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, SslStream};
+    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, TlsStream};
     use actix_tls::accept::TlsError;
 
     use super::*;
 
-    impl<S, B> H2Service<SslStream<TcpStream>, S, B>
+    impl<S, B> H2Service<TlsStream<TcpStream>, S, B>
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Error: Into<Error> + 'static,
@@ -123,7 +123,7 @@ mod openssl {
                     .map_init_err(|_| panic!()),
             )
             .and_then(fn_factory(|| {
-                ok::<_, S::InitError>(fn_service(|io: SslStream<TcpStream>| {
+                ok::<_, S::InitError>(fn_service(|io: TlsStream<TcpStream>| {
                     let peer_addr = io.get_ref().peer_addr().ok();
                     ok((io, peer_addr))
                 }))
@@ -243,7 +243,7 @@ where
     }
 }
 
-/// `Service` implementation for http/2 transport
+/// `Service` implementation for HTTP/2 transport
 pub struct H2ServiceHandler<T, S, B>
 where
     S: Service<Request>,
@@ -368,7 +368,6 @@ where
                         conn,
                         on_connect_data,
                         config.take().unwrap(),
-                        None,
                         *peer_addr,
                     ));
                     self.poll(cx)

actix-http/src/header/as_name.rs

@@ -1,4 +1,6 @@
 //! Helper trait for types that can be effectively borrowed as a [HeaderValue].
+//!
+//! [HeaderValue]: crate::http::HeaderValue
 
 use std::{borrow::Cow, str::FromStr};
 

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

@@ -6,7 +6,7 @@
 //! Browser conformance tests at: http://greenbytes.de/tech/tc2231/
 //! IANA assignment: http://www.iana.org/assignments/cont-disp/cont-disp.xhtml
 
-use lazy_static::lazy_static;
+use once_cell::sync::Lazy;
 use regex::Regex;
 use std::fmt::{self, Write};
 
@@ -520,9 +520,7 @@ impl fmt::Display for DispositionParam {
         //
         //
         // See also comments in test_from_raw_unnecessary_percent_decode.
-        lazy_static! {
+        static RE: Lazy<Regex> = Lazy::new(|| Regex::new("[\x00-\x08\x10-\x1F\x7F\"\\\\]").unwrap());
-            static ref RE: Regex = Regex::new("[\x00-\x08\x10-\x1F\x7F\"\\\\]").unwrap();
-        }
         match self {
             DispositionParam::Name(ref value) => write!(f, "name={}", value),
             DispositionParam::Filename(ref value) => {

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

@@ -5,7 +5,7 @@ use crate::header::{
     self, from_one_raw_str, EntityTag, Header, HeaderName, HeaderValue, HttpDate,
     IntoHeaderValue, InvalidHeaderValue, Writer,
 };
-use crate::httpmessage::HttpMessage;
+use crate::HttpMessage;
 
 /// `If-Range` header, defined in [RFC7233](http://tools.ietf.org/html/rfc7233#section-3.2)
 ///

actix-http/src/header/mod.rs

@@ -9,7 +9,7 @@ use percent_encoding::{AsciiSet, CONTROLS};
 pub use http::header::*;
 
 use crate::error::ParseError;
-use crate::httpmessage::HttpMessage;
+use crate::HttpMessage;
 
 mod as_name;
 mod into_pair;

actix-http/src/http_codes.rs

@@ -67,6 +67,14 @@ impl Response {
     static_resp!(ExpectationFailed, StatusCode::EXPECTATION_FAILED);
     static_resp!(UnprocessableEntity, StatusCode::UNPROCESSABLE_ENTITY);
     static_resp!(TooManyRequests, StatusCode::TOO_MANY_REQUESTS);
+    static_resp!(
+        RequestHeaderFieldsTooLarge,
+        StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE
+    );
+    static_resp!(
+        UnavailableForLegalReasons,
+        StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS
+    );
 
     static_resp!(InternalServerError, StatusCode::INTERNAL_SERVER_ERROR);
     static_resp!(NotImplemented, StatusCode::NOT_IMPLEMENTED);

actix-http/src/http_message.rs

@@ -5,12 +5,14 @@ use encoding_rs::{Encoding, UTF_8};
 use http::header;
 use mime::Mime;
 
-use crate::cookie::Cookie;
+use crate::error::{ContentTypeError, ParseError};
-use crate::error::{ContentTypeError, CookieParseError, ParseError};
 use crate::extensions::Extensions;
 use crate::header::{Header, HeaderMap};
 use crate::payload::Payload;
+#[cfg(feature = "cookies")]
+use crate::{cookie::Cookie, error::CookieParseError};
 
+#[cfg(feature = "cookies")]
 struct Cookies(Vec<Cookie<'static>>);
 
 /// Trait that implements general purpose operations on HTTP messages.
@@ -104,7 +106,7 @@ pub trait HttpMessage: Sized {
     }
 
     /// Load request cookies.
-    #[inline]
+    #[cfg(feature = "cookies")]
     fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, CookieParseError> {
         if self.extensions().get::<Cookies>().is_none() {
             let mut cookies = Vec::new();
@@ -119,12 +121,14 @@ pub trait HttpMessage: Sized {
             }
             self.extensions_mut().insert(Cookies(cookies));
         }
+
         Ok(Ref::map(self.extensions(), |ext| {
             &ext.get::<Cookies>().unwrap().0
         }))
     }
 
     /// Return request cookie.
+    #[cfg(feature = "cookies")]
     fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
         if let Ok(cookies) = self.cookies() {
             for cookie in cookies.iter() {

actix-http/src/lib.rs

@@ -1,6 +1,21 @@
 //! HTTP primitives for the Actix ecosystem.
+//!
+//! ## Crate Features
+//! | Feature          | Functionality                                         |
+//! | ---------------- | ----------------------------------------------------- |
+//! | `openssl`        | TLS support via [OpenSSL].                            |
+//! | `rustls`         | TLS support via [rustls].                             |
+//! | `compress`       | Payload compression support. (Deflate, Gzip & Brotli) |
+//! | `cookies`        | Support for cookies backed by the [cookie] crate.     |
+//! | `secure-cookies` | Adds for secure cookies. Enables `cookies` feature.   |
+//! | `trust-dns`      | Use [trust-dns] as the client DNS resolver.           |
+//!
+//! [OpenSSL]: https://crates.io/crates/openssl
+//! [rustls]: https://crates.io/crates/rustls
+//! [cookie]: https://crates.io/crates/cookie
+//! [trust-dns]: https://crates.io/crates/trust-dns
 
-#![deny(rust_2018_idioms)]
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![allow(
     clippy::type_complexity,
     clippy::too_many_arguments,
@@ -25,8 +40,8 @@ pub mod encoding;
 mod extensions;
 mod header;
 mod helpers;
-mod httpcodes;
+mod http_codes;
-pub mod httpmessage;
+mod http_message;
 mod message;
 mod payload;
 mod request;
@@ -34,18 +49,20 @@ mod response;
 mod service;
 mod time_parser;
 
-pub use cookie;
 pub mod error;
 pub mod h1;
 pub mod h2;
 pub mod test;
 pub mod ws;
 
+#[cfg(feature = "cookies")]
+pub use cookie;
+
 pub use self::builder::HttpServiceBuilder;
 pub use self::config::{KeepAlive, ServiceConfig};
 pub use self::error::{Error, ResponseError, Result};
 pub use self::extensions::Extensions;
-pub use self::httpmessage::HttpMessage;
+pub use self::http_message::HttpMessage;
 pub use self::message::{Message, RequestHead, RequestHeadType, ResponseHead};
 pub use self::payload::{Payload, PayloadStream};
 pub use self::request::Request;
@@ -61,6 +78,7 @@ pub mod http {
     pub use http::{uri, Error, Uri};
     pub use http::{Method, StatusCode, Version};
 
+    #[cfg(feature = "cookies")]
     pub use crate::cookie::{Cookie, CookieBuilder};
     pub use crate::header::HeaderMap;
 

actix-http/src/message.rs

@@ -13,8 +13,10 @@ use crate::http::{header, Method, StatusCode, Uri, Version};
 pub enum ConnectionType {
     /// Close connection after response
     Close,
+
     /// Keep connection alive after response
     KeepAlive,
+
     /// Connection is upgraded to different type
     Upgrade,
 }

actix-http/src/request.rs

@@ -9,9 +9,9 @@ use http::{header, Method, Uri, Version};
 
 use crate::extensions::Extensions;
 use crate::header::HeaderMap;
-use crate::httpmessage::HttpMessage;
 use crate::message::{Message, RequestHead};
 use crate::payload::{Payload, PayloadStream};
+use crate::HttpMessage;
 
 /// Request
 pub struct Request<P = PayloadStream> {
@@ -107,7 +107,7 @@ impl<P> Request<P> {
 
     #[inline]
     #[doc(hidden)]
-    /// Mutable reference to a http message part of the request
+    /// Mutable reference to a HTTP message part of the request
     pub fn head_mut(&mut self) -> &mut RequestHead {
         &mut *self.head
     }
@@ -158,10 +158,12 @@ impl<P> Request<P> {
         self.head().method == Method::CONNECT
     }
 
-    /// Peer socket address
+    /// Peer socket address.
     ///
-    /// Peer address is actual socket address, if proxy is used in front of
+    /// Peer address is the directly connected peer's socket address. If a proxy is used in front of
-    /// actix http server, then peer address would be address of this proxy.
+    /// the Actix Web server, then it would be address of this proxy.
+    ///
+    /// Will only return None when called in unit tests.
     #[inline]
     pub fn peer_addr(&self) -> Option<net::SocketAddr> {
         self.head().peer_addr

actix-http/src/response.rs

@@ -5,7 +5,6 @@ use std::{
     convert::TryInto,
     fmt,
     future::Future,
-    ops,
     pin::Pin,
     str,
     task::{Context, Poll},
@@ -16,13 +15,17 @@ use futures_core::Stream;
 use serde::Serialize;
 
 use crate::body::{Body, BodyStream, MessageBody, ResponseBody};
-use crate::cookie::{Cookie, CookieJar};
 use crate::error::Error;
 use crate::extensions::Extensions;
 use crate::header::{IntoHeaderPair, IntoHeaderValue};
-use crate::http::header::{self, HeaderName, HeaderValue};
+use crate::http::header::{self, HeaderName};
 use crate::http::{Error as HttpError, HeaderMap, StatusCode};
 use crate::message::{BoxedResponseHead, ConnectionType, ResponseHead};
+#[cfg(feature = "cookies")]
+use crate::{
+    cookie::{Cookie, CookieJar},
+    http::header::HeaderValue,
+};
 
 /// An HTTP Response
 pub struct Response<B = Body> {
@@ -32,13 +35,13 @@ pub struct Response<B = Body> {
 }
 
 impl Response<Body> {
-    /// Create http response builder with specific status.
+    /// Create HTTP response builder with specific status.
     #[inline]
     pub fn build(status: StatusCode) -> ResponseBuilder {
         ResponseBuilder::new(status)
     }
 
-    /// Create http response builder
+    /// Create HTTP response builder
     #[inline]
     pub fn build_from<T: Into<ResponseBuilder>>(source: T) -> ResponseBuilder {
         source.into()
@@ -97,7 +100,7 @@ impl<B> Response<B> {
     }
 
     #[inline]
-    /// Mutable reference to a http message part of the response
+    /// Mutable reference to a HTTP message part of the response
     pub fn head_mut(&mut self) -> &mut ResponseHead {
         &mut *self.head
     }
@@ -133,6 +136,7 @@ impl<B> Response<B> {
     }
 
     /// Get an iterator for the cookies set by this response
+    #[cfg(feature = "cookies")]
     #[inline]
     pub fn cookies(&self) -> CookieIter<'_> {
         CookieIter {
@@ -141,6 +145,7 @@ impl<B> Response<B> {
     }
 
     /// Add a cookie to this response
+    #[cfg(feature = "cookies")]
     #[inline]
     pub fn add_cookie(&mut self, cookie: &Cookie<'_>) -> Result<(), HttpError> {
         let h = &mut self.head.headers;
@@ -153,6 +158,7 @@ impl<B> Response<B> {
 
     /// Remove all cookies with the given name from this response. Returns
     /// the number of cookies removed.
+    #[cfg(feature = "cookies")]
     #[inline]
     pub fn del_cookie(&mut self, name: &str) -> usize {
         let h = &mut self.head.headers;
@@ -298,10 +304,12 @@ impl Future for Response {
     }
 }
 
+#[cfg(feature = "cookies")]
 pub struct CookieIter<'a> {
     iter: header::GetAll<'a>,
 }
 
+#[cfg(feature = "cookies")]
 impl<'a> Iterator for CookieIter<'a> {
     type Item = Cookie<'a>;
 
@@ -316,13 +324,13 @@ impl<'a> Iterator for CookieIter<'a> {
     }
 }
 
-/// An HTTP response builder
+/// An HTTP response builder.
 ///
-/// This type can be used to construct an instance of `Response` through a
+/// This type can be used to construct an instance of `Response` through a builder-like pattern.
-/// builder-like pattern.
 pub struct ResponseBuilder {
     head: Option<BoxedResponseHead>,
     err: Option<HttpError>,
+    #[cfg(feature = "cookies")]
     cookies: Option<CookieJar>,
 }
 
@@ -333,6 +341,7 @@ impl ResponseBuilder {
         ResponseBuilder {
             head: Some(BoxedResponseHead::new(status)),
             err: None,
+            #[cfg(feature = "cookies")]
             cookies: None,
         }
     }
@@ -488,7 +497,8 @@ impl ResponseBuilder {
     /// Disable chunked transfer encoding for HTTP/1.1 streaming responses.
     #[inline]
     pub fn no_chunking(&mut self, len: u64) -> &mut Self {
-        self.insert_header((header::CONTENT_LENGTH, len));
+        let mut buf = itoa::Buffer::new();
+        self.insert_header((header::CONTENT_LENGTH, buf.format(len)));
 
         if let Some(parts) = parts(&mut self.head, &self.err) {
             parts.no_chunking(true);
@@ -531,6 +541,7 @@ impl ResponseBuilder {
     ///         .finish()
     /// }
     /// ```
+    #[cfg(feature = "cookies")]
     pub fn cookie<'c>(&mut self, cookie: Cookie<'c>) -> &mut Self {
         if self.cookies.is_none() {
             let mut jar = CookieJar::new();
@@ -557,6 +568,7 @@ impl ResponseBuilder {
     ///     builder.finish()
     /// }
     /// ```
+    #[cfg(feature = "cookies")]
     pub fn del_cookie<'a>(&mut self, cookie: &Cookie<'a>) -> &mut Self {
         if self.cookies.is_none() {
             self.cookies = Some(CookieJar::new())
@@ -624,8 +636,11 @@ impl ResponseBuilder {
             return Response::from(Error::from(e)).into_body();
         }
 
+        // allow unused mut when cookies feature is disabled
+        #[allow(unused_mut)]
         let mut response = self.head.take().expect("cannot reuse response builder");
 
+        #[cfg(feature = "cookies")]
         if let Some(ref jar) = self.cookies {
             for cookie in jar.delta() {
                 match HeaderValue::from_str(&cookie.to_string()) {
@@ -657,12 +672,8 @@ impl ResponseBuilder {
     /// Set a json body and generate `Response`
     ///
     /// `ResponseBuilder` can not be used after this call.
-    pub fn json<T>(&mut self, value: T) -> Response
+    pub fn json(&mut self, value: impl Serialize) -> Response {
-    where
+        match serde_json::to_string(&value) {
-        T: ops::Deref,
-        T::Target: Serialize,
-    {
-        match serde_json::to_string(&*value) {
             Ok(body) => {
                 let contains = if let Some(parts) = parts(&mut self.head, &self.err) {
                     parts.headers.contains_key(header::CONTENT_TYPE)
@@ -693,6 +704,7 @@ impl ResponseBuilder {
         ResponseBuilder {
             head: self.head.take(),
             err: self.err.take(),
+            #[cfg(feature = "cookies")]
             cookies: self.cookies.take(),
         }
     }
@@ -712,21 +724,28 @@ fn parts<'a>(
 /// Convert `Response` to a `ResponseBuilder`. Body get dropped.
 impl<B> From<Response<B>> for ResponseBuilder {
     fn from(res: Response<B>) -> ResponseBuilder {
-        // If this response has cookies, load them into a jar
+        #[cfg(feature = "cookies")]
-        let mut jar: Option<CookieJar> = None;
+        let jar = {
-        for c in res.cookies() {
+            // If this response has cookies, load them into a jar
-            if let Some(ref mut j) = jar {
+            let mut jar: Option<CookieJar> = None;
-                j.add_original(c.into_owned());
+
-            } else {
+            for c in res.cookies() {
-                let mut j = CookieJar::new();
+                if let Some(ref mut j) = jar {
-                j.add_original(c.into_owned());
+                    j.add_original(c.into_owned());
-                jar = Some(j);
+                } else {
+                    let mut j = CookieJar::new();
+                    j.add_original(c.into_owned());
+                    jar = Some(j);
+                }
             }
-        }
+
+            jar
+        };
 
         ResponseBuilder {
             head: Some(res.head),
             err: None,
+            #[cfg(feature = "cookies")]
             cookies: jar,
         }
     }
@@ -735,22 +754,6 @@ impl<B> From<Response<B>> for ResponseBuilder {
 /// Convert `ResponseHead` to a `ResponseBuilder`
 impl<'a> From<&'a ResponseHead> for ResponseBuilder {
     fn from(head: &'a ResponseHead) -> ResponseBuilder {
-        // If this response has cookies, load them into a jar
-        let mut jar: Option<CookieJar> = None;
-
-        let cookies = CookieIter {
-            iter: head.headers.get_all(header::SET_COOKIE),
-        };
-        for c in cookies {
-            if let Some(ref mut j) = jar {
-                j.add_original(c.into_owned());
-            } else {
-                let mut j = CookieJar::new();
-                j.add_original(c.into_owned());
-                jar = Some(j);
-            }
-        }
-
         let mut msg = BoxedResponseHead::new(head.status);
         msg.version = head.version;
         msg.reason = head.reason;
@@ -761,9 +764,32 @@ impl<'a> From<&'a ResponseHead> for ResponseBuilder {
 
         msg.no_chunking(!head.chunked());
 
+        #[cfg(feature = "cookies")]
+        let jar = {
+            // If this response has cookies, load them into a jar
+            let mut jar: Option<CookieJar> = None;
+
+            let cookies = CookieIter {
+                iter: head.headers.get_all(header::SET_COOKIE),
+            };
+
+            for c in cookies {
+                if let Some(ref mut j) = jar {
+                    j.add_original(c.into_owned());
+                } else {
+                    let mut j = CookieJar::new();
+                    j.add_original(c.into_owned());
+                    jar = Some(j);
+                }
+            }
+
+            jar
+        };
+
         ResponseBuilder {
             head: Some(msg),
             err: None,
+            #[cfg(feature = "cookies")]
             cookies: jar,
         }
     }
@@ -866,7 +892,9 @@ mod tests {
 
     use super::*;
     use crate::body::Body;
-    use crate::http::header::{HeaderValue, CONTENT_TYPE, COOKIE, SET_COOKIE};
+    use crate::http::header::{HeaderValue, CONTENT_TYPE, COOKIE};
+    #[cfg(feature = "cookies")]
+    use crate::{http::header::SET_COOKIE, HttpMessage};
 
     #[test]
     fn test_debug() {
@@ -878,10 +906,9 @@ mod tests {
         assert!(dbg.contains("Response"));
     }
 
+    #[cfg(feature = "cookies")]
     #[test]
     fn test_response_cookies() {
-        use crate::httpmessage::HttpMessage;
-
         let req = crate::test::TestRequest::default()
             .append_header((COOKIE, "cookie1=value1"))
             .append_header((COOKIE, "cookie2=value2"))
@@ -917,6 +944,7 @@ mod tests {
         );
     }
 
+    #[cfg(feature = "cookies")]
     #[test]
     fn test_update_response_cookies() {
         let mut r = Response::Ok()
@@ -974,7 +1002,12 @@ mod tests {
 
     #[test]
     fn test_json() {
-        let resp = Response::build(StatusCode::OK).json(vec!["v1", "v2", "v3"]);
+        let resp = Response::Ok().json(vec!["v1", "v2", "v3"]);
+        let ct = resp.headers().get(CONTENT_TYPE).unwrap();
+        assert_eq!(ct, HeaderValue::from_static("application/json"));
+        assert_eq!(resp.body().get_ref(), b"[\"v1\",\"v2\",\"v3\"]");
+
+        let resp = Response::Ok().json(&["v1", "v2", "v3"]);
         let ct = resp.headers().get(CONTENT_TYPE).unwrap();
         assert_eq!(ct, HeaderValue::from_static("application/json"));
         assert_eq!(resp.body().get_ref(), b"[\"v1\",\"v2\",\"v3\"]");
@@ -1068,6 +1101,7 @@ mod tests {
         assert_eq!(resp.body().get_ref(), b"test");
     }
 
+    #[cfg(feature = "cookies")]
     #[test]
     fn test_into_builder() {
         let mut resp: Response = "test".into();

actix-http/src/service.rs

@@ -185,10 +185,10 @@ where
 mod openssl {
     use super::*;
     use actix_service::ServiceFactoryExt;
-    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, SslStream};
+    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, TlsStream};
     use actix_tls::accept::TlsError;
 
-    impl<S, B, X, U> HttpService<SslStream<TcpStream>, S, B, X, U>
+    impl<S, B, X, U> HttpService<TlsStream<TcpStream>, S, B, X, U>
     where
         S: ServiceFactory<Request, Config = ()>,
         S::Error: Into<Error> + 'static,
@@ -201,13 +201,13 @@ mod openssl {
         X::InitError: fmt::Debug,
         <X::Service as Service<Request>>::Future: 'static,
         U: ServiceFactory<
-            (Request, Framed<SslStream<TcpStream>, h1::Codec>),
+            (Request, Framed<TlsStream<TcpStream>, h1::Codec>),
             Config = (),
             Response = (),
         >,
         U::Error: fmt::Display + Into<Error>,
         U::InitError: fmt::Debug,
-        <U::Service as Service<(Request, Framed<SslStream<TcpStream>, h1::Codec>)>>::Future: 'static,
+        <U::Service as Service<(Request, Framed<TlsStream<TcpStream>, h1::Codec>)>>::Future: 'static,
     {
         /// Create openssl based service
         pub fn openssl(
@@ -225,7 +225,7 @@ mod openssl {
                     .map_err(TlsError::Tls)
                     .map_init_err(|_| panic!()),
             )
-            .and_then(|io: SslStream<TcpStream>| async {
+            .and_then(|io: TlsStream<TcpStream>| async {
                 let proto = if let Some(protos) = io.ssl().selected_alpn_protocol() {
                     if protos.windows(2).any(|window| window == b"h2") {
                         Protocol::Http2
@@ -432,7 +432,7 @@ where
     }
 }
 
-/// `Service` implementation for http transport
+/// `Service` implementation for HTTP transport
 pub struct HttpServiceHandler<T, S, B, X, U>
 where
     S: Service<Request>,
@@ -658,7 +658,6 @@ where
                             conn,
                             on_connect_data,
                             cfg,
-                            None,
                             peer_addr,
                         )));
                         self.poll(cx)

actix-http/src/test.rs

@@ -11,13 +11,14 @@ use std::{
 
 use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
 use bytes::{Bytes, BytesMut};
-use http::{
+use http::{Method, Uri, Version};
-    header::{self, HeaderValue},
-    Method, Uri, Version,
-};
 
+#[cfg(feature = "cookies")]
 use crate::{
     cookie::{Cookie, CookieJar},
+    header::{self, HeaderValue},
+};
+use crate::{
     header::{HeaderMap, IntoHeaderPair},
     payload::Payload,
     Request,
@@ -53,6 +54,7 @@ struct Inner {
     method: Method,
     uri: Uri,
     headers: HeaderMap,
+    #[cfg(feature = "cookies")]
     cookies: CookieJar,
     payload: Option<Payload>,
 }
@@ -64,6 +66,7 @@ impl Default for TestRequest {
             uri: Uri::from_str("/").unwrap(),
             version: Version::HTTP_11,
             headers: HeaderMap::new(),
+            #[cfg(feature = "cookies")]
             cookies: CookieJar::new(),
             payload: None,
         }))
@@ -132,6 +135,7 @@ impl TestRequest {
     }
 
     /// Set cookie for this request.
+    #[cfg(feature = "cookies")]
     pub fn cookie<'a>(&mut self, cookie: Cookie<'a>) -> &mut Self {
         parts(&mut self.0).cookies.add(cookie.into_owned());
         self
@@ -165,17 +169,20 @@ impl TestRequest {
         head.version = inner.version;
         head.headers = inner.headers;
 
-        let cookie: String = inner
+        #[cfg(feature = "cookies")]
-            .cookies
+        {
-            .delta()
+            let cookie: String = inner
-            // ensure only name=value is written to cookie header
+                .cookies
-            .map(|c| Cookie::new(c.name(), c.value()).encoded().to_string())
+                .delta()
-            .collect::<Vec<_>>()
+                // ensure only name=value is written to cookie header
-            .join("; ");
+                .map(|c| Cookie::new(c.name(), c.value()).encoded().to_string())
+                .collect::<Vec<_>>()
+                .join("; ");
 
-        if !cookie.is_empty() {
+            if !cookie.is_empty() {
-            head.headers
+                head.headers
-                .insert(header::COOKIE, HeaderValue::from_str(&cookie).unwrap());
+                    .insert(header::COOKIE, HeaderValue::from_str(&cookie).unwrap());
+            }
         }
 
         req

actix-http/src/time_parser.rs

@@ -8,35 +8,65 @@ pub fn parse_http_date(time: &str) -> Option<PrimitiveDateTime> {
 }
 
 /// Attempt to parse a `time` string as a RFC 1123 formatted date time string.
+///
+/// Eg: `Fri, 12 Feb 2021 00:14:29 GMT`
 fn try_parse_rfc_1123(time: &str) -> Option<PrimitiveDateTime> {
     time::parse(time, "%a, %d %b %Y %H:%M:%S").ok()
 }
 
 /// Attempt to parse a `time` string as a RFC 850 formatted date time string.
+///
+/// Eg: `Wednesday, 11-Jan-21 13:37:41 UTC`
 fn try_parse_rfc_850(time: &str) -> Option<PrimitiveDateTime> {
-    match PrimitiveDateTime::parse(time, "%A, %d-%b-%y %H:%M:%S") {
+    let dt = PrimitiveDateTime::parse(time, "%A, %d-%b-%y %H:%M:%S").ok()?;
-        Ok(dt) => {
-            // 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_utc();
-            let century_start_year = (now.year() / 100) * 100;
-            let mut expanded_year = century_start_year + dt.year();
 
-            if expanded_year > now.year() + 50 {
+    // If the `time` string contains a two-digit year, then as per RFC 2616 § 19.3,
-                expanded_year -= 100;
+    // 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.
 
-            match Date::try_from_ymd(expanded_year, dt.month(), dt.day()) {
+    let now = OffsetDateTime::now_utc();
-                Ok(date) => Some(PrimitiveDateTime::new(date, dt.time())),
+    let century_start_year = (now.year() / 100) * 100;
-                Err(_) => None,
+    let mut expanded_year = century_start_year + dt.year();
-            }
+
-        }
+    if expanded_year > now.year() + 50 {
-        Err(_) => None,
+        expanded_year -= 100;
     }
+
+    let date = Date::try_from_ymd(expanded_year, dt.month(), dt.day()).ok()?;
+    Some(PrimitiveDateTime::new(date, dt.time()))
 }
 
 /// Attempt to parse a `time` string using ANSI C's `asctime` format.
+///
+/// Eg: `Wed Feb 13 15:46:11 2013`
 fn try_parse_asctime(time: &str) -> Option<PrimitiveDateTime> {
     time::parse(time, "%a %b %_d %H:%M:%S %Y").ok()
 }
+
+#[cfg(test)]
+mod tests {
+    use time::{date, time};
+
+    use super::*;
+
+    #[test]
+    fn test_rfc_850_year_shift() {
+        let date = try_parse_rfc_850("Friday, 19-Nov-82 16:14:55 EST").unwrap();
+        assert_eq!(date, date!(1982 - 11 - 19).with_time(time!(16:14:55)));
+
+        let date = try_parse_rfc_850("Wednesday, 11-Jan-62 13:37:41 EST").unwrap();
+        assert_eq!(date, date!(2062 - 01 - 11).with_time(time!(13:37:41)));
+
+        let date = try_parse_rfc_850("Wednesday, 11-Jan-21 13:37:41 EST").unwrap();
+        assert_eq!(date, date!(2021 - 01 - 11).with_time(time!(13:37:41)));
+
+        let date = try_parse_rfc_850("Wednesday, 11-Jan-23 13:37:41 EST").unwrap();
+        assert_eq!(date, date!(2023 - 01 - 11).with_time(time!(13:37:41)));
+
+        let date = try_parse_rfc_850("Wednesday, 11-Jan-99 13:37:41 EST").unwrap();
+        assert_eq!(date, date!(1999 - 01 - 11).with_time(time!(13:37:41)));
+
+        let date = try_parse_rfc_850("Wednesday, 11-Jan-00 13:37:41 EST").unwrap();
+        assert_eq!(date, date!(2000 - 01 - 11).with_time(time!(13:37:41)));
+    }
+}

actix-http/src/ws/codec.rs

@@ -54,7 +54,7 @@ pub enum Frame {
     Close(Option<CloseReason>),
 }
 
-/// A `WebSocket` continuation item.
+/// A WebSocket continuation item.
 #[derive(Debug, PartialEq)]
 pub enum Item {
     FirstText(Bytes),
@@ -79,8 +79,8 @@ bitflags! {
 }
 
 impl Codec {
-    /// Create new websocket frames decoder.
+    /// Create new WebSocket frames decoder.
-    pub fn new() -> Codec {
+    pub const fn new() -> Codec {
         Codec {
             max_size: 65_536,
             flags: Flags::SERVER,

actix-http/src/ws/frame.rs

@@ -7,7 +7,7 @@ use crate::ws::mask::apply_mask;
 use crate::ws::proto::{CloseCode, CloseReason, OpCode};
 use crate::ws::ProtocolError;
 
-/// A struct representing a `WebSocket` frame.
+/// A struct representing a WebSocket frame.
 #[derive(Debug)]
 pub struct Parser;
 
@@ -16,7 +16,8 @@ impl Parser {
         src: &[u8],
         server: bool,
         max_size: usize,
-    ) -> Result<Option<(usize, bool, OpCode, usize, Option<u32>)>, ProtocolError> {
+    ) -> Result<Option<(usize, bool, OpCode, usize, Option<[u8; 4]>)>, ProtocolError>
+    {
         let chunk_len = src.len();
 
         let mut idx = 2;
@@ -77,9 +78,10 @@ impl Parser {
                 return Ok(None);
             }
 
-            let mask =
+            let mask = TryFrom::try_from(&src[idx..idx + 4]).unwrap();
-                u32::from_le_bytes(TryFrom::try_from(&src[idx..idx + 4]).unwrap());
+
             idx += 4;
+
             Some(mask)
         } else {
             None
@@ -187,8 +189,8 @@ impl Parser {
         };
 
         if mask {
-            let mask = rand::random::<u32>();
+            let mask = rand::random::<[u8; 4]>();
-            dst.put_u32_le(mask);
+            dst.put_slice(mask.as_ref());
             dst.put_slice(payload.as_ref());
             let pos = dst.len() - payload_len;
             apply_mask(&mut dst[pos..], mask);

actix-http/src/ws/mask.rs

@@ -1,136 +1,57 @@
 //! This is code from [Tungstenite project](https://github.com/snapview/tungstenite-rs)
-#![allow(clippy::cast_ptr_alignment)]
-use std::ptr::copy_nonoverlapping;
-use std::slice;
 
-/// Holds a slice guaranteed to be shorter than 8 bytes.
+/// Mask/unmask a frame.
-struct ShortSlice<'a> {
-    inner: &'a mut [u8],
-}
-
-impl<'a> ShortSlice<'a> {
-    /// # Safety
-    /// Given slice must be shorter than 8 bytes.
-    unsafe fn new(slice: &'a mut [u8]) -> Self {
-        // Sanity check for debug builds
-        debug_assert!(slice.len() < 8);
-        ShortSlice { inner: slice }
-    }
-
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-/// Faster version of `apply_mask()` which operates on 8-byte blocks.
 #[inline]
-#[allow(clippy::cast_lossless)]
+pub fn apply_mask(buf: &mut [u8], mask: [u8; 4]) {
-pub(crate) fn apply_mask(buf: &mut [u8], mask_u32: u32) {
+    apply_mask_fast32(buf, mask)
-    // Extend the mask to 64 bits
+}
-    let mut mask_u64 = ((mask_u32 as u64) << 32) | (mask_u32 as u64);
-    // Split the buffer into three segments
-    let (head, mid, tail) = align_buf(buf);
 
-    // Initial unaligned segment
+/// A safe unoptimized mask application.
-    let head_len = head.len();
+#[inline]
-    if head_len > 0 {
+fn apply_mask_fallback(buf: &mut [u8], mask: [u8; 4]) {
-        xor_short(head, mask_u64);
+    for (i, byte) in buf.iter_mut().enumerate() {
+        *byte ^= mask[i & 3];
+    }
+}
+
+/// Faster version of `apply_mask()` which operates on 4-byte blocks.
+#[inline]
+pub fn apply_mask_fast32(buf: &mut [u8], mask: [u8; 4]) {
+    let mask_u32 = u32::from_ne_bytes(mask);
+
+    // SAFETY:
+    //
+    // buf is a valid slice borrowed mutably from bytes::BytesMut.
+    //
+    // un aligned prefix and suffix would be mask/unmask per byte.
+    // proper aligned middle slice goes into fast path and operates on 4-byte blocks.
+    let (mut prefix, words, mut suffix) = unsafe { buf.align_to_mut::<u32>() };
+    apply_mask_fallback(&mut prefix, mask);
+    let head = prefix.len() & 3;
+    let mask_u32 = if head > 0 {
         if cfg!(target_endian = "big") {
-            mask_u64 = mask_u64.rotate_left(8 * head_len as u32);
+            mask_u32.rotate_left(8 * head as u32)
         } else {
-            mask_u64 = mask_u64.rotate_right(8 * head_len as u32);
+            mask_u32.rotate_right(8 * head as u32)
-        }
-    }
-    // Aligned segment
-    for v in mid {
-        *v ^= mask_u64;
-    }
-    // Final unaligned segment
-    if tail.len() > 0 {
-        xor_short(tail, mask_u64);
-    }
-}
-
-// TODO: copy_nonoverlapping here compiles to call memcpy. While it is not so
-// inefficient, it could be done better. The compiler does not understand that
-// a `ShortSlice` must be smaller than a u64.
-#[inline]
-#[allow(clippy::needless_pass_by_value)]
-fn xor_short(buf: ShortSlice<'_>, mask: u64) {
-    // SAFETY: we know that a `ShortSlice` fits in a u64
-    unsafe {
-        let (ptr, len) = (buf.inner.as_mut_ptr(), buf.len());
-        let mut b: u64 = 0;
-        #[allow(trivial_casts)]
-        copy_nonoverlapping(ptr, &mut b as *mut _ as *mut u8, len);
-        b ^= mask;
-        #[allow(trivial_casts)]
-        copy_nonoverlapping(&b as *const _ as *const u8, ptr, len);
-    }
-}
-
-/// # Safety
-/// Caller must ensure the buffer has the correct size and alignment.
-#[inline]
-unsafe fn cast_slice(buf: &mut [u8]) -> &mut [u64] {
-    // Assert correct size and alignment in debug builds
-    debug_assert!(buf.len().trailing_zeros() >= 3);
-    debug_assert!((buf.as_ptr() as usize).trailing_zeros() >= 3);
-
-    slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u64, buf.len() >> 3)
-}
-
-/// Splits a slice into three parts:
-/// - an unaligned short head
-/// - an aligned `u64` slice mid section
-/// - an unaligned short tail
-#[inline]
-fn align_buf(buf: &mut [u8]) -> (ShortSlice<'_>, &mut [u64], ShortSlice<'_>) {
-    let start_ptr = buf.as_ptr() as usize;
-    let end_ptr = start_ptr + buf.len();
-
-    // Round *up* to next aligned boundary for start
-    let start_aligned = (start_ptr + 7) & !0x7;
-    // Round *down* to last aligned boundary for end
-    let end_aligned = end_ptr & !0x7;
-
-    if end_aligned >= start_aligned {
-        // We have our three segments (head, mid, tail)
-        let (tmp, tail) = buf.split_at_mut(end_aligned - start_ptr);
-        let (head, mid) = tmp.split_at_mut(start_aligned - start_ptr);
-
-        // SAFETY: we know the middle section is correctly aligned, and the outer
-        // sections are smaller than 8 bytes
-        unsafe {
-            (
-                ShortSlice::new(head),
-                cast_slice(mid),
-                ShortSlice::new(tail),
-            )
         }
     } else {
-        // We didn't cross even one aligned boundary!
+        mask_u32
-
+    };
-        // SAFETY: The outer sections are smaller than 8 bytes
+    for word in words.iter_mut() {
-        unsafe { (ShortSlice::new(buf), &mut [], ShortSlice::new(&mut [])) }
+        *word ^= mask_u32;
     }
+    apply_mask_fallback(&mut suffix, mask_u32.to_ne_bytes());
 }
 
 #[cfg(test)]
 mod tests {
-    use super::apply_mask;
+    use super::*;
-
-    /// A safe unoptimized mask application.
-    fn apply_mask_fallback(buf: &mut [u8], mask: &[u8; 4]) {
-        for (i, byte) in buf.iter_mut().enumerate() {
-            *byte ^= mask[i & 3];
-        }
-    }
 
+    // legacy test from old apply mask test. kept for now for back compat test.
+    // TODO: remove it and favor the other test.
     #[test]
-    fn test_apply_mask() {
+    fn test_apply_mask_legacy() {
         let mask = [0x6d, 0xb6, 0xb2, 0x80];
-        let mask_u32 = u32::from_le_bytes(mask);
 
         let unmasked = vec![
             0xf3, 0x00, 0x01, 0x02, 0x03, 0x80, 0x81, 0x82, 0xff, 0xfe, 0x00, 0x17,
@@ -140,10 +61,10 @@ mod tests {
         // Check masking with proper alignment.
         {
             let mut masked = unmasked.clone();
-            apply_mask_fallback(&mut masked, &mask);
+            apply_mask_fallback(&mut masked, mask);
 
             let mut masked_fast = unmasked.clone();
-            apply_mask(&mut masked_fast, mask_u32);
+            apply_mask(&mut masked_fast, mask);
 
             assert_eq!(masked, masked_fast);
         }
@@ -151,12 +72,38 @@ mod tests {
         // Check masking without alignment.
         {
             let mut masked = unmasked.clone();
-            apply_mask_fallback(&mut masked[1..], &mask);
+            apply_mask_fallback(&mut masked[1..], mask);
 
             let mut masked_fast = unmasked;
-            apply_mask(&mut masked_fast[1..], mask_u32);
+            apply_mask(&mut masked_fast[1..], mask);
 
             assert_eq!(masked, masked_fast);
         }
     }
+
+    #[test]
+    fn test_apply_mask() {
+        let mask = [0x6d, 0xb6, 0xb2, 0x80];
+        let unmasked = vec![
+            0xf3, 0x00, 0x01, 0x02, 0x03, 0x80, 0x81, 0x82, 0xff, 0xfe, 0x00, 0x17,
+            0x74, 0xf9, 0x12, 0x03,
+        ];
+
+        for data_len in 0..=unmasked.len() {
+            let unmasked = &unmasked[0..data_len];
+            // Check masking with different alignment.
+            for off in 0..=3 {
+                if unmasked.len() < off {
+                    continue;
+                }
+                let mut masked = unmasked.to_vec();
+                apply_mask_fallback(&mut masked[off..], mask);
+
+                let mut masked_fast = unmasked.to_vec();
+                apply_mask_fast32(&mut masked_fast[off..], mask);
+
+                assert_eq!(masked, masked_fast);
+            }
+        }
+    }
 }

actix-http/src/ws/mod.rs

@@ -1,6 +1,6 @@
-//! WebSocket protocol support.
+//! WebSocket protocol implementation.
 //!
-//! To setup a WebSocket, first do web socket handshake then on success convert `Payload` into a
+//! To setup a WebSocket, first perform the WebSocket handshake then on success convert `Payload` into a
 //! `WsStream` stream and then use `WsWriter` to communicate with the peer.
 
 use std::io;
@@ -8,9 +8,12 @@ use std::io;
 use derive_more::{Display, Error, From};
 use http::{header, Method, StatusCode};
 
-use crate::error::ResponseError;
+use crate::{
-use crate::message::RequestHead;
+    error::ResponseError,
-use crate::response::{Response, ResponseBuilder};
+    header::HeaderValue,
+    message::RequestHead,
+    response::{Response, ResponseBuilder},
+};
 
 mod codec;
 mod dispatcher;
@@ -76,7 +79,7 @@ pub enum HandshakeError {
     #[display(fmt = "Method not allowed.")]
     GetMethodRequired,
 
-    /// Upgrade header if not set to websocket.
+    /// Upgrade header if not set to WebSocket.
     #[display(fmt = "WebSocket upgrade is expected.")]
     NoWebsocketUpgrade,
 
@@ -88,8 +91,8 @@ pub enum HandshakeError {
     #[display(fmt = "WebSocket version header is required.")]
     NoVersionHeader,
 
-    /// Unsupported websocket version.
+    /// Unsupported WebSocket version.
-    #[display(fmt = "Unsupported version.")]
+    #[display(fmt = "Unsupported WebSocket version.")]
     UnsupportedVersion,
 
     /// WebSocket key is not set or wrong.
@@ -105,19 +108,19 @@ impl ResponseError for HandshakeError {
                 .finish(),
 
             HandshakeError::NoWebsocketUpgrade => Response::BadRequest()
-                .reason("No WebSocket UPGRADE header found")
+                .reason("No WebSocket Upgrade header found")
                 .finish(),
 
             HandshakeError::NoConnectionUpgrade => Response::BadRequest()
-                .reason("No CONNECTION upgrade")
+                .reason("No Connection upgrade")
                 .finish(),
 
             HandshakeError::NoVersionHeader => Response::BadRequest()
-                .reason("Websocket version header is required")
+                .reason("WebSocket version header is required")
                 .finish(),
 
             HandshakeError::UnsupportedVersion => Response::BadRequest()
-                .reason("Unsupported version")
+                .reason("Unsupported WebSocket version")
                 .finish(),
 
             HandshakeError::BadWebsocketKey => {
@@ -127,20 +130,20 @@ impl ResponseError for HandshakeError {
     }
 }
 
-/// Verify `WebSocket` handshake request and create handshake response.
+/// Verify WebSocket handshake request and create handshake response.
 pub fn handshake(req: &RequestHead) -> Result<ResponseBuilder, HandshakeError> {
     verify_handshake(req)?;
     Ok(handshake_response(req))
 }
 
-/// Verify `WebSocket` handshake request.
+/// Verify WebSocket handshake request.
 pub fn verify_handshake(req: &RequestHead) -> Result<(), HandshakeError> {
     // WebSocket accepts only GET
     if req.method != Method::GET {
         return Err(HandshakeError::GetMethodRequired);
     }
 
-    // Check for "UPGRADE" to websocket header
+    // Check for "UPGRADE" to WebSocket header
     let has_hdr = if let Some(hdr) = req.headers().get(header::UPGRADE) {
         if let Ok(s) = hdr.to_str() {
             s.to_ascii_lowercase().contains("websocket")
@@ -181,7 +184,7 @@ pub fn verify_handshake(req: &RequestHead) -> Result<(), HandshakeError> {
     Ok(())
 }
 
-/// Create websocket handshake response
+/// Create WebSocket handshake response.
 ///
 /// This function returns handshake `Response`, ready to send to peer.
 pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
@@ -193,7 +196,11 @@ pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
     Response::build(StatusCode::SWITCHING_PROTOCOLS)
         .upgrade("websocket")
         .insert_header((header::TRANSFER_ENCODING, "chunked"))
-        .insert_header((header::SEC_WEBSOCKET_ACCEPT, key))
+        .insert_header((
+            header::SEC_WEBSOCKET_ACCEPT,
+            // key is known to be header value safe ascii
+            HeaderValue::from_bytes(&key).unwrap(),
+        ))
         .take()
 }
 

actix-http/src/ws/proto.rs

@@ -1,5 +1,7 @@
-use std::convert::{From, Into};
+use std::{
-use std::fmt;
+    convert::{From, Into},
+    fmt,
+};
 
 /// Operation codes as part of RFC6455.
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
@@ -28,8 +30,9 @@ pub enum OpCode {
 
 impl fmt::Display for OpCode {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use self::OpCode::*;
+        use OpCode::*;
-        match *self {
+
+        match self {
             Continue => write!(f, "CONTINUE"),
             Text => write!(f, "TEXT"),
             Binary => write!(f, "BINARY"),
@@ -44,6 +47,7 @@ impl fmt::Display for OpCode {
 impl From<OpCode> for u8 {
     fn from(op: OpCode) -> u8 {
         use self::OpCode::*;
+
         match op {
             Continue => 0,
             Text => 1,
@@ -62,6 +66,7 @@ impl From<OpCode> for u8 {
 impl From<u8> for OpCode {
     fn from(byte: u8) -> OpCode {
         use self::OpCode::*;
+
         match byte {
             0 => Continue,
             1 => Text,
@@ -74,67 +79,69 @@ impl From<u8> for OpCode {
     }
 }
 
-/// Status code used to indicate why an endpoint is closing the `WebSocket`
+/// Status code used to indicate why an endpoint is closing the WebSocket connection.
-/// connection.
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 pub enum CloseCode {
-    /// Indicates a normal closure, meaning that the purpose for
+    /// Indicates a normal closure, meaning that the purpose for which the connection was
-    /// which the connection was established has been fulfilled.
+    /// established has been fulfilled.
     Normal,
-    /// Indicates that an endpoint is "going away", such as a server
+
-    /// going down or a browser having navigated away from a page.
+    /// Indicates that an endpoint is "going away", such as a server going down or a browser having
+    /// navigated away from a page.
     Away,
-    /// Indicates that an endpoint is terminating the connection due
+
-    /// to a protocol error.
+    /// Indicates that an endpoint is terminating the connection due to a protocol error.
     Protocol,
-    /// Indicates that an endpoint is terminating the connection
+
-    /// because it has received a type of data it cannot accept (e.g., an
+    /// Indicates that an endpoint is terminating the connection because it has received a type of
-    /// endpoint that understands only text data MAY send this if it
+    /// data it cannot accept (e.g., an endpoint that understands only text data MAY send this if it
     /// receives a binary message).
     Unsupported,
-    /// Indicates an abnormal closure. If the abnormal closure was due to an
+
-    /// error, this close code will not be used. Instead, the `on_error` method
+    /// Indicates an abnormal closure. If the abnormal closure was due to an error, this close code
-    /// of the handler will be called with the error. However, if the connection
+    /// will not be used. Instead, the `on_error` method of the handler will be called with
-    /// is simply dropped, without an error, this close code will be sent to the
+    /// the error. However, if the connection is simply dropped, without an error, this close code
-    /// handler.
+    /// will be sent to the handler.
     Abnormal,
-    /// Indicates that an endpoint is terminating the connection
+
-    /// because it has received data within a message that was not
+    /// Indicates that an endpoint is terminating the connection because it has received data within
-    /// consistent with the type of the message (e.g., non-UTF-8 \[RFC3629\]
+    /// a message that was not consistent with the type of the message (e.g., non-UTF-8 \[RFC3629\]
     /// data within a text message).
     Invalid,
-    /// Indicates that an endpoint is terminating the connection
+
-    /// because it has received a message that violates its policy.  This
+    /// Indicates that an endpoint is terminating the connection because it has received a message
-    /// is a generic status code that can be returned when there is no
+    /// that violates its policy. This is a generic status code that can be returned when there is
-    /// other more suitable status code (e.g., Unsupported or Size) or if there
+    /// no other more suitable status code (e.g., Unsupported or Size) or if there is a need to hide
-    /// is a need to hide specific details about the policy.
+    /// specific details about the policy.
     Policy,
-    /// Indicates that an endpoint is terminating the connection
+
-    /// because it has received a message that is too big for it to
+    /// Indicates that an endpoint is terminating the connection because it has received a message
-    /// process.
+    /// that is too big for it to process.
     Size,
-    /// Indicates that an endpoint (client) is terminating the
+
-    /// connection because it has expected the server to negotiate one or
+    /// Indicates that an endpoint (client) is terminating the connection because it has expected
-    /// more extension, but the server didn't return them in the response
+    /// the server to negotiate one or more extension, but the server didn't return them in the
-    /// message of the WebSocket handshake.  The list of extensions that
+    /// response message of the WebSocket handshake.  The list of extensions that are needed should
-    /// are needed should be given as the reason for closing.
+    /// be given as the reason for closing. Note that this status code is not used by the server,
-    /// Note that this status code is not used by the server, because it
+    /// because it can fail the WebSocket handshake instead.
-    /// can fail the WebSocket handshake instead.
     Extension,
-    /// Indicates that a server is terminating the connection because
+
-    /// it encountered an unexpected condition that prevented it from
+    /// Indicates that a server is terminating the connection because it encountered an unexpected
-    /// fulfilling the request.
+    /// condition that prevented it from fulfilling the request.
     Error,
-    /// Indicates that the server is restarting. A client may choose to
+
-    /// reconnect, and if it does, it should use a randomized delay of 5-30
+    /// Indicates that the server is restarting. A client may choose to reconnect, and if it does,
-    /// seconds between attempts.
+    /// it should use a randomized delay of 5-30 seconds between attempts.
     Restart,
-    /// Indicates that the server is overloaded and the client should either
+
-    /// connect to a different IP (when multiple targets exist), or
+    /// Indicates that the server is overloaded and the client should either connect to a different
-    /// reconnect to the same IP when a user has performed an action.
+    /// IP (when multiple targets exist), or reconnect to the same IP when a user has performed
+    /// an action.
     Again,
+
     #[doc(hidden)]
     Tls,
+
     #[doc(hidden)]
     Other(u16),
 }
@@ -142,6 +149,7 @@ pub enum CloseCode {
 impl From<CloseCode> for u16 {
     fn from(code: CloseCode) -> u16 {
         use self::CloseCode::*;
+
         match code {
             Normal => 1000,
             Away => 1001,
@@ -164,6 +172,7 @@ impl From<CloseCode> for u16 {
 impl From<u16> for CloseCode {
     fn from(code: u16) -> CloseCode {
         use self::CloseCode::*;
+
         match code {
             1000 => Normal,
             1001 => Away,
@@ -211,17 +220,29 @@ impl<T: Into<String>> From<(CloseCode, T)> for CloseReason {
     }
 }
 
-static WS_GUID: &str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+/// The WebSocket GUID as stated in the spec. See https://tools.ietf.org/html/rfc6455#section-1.3.
+static WS_GUID: &[u8] = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
-// TODO: hash is always same size, we don't need String
+/// Hashes the `Sec-WebSocket-Key` header according to the WebSocket spec.
-pub fn hash_key(key: &[u8]) -> String {
+///
-    use sha1::Digest;
+/// Result is a Base64 encoded byte array. `base64(sha1(input))` is always 28 bytes.
-    let mut hasher = sha1::Sha1::new();
+pub fn hash_key(key: &[u8]) -> [u8; 28] {
+    let hash = {
+        use sha1::Digest as _;
 
-    hasher.update(key);
+        let mut hasher = sha1::Sha1::new();
-    hasher.update(WS_GUID.as_bytes());
 
-    base64::encode(&hasher.finalize())
+        hasher.update(key);
+        hasher.update(WS_GUID);
+
+        hasher.finalize()
+    };
+
+    let mut hash_b64 = [0; 28];
+    let n = base64::encode_config_slice(&hash, base64::STANDARD, &mut hash_b64);
+    assert_eq!(n, 28);
+
+    hash_b64
 }
 
 #[cfg(test)]
@@ -289,11 +310,11 @@ mod test {
     #[test]
     fn test_hash_key() {
         let hash = hash_key(b"hello actix-web");
-        assert_eq!(&hash, "cR1dlyUUJKp0s/Bel25u5TgvC3E=");
+        assert_eq!(&hash, b"cR1dlyUUJKp0s/Bel25u5TgvC3E=");
     }
 
     #[test]
-    fn closecode_from_u16() {
+    fn close_code_from_u16() {
         assert_eq!(CloseCode::from(1000u16), CloseCode::Normal);
         assert_eq!(CloseCode::from(1001u16), CloseCode::Away);
         assert_eq!(CloseCode::from(1002u16), CloseCode::Protocol);
@@ -311,7 +332,7 @@ mod test {
     }
 
     #[test]
-    fn closecode_into_u16() {
+    fn close_code_into_u16() {
         assert_eq!(1000u16, Into::<u16>::into(CloseCode::Normal));
         assert_eq!(1001u16, Into::<u16>::into(CloseCode::Away));
         assert_eq!(1002u16, Into::<u16>::into(CloseCode::Protocol));

actix-http/tests/test_client.rs

@@ -1,8 +1,13 @@
-use actix_http::{http, HttpService, Request, Response};
+use actix_http::{
+    error, http, http::StatusCode, HttpMessage, HttpService, Request, Response,
+};
 use actix_http_test::test_server;
 use actix_service::ServiceFactoryExt;
 use bytes::Bytes;
-use futures_util::future::{self, ok};
+use futures_util::{
+    future::{self, ok},
+    StreamExt,
+};
 
 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
                    Hello World Hello World Hello World Hello World Hello World \
@@ -88,3 +93,55 @@ async fn test_with_query_parameter() {
     let response = request.send().await.unwrap();
     assert!(response.status().is_success());
 }
+
+#[actix_rt::test]
+async fn test_h1_expect() {
+    let srv = test_server(move || {
+        HttpService::build()
+            .expect(|req: Request| async {
+                if req.headers().contains_key("AUTH") {
+                    Ok(req)
+                } else {
+                    Err(error::ErrorExpectationFailed("expect failed"))
+                }
+            })
+            .h1(|req: Request| async move {
+                let (_, mut body) = req.into_parts();
+                let mut buf = Vec::new();
+                while let Some(Ok(chunk)) = body.next().await {
+                    buf.extend_from_slice(&chunk);
+                }
+                let str = std::str::from_utf8(&buf).unwrap();
+                assert_eq!(str, "expect body");
+
+                Ok::<_, ()>(Response::Ok().finish())
+            })
+            .tcp()
+    })
+    .await;
+
+    // test expect without payload.
+    let request = srv
+        .request(http::Method::GET, srv.url("/"))
+        .insert_header(("Expect", "100-continue"));
+
+    let response = request.send().await;
+    assert!(response.is_err());
+
+    // test expect would fail to continue
+    let request = srv
+        .request(http::Method::GET, srv.url("/"))
+        .insert_header(("Expect", "100-continue"));
+
+    let response = request.send_body("expect body").await.unwrap();
+    assert_eq!(response.status(), StatusCode::EXPECTATION_FAILED);
+
+    // test exepct would continue
+    let request = srv
+        .request(http::Method::GET, srv.url("/"))
+        .insert_header(("Expect", "100-continue"))
+        .insert_header(("AUTH", "996"));
+
+    let response = request.send_body("expect body").await.unwrap();
+    assert!(response.status().is_success());
+}

actix-http/tests/test_openssl.rs

@@ -7,14 +7,18 @@ use std::io;
 use actix_http::error::{ErrorBadRequest, PayloadError};
 use actix_http::http::header::{self, HeaderName, HeaderValue};
 use actix_http::http::{Method, StatusCode, Version};
-use actix_http::httpmessage::HttpMessage;
+use actix_http::HttpMessage;
 use actix_http::{body, Error, HttpService, Request, Response};
 use actix_http_test::test_server;
 use actix_service::{fn_service, ServiceFactoryExt};
 use bytes::{Bytes, BytesMut};
 use futures_util::future::{err, ok, ready};
 use futures_util::stream::{once, Stream, StreamExt};
-use openssl::ssl::{AlpnError, SslAcceptor, SslFiletype, SslMethod};
+use openssl::{
+    pkey::PKey,
+    ssl::{SslAcceptor, SslMethod},
+    x509::X509,
+};
 
 async fn load_body<S>(stream: S) -> Result<BytesMut, PayloadError>
 where
@@ -34,29 +38,26 @@ where
     Ok(body)
 }
 
-fn ssl_acceptor() -> SslAcceptor {
+fn tls_config() -> SslAcceptor {
-    // load ssl keys
+    let cert = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();
+    let cert_file = cert.serialize_pem().unwrap();
+    let key_file = cert.serialize_private_key_pem();
+    let cert = X509::from_pem(cert_file.as_bytes()).unwrap();
+    let key = PKey::private_key_from_pem(key_file.as_bytes()).unwrap();
+
     let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
-    builder
+    builder.set_certificate(&cert).unwrap();
-        .set_private_key_file("../tests/key.pem", SslFiletype::PEM)
+    builder.set_private_key(&key).unwrap();
-        .unwrap();
+
-    builder
-        .set_certificate_chain_file("../tests/cert.pem")
-        .unwrap();
     builder.set_alpn_select_callback(|_, protos| {
         const H2: &[u8] = b"\x02h2";
-        const H11: &[u8] = b"\x08http/1.1";
         if protos.windows(3).any(|window| window == H2) {
             Ok(b"h2")
-        } else if protos.windows(9).any(|window| window == H11) {
-            Ok(b"http/1.1")
         } else {
-            Err(AlpnError::NOACK)
+            Err(openssl::ssl::AlpnError::NOACK)
         }
     });
-    builder
+    builder.set_alpn_protos(b"\x02h2").unwrap();
-        .set_alpn_protos(b"\x08http/1.1\x02h2")
-        .expect("Can not contrust SslAcceptor");
 
     builder.build()
 }
@@ -66,7 +67,7 @@ async fn test_h2() -> io::Result<()> {
     let srv = test_server(move || {
         HttpService::build()
             .h2(|_| ok::<_, Error>(Response::Ok().finish()))
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -85,7 +86,7 @@ async fn test_h2_1() -> io::Result<()> {
                 assert_eq!(req.version(), Version::HTTP_2);
                 ok::<_, Error>(Response::Ok().finish())
             })
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -104,7 +105,7 @@ async fn test_h2_body() -> io::Result<()> {
                 let body = load_body(req.take_payload()).await?;
                 Ok::<_, Error>(Response::Ok().body(body))
             })
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -122,18 +123,16 @@ async fn test_h2_content_length() {
     let srv = test_server(move || {
         HttpService::build()
             .h2(|req: Request| {
-                let indx: usize = req.uri().path()[1..].parse().unwrap();
+                let idx: usize = req.uri().path()[1..].parse().unwrap();
                 let statuses = [
-                    StatusCode::NO_CONTENT,
                     StatusCode::CONTINUE,
-                    StatusCode::SWITCHING_PROTOCOLS,
+                    StatusCode::NO_CONTENT,
-                    StatusCode::PROCESSING,
                     StatusCode::OK,
                     StatusCode::NOT_FOUND,
                 ];
-                ok::<_, ()>(Response::new(statuses[indx]))
+                ok::<_, ()>(Response::new(statuses[idx]))
             })
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -142,21 +141,29 @@ async fn test_h2_content_length() {
     let value = HeaderValue::from_static("0");
 
     {
-        for i in 0..4 {
+        for &i in &[0] {
+            let req = srv
+                .request(Method::HEAD, srv.surl(&format!("/{}", i)))
+                .send();
+            let _response = req.await.expect_err("should timeout on recv 1xx frame");
+            // assert_eq!(response.headers().get(&header), None);
+
+            let req = srv
+                .request(Method::GET, srv.surl(&format!("/{}", i)))
+                .send();
+            let _response = req.await.expect_err("should timeout on recv 1xx frame");
+            // assert_eq!(response.headers().get(&header), None);
+        }
+
+        for &i in &[1] {
             let req = srv
                 .request(Method::GET, srv.surl(&format!("/{}", i)))
                 .send();
             let response = req.await.unwrap();
             assert_eq!(response.headers().get(&header), None);
-
-            let req = srv
-                .request(Method::HEAD, srv.surl(&format!("/{}", i)))
-                .send();
-            let response = req.await.unwrap();
-            assert_eq!(response.headers().get(&header), None);
         }
 
-        for i in 4..6 {
+        for &i in &[2, 3] {
             let req = srv
                 .request(Method::GET, srv.surl(&format!("/{}", i)))
                 .send();
@@ -195,7 +202,7 @@ async fn test_h2_headers() {
             }
             ok::<_, ()>(builder.body(data.clone()))
         })
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
                     .map_err(|_| ())
     }).await;
 
@@ -234,7 +241,7 @@ async fn test_h2_body2() {
     let mut srv = test_server(move || {
         HttpService::build()
             .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -252,7 +259,7 @@ async fn test_h2_head_empty() {
     let mut srv = test_server(move || {
         HttpService::build()
             .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -276,7 +283,7 @@ async fn test_h2_head_binary() {
     let mut srv = test_server(move || {
         HttpService::build()
             .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -299,7 +306,7 @@ async fn test_h2_head_binary2() {
     let srv = test_server(move || {
         HttpService::build()
             .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -323,7 +330,7 @@ async fn test_h2_body_length() {
                     Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
                 )
             })
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -348,7 +355,7 @@ async fn test_h2_body_chunked_explicit() {
                         .streaming(body),
                 )
             })
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -376,7 +383,7 @@ async fn test_h2_response_http_error_handling() {
                         .body(STR),
                 )
             }))
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -394,7 +401,7 @@ async fn test_h2_service_error() {
     let mut srv = test_server(move || {
         HttpService::build()
             .h2(|_| err::<Response, Error>(ErrorBadRequest("error")))
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;
@@ -418,7 +425,7 @@ async fn test_h2_on_connect() {
                 assert!(req.extensions().contains::<isize>());
                 ok::<_, ()>(Response::Ok().finish())
             })
-            .openssl(ssl_acceptor())
+            .openssl(tls_config())
             .map_err(|_| ())
     })
     .await;

actix-http/tests/test_rustls.rs

@@ -17,7 +17,6 @@ use rustls::{
     NoClientAuth, ServerConfig as RustlsServerConfig,
 };
 
-use std::fs::File;
 use std::io::{self, BufReader};
 
 async fn load_body<S>(mut stream: S) -> Result<BytesMut, PayloadError>
@@ -31,14 +30,19 @@ where
     Ok(body)
 }
 
-fn ssl_acceptor() -> RustlsServerConfig {
+fn tls_config() -> RustlsServerConfig {
-    // load ssl keys
+    let cert = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();
+    let cert_file = cert.serialize_pem().unwrap();
+    let key_file = cert.serialize_private_key_pem();
+
     let mut config = RustlsServerConfig::new(NoClientAuth::new());
-    let cert_file = &mut BufReader::new(File::open("../tests/cert.pem").unwrap());
+    let cert_file = &mut BufReader::new(cert_file.as_bytes());
-    let key_file = &mut BufReader::new(File::open("../tests/key.pem").unwrap());
+    let key_file = &mut BufReader::new(key_file.as_bytes());
+
     let cert_chain = certs(cert_file).unwrap();
     let mut keys = pkcs8_private_keys(key_file).unwrap();
     config.set_single_cert(cert_chain, keys.remove(0)).unwrap();
+
     config
 }
 
@@ -47,7 +51,7 @@ async fn test_h1() -> io::Result<()> {
     let srv = test_server(move || {
         HttpService::build()
             .h1(|_| future::ok::<_, Error>(Response::Ok().finish()))
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -61,7 +65,7 @@ async fn test_h2() -> io::Result<()> {
     let srv = test_server(move || {
         HttpService::build()
             .h2(|_| future::ok::<_, Error>(Response::Ok().finish()))
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -79,7 +83,7 @@ async fn test_h1_1() -> io::Result<()> {
                 assert_eq!(req.version(), Version::HTTP_11);
                 future::ok::<_, Error>(Response::Ok().finish())
             })
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -97,7 +101,7 @@ async fn test_h2_1() -> io::Result<()> {
                 assert_eq!(req.version(), Version::HTTP_2);
                 future::ok::<_, Error>(Response::Ok().finish())
             })
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -115,7 +119,7 @@ async fn test_h2_body1() -> io::Result<()> {
                 let body = load_body(req.take_payload()).await?;
                 Ok::<_, Error>(Response::Ok().body(body))
             })
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -134,37 +138,44 @@ async fn test_h2_content_length() {
             .h2(|req: Request| {
                 let indx: usize = req.uri().path()[1..].parse().unwrap();
                 let statuses = [
-                    StatusCode::NO_CONTENT,
                     StatusCode::CONTINUE,
-                    StatusCode::SWITCHING_PROTOCOLS,
+                    StatusCode::NO_CONTENT,
-                    StatusCode::PROCESSING,
                     StatusCode::OK,
                     StatusCode::NOT_FOUND,
                 ];
                 future::ok::<_, ()>(Response::new(statuses[indx]))
             })
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
     let header = HeaderName::from_static("content-length");
     let value = HeaderValue::from_static("0");
+
     {
-        for i in 0..4 {
+        for &i in &[0] {
+            let req = srv
+                .request(Method::HEAD, srv.surl(&format!("/{}", i)))
+                .send();
+            let _response = req.await.expect_err("should timeout on recv 1xx frame");
+            // assert_eq!(response.headers().get(&header), None);
+
+            let req = srv
+                .request(Method::GET, srv.surl(&format!("/{}", i)))
+                .send();
+            let _response = req.await.expect_err("should timeout on recv 1xx frame");
+            // assert_eq!(response.headers().get(&header), None);
+        }
+
+        for &i in &[1] {
             let req = srv
                 .request(Method::GET, srv.surl(&format!("/{}", i)))
                 .send();
             let response = req.await.unwrap();
             assert_eq!(response.headers().get(&header), None);
-
-            let req = srv
-                .request(Method::HEAD, srv.surl(&format!("/{}", i)))
-                .send();
-            let response = req.await.unwrap();
-            assert_eq!(response.headers().get(&header), None);
         }
 
-        for i in 4..6 {
+        for &i in &[2, 3] {
             let req = srv
                 .request(Method::GET, srv.surl(&format!("/{}", i)))
                 .send();
@@ -203,7 +214,7 @@ async fn test_h2_headers() {
             }
             future::ok::<_, ()>(config.body(data.clone()))
         })
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     }).await;
 
     let response = srv.sget("/").send().await.unwrap();
@@ -241,7 +252,7 @@ async fn test_h2_body2() {
     let mut srv = test_server(move || {
         HttpService::build()
             .h2(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -258,7 +269,7 @@ async fn test_h2_head_empty() {
     let mut srv = test_server(move || {
         HttpService::build()
             .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -284,7 +295,7 @@ async fn test_h2_head_binary() {
     let mut srv = test_server(move || {
         HttpService::build()
             .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -309,7 +320,7 @@ async fn test_h2_head_binary2() {
     let srv = test_server(move || {
         HttpService::build()
             .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -335,7 +346,7 @@ async fn test_h2_body_length() {
                     Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
                 )
             })
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -359,7 +370,7 @@ async fn test_h2_body_chunked_explicit() {
                         .streaming(body),
                 )
             })
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -388,7 +399,7 @@ async fn test_h2_response_http_error_handling() {
                     )
                 }))
             }))
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -405,7 +416,7 @@ async fn test_h2_service_error() {
     let mut srv = test_server(move || {
         HttpService::build()
             .h2(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 
@@ -422,7 +433,7 @@ async fn test_h1_service_error() {
     let mut srv = test_server(move || {
         HttpService::build()
             .h1(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
-            .rustls(ssl_acceptor())
+            .rustls(tls_config())
     })
     .await;
 

actix-http/tests/test_server.rs

@@ -10,7 +10,7 @@ use futures_util::future::{self, err, ok, ready, FutureExt};
 use futures_util::stream::{once, StreamExt};
 use regex::Regex;
 
-use actix_http::httpmessage::HttpMessage;
+use actix_http::HttpMessage;
 use actix_http::{
     body, error, http, http::header, Error, HttpService, KeepAlive, Request, Response,
 };
@@ -126,7 +126,7 @@ async fn test_chunked_payload() {
                     .take_payload()
                     .map(|res| match res {
                         Ok(pl) => pl,
-                        Err(e) => panic!(format!("Error reading payload: {}", e)),
+                        Err(e) => panic!("Error reading payload: {}", e),
                     })
                     .fold(0usize, |acc, chunk| ready(acc + chunk.len()))
                     .map(|req_size| {
@@ -162,7 +162,7 @@ async fn test_chunked_payload() {
         let re = Regex::new(r"size=(\d+)").unwrap();
         let size: usize = match re.captures(&data) {
             Some(caps) => caps.get(1).unwrap().as_str().parse().unwrap(),
-            None => panic!(format!("Failed to find size in HTTP Response: {}", data)),
+            None => panic!("Failed to find size in HTTP Response: {}", data),
         };
         size
     };

actix-multipart/CHANGES.md

@@ -3,6 +3,10 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 0.4.0-beta.3 - 2021-03-09
+* No notable changes.
+
+
 ## 0.4.0-beta.2 - 2021-02-10
 * No notable changes.
 

actix-multipart/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-multipart"
-version = "0.4.0-beta.2"
+version = "0.4.0-beta.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Multipart form support for Actix Web"
 readme = "README.md"
@@ -16,17 +16,19 @@ name = "actix_multipart"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = { version = "4.0.0-beta.2", default-features = false }
+actix-web = { version = "4.0.0-beta.4", default-features = false }
 actix-utils = "3.0.0-beta.2"
 
 bytes = "1"
 derive_more = "0.99.5"
 httparse = "1.3"
-futures-util = { version = "0.3.7", default-features = false }
+futures-util = { version = "0.3.7", default-features = false, features = ["alloc"] }
 log = "0.4"
 mime = "0.3"
 twoway = "0.2"
 
 [dev-dependencies]
-actix-rt = "2"
+actix-rt = "2.1"
-actix-http = "3.0.0-beta.2"
+actix-http = "3.0.0-beta.4"
+tokio = { version = "1", features = ["sync"] }
+tokio-stream = "0.1"

actix-multipart/README.md

@@ -3,13 +3,12 @@
 > Multipart form support for Actix Web.
 
 [![crates.io](https://img.shields.io/crates/v/actix-multipart?label=latest)](https://crates.io/crates/actix-multipart)
-[![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.4.0-beta.2)](https://docs.rs/actix-multipart/0.4.0-beta.2)
+[![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.4.0-beta.3)](https://docs.rs/actix-multipart/0.4.0-beta.3)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-multipart.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-multipart/0.4.0-beta.2/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0-beta.2)
+[![dependency status](https://deps.rs/crate/actix-multipart/0.4.0-beta.3/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0-beta.3)
 [![Download](https://img.shields.io/crates/d/actix-multipart.svg)](https://crates.io/crates/actix-multipart)
-[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Documentation & Resources
 

actix-multipart/src/server.rs

@@ -13,9 +13,7 @@ use futures_util::stream::{LocalBoxStream, Stream, StreamExt};
 
 use actix_utils::task::LocalWaker;
 use actix_web::error::{ParseError, PayloadError};
-use actix_web::http::header::{
+use actix_web::http::header::{self, ContentDisposition, HeaderMap, HeaderName, HeaderValue};
-    self, ContentDisposition, HeaderMap, HeaderName, HeaderValue,
-};
 
 use crate::error::MultipartError;
 
@@ -120,10 +118,7 @@ impl Multipart {
 impl Stream for Multipart {
     type Item = Result<Field, MultipartError>;
 
-    fn poll_next(
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
         if let Some(err) = self.error.take() {
             Poll::Ready(Some(Err(err)))
         } else if self.safety.current() {
@@ -142,9 +137,7 @@ impl Stream for Multipart {
 }
 
 impl InnerMultipart {
-    fn read_headers(
+    fn read_headers(payload: &mut PayloadBuffer) -> Result<Option<HeaderMap>, MultipartError> {
-        payload: &mut PayloadBuffer,
-    ) -> Result<Option<HeaderMap>, MultipartError> {
         match payload.read_until(b"\r\n\r\n")? {
             None => {
                 if payload.eof {
@@ -226,8 +219,7 @@ impl InnerMultipart {
                     if chunk.len() < boundary.len() {
                         continue;
                     }
-                    if &chunk[..2] == b"--"
+                    if &chunk[..2] == b"--" && &chunk[2..chunk.len() - 2] == boundary.as_bytes()
-                        && &chunk[2..chunk.len() - 2] == boundary.as_bytes()
                     {
                         break;
                     } else {
@@ -273,9 +265,7 @@ impl InnerMultipart {
                             match field.borrow_mut().poll(safety) {
                                 Poll::Pending => return Poll::Pending,
                                 Poll::Ready(Some(Ok(_))) => continue,
-                                Poll::Ready(Some(Err(e))) => {
+                                Poll::Ready(Some(Err(e))) => return Poll::Ready(Some(Err(e))),
-                                    return Poll::Ready(Some(Err(e)))
-                                }
                                 Poll::Ready(None) => true,
                             }
                         }
@@ -311,10 +301,7 @@ impl InnerMultipart {
                     }
                     // read boundary
                     InnerState::Boundary => {
-                        match InnerMultipart::read_boundary(
+                        match InnerMultipart::read_boundary(&mut *payload, &self.boundary)? {
-                            &mut *payload,
-                            &self.boundary,
-                        )? {
                             None => return Poll::Pending,
                             Some(eof) => {
                                 if eof {
@@ -418,8 +405,7 @@ impl Field {
     pub fn content_disposition(&self) -> Option<ContentDisposition> {
         // RFC 7578: 'Each part MUST contain a Content-Disposition header field
         // where the disposition type is "form-data".'
-        if let Some(content_disposition) = self.headers.get(&header::CONTENT_DISPOSITION)
+        if let Some(content_disposition) = self.headers.get(&header::CONTENT_DISPOSITION) {
-        {
             ContentDisposition::from_raw(content_disposition).ok()
         } else {
             None
@@ -430,15 +416,10 @@ impl Field {
 impl Stream for Field {
     type Item = Result<Bytes, MultipartError>;
 
-    fn poll_next(
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
         if self.safety.current() {
             let mut inner = self.inner.borrow_mut();
-            if let Some(mut payload) =
+            if let Some(mut payload) = inner.payload.as_ref().unwrap().get_mut(&self.safety) {
-                inner.payload.as_ref().unwrap().get_mut(&self.safety)
-            {
                 payload.poll_stream(cx)?;
             }
             inner.poll(&self.safety)
@@ -607,8 +588,7 @@ impl InnerField {
             return Poll::Ready(None);
         }
 
-        let result = if let Some(mut payload) = self.payload.as_ref().unwrap().get_mut(s)
+        let result = if let Some(mut payload) = self.payload.as_ref().unwrap().get_mut(s) {
-        {
             if !self.eof {
                 let res = if let Some(ref mut len) = self.length {
                     InnerField::read_len(&mut *payload, len)
@@ -628,7 +608,9 @@ impl InnerField {
                 Ok(None) => Poll::Pending,
                 Ok(Some(line)) => {
                     if line.as_ref() != b"\r\n" {
-                        log::warn!("multipart field did not read all the data or it is malformed");
+                        log::warn!(
+                            "multipart field did not read all the data or it is malformed"
+                        );
                     }
                     Poll::Ready(None)
                 }
@@ -804,9 +786,7 @@ impl PayloadBuffer {
     /// Read bytes until new line delimiter or eof
     pub fn readline_or_eof(&mut self) -> Result<Option<Bytes>, MultipartError> {
         match self.readline() {
-            Err(MultipartError::Incomplete) if self.eof => {
+            Err(MultipartError::Incomplete) if self.eof => Ok(Some(self.buf.split().freeze())),
-                Ok(Some(self.buf.split().freeze()))
-            }
             line => line,
         }
     }
@@ -824,12 +804,13 @@ mod tests {
     use super::*;
 
     use actix_http::h1::Payload;
-    use actix_utils::mpsc;
     use actix_web::http::header::{DispositionParam, DispositionType};
     use actix_web::test::TestRequest;
     use actix_web::FromRequest;
     use bytes::Bytes;
     use futures_util::future::lazy;
+    use tokio::sync::mpsc;
+    use tokio_stream::wrappers::UnboundedReceiverStream;
 
     #[actix_rt::test]
     async fn test_boundary() {
@@ -875,13 +856,17 @@ mod tests {
     }
 
     fn create_stream() -> (
-        mpsc::Sender<Result<Bytes, PayloadError>>,
+        mpsc::UnboundedSender<Result<Bytes, PayloadError>>,
         impl Stream<Item = Result<Bytes, PayloadError>>,
     ) {
-        let (tx, rx) = mpsc::channel();
+        let (tx, rx) = mpsc::unbounded_channel();
 
-        (tx, rx.map(|res| res.map_err(|_| panic!())))
+        (
+            tx,
+            UnboundedReceiverStream::new(rx).map(|res| res.map_err(|_| panic!())),
+        )
     }
+
     // Stream that returns from a Bytes, one char at a time and Pending every other poll()
     struct SlowStream {
         bytes: Bytes,
@@ -902,19 +887,18 @@ mod tests {
     impl Stream for SlowStream {
         type Item = Result<Bytes, PayloadError>;
 
-        fn poll_next(
+        fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-            self: Pin<&mut Self>,
-            cx: &mut Context<'_>,
-        ) -> Poll<Option<Self::Item>> {
             let this = self.get_mut();
             if !this.ready {
                 this.ready = true;
                 cx.waker().wake_by_ref();
                 return Poll::Pending;
             }
+
             if this.pos == this.bytes.len() {
                 return Poll::Ready(None);
             }
+
             let res = Poll::Ready(Some(Ok(this.bytes.slice(this.pos..(this.pos + 1)))));
             this.pos += 1;
             this.ready = false;

actix-web-actors/CHANGES.md

@@ -3,6 +3,10 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 4.0.0-beta.3 - 2021-03-09
+* No notable changes.
+
+
 ## 4.0.0-beta.2 - 2021-02-10
 * No notable changes.
 

actix-web-actors/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web-actors"
-version = "4.0.0-beta.2"
+version = "4.0.0-beta.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix actors support for Actix Web"
 readme = "README.md"
@@ -16,10 +16,10 @@ name = "actix_web_actors"
 path = "src/lib.rs"
 
 [dependencies]
-actix = { version = "0.11.0-beta.2", default-features = false }
+actix = { version = "0.11.0-beta.3", default-features = false }
 actix-codec = "0.4.0-beta.1"
-actix-http = "3.0.0-beta.2"
+actix-http = "3.0.0-beta.4"
-actix-web = { version = "4.0.0-beta.2", default-features = false }
+actix-web = { version = "4.0.0-beta.4", default-features = false }
 
 bytes = "1"
 bytestring = "1"
@@ -28,6 +28,6 @@ pin-project = "1.0.0"
 tokio = { version = "1", features = ["sync"] }
 
 [dev-dependencies]
-actix-rt = "2"
+actix-rt = "2.1"
 env_logger = "0.8"
 futures-util = { version = "0.3.7", default-features = false }

actix-web-actors/README.md

@@ -3,11 +3,11 @@
 > Actix actors support for Actix Web.
 
 [![crates.io](https://img.shields.io/crates/v/actix-web-actors?label=latest)](https://crates.io/crates/actix-web-actors)
-[![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=0.5.0)](https://docs.rs/actix-web-actors/0.5.0)
+[![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=4.0.0-beta.3)](https://docs.rs/actix-web-actors/4.0.0-beta.3)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
 ![License](https://img.shields.io/crates/l/actix-web-actors.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-web-actors/0.5.0/status.svg)](https://deps.rs/crate/actix-web-actors/0.5.0)
+[![dependency status](https://deps.rs/crate/actix-web-actors/4.0.0-beta.3/status.svg)](https://deps.rs/crate/actix-web-actors/4.0.0-beta.3)
 [![Download](https://img.shields.io/crates/d/actix-web-actors.svg)](https://crates.io/crates/actix-web-actors)
 [![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)
 

actix-web-actors/src/context.rs

@@ -3,9 +3,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use actix::dev::{
+use actix::dev::{AsyncContextParts, ContextFut, ContextParts, Envelope, Mailbox, ToEnvelope};
-    AsyncContextParts, ContextFut, ContextParts, Envelope, Mailbox, ToEnvelope,
-};
 use actix::fut::ActorFuture;
 use actix::{
     Actor, ActorContext, ActorState, Addr, AsyncContext, Handler, Message, SpawnHandle,
@@ -15,7 +13,7 @@ use bytes::Bytes;
 use futures_core::Stream;
 use tokio::sync::oneshot::Sender;
 
-/// Execution context for http actors
+/// Execution context for HTTP actors
 pub struct HttpContext<A>
 where
     A: Actor<Context = HttpContext<A>>,
@@ -46,7 +44,7 @@ where
     #[inline]
     fn spawn<F>(&mut self, fut: F) -> SpawnHandle
     where
-        F: ActorFuture<Output = (), Actor = A> + 'static,
+        F: ActorFuture<A, Output = ()> + 'static,
     {
         self.inner.spawn(fut)
     }
@@ -54,7 +52,7 @@ where
     #[inline]
     fn wait<F>(&mut self, fut: F)
     where
-        F: ActorFuture<Output = (), Actor = A> + 'static,
+        F: ActorFuture<A, Output = ()> + 'static,
     {
         self.inner.wait(fut)
     }
@@ -165,10 +163,7 @@ where
 {
     type Item = Result<Bytes, Error>;
 
-    fn poll_next(
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
         if self.fut.alive() {
             let _ = Pin::new(&mut self.fut).poll(cx);
         }
@@ -233,10 +228,11 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_default_resource() {
-        let srv = init_service(App::new().service(web::resource("/test").to(|| {
+        let srv =
-            HttpResponse::Ok().streaming(HttpContext::create(MyActor { count: 0 }))
+            init_service(App::new().service(web::resource("/test").to(|| {
-        })))
+                HttpResponse::Ok().streaming(HttpContext::create(MyActor { count: 0 }))
-        .await;
+            })))
+            .await;
 
         let req = TestRequest::with_uri("/test").to_request();
         let resp = call_service(&srv, req).await;

actix-web-actors/src/ws.rs

@@ -7,19 +7,21 @@ use std::task::{Context, Poll};
 use std::{collections::VecDeque, convert::TryFrom};
 
 use actix::dev::{
-    AsyncContextParts, ContextFut, ContextParts, Envelope, Mailbox, StreamHandler,
+    AsyncContextParts, ContextFut, ContextParts, Envelope, Mailbox, StreamHandler, ToEnvelope,
-    ToEnvelope,
 };
 use actix::fut::ActorFuture;
 use actix::{
-    Actor, ActorContext, ActorState, Addr, AsyncContext, Handler,
+    Actor, ActorContext, ActorState, Addr, AsyncContext, Handler, Message as ActixMessage,
-    Message as ActixMessage, SpawnHandle,
+    SpawnHandle,
 };
 use actix_codec::{Decoder, Encoder};
-use actix_http::ws::{hash_key, Codec};
 pub use actix_http::ws::{
     CloseCode, CloseReason, Frame, HandshakeError, Message, ProtocolError,
 };
+use actix_http::{
+    http::HeaderValue,
+    ws::{hash_key, Codec},
+};
 use actix_web::dev::HttpResponseBuilder;
 use actix_web::error::{Error, PayloadError};
 use actix_web::http::{header, Method, StatusCode};
@@ -32,8 +34,7 @@ use tokio::sync::oneshot::Sender;
 /// Perform WebSocket handshake and start actor.
 pub fn start<A, T>(actor: A, req: &HttpRequest, stream: T) -> Result<HttpResponse, Error>
 where
-    A: Actor<Context = WebsocketContext<A>>
+    A: Actor<Context = WebsocketContext<A>> + StreamHandler<Result<Message, ProtocolError>>,
-        + StreamHandler<Result<Message, ProtocolError>>,
     T: Stream<Item = Result<Bytes, PayloadError>> + 'static,
 {
     let mut res = handshake(req)?;
@@ -50,15 +51,14 @@ where
 ///
 /// If successful, returns a pair where the first item is an address for the
 /// created actor and the second item is the response that should be returned
-/// from the websocket request.
+/// from the WebSocket request.
 pub fn start_with_addr<A, T>(
     actor: A,
     req: &HttpRequest,
     stream: T,
 ) -> Result<(Addr<A>, HttpResponse), Error>
 where
-    A: Actor<Context = WebsocketContext<A>>
+    A: Actor<Context = WebsocketContext<A>> + StreamHandler<Result<Message, ProtocolError>>,
-        + StreamHandler<Result<Message, ProtocolError>>,
     T: Stream<Item = Result<Bytes, PayloadError>> + 'static,
 {
     let mut res = handshake(req)?;
@@ -66,7 +66,7 @@ where
     Ok((addr, res.streaming(out_stream)))
 }
 
-/// Do websocket handshake and start ws actor.
+/// Do WebSocket handshake and start ws actor.
 ///
 /// `protocols` is a sequence of known protocols.
 pub fn start_with_protocols<A, T>(
@@ -76,15 +76,14 @@ pub fn start_with_protocols<A, T>(
     stream: T,
 ) -> Result<HttpResponse, Error>
 where
-    A: Actor<Context = WebsocketContext<A>>
+    A: Actor<Context = WebsocketContext<A>> + StreamHandler<Result<Message, ProtocolError>>,
-        + StreamHandler<Result<Message, ProtocolError>>,
     T: Stream<Item = Result<Bytes, PayloadError>> + 'static,
 {
     let mut res = handshake_with_protocols(req, protocols)?;
     Ok(res.streaming(WebsocketContext::create(actor, stream)))
 }
 
-/// Prepare `WebSocket` handshake response.
+/// Prepare WebSocket handshake response.
 ///
 /// This function returns handshake `HttpResponse`, ready to send to peer.
 /// It does not perform any IO.
@@ -92,7 +91,7 @@ pub fn handshake(req: &HttpRequest) -> Result<HttpResponseBuilder, HandshakeErro
     handshake_with_protocols(req, &[])
 }
 
-/// Prepare `WebSocket` handshake response.
+/// Prepare WebSocket handshake response.
 ///
 /// This function returns handshake `HttpResponse`, ready to send to peer.
 /// It does not perform any IO.
@@ -109,7 +108,7 @@ pub fn handshake_with_protocols(
         return Err(HandshakeError::GetMethodRequired);
     }
 
-    // Check for "UPGRADE" to websocket header
+    // check for "UPGRADE" to WebSocket header
     let has_hdr = if let Some(hdr) = req.headers().get(&header::UPGRADE) {
         if let Ok(s) = hdr.to_str() {
             s.to_ascii_lowercase().contains("websocket")
@@ -166,7 +165,11 @@ pub fn handshake_with_protocols(
 
     let mut response = HttpResponse::build(StatusCode::SWITCHING_PROTOCOLS)
         .upgrade("websocket")
-        .insert_header((header::SEC_WEBSOCKET_ACCEPT, key))
+        .insert_header((
+            header::SEC_WEBSOCKET_ACCEPT,
+            // key is known to be header value safe ascii
+            HeaderValue::from_bytes(&key).unwrap(),
+        ))
         .take();
 
     if let Some(protocol) = protocol {
@@ -208,14 +211,14 @@ where
 {
     fn spawn<F>(&mut self, fut: F) -> SpawnHandle
     where
-        F: ActorFuture<Output = (), Actor = A> + 'static,
+        F: ActorFuture<A, Output = ()> + 'static,
     {
         self.inner.spawn(fut)
     }
 
     fn wait<F>(&mut self, fut: F)
     where
-        F: ActorFuture<Output = (), Actor = A> + 'static,
+        F: ActorFuture<A, Output = ()> + 'static,
     {
         self.inner.wait(fut)
     }
@@ -301,10 +304,7 @@ where
     }
 
     /// Create a new Websocket context
-    pub fn with_factory<S, F>(
+    pub fn with_factory<S, F>(stream: S, f: F) -> impl Stream<Item = Result<Bytes, Error>>
-        stream: S,
-        f: F,
-    ) -> impl Stream<Item = Result<Bytes, Error>>
     where
         F: FnOnce(&mut Self) -> A + 'static,
         A: StreamHandler<Result<Message, ProtocolError>>,
@@ -423,10 +423,7 @@ where
 {
     type Item = Result<Bytes, Error>;
 
-    fn poll_next(
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
         let this = self.get_mut();
 
         if this.fut.alive() {
@@ -493,15 +490,11 @@ where
 {
     type Item = Result<Message, ProtocolError>;
 
-    fn poll_next(
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
         let mut this = self.as_mut().project();
 
         if !*this.closed {
             loop {
-                this = self.as_mut().project();
                 match Pin::new(&mut this.stream).poll_next(cx) {
                     Poll::Ready(Some(Ok(chunk))) => {
                         this.buf.extend_from_slice(&chunk[..]);
@@ -512,9 +505,10 @@ where
                     }
                     Poll::Pending => break,
                     Poll::Ready(Some(Err(e))) => {
-                        return Poll::Ready(Some(Err(ProtocolError::Io(
+                        return Poll::Ready(Some(Err(ProtocolError::Io(io::Error::new(
-                            io::Error::new(io::ErrorKind::Other, format!("{}", e)),
+                            io::ErrorKind::Other,
-                        ))));
+                            format!("{}", e),
+                        )))));
                     }
                 }
             }

actix-web-actors/tests/test_ws.rs

@@ -11,11 +11,7 @@ impl Actor for Ws {
 }
 
 impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for Ws {
-    fn handle(
+    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
-        &mut self,
-        msg: Result<ws::Message, ws::ProtocolError>,
-        ctx: &mut Self::Context,
-    ) {
         match msg.unwrap() {
             ws::Message::Ping(msg) => ctx.pong(&msg),
             ws::Message::Text(text) => ctx.text(text),
@@ -30,9 +26,7 @@ impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for Ws {
 async fn test_simple() {
     let mut srv = test::start(|| {
         App::new().service(web::resource("/").to(
-            |req: HttpRequest, stream: web::Payload| async move {
+            |req: HttpRequest, stream: web::Payload| async move { ws::start(Ws, &req, stream) },
-                ws::start(Ws, &req, stream)
-            },
         ))
     });
 

actix-web-codegen/CHANGES.md

@@ -3,6 +3,18 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 0.5.0-beta.2 - 2021-03-09
+* Preserve doc comments when using route macros. [#2022]
+* Add `name` attribute to `route` macro. [#1934]
+
+[#2022]: https://github.com/actix/actix-web/pull/2022
+[#1934]: https://github.com/actix/actix-web/pull/1934
+
+
+## 0.5.0-beta.1 - 2021-02-10
+* Use new call signature for `System::new`.
+
+
 ## 0.4.0 - 2020-09-20
 * Added compile success and failure testing. [#1677]
 * Add `route` macro for supporting multiple HTTP methods guards. [#1674]

actix-web-codegen/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "actix-web-codegen"
-version = "0.4.0"
+version = "0.5.0-beta.2"
-description = "Actix web proc macros"
+description = "Routing and runtime macros for Actix Web"
 readme = "README.md"
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web"
@@ -19,8 +19,8 @@ syn = { version = "1", features = ["full", "parsing"] }
 proc-macro2 = "1"
 
 [dev-dependencies]
-actix-rt = "2"
+actix-rt = "2.1"
-actix-web = "4.0.0-beta.2"
+actix-web = "4.0.0-beta.4"
 futures-util = { version = "0.3.7", default-features = false }
 trybuild = "1"
 rustversion = "1"

actix-web-codegen/README.md

@@ -1,22 +1,24 @@
 # actix-web-codegen
 
-> Helper and convenience macros for Actix Web
+> Routing and runtime macros for Actix Web.
 
-[![crates.io](https://meritbadge.herokuapp.com/actix-web-codegen)](https://crates.io/crates/actix-web-codegen)
+[![crates.io](https://img.shields.io/crates/v/actix-web-codegen?label=latest)](https://crates.io/crates/actix-web-codegen)
-[![Documentation](https://docs.rs/actix-web-codegen/badge.svg)](https://docs.rs/actix-web-codegen/0.4.0/actix_web_codegen/)
+[![Documentation](https://docs.rs/actix-web-codegen/badge.svg?version=0.5.0-beta.2)](https://docs.rs/actix-web-codegen/0.5.0-beta.2)
 [![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-[![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web)
+![License](https://img.shields.io/crates/l/actix-web-codegen.svg)
-[![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web)
+<br />
+[![dependency status](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.2/status.svg)](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.2)
+[![Download](https://img.shields.io/crates/d/actix-web-codegen.svg)](https://crates.io/crates/actix-web-codegen)
 [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Documentation & Resources
 
 - [API Documentation](https://docs.rs/actix-web-codegen)
 - [Chat on Gitter](https://gitter.im/actix/actix-web)
-- Cargo package: [actix-web-codegen](https://crates.io/crates/actix-web-codegen)
 - Minimum supported Rust version: 1.46 or later.
 
 ## Compile Testing
+
 Uses the [`trybuild`] crate. All compile fail tests should include a stderr file generated by `trybuild`. See the [workflow section](https://github.com/dtolnay/trybuild#workflow) of the trybuild docs for info on how to do this.
 
 [`trybuild`]: https://github.com/dtolnay/trybuild

actix-web-codegen/src/lib.rs

@@ -1,6 +1,6 @@
-//! Macros for reducing boilerplate code in Actix Web applications.
+//! Routing and runtime macros for Actix Web.
 //!
-//! ## Actix Web Re-exports
+//! # Actix Web Re-exports
 //! Actix Web re-exports a version of this crate in it's entirety so you usually don't have to
 //! specify a dependency on this crate explicitly. Sometimes, however, updates are made to this
 //! crate before the actix-web dependency is updated. Therefore, code examples here will show
@@ -10,7 +10,7 @@
 //! # Runtime Setup
 //! Used for setting up the actix async runtime. See [macro@main] macro docs.
 //!
-//! ```rust
+//! ```
 //! #[actix_web_codegen::main] // or `#[actix_web::main]` in Actix Web apps
 //! async fn main() {
 //!     async { println!("Hello world"); }.await
@@ -23,7 +23,7 @@
 //!
 //! See docs for: [GET], [POST], [PATCH], [PUT], [DELETE], [HEAD], [CONNECT], [OPTIONS], [TRACE]
 //!
-//! ```rust
+//! ```
 //! # use actix_web::HttpResponse;
 //! # use actix_web_codegen::get;
 //! #[get("/test")]
@@ -36,7 +36,7 @@
 //! Similar to the single method handler macro but takes one or more arguments for the HTTP methods
 //! it should respond to. See [macro@route] macro docs.
 //!
-//! ```rust
+//! ```
 //! # use actix_web::HttpResponse;
 //! # use actix_web_codegen::route;
 //! #[route("/test", method="GET", method="HEAD")]
@@ -71,6 +71,7 @@ mod route;
 ///
 /// # Attributes
 /// - `"path"` - Raw literal string with path for which to register handler.
+/// - `name="resource_name"` - Specifies resource name for the handler. If not set, the function name of handler is used.
 /// - `method="HTTP_METHOD"` - Registers HTTP method to provide guard for. Upper-case string, "GET", "POST" for example.
 /// - `guard="function_name"` - Registers function as guard using `actix_web::guard::fn_guard`
 /// - `wrap="Middleware"` - Registers a resource middleware.
@@ -116,6 +117,7 @@ Creates route handler with `actix_web::guard::", stringify!($variant), "`.
 
 # Attributes
 - `"path"` - Raw literal string with path for which to register handler.
+- `name="resource_name"` - Specifies resource name for the handler. If not set, the function name of handler is used.
 - `guard="function_name"` - Registers function as guard using `actix_web::guard::fn_guard`.
 - `wrap="Middleware"` - Registers a resource middleware.
 

actix-web-codegen/src/route.rs

@@ -78,6 +78,7 @@ impl TryFrom<&syn::LitStr> for MethodType {
 
 struct Args {
     path: syn::LitStr,
+    resource_name: Option<syn::LitStr>,
     guards: Vec<Ident>,
     wrappers: Vec<syn::Type>,
     methods: HashSet<MethodType>,
@@ -86,6 +87,7 @@ struct Args {
 impl Args {
     fn new(args: AttributeArgs, method: Option<MethodType>) -> syn::Result<Self> {
         let mut path = None;
+        let mut resource_name = None;
         let mut guards = Vec::new();
         let mut wrappers = Vec::new();
         let mut methods = HashSet::new();
@@ -109,7 +111,16 @@ impl Args {
                     }
                 },
                 NestedMeta::Meta(syn::Meta::NameValue(nv)) => {
-                    if nv.path.is_ident("guard") {
+                    if nv.path.is_ident("name") {
+                        if let syn::Lit::Str(lit) = nv.lit {
+                            resource_name = Some(lit);
+                        } else {
+                            return Err(syn::Error::new_spanned(
+                                nv.lit,
+                                "Attribute name expects literal string!",
+                            ));
+                        }
+                    } else if nv.path.is_ident("guard") {
                         if let syn::Lit::Str(lit) = nv.lit {
                             guards.push(Ident::new(&lit.value(), Span::call_site()));
                         } else {
@@ -164,6 +175,7 @@ impl Args {
         }
         Ok(Args {
             path: path.unwrap(),
+            resource_name,
             guards,
             wrappers,
             methods,
@@ -176,6 +188,9 @@ pub struct Route {
     args: Args,
     ast: syn::ItemFn,
     resource_type: ResourceType,
+
+    /// The doc comment attributes to copy to generated struct, if any.
+    doc_attributes: Vec<syn::Attribute>,
 }
 
 fn guess_resource_type(typ: &syn::Type) -> ResourceType {
@@ -221,6 +236,18 @@ impl Route {
         let ast: syn::ItemFn = syn::parse(input)?;
         let name = ast.sig.ident.clone();
 
+        // Try and pull out the doc comments so that we can reapply them to the
+        // generated struct.
+        //
+        // Note that multi line doc comments are converted to multiple doc
+        // attributes.
+        let doc_attributes = ast
+            .attrs
+            .iter()
+            .filter(|attr| attr.path.is_ident("doc"))
+            .cloned()
+            .collect();
+
         let args = Args::new(args, method)?;
         if args.methods.is_empty() {
             return Err(syn::Error::new(
@@ -248,6 +275,7 @@ impl Route {
             args,
             ast,
             resource_type,
+            doc_attributes,
         })
     }
 }
@@ -260,13 +288,17 @@ impl ToTokens for Route {
             args:
                 Args {
                     path,
+                    resource_name,
                     guards,
                     wrappers,
                     methods,
                 },
             resource_type,
+            doc_attributes,
         } = self;
-        let resource_name = name.to_string();
+        let resource_name = resource_name
+            .as_ref()
+            .map_or_else(|| name.to_string(), |n| n.value());
         let method_guards = {
             let mut others = methods.iter();
             // unwrapping since length is checked to be at least one
@@ -287,6 +319,7 @@ impl ToTokens for Route {
         };
 
         let stream = quote! {
+            #(#doc_attributes)*
             #[allow(non_camel_case_types, missing_docs)]
             pub struct #name;
 

actix-web-codegen/tests/test_macro.rs

@@ -4,9 +4,7 @@ use std::task::{Context, Poll};
 use actix_web::dev::{Service, ServiceRequest, ServiceResponse, Transform};
 use actix_web::http::header::{HeaderName, HeaderValue};
 use actix_web::{http, test, web::Path, App, Error, HttpResponse, Responder};
-use actix_web_codegen::{
+use actix_web_codegen::{connect, delete, get, head, options, patch, post, put, route, trace};
-    connect, delete, get, head, options, patch, post, put, route, trace,
-};
 use futures_util::future::{self, LocalBoxFuture};
 
 // Make sure that we can name function as 'config'
@@ -85,6 +83,13 @@ async fn route_test() -> impl Responder {
     HttpResponse::Ok()
 }
 
+#[get("/custom_resource_name", name = "custom")]
+async fn custom_resource_name_test<'a>(req: actix_web::HttpRequest) -> impl Responder {
+    assert!(req.url_for_static("custom").is_ok());
+    assert!(req.url_for_static("custom_resource_name_test").is_err());
+    HttpResponse::Ok()
+}
+
 pub struct ChangeStatusCode;
 
 impl<S, B> Transform<S, ServiceRequest> for ChangeStatusCode
@@ -176,6 +181,7 @@ async fn test_body() {
             .service(patch_test)
             .service(test_handler)
             .service(route_test)
+            .service(custom_resource_name_test)
     });
     let request = srv.request(http::Method::GET, srv.url("/test"));
     let response = request.send().await.unwrap();
@@ -230,6 +236,10 @@ async fn test_body() {
     let request = srv.request(http::Method::PATCH, srv.url("/multi"));
     let response = request.send().await.unwrap();
     assert!(!response.status().is_success());
+
+    let request = srv.request(http::Method::GET, srv.url("/custom_resource_name"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
 }
 
 #[actix_rt::test]

actix-web-codegen/tests/trybuild.rs

@@ -9,6 +9,8 @@ fn compile_macros() {
     t.compile_fail("tests/trybuild/route-missing-method-fail.rs");
     t.compile_fail("tests/trybuild/route-duplicate-method-fail.rs");
     t.compile_fail("tests/trybuild/route-unexpected-method-fail.rs");
+
+    t.pass("tests/trybuild/docstring-ok.rs");
 }
 
 // #[rustversion::not(nightly)]

actix-web-codegen/tests/trybuild/docstring-ok.rs

@@ -0,0 +1,17 @@
+use actix_web::{Responder, HttpResponse, App, test};
+use actix_web_codegen::*;
+
+/// Docstrings shouldn't break anything.
+#[get("/")]
+async fn index() -> impl Responder {
+    HttpResponse::Ok()
+}
+
+#[actix_web::main]
+async fn main() {
+    let srv = test::start(|| App::new().service(index));
+
+    let request = srv.get("/");
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}

awc/CHANGES.md

@@ -3,6 +3,26 @@
 ## Unreleased - 2021-xx-xx
 
 
+## 3.0.0-beta.3 - 2021-03-08
+### Added
+* `ClientResponse::timeout` for set the timeout of collecting response body. [#1931]
+* `ClientBuilder::local_address` for bind to a local ip address for this client. [#2024]
+
+### Changed
+* Feature `cookies` is now optional and enabled by default. [#1981]
+* `ClientBuilder::connector` method would take `actix_http::client::Connector<T, U>` type. [#2008]
+* Basic auth password now takes blank passwords as an empty string instead of Option. [#2050]
+
+### Removed
+* `ClientBuilder::default` function [#2008]
+
+[#1931]: https://github.com/actix/actix-web/pull/1931
+[#1981]: https://github.com/actix/actix-web/pull/1981
+[#2008]: https://github.com/actix/actix-web/pull/2008
+[#2024]: https://github.com/actix/actix-web/pull/2024
+[#2050]: https://github.com/actix/actix-web/pull/2050
+
+
 ## 3.0.0-beta.2 - 2021-02-10
 ### Added
 * `ClientRequest::insert_header` method which allows using typed headers. [#1869]

awc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "awc"
-version = "3.0.0-beta.2"
+version = "3.0.0-beta.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Async HTTP and WebSocket client library built on the Actix ecosystem"
 readme = "README.md"
@@ -22,10 +22,11 @@ name = "awc"
 path = "src/lib.rs"
 
 [package.metadata.docs.rs]
-features = ["openssl", "rustls", "compress"]
+# features that docs.rs will build with
+features = ["openssl", "rustls", "compress", "cookies"]
 
 [features]
-default = ["compress"]
+default = ["compress", "cookies"]
 
 # openssl
 openssl = ["tls-openssl", "actix-http/openssl"]
@@ -36,23 +37,28 @@ rustls = ["tls-rustls", "actix-http/rustls"]
 # content-encoding support
 compress = ["actix-http/compress"]
 
+# cookie parsing and cookie jar
+cookies = ["actix-http/cookies"]
+
 # trust-dns as dns resolver
 trust-dns = ["actix-http/trust-dns"]
 
 [dependencies]
 actix-codec = "0.4.0-beta.1"
 actix-service = "2.0.0-beta.4"
-actix-http = "3.0.0-beta.2"
+actix-http = "3.0.0-beta.4"
-actix-rt = "2"
+actix-rt = { version = "2.1", default-features = false }
 
 base64 = "0.13"
 bytes = "1"
 cfg-if = "1.0"
 derive_more = "0.99.5"
 futures-core = { version = "0.3.7", default-features = false }
+itoa = "0.4"
 log =" 0.4"
 mime = "0.3"
 percent-encoding = "2.1"
+pin-project-lite = "0.2"
 rand = "0.8"
 serde = "1.0"
 serde_json = "1.0"
@@ -60,17 +66,23 @@ serde_urlencoded = "0.7"
 tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
 tls-rustls = { version = "0.19.0", package = "rustls", optional = true, features = ["dangerous_configuration"] }
 
+[target.'cfg(windows)'.dependencies.tls-openssl]
+version = "0.10.9"
+package = "openssl"
+features = ["vendored"]
+optional = true
+
 [dev-dependencies]
-actix-web = { version = "4.0.0-beta.2", features = ["openssl"] }
+actix-web = { version = "4.0.0-beta.4", features = ["openssl"] }
-actix-http = { version = "3.0.0-beta.2", features = ["openssl"] }
+actix-http = { version = "3.0.0-beta.4", features = ["openssl"] }
-actix-http-test = { version = "3.0.0-beta.2", features = ["openssl"] }
+actix-http-test = { version = "3.0.0-beta.3", features = ["openssl"] }
 actix-utils = "3.0.0-beta.1"
 actix-server = "2.0.0-beta.3"
-actix-tls = { version = "3.0.0-beta.3", features = ["openssl", "rustls"] }
+actix-tls = { version = "3.0.0-beta.4", features = ["openssl", "rustls"] }
 
 brotli2 = "0.3.2"
+env_logger = "0.8"
 flate2 = "1.0.13"
 futures-util = { version = "0.3.7", default-features = false }
-env_logger = "0.8"
 rcgen = "0.8"
 webpki = "0.21"