beta.7 releases (#2266 )

refined error model (#2253 )
fix cargo cache on msrv
2025-07-03 09:36:36 +02:00 · 2021-06-19 11:51:20 +01:00 · 2021-06-17 17:57:58 +01:00 · 2021-06-17 16:49:31 +01:00 · 2021-06-16 20:33:22 +01:00 · 2021-06-16 15:52:49 +01:00
166 changed files with 6876 additions and 4400 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@ -1,3 +1,8 @@
 [alias]
-chk = "hack check --workspace --all-features --tests --examples"
-lint = "hack --clean-per-run clippy --workspace --tests --examples"
+chk = "check --workspace --all-features --tests --examples --bins"
+lint = "clippy --workspace --tests --examples"
+ci-min = "hack check --workspace --no-default-features"
+ci-min-test = "hack check --workspace --no-default-features --tests --examples"
+ci-default = "hack check --workspace"
+ci-full = "check --workspace --bins --examples --tests"
+ci-test = "test --workspace --all-features --no-fail-fast"
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -86,7 +86,7 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: test
-          args: -v --workspace --all-features --no-fail-fast -- --nocapture
+          args: --workspace --all-features --no-fail-fast -- --nocapture
            --skip=test_h2_content_length
            --skip=test_reading_deflate_encoding_large_random_rustls

@ -123,5 +123,5 @@ jobs:

      - name: Clear the cargo caches
        run: |
-          cargo install cargo-cache --no-default-features --features ci-autoclean
+          cargo install cargo-cache --version 0.6.2 --no-default-features --features ci-autoclean
          cargo-cache
--- a/CHANGES.md
+++ b/CHANGES.md
@ -3,6 +3,45 @@
 ## Unreleased - 2021-xx-xx


+## 4.0.0-beta.7 - 2021-06-17
+### Added
+* `HttpServer::worker_max_blocking_threads` for setting block thread pool. [#2200]
+
+### Changed
+
+* Adjusted default JSON payload limit to 2MB (from 32kb) and included size and limits in the `JsonPayloadError::Overflow` error variant. [#2162]
+[#2162]: (https://github.com/actix/actix-web/pull/2162)
+* `ServiceResponse::error_response` now uses body type of `Body`. [#2201]
+* `ServiceResponse::checked_expr` now returns a `Result`. [#2201]
+* Update `language-tags` to `0.3`.
+* `ServiceResponse::take_body`. [#2201]
+* `ServiceResponse::map_body` closure receives and returns `B` instead of `ResponseBody<B>` types. [#2201]
+* All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
+* All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
+* `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
+* `middleware::normalize` now will not try to normalize URIs with no valid path [#2246]
+
+### Removed
+* `HttpResponse::take_body` and old `HttpResponse::into_body` method that casted body type. [#2201]
+
+[#2200]: https://github.com/actix/actix-web/pull/2200
+[#2201]: https://github.com/actix/actix-web/pull/2201
+[#2253]: https://github.com/actix/actix-web/pull/2253
+[#2246]: https://github.com/actix/actix-web/pull/2246
+
+
+## 4.0.0-beta.6 - 2021-04-17
+### Added
+* `HttpResponse` and `HttpResponseBuilder` structs. [#2065]
+
+### Changed
+* Most error types are now marked `#[non_exhaustive]`. [#2148]
+* Methods on `ContentDisposition` that took `T: AsRef<str>` now take `impl AsRef<str>`.
+
+[#2065]: https://github.com/actix/actix-web/pull/2065
+[#2148]: https://github.com/actix/actix-web/pull/2148
+
+
 ## 4.0.0-beta.5 - 2021-04-02
 ### Added
 * `Header` extractor for extracting common HTTP headers in handlers. [#2094]
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,26 +1,23 @@
 [package]
 name = "actix-web"
-version = "4.0.0-beta.5"
+version = "4.0.0-beta.7"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
-readme = "README.md"
 keywords = ["actix", "http", "web", "framework", "async"]
+categories = [
+    "network-programming",
+    "asynchronous",
+    "web-programming::http-server",
+    "web-programming::websocket"
+]
 homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-web/"
-categories = ["network-programming", "asynchronous",
-              "web-programming::http-server",
-              "web-programming::websocket"]
+repository = "https://github.com/actix/actix-web"
 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]
-travis-ci = { repository = "actix/actix-web", branch = "master" }
-codecov = { repository = "actix/actix-web", branch = "master", service = "github" }
+features = ["openssl", "rustls", "compress", "cookies", "secure-cookies"]

 [lib]
 name = "actix_web"
@ -28,16 +25,18 @@ path = "src/lib.rs"

 [workspace]
 members = [
-  ".",
-  "awc",
-  "actix-http",
-  "actix-files",
-  "actix-multipart",
-  "actix-web-actors",
-  "actix-web-codegen",
-  "actix-http-test",
-  "actix-test",
+    ".",
+    "awc",
+    "actix-http",
+    "actix-files",
+    "actix-multipart",
+    "actix-web-actors",
+    "actix-web-codegen",
+    "actix-http-test",
+    "actix-test",
 ]
+# enable when MSRV is 1.51+
+# resolver = "2"

 [features]
 default = ["compress", "cookies"]
@ -46,10 +45,10 @@ default = ["compress", "cookies"]
 compress = ["actix-http/compress"]

 # support for cookies
-cookies = ["actix-http/cookies"]
+cookies = ["cookie"]

 # secure cookies feature
-secure-cookies = ["actix-http/secure-cookies"]
+secure-cookies = ["cookie/secure"]

 # openssl
 openssl = ["actix-http/openssl", "actix-tls/accept", "actix-tls/openssl"]
@ -57,46 +56,33 @@ openssl = ["actix-http/openssl", "actix-tls/accept", "actix-tls/openssl"]
 # rustls
 rustls = ["actix-http/rustls", "actix-tls/accept", "actix-tls/rustls"]

-[[example]]
-name = "basic"
-required-features = ["compress"]
-
-[[example]]
-name = "uds"
-required-features = ["compress"]
-
-[[test]]
-name = "test_server"
-required-features = ["compress", "cookies"]
-
-[[example]]
-name = "on_connect"
-required-features = []
-
 [dependencies]
-actix-codec = "0.4.0-beta.1"
-actix-macros = "0.2.0"
+actix-codec = "0.4.0"
+actix-macros = "0.2.1"
 actix-router = "0.2.7"
 actix-rt = "2.2"
 actix-server = "2.0.0-beta.3"
-actix-service = "2.0.0-beta.4"
-actix-utils = "3.0.0-beta.4"
+actix-service = "2.0.0"
+actix-utils = "3.0.0"
 actix-tls = { version = "3.0.0-beta.5", default-features = false, optional = true }

 actix-web-codegen = "0.5.0-beta.2"
-actix-http = "3.0.0-beta.5"
+actix-http = "3.0.0-beta.7"

 ahash = "0.7"
 bytes = "1"
+cookie = { version = "0.15", features = ["percent-encode"], optional = true }
 derive_more = "0.99.5"
 either = "1.5.3"
 encoding_rs = "0.8"
 futures-core = { version = "0.3.7", default-features = false }
 futures-util = { version = "0.3.7", default-features = false }
-language-tags = "0.2"
+itoa = "0.4"
+language-tags = "0.3"
 once_cell = "1.5"
 log = "0.4"
 mime = "0.3"
+paste = "1"
 pin-project = "1.0.0"
 regex = "1.4"
 serde = { version = "1.0", features = ["derive"] }
@ -108,13 +94,14 @@ time = { version = "0.2.23", default-features = false, features = ["std"] }
 url = "2.1"

 [dev-dependencies]
-actix-test = { version = "0.0.1", features = ["openssl", "rustls"] }
-awc = { version = "3.0.0-beta.4", features = ["openssl"] }
+actix-test = { version = "0.1.0-beta.2", features = ["openssl", "rustls"] }
+awc = { version = "3.0.0-beta.6", features = ["openssl"] }

 brotli2 = "0.3.2"
 criterion = "0.3"
 env_logger = "0.8"
 flate2 = "1.0.13"
+zstd = "0.7"
 rand = "0.8"
 rcgen = "0.8"
 serde_derive = "1.0"
@ -137,6 +124,22 @@ actix-web-actors = { path = "actix-web-actors" }
 actix-web-codegen = { path = "actix-web-codegen" }
 awc = { path = "awc" }

+[[test]]
+name = "test_server"
+required-features = ["compress", "cookies"]
+
+[[example]]
+name = "basic"
+required-features = ["compress"]
+
+[[example]]
+name = "uds"
+required-features = ["compress"]
+
+[[example]]
+name = "on_connect"
+required-features = []
+
 [[bench]]
 name = "server"
 harness = false
--- a/2
+++ b/2
@ -1,4 +1,4 @@
-Copyright (c) 2017 Actix Team
+Copyright (c) 2017-NOW Actix Team

 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated
--- a/README.md
+++ b/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.5)](https://docs.rs/actix-web/4.0.0-beta.5)
+[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.0.0-beta.7)](https://docs.rs/actix-web/4.0.0-beta.7)
 [![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.5/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.5)
+[![Dependency Status](https://deps.rs/crate/actix-web/4.0.0-beta.7/status.svg)](https://deps.rs/crate/actix-web/4.0.0-beta.7)
 <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,7 +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://docs.rs/actix-web/latest/actix_web/client/index.html)
+* Includes an async [HTTP client](https://docs.rs/awc/)
 * Runs on stable Rust 1.46+

 ## Documentation
@ -90,7 +90,7 @@ You may consider checking out
 ## Benchmarks

 One of the fastest web frameworks available according to the
-[TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r19).
+[TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r20&test=composite).

 ## License

--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@ -3,6 +3,25 @@
 ## Unreleased - 2021-xx-xx


+## 0.6.0-beta.5 - 2021-06-17
+* `NamedFile` now implements `ServiceFactory` and `HttpServiceFactory` making it much more useful in routing. For example, it can be used directly as a default service. [#2135]
+* For symbolic links, `Content-Disposition` header no longer shows the filename of the original file. [#2156]
+* `Files::redirect_to_slash_directory()` now works as expected when used with `Files::show_files_listing()`. [#2225]
+* `application/{javascript, json, wasm}` mime type now have `inline` disposition by default. [#2257]
+
+[#2135]: https://github.com/actix/actix-web/pull/2135
+[#2156]: https://github.com/actix/actix-web/pull/2156
+[#2225]: https://github.com/actix/actix-web/pull/2225
+[#2257]: https://github.com/actix/actix-web/pull/2257
+
+
+## 0.6.0-beta.4 - 2021-04-02
+* No notable changes.
+
+* Add support for `.guard` in `Files` to selectively filter `Files` services. [#2046]
+
+[#2046]: https://github.com/actix/actix-web/pull/2046
+
 ## 0.6.0-beta.3 - 2021-03-09
 * No notable changes.

--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.6.0-beta.3"
+version = "0.6.0-beta.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static file serving for Actix Web"
 readme = "README.md"
@ -17,9 +17,10 @@ name = "actix_files"
 path = "src/lib.rs"

 [dependencies]
-actix-web = { version = "4.0.0-beta.5", default-features = false }
-actix-service = "2.0.0-beta.4"
-actix-utils = "3.0.0-beta.4"
+actix-web = { version = "4.0.0-beta.7", default-features = false }
+actix-http = "3.0.0-beta.7"
+actix-service = "2.0.0"
+actix-utils = "3.0.0"

 askama_escape = "0.10"
 bitflags = "1"
@ -34,5 +35,5 @@ percent-encoding = "2.1"

 [dev-dependencies]
 actix-rt = "2.2"
-actix-web = "4.0.0-beta.5"
-actix-test = "0.0.1"
+actix-web = "4.0.0-beta.7"
+actix-test = "0.1.0-beta.2"
--- a/actix-files/README.md
+++ b/actix-files/README.md
@ -3,11 +3,11 @@
 > 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.6.0-beta.3)](https://docs.rs/actix-files/0.6.0-beta.3)
+[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.0-beta.5)](https://docs.rs/actix-files/0.6.0-beta.5)
 [![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.6.0-beta.3/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.3)
+[![dependency status](https://deps.rs/crate/actix-files/0.6.0-beta.5/status.svg)](https://deps.rs/crate/actix-files/0.6.0-beta.5)
 [![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)

--- a/actix-files/src/error.rs
+++ b/actix-files/src/error.rs
@ -1,4 +1,4 @@
-use actix_web::{http::StatusCode, HttpResponse, ResponseError};
+use actix_web::{http::StatusCode, ResponseError};
 use derive_more::Display;

 /// Errors which can occur when serving static files.
@ -16,8 +16,8 @@ pub enum FilesError {

 /// Return `NotFound` for `FilesError`
 impl ResponseError for FilesError {
-    fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::NOT_FOUND)
+    fn status_code(&self) -> StatusCode {
+        StatusCode::NOT_FOUND
    }
 }

--- a/actix-files/src/files.rs
+++ b/actix-files/src/files.rs
@ -37,7 +37,8 @@ pub struct Files {
    renderer: Rc<DirectoryRenderer>,
    mime_override: Option<Rc<MimeOverride>>,
    file_flags: named::Flags,
-    guards: Option<Rc<dyn Guard>>,
+    use_guards: Option<Rc<dyn Guard>>,
+    guards: Vec<Rc<dyn Guard>>,
    hidden_files: bool,
 }

@ -59,6 +60,7 @@ impl Clone for Files {
            file_flags: self.file_flags,
            path: self.path.clone(),
            mime_override: self.mime_override.clone(),
+            use_guards: self.use_guards.clone(),
            guards: self.guards.clone(),
            hidden_files: self.hidden_files,
        }
@ -80,10 +82,9 @@ impl Files {
    /// If the mount path is set as the root path `/`, services registered after this one will
    /// be inaccessible. Register more specific handlers and services first.
    ///
-    /// `Files` uses a threadpool for blocking filesystem operations. By default, the pool uses a
-    /// max number of threads equal to `512 * HttpServer::worker`. Real time thread count are
-    /// adjusted with work load. More threads would spawn when need and threads goes idle for a
-    /// period of time would be de-spawned.
+    /// `Files` utilizes the existing Tokio thread-pool for blocking filesystem operations.
+    /// The number of running threads is adjusted over time as needed, up to a maximum of 512 times
+    /// the number of server [workers](actix_web::HttpServer::workers), by default.
    pub fn new<T: Into<PathBuf>>(mount_path: &str, serve_from: T) -> Files {
        let orig_dir = serve_from.into();
        let dir = match orig_dir.canonicalize() {
@ -104,7 +105,8 @@ impl Files {
            renderer: Rc::new(directory_listing),
            mime_override: None,
            file_flags: named::Flags::default(),
-            guards: None,
+            use_guards: None,
+            guards: Vec::new(),
            hidden_files: false,
        }
    }
@ -156,7 +158,6 @@ impl Files {
    /// Specifies whether to use ETag or not.
    ///
    /// Default is true.
-    #[inline]
    pub fn use_etag(mut self, value: bool) -> Self {
        self.file_flags.set(named::Flags::ETAG, value);
        self
@ -165,7 +166,6 @@ impl Files {
    /// Specifies whether to use Last-Modified or not.
    ///
    /// Default is true.
-    #[inline]
    pub fn use_last_modified(mut self, value: bool) -> Self {
        self.file_flags.set(named::Flags::LAST_MD, value);
        self
@ -174,31 +174,74 @@ impl Files {
    /// Specifies whether text responses should signal a UTF-8 encoding.
    ///
    /// Default is false (but will default to true in a future version).
-    #[inline]
    pub fn prefer_utf8(mut self, value: bool) -> Self {
        self.file_flags.set(named::Flags::PREFER_UTF8, value);
        self
    }

-    /// Specifies custom guards to use for directory listings and files.
+    /// Adds a routing guard.
    ///
-    /// Default behaviour allows GET and HEAD.
-    #[inline]
-    pub fn use_guards<G: Guard + 'static>(mut self, guards: G) -> Self {
-        self.guards = Some(Rc::new(guards));
+    /// Use this to allow multiple chained file services that respond to strictly different
+    /// properties of a request. Due to the way routing works, if a guard check returns true and the
+    /// request starts being handled by the file service, it will not be able to back-out and try
+    /// the next service, you will simply get a 404 (or 405) error response.
+    ///
+    /// To allow `POST` requests to retrieve files, see [`Files::use_guards`].
+    ///
+    /// # Examples
+    /// ```
+    /// use actix_web::{guard::Header, App};
+    /// use actix_files::Files;
+    ///
+    /// App::new().service(
+    ///     Files::new("/","/my/site/files")
+    ///         .guard(Header("Host", "example.com"))
+    /// );
+    /// ```
+    pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
+        self.guards.push(Rc::new(guard));
        self
    }

+    /// Specifies guard to check before fetching directory listings or files.
+    ///
+    /// Note that this guard has no effect on routing; it's main use is to guard on the request's
+    /// method just before serving the file, only allowing `GET` and `HEAD` requests by default.
+    /// See [`Files::guard`] for routing guards.
+    pub fn method_guard<G: Guard + 'static>(mut self, guard: G) -> Self {
+        self.use_guards = Some(Rc::new(guard));
+        self
+    }
+
+    #[doc(hidden)]
+    #[deprecated(since = "0.6.0", note = "Renamed to `method_guard`.")]
+    /// See [`Files::method_guard`].
+    pub fn use_guards<G: Guard + 'static>(self, guard: G) -> Self {
+        self.method_guard(guard)
+    }
+
    /// Disable `Content-Disposition` header.
    ///
    /// By default Content-Disposition` header is enabled.
-    #[inline]
    pub fn disable_content_disposition(mut self) -> Self {
        self.file_flags.remove(named::Flags::CONTENT_DISPOSITION);
        self
    }

    /// Sets default handler which is used when no matched file could be found.
+    ///
+    /// # Examples
+    /// Setting a fallback static file handler:
+    /// ```
+    /// use actix_files::{Files, NamedFile};
+    ///
+    /// # fn run() -> Result<(), actix_web::Error> {
+    /// let files = Files::new("/", "./static")
+    ///     .index_file("index.html")
+    ///     .default_handler(NamedFile::open("./static/404.html")?);
+    /// # Ok(())
+    /// # }
+    /// ```
    pub fn default_handler<F, U>(mut self, f: F) -> Self
    where
        F: IntoServiceFactory<U, ServiceRequest>,
@ -218,7 +261,6 @@ impl Files {
    }

    /// Enables serving hidden files and directories, allowing a leading dots in url fragments.
-    #[inline]
    pub fn use_hidden_files(mut self) -> Self {
        self.hidden_files = true;
        self
@ -226,7 +268,19 @@ impl Files {
 }

 impl HttpServiceFactory for Files {
-    fn register(self, config: &mut AppService) {
+    fn register(mut self, config: &mut AppService) {
+        let guards = if self.guards.is_empty() {
+            None
+        } else {
+            let guards = std::mem::take(&mut self.guards);
+            Some(
+                guards
+                    .into_iter()
+                    .map(|guard| -> Box<dyn Guard> { Box::new(guard) })
+                    .collect::<Vec<_>>(),
+            )
+        };
+
        if self.default.borrow().is_none() {
            *self.default.borrow_mut() = Some(config.default_service());
        }
@ -237,7 +291,7 @@ impl HttpServiceFactory for Files {
            ResourceDef::prefix(&self.path)
        };

-        config.register_service(rdef, None, self, None)
+        config.register_service(rdef, guards, self, None)
    }
 }

@ -259,7 +313,7 @@ impl ServiceFactory<ServiceRequest> for Files {
            renderer: self.renderer.clone(),
            mime_override: self.mime_override.clone(),
            file_flags: self.file_flags,
-            guards: self.guards.clone(),
+            guards: self.use_guards.clone(),
            hidden_files: self.hidden_files,
        };

--- a/actix-files/src/lib.rs
+++ b/actix-files/src/lib.rs
@ -279,6 +279,22 @@ mod tests {
        );
    }

+    #[actix_rt::test]
+    async fn test_named_file_javascript() {
+        let file = NamedFile::open("tests/test.js").unwrap();
+
+        let req = TestRequest::default().to_http_request();
+        let resp = file.respond_to(&req).await.unwrap();
+        assert_eq!(
+            resp.headers().get(header::CONTENT_TYPE).unwrap(),
+            "application/javascript"
+        );
+        assert_eq!(
+            resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+            "inline; filename=\"test.js\""
+        );
+    }
+
    #[actix_rt::test]
    async fn test_named_file_image_attachment() {
        let cd = ContentDisposition {
@ -532,7 +548,7 @@ mod tests {
    #[actix_rt::test]
    async fn test_files_guards() {
        let srv = test::init_service(
-            App::new().service(Files::new("/", ".").use_guards(guard::Post())),
+            App::new().service(Files::new("/", ".").method_guard(guard::Post())),
        )
        .await;

@ -632,7 +648,7 @@ mod tests {

    #[actix_rt::test]
    async fn test_redirect_to_slash_directory() {
-        // should not redirect if no index
+        // should not redirect if no index and files listing is disabled
        let srv = test::init_service(
            App::new().service(Files::new("/", ".").redirect_to_slash_directory()),
        )
@ -654,6 +670,19 @@ mod tests {
        let resp = test::call_service(&srv, req).await;
        assert_eq!(resp.status(), StatusCode::FOUND);

+        // should redirect if files listing is enabled
+        let srv = test::init_service(
+            App::new().service(
+                Files::new("/", ".")
+                    .show_files_listing()
+                    .redirect_to_slash_directory(),
+            ),
+        )
+        .await;
+        let req = TestRequest::with_uri("/tests").to_request();
+        let resp = test::call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::FOUND);
+
        // should not redirect if the path is wrong
        let req = TestRequest::with_uri("/not_existing").to_request();
        let resp = test::call_service(&srv, req).await;
@ -754,4 +783,93 @@ mod tests {
        let res = test::call_service(&srv, req).await;
        assert_eq!(res.status(), StatusCode::OK);
    }
+
+    #[actix_rt::test]
+    async fn test_serve_named_file() {
+        let srv =
+            test::init_service(App::new().service(NamedFile::open("Cargo.toml").unwrap()))
+                .await;
+
+        let req = TestRequest::get().uri("/Cargo.toml").to_request();
+        let res = test::call_service(&srv, req).await;
+        assert_eq!(res.status(), StatusCode::OK);
+
+        let bytes = test::read_body(res).await;
+        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+        assert_eq!(bytes, data);
+
+        let req = TestRequest::get().uri("/test/unknown").to_request();
+        let res = test::call_service(&srv, req).await;
+        assert_eq!(res.status(), StatusCode::NOT_FOUND);
+    }
+
+    #[actix_rt::test]
+    async fn test_serve_named_file_prefix() {
+        let srv = test::init_service(
+            App::new()
+                .service(web::scope("/test").service(NamedFile::open("Cargo.toml").unwrap())),
+        )
+        .await;
+
+        let req = TestRequest::get().uri("/test/Cargo.toml").to_request();
+        let res = test::call_service(&srv, req).await;
+        assert_eq!(res.status(), StatusCode::OK);
+
+        let bytes = test::read_body(res).await;
+        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+        assert_eq!(bytes, data);
+
+        let req = TestRequest::get().uri("/Cargo.toml").to_request();
+        let res = test::call_service(&srv, req).await;
+        assert_eq!(res.status(), StatusCode::NOT_FOUND);
+    }
+
+    #[actix_rt::test]
+    async fn test_named_file_default_service() {
+        let srv = test::init_service(
+            App::new().default_service(NamedFile::open("Cargo.toml").unwrap()),
+        )
+        .await;
+
+        for route in ["/foobar", "/baz", "/"].iter() {
+            let req = TestRequest::get().uri(route).to_request();
+            let res = test::call_service(&srv, req).await;
+            assert_eq!(res.status(), StatusCode::OK);
+
+            let bytes = test::read_body(res).await;
+            let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+            assert_eq!(bytes, data);
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_default_handler_named_file() {
+        let st = Files::new("/", ".")
+            .default_handler(NamedFile::open("Cargo.toml").unwrap())
+            .new_service(())
+            .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;
+        let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+        assert_eq!(bytes, data);
+    }
+
+    #[actix_rt::test]
+    async fn test_symlinks() {
+        let srv = test::init_service(App::new().service(Files::new("test", "."))).await;
+
+        let req = TestRequest::get()
+            .uri("/test/tests/symlink-test.png")
+            .to_request();
+        let res = test::call_service(&srv, req).await;
+        assert_eq!(res.status(), StatusCode::OK);
+        assert_eq!(
+            res.headers().get(header::CONTENT_DISPOSITION).unwrap(),
+            "inline; filename=\"symlink-test.png\""
+        );
+    }
 }
--- a/actix-files/src/named.rs
+++ b/actix-files/src/named.rs
@ -1,3 +1,6 @@
+use actix_service::{Service, ServiceFactory};
+use actix_utils::future::{ok, ready, Ready};
+use actix_web::dev::{AppService, HttpServiceFactory, ResourceDef};
 use std::fs::{File, Metadata};
 use std::io;
 use std::ops::{Deref, DerefMut};
@ -8,14 +11,14 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use std::os::unix::fs::MetadataExt;

 use actix_web::{
-    dev::{BodyEncoding, SizedStream},
+    dev::{BodyEncoding, ServiceRequest, ServiceResponse, SizedStream},
    http::{
        header::{
            self, Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue,
        },
        ContentEncoding, StatusCode,
    },
-    HttpMessage, HttpRequest, HttpResponse, Responder,
+    Error, HttpMessage, HttpRequest, HttpResponse, Responder,
 };
 use bitflags::bitflags;
 use mime_guess::from_path;
@ -39,6 +42,29 @@ impl Default for Flags {
 }

 /// A file with an associated name.
+///
+/// `NamedFile` can be registered as services:
+/// ```
+/// use actix_web::App;
+/// use actix_files::NamedFile;
+///
+/// # fn run() -> Result<(), Box<dyn std::error::Error>> {
+/// let app = App::new()
+///     .service(NamedFile::open("./static/index.html")?);
+/// # Ok(())
+/// # }
+/// ```
+///
+/// They can also be returned from handlers:
+/// ```
+/// use actix_web::{Responder, get};
+/// use actix_files::NamedFile;
+///
+/// #[get("/")]
+/// async fn index() -> impl Responder {
+///     NamedFile::open("./static/index.html")
+/// }
+/// ```
 #[derive(Debug)]
 pub struct NamedFile {
    path: PathBuf,
@ -94,6 +120,11 @@ impl NamedFile {

            let disposition = match ct.type_() {
                mime::IMAGE | mime::TEXT | mime::VIDEO => DispositionType::Inline,
+                mime::APPLICATION => match ct.subtype() {
+                    mime::JAVASCRIPT | mime::JSON => DispositionType::Inline,
+                    name if name == "wasm" => DispositionType::Inline,
+                    _ => DispositionType::Attachment,
+                },
                _ => DispositionType::Attachment,
            };

@ -187,9 +218,11 @@ impl NamedFile {

    /// Set the Content-Disposition for serving this file. This allows
    /// changing the inline/attachment disposition as well as the filename
-    /// sent to the peer. By default the disposition is `inline` for text,
-    /// image, and video content types, and `attachment` otherwise, and
-    /// the filename is taken from the path provided in the `open` method
+    /// sent to the peer.
+    ///
+    /// By default the disposition is `inline` for `text/*`, `image/*`, `video/*` and
+    /// `application/{javascript, json, wasm}` mime types, and `attachment` otherwise,
+    /// and the filename is taken from the path provided in the `open` method
    /// after converting it to UTF-8 using.
    /// [`std::ffi::OsStr::to_string_lossy`]
    #[inline]
@ -209,6 +242,8 @@ impl NamedFile {
    }

    /// Set content encoding for serving this file
+    ///
+    /// Must be used with [`actix_web::middleware::Compress`] to take effect.
    #[inline]
    pub fn set_content_encoding(mut self, enc: ContentEncoding) -> Self {
        self.encoding = Some(enc);
@ -480,3 +515,53 @@ impl Responder for NamedFile {
        self.into_response(req)
    }
 }
+
+impl ServiceFactory<ServiceRequest> for NamedFile {
+    type Response = ServiceResponse;
+    type Error = Error;
+    type Config = ();
+    type InitError = ();
+    type Service = NamedFileService;
+    type Future = Ready<Result<Self::Service, ()>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        ok(NamedFileService {
+            path: self.path.clone(),
+        })
+    }
+}
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct NamedFileService {
+    path: PathBuf,
+}
+
+impl Service<ServiceRequest> for NamedFileService {
+    type Response = ServiceResponse;
+    type Error = Error;
+    type Future = Ready<Result<Self::Response, Self::Error>>;
+
+    actix_service::always_ready!();
+
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        let (req, _) = req.into_parts();
+        ready(
+            NamedFile::open(&self.path)
+                .map_err(|e| e.into())
+                .map(|f| f.into_response(&req))
+                .map(|res| ServiceResponse::new(req, res)),
+        )
+    }
+}
+
+impl HttpServiceFactory for NamedFile {
+    fn register(self, config: &mut AppService) {
+        config.register_service(
+            ResourceDef::root_prefix(self.path.to_string_lossy().as_ref()),
+            None,
+            self,
+            None,
+        )
+    }
+}
--- a/actix-files/src/service.rs
+++ b/actix-files/src/service.rs
@ -83,24 +83,26 @@ impl Service<ServiceRequest> for FilesService {
            };

        // full file path
-        let path = match self.directory.join(&real_path).canonicalize() {
-            Ok(path) => path,
-            Err(err) => return Box::pin(self.handle_err(err, req)),
-        };
+        let path = self.directory.join(&real_path);
+        if let Err(err) = path.canonicalize() {
+            return Box::pin(self.handle_err(err, req));
+        }

        if path.is_dir() {
+            if self.redirect_to_slash
+                && !req.path().ends_with('/')
+                && (self.index.is_some() || self.show_index)
+            {
+                let redirect_to = format!("{}/", req.path());
+
+                return Box::pin(ok(req.into_response(
+                    HttpResponse::Found()
+                        .insert_header((header::LOCATION, redirect_to))
+                        .finish(),
+                )));
+            }
+
            if let Some(ref redir_index) = self.index {
-                if self.redirect_to_slash && !req.path().ends_with('/') {
-                    let redirect_to = format!("{}/", req.path());
-
-                    return Box::pin(ok(req.into_response(
-                        HttpResponse::Found()
-                            .insert_header((header::LOCATION, redirect_to))
-                            .body("")
-                            .into_body(),
-                    )));
-                }
-
                let path = path.join(redir_index);

                match NamedFile::open(path) {
--- a/actix-files/tests/fixtures/guards/first/index.txt
+++ b/actix-files/tests/fixtures/guards/first/index.txt
@ -0,0 +1 @@
+first
--- a/actix-files/tests/fixtures/guards/second/index.txt
+++ b/actix-files/tests/fixtures/guards/second/index.txt
@ -0,0 +1 @@
+second
--- a/actix-files/tests/guard.rs
+++ b/actix-files/tests/guard.rs
@ -0,0 +1,36 @@
+use actix_files::Files;
+use actix_web::{
+    guard::Host,
+    http::StatusCode,
+    test::{self, TestRequest},
+    App,
+};
+use bytes::Bytes;
+
+#[actix_rt::test]
+async fn test_guard_filter() {
+    let srv = test::init_service(
+        App::new()
+            .service(Files::new("/", "./tests/fixtures/guards/first").guard(Host("first.com")))
+            .service(
+                Files::new("/", "./tests/fixtures/guards/second").guard(Host("second.com")),
+            ),
+    )
+    .await;
+
+    let req = TestRequest::with_uri("/index.txt")
+        .append_header(("Host", "first.com"))
+        .to_request();
+    let res = test::call_service(&srv, req).await;
+
+    assert_eq!(res.status(), StatusCode::OK);
+    assert_eq!(test::read_body(res).await, Bytes::from("first"));
+
+    let req = TestRequest::with_uri("/index.txt")
+        .append_header(("Host", "second.com"))
+        .to_request();
+    let res = test::call_service(&srv, req).await;
+
+    assert_eq!(res.status(), StatusCode::OK);
+    assert_eq!(test::read_body(res).await, Bytes::from("second"));
+}
--- a/actix-files/tests/symlink-test.png
+++ b/actix-files/tests/symlink-test.png
@ -0,0 +1 @@
+test.png
--- a/actix-files/tests/test.js
+++ b/actix-files/tests/test.js
@ -0,0 +1 @@
+// this file is empty.
--- a/actix-http-test/CHANGES.md
+++ b/actix-http-test/CHANGES.md
@ -1,9 +1,14 @@
 # Changes

 ## Unreleased - 2021-xx-xx
-### Added
+
+
+## 3.0.0-beta.4 - 2021-04-02
 * Added `TestServer::client_headers` method. [#2097]

+[#2097]: https://github.com/actix/actix-web/pull/2097
+
+
 ## 3.0.0-beta.3 - 2021-03-09
 * No notable changes.

--- a/actix-http-test/Cargo.toml
+++ b/actix-http-test/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-http-test"
-version = "3.0.0-beta.3"
+version = "3.0.0-beta.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Various helpers for Actix applications to use during testing"
 readme = "README.md"
@ -29,13 +29,13 @@ default = []
 openssl = ["tls-openssl", "awc/openssl"]

 [dependencies]
-actix-service = "2.0.0-beta.4"
-actix-codec = "0.4.0-beta.1"
+actix-service = "2.0.0"
+actix-codec = "0.4.0"
 actix-tls = "3.0.0-beta.5"
-actix-utils = "3.0.0-beta.4"
+actix-utils = "3.0.0"
 actix-rt = "2.2"
 actix-server = "2.0.0-beta.3"
-awc = { version = "3.0.0-beta.4", default-features = false }
+awc = { version = "3.0.0-beta.6", default-features = false }

 base64 = "0.13"
 bytes = "1"
@ -51,5 +51,5 @@ time = { version = "0.2.23", default-features = false, features = ["std"] }
 tls-openssl = { version = "0.10.9", package = "openssl", optional = true }

 [dev-dependencies]
-actix-web = { version = "4.0.0-beta.5", default-features = false, features = ["cookies"] }
-actix-http = "3.0.0-beta.5"
+actix-web = { version = "4.0.0-beta.7", default-features = false, features = ["cookies"] }
+actix-http = "3.0.0-beta.7"
--- a/actix-http-test/README.md
+++ b/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=3.0.0-beta.3)](https://docs.rs/actix-http-test/3.0.0-beta.3)
+[![Documentation](https://docs.rs/actix-http-test/badge.svg?version=3.0.0-beta.4)](https://docs.rs/actix-http-test/3.0.0-beta.4)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http-test)
-[![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)
+[![Dependency Status](https://deps.rs/crate/actix-http-test/3.0.0-beta.4/status.svg)](https://deps.rs/crate/actix-http-test/3.0.0-beta.4)
 [![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
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@ -3,6 +3,83 @@
 ## Unreleased - 2021-xx-xx


+## 3.0.0-beta.7 - 2021-06-17
+### Added
+* Alias `body::Body` as `body::AnyBody`. [#2215]
+* `BoxAnyBody`: a boxed message body with boxed errors. [#2183]
+* Re-export `http` crate's `Error` type as `error::HttpError`. [#2171]
+* Re-export `StatusCode`, `Method`, `Version` and `Uri` at the crate root. [#2171]
+* Re-export `ContentEncoding` and `ConnectionType` at the crate root. [#2171]
+* `Response::into_body` that consumes response and returns body type. [#2201]
+* `impl Default` for `Response`. [#2201]
+* Add zstd support for `ContentEncoding`. [#2244]
+
+### Changed
+* The `MessageBody` trait now has an associated `Error` type. [#2183]
+* All error trait bounds in server service builders have changed from `Into<Error>` to `Into<Response<AnyBody>>`. [#2253]
+* All error trait bounds in message body and stream impls changed from `Into<Error>` to `Into<Box<dyn std::error::Error>>`. [#2253]
+* Places in `Response` where `ResponseBody<B>` was received or returned now simply use `B`. [#2201]
+* `header` mod is now public. [#2171]
+* `uri` mod is now public. [#2171]
+* Update `language-tags` to `0.3`.
+* Reduce the level from `error` to `debug` for the log line that is emitted when a `500 Internal Server Error` is built using `HttpResponse::from_error`. [#2201]
+* `ResponseBuilder::message_body` now returns a `Result`. [#2201]
+* Remove `Unpin` bound on `ResponseBuilder::streaming`. [#2253]
+* `HttpServer::{listen_rustls(), bind_rustls()}` now honor the ALPN protocols in the configuation parameter. [#2226]
+
+### Removed
+* Stop re-exporting `http` crate's `HeaderMap` types in addition to ours. [#2171]
+* Down-casting for `MessageBody` types. [#2183]
+* `error::Result` alias. [#2201]
+* Error field from `Response` and `Response::error`. [#2205]
+* `impl Future` for `Response`. [#2201]
+* `Response::take_body` and old `Response::into_body` method that casted body type. [#2201]
+* `InternalError` and all the error types it constructed. [#2215]
+* Conversion (`impl Into`) of `Response<Body>` and `ResponseBuilder` to `Error`. [#2215]
+
+[#2171]: https://github.com/actix/actix-web/pull/2171
+[#2183]: https://github.com/actix/actix-web/pull/2183
+[#2196]: https://github.com/actix/actix-web/pull/2196
+[#2201]: https://github.com/actix/actix-web/pull/2201
+[#2205]: https://github.com/actix/actix-web/pull/2205
+[#2215]: https://github.com/actix/actix-web/pull/2215
+[#2253]: https://github.com/actix/actix-web/pull/2253
+[#2244]: https://github.com/actix/actix-web/pull/2244
+
+
+
+## 3.0.0-beta.6 - 2021-04-17
+### Added
+* `impl<T: MessageBody> MessageBody for Pin<Box<T>>`. [#2152]
+* `Response::{ok, bad_request, not_found, internal_server_error}`. [#2159]
+* Helper `body::to_bytes` for async collecting message body into Bytes. [#2158]
+
+### Changes
+* The type parameter of `Response` no longer has a default. [#2152]
+* The `Message` variant of `body::Body` is now `Pin<Box<dyn MessageBody>>`. [#2152]
+* `BodyStream` and `SizedStream` are no longer restricted to Unpin types. [#2152]
+* Error enum types are marked `#[non_exhaustive]`. [#2161]
+
+### Removed
+* `cookies` feature flag. [#2065]
+* Top-level `cookies` mod (re-export). [#2065]
+* `HttpMessage` trait loses the `cookies` and `cookie` methods. [#2065]
+* `impl ResponseError for CookieParseError`. [#2065]
+* Deprecated methods on `ResponseBuilder`: `if_true`, `if_some`. [#2148]
+* `ResponseBuilder::json`. [#2148]
+* `ResponseBuilder::{set_header, header}`. [#2148]
+* `impl From<serde_json::Value> for Body`. [#2148]
+* `Response::build_from`. [#2159]
+* Most of the status code builders on `Response`. [#2159]
+
+[#2065]: https://github.com/actix/actix-web/pull/2065
+[#2148]: https://github.com/actix/actix-web/pull/2148
+[#2152]: https://github.com/actix/actix-web/pull/2152
+[#2159]: https://github.com/actix/actix-web/pull/2159
+[#2158]: https://github.com/actix/actix-web/pull/2158
+[#2161]: https://github.com/actix/actix-web/pull/2161
+
+
 ## 3.0.0-beta.5 - 2021-04-02
 ### Added
 * `client::Connector::handshake_timeout` method for customizing TLS connection handshake timeout. [#2081]
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "3.0.0-beta.5"
+version = "3.0.0-beta.7"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "HTTP primitives for the Actix ecosystem"
 readme = "README.md"
@ -16,7 +16,7 @@ edition = "2018"

 [package.metadata.docs.rs]
 # features that docs.rs will build with
-features = ["openssl", "rustls", "compress", "cookies", "secure-cookies"]
+features = ["openssl", "rustls", "compress"]

 [lib]
 name = "actix_http"
@ -32,21 +32,15 @@ openssl = ["actix-tls/openssl"]
 rustls = ["actix-tls/rustls"]

 # enable compression support
-compress = ["flate2", "brotli2"]
-
-# support for cookies
-cookies = ["cookie"]
-
-# support for secure cookies
-secure-cookies = ["cookies", "cookie/secure"]
+compress = ["flate2", "brotli2", "zstd"]

 # trust-dns as client dns resolver
 trust-dns = ["trust-dns-resolver"]

 [dependencies]
-actix-service = "2.0.0-beta.4"
-actix-codec = "0.4.0-beta.1"
-actix-utils = "3.0.0-beta.4"
+actix-service = "2.0.0"
+actix-codec = "0.4.0"
+actix-utils = "3.0.0"
 actix-rt = "2.2"
 actix-tls = { version = "3.0.0-beta.5", features = ["accept", "connect"] }

@ -55,7 +49,6 @@ base64 = "0.13"
 bitflags = "1.2"
 bytes = "1"
 bytestring = "1"
-cookie = { version = "0.14.1", features = ["percent-encode"], optional = true }
 derive_more = "0.99.5"
 encoding_rs = "0.8"
 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
@ -64,7 +57,7 @@ h2 = "0.3.1"
 http = "0.2.2"
 httparse = "1.3"
 itoa = "0.4"
-language-tags = "0.2"
+language-tags = "0.3"
 local-channel = "0.1"
 once_cell = "1.5"
 log = "0.4"
@ -75,8 +68,6 @@ pin-project-lite = "0.2"
 rand = "0.8"
 regex = "1.3"
 serde = "1.0"
-serde_json = "1.0"
-serde_urlencoded = "0.7"
 sha-1 = "0.9"
 smallvec = "1.6"
 time = { version = "0.2.23", default-features = false, features = ["std"] }
@ -85,19 +76,23 @@ tokio = { version = "1.2", features = ["sync"] }
 # compression
 brotli2 = { version="0.3.2", optional = true }
 flate2 = { version = "1.0.13", optional = true }
+zstd = { version = "0.7", optional = true }

 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.3", features = ["openssl"] }
+actix-http-test = { version = "3.0.0-beta.4", features = ["openssl"] }
 actix-tls = { version = "3.0.0-beta.5", features = ["openssl"] }
-criterion = "0.3"
+async-stream = "0.3"
+criterion = { version = "0.3", features = ["html_reports"] }
 env_logger = "0.8"
 rcgen = "0.8"
-serde_derive = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 tls-openssl = { version = "0.10", package = "openssl" }
 tls-rustls = { version = "0.19", package = "rustls" }
+webpki = { version = "0.21.0" }

 [[example]]
 name = "ws"
--- a/actix-http/README.md
+++ b/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.5)](https://docs.rs/actix-http/3.0.0-beta.5)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.0.0-beta.7)](https://docs.rs/actix-http/3.0.0-beta.7)
 [![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.5/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.5)
+[![dependency status](https://deps.rs/crate/actix-http/3.0.0-beta.7/status.svg)](https://deps.rs/crate/actix-http/3.0.0-beta.7)
 [![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)

--- a/actix-http/examples/echo.rs
+++ b/actix-http/examples/echo.rs
@ -1,19 +1,17 @@
-use std::{env, io};
+use std::io;

-use actix_http::{Error, HttpService, Request, Response};
+use actix_http::{http::StatusCode, Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
 use futures_util::StreamExt as _;
 use http::header::HeaderValue;
-use log::info;

 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "echo=info");
-    env_logger::init();
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));

    Server::build()
-        .bind("echo", "127.0.0.1:8080", || {
+        .bind("echo", ("127.0.0.1", 8080), || {
            HttpService::build()
                .client_timeout(1000)
                .client_disconnect(1000)
@ -23,9 +21,10 @@ async fn main() -> io::Result<()> {
                        body.extend_from_slice(&item?);
                    }

-                    info!("request body: {:?}", body);
+                    log::info!("request body: {:?}", body);
+
                    Ok::<_, Error>(
-                        Response::Ok()
+                        Response::build(StatusCode::OK)
                            .insert_header((
                                "x-head",
                                HeaderValue::from_static("dummy value!"),
--- a/actix-http/examples/echo2.rs
+++ b/actix-http/examples/echo2.rs
@ -1,31 +1,30 @@
-use std::{env, io};
+use std::io;

-use actix_http::http::HeaderValue;
+use actix_http::{body::Body, http::HeaderValue, http::StatusCode};
 use actix_http::{Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
 use futures_util::StreamExt as _;
-use log::info;

-async fn handle_request(mut req: Request) -> Result<Response, Error> {
+async fn handle_request(mut req: Request) -> Result<Response<Body>, Error> {
    let mut body = BytesMut::new();
    while let Some(item) = req.payload().next().await {
        body.extend_from_slice(&item?)
    }

-    info!("request body: {:?}", body);
-    Ok(Response::Ok()
+    log::info!("request body: {:?}", body);
+
+    Ok(Response::build(StatusCode::OK)
        .insert_header(("x-head", HeaderValue::from_static("dummy value!")))
        .body(body))
 }

 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "echo=info");
-    env_logger::init();
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));

    Server::build()
-        .bind("echo", "127.0.0.1:8080", || {
+        .bind("echo", ("127.0.0.1", 8080), || {
            HttpService::build().finish(handle_request).tcp()
        })?
        .run()
--- a/actix-http/examples/hello-world.rs
+++ b/actix-http/examples/hello-world.rs
@ -1,29 +1,28 @@
-use std::{env, io};
+use std::{convert::Infallible, io};

-use actix_http::{HttpService, Response};
+use actix_http::{http::StatusCode, HttpService, Response};
 use actix_server::Server;
-use actix_utils::future;
 use http::header::HeaderValue;
-use log::info;

 #[actix_rt::main]
 async fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "hello_world=info");
-    env_logger::init();
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));

    Server::build()
-        .bind("hello-world", "127.0.0.1:8080", || {
+        .bind("hello-world", ("127.0.0.1", 8080), || {
            HttpService::build()
                .client_timeout(1000)
                .client_disconnect(1000)
-                .finish(|_req| {
-                    info!("{:?}", _req);
-                    let mut res = Response::Ok();
+                .finish(|req| async move {
+                    log::info!("{:?}", req);
+
+                    let mut res = Response::build(StatusCode::OK);
                    res.insert_header((
                        "x-head",
                        HeaderValue::from_static("dummy value!"),
                    ));
-                    future::ok::<_, ()>(res.body("Hello world!"))
+
+                    Ok::<_, Infallible>(res.body("Hello world!"))
                })
                .tcp()
        })?
--- a/actix-http/examples/streaming-error.rs
+++ b/actix-http/examples/streaming-error.rs
@ -0,0 +1,40 @@
+//! Example showing response body (chunked) stream erroring.
+//!
+//! Test using `nc` or `curl`.
+//! ```sh
+//! $ curl -vN 127.0.0.1:8080
+//! $ echo 'GET / HTTP/1.1\n\n' | nc 127.0.0.1 8080
+//! ```
+
+use std::{convert::Infallible, io, time::Duration};
+
+use actix_http::{body::BodyStream, HttpService, Response};
+use actix_server::Server;
+use async_stream::stream;
+use bytes::Bytes;
+
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    Server::build()
+        .bind("streaming-error", ("127.0.0.1", 8080), || {
+            HttpService::build()
+                .finish(|req| async move {
+                    log::info!("{:?}", req);
+                    let res = Response::ok();
+
+                    Ok::<_, Infallible>(res.set_body(BodyStream::new(stream! {
+                        yield Ok(Bytes::from("123"));
+                        yield Ok(Bytes::from("456"));
+
+                        actix_rt::time::sleep(Duration::from_millis(1000)).await;
+
+                        yield Err(io::Error::new(io::ErrorKind::Other, ""));
+                    })))
+                })
+                .tcp()
+        })?
+        .run()
+        .await
+}
--- a/actix-http/examples/ws.rs
+++ b/actix-http/examples/ws.rs
@ -4,14 +4,14 @@
 extern crate tls_rustls as rustls;

 use std::{
-    env, io,
+    io,
    pin::Pin,
    task::{Context, Poll},
    time::Duration,
 };

 use actix_codec::Encoder;
-use actix_http::{error::Error, ws, HttpService, Request, Response};
+use actix_http::{body::BodyStream, error::Error, ws, HttpService, Request, Response};
 use actix_rt::time::{interval, Interval};
 use actix_server::Server;
 use bytes::{Bytes, BytesMut};
@ -20,8 +20,7 @@ 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();
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));

    Server::build()
        .bind("tcp", ("127.0.0.1", 8080), || {
@ -34,14 +33,14 @@ async fn main() -> io::Result<()> {
        .await
 }

-async fn handler(req: Request) -> Result<Response, Error> {
+async fn handler(req: Request) -> Result<Response<BodyStream<Heartbeat>>, 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())))
+    Ok(res.message_body(BodyStream::new(Heartbeat::new(ws::Codec::new())))?)
 }

 struct Heartbeat {
--- a/actix-http/src/body/body.rs
+++ b/actix-http/src/body/body.rs
@ -1,58 +1,71 @@
 use std::{
+    borrow::Cow,
+    error::Error as StdError,
    fmt, mem,
    pin::Pin,
    task::{Context, Poll},
 };

 use bytes::{Bytes, BytesMut};
-use futures_core::Stream;
+use futures_core::{ready, Stream};

 use crate::error::Error;

-use super::{BodySize, BodyStream, MessageBody, SizedStream};
+use super::{BodySize, BodyStream, MessageBody, MessageBodyMapErr, SizedStream};
+
+pub type Body = AnyBody;

 /// Represents various types of HTTP message body.
-pub enum Body {
+pub enum AnyBody {
    /// 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>),
+    Message(BoxAnyBody),
 }

-impl Body {
+impl AnyBody {
    /// Create body from slice (copy)
-    pub fn from_slice(s: &[u8]) -> Body {
-        Body::Bytes(Bytes::copy_from_slice(s))
+    pub fn from_slice(s: &[u8]) -> Self {
+        Self::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))
+    pub fn from_message<B>(body: B) -> Self
+    where
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError + 'static>>,
+    {
+        Self::Message(BoxAnyBody::from_body(body))
    }
 }

-impl MessageBody for Body {
+impl MessageBody for AnyBody {
+    type Error = Error;
+
    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(),
+            AnyBody::None => BodySize::None,
+            AnyBody::Empty => BodySize::Empty,
+            AnyBody::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
+            AnyBody::Message(ref body) => body.size(),
        }
    }

    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        match self.get_mut() {
-            Body::None => Poll::Ready(None),
-            Body::Empty => Poll::Ready(None),
-            Body::Bytes(ref mut bin) => {
+            AnyBody::None => Poll::Ready(None),
+            AnyBody::Empty => Poll::Ready(None),
+            AnyBody::Bytes(ref mut bin) => {
                let len = bin.len();
                if len == 0 {
                    Poll::Ready(None)
@ -60,99 +73,161 @@ impl MessageBody for Body {
                    Poll::Ready(Some(Ok(mem::take(bin))))
                }
            }
-            Body::Message(body) => Pin::new(&mut **body).poll_next(cx),
+
+            // TODO: MSRV 1.51: poll_map_err
+            AnyBody::Message(body) => match ready!(body.as_pin_mut().poll_next(cx)) {
+                Some(Err(err)) => {
+                    Poll::Ready(Some(Err(Error::new_body().with_cause(err))))
+                }
+                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                None => Poll::Ready(None),
+            },
        }
    }
 }

-impl PartialEq for Body {
+impl PartialEq for AnyBody {
    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,
+            AnyBody::None => matches!(*other, AnyBody::None),
+            AnyBody::Empty => matches!(*other, AnyBody::Empty),
+            AnyBody::Bytes(ref b) => match *other {
+                AnyBody::Bytes(ref b2) => b == b2,
                _ => false,
            },
-            Body::Message(_) => false,
+            AnyBody::Message(_) => false,
        }
    }
 }

-impl fmt::Debug for Body {
+impl fmt::Debug for AnyBody {
    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(_)"),
+            AnyBody::None => write!(f, "AnyBody::None"),
+            AnyBody::Empty => write!(f, "AnyBody::Empty"),
+            AnyBody::Bytes(ref b) => write!(f, "AnyBody::Bytes({:?})", b),
+            AnyBody::Message(_) => write!(f, "AnyBody::Message(_)"),
        }
    }
 }

-impl From<&'static str> for Body {
+impl From<&'static str> for AnyBody {
    fn from(s: &'static str) -> Body {
-        Body::Bytes(Bytes::from_static(s.as_ref()))
+        AnyBody::Bytes(Bytes::from_static(s.as_ref()))
    }
 }

-impl From<&'static [u8]> for Body {
+impl From<&'static [u8]> for AnyBody {
    fn from(s: &'static [u8]) -> Body {
-        Body::Bytes(Bytes::from_static(s))
+        AnyBody::Bytes(Bytes::from_static(s))
    }
 }

-impl From<Vec<u8>> for Body {
+impl From<Vec<u8>> for AnyBody {
    fn from(vec: Vec<u8>) -> Body {
-        Body::Bytes(Bytes::from(vec))
+        AnyBody::Bytes(Bytes::from(vec))
    }
 }

-impl From<String> for Body {
+impl From<String> for AnyBody {
    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<&'_ String> for AnyBody {
+    fn from(s: &String) -> Body {
+        AnyBody::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
    }
 }

-impl From<Bytes> for Body {
+impl From<Cow<'_, str>> for AnyBody {
+    fn from(s: Cow<'_, str>) -> Body {
+        match s {
+            Cow::Owned(s) => AnyBody::from(s),
+            Cow::Borrowed(s) => {
+                AnyBody::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(s)))
+            }
+        }
+    }
+}
+
+impl From<Bytes> for AnyBody {
    fn from(s: Bytes) -> Body {
-        Body::Bytes(s)
+        AnyBody::Bytes(s)
    }
 }

-impl From<BytesMut> for Body {
+impl From<BytesMut> for AnyBody {
    fn from(s: BytesMut) -> Body {
-        Body::Bytes(s.freeze())
+        AnyBody::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
+impl<S, E> From<SizedStream<S>> for AnyBody
 where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin + 'static,
+    S: Stream<Item = Result<Bytes, E>> + 'static,
+    E: Into<Box<dyn StdError>> + 'static,
 {
    fn from(s: SizedStream<S>) -> Body {
-        Body::from_message(s)
+        AnyBody::from_message(s)
    }
 }

-impl<S, E> From<BodyStream<S>> for Body
+impl<S, E> From<BodyStream<S>> for AnyBody
 where
-    S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-    E: Into<Error> + 'static,
+    S: Stream<Item = Result<Bytes, E>> + 'static,
+    E: Into<Box<dyn StdError>> + 'static,
 {
    fn from(s: BodyStream<S>) -> Body {
-        Body::from_message(s)
+        AnyBody::from_message(s)
+    }
+}
+
+/// A boxed message body with boxed errors.
+pub struct BoxAnyBody(Pin<Box<dyn MessageBody<Error = Box<dyn StdError + 'static>>>>);
+
+impl BoxAnyBody {
+    /// Boxes a `MessageBody` and any errors it generates.
+    pub fn from_body<B>(body: B) -> Self
+    where
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError + 'static>>,
+    {
+        let body = MessageBodyMapErr::new(body, Into::into);
+        Self(Box::pin(body))
+    }
+
+    /// Returns a mutable pinned reference to the inner message body type.
+    pub fn as_pin_mut(
+        &mut self,
+    ) -> Pin<&mut (dyn MessageBody<Error = Box<dyn StdError + 'static>>)> {
+        self.0.as_mut()
+    }
+}
+
+impl fmt::Debug for BoxAnyBody {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("BoxAnyBody(dyn MessageBody)")
+    }
+}
+
+impl MessageBody for BoxAnyBody {
+    type Error = Error;
+
+    fn size(&self) -> BodySize {
+        self.0.size()
+    }
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        // TODO: MSRV 1.51: poll_map_err
+        match ready!(self.0.as_mut().poll_next(cx)) {
+            Some(Err(err)) => Poll::Ready(Some(Err(Error::new_body().with_cause(err)))),
+            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+            None => Poll::Ready(None),
+        }
    }
 }
--- a/actix-http/src/body/body_stream.rs
+++ b/actix-http/src/body/body_stream.rs
@ -1,26 +1,29 @@
 use std::{
+    error::Error as StdError,
    pin::Pin,
    task::{Context, Poll},
 };

 use bytes::Bytes;
 use futures_core::{ready, Stream};
-
-use crate::error::Error;
+use pin_project_lite::pin_project;

 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,
+pin_project! {
+    /// Streaming response wrapper.
+    ///
+    /// Response does not contain `Content-Length` header and appropriate transfer encoding is used.
+    pub struct BodyStream<S> {
+        #[pin]
+        stream: S,
+    }
 }

 impl<S, E> BodyStream<S>
 where
-    S: Stream<Item = Result<Bytes, E>> + Unpin,
-    E: Into<Error>,
+    S: Stream<Item = Result<Bytes, E>>,
+    E: Into<Box<dyn StdError>> + 'static,
 {
    pub fn new(stream: S) -> Self {
        BodyStream { stream }
@ -29,9 +32,11 @@ where

 impl<S, E> MessageBody for BodyStream<S>
 where
-    S: Stream<Item = Result<Bytes, E>> + Unpin,
-    E: Into<Error>,
+    S: Stream<Item = Result<Bytes, E>>,
+    E: Into<Box<dyn StdError>> + 'static,
 {
+    type Error = E;
+
    fn size(&self) -> BodySize {
        BodySize::Stream
    }
@ -44,16 +49,123 @@ where
    fn poll_next(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        loop {
-            let stream = &mut self.as_mut().stream;
+            let stream = self.as_mut().project().stream;

-            let chunk = match ready!(Pin::new(stream).poll_next(cx)) {
+            let chunk = match ready!(stream.poll_next(cx)) {
                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
-                opt => opt.map(|res| res.map_err(Into::into)),
+                opt => opt,
            };

            return Poll::Ready(chunk);
        }
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{convert::Infallible, time::Duration};
+
+    use actix_rt::{
+        pin,
+        time::{sleep, Sleep},
+    };
+    use actix_utils::future::poll_fn;
+    use derive_more::{Display, Error};
+    use futures_core::ready;
+    use futures_util::{stream, FutureExt as _};
+
+    use super::*;
+    use crate::body::to_bytes;
+
+    #[actix_rt::test]
+    async fn skips_empty_chunks() {
+        let body = BodyStream::new(stream::iter(
+            ["1", "", "2"]
+                .iter()
+                .map(|&v| Ok::<_, Infallible>(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 read_to_bytes() {
+        let body = BodyStream::new(stream::iter(
+            ["1", "", "2"]
+                .iter()
+                .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
+        ));
+
+        assert_eq!(to_bytes(body).await.ok(), Some(Bytes::from("12")));
+    }
+    #[derive(Debug, Display, Error)]
+    #[display(fmt = "stream error")]
+    struct StreamErr;
+
+    #[actix_rt::test]
+    async fn stream_immediate_error() {
+        let body = BodyStream::new(stream::once(async { Err(StreamErr) }));
+        assert!(matches!(to_bytes(body).await, Err(StreamErr)));
+    }
+
+    #[actix_rt::test]
+    async fn stream_delayed_error() {
+        let body =
+            BodyStream::new(stream::iter(vec![Ok(Bytes::from("1")), Err(StreamErr)]));
+        assert!(matches!(to_bytes(body).await, Err(StreamErr)));
+
+        #[pin_project::pin_project(project = TimeDelayStreamProj)]
+        #[derive(Debug)]
+        enum TimeDelayStream {
+            Start,
+            Sleep(Pin<Box<Sleep>>),
+            Done,
+        }
+
+        impl Stream for TimeDelayStream {
+            type Item = Result<Bytes, StreamErr>;
+
+            fn poll_next(
+                mut self: Pin<&mut Self>,
+                cx: &mut Context<'_>,
+            ) -> Poll<Option<Self::Item>> {
+                match self.as_mut().get_mut() {
+                    TimeDelayStream::Start => {
+                        let sleep = sleep(Duration::from_millis(1));
+                        self.as_mut().set(TimeDelayStream::Sleep(Box::pin(sleep)));
+                        cx.waker().wake_by_ref();
+                        Poll::Pending
+                    }
+
+                    TimeDelayStream::Sleep(ref mut delay) => {
+                        ready!(delay.poll_unpin(cx));
+                        self.set(TimeDelayStream::Done);
+                        cx.waker().wake_by_ref();
+                        Poll::Pending
+                    }
+
+                    TimeDelayStream::Done => Poll::Ready(Some(Err(StreamErr))),
+                }
+            }
+        }
+
+        let body = BodyStream::new(TimeDelayStream::Start);
+        assert!(matches!(to_bytes(body).await, Err(StreamErr)));
+    }
+}
--- a/actix-http/src/body/message_body.rs
+++ b/actix-http/src/body/message_body.rs
@ -1,32 +1,37 @@
 //! [`MessageBody`] trait and foreign implementations.

 use std::{
+    convert::Infallible,
    mem,
    pin::Pin,
    task::{Context, Poll},
 };

 use bytes::{Bytes, BytesMut};
+use futures_core::ready;
+use pin_project_lite::pin_project;

 use crate::error::Error;

 use super::BodySize;

-/// Type that implement this trait can be streamed to a peer.
+/// An interface for response bodies.
 pub trait MessageBody {
+    type Error;
+
+    /// Body size hint.
    fn size(&self) -> BodySize;

+    /// Attempt to pull out the next chunk of body bytes.
    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>>;
-
-    downcast_get_type_id!();
+    ) -> Poll<Option<Result<Bytes, Self::Error>>>;
 }

-downcast!(MessageBody);
-
 impl MessageBody for () {
+    type Error = Infallible;
+
    fn size(&self) -> BodySize {
        BodySize::Empty
    }
@ -34,12 +39,18 @@ impl MessageBody for () {
    fn poll_next(
        self: Pin<&mut Self>,
        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        Poll::Ready(None)
    }
 }

-impl<T: MessageBody + Unpin> MessageBody for Box<T> {
+impl<B> MessageBody for Box<B>
+where
+    B: MessageBody + Unpin,
+    B::Error: Into<Error>,
+{
+    type Error = B::Error;
+
    fn size(&self) -> BodySize {
        self.as_ref().size()
    }
@ -47,12 +58,33 @@ impl<T: MessageBody + Unpin> MessageBody for Box<T> {
    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        Pin::new(self.get_mut().as_mut()).poll_next(cx)
    }
 }

+impl<B> MessageBody for Pin<Box<B>>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = B::Error;
+
+    fn size(&self) -> BodySize {
+        self.as_ref().size()
+    }
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        self.as_mut().poll_next(cx)
+    }
+}
+
 impl MessageBody for Bytes {
+    type Error = Infallible;
+
    fn size(&self) -> BodySize {
        BodySize::Sized(self.len() as u64)
    }
@ -60,7 +92,7 @@ impl MessageBody for Bytes {
    fn poll_next(
        self: Pin<&mut Self>,
        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
@ -70,6 +102,8 @@ impl MessageBody for Bytes {
 }

 impl MessageBody for BytesMut {
+    type Error = Infallible;
+
    fn size(&self) -> BodySize {
        BodySize::Sized(self.len() as u64)
    }
@ -77,7 +111,7 @@ impl MessageBody for BytesMut {
    fn poll_next(
        self: Pin<&mut Self>,
        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
@ -87,6 +121,8 @@ impl MessageBody for BytesMut {
 }

 impl MessageBody for &'static str {
+    type Error = Infallible;
+
    fn size(&self) -> BodySize {
        BodySize::Sized(self.len() as u64)
    }
@ -94,7 +130,7 @@ impl MessageBody for &'static str {
    fn poll_next(
        self: Pin<&mut Self>,
        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
@ -106,6 +142,8 @@ impl MessageBody for &'static str {
 }

 impl MessageBody for Vec<u8> {
+    type Error = Infallible;
+
    fn size(&self) -> BodySize {
        BodySize::Sized(self.len() as u64)
    }
@ -113,7 +151,7 @@ impl MessageBody for Vec<u8> {
    fn poll_next(
        self: Pin<&mut Self>,
        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
@ -123,6 +161,8 @@ impl MessageBody for Vec<u8> {
 }

 impl MessageBody for String {
+    type Error = Infallible;
+
    fn size(&self) -> BodySize {
        BodySize::Sized(self.len() as u64)
    }
@ -130,7 +170,7 @@ impl MessageBody for String {
    fn poll_next(
        self: Pin<&mut Self>,
        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
@ -140,3 +180,53 @@ impl MessageBody for String {
        }
    }
 }
+
+pin_project! {
+    pub(crate) struct MessageBodyMapErr<B, F> {
+        #[pin]
+        body: B,
+        mapper: Option<F>,
+    }
+}
+
+impl<B, F, E> MessageBodyMapErr<B, F>
+where
+    B: MessageBody,
+    F: FnOnce(B::Error) -> E,
+{
+    pub(crate) fn new(body: B, mapper: F) -> Self {
+        Self {
+            body,
+            mapper: Some(mapper),
+        }
+    }
+}
+
+impl<B, F, E> MessageBody for MessageBodyMapErr<B, F>
+where
+    B: MessageBody,
+    F: FnOnce(B::Error) -> E,
+{
+    type Error = E;
+
+    fn size(&self) -> BodySize {
+        self.body.size()
+    }
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        let this = self.as_mut().project();
+
+        match ready!(this.body.poll_next(cx)) {
+            Some(Err(err)) => {
+                let f = self.as_mut().project().mapper.take().unwrap();
+                let mapped_err = (f)(err);
+                Poll::Ready(Some(Err(mapped_err)))
+            }
+            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+            None => Poll::Ready(None),
+        }
+    }
+}
--- a/actix-http/src/body/mod.rs
+++ b/actix-http/src/body/mod.rs
@ -1,5 +1,12 @@
 //! Traits and structures to aid consuming and writing HTTP payloads.

+use std::task::Poll;
+
+use actix_rt::pin;
+use actix_utils::future::poll_fn;
+use bytes::{Bytes, BytesMut};
+use futures_core::ready;
+
 #[allow(clippy::module_inception)]
 mod body;
 mod body_stream;
@ -8,13 +15,58 @@ mod response_body;
 mod size;
 mod sized_stream;

-pub use self::body::Body;
+pub use self::body::{AnyBody, Body, BoxAnyBody};
 pub use self::body_stream::BodyStream;
 pub use self::message_body::MessageBody;
+pub(crate) use self::message_body::MessageBodyMapErr;
 pub use self::response_body::ResponseBody;
 pub use self::size::BodySize;
 pub use self::sized_stream::SizedStream;

+/// Collects the body produced by a `MessageBody` implementation into `Bytes`.
+///
+/// Any errors produced by the body stream are returned immediately.
+///
+/// # Examples
+/// ```
+/// use actix_http::body::{Body, to_bytes};
+/// use bytes::Bytes;
+///
+/// # async fn test_to_bytes() {
+/// let body = Body::Empty;
+/// let bytes = to_bytes(body).await.unwrap();
+/// assert!(bytes.is_empty());
+///
+/// let body = Body::Bytes(Bytes::from_static(b"123"));
+/// let bytes = to_bytes(body).await.unwrap();
+/// assert_eq!(bytes, b"123"[..]);
+/// # }
+/// ```
+pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
+    let cap = match body.size() {
+        BodySize::None | BodySize::Empty | BodySize::Sized(0) => return Ok(Bytes::new()),
+        BodySize::Sized(size) => size as usize,
+        BodySize::Stream => 32_768,
+    };
+
+    let mut buf = BytesMut::with_capacity(cap);
+
+    pin!(body);
+
+    poll_fn(|cx| loop {
+        let body = body.as_mut();
+
+        match ready!(body.poll_next(cx)) {
+            Some(Ok(bytes)) => buf.extend_from_slice(&*bytes),
+            None => return Poll::Ready(Ok(())),
+            Some(Err(err)) => return Poll::Ready(Err(err)),
+        }
+    })
+    .await?;
+
+    Ok(buf.freeze())
+}
+
 #[cfg(test)]
 mod tests {
    use std::pin::Pin;
@ -22,7 +74,6 @@ mod tests {
    use actix_rt::pin;
    use actix_utils::future::poll_fn;
    use bytes::{Bytes, BytesMut};
-    use futures_util::stream;

    use super::*;

@ -35,15 +86,6 @@ mod tests {
        }
    }

-    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));
@ -149,11 +191,15 @@ mod tests {
    }

    #[actix_rt::test]
-    async fn test_box() {
+    async fn test_box_and_pin() {
        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());
+
+        let mut val = Box::pin(());
+        assert_eq!(val.size(), BodySize::Empty);
+        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
    }

    #[actix_rt::test]
@ -174,73 +220,26 @@ mod tests {

    #[actix_rt::test]
    async fn test_serde_json() {
-        use serde_json::json;
+        use serde_json::{json, Value};
        assert_eq!(
-            Body::from(serde_json::Value::String("test".into())).size(),
+            Body::from(serde_json::to_vec(&Value::String("test".to_owned())).unwrap())
+                .size(),
            BodySize::Sized(6)
        );
        assert_eq!(
-            Body::from(json!({"test-key":"test-value"})).size(),
+            Body::from(serde_json::to_vec(&json!({"test-key":"test-value"})).unwrap())
+                .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")),
-            );
-        }
-    }
-
+    // down-casting used to be done with a method on MessageBody trait
+    // test is kept to demonstrate equivalence of Any trait
    #[actix_rt::test]
    async fn test_body_casting() {
        let mut body = String::from("hello cast");
-        let resp_body: &mut dyn MessageBody = &mut body;
+        // let mut resp_body: &mut dyn MessageBody<Error = Error> = &mut body;
+        let resp_body: &mut dyn std::any::Any = &mut body;
        let body = resp_body.downcast_ref::<String>().unwrap();
        assert_eq!(body, "hello cast");
        let body = &mut resp_body.downcast_mut::<String>().unwrap();
@ -250,4 +249,15 @@ mod tests {
        let not_body = resp_body.downcast_ref::<()>();
        assert!(not_body.is_none());
    }
+
+    #[actix_rt::test]
+    async fn test_to_bytes() {
+        let body = Body::Empty;
+        let bytes = to_bytes(body).await.unwrap();
+        assert!(bytes.is_empty());
+
+        let body = Body::Bytes(Bytes::from_static(b"123"));
+        let bytes = to_bytes(body).await.unwrap();
+        assert_eq!(bytes, b"123"[..]);
+    }
 }
--- a/actix-http/src/body/response_body.rs
+++ b/actix-http/src/body/response_body.rs
@ -5,7 +5,7 @@ use std::{
 };

 use bytes::Bytes;
-use futures_core::Stream;
+use futures_core::{ready, Stream};
 use pin_project::pin_project;

 use crate::error::Error;
@ -43,7 +43,13 @@ impl<B: MessageBody> ResponseBody<B> {
    }
 }

-impl<B: MessageBody> MessageBody for ResponseBody<B> {
+impl<B> MessageBody for ResponseBody<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = Error;
+
    fn size(&self) -> BodySize {
        match self {
            ResponseBody::Body(ref body) => body.size(),
@ -54,15 +60,16 @@ impl<B: MessageBody> MessageBody for ResponseBody<B> {
    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),
-        }
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        Stream::poll_next(self, cx)
    }
 }

-impl<B: MessageBody> Stream for ResponseBody<B> {
+impl<B> Stream for ResponseBody<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
    type Item = Result<Bytes, Error>;

    fn poll_next(
@ -70,7 +77,12 @@ impl<B: MessageBody> Stream for ResponseBody<B> {
        cx: &mut Context<'_>,
    ) -> Poll<Option<Self::Item>> {
        match self.project() {
-            ResponseBodyProj::Body(body) => body.poll_next(cx),
+            // TODO: MSRV 1.51: poll_map_err
+            ResponseBodyProj::Body(body) => match ready!(body.poll_next(cx)) {
+                Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
+                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                None => Poll::Ready(None),
+            },
            ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
        }
    }
--- a/actix-http/src/body/sized_stream.rs
+++ b/actix-http/src/body/sized_stream.rs
@ -1,37 +1,44 @@
 use std::{
+    error::Error as StdError,
    pin::Pin,
    task::{Context, Poll},
 };

 use bytes::Bytes;
 use futures_core::{ready, Stream};
-
-use crate::error::Error;
+use pin_project_lite::pin_project;

 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,
+pin_project! {
+    /// Known sized streaming response wrapper.
+    ///
+    /// This body implementation should be used if total size of stream is known. Data is sent as-is
+    /// without using chunked transfer encoding.
+    pub struct SizedStream<S> {
+        size: u64,
+        #[pin]
+        stream: S,
+    }
 }

-impl<S> SizedStream<S>
+impl<S, E> SizedStream<S>
 where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin,
+    S: Stream<Item = Result<Bytes, E>>,
+    E: Into<Box<dyn StdError>> + 'static,
 {
    pub fn new(size: u64, stream: S) -> Self {
        SizedStream { size, stream }
    }
 }

-impl<S> MessageBody for SizedStream<S>
+impl<S, E> MessageBody for SizedStream<S>
 where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin,
+    S: Stream<Item = Result<Bytes, E>>,
+    E: Into<Box<dyn StdError>> + 'static,
 {
+    type Error = E;
+
    fn size(&self) -> BodySize {
        BodySize::Sized(self.size as u64)
    }
@ -44,11 +51,11 @@ where
    fn poll_next(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        loop {
-            let stream = &mut self.as_mut().stream;
+            let stream = self.as_mut().project().stream;

-            let chunk = match ready!(Pin::new(stream).poll_next(cx)) {
+            let chunk = match ready!(stream.poll_next(cx)) {
                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
                val => val,
            };
@ -57,3 +64,59 @@ where
        }
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::convert::Infallible;
+
+    use actix_rt::pin;
+    use actix_utils::future::poll_fn;
+    use futures_util::stream;
+
+    use super::*;
+    use crate::body::to_bytes;
+
+    #[actix_rt::test]
+    async fn skips_empty_chunks() {
+        let body = SizedStream::new(
+            2,
+            stream::iter(
+                ["1", "", "2"]
+                    .iter()
+                    .map(|&v| Ok::<_, Infallible>(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 read_to_bytes() {
+        let body = SizedStream::new(
+            2,
+            stream::iter(
+                ["1", "", "2"]
+                    .iter()
+                    .map(|&v| Ok::<_, Infallible>(Bytes::from(v))),
+            ),
+        );
+
+        assert_eq!(to_bytes(body).await.ok(), Some(Bytes::from("12")));
+    }
+}
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@ -1,19 +1,16 @@
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::{fmt, net};
+use std::{error::Error as StdError, fmt, marker::PhantomData, net, rc::Rc};

 use actix_codec::Framed;
 use actix_service::{IntoServiceFactory, Service, ServiceFactory};

-use crate::body::MessageBody;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::Error;
-use crate::h1::{Codec, ExpectHandler, H1Service, UpgradeHandler};
-use crate::h2::H2Service;
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpService;
-use crate::{ConnectCallback, Extensions};
+use crate::{
+    body::{AnyBody, MessageBody},
+    config::{KeepAlive, ServiceConfig},
+    h1::{self, ExpectHandler, H1Service, UpgradeHandler},
+    h2::H2Service,
+    service::HttpService,
+    ConnectCallback, Extensions, Request, Response,
+};

 /// A HTTP service builder
 ///
@ -34,7 +31,7 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler> {
 impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler>
 where
    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: fmt::Debug,
    <S::Service as Service<Request>>::Future: 'static,
 {
@ -57,13 +54,13 @@ where
 impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
 where
    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: fmt::Debug,
    <S::Service as Service<Request>>::Future: 'static,
    X: ServiceFactory<Request, Config = (), Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
    X::InitError: fmt::Debug,
-    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
+    U: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
    U::Error: fmt::Display,
    U::InitError: fmt::Debug,
 {
@ -123,7 +120,7 @@ where
    where
        F: IntoServiceFactory<X1, Request>,
        X1: ServiceFactory<Request, Config = (), Response = Request>,
-        X1::Error: Into<Error>,
+        X1::Error: Into<Response<AnyBody>>,
        X1::InitError: fmt::Debug,
    {
        HttpServiceBuilder {
@ -145,8 +142,8 @@ where
    /// and this service get called with original request and framed object.
    pub fn upgrade<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1>
    where
-        F: IntoServiceFactory<U1, (Request, Framed<T, Codec>)>,
-        U1: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
+        F: IntoServiceFactory<U1, (Request, Framed<T, h1::Codec>)>,
+        U1: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
        U1::Error: fmt::Display,
        U1::InitError: fmt::Debug,
    {
@ -181,7 +178,7 @@ where
    where
        B: MessageBody,
        F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Error>,
+        S::Error: Into<Response<AnyBody>>,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
    {
@ -202,11 +199,13 @@ where
    /// Finish service configuration and create a HTTP service for HTTP/2 protocol.
    pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B>
    where
-        B: MessageBody + 'static,
        F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>> + 'static,
+
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
    {
        let cfg = ServiceConfig::new(
            self.keep_alive,
@ -223,11 +222,13 @@ where
    /// Finish service configuration and create `HttpService` instance.
    pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>
    where
-        B: MessageBody + 'static,
        F: IntoServiceFactory<S, Request>,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>> + 'static,
+
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
    {
        let cfg = ServiceConfig::new(
            self.keep_alive,
--- a/actix-http/src/client/connection.rs
+++ b/actix-http/src/client/connection.rs
@ -12,10 +12,10 @@ use bytes::Bytes;
 use futures_core::future::LocalBoxFuture;
 use h2::client::SendRequest;

-use crate::body::MessageBody;
 use crate::h1::ClientCodec;
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
+use crate::{body::MessageBody, Error};

 use super::error::SendRequestError;
 use super::pool::Acquired;
@ -256,8 +256,9 @@ where
        body: RB,
    ) -> LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>
    where
-        RB: MessageBody + 'static,
        H: Into<RequestHeadType> + 'static,
+        RB: MessageBody + 'static,
+        RB::Error: Into<Error>,
    {
        Box::pin(async move {
            match self {
--- a/actix-http/src/client/error.rs
+++ b/actix-http/src/client/error.rs
@ -1,15 +1,16 @@
-use std::io;
+use std::{error::Error as StdError, fmt, io};

 use derive_more::{Display, From};

 #[cfg(feature = "openssl")]
 use actix_tls::accept::openssl::SslError;

-use crate::error::{Error, ParseError, ResponseError};
-use crate::http::{Error as HttpError, StatusCode};
+use crate::error::{Error, ParseError};
+use crate::http::Error as HttpError;

 /// A set of errors that can occur while connecting to an HTTP host
 #[derive(Debug, Display, From)]
+#[non_exhaustive]
 pub enum ConnectError {
    /// SSL feature is not enabled
    #[display(fmt = "SSL is not supported")]
@ -64,6 +65,7 @@ impl From<actix_tls::connect::ConnectError> for ConnectError {
 }

 #[derive(Debug, Display, From)]
+#[non_exhaustive]
 pub enum InvalidUrl {
    #[display(fmt = "Missing URL scheme")]
    MissingScheme,
@ -82,6 +84,7 @@ impl std::error::Error for InvalidUrl {}

 /// A set of errors that can occur during request sending and response reading
 #[derive(Debug, Display, From)]
+#[non_exhaustive]
 pub enum SendRequestError {
    /// Invalid URL
    #[display(fmt = "Invalid URL: {}", _0)]
@ -115,25 +118,17 @@ pub enum SendRequestError {

    /// Error sending request body
    Body(Error),
+
+    /// Other errors that can occur after submitting a request.
+    #[display(fmt = "{:?}: {}", _1, _0)]
+    Custom(Box<dyn StdError>, Box<dyn fmt::Debug>),
 }

 impl std::error::Error for SendRequestError {}

-/// Convert `SendRequestError` to a server `Response`
-impl ResponseError for SendRequestError {
-    fn status_code(&self) -> StatusCode {
-        match *self {
-            SendRequestError::Connect(ConnectError::Timeout) => {
-                StatusCode::GATEWAY_TIMEOUT
-            }
-            SendRequestError::Connect(_) => StatusCode::BAD_REQUEST,
-            _ => StatusCode::INTERNAL_SERVER_ERROR,
-        }
-    }
-}
-
 /// A set of errors that can occur during freezing a request
 #[derive(Debug, Display, From)]
+#[non_exhaustive]
 pub enum FreezeRequestError {
    /// Invalid URL
    #[display(fmt = "Invalid URL: {}", _0)]
@ -142,15 +137,20 @@ pub enum FreezeRequestError {
    /// HTTP error
    #[display(fmt = "{}", _0)]
    Http(HttpError),
+
+    /// Other errors that can occur after submitting a request.
+    #[display(fmt = "{:?}: {}", _1, _0)]
+    Custom(Box<dyn StdError>, Box<dyn fmt::Debug>),
 }

 impl std::error::Error for FreezeRequestError {}

 impl From<FreezeRequestError> for SendRequestError {
-    fn from(e: FreezeRequestError) -> Self {
-        match e {
-            FreezeRequestError::Url(e) => e.into(),
-            FreezeRequestError::Http(e) => e.into(),
+    fn from(err: FreezeRequestError) -> Self {
+        match err {
+            FreezeRequestError::Url(err) => err.into(),
+            FreezeRequestError::Http(err) => err.into(),
+            FreezeRequestError::Custom(err, msg) => SendRequestError::Custom(err, msg),
        }
    }
 }
--- a/actix-http/src/client/h1proto.rs
+++ b/actix-http/src/client/h1proto.rs
@ -11,7 +11,6 @@ use bytes::{Bytes, BytesMut};
 use futures_core::{ready, Stream};
 use futures_util::SinkExt as _;

-use crate::error::PayloadError;
 use crate::h1;
 use crate::http::{
    header::{HeaderMap, IntoHeaderValue, EXPECT, HOST},
@ -19,6 +18,7 @@ use crate::http::{
 };
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
+use crate::{error::PayloadError, Error};

 use super::connection::{ConnectionIo, H1Connection};
 use super::error::{ConnectError, SendRequestError};
@ -32,6 +32,7 @@ pub(crate) async fn send_request<Io, B>(
 where
    Io: ConnectionIo,
    B: MessageBody,
+    B::Error: Into<Error>,
 {
    // set request host header
    if !head.as_ref().headers.contains_key(HOST)
@ -154,6 +155,7 @@ pub(crate) async fn send_body<Io, B>(
 where
    Io: ConnectionIo,
    B: MessageBody,
+    B::Error: Into<Error>,
 {
    actix_rt::pin!(body);

@ -161,9 +163,10 @@ where
    while !eof {
        while !eof && !framed.as_ref().is_write_buf_full() {
            match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
-                Some(result) => {
-                    framed.as_mut().write(h1::Message::Chunk(Some(result?)))?;
+                Some(Ok(chunk)) => {
+                    framed.as_mut().write(h1::Message::Chunk(Some(chunk)))?;
                }
+                Some(Err(err)) => return Err(err.into().into()),
                None => {
                    eof = true;
                    framed.as_mut().write(h1::Message::Chunk(None))?;
--- a/actix-http/src/client/h2proto.rs
+++ b/actix-http/src/client/h2proto.rs
@ -9,14 +9,19 @@ use h2::{
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, Method, Version};

-use crate::body::{BodySize, MessageBody};
-use crate::header::HeaderMap;
-use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::Payload;
+use crate::{
+    body::{BodySize, MessageBody},
+    header::HeaderMap,
+    message::{RequestHeadType, ResponseHead},
+    payload::Payload,
+    Error,
+};

-use super::config::ConnectorConfig;
-use super::connection::{ConnectionIo, H2Connection};
-use super::error::SendRequestError;
+use super::{
+    config::ConnectorConfig,
+    connection::{ConnectionIo, H2Connection},
+    error::SendRequestError,
+};

 pub(crate) async fn send_request<Io, B>(
    mut io: H2Connection<Io>,
@ -26,6 +31,7 @@ pub(crate) async fn send_request<Io, B>(
 where
    Io: ConnectionIo,
    B: MessageBody,
+    B::Error: Into<Error>,
 {
    trace!("Sending client request: {:?} {:?}", head, body.size());

@ -125,10 +131,14 @@ where
    Ok((head, payload))
 }

-async fn send_body<B: MessageBody>(
+async fn send_body<B>(
    body: B,
    mut send: SendStream<Bytes>,
-) -> Result<(), SendRequestError> {
+) -> Result<(), SendRequestError>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
    let mut buf = None;
    actix_rt::pin!(body);
    loop {
@ -138,7 +148,7 @@ async fn send_body<B: MessageBody>(
                    send.reserve_capacity(b.len());
                    buf = Some(b);
                }
-                Some(Err(e)) => return Err(e.into()),
+                Some(Err(e)) => return Err(e.into().into()),
                None => {
                    if let Err(e) = send.send_data(Bytes::new(), true) {
                        return Err(e.into());
--- a/actix-http/src/encoding/decoder.rs
+++ b/actix-http/src/encoding/decoder.rs
@ -12,6 +12,7 @@ use brotli2::write::BrotliDecoder;
 use bytes::Bytes;
 use flate2::write::{GzDecoder, ZlibDecoder};
 use futures_core::{ready, Stream};
+use zstd::stream::write::Decoder as ZstdDecoder;

 use crate::{
    encoding::Writer,
@ -45,6 +46,12 @@ where
            ContentEncoding::Gzip => Some(ContentDecoder::Gzip(Box::new(
                GzDecoder::new(Writer::new()),
            ))),
+            ContentEncoding::Zstd => Some(ContentDecoder::Zstd(Box::new(
+                ZstdDecoder::new(Writer::new()).expect(
+                    "Failed to create zstd decoder. This is a bug. \
+                         Please report it to the actix-web repository.",
+                ),
+            ))),
            _ => None,
        };

@ -144,6 +151,9 @@ enum ContentDecoder {
    Deflate(Box<ZlibDecoder<Writer>>),
    Gzip(Box<GzDecoder<Writer>>),
    Br(Box<BrotliDecoder<Writer>>),
+    // We need explicit 'static lifetime here because ZstdDecoder need lifetime
+    // argument, and we use `spawn_blocking` in `Decoder::poll_next` that require `FnOnce() -> R + Send + 'static`
+    Zstd(Box<ZstdDecoder<'static, Writer>>),
 }

 impl ContentDecoder {
@ -186,6 +196,18 @@ impl ContentDecoder {
                }
                Err(e) => Err(e),
            },
+
+            ContentDecoder::Zstd(ref mut decoder) => match decoder.flush() {
+                Ok(_) => {
+                    let b = decoder.get_mut().take();
+                    if !b.is_empty() {
+                        Ok(Some(b))
+                    } else {
+                        Ok(None)
+                    }
+                }
+                Err(e) => Err(e),
+            },
        }
    }

@ -232,6 +254,20 @@ impl ContentDecoder {
                }
                Err(e) => Err(e),
            },
+
+            ContentDecoder::Zstd(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 {
+                        Ok(None)
+                    }
+                }
+                Err(e) => Err(e),
+            },
        }
    }
 }
--- a/actix-http/src/encoding/encoder.rs
+++ b/actix-http/src/encoding/encoder.rs
@ -1,6 +1,7 @@
 //! Stream encoders.

 use std::{
+    error::Error as StdError,
    future::Future,
    io::{self, Write as _},
    pin::Pin,
@ -10,12 +11,14 @@ use std::{
 use actix_rt::task::{spawn_blocking, JoinHandle};
 use brotli2::write::BrotliEncoder;
 use bytes::Bytes;
+use derive_more::Display;
 use flate2::write::{GzEncoder, ZlibEncoder};
 use futures_core::ready;
 use pin_project::pin_project;
+use zstd::stream::write::Encoder as ZstdEncoder;

 use crate::{
-    body::{Body, BodySize, MessageBody, ResponseBody},
+    body::{Body, BodySize, BoxAnyBody, MessageBody, ResponseBody},
    http::{
        header::{ContentEncoding, CONTENT_ENCODING},
        HeaderValue, StatusCode,
@ -92,10 +95,16 @@ impl<B: MessageBody> Encoder<B> {
 enum EncoderBody<B> {
    Bytes(Bytes),
    Stream(#[pin] B),
-    BoxedStream(Box<dyn MessageBody + Unpin>),
+    BoxedStream(BoxAnyBody),
 }

-impl<B: MessageBody> MessageBody for EncoderBody<B> {
+impl<B> MessageBody for EncoderBody<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = EncoderError<B::Error>;
+
    fn size(&self) -> BodySize {
        match self {
            EncoderBody::Bytes(ref b) => b.size(),
@ -107,7 +116,7 @@ impl<B: MessageBody> MessageBody for EncoderBody<B> {
    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        match self.project() {
            EncoderBodyProj::Bytes(b) => {
                if b.is_empty() {
@ -116,15 +125,30 @@ impl<B: MessageBody> MessageBody for EncoderBody<B> {
                    Poll::Ready(Some(Ok(std::mem::take(b))))
                }
            }
-            EncoderBodyProj::Stream(b) => b.poll_next(cx),
+            // TODO: MSRV 1.51: poll_map_err
+            EncoderBodyProj::Stream(b) => match ready!(b.poll_next(cx)) {
+                Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Body(err)))),
+                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                None => Poll::Ready(None),
+            },
            EncoderBodyProj::BoxedStream(ref mut b) => {
-                Pin::new(b.as_mut()).poll_next(cx)
+                match ready!(b.as_pin_mut().poll_next(cx)) {
+                    Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Boxed(err)))),
+                    Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                    None => Poll::Ready(None),
+                }
            }
        }
    }
 }

-impl<B: MessageBody> MessageBody for Encoder<B> {
+impl<B> MessageBody for Encoder<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = EncoderError<B::Error>;
+
    fn size(&self) -> BodySize {
        if self.encoder.is_none() {
            self.body.size()
@ -136,7 +160,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
        let mut this = self.project();
        loop {
            if *this.eof {
@ -144,8 +168,9 @@ 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 mut encoder = ready!(Pin::new(fut).poll(cx))
+                    .map_err(|_| EncoderError::Blocking(BlockingError))?
+                    .map_err(EncoderError::Io)?;

                let chunk = encoder.take();
                *this.encoder = Some(encoder);
@ -164,7 +189,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
                Some(Ok(chunk)) => {
                    if let Some(mut encoder) = this.encoder.take() {
                        if chunk.len() < MAX_CHUNK_SIZE_ENCODE_IN_PLACE {
-                            encoder.write(&chunk)?;
+                            encoder.write(&chunk).map_err(EncoderError::Io)?;
                            let chunk = encoder.take();
                            *this.encoder = Some(encoder);

@ -184,7 +209,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {

                None => {
                    if let Some(encoder) = this.encoder.take() {
-                        let chunk = encoder.finish()?;
+                        let chunk = encoder.finish().map_err(EncoderError::Io)?;
                        if chunk.is_empty() {
                            return Poll::Ready(None);
                        } else {
@ -211,6 +236,9 @@ enum ContentEncoder {
    Deflate(ZlibEncoder<Writer>),
    Gzip(GzEncoder<Writer>),
    Br(BrotliEncoder<Writer>),
+    // We need explicit 'static lifetime here because ZstdEncoder need lifetime
+    // argument, and we use `spawn_blocking` in `Encoder::poll_next` that require `FnOnce() -> R + Send + 'static`
+    Zstd(ZstdEncoder<'static, Writer>),
 }

 impl ContentEncoder {
@ -227,6 +255,10 @@ impl ContentEncoder {
            ContentEncoding::Br => {
                Some(ContentEncoder::Br(BrotliEncoder::new(Writer::new(), 3)))
            }
+            ContentEncoding::Zstd => {
+                let encoder = ZstdEncoder::new(Writer::new(), 3).ok()?;
+                Some(ContentEncoder::Zstd(encoder))
+            }
            _ => None,
        }
    }
@ -237,6 +269,7 @@ impl ContentEncoder {
            ContentEncoder::Br(ref mut encoder) => encoder.get_mut().take(),
            ContentEncoder::Deflate(ref mut encoder) => encoder.get_mut().take(),
            ContentEncoder::Gzip(ref mut encoder) => encoder.get_mut().take(),
+            ContentEncoder::Zstd(ref mut encoder) => encoder.get_mut().take(),
        }
    }

@ -254,6 +287,10 @@ impl ContentEncoder {
                Ok(writer) => Ok(writer.buf.freeze()),
                Err(err) => Err(err),
            },
+            ContentEncoder::Zstd(encoder) => match encoder.finish() {
+                Ok(writer) => Ok(writer.buf.freeze()),
+                Err(err) => Err(err),
+            },
        }
    }

@ -280,6 +317,46 @@ impl ContentEncoder {
                    Err(err)
                }
            },
+            ContentEncoder::Zstd(ref mut encoder) => match encoder.write_all(data) {
+                Ok(_) => Ok(()),
+                Err(err) => {
+                    trace!("Error decoding ztsd encoding: {}", err);
+                    Err(err)
+                }
+            },
        }
    }
 }
+
+#[derive(Debug, Display)]
+#[non_exhaustive]
+pub enum EncoderError<E> {
+    #[display(fmt = "body")]
+    Body(E),
+
+    #[display(fmt = "boxed")]
+    Boxed(Box<dyn StdError>),
+
+    #[display(fmt = "blocking")]
+    Blocking(BlockingError),
+
+    #[display(fmt = "io")]
+    Io(io::Error),
+}
+
+impl<E: StdError + 'static> StdError for EncoderError<E> {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        match self {
+            EncoderError::Body(err) => Some(err),
+            EncoderError::Boxed(err) => Some(&**err),
+            EncoderError::Blocking(err) => Some(err),
+            EncoderError::Io(err) => Some(err),
+        }
+    }
+}
+
+impl<E: StdError + 'static> From<EncoderError<E>> for crate::Error {
+    fn from(err: EncoderError<E>) -> Self {
+        crate::Error::new_encoder().with_cause(err)
+    }
+}
--- a/actix-http/src/error.rs
+++ b/actix-http/src/error.rs
--- a/actix-http/src/h1/decoder.rs
+++ b/actix-http/src/h1/decoder.rs
@ -1213,8 +1213,9 @@ mod tests {
    #[test]
    fn test_parse_chunked_payload_chunk_extension() {
        let mut buf = BytesMut::from(
-            &"GET /test HTTP/1.1\r\n\
-              transfer-encoding: chunked\r\n\r\n"[..],
+            "GET /test HTTP/1.1\r\n\
+            transfer-encoding: chunked\r\n\
+            \r\n",
        );

        let mut reader = MessageDecoder::<Request>::default();
@ -1233,7 +1234,7 @@ mod tests {

    #[test]
    fn test_response_http10_read_until_eof() {
-        let mut buf = BytesMut::from(&"HTTP/1.0 200 Ok\r\n\r\ntest data"[..]);
+        let mut buf = BytesMut::from("HTTP/1.0 200 Ok\r\n\r\ntest data");

        let mut reader = MessageDecoder::<ResponseHead>::default();
        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
@ -1,5 +1,6 @@
 use std::{
    collections::VecDeque,
+    error::Error as StdError,
    fmt,
    future::Future,
    io, mem, net,
@ -17,18 +18,19 @@ use futures_core::ready;
 use log::{error, trace};
 use pin_project::pin_project;

-use crate::body::{Body, BodySize, MessageBody, ResponseBody};
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::error::{ParseError, PayloadError};
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpFlow;
-use crate::OnConnectData;
+use crate::{
+    body::{AnyBody, BodySize, MessageBody},
+    config::ServiceConfig,
+    error::{DispatchError, ParseError, PayloadError},
+    service::HttpFlow,
+    OnConnectData, Request, Response, StatusCode,
+};

-use super::codec::Codec;
-use super::payload::{Payload, PayloadSender, PayloadStatus};
-use super::{Message, MessageType};
+use super::{
+    codec::Codec,
+    payload::{Payload, PayloadSender, PayloadStatus},
+    Message, MessageType,
+};

 const LW_BUFFER_SIZE: usize = 1024;
 const HW_BUFFER_SIZE: usize = 1024 * 8;
@ -49,10 +51,14 @@ bitflags! {
 pub struct Dispatcher<T, S, B, X, U>
 where
    S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
@ -67,10 +73,14 @@ where
 enum DispatcherState<T, S, B, X, U>
 where
    S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
@ -82,10 +92,14 @@ where
 struct InnerDispatcher<T, S, B, X, U>
 where
    S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
@ -121,19 +135,25 @@ enum State<S, B, X>
 where
    S: Service<Request>,
    X: Service<Request, Response = Request>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
 {
    None,
    ExpectCall(#[pin] X::Future),
    ServiceCall(#[pin] S::Future),
-    SendPayload(#[pin] ResponseBody<B>),
+    SendPayload(#[pin] B),
+    SendErrorPayload(#[pin] AnyBody),
 }

 impl<S, B, X> State<S, B, X>
 where
    S: Service<Request>,
+
    X: Service<Request, Response = Request>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
 {
    fn is_empty(&self) -> bool {
        matches!(self, State::None)
@ -149,12 +169,17 @@ enum PollResponse {
 impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin,
+
    S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
    S::Response: Into<Response<B>>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
@ -205,12 +230,17 @@ where
 impl<T, S, B, X, U> InnerDispatcher<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin,
+
    S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
    S::Response: Into<Response<B>>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
@ -267,11 +297,11 @@ where
        io.poll_flush(cx)
    }

-    fn send_response(
+    fn send_response_inner(
        self: Pin<&mut Self>,
        message: Response<()>,
-        body: ResponseBody<B>,
-    ) -> Result<(), DispatchError> {
+        body: &impl MessageBody,
+    ) -> Result<BodySize, DispatchError> {
        let size = body.size();
        let mut this = self.project();
        this.codec
@ -284,10 +314,35 @@ where
            })?;

        this.flags.set(Flags::KEEPALIVE, this.codec.keepalive());
-        match size {
-            BodySize::None | BodySize::Empty => this.state.set(State::None),
-            _ => this.state.set(State::SendPayload(body)),
+
+        Ok(size)
+    }
+
+    fn send_response(
+        mut self: Pin<&mut Self>,
+        message: Response<()>,
+        body: B,
+    ) -> Result<(), DispatchError> {
+        let size = self.as_mut().send_response_inner(message, &body)?;
+        let state = match size {
+            BodySize::None | BodySize::Empty => State::None,
+            _ => State::SendPayload(body),
        };
+        self.project().state.set(state);
+        Ok(())
+    }
+
+    fn send_error_response(
+        mut self: Pin<&mut Self>,
+        message: Response<()>,
+        body: AnyBody,
+    ) -> Result<(), DispatchError> {
+        let size = self.as_mut().send_response_inner(message, &body)?;
+        let state = match size {
+            BodySize::None | BodySize::Empty => State::None,
+            _ => State::SendErrorPayload(body),
+        };
+        self.project().state.set(state);
        Ok(())
    }

@ -325,8 +380,7 @@ where
                        // 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))?;
+                        self.as_mut().send_error_response(res, AnyBody::Empty)?;
                    }

                    // return with upgrade request and poll it exclusively.
@ -346,9 +400,9 @@ where

                    // send service call error as response
                    Poll::Ready(Err(err)) => {
-                        let res: Response = err.into().into();
+                        let res: Response<AnyBody> = err.into();
                        let (res, body) = res.replace_body(());
-                        self.as_mut().send_response(res, body.into_body())?;
+                        self.as_mut().send_error_response(res, body)?;
                    }

                    // service call pending and could be waiting for more chunk messages.
@ -385,7 +439,42 @@ where
                            }

                            Poll::Ready(Some(Err(err))) => {
-                                return Err(DispatchError::Service(err))
+                                return Err(DispatchError::Body(err.into()))
+                            }
+
+                            Poll::Pending => return Ok(PollResponse::DoNothing),
+                        }
+                    }
+                    // buffer is beyond max size.
+                    // return and try to write the whole buffer to io stream.
+                    return Ok(PollResponse::DrainWriteBuf);
+                }
+
+                StateProj::SendErrorPayload(mut stream) => {
+                    // TODO: de-dupe impl with SendPayload
+
+                    // keep populate writer buffer until buffer size limit hit,
+                    // get blocked or finished.
+                    while this.write_buf.len() < super::payload::MAX_BUFFER_SIZE {
+                        match stream.as_mut().poll_next(cx) {
+                            Poll::Ready(Some(Ok(item))) => {
+                                this.codec.encode(
+                                    Message::Chunk(Some(item)),
+                                    &mut this.write_buf,
+                                )?;
+                            }
+
+                            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.into()))
                            }

                            Poll::Pending => return Ok(PollResponse::DoNothing),
@ -405,12 +494,14 @@ where
                        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: Response<AnyBody> = err.into();
                        let (res, body) = res.replace_body(());
-                        self.as_mut().send_response(res, body.into_body())?;
+                        self.as_mut().send_error_response(res, body)?;
                    }
+
                    // expect must be solved before progress can be made.
                    Poll::Pending => return Ok(PollResponse::DoNothing),
                },
@ -456,10 +547,9 @@ where
                        // to notify the dispatcher a new state is set and the outer loop
                        // should be continue.
                        Poll::Ready(Err(err)) => {
-                            let err = err.into();
-                            let res: Response = err.into();
+                            let res: Response<AnyBody> = err.into();
                            let (res, body) = res.replace_body(());
-                            return self.send_response(res, body.into_body());
+                            return self.send_error_response(res, body);
                        }
                    }
                }
@ -477,9 +567,9 @@ where
                        Poll::Pending => Ok(()),
                        // see the comment on ExpectCall state branch's Ready(Err(err)).
                        Poll::Ready(Err(err)) => {
-                            let res: Response = err.into().into();
+                            let res: Response<AnyBody> = err.into();
                            let (res, body) = res.replace_body(());
-                            self.send_response(res, body.into_body())
+                            self.send_error_response(res, body)
                        }
                    };
                }
@ -563,7 +653,7 @@ where
                                );
                                this.flags.insert(Flags::READ_DISCONNECT);
                                this.messages.push_back(DispatcherMessage::Error(
-                                    Response::InternalServerError().finish().drop_body(),
+                                    Response::internal_server_error().drop_body(),
                                ));
                                *this.error = Some(DispatchError::InternalError);
                                break;
@ -576,7 +666,7 @@ where
                                error!("Internal server error: unexpected eof");
                                this.flags.insert(Flags::READ_DISCONNECT);
                                this.messages.push_back(DispatcherMessage::Error(
-                                    Response::InternalServerError().finish().drop_body(),
+                                    Response::internal_server_error().drop_body(),
                                ));
                                *this.error = Some(DispatchError::InternalError);
                                break;
@ -599,7 +689,10 @@ where
                    }
                    // Requests overflow buffer size should be responded with 431
                    this.messages.push_back(DispatcherMessage::Error(
-                        Response::RequestHeaderFieldsTooLarge().finish().drop_body(),
+                        Response::with_body(
+                            StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE,
+                            (),
+                        ),
                    ));
                    this.flags.insert(Flags::READ_DISCONNECT);
                    *this.error = Some(ParseError::TooLarge.into());
@ -612,7 +705,7 @@ where

                    // Malformed requests should be responded with 400
                    this.messages.push_back(DispatcherMessage::Error(
-                        Response::BadRequest().finish().drop_body(),
+                        Response::bad_request().drop_body(),
                    ));
                    this.flags.insert(Flags::READ_DISCONNECT);
                    *this.error = Some(err.into());
@ -648,11 +741,6 @@ where
                        // go into Some<Pin<&mut Sleep>> branch
                        this.ka_timer.set(Some(sleep_until(deadline)));
                        return self.poll_keepalive(cx);
-                    } else {
-                        this.flags.insert(Flags::READ_DISCONNECT);
-                        if let Some(mut payload) = this.payload.take() {
-                            payload.set_error(PayloadError::Incomplete(None));
-                        }
                    }
                }
            }
@ -682,18 +770,13 @@ where
                                }
                            } else {
                                // timeout on first request (slow request) return 408
-                                if !this.flags.contains(Flags::STARTED) {
-                                    trace!("Slow request timeout");
-                                    let _ = self.as_mut().send_response(
-                                        Response::RequestTimeout().finish().drop_body(),
-                                        ResponseBody::Other(Body::Empty),
-                                    );
-                                    this = self.project();
-                                } else {
-                                    trace!("Keep-alive connection timeout");
-                                }
+                                trace!("Slow request timeout");
+                                let _ = self.as_mut().send_error_response(
+                                    Response::with_body(StatusCode::REQUEST_TIMEOUT, ()),
+                                    AnyBody::Empty,
+                                );
+                                this = self.project();
                                this.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
-                                this.state.set(State::None);
                            }
                            // still have unfinished task. try to reset and register keep-alive.
                        } else if let Some(deadline) =
@ -825,12 +908,17 @@ where
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin,
+
    S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
    S::Response: Into<Response<B>>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
@ -952,6 +1040,7 @@ mod tests {

    use actix_service::fn_service;
    use actix_utils::future::{ready, Ready};
+    use bytes::Bytes;
    use futures_util::future::lazy;

    use super::*;
@ -979,19 +1068,23 @@ mod tests {
        }
    }

-    fn ok_service() -> impl Service<Request, Response = Response, Error = Error> {
-        fn_service(|_req: Request| ready(Ok::<_, Error>(Response::Ok().finish())))
+    fn ok_service() -> impl Service<Request, Response = Response<AnyBody>, Error = Error>
+    {
+        fn_service(|_req: Request| ready(Ok::<_, Error>(Response::ok())))
    }

-    fn echo_path_service() -> impl Service<Request, Response = Response, Error = Error> {
+    fn echo_path_service(
+    ) -> impl Service<Request, Response = Response<AnyBody>, Error = Error> {
        fn_service(|req: Request| {
            let path = req.path().as_bytes();
-            ready(Ok::<_, Error>(Response::Ok().body(Body::from_slice(path))))
+            ready(Ok::<_, Error>(
+                Response::ok().set_body(AnyBody::from_slice(path)),
+            ))
        })
    }

-    fn echo_payload_service() -> impl Service<Request, Response = Response, Error = Error>
-    {
+    fn echo_payload_service(
+    ) -> impl Service<Request, Response = Response<Bytes>, Error = Error> {
        fn_service(|mut req: Request| {
            Box::pin(async move {
                use futures_util::stream::StreamExt as _;
@ -1002,7 +1095,7 @@ mod tests {
                    body.extend_from_slice(chunk.unwrap().chunk())
                }

-                Ok::<_, Error>(Response::Ok().body(body))
+                Ok::<_, Error>(Response::ok().set_body(body.freeze()))
            })
        })
    }
--- a/actix-http/src/h1/encoder.rs
+++ b/actix-http/src/h1/encoder.rs
@ -6,14 +6,15 @@ use std::{cmp, io};

 use bytes::{BufMut, BytesMut};

-use crate::body::BodySize;
-use crate::config::ServiceConfig;
-use crate::header::{map::Value, HeaderName};
-use crate::helpers;
-use crate::http::header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
-use crate::http::{HeaderMap, StatusCode, Version};
-use crate::message::{ConnectionType, RequestHeadType};
-use crate::response::Response;
+use crate::{
+    body::BodySize,
+    config::ServiceConfig,
+    header::{map::Value, HeaderMap, HeaderName},
+    header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING},
+    helpers,
+    message::{ConnectionType, RequestHeadType},
+    Response, StatusCode, Version,
+};

 const AVERAGE_HEADER_SIZE: usize = 30;

@ -287,7 +288,7 @@ impl MessageType for RequestHeadType {
        let head = self.as_ref();
        dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE);
        write!(
-            helpers::Writer(dst),
+            helpers::MutWriter(dst),
            "{} {} {}",
            head.method,
            head.uri.path_and_query().map(|u| u.as_str()).unwrap_or("/"),
@ -420,7 +421,7 @@ impl TransferEncoding {
                    *eof = true;
                    buf.extend_from_slice(b"0\r\n\r\n");
                } else {
-                    writeln!(helpers::Writer(buf), "{:X}\r", msg.len())
+                    writeln!(helpers::MutWriter(buf), "{:X}\r", msg.len())
                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;

                    buf.reserve(msg.len() + 2);
@ -630,8 +631,7 @@ mod tests {
    async fn test_no_content_length() {
        let mut bytes = BytesMut::with_capacity(2048);

-        let mut res: Response<()> =
-            Response::new(StatusCode::SWITCHING_PROTOCOLS).into_body::<()>();
+        let mut res = Response::with_body(StatusCode::SWITCHING_PROTOCOLS, ());
        res.headers_mut().insert(DATE, HeaderValue::from_static(""));
        res.headers_mut()
            .insert(CONTENT_LENGTH, HeaderValue::from_static("0"));
--- a/actix-http/src/h1/service.rs
+++ b/actix-http/src/h1/service.rs
@ -1,25 +1,29 @@
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-use std::{fmt, net};
+use std::{
+    error::Error as StdError,
+    fmt,
+    marker::PhantomData,
+    net,
+    rc::Rc,
+    task::{Context, Poll},
+};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_rt::net::TcpStream;
-use actix_service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
+use actix_service::{
+    fn_service, IntoServiceFactory, Service, ServiceFactory, ServiceFactoryExt as _,
+};
 use actix_utils::future::ready;
 use futures_core::future::LocalBoxFuture;

-use crate::body::MessageBody;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpServiceHandler;
-use crate::{ConnectCallback, OnConnectData};
+use crate::{
+    body::{AnyBody, MessageBody},
+    config::ServiceConfig,
+    error::DispatchError,
+    service::HttpServiceHandler,
+    ConnectCallback, OnConnectData, Request, Response,
+};

-use super::codec::Codec;
-use super::dispatcher::Dispatcher;
-use super::{ExpectHandler, UpgradeHandler};
+use super::{codec::Codec, dispatcher::Dispatcher, ExpectHandler, UpgradeHandler};

 /// `ServiceFactory` implementation for HTTP1 transport
 pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
@ -34,7 +38,7 @@ pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
 impl<T, S, B> H1Service<T, S, B>
 where
    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
    B: MessageBody,
@ -59,17 +63,21 @@ impl<S, B, X, U> H1Service<TcpStream, S, B, X, U>
 where
    S: ServiceFactory<Request, Config = ()>,
    S::Future: 'static,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: ServiceFactory<Request, Config = (), Response = Request>,
    X::Future: 'static,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
    X::InitError: fmt::Debug,
+
    U: ServiceFactory<(Request, Framed<TcpStream, Codec>), Config = (), Response = ()>,
    U::Future: 'static,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
    U::InitError: fmt::Debug,
 {
    /// Create simple tcp stream service
@ -82,7 +90,7 @@ where
        Error = DispatchError,
        InitError = (),
    > {
-        pipeline_factory(|io: TcpStream| {
+        fn_service(|io: TcpStream| {
            let peer_addr = io.peer_addr().ok();
            ready(Ok((io, peer_addr)))
        })
@ -104,21 +112,25 @@ mod openssl {
    where
        S: ServiceFactory<Request, Config = ()>,
        S::Future: 'static,
-        S::Error: Into<Error>,
+        S::Error: Into<Response<AnyBody>>,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
+
        B: MessageBody,
+        B::Error: Into<Box<dyn StdError>>,
+
        X: ServiceFactory<Request, Config = (), Response = Request>,
        X::Future: 'static,
-        X::Error: Into<Error>,
+        X::Error: Into<Response<AnyBody>>,
        X::InitError: fmt::Debug,
+
        U: ServiceFactory<
            (Request, Framed<TlsStream<TcpStream>, Codec>),
            Config = (),
            Response = (),
        >,
        U::Future: 'static,
-        U::Error: fmt::Display + Into<Error>,
+        U::Error: fmt::Display + Into<Response<AnyBody>>,
        U::InitError: fmt::Debug,
    {
        /// Create openssl based service
@ -132,16 +144,14 @@ mod openssl {
            Error = TlsError<SslError, DispatchError>,
            InitError = (),
        > {
-            pipeline_factory(
-                Acceptor::new(acceptor)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(|io: TlsStream<TcpStream>| {
-                let peer_addr = io.get_ref().peer_addr().ok();
-                ready(Ok((io, peer_addr)))
-            })
-            .and_then(self.map_err(TlsError::Service))
+            Acceptor::new(acceptor)
+                .map_err(TlsError::Tls)
+                .map_init_err(|_| panic!())
+                .and_then(|io: TlsStream<TcpStream>| {
+                    let peer_addr = io.get_ref().peer_addr().ok();
+                    ready(Ok((io, peer_addr)))
+                })
+                .and_then(self.map_err(TlsError::Service))
        }
    }
 }
@ -162,21 +172,25 @@ mod rustls {
    where
        S: ServiceFactory<Request, Config = ()>,
        S::Future: 'static,
-        S::Error: Into<Error>,
+        S::Error: Into<Response<AnyBody>>,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
+
        B: MessageBody,
+        B::Error: Into<Box<dyn StdError>>,
+
        X: ServiceFactory<Request, Config = (), Response = Request>,
        X::Future: 'static,
-        X::Error: Into<Error>,
+        X::Error: Into<Response<AnyBody>>,
        X::InitError: fmt::Debug,
+
        U: ServiceFactory<
            (Request, Framed<TlsStream<TcpStream>, Codec>),
            Config = (),
            Response = (),
        >,
        U::Future: 'static,
-        U::Error: fmt::Display + Into<Error>,
+        U::Error: fmt::Display + Into<Response<AnyBody>>,
        U::InitError: fmt::Debug,
    {
        /// Create rustls based service
@ -190,16 +204,14 @@ mod rustls {
            Error = TlsError<io::Error, DispatchError>,
            InitError = (),
        > {
-            pipeline_factory(
-                Acceptor::new(config)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(|io: TlsStream<TcpStream>| {
-                let peer_addr = io.get_ref().0.peer_addr().ok();
-                ready(Ok((io, peer_addr)))
-            })
-            .and_then(self.map_err(TlsError::Service))
+            Acceptor::new(config)
+                .map_err(TlsError::Tls)
+                .map_init_err(|_| panic!())
+                .and_then(|io: TlsStream<TcpStream>| {
+                    let peer_addr = io.get_ref().0.peer_addr().ok();
+                    ready(Ok((io, peer_addr)))
+                })
+                .and_then(self.map_err(TlsError::Service))
        }
    }
 }
@ -207,7 +219,7 @@ mod rustls {
 impl<T, S, B, X, U> H1Service<T, S, B, X, U>
 where
    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
    S::Response: Into<Response<B>>,
    S::InitError: fmt::Debug,
    B: MessageBody,
@ -215,7 +227,7 @@ where
    pub fn expect<X1>(self, expect: X1) -> H1Service<T, S, B, X1, U>
    where
        X1: ServiceFactory<Request, Response = Request>,
-        X1::Error: Into<Error>,
+        X1::Error: Into<Response<AnyBody>>,
        X1::InitError: fmt::Debug,
    {
        H1Service {
@ -255,19 +267,24 @@ impl<T, S, B, X, U> ServiceFactory<(T, Option<net::SocketAddr>)>
    for H1Service<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin + 'static,
+
    S: ServiceFactory<Request, Config = ()>,
    S::Future: 'static,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
    S::Response: Into<Response<B>>,
    S::InitError: fmt::Debug,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: ServiceFactory<Request, Config = (), Response = Request>,
    X::Future: 'static,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
    X::InitError: fmt::Debug,
+
    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
    U::Future: 'static,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
    U::InitError: fmt::Debug,
 {
    type Response = ();
@ -321,14 +338,19 @@ impl<T, S, B, X, U> Service<(T, Option<net::SocketAddr>)>
    for HttpServiceHandler<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin,
+
    S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
    S::Response: Into<Response<B>>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
 {
    type Response = ();
    type Error = DispatchError;
--- a/actix-http/src/h1/utils.rs
+++ b/actix-http/src/h1/utils.rs
@ -4,7 +4,7 @@ use std::task::{Context, Poll};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};

-use crate::body::{BodySize, MessageBody, ResponseBody};
+use crate::body::{BodySize, MessageBody};
 use crate::error::Error;
 use crate::h1::{Codec, Message};
 use crate::response::Response;
@ -14,7 +14,7 @@ use crate::response::Response;
 pub struct SendResponse<T, B> {
    res: Option<Message<(Response<()>, BodySize)>>,
    #[pin]
-    body: Option<ResponseBody<B>>,
+    body: Option<B>,
    #[pin]
    framed: Option<Framed<T, Codec>>,
 }
@ -22,6 +22,7 @@ pub struct SendResponse<T, B> {
 impl<T, B> SendResponse<T, B>
 where
    B: MessageBody,
+    B::Error: Into<Error>,
 {
    pub fn new(framed: Framed<T, Codec>, response: Response<B>) -> Self {
        let (res, body) = response.into_parts();
@ -38,6 +39,7 @@ impl<T, B> Future for SendResponse<T, B>
 where
    T: AsyncRead + AsyncWrite + Unpin,
    B: MessageBody + Unpin,
+    B::Error: Into<Error>,
 {
    type Output = Result<Framed<T, Codec>, Error>;

@ -60,7 +62,18 @@ where
                        .unwrap()
                        .is_write_buf_full()
                {
-                    match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx)? {
+                    let next =
+                        // TODO: MSRV 1.51: poll_map_err
+                        match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx) {
+                            Poll::Ready(Some(Ok(item))) => Poll::Ready(Some(item)),
+                            Poll::Ready(Some(Err(err))) => {
+                                return Poll::Ready(Err(err.into()))
+                            }
+                            Poll::Ready(None) => Poll::Ready(None),
+                            Poll::Pending => Poll::Pending,
+                        };
+
+                    match next {
                        Poll::Ready(item) => {
                            // body is done when item is None
                            body_done = item.is_none();
@ -68,7 +81,9 @@ where
                                let _ = this.body.take();
                            }
                            let framed = this.framed.as_mut().as_pin_mut().unwrap();
-                            framed.write(Message::Chunk(item))?;
+                            framed.write(Message::Chunk(item)).map_err(|err| {
+                                Error::new_send_response().with_cause(err)
+                            })?;
                        }
                        Poll::Pending => body_ready = false,
                    }
@ -79,7 +94,10 @@ where

            // flush write buffer
            if !framed.is_write_buf_empty() {
-                match framed.flush(cx)? {
+                match framed
+                    .flush(cx)
+                    .map_err(|err| Error::new_send_response().with_cause(err))?
+                {
                    Poll::Ready(_) => {
                        if body_ready {
                            continue;
@ -93,7 +111,9 @@ where

            // send response
            if let Some(res) = this.res.take() {
-                framed.write(res)?;
+                framed
+                    .write(res)
+                    .map_err(|err| Error::new_send_response().with_cause(err))?;
                continue;
            }

--- a/actix-http/src/h2/dispatcher.rs
+++ b/actix-http/src/h2/dispatcher.rs
@ -1,53 +1,46 @@
-use std::task::{Context, Poll};
-use std::{cmp, future::Future, marker::PhantomData, net, pin::Pin, rc::Rc};
+use std::{
+    cmp,
+    error::Error as StdError,
+    future::Future,
+    marker::PhantomData,
+    net,
+    pin::Pin,
+    rc::Rc,
+    task::{Context, Poll},
+};

 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_service::Service;
+use actix_utils::future::poll_fn;
 use bytes::{Bytes, BytesMut};
 use futures_core::ready;
-use h2::{
-    server::{Connection, SendResponse},
-    SendStream,
-};
+use h2::server::{Connection, SendResponse};
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
 use log::{error, trace};
+use pin_project_lite::pin_project;

-use crate::body::{BodySize, MessageBody, ResponseBody};
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::message::ResponseHead;
-use crate::payload::Payload;
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpFlow;
-use crate::OnConnectData;
+use crate::{
+    body::{AnyBody, BodySize, MessageBody},
+    config::ServiceConfig,
+    service::HttpFlow,
+    OnConnectData, Payload, Request, Response, ResponseHead,
+};

 const CHUNK_SIZE: usize = 16_384;

-/// Dispatcher for HTTP/2 protocol.
-#[pin_project::pin_project]
-pub struct Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    B: MessageBody,
-{
-    flow: Rc<HttpFlow<S, X, U>>,
-    connection: Connection<T, Bytes>,
-    on_connect_data: OnConnectData,
-    config: ServiceConfig,
-    peer_addr: Option<net::SocketAddr>,
-    _phantom: PhantomData<B>,
+pin_project! {
+    /// Dispatcher for HTTP/2 protocol.
+    pub struct Dispatcher<T, S, B, X, U> {
+        flow: Rc<HttpFlow<S, X, U>>,
+        connection: Connection<T, Bytes>,
+        on_connect_data: OnConnectData,
+        config: ServiceConfig,
+        peer_addr: Option<net::SocketAddr>,
+        _phantom: PhantomData<B>,
+    }
 }

-impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
+impl<T, S, B, X, U> Dispatcher<T, S, B, X, U> {
    pub(crate) fn new(
        flow: Rc<HttpFlow<S, X, U>>,
        connection: Connection<T, Bytes>,
@ -55,7 +48,7 @@ where
        config: ServiceConfig,
        peer_addr: Option<net::SocketAddr>,
    ) -> Self {
-        Dispatcher {
+        Self {
            flow,
            config,
            peer_addr,
@ -69,269 +62,208 @@ where
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin,
+
    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>>,
    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
+    S::Response: Into<Response<B>>,
+
+    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
 {
-    type Output = Result<(), DispatchError>;
+    type Output = Result<(), crate::error::DispatchError>;

    #[inline]
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.get_mut();

-        loop {
-            match ready!(Pin::new(&mut this.connection).poll_accept(cx)) {
-                None => return Poll::Ready(Ok(())),
+        while let Some((req, tx)) =
+            ready!(Pin::new(&mut this.connection).poll_accept(cx)?)
+        {
+            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);

-                Some(Err(err)) => return Poll::Ready(Err(err.into())),
+            let head = req.head_mut();
+            head.uri = parts.uri;
+            head.method = parts.method;
+            head.version = parts.version;
+            head.headers = parts.headers.into();
+            head.peer_addr = this.peer_addr;

-                Some(Ok((req, res))) => {
-                    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);
+            // merge on_connect_ext data into request extensions
+            this.on_connect_data.merge_into(&mut req);

-                    let head = req.head_mut();
-                    head.uri = parts.uri;
-                    head.method = parts.method;
-                    head.version = parts.version;
-                    head.headers = parts.headers.into();
-                    head.peer_addr = this.peer_addr;
+            let fut = this.flow.service.call(req);
+            let config = this.config.clone();

-                    // merge on_connect_ext data into request extensions
-                    this.on_connect_data.merge_into(&mut req);
+            // multiplex request handling with spawn task
+            actix_rt::spawn(async move {
+                // resolve service call and send response.
+                let res = match fut.await {
+                    Ok(res) => handle_response(res.into(), tx, config).await,
+                    Err(err) => {
+                        let res: Response<AnyBody> = err.into();
+                        handle_response(res, tx, config).await
+                    }
+                };

-                    let svc = ServiceResponse {
-                        state: ServiceResponseState::ServiceCall(
-                            this.flow.service.call(req),
-                            Some(res),
-                        ),
-                        config: this.config.clone(),
-                        buffer: None,
-                        _phantom: PhantomData,
-                    };
+                // log error.
+                if let Err(err) = res {
+                    match err {
+                        DispatchError::SendResponse(err) => {
+                            trace!("Error sending HTTP/2 response: {:?}", err)
+                        }
+                        DispatchError::SendData(err) => warn!("{:?}", err),
+                        DispatchError::ResponseBody(err) => {
+                            error!("Response payload stream error: {:?}", err)
+                        }
+                    }
+                }
+            });
+        }

-                    actix_rt::spawn(svc);
+        Poll::Ready(Ok(()))
+    }
+}
+
+enum DispatchError {
+    SendResponse(h2::Error),
+    SendData(h2::Error),
+    ResponseBody(Box<dyn StdError>),
+}
+
+async fn handle_response<B>(
+    res: Response<B>,
+    mut tx: SendResponse<Bytes>,
+    config: ServiceConfig,
+) -> Result<(), DispatchError>
+where
+    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+{
+    let (res, body) = res.replace_body(());
+
+    // prepare response.
+    let mut size = body.size();
+    let res = prepare_response(config, res.head(), &mut size);
+    let eof = size.is_eof();
+
+    // send response head and return on eof.
+    let mut stream = tx
+        .send_response(res, eof)
+        .map_err(DispatchError::SendResponse)?;
+
+    if eof {
+        return Ok(());
+    }
+
+    // poll response body and send chunks to client.
+    actix_rt::pin!(body);
+
+    while let Some(res) = poll_fn(|cx| body.as_mut().poll_next(cx)).await {
+        let mut chunk = res.map_err(|err| DispatchError::ResponseBody(err.into()))?;
+
+        'send: loop {
+            // reserve enough space and wait for stream ready.
+            stream.reserve_capacity(cmp::min(chunk.len(), CHUNK_SIZE));
+
+            match poll_fn(|cx| stream.poll_capacity(cx)).await {
+                // No capacity left. drop body and return.
+                None => return Ok(()),
+                Some(res) => {
+                    // Split chuck to writeable size and send to client.
+                    let cap = res.map_err(DispatchError::SendData)?;
+
+                    let len = chunk.len();
+                    let bytes = chunk.split_to(cmp::min(cap, len));
+
+                    stream
+                        .send_data(bytes, false)
+                        .map_err(DispatchError::SendData)?;
+
+                    // Current chuck completely sent. break send loop and poll next one.
+                    if chunk.is_empty() {
+                        break 'send;
+                    }
                }
            }
        }
    }
+
+    // response body streaming finished. send end of stream and return.
+    stream
+        .send_data(Bytes::new(), true)
+        .map_err(DispatchError::SendData)?;
+
+    Ok(())
 }

-#[pin_project::pin_project]
-struct ServiceResponse<F, I, E, B> {
-    #[pin]
-    state: ServiceResponseState<F, B>,
+fn prepare_response(
    config: ServiceConfig,
-    buffer: Option<Bytes>,
-    _phantom: PhantomData<(I, E)>,
-}
+    head: &ResponseHead,
+    size: &mut BodySize,
+) -> http::Response<()> {
+    let mut has_date = false;
+    let mut skip_len = size != &BodySize::Stream;

-#[pin_project::pin_project(project = ServiceResponseStateProj)]
-enum ServiceResponseState<F, B> {
-    ServiceCall(#[pin] F, Option<SendResponse<Bytes>>),
-    SendPayload(SendStream<Bytes>, #[pin] ResponseBody<B>),
-}
+    let mut res = http::Response::new(());
+    *res.status_mut() = head.status;
+    *res.version_mut() = http::Version::HTTP_2;

-impl<F, I, E, B> ServiceResponse<F, I, E, B>
-where
-    F: Future<Output = Result<I, E>>,
-    E: Into<Error>,
-    I: Into<Response<B>>,
-    B: MessageBody,
-{
-    fn prepare_response(
-        &self,
-        head: &ResponseHead,
-        size: &mut BodySize,
-    ) -> http::Response<()> {
-        let mut has_date = false;
-        let mut skip_len = size != &BodySize::Stream;
+    // Content length
+    match head.status {
+        http::StatusCode::NO_CONTENT
+        | http::StatusCode::CONTINUE
+        | http::StatusCode::PROCESSING => *size = BodySize::None,
+        http::StatusCode::SWITCHING_PROTOCOLS => {
+            skip_len = true;
+            *size = BodySize::Stream;
+        }
+        _ => {}
+    }

-        let mut res = http::Response::new(());
-        *res.status_mut() = head.status;
-        *res.version_mut() = http::Version::HTTP_2;
+    let _ = match size {
+        BodySize::None | BodySize::Stream => None,
+        BodySize::Empty => res
+            .headers_mut()
+            .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
+        BodySize::Sized(len) => {
+            let mut buf = itoa::Buffer::new();

-        // Content length
-        match head.status {
-            http::StatusCode::NO_CONTENT
-            | http::StatusCode::CONTINUE
-            | http::StatusCode::PROCESSING => *size = BodySize::None,
-            http::StatusCode::SWITCHING_PROTOCOLS => {
-                skip_len = true;
-                *size = BodySize::Stream;
-            }
+            res.headers_mut().insert(
+                CONTENT_LENGTH,
+                HeaderValue::from_str(buf.format(*len)).unwrap(),
+            )
+        }
+    };
+
+    // copy headers
+    for (key, value) in head.headers.iter() {
+        match *key {
+            // 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,
            _ => {}
        }

-        let _ = match size {
-            BodySize::None | BodySize::Stream => None,
-            BodySize::Empty => res
-                .headers_mut()
-                .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
-            BodySize::Sized(len) => {
-                let mut buf = itoa::Buffer::new();
-
-                res.headers_mut().insert(
-                    CONTENT_LENGTH,
-                    HeaderValue::from_str(buf.format(*len)).unwrap(),
-                )
-            }
-        };
-
-        // copy headers
-        for (key, value) in head.headers.iter() {
-            match *key {
-                // 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,
-                _ => {}
-            }
-
-            res.headers_mut().append(key, value.clone());
-        }
-
-        // set date header
-        if !has_date {
-            let mut bytes = BytesMut::with_capacity(29);
-            self.config.set_date_header(&mut bytes);
-            res.headers_mut().insert(
-                DATE,
-                // SAFETY: serialized date-times are known ASCII strings
-                unsafe { HeaderValue::from_maybe_shared_unchecked(bytes.freeze()) },
-            );
-        }
-
-        res
+        res.headers_mut().append(key, value.clone());
    }
-}

-impl<F, I, E, B> Future for ServiceResponse<F, I, E, B>
-where
-    F: Future<Output = Result<I, E>>,
-    E: Into<Error>,
-    I: Into<Response<B>>,
-    B: MessageBody,
-{
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        match this.state.project() {
-            ServiceResponseStateProj::ServiceCall(call, send) => {
-                match ready!(call.poll(cx)) {
-                    Ok(res) => {
-                        let (res, body) = res.into().replace_body(());
-
-                        let mut send = send.take().unwrap();
-                        let mut size = body.size();
-                        let h2_res =
-                            self.as_mut().prepare_response(res.head(), &mut size);
-                        this = self.as_mut().project();
-
-                        let stream = match send.send_response(h2_res, size.is_eof()) {
-                            Err(e) => {
-                                trace!("Error sending HTTP/2 response: {:?}", e);
-                                return Poll::Ready(());
-                            }
-                            Ok(stream) => stream,
-                        };
-
-                        if size.is_eof() {
-                            Poll::Ready(())
-                        } else {
-                            this.state
-                                .set(ServiceResponseState::SendPayload(stream, body));
-                            self.poll(cx)
-                        }
-                    }
-
-                    Err(e) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
-
-                        let mut send = send.take().unwrap();
-                        let mut size = body.size();
-                        let h2_res =
-                            self.as_mut().prepare_response(res.head(), &mut size);
-                        this = self.as_mut().project();
-
-                        let stream = match send.send_response(h2_res, size.is_eof()) {
-                            Err(e) => {
-                                trace!("Error sending HTTP/2 response: {:?}", e);
-                                return Poll::Ready(());
-                            }
-                            Ok(stream) => stream,
-                        };
-
-                        if size.is_eof() {
-                            Poll::Ready(())
-                        } else {
-                            this.state.set(ServiceResponseState::SendPayload(
-                                stream,
-                                body.into_body(),
-                            ));
-                            self.poll(cx)
-                        }
-                    }
-                }
-            }
-
-            ServiceResponseStateProj::SendPayload(ref mut stream, ref mut body) => {
-                loop {
-                    match this.buffer {
-                        Some(ref mut buffer) => match ready!(stream.poll_capacity(cx)) {
-                            None => return Poll::Ready(()),
-
-                            Some(Ok(cap)) => {
-                                let len = buffer.len();
-                                let bytes = buffer.split_to(cmp::min(cap, len));
-
-                                if let Err(e) = stream.send_data(bytes, false) {
-                                    warn!("{:?}", e);
-                                    return Poll::Ready(());
-                                } else if !buffer.is_empty() {
-                                    let cap = cmp::min(buffer.len(), CHUNK_SIZE);
-                                    stream.reserve_capacity(cap);
-                                } else {
-                                    this.buffer.take();
-                                }
-                            }
-
-                            Some(Err(e)) => {
-                                warn!("{:?}", e);
-                                return Poll::Ready(());
-                            }
-                        },
-
-                        None => match ready!(body.as_mut().poll_next(cx)) {
-                            None => {
-                                if let Err(e) = stream.send_data(Bytes::new(), true) {
-                                    warn!("{:?}", e);
-                                }
-                                return Poll::Ready(());
-                            }
-
-                            Some(Ok(chunk)) => {
-                                stream
-                                    .reserve_capacity(cmp::min(chunk.len(), CHUNK_SIZE));
-                                *this.buffer = Some(chunk);
-                            }
-
-                            Some(Err(e)) => {
-                                error!("Response payload stream error: {:?}", e);
-                                return Poll::Ready(());
-                            }
-                        },
-                    }
-                }
-            }
-        }
+    // set date header
+    if !has_date {
+        let mut bytes = BytesMut::with_capacity(29);
+        config.set_date_header(&mut bytes);
+        res.headers_mut().insert(
+            DATE,
+            // SAFETY: serialized date-times are known ASCII strings
+            unsafe { HeaderValue::from_maybe_shared_unchecked(bytes.freeze()) },
+        );
    }
+
+    res
 }
--- a/actix-http/src/h2/service.rs
+++ b/actix-http/src/h2/service.rs
@ -1,28 +1,32 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{net, rc::Rc};
+use std::{
+    error::Error as StdError,
+    future::Future,
+    marker::PhantomData,
+    net,
+    pin::Pin,
+    rc::Rc,
+    task::{Context, Poll},
+};

 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::net::TcpStream;
 use actix_service::{
-    fn_factory, fn_service, pipeline_factory, IntoServiceFactory, Service,
-    ServiceFactory,
+    fn_factory, fn_service, IntoServiceFactory, Service, ServiceFactory,
+    ServiceFactoryExt as _,
 };
 use actix_utils::future::ready;
 use bytes::Bytes;
 use futures_core::{future::LocalBoxFuture, ready};
-use h2::server::{handshake, Handshake};
+use h2::server::{handshake as h2_handshake, Handshake as H2Handshake};
 use log::error;

-use crate::body::MessageBody;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpFlow;
-use crate::{ConnectCallback, OnConnectData};
+use crate::{
+    body::{AnyBody, MessageBody},
+    config::ServiceConfig,
+    error::DispatchError,
+    service::HttpFlow,
+    ConnectCallback, OnConnectData, Request, Response,
+};

 use super::dispatcher::Dispatcher;

@ -37,10 +41,12 @@ pub struct H2Service<T, S, B> {
 impl<T, S, B> H2Service<T, S, B>
 where
    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
+
    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
    /// Create new `H2Service` instance with config.
    pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
@ -66,10 +72,12 @@ impl<S, B> H2Service<TcpStream, S, B>
 where
    S: ServiceFactory<Request, Config = ()>,
    S::Future: 'static,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
+
    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
    /// Create plain TCP based service
    pub fn tcp(
@ -81,12 +89,12 @@ where
        Error = DispatchError,
        InitError = S::InitError,
    > {
-        pipeline_factory(fn_factory(|| {
+        fn_factory(|| {
            ready(Ok::<_, S::InitError>(fn_service(|io: TcpStream| {
                let peer_addr = io.peer_addr().ok();
                ready(Ok::<_, DispatchError>((io, peer_addr)))
            })))
-        }))
+        })
        .and_then(self)
    }
 }
@ -103,10 +111,12 @@ mod openssl {
    where
        S: ServiceFactory<Request, Config = ()>,
        S::Future: 'static,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
        S::Response: Into<Response<B>> + 'static,
        <S::Service as Service<Request>>::Future: 'static,
+
        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
    {
        /// Create OpenSSL based service
        pub fn openssl(
@ -119,20 +129,18 @@ mod openssl {
            Error = TlsError<SslError, DispatchError>,
            InitError = S::InitError,
        > {
-            pipeline_factory(
-                Acceptor::new(acceptor)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(fn_factory(|| {
-                ready(Ok::<_, S::InitError>(fn_service(
-                    |io: TlsStream<TcpStream>| {
-                        let peer_addr = io.get_ref().peer_addr().ok();
-                        ready(Ok((io, peer_addr)))
-                    },
-                )))
-            }))
-            .and_then(self.map_err(TlsError::Service))
+            Acceptor::new(acceptor)
+                .map_err(TlsError::Tls)
+                .map_init_err(|_| panic!())
+                .and_then(fn_factory(|| {
+                    ready(Ok::<_, S::InitError>(fn_service(
+                        |io: TlsStream<TcpStream>| {
+                            let peer_addr = io.get_ref().peer_addr().ok();
+                            ready(Ok((io, peer_addr)))
+                        },
+                    )))
+                }))
+                .and_then(self.map_err(TlsError::Service))
        }
    }
 }
@ -149,10 +157,12 @@ mod rustls {
    where
        S: ServiceFactory<Request, Config = ()>,
        S::Future: 'static,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
        S::Response: Into<Response<B>> + 'static,
        <S::Service as Service<Request>>::Future: 'static,
+
        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,
    {
        /// Create Rustls based service
        pub fn rustls(
@ -165,23 +175,22 @@ mod rustls {
            Error = TlsError<io::Error, DispatchError>,
            InitError = S::InitError,
        > {
-            let protos = vec!["h2".to_string().into()];
+            let mut protos = vec![b"h2".to_vec()];
+            protos.extend_from_slice(&config.alpn_protocols);
            config.set_protocols(&protos);

-            pipeline_factory(
-                Acceptor::new(config)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(fn_factory(|| {
-                ready(Ok::<_, S::InitError>(fn_service(
-                    |io: TlsStream<TcpStream>| {
-                        let peer_addr = io.get_ref().0.peer_addr().ok();
-                        ready(Ok((io, peer_addr)))
-                    },
-                )))
-            }))
-            .and_then(self.map_err(TlsError::Service))
+            Acceptor::new(config)
+                .map_err(TlsError::Tls)
+                .map_init_err(|_| panic!())
+                .and_then(fn_factory(|| {
+                    ready(Ok::<_, S::InitError>(fn_service(
+                        |io: TlsStream<TcpStream>| {
+                            let peer_addr = io.get_ref().0.peer_addr().ok();
+                            ready(Ok((io, peer_addr)))
+                        },
+                    )))
+                }))
+                .and_then(self.map_err(TlsError::Service))
        }
    }
 }
@ -189,12 +198,15 @@ mod rustls {
 impl<T, S, B> ServiceFactory<(T, Option<net::SocketAddr>)> for H2Service<T, S, B>
 where
    T: AsyncRead + AsyncWrite + Unpin + 'static,
+
    S: ServiceFactory<Request, Config = ()>,
    S::Future: 'static,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
+
    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
    type Response = ();
    type Error = DispatchError;
@ -229,7 +241,7 @@ where
 impl<T, S, B> H2ServiceHandler<T, S, B>
 where
    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Future: 'static,
    S::Response: Into<Response<B>> + 'static,
    B: MessageBody + 'static,
@ -252,10 +264,11 @@ impl<T, S, B> Service<(T, Option<net::SocketAddr>)> for H2ServiceHandler<T, S, B
 where
    T: AsyncRead + AsyncWrite + Unpin,
    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Future: 'static,
    S::Response: Into<Response<B>> + 'static,
    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
    type Response = ();
    type Error = DispatchError;
@ -279,7 +292,7 @@ where
                Some(self.cfg.clone()),
                addr,
                on_connect_data,
-                handshake(io),
+                h2_handshake(io),
            ),
        }
    }
@ -296,7 +309,7 @@ where
        Option<ServiceConfig>,
        Option<net::SocketAddr>,
        OnConnectData,
-        Handshake<T, Bytes>,
+        H2Handshake<T, Bytes>,
    ),
 }

@ -304,7 +317,7 @@ pub struct H2ServiceHandlerResponse<T, S, B>
 where
    T: AsyncRead + AsyncWrite + Unpin,
    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Future: 'static,
    S::Response: Into<Response<B>> + 'static,
    B: MessageBody + 'static,
@ -316,10 +329,11 @@ impl<T, S, B> Future for H2ServiceHandlerResponse<T, S, B>
 where
    T: AsyncRead + AsyncWrite + Unpin,
    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Future: 'static,
    S::Response: Into<Response<B>> + 'static,
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
 {
    type Output = Result<(), DispatchError>;

--- a/actix-http/src/header/as_name.rs
+++ b/actix-http/src/header/as_name.rs
@ -8,40 +8,42 @@ use http::header::{HeaderName, InvalidHeaderName};

 pub trait AsHeaderName: Sealed {}

+pub struct Seal;
+
 pub trait Sealed {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName>;
+    fn try_as_name(&self, seal: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName>;
 }

 impl Sealed for HeaderName {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
        Ok(Cow::Borrowed(self))
    }
 }
 impl AsHeaderName for HeaderName {}

 impl Sealed for &HeaderName {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
        Ok(Cow::Borrowed(*self))
    }
 }
 impl AsHeaderName for &HeaderName {}

 impl Sealed for &str {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
        HeaderName::from_str(self).map(Cow::Owned)
    }
 }
 impl AsHeaderName for &str {}

 impl Sealed for String {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
        HeaderName::from_str(self).map(Cow::Owned)
    }
 }
 impl AsHeaderName for String {}

 impl Sealed for &String {
-    fn try_as_name(&self) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
+    fn try_as_name(&self, _: Seal) -> Result<Cow<'_, HeaderName>, InvalidHeaderName> {
        HeaderName::from_str(self).map(Cow::Owned)
    }
 }
--- a/actix-http/src/header/map.rs
+++ b/actix-http/src/header/map.rs
@ -213,7 +213,7 @@ impl HeaderMap {
    }

    fn get_value(&self, key: impl AsHeaderName) -> Option<&Value> {
-        match key.try_as_name().ok()? {
+        match key.try_as_name(super::as_name::Seal).ok()? {
            Cow::Borrowed(name) => self.inner.get(name),
            Cow::Owned(name) => self.inner.get(&name),
        }
@ -279,7 +279,7 @@ impl HeaderMap {
    /// assert!(map.get("INVALID HEADER NAME").is_none());
    /// ```
    pub fn get_mut(&mut self, key: impl AsHeaderName) -> Option<&mut HeaderValue> {
-        match key.try_as_name().ok()? {
+        match key.try_as_name(super::as_name::Seal).ok()? {
            Cow::Borrowed(name) => self.inner.get_mut(name).map(|v| v.first_mut()),
            Cow::Owned(name) => self.inner.get_mut(&name).map(|v| v.first_mut()),
        }
@ -327,7 +327,7 @@ impl HeaderMap {
    /// assert!(map.contains_key(header::ACCEPT));
    /// ```
    pub fn contains_key(&self, key: impl AsHeaderName) -> bool {
-        match key.try_as_name() {
+        match key.try_as_name(super::as_name::Seal) {
            Ok(Cow::Borrowed(name)) => self.inner.contains_key(name),
            Ok(Cow::Owned(name)) => self.inner.contains_key(&name),
            Err(_) => false,
@ -410,7 +410,7 @@ impl HeaderMap {
    ///
    /// assert!(map.is_empty());
    pub fn remove(&mut self, key: impl AsHeaderName) -> Removed {
-        let value = match key.try_as_name() {
+        let value = match key.try_as_name(super::as_name::Seal) {
            Ok(Cow::Borrowed(name)) => self.inner.remove(name),
            Ok(Cow::Owned(name)) => self.inner.remove(&name),
            Err(_) => None,
--- a/actix-http/src/header/mod.rs
+++ b/actix-http/src/header/mod.rs
@ -1,9 +1,33 @@
-//! Typed HTTP headers, pre-defined `HeaderName`s, traits for parsing and conversion, and other
-//! header utility methods.
+//! Pre-defined `HeaderName`s, traits for parsing and conversion, and other header utility methods.

 use percent_encoding::{AsciiSet, CONTROLS};

-pub use http::header::*;
+// re-export from http except header map related items
+pub use http::header::{
+    HeaderName, HeaderValue, InvalidHeaderName, InvalidHeaderValue, ToStrError,
+};
+
+// re-export const header names
+pub use http::header::{
+    ACCEPT, ACCEPT_CHARSET, ACCEPT_ENCODING, ACCEPT_LANGUAGE, ACCEPT_RANGES,
+    ACCESS_CONTROL_ALLOW_CREDENTIALS, ACCESS_CONTROL_ALLOW_HEADERS,
+    ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
+    ACCESS_CONTROL_EXPOSE_HEADERS, ACCESS_CONTROL_MAX_AGE,
+    ACCESS_CONTROL_REQUEST_HEADERS, ACCESS_CONTROL_REQUEST_METHOD, AGE, ALLOW, ALT_SVC,
+    AUTHORIZATION, CACHE_CONTROL, CONNECTION, CONTENT_DISPOSITION, CONTENT_ENCODING,
+    CONTENT_LANGUAGE, CONTENT_LENGTH, CONTENT_LOCATION, CONTENT_RANGE,
+    CONTENT_SECURITY_POLICY, CONTENT_SECURITY_POLICY_REPORT_ONLY, CONTENT_TYPE, COOKIE,
+    DATE, DNT, ETAG, EXPECT, EXPIRES, FORWARDED, FROM, HOST, IF_MATCH,
+    IF_MODIFIED_SINCE, IF_NONE_MATCH, IF_RANGE, IF_UNMODIFIED_SINCE, LAST_MODIFIED,
+    LINK, LOCATION, MAX_FORWARDS, ORIGIN, PRAGMA, PROXY_AUTHENTICATE,
+    PROXY_AUTHORIZATION, PUBLIC_KEY_PINS, PUBLIC_KEY_PINS_REPORT_ONLY, RANGE, REFERER,
+    REFERRER_POLICY, REFRESH, RETRY_AFTER, SEC_WEBSOCKET_ACCEPT,
+    SEC_WEBSOCKET_EXTENSIONS, SEC_WEBSOCKET_KEY, SEC_WEBSOCKET_PROTOCOL,
+    SEC_WEBSOCKET_VERSION, SERVER, SET_COOKIE, STRICT_TRANSPORT_SECURITY, TE, TRAILER,
+    TRANSFER_ENCODING, UPGRADE, UPGRADE_INSECURE_REQUESTS, USER_AGENT, VARY, VIA,
+    WARNING, WWW_AUTHENTICATE, X_CONTENT_TYPE_OPTIONS, X_DNS_PREFETCH_CONTROL,
+    X_FRAME_OPTIONS, X_XSS_PROTECTION,
+};

 use crate::error::ParseError;
 use crate::HttpMessage;
--- a/actix-http/src/header/shared/charset.rs
+++ b/actix-http/src/header/shared/charset.rs
@ -104,7 +104,7 @@ impl Display for Charset {
 impl FromStr for Charset {
    type Err = crate::Error;

-    fn from_str(s: &str) -> crate::Result<Charset> {
+    fn from_str(s: &str) -> Result<Charset, crate::Error> {
        Ok(match s.to_ascii_uppercase().as_ref() {
            "US-ASCII" => Us_Ascii,
            "ISO-8859-1" => Iso_8859_1,
--- a/actix-http/src/header/shared/content_encoding.rs
+++ b/actix-http/src/header/shared/content_encoding.rs
@ -23,6 +23,9 @@ pub enum ContentEncoding {
    /// Gzip algorithm.
    Gzip,

+    // Zstd algorithm.
+    Zstd,
+
    /// Indicates the identity function (i.e. no compression, nor modification).
    Identity,
 }
@ -41,6 +44,7 @@ impl ContentEncoding {
            ContentEncoding::Br => "br",
            ContentEncoding::Gzip => "gzip",
            ContentEncoding::Deflate => "deflate",
+            ContentEncoding::Zstd => "zstd",
            ContentEncoding::Identity | ContentEncoding::Auto => "identity",
        }
    }
@ -53,6 +57,7 @@ impl ContentEncoding {
            ContentEncoding::Gzip => 1.0,
            ContentEncoding::Deflate => 0.9,
            ContentEncoding::Identity | ContentEncoding::Auto => 0.1,
+            ContentEncoding::Zstd => 0.0,
        }
    }
 }
@ -81,6 +86,8 @@ impl From<&str> for ContentEncoding {
            ContentEncoding::Gzip
        } else if val.eq_ignore_ascii_case("deflate") {
            ContentEncoding::Deflate
+        } else if val.eq_ignore_ascii_case("zstd") {
+            ContentEncoding::Zstd
        } else {
            ContentEncoding::default()
        }
--- a/actix-http/src/helpers.rs
+++ b/actix-http/src/helpers.rs
@ -27,7 +27,9 @@ pub(crate) fn write_status_line<B: BufMut>(version: Version, n: u16, buf: &mut B
    buf.put_u8(b' ');
 }

-/// NOTE: bytes object has to contain enough space
+/// Write out content length header.
+///
+/// Buffer must to contain enough space or be implicitly extendable.
 pub fn write_content_length<B: BufMut>(n: u64, buf: &mut B) {
    if n == 0 {
        buf.put_slice(b"\r\ncontent-length: 0\r\n");
@ -41,9 +43,15 @@ pub fn write_content_length<B: BufMut>(n: u64, buf: &mut B) {
    buf.put_slice(b"\r\n");
 }

-pub(crate) struct Writer<'a, B>(pub &'a mut B);
+/// An `io::Write`r that only requires mutable reference and assumes that there is space available
+/// in the buffer for every write operation or that it can be extended implicitly (like
+/// `bytes::BytesMut`, for example).
+///
+/// This is slightly faster (~10%) than `bytes::buf::Writer` in such cases because it does not
+/// perform a remaining length check before writing.
+pub(crate) struct MutWriter<'a, B>(pub(crate) &'a mut B);

-impl<'a, B> io::Write for Writer<'a, B>
+impl<'a, B> io::Write for MutWriter<'a, B>
 where
    B: BufMut,
 {
--- a/actix-http/src/http_message.rs
+++ b/actix-http/src/http_message.rs
@ -1,19 +1,18 @@
-use std::cell::{Ref, RefMut};
-use std::str;
+use std::{
+    cell::{Ref, RefMut},
+    str,
+};

 use encoding_rs::{Encoding, UTF_8};
 use http::header;
 use mime::Mime;

-use crate::error::{ContentTypeError, 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>>);
+use crate::{
+    error::{ContentTypeError, ParseError},
+    header::{Header, HeaderMap},
+    payload::Payload,
+    Extensions,
+};

 /// Trait that implements general purpose operations on HTTP messages.
 pub trait HttpMessage: Sized {
@ -104,41 +103,6 @@ pub trait HttpMessage: Sized {
            Ok(false)
        }
    }
-
-    /// Load request cookies.
-    #[cfg(feature = "cookies")]
-    fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, CookieParseError> {
-        if self.extensions().get::<Cookies>().is_none() {
-            let mut cookies = Vec::new();
-            for hdr in self.headers().get_all(header::COOKIE) {
-                let s =
-                    str::from_utf8(hdr.as_bytes()).map_err(CookieParseError::from)?;
-                for cookie_str in s.split(';').map(|s| s.trim()) {
-                    if !cookie_str.is_empty() {
-                        cookies.push(Cookie::parse_encoded(cookie_str)?.into_owned());
-                    }
-                }
-            }
-            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() {
-                if cookie.name() == name {
-                    return Some(cookie.to_owned());
-                }
-            }
-        }
-        None
-    }
 }

 impl<'a, T> HttpMessage for &'a mut T
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@ -6,13 +6,10 @@
 //! | `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, nonstandard_style)]
@ -38,14 +35,14 @@ mod config;
 #[cfg(feature = "compress")]
 pub mod encoding;
 mod extensions;
-mod header;
+pub mod header;
 mod helpers;
-mod http_codes;
 mod http_message;
 mod message;
 mod payload;
 mod request;
 mod response;
+mod response_builder;
 mod service;
 mod time_parser;

@ -55,20 +52,24 @@ 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::error::Error;
 pub use self::extensions::Extensions;
+pub use self::header::ContentEncoding;
 pub use self::http_message::HttpMessage;
+pub use self::message::ConnectionType;
 pub use self::message::{Message, RequestHead, RequestHeadType, ResponseHead};
 pub use self::payload::{Payload, PayloadStream};
 pub use self::request::Request;
-pub use self::response::{Response, ResponseBuilder};
+pub use self::response::Response;
+pub use self::response_builder::ResponseBuilder;
 pub use self::service::HttpService;

+pub use ::http::{uri, uri::Uri};
+pub use ::http::{Method, StatusCode, Version};
+
+// TODO: deprecate this mish-mash of random items
 pub mod http {
    //! Various HTTP related types.

@ -78,8 +79,6 @@ 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;

    /// A collection of HTTP headers and helpers.
--- a/actix-http/src/macros.rs
+++ b/actix-http/src/macros.rs
@ -1,4 +1,5 @@
 #[macro_export]
+#[doc(hidden)]
 macro_rules! downcast_get_type_id {
    () => {
        /// A helper method to get the type ID of the type
@ -14,8 +15,15 @@ macro_rules! downcast_get_type_id {
        /// making it impossible for safe code to construct outside of
        /// this module. This ensures that safe code cannot violate
        /// type-safety by implementing this method.
+        ///
+        /// We also take `PrivateHelper` as a parameter, to ensure that
+        /// safe code cannot obtain a `PrivateHelper` instance by
+        /// delegating to an existing implementation of `__private_get_type_id__`
        #[doc(hidden)]
-        fn __private_get_type_id__(&self) -> (std::any::TypeId, PrivateHelper)
+        fn __private_get_type_id__(
+            &self,
+            _: PrivateHelper,
+        ) -> (std::any::TypeId, PrivateHelper)
        where
            Self: 'static,
        {
@ -25,6 +33,7 @@ macro_rules! downcast_get_type_id {
 }

 //Generate implementation for dyn $name
+#[doc(hidden)]
 #[macro_export]
 macro_rules! downcast {
    ($name:ident) => {
@ -37,7 +46,9 @@ macro_rules! downcast {
        impl dyn $name + 'static {
            /// Downcasts generic body to a specific type.
            pub fn downcast_ref<T: $name + 'static>(&self) -> Option<&T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
+                if self.__private_get_type_id__(PrivateHelper(())).0
+                    == std::any::TypeId::of::<T>()
+                {
                    // SAFETY: external crates cannot override the default
                    // implementation of `__private_get_type_id__`, since
                    // it requires returning a private type. We can therefore
@ -51,7 +62,9 @@ macro_rules! downcast {

            /// Downcasts a generic body to a mutable specific type.
            pub fn downcast_mut<T: $name + 'static>(&mut self) -> Option<&mut T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
+                if self.__private_get_type_id__(PrivateHelper(())).0
+                    == std::any::TypeId::of::<T>()
+                {
                    // SAFETY: external crates cannot override the default
                    // implementation of `__private_get_type_id__`, since
                    // it requires returning a private type. We can therefore
@ -70,6 +83,7 @@ macro_rules! downcast {

 #[cfg(test)]
 mod tests {
+    #![allow(clippy::upper_case_acronyms)]

    trait MB {
        downcast_get_type_id!();
--- a/actix-http/src/message.rs
+++ b/actix-http/src/message.rs
@ -1,12 +1,15 @@
-use std::cell::{Ref, RefCell, RefMut};
-use std::net;
-use std::rc::Rc;
+use std::{
+    cell::{Ref, RefCell, RefMut},
+    net,
+    rc::Rc,
+};

 use bitflags::bitflags;

-use crate::extensions::Extensions;
-use crate::header::HeaderMap;
-use crate::http::{header, Method, StatusCode, Uri, Version};
+use crate::{
+    header::{self, HeaderMap},
+    Extensions, Method, StatusCode, Uri, Version,
+};

 /// Represents various types of connection
 #[derive(Copy, Clone, PartialEq, Debug)]
@ -290,14 +293,14 @@ impl ResponseHead {
        }
    }

-    #[inline]
    /// Check if keep-alive is enabled
+    #[inline]
    pub fn keep_alive(&self) -> bool {
        self.connection_type() == ConnectionType::KeepAlive
    }

-    #[inline]
    /// Check upgrade status of this message
+    #[inline]
    pub fn upgrade(&self) -> bool {
        self.connection_type() == ConnectionType::Upgrade
    }
@ -345,8 +348,8 @@ impl ResponseHead {
 }

 pub struct Message<T: Head> {
-    // Rc here should not be cloned by anyone.
-    // It's used to reuse allocation of T and no shared ownership is allowed.
+    /// Rc here should not be cloned by anyone.
+    /// It's used to reuse allocation of T and no shared ownership is allowed.
    head: Rc<T>,
 }

@ -386,12 +389,6 @@ impl BoxedResponseHead {
    pub fn new(status: StatusCode) -> Self {
        RESPONSE_POOL.with(|p| p.get_message(status))
    }
-
-    pub(crate) fn take(&mut self) -> Self {
-        BoxedResponseHead {
-            head: self.head.take(),
-        }
-    }
 }

 impl std::ops::Deref for BoxedResponseHead {
--- a/actix-http/src/request.rs
+++ b/actix-http/src/request.rs
@ -2,16 +2,18 @@

 use std::{
    cell::{Ref, RefMut},
-    fmt, net,
+    fmt, net, str,
 };

 use http::{header, Method, Uri, Version};

-use crate::extensions::Extensions;
-use crate::header::HeaderMap;
-use crate::message::{Message, RequestHead};
-use crate::payload::{Payload, PayloadStream};
-use crate::HttpMessage;
+use crate::{
+    extensions::Extensions,
+    header::HeaderMap,
+    message::{Message, RequestHead},
+    payload::{Payload, PayloadStream},
+    HttpMessage,
+};

 /// Request
 pub struct Request<P = PayloadStream> {
--- a/actix-http/src/response.rs
+++ b/actix-http/src/response.rs
--- a/actix-http/src/response_builder.rs
+++ b/actix-http/src/response_builder.rs
@ -0,0 +1,464 @@
+//! HTTP response builder.
+
+use std::{
+    cell::{Ref, RefMut},
+    error::Error as StdError,
+    fmt,
+    future::Future,
+    pin::Pin,
+    str,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use futures_core::Stream;
+
+use crate::{
+    body::{AnyBody, BodyStream},
+    error::{Error, HttpError},
+    header::{self, IntoHeaderPair, IntoHeaderValue},
+    message::{BoxedResponseHead, ConnectionType, ResponseHead},
+    Extensions, Response, StatusCode,
+};
+
+/// An HTTP response builder.
+///
+/// Used to construct an instance of `Response` using a builder pattern. Response builders are often
+/// created using [`Response::build`].
+///
+/// # Examples
+/// ```
+/// use actix_http::{Response, ResponseBuilder, body, http::StatusCode, http::header};
+///
+/// # actix_rt::System::new().block_on(async {
+/// let mut res: Response<_> = Response::build(StatusCode::OK)
+///     .content_type(mime::APPLICATION_JSON)
+///     .insert_header((header::SERVER, "my-app/1.0"))
+///     .append_header((header::SET_COOKIE, "a=1"))
+///     .append_header((header::SET_COOKIE, "b=2"))
+///     .body("1234");
+///
+/// assert_eq!(res.status(), StatusCode::OK);
+///
+/// assert!(res.headers().contains_key("server"));
+/// assert_eq!(res.headers().get_all("set-cookie").count(), 2);
+///
+/// assert_eq!(body::to_bytes(res.into_body()).await.unwrap(), &b"1234"[..]);
+/// # })
+/// ```
+pub struct ResponseBuilder {
+    head: Option<BoxedResponseHead>,
+    err: Option<HttpError>,
+}
+
+impl ResponseBuilder {
+    /// Create response builder
+    ///
+    /// # Examples
+    /// ```
+    /// use actix_http::{Response, ResponseBuilder, http::StatusCode};
+    ///
+    /// let res: Response<_> = ResponseBuilder::default().finish();
+    /// assert_eq!(res.status(), StatusCode::OK);
+    /// ```
+    #[inline]
+    pub fn new(status: StatusCode) -> Self {
+        ResponseBuilder {
+            head: Some(BoxedResponseHead::new(status)),
+            err: None,
+        }
+    }
+
+    /// Set HTTP status code of this response.
+    ///
+    /// # Examples
+    /// ```
+    /// use actix_http::{ResponseBuilder, http::StatusCode};
+    ///
+    /// let res = ResponseBuilder::default().status(StatusCode::NOT_FOUND).finish();
+    /// assert_eq!(res.status(), StatusCode::NOT_FOUND);
+    /// ```
+    #[inline]
+    pub fn status(&mut self, status: StatusCode) -> &mut Self {
+        if let Some(parts) = self.inner() {
+            parts.status = status;
+        }
+        self
+    }
+
+    /// Insert a header, replacing any that were set with an equivalent field name.
+    ///
+    /// # Examples
+    /// ```
+    /// use actix_http::{ResponseBuilder, http::header};
+    ///
+    /// let res = ResponseBuilder::default()
+    ///     .insert_header((header::CONTENT_TYPE, mime::APPLICATION_JSON))
+    ///     .insert_header(("X-TEST", "value"))
+    ///     .finish();
+    ///
+    /// assert!(res.headers().contains_key("content-type"));
+    /// assert!(res.headers().contains_key("x-test"));
+    /// ```
+    pub fn insert_header<H>(&mut self, header: H) -> &mut Self
+    where
+        H: IntoHeaderPair,
+    {
+        if let Some(parts) = self.inner() {
+            match header.try_into_header_pair() {
+                Ok((key, value)) => {
+                    parts.headers.insert(key, value);
+                }
+                Err(e) => self.err = Some(e.into()),
+            };
+        }
+
+        self
+    }
+
+    /// Append a header, keeping any that were set with an equivalent field name.
+    ///
+    /// # Examples
+    /// ```
+    /// use actix_http::{ResponseBuilder, http::header};
+    ///
+    /// let res = ResponseBuilder::default()
+    ///     .append_header((header::CONTENT_TYPE, mime::APPLICATION_JSON))
+    ///     .append_header(("X-TEST", "value1"))
+    ///     .append_header(("X-TEST", "value2"))
+    ///     .finish();
+    ///
+    /// assert_eq!(res.headers().get_all("content-type").count(), 1);
+    /// assert_eq!(res.headers().get_all("x-test").count(), 2);
+    /// ```
+    pub fn append_header<H>(&mut self, header: H) -> &mut Self
+    where
+        H: IntoHeaderPair,
+    {
+        if let Some(parts) = self.inner() {
+            match header.try_into_header_pair() {
+                Ok((key, value)) => parts.headers.append(key, value),
+                Err(e) => self.err = Some(e.into()),
+            };
+        }
+
+        self
+    }
+
+    /// Set the custom reason for the response.
+    #[inline]
+    pub fn reason(&mut self, reason: &'static str) -> &mut Self {
+        if let Some(parts) = self.inner() {
+            parts.reason = Some(reason);
+        }
+        self
+    }
+
+    /// Set connection type to KeepAlive
+    #[inline]
+    pub fn keep_alive(&mut self) -> &mut Self {
+        if let Some(parts) = self.inner() {
+            parts.set_connection_type(ConnectionType::KeepAlive);
+        }
+        self
+    }
+
+    /// Set connection type to Upgrade
+    #[inline]
+    pub fn upgrade<V>(&mut self, value: V) -> &mut Self
+    where
+        V: IntoHeaderValue,
+    {
+        if let Some(parts) = self.inner() {
+            parts.set_connection_type(ConnectionType::Upgrade);
+        }
+
+        if let Ok(value) = value.try_into_value() {
+            self.insert_header((header::UPGRADE, value));
+        }
+
+        self
+    }
+
+    /// Force close connection, even if it is marked as keep-alive
+    #[inline]
+    pub fn force_close(&mut self) -> &mut Self {
+        if let Some(parts) = self.inner() {
+            parts.set_connection_type(ConnectionType::Close);
+        }
+        self
+    }
+
+    /// Disable chunked transfer encoding for HTTP/1.1 streaming responses.
+    #[inline]
+    pub fn no_chunking(&mut self, len: u64) -> &mut Self {
+        let mut buf = itoa::Buffer::new();
+        self.insert_header((header::CONTENT_LENGTH, buf.format(len)));
+
+        if let Some(parts) = self.inner() {
+            parts.no_chunking(true);
+        }
+        self
+    }
+
+    /// Set response content type.
+    #[inline]
+    pub fn content_type<V>(&mut self, value: V) -> &mut Self
+    where
+        V: IntoHeaderValue,
+    {
+        if let Some(parts) = self.inner() {
+            match value.try_into_value() {
+                Ok(value) => {
+                    parts.headers.insert(header::CONTENT_TYPE, value);
+                }
+                Err(e) => self.err = Some(e.into()),
+            };
+        }
+        self
+    }
+
+    /// Responses extensions
+    #[inline]
+    pub fn extensions(&self) -> Ref<'_, Extensions> {
+        let head = self.head.as_ref().expect("cannot reuse response builder");
+        head.extensions.borrow()
+    }
+
+    /// Mutable reference to a the response's extensions
+    #[inline]
+    pub fn extensions_mut(&mut self) -> RefMut<'_, Extensions> {
+        let head = self.head.as_ref().expect("cannot reuse response builder");
+        head.extensions.borrow_mut()
+    }
+
+    /// Generate response with a wrapped body.
+    ///
+    /// This `ResponseBuilder` will be left in a useless state.
+    #[inline]
+    pub fn body<B: Into<AnyBody>>(&mut self, body: B) -> Response<AnyBody> {
+        self.message_body(body.into())
+            .unwrap_or_else(Response::from)
+    }
+
+    /// Generate response with a body.
+    ///
+    /// This `ResponseBuilder` will be left in a useless state.
+    pub fn message_body<B>(&mut self, body: B) -> Result<Response<B>, Error> {
+        if let Some(err) = self.err.take() {
+            return Err(Error::new_http().with_cause(err));
+        }
+
+        let head = self.head.take().expect("cannot reuse response builder");
+        Ok(Response { head, body })
+    }
+
+    /// Generate response with a streaming body.
+    ///
+    /// This `ResponseBuilder` will be left in a useless state.
+    #[inline]
+    pub fn streaming<S, E>(&mut self, stream: S) -> Response<AnyBody>
+    where
+        S: Stream<Item = Result<Bytes, E>> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
+    {
+        self.body(AnyBody::from_message(BodyStream::new(stream)))
+    }
+
+    /// Generate response with an empty body.
+    ///
+    /// This `ResponseBuilder` will be left in a useless state.
+    #[inline]
+    pub fn finish(&mut self) -> Response<AnyBody> {
+        self.body(AnyBody::Empty)
+    }
+
+    /// Create an owned `ResponseBuilder`, leaving the original in a useless state.
+    pub fn take(&mut self) -> ResponseBuilder {
+        ResponseBuilder {
+            head: self.head.take(),
+            err: self.err.take(),
+        }
+    }
+
+    /// Get access to the inner response head if there has been no error.
+    fn inner(&mut self) -> Option<&mut ResponseHead> {
+        if self.err.is_some() {
+            return None;
+        }
+
+        self.head.as_deref_mut()
+    }
+}
+
+impl Default for ResponseBuilder {
+    fn default() -> Self {
+        Self::new(StatusCode::OK)
+    }
+}
+
+/// Convert `Response` to a `ResponseBuilder`. Body get dropped.
+impl<B> From<Response<B>> for ResponseBuilder {
+    fn from(res: Response<B>) -> ResponseBuilder {
+        ResponseBuilder {
+            head: Some(res.head),
+            err: None,
+        }
+    }
+}
+
+/// Convert `ResponseHead` to a `ResponseBuilder`
+impl<'a> From<&'a ResponseHead> for ResponseBuilder {
+    fn from(head: &'a ResponseHead) -> ResponseBuilder {
+        let mut msg = BoxedResponseHead::new(head.status);
+        msg.version = head.version;
+        msg.reason = head.reason;
+
+        for (k, v) in head.headers.iter() {
+            msg.headers.append(k.clone(), v.clone());
+        }
+
+        msg.no_chunking(!head.chunked());
+
+        ResponseBuilder {
+            head: Some(msg),
+            err: None,
+        }
+    }
+}
+
+impl Future for ResponseBuilder {
+    type Output = Result<Response<AnyBody>, Error>;
+
+    fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(Ok(self.finish()))
+    }
+}
+
+impl fmt::Debug for ResponseBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let head = self.head.as_ref().unwrap();
+
+        let res = writeln!(
+            f,
+            "\nResponseBuilder {:?} {}{}",
+            head.version,
+            head.status,
+            head.reason.unwrap_or(""),
+        );
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in head.headers.iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
+        }
+        res
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::body::Body;
+    use crate::http::header::{HeaderName, HeaderValue, CONTENT_TYPE};
+
+    #[test]
+    fn test_basic_builder() {
+        let resp = Response::build(StatusCode::OK)
+            .insert_header(("X-TEST", "value"))
+            .finish();
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+
+    #[test]
+    fn test_upgrade() {
+        let resp = Response::build(StatusCode::OK)
+            .upgrade("websocket")
+            .finish();
+        assert!(resp.upgrade());
+        assert_eq!(
+            resp.headers().get(header::UPGRADE).unwrap(),
+            HeaderValue::from_static("websocket")
+        );
+    }
+
+    #[test]
+    fn test_force_close() {
+        let resp = Response::build(StatusCode::OK).force_close().finish();
+        assert!(!resp.keep_alive())
+    }
+
+    #[test]
+    fn test_content_type() {
+        let resp = Response::build(StatusCode::OK)
+            .content_type("text/plain")
+            .body(Body::Empty);
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "text/plain")
+    }
+
+    #[test]
+    fn test_into_builder() {
+        let mut resp: Response<Body> = "test".into();
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        resp.headers_mut().insert(
+            HeaderName::from_static("cookie"),
+            HeaderValue::from_static("cookie1=val100"),
+        );
+
+        let mut builder: ResponseBuilder = resp.into();
+        let resp = builder.status(StatusCode::BAD_REQUEST).finish();
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+
+        let cookie = resp.headers().get_all("Cookie").next().unwrap();
+        assert_eq!(cookie.to_str().unwrap(), "cookie1=val100");
+    }
+
+    #[test]
+    fn response_builder_header_insert_kv() {
+        let mut res = Response::build(StatusCode::OK);
+        res.insert_header(("Content-Type", "application/octet-stream"));
+        let res = res.finish();
+
+        assert_eq!(
+            res.headers().get("Content-Type"),
+            Some(&HeaderValue::from_static("application/octet-stream"))
+        );
+    }
+
+    #[test]
+    fn response_builder_header_insert_typed() {
+        let mut res = Response::build(StatusCode::OK);
+        res.insert_header((header::CONTENT_TYPE, mime::APPLICATION_OCTET_STREAM));
+        let res = res.finish();
+
+        assert_eq!(
+            res.headers().get("Content-Type"),
+            Some(&HeaderValue::from_static("application/octet-stream"))
+        );
+    }
+
+    #[test]
+    fn response_builder_header_append_kv() {
+        let mut res = Response::build(StatusCode::OK);
+        res.append_header(("Content-Type", "application/octet-stream"));
+        res.append_header(("Content-Type", "application/json"));
+        let res = res.finish();
+
+        let headers: Vec<_> = res.headers().get_all("Content-Type").cloned().collect();
+        assert_eq!(headers.len(), 2);
+        assert!(headers.contains(&HeaderValue::from_static("application/octet-stream")));
+        assert!(headers.contains(&HeaderValue::from_static("application/json")));
+    }
+
+    #[test]
+    fn response_builder_header_append_typed() {
+        let mut res = Response::build(StatusCode::OK);
+        res.append_header((header::CONTENT_TYPE, mime::APPLICATION_OCTET_STREAM));
+        res.append_header((header::CONTENT_TYPE, mime::APPLICATION_JSON));
+        let res = res.finish();
+
+        let headers: Vec<_> = res.headers().get_all("Content-Type").cloned().collect();
+        assert_eq!(headers.len(), 2);
+        assert!(headers.contains(&HeaderValue::from_static("application/octet-stream")));
+        assert!(headers.contains(&HeaderValue::from_static("application/json")));
+    }
+}
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@ -1,4 +1,5 @@
 use std::{
+    error::Error as StdError,
    fmt,
    future::Future,
    marker::PhantomData,
@ -8,21 +9,23 @@ use std::{
    task::{Context, Poll},
 };

+use ::h2::server::{handshake as h2_handshake, Handshake as H2Handshake};
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_rt::net::TcpStream;
-use actix_service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
+use actix_service::{
+    fn_service, IntoServiceFactory, Service, ServiceFactory, ServiceFactoryExt as _,
+};
 use bytes::Bytes;
 use futures_core::{future::LocalBoxFuture, ready};
-use h2::server::{handshake, Handshake};
 use pin_project::pin_project;

-use crate::body::MessageBody;
-use crate::builder::HttpServiceBuilder;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::{DispatchError, Error};
-use crate::request::Request;
-use crate::response::Response;
-use crate::{h1, h2::Dispatcher, ConnectCallback, OnConnectData, Protocol};
+use crate::{
+    body::{AnyBody, MessageBody},
+    builder::HttpServiceBuilder,
+    config::{KeepAlive, ServiceConfig},
+    error::DispatchError,
+    h1, h2, ConnectCallback, OnConnectData, Protocol, Request, Response,
+};

 /// A `ServiceFactory` for HTTP/1.1 or HTTP/2 protocol.
 pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler> {
@ -37,7 +40,7 @@ pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler> {
 impl<T, S, B> HttpService<T, S, B>
 where
    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
@ -52,11 +55,12 @@ where
 impl<T, S, B> HttpService<T, S, B>
 where
    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
    /// Create new `HttpService` instance.
    pub fn new<F: IntoServiceFactory<S, Request>>(service: F) -> Self {
@ -91,7 +95,7 @@ where
 impl<T, S, B, X, U> HttpService<T, S, B, X, U>
 where
    S: ServiceFactory<Request, Config = ()>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
@ -105,7 +109,7 @@ where
    pub fn expect<X1>(self, expect: X1) -> HttpService<T, S, B, X1, U>
    where
        X1: ServiceFactory<Request, Config = (), Response = Request>,
-        X1::Error: Into<Error>,
+        X1::Error: Into<Response<AnyBody>>,
        X1::InitError: fmt::Debug,
    {
        HttpService {
@ -149,16 +153,17 @@ impl<S, B, X, U> HttpService<TcpStream, S, B, X, U>
 where
    S: ServiceFactory<Request, Config = ()>,
    S::Future: 'static,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,

    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,

    X: ServiceFactory<Request, Config = (), Response = Request>,
    X::Future: 'static,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
    X::InitError: fmt::Debug,

    U: ServiceFactory<
@ -167,7 +172,7 @@ where
        Response = (),
    >,
    U::Future: 'static,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
    U::InitError: fmt::Debug,
 {
    /// Create simple tcp stream service
@ -180,7 +185,7 @@ where
        Error = DispatchError,
        InitError = (),
    > {
-        pipeline_factory(|io: TcpStream| async {
+        fn_service(|io: TcpStream| async {
            let peer_addr = io.peer_addr().ok();
            Ok((io, Protocol::Http1, peer_addr))
        })
@ -200,16 +205,17 @@ mod openssl {
    where
        S: ServiceFactory<Request, Config = ()>,
        S::Future: 'static,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>> + 'static,
        <S::Service as Service<Request>>::Future: 'static,

        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,

        X: ServiceFactory<Request, Config = (), Response = Request>,
        X::Future: 'static,
-        X::Error: Into<Error>,
+        X::Error: Into<Response<AnyBody>>,
        X::InitError: fmt::Debug,

        U: ServiceFactory<
@ -218,7 +224,7 @@ mod openssl {
            Response = (),
        >,
        U::Future: 'static,
-        U::Error: fmt::Display + Into<Error>,
+        U::Error: fmt::Display + Into<Response<AnyBody>>,
        U::InitError: fmt::Debug,
    {
        /// Create openssl based service
@ -232,25 +238,23 @@ mod openssl {
            Error = TlsError<SslError, DispatchError>,
            InitError = (),
        > {
-            pipeline_factory(
-                Acceptor::new(acceptor)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .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
+            Acceptor::new(acceptor)
+                .map_err(TlsError::Tls)
+                .map_init_err(|_| panic!())
+                .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
+                        } else {
+                            Protocol::Http1
+                        }
                    } else {
                        Protocol::Http1
-                    }
-                } else {
-                    Protocol::Http1
-                };
-                let peer_addr = io.get_ref().peer_addr().ok();
-                Ok((io, proto, peer_addr))
-            })
-            .and_then(self.map_err(TlsError::Service))
+                    };
+                    let peer_addr = io.get_ref().peer_addr().ok();
+                    Ok((io, proto, peer_addr))
+                })
+                .and_then(self.map_err(TlsError::Service))
        }
    }
 }
@ -269,16 +273,17 @@ mod rustls {
    where
        S: ServiceFactory<Request, Config = ()>,
        S::Future: 'static,
-        S::Error: Into<Error> + 'static,
+        S::Error: Into<Response<AnyBody>> + 'static,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>> + 'static,
        <S::Service as Service<Request>>::Future: 'static,

        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError>>,

        X: ServiceFactory<Request, Config = (), Response = Request>,
        X::Future: 'static,
-        X::Error: Into<Error>,
+        X::Error: Into<Response<AnyBody>>,
        X::InitError: fmt::Debug,

        U: ServiceFactory<
@ -287,7 +292,7 @@ mod rustls {
            Response = (),
        >,
        U::Future: 'static,
-        U::Error: fmt::Display + Into<Error>,
+        U::Error: fmt::Display + Into<Response<AnyBody>>,
        U::InitError: fmt::Debug,
    {
        /// Create rustls based service
@ -301,28 +306,28 @@ mod rustls {
            Error = TlsError<io::Error, DispatchError>,
            InitError = (),
        > {
-            let protos = vec!["h2".to_string().into(), "http/1.1".to_string().into()];
+            let mut protos = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
+            protos.extend_from_slice(&config.alpn_protocols);
            config.set_protocols(&protos);

-            pipeline_factory(
-                Acceptor::new(config)
-                    .map_err(TlsError::Tls)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(|io: TlsStream<TcpStream>| async {
-                let proto = if let Some(protos) = io.get_ref().1.get_alpn_protocol() {
-                    if protos.windows(2).any(|window| window == b"h2") {
-                        Protocol::Http2
+            Acceptor::new(config)
+                .map_err(TlsError::Tls)
+                .map_init_err(|_| panic!())
+                .and_then(|io: TlsStream<TcpStream>| async {
+                    let proto = if let Some(protos) = io.get_ref().1.get_alpn_protocol()
+                    {
+                        if protos.windows(2).any(|window| window == b"h2") {
+                            Protocol::Http2
+                        } else {
+                            Protocol::Http1
+                        }
                    } else {
                        Protocol::Http1
-                    }
-                } else {
-                    Protocol::Http1
-                };
-                let peer_addr = io.get_ref().0.peer_addr().ok();
-                Ok((io, proto, peer_addr))
-            })
-            .and_then(self.map_err(TlsError::Service))
+                    };
+                    let peer_addr = io.get_ref().0.peer_addr().ok();
+                    Ok((io, proto, peer_addr))
+                })
+                .and_then(self.map_err(TlsError::Service))
        }
    }
 }
@ -334,21 +339,22 @@ where

    S: ServiceFactory<Request, Config = ()>,
    S::Future: 'static,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,

    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,

    X: ServiceFactory<Request, Config = (), Response = Request>,
    X::Future: 'static,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
    X::InitError: fmt::Debug,

    U: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
    U::Future: 'static,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
    U::InitError: fmt::Debug,
 {
    type Response = ();
@ -411,11 +417,11 @@ where
 impl<T, S, B, X, U> HttpServiceHandler<T, S, B, X, U>
 where
    S: Service<Request>,
-    S::Error: Into<Error>,
+    S::Error: Into<Response<AnyBody>>,
    X: Service<Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
    U: Service<(Request, Framed<T, h1::Codec>)>,
-    U::Error: Into<Error>,
+    U::Error: Into<Response<AnyBody>>,
 {
    pub(super) fn new(
        cfg: ServiceConfig,
@ -432,7 +438,10 @@ where
        }
    }

-    pub(super) fn _poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
+    pub(super) fn _poll_ready(
+        &self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Response<AnyBody>>> {
        ready!(self.flow.expect.poll_ready(cx).map_err(Into::into))?;

        ready!(self.flow.service.poll_ready(cx).map_err(Into::into))?;
@ -466,15 +475,20 @@ impl<T, S, B, X, U> Service<(T, Protocol, Option<net::SocketAddr>)>
    for HttpServiceHandler<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin,
+
    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Future: 'static,
    S::Response: Into<Response<B>> + 'static,
+
    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display + Into<Response<AnyBody>>,
 {
    type Response = ();
    type Error = DispatchError;
@ -497,7 +511,7 @@ where
        match proto {
            Protocol::Http2 => HttpServiceHandlerResponse {
                state: State::H2Handshake(Some((
-                    handshake(io),
+                    h2_handshake(io),
                    self.cfg.clone(),
                    self.flow.clone(),
                    on_connect_data,
@ -523,21 +537,26 @@ where
 #[pin_project(project = StateProj)]
 enum State<T, S, B, X, U>
 where
+    T: AsyncRead + AsyncWrite + Unpin,
+
    S: Service<Request>,
    S::Future: 'static,
-    S::Error: Into<Error>,
-    T: AsyncRead + AsyncWrite + Unpin,
+    S::Error: Into<Response<AnyBody>>,
+
    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
    H1(#[pin] h1::Dispatcher<T, S, B, X, U>),
-    H2(#[pin] Dispatcher<T, S, B, X, U>),
+    H2(#[pin] h2::Dispatcher<T, S, B, X, U>),
    H2Handshake(
        Option<(
-            Handshake<T, Bytes>,
+            H2Handshake<T, Bytes>,
            ServiceConfig,
            Rc<HttpFlow<S, X, U>>,
            OnConnectData,
@ -550,13 +569,18 @@ where
 pub struct HttpServiceHandlerResponse<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin,
+
    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Future: 'static,
    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
+
+    B: MessageBody,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
@ -567,13 +591,18 @@ where
 impl<T, S, B, X, U> Future for HttpServiceHandlerResponse<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin,
+
    S: Service<Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Response<AnyBody>> + 'static,
    S::Future: 'static,
    S::Response: Into<Response<B>> + 'static,
-    B: MessageBody,
+
+    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
+
    X: Service<Request, Response = Request>,
-    X::Error: Into<Error>,
+    X::Error: Into<Response<AnyBody>>,
+
    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
@ -588,13 +617,15 @@ where
                    Ok(conn) => {
                        let (_, cfg, srv, on_connect_data, peer_addr) =
                            data.take().unwrap();
-                        self.as_mut().project().state.set(State::H2(Dispatcher::new(
-                            srv,
-                            conn,
-                            on_connect_data,
-                            cfg,
-                            peer_addr,
-                        )));
+                        self.as_mut().project().state.set(State::H2(
+                            h2::Dispatcher::new(
+                                srv,
+                                conn,
+                                on_connect_data,
+                                cfg,
+                                peer_addr,
+                            ),
+                        ));
                        self.poll(cx)
                    }
                    Err(err) => {
--- a/actix-http/src/test.rs
+++ b/actix-http/src/test.rs
@ -13,11 +13,6 @@ use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
 use bytes::{Bytes, BytesMut};
 use http::{Method, Uri, Version};

-#[cfg(feature = "cookies")]
-use crate::{
-    cookie::{Cookie, CookieJar},
-    header::{self, HeaderValue},
-};
 use crate::{
    header::{HeaderMap, IntoHeaderPair},
    payload::Payload,
@ -54,8 +49,6 @@ struct Inner {
    method: Method,
    uri: Uri,
    headers: HeaderMap,
-    #[cfg(feature = "cookies")]
-    cookies: CookieJar,
    payload: Option<Payload>,
 }

@ -66,8 +59,6 @@ impl Default for TestRequest {
            uri: Uri::from_str("/").unwrap(),
            version: Version::HTTP_11,
            headers: HeaderMap::new(),
-            #[cfg(feature = "cookies")]
-            cookies: CookieJar::new(),
            payload: None,
        }))
    }
@ -134,13 +125,6 @@ impl TestRequest {
        self
    }

-    /// 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
-    }
-
    /// Set request payload.
    pub fn set_payload<B: Into<Bytes>>(&mut self, data: B) -> &mut Self {
        let mut payload = crate::h1::Payload::empty();
@ -169,22 +153,6 @@ impl TestRequest {
        head.version = inner.version;
        head.headers = inner.headers;

-        #[cfg(feature = "cookies")]
-        {
-            let cookie: String = inner
-                .cookies
-                .delta()
-                // ensure only name=value is written to cookie header
-                .map(|c| Cookie::new(c.name(), c.value()).encoded().to_string())
-                .collect::<Vec<_>>()
-                .join("; ");
-
-            if !cookie.is_empty() {
-                head.headers
-                    .insert(header::COOKIE, HeaderValue::from_str(&cookie).unwrap());
-            }
-        }
-
        req
    }
 }
--- a/actix-http/src/ws/dispatcher.rs
+++ b/actix-http/src/ws/dispatcher.rs
@ -72,7 +72,7 @@ mod inner {

    use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};

-    use crate::ResponseError;
+    use crate::{body::AnyBody, Response};

    /// Framed transport errors
    pub enum DispatcherError<E, U, I>
@ -136,13 +136,16 @@ mod inner {
        }
    }

-    impl<E, U, I> ResponseError for DispatcherError<E, U, I>
+    impl<E, U, I> From<DispatcherError<E, U, I>> for Response<AnyBody>
    where
        E: fmt::Debug + fmt::Display,
        U: Encoder<I> + Decoder,
        <U as Encoder<I>>::Error: fmt::Debug,
        <U as Decoder>::Error: fmt::Debug,
    {
+        fn from(err: DispatcherError<E, U, I>) -> Self {
+            Response::internal_server_error().set_body(AnyBody::from(err.to_string()))
+        }
    }

    /// Message type wrapper for signalling end of message stream.
--- a/actix-http/src/ws/mod.rs
+++ b/actix-http/src/ws/mod.rs
@ -9,10 +9,8 @@ use derive_more::{Display, Error, From};
 use http::{header, Method, StatusCode};

 use crate::{
-    error::ResponseError,
-    header::HeaderValue,
-    message::RequestHead,
-    response::{Response, ResponseBuilder},
+    body::AnyBody, header::HeaderValue, message::RequestHead, response::Response,
+    ResponseBuilder,
 };

 mod codec;
@ -27,7 +25,7 @@ pub use self::frame::Parser;
 pub use self::proto::{hash_key, CloseCode, CloseReason, OpCode};

 /// WebSocket protocol errors.
-#[derive(Debug, Display, From, Error)]
+#[derive(Debug, Display, Error, From)]
 pub enum ProtocolError {
    /// Received an unmasked frame from client.
    #[display(fmt = "Received an unmasked frame from client.")]
@ -70,10 +68,8 @@ pub enum ProtocolError {
    Io(io::Error),
 }

-impl ResponseError for ProtocolError {}
-
 /// WebSocket handshake errors
-#[derive(PartialEq, Debug, Display)]
+#[derive(Debug, PartialEq, Display, Error)]
 pub enum HandshakeError {
    /// Only get method is allowed.
    #[display(fmt = "Method not allowed.")]
@ -100,36 +96,55 @@ pub enum HandshakeError {
    BadWebsocketKey,
 }

-impl ResponseError for HandshakeError {
-    fn error_response(&self) -> Response {
-        match self {
-            HandshakeError::GetMethodRequired => Response::MethodNotAllowed()
-                .insert_header((header::ALLOW, "GET"))
-                .finish(),
+impl From<&HandshakeError> for Response<AnyBody> {
+    fn from(err: &HandshakeError) -> Self {
+        match err {
+            HandshakeError::GetMethodRequired => {
+                let mut res = Response::new(StatusCode::METHOD_NOT_ALLOWED);
+                res.headers_mut()
+                    .insert(header::ALLOW, HeaderValue::from_static("GET"));
+                res
+            }

-            HandshakeError::NoWebsocketUpgrade => Response::BadRequest()
-                .reason("No WebSocket Upgrade header found")
-                .finish(),
+            HandshakeError::NoWebsocketUpgrade => {
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("No WebSocket Upgrade header found");
+                res
+            }

-            HandshakeError::NoConnectionUpgrade => Response::BadRequest()
-                .reason("No Connection upgrade")
-                .finish(),
+            HandshakeError::NoConnectionUpgrade => {
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("No Connection upgrade");
+                res
+            }

-            HandshakeError::NoVersionHeader => Response::BadRequest()
-                .reason("WebSocket version header is required")
-                .finish(),
+            HandshakeError::NoVersionHeader => {
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("WebSocket version header is required");
+                res
+            }

-            HandshakeError::UnsupportedVersion => Response::BadRequest()
-                .reason("Unsupported WebSocket version")
-                .finish(),
+            HandshakeError::UnsupportedVersion => {
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("Unsupported WebSocket version");
+                res
+            }

            HandshakeError::BadWebsocketKey => {
-                Response::BadRequest().reason("Handshake error").finish()
+                let mut res = Response::bad_request();
+                res.head_mut().reason = Some("Handshake error");
+                res
            }
        }
    }
 }

+impl From<HandshakeError> for Response<AnyBody> {
+    fn from(err: HandshakeError) -> Self {
+        (&err).into()
+    }
+}
+
 /// Verify WebSocket handshake request and create handshake response.
 pub fn handshake(req: &RequestHead) -> Result<ResponseBuilder, HandshakeError> {
    verify_handshake(req)?;
@ -207,7 +222,7 @@ pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::test::TestRequest;
+    use crate::{body::AnyBody, test::TestRequest};
    use http::{header, Method};

    #[test]
@ -321,18 +336,18 @@ mod tests {
    }

    #[test]
-    fn test_wserror_http_response() {
-        let resp: Response = HandshakeError::GetMethodRequired.error_response();
+    fn test_ws_error_http_response() {
+        let resp: Response<AnyBody> = HandshakeError::GetMethodRequired.into();
        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
-        let resp: Response = HandshakeError::NoWebsocketUpgrade.error_response();
+        let resp: Response<AnyBody> = HandshakeError::NoWebsocketUpgrade.into();
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: Response = HandshakeError::NoConnectionUpgrade.error_response();
+        let resp: Response<AnyBody> = HandshakeError::NoConnectionUpgrade.into();
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: Response = HandshakeError::NoVersionHeader.error_response();
+        let resp: Response<AnyBody> = HandshakeError::NoVersionHeader.into();
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: Response = HandshakeError::UnsupportedVersion.error_response();
+        let resp: Response<AnyBody> = HandshakeError::UnsupportedVersion.into();
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: Response = HandshakeError::BadWebsocketKey.error_response();
+        let resp: Response<AnyBody> = HandshakeError::BadWebsocketKey.into();
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
    }
 }
--- a/actix-http/tests/test_client.rs
+++ b/actix-http/tests/test_client.rs
@ -1,10 +1,13 @@
+use std::convert::Infallible;
+
 use actix_http::{
-    error, http, http::StatusCode, HttpMessage, HttpService, Request, Response,
+    body::AnyBody, http, http::StatusCode, HttpMessage, HttpService, Request, Response,
 };
 use actix_http_test::test_server;
 use actix_service::ServiceFactoryExt;
 use actix_utils::future;
 use bytes::Bytes;
+use derive_more::{Display, Error};
 use futures_util::StreamExt as _;

 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
@ -33,7 +36,7 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 async fn test_h1_v2() {
    let srv = test_server(move || {
        HttpService::build()
-            .finish(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
+            .finish(|_| future::ok::<_, Infallible>(Response::ok().set_body(STR)))
            .tcp()
    })
    .await;
@ -61,7 +64,7 @@ async fn test_h1_v2() {
 async fn test_connection_close() {
    let srv = test_server(move || {
        HttpService::build()
-            .finish(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
+            .finish(|_| future::ok::<_, Infallible>(Response::ok().set_body(STR)))
            .tcp()
            .map(|_| ())
    })
@ -75,11 +78,11 @@ async fn test_connection_close() {
 async fn test_with_query_parameter() {
    let srv = test_server(move || {
        HttpService::build()
-            .finish(|req: Request| {
+            .finish(|req: Request| async move {
                if req.uri().query().unwrap().contains("qp=") {
-                    future::ok::<_, ()>(Response::Ok().finish())
+                    Ok::<_, Infallible>(Response::ok())
                } else {
-                    future::ok::<_, ()>(Response::BadRequest().finish())
+                    Ok(Response::bad_request())
                }
            })
            .tcp()
@ -92,6 +95,16 @@ async fn test_with_query_parameter() {
    assert!(response.status().is_success());
 }

+#[derive(Debug, Display, Error)]
+#[display(fmt = "expect failed")]
+struct ExpectFailed;
+
+impl From<ExpectFailed> for Response<AnyBody> {
+    fn from(_: ExpectFailed) -> Self {
+        Response::new(StatusCode::EXPECTATION_FAILED)
+    }
+}
+
 #[actix_rt::test]
 async fn test_h1_expect() {
    let srv = test_server(move || {
@ -100,7 +113,7 @@ async fn test_h1_expect() {
                if req.headers().contains_key("AUTH") {
                    Ok(req)
                } else {
-                    Err(error::ErrorExpectationFailed("expect failed"))
+                    Err(ExpectFailed)
                }
            })
            .h1(|req: Request| async move {
@ -112,7 +125,7 @@ async fn test_h1_expect() {
                let str = std::str::from_utf8(&buf).unwrap();
                assert_eq!(str, "expect body");

-                Ok::<_, ()>(Response::Ok().finish())
+                Ok::<_, Infallible>(Response::ok())
            })
            .tcp()
    })
@ -134,7 +147,7 @@ async fn test_h1_expect() {
    let response = request.send_body("expect body").await.unwrap();
    assert_eq!(response.status(), StatusCode::EXPECTATION_FAILED);

-    // test exepct would continue
+    // test expect would continue
    let request = srv
        .request(http::Method::GET, srv.url("/"))
        .insert_header(("Expect", "100-continue"))
--- a/actix-http/tests/test_openssl.rs
+++ b/actix-http/tests/test_openssl.rs
@ -2,17 +2,22 @@

 extern crate tls_openssl as openssl;

-use std::io;
+use std::{convert::Infallible, 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;
-use actix_http::{body, Error, HttpService, Request, Response};
+use actix_http::{
+    body::{AnyBody, Body, SizedStream},
+    error::PayloadError,
+    http::{
+        header::{self, HeaderName, HeaderValue},
+        Method, StatusCode, Version,
+    },
+    Error, HttpMessage, HttpService, Request, Response,
+};
 use actix_http_test::test_server;
 use actix_service::{fn_service, ServiceFactoryExt};
 use actix_utils::future::{err, ok, ready};
 use bytes::{Bytes, BytesMut};
+use derive_more::{Display, Error};
 use futures_core::Stream;
 use futures_util::stream::{once, StreamExt as _};
 use openssl::{
@ -67,7 +72,7 @@ fn tls_config() -> SslAcceptor {
 async fn test_h2() -> io::Result<()> {
    let srv = test_server(move || {
        HttpService::build()
-            .h2(|_| ok::<_, Error>(Response::Ok().finish()))
+            .h2(|_| ok::<_, Error>(Response::ok()))
            .openssl(tls_config())
            .map_err(|_| ())
    })
@ -85,7 +90,7 @@ async fn test_h2_1() -> io::Result<()> {
            .finish(|req: Request| {
                assert!(req.peer_addr().is_some());
                assert_eq!(req.version(), Version::HTTP_2);
-                ok::<_, Error>(Response::Ok().finish())
+                ok::<_, Error>(Response::ok())
            })
            .openssl(tls_config())
            .map_err(|_| ())
@ -104,7 +109,7 @@ async fn test_h2_body() -> io::Result<()> {
        HttpService::build()
            .h2(|mut req: Request<_>| async move {
                let body = load_body(req.take_payload()).await?;
-                Ok::<_, Error>(Response::Ok().body(body))
+                Ok::<_, Error>(Response::ok().set_body(body))
            })
            .openssl(tls_config())
            .map_err(|_| ())
@ -131,7 +136,7 @@ async fn test_h2_content_length() {
                    StatusCode::OK,
                    StatusCode::NOT_FOUND,
                ];
-                ok::<_, ()>(Response::new(statuses[idx]))
+                ok::<_, Infallible>(Response::new(statuses[idx]))
            })
            .openssl(tls_config())
            .map_err(|_| ())
@ -182,7 +187,7 @@ async fn test_h2_headers() {
    let mut srv = test_server(move || {
        let data = data.clone();
        HttpService::build().h2(move |_| {
-            let mut builder = Response::Ok();
+            let mut builder = Response::build(StatusCode::OK);
            for idx in 0..90 {
                builder.insert_header(
                    (format!("X-TEST-{}", idx).as_str(),
@ -201,7 +206,7 @@ async fn test_h2_headers() {
                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
                ));
            }
-            ok::<_, ()>(builder.body(data.clone()))
+            ok::<_, Infallible>(builder.body(data.clone()))
        })
            .openssl(tls_config())
                    .map_err(|_| ())
@ -241,7 +246,7 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 async fn test_h2_body2() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .openssl(tls_config())
            .map_err(|_| ())
    })
@ -259,7 +264,7 @@ async fn test_h2_body2() {
 async fn test_h2_head_empty() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .finish(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .openssl(tls_config())
            .map_err(|_| ())
    })
@ -283,7 +288,7 @@ async fn test_h2_head_empty() {
 async fn test_h2_head_binary() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .openssl(tls_config())
            .map_err(|_| ())
    })
@ -306,7 +311,7 @@ async fn test_h2_head_binary() {
 async fn test_h2_head_binary2() {
    let srv = test_server(move || {
        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .openssl(tls_config())
            .map_err(|_| ())
    })
@ -325,10 +330,13 @@ async fn test_h2_head_binary2() {
 async fn test_h2_body_length() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .h2(|_| {
-                let body = once(ok(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
+            .h2(|_| async {
+                let body = once(async {
+                    Ok::<_, Infallible>(Bytes::from_static(STR.as_ref()))
+                });
+
+                Ok::<_, Infallible>(
+                    Response::ok().set_body(SizedStream::new(STR.len() as u64, body)),
                )
            })
            .openssl(tls_config())
@ -350,8 +358,8 @@ async fn test_h2_body_chunked_explicit() {
        HttpService::build()
            .h2(|_| {
                let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok()
+                ok::<_, Infallible>(
+                    Response::build(StatusCode::OK)
                        .insert_header((header::TRANSFER_ENCODING, "chunked"))
                        .streaming(body),
                )
@ -378,8 +386,8 @@ async fn test_h2_response_http_error_handling() {
        HttpService::build()
            .h2(fn_service(|_| {
                let broken_header = Bytes::from_static(b"\0\0\0");
-                ok::<_, ()>(
-                    Response::Ok()
+                ok::<_, Infallible>(
+                    Response::build(StatusCode::OK)
                        .insert_header((header::CONTENT_TYPE, broken_header))
                        .body(STR),
                )
@ -394,14 +402,27 @@ async fn test_h2_response_http_error_handling() {

    // read response
    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
+    assert_eq!(
+        bytes,
+        Bytes::from_static(b"error processing HTTP: failed to parse header value")
+    );
+}
+
+#[derive(Debug, Display, Error)]
+#[display(fmt = "error")]
+struct BadRequest;
+
+impl From<BadRequest> for Response<AnyBody> {
+    fn from(err: BadRequest) -> Self {
+        Response::build(StatusCode::BAD_REQUEST).body(err.to_string())
+    }
 }

 #[actix_rt::test]
 async fn test_h2_service_error() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .h2(|_| err::<Response, Error>(ErrorBadRequest("error")))
+            .h2(|_| err::<Response<Body>, _>(BadRequest))
            .openssl(tls_config())
            .map_err(|_| ())
    })
@ -424,7 +445,7 @@ async fn test_h2_on_connect() {
            })
            .h2(|req: Request| {
                assert!(req.extensions().contains::<isize>());
-                ok::<_, ()>(Response::Ok().finish())
+                ok::<_, Infallible>(Response::ok())
            })
            .openssl(tls_config())
            .map_err(|_| ())
--- a/actix-http/tests/test_rustls.rs
+++ b/actix-http/tests/test_rustls.rs
@ -2,23 +2,34 @@

 extern crate tls_rustls as rustls;

-use actix_http::error::PayloadError;
-use actix_http::http::header::{self, HeaderName, HeaderValue};
-use actix_http::http::{Method, StatusCode, Version};
-use actix_http::{body, error, Error, HttpService, Request, Response};
+use std::{
+    convert::Infallible,
+    io::{self, BufReader, Write},
+    net::{SocketAddr, TcpStream as StdTcpStream},
+    sync::Arc,
+};
+
+use actix_http::{
+    body::{AnyBody, Body, SizedStream},
+    error::PayloadError,
+    http::{
+        header::{self, HeaderName, HeaderValue},
+        Method, StatusCode, Version,
+    },
+    Error, HttpService, Request, Response,
+};
 use actix_http_test::test_server;
 use actix_service::{fn_factory_with_config, fn_service};
 use actix_utils::future::{err, ok};
-
 use bytes::{Bytes, BytesMut};
+use derive_more::{Display, Error};
 use futures_core::Stream;
 use futures_util::stream::{once, StreamExt as _};
 use rustls::{
    internal::pemfile::{certs, pkcs8_private_keys},
-    NoClientAuth, ServerConfig as RustlsServerConfig,
+    NoClientAuth, ServerConfig as RustlsServerConfig, Session,
 };
-
-use std::io::{self, BufReader};
+use webpki::DNSNameRef;

 async fn load_body<S>(mut stream: S) -> Result<BytesMut, PayloadError>
 where
@ -47,11 +58,30 @@ fn tls_config() -> RustlsServerConfig {
    config
 }

+pub fn get_negotiated_alpn_protocol(
+    addr: SocketAddr,
+    client_alpn_protocol: &[u8],
+) -> Option<Vec<u8>> {
+    let mut config = rustls::ClientConfig::new();
+    config.alpn_protocols.push(client_alpn_protocol.to_vec());
+    let mut sess = rustls::ClientSession::new(
+        &Arc::new(config),
+        DNSNameRef::try_from_ascii_str("localhost").unwrap(),
+    );
+    let mut sock = StdTcpStream::connect(addr).unwrap();
+    let mut stream = rustls::Stream::new(&mut sess, &mut sock);
+    // The handshake will fails because the client will not be able to verify the server
+    // certificate, but it doesn't matter here as we are just interested in the negotiated ALPN
+    // protocol
+    let _ = stream.flush();
+    sess.get_alpn_protocol().map(|proto| proto.to_vec())
+}
+
 #[actix_rt::test]
 async fn test_h1() -> io::Result<()> {
    let srv = test_server(move || {
        HttpService::build()
-            .h1(|_| ok::<_, Error>(Response::Ok().finish()))
+            .h1(|_| ok::<_, Error>(Response::ok()))
            .rustls(tls_config())
    })
    .await;
@ -65,7 +95,7 @@ async fn test_h1() -> io::Result<()> {
 async fn test_h2() -> io::Result<()> {
    let srv = test_server(move || {
        HttpService::build()
-            .h2(|_| ok::<_, Error>(Response::Ok().finish()))
+            .h2(|_| ok::<_, Error>(Response::ok()))
            .rustls(tls_config())
    })
    .await;
@ -82,7 +112,7 @@ async fn test_h1_1() -> io::Result<()> {
            .h1(|req: Request| {
                assert!(req.peer_addr().is_some());
                assert_eq!(req.version(), Version::HTTP_11);
-                ok::<_, Error>(Response::Ok().finish())
+                ok::<_, Error>(Response::ok())
            })
            .rustls(tls_config())
    })
@ -100,7 +130,7 @@ async fn test_h2_1() -> io::Result<()> {
            .finish(|req: Request| {
                assert!(req.peer_addr().is_some());
                assert_eq!(req.version(), Version::HTTP_2);
-                ok::<_, Error>(Response::Ok().finish())
+                ok::<_, Error>(Response::ok())
            })
            .rustls(tls_config())
    })
@ -118,7 +148,7 @@ async fn test_h2_body1() -> io::Result<()> {
        HttpService::build()
            .h2(|mut req: Request<_>| async move {
                let body = load_body(req.take_payload()).await?;
-                Ok::<_, Error>(Response::Ok().body(body))
+                Ok::<_, Error>(Response::ok().set_body(body))
            })
            .rustls(tls_config())
    })
@ -144,7 +174,7 @@ async fn test_h2_content_length() {
                    StatusCode::OK,
                    StatusCode::NOT_FOUND,
                ];
-                ok::<_, ()>(Response::new(statuses[indx]))
+                ok::<_, Infallible>(Response::new(statuses[indx]))
            })
            .rustls(tls_config())
    })
@ -194,7 +224,7 @@ async fn test_h2_headers() {
    let mut srv = test_server(move || {
        let data = data.clone();
        HttpService::build().h2(move |_| {
-            let mut config = Response::Ok();
+            let mut config = Response::build(StatusCode::OK);
            for idx in 0..90 {
                config.insert_header((
                    format!("X-TEST-{}", idx).as_str(),
@ -213,7 +243,7 @@ async fn test_h2_headers() {
                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
                ));
            }
-            ok::<_, ()>(config.body(data.clone()))
+            ok::<_, Infallible>(config.body(data.clone()))
        })
            .rustls(tls_config())
    }).await;
@ -252,7 +282,7 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 async fn test_h2_body2() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .rustls(tls_config())
    })
    .await;
@ -269,7 +299,7 @@ async fn test_h2_body2() {
 async fn test_h2_head_empty() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .finish(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .rustls(tls_config())
    })
    .await;
@ -295,7 +325,7 @@ async fn test_h2_head_empty() {
 async fn test_h2_head_binary() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .rustls(tls_config())
    })
    .await;
@ -320,7 +350,7 @@ async fn test_h2_head_binary() {
 async fn test_h2_head_binary2() {
    let srv = test_server(move || {
        HttpService::build()
-            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .rustls(tls_config())
    })
    .await;
@ -342,9 +372,9 @@ async fn test_h2_body_length() {
    let mut srv = test_server(move || {
        HttpService::build()
            .h2(|_| {
-                let body = once(ok(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
+                let body = once(ok::<_, Infallible>(Bytes::from_static(STR.as_ref())));
+                ok::<_, Infallible>(
+                    Response::ok().set_body(SizedStream::new(STR.len() as u64, body)),
                )
            })
            .rustls(tls_config())
@ -365,8 +395,8 @@ async fn test_h2_body_chunked_explicit() {
        HttpService::build()
            .h2(|_| {
                let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok()
+                ok::<_, Infallible>(
+                    Response::build(StatusCode::OK)
                        .insert_header((header::TRANSFER_ENCODING, "chunked"))
                        .streaming(body),
                )
@ -391,10 +421,10 @@ async fn test_h2_response_http_error_handling() {
    let mut srv = test_server(move || {
        HttpService::build()
            .h2(fn_factory_with_config(|_: ()| {
-                ok::<_, ()>(fn_service(|_| {
+                ok::<_, Infallible>(fn_service(|_| {
                    let broken_header = Bytes::from_static(b"\0\0\0");
-                    ok::<_, ()>(
-                        Response::Ok()
+                    ok::<_, Infallible>(
+                        Response::build(StatusCode::OK)
                            .insert_header((http::header::CONTENT_TYPE, broken_header))
                            .body(STR),
                    )
@ -409,14 +439,27 @@ async fn test_h2_response_http_error_handling() {

    // read response
    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
+    assert_eq!(
+        bytes,
+        Bytes::from_static(b"error processing HTTP: failed to parse header value")
+    );
+}
+
+#[derive(Debug, Display, Error)]
+#[display(fmt = "error")]
+struct BadRequest;
+
+impl From<BadRequest> for Response<AnyBody> {
+    fn from(_: BadRequest) -> Self {
+        Response::bad_request().set_body(AnyBody::from("error"))
+    }
 }

 #[actix_rt::test]
 async fn test_h2_service_error() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .h2(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
+            .h2(|_| err::<Response<Body>, _>(BadRequest))
            .rustls(tls_config())
    })
    .await;
@ -433,7 +476,7 @@ async fn test_h2_service_error() {
 async fn test_h1_service_error() {
    let mut srv = test_server(move || {
        HttpService::build()
-            .h1(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
+            .h1(|_| err::<Response<Body>, _>(BadRequest))
            .rustls(tls_config())
    })
    .await;
@ -445,3 +488,85 @@ async fn test_h1_service_error() {
    let bytes = srv.load_body(response).await.unwrap();
    assert_eq!(bytes, Bytes::from_static(b"error"));
 }
+
+const H2_ALPN_PROTOCOL: &[u8] = b"h2";
+const HTTP1_1_ALPN_PROTOCOL: &[u8] = b"http/1.1";
+const CUSTOM_ALPN_PROTOCOL: &[u8] = b"custom";
+
+#[actix_rt::test]
+async fn test_alpn_h1() -> io::Result<()> {
+    let srv = test_server(move || {
+        let mut config = tls_config();
+        config.alpn_protocols.push(CUSTOM_ALPN_PROTOCOL.to_vec());
+        HttpService::build()
+            .h1(|_| ok::<_, Error>(Response::ok()))
+            .rustls(config)
+    })
+    .await;
+
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), CUSTOM_ALPN_PROTOCOL),
+        Some(CUSTOM_ALPN_PROTOCOL.to_vec())
+    );
+
+    let response = srv.sget("/").send().await.unwrap();
+    assert!(response.status().is_success());
+
+    Ok(())
+}
+
+#[actix_rt::test]
+async fn test_alpn_h2() -> io::Result<()> {
+    let srv = test_server(move || {
+        let mut config = tls_config();
+        config.alpn_protocols.push(CUSTOM_ALPN_PROTOCOL.to_vec());
+        HttpService::build()
+            .h2(|_| ok::<_, Error>(Response::ok()))
+            .rustls(config)
+    })
+    .await;
+
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), H2_ALPN_PROTOCOL),
+        Some(H2_ALPN_PROTOCOL.to_vec())
+    );
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), CUSTOM_ALPN_PROTOCOL),
+        Some(CUSTOM_ALPN_PROTOCOL.to_vec())
+    );
+
+    let response = srv.sget("/").send().await.unwrap();
+    assert!(response.status().is_success());
+
+    Ok(())
+}
+
+#[actix_rt::test]
+async fn test_alpn_h2_1() -> io::Result<()> {
+    let srv = test_server(move || {
+        let mut config = tls_config();
+        config.alpn_protocols.push(CUSTOM_ALPN_PROTOCOL.to_vec());
+        HttpService::build()
+            .finish(|_| ok::<_, Error>(Response::ok()))
+            .rustls(config)
+    })
+    .await;
+
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), H2_ALPN_PROTOCOL),
+        Some(H2_ALPN_PROTOCOL.to_vec())
+    );
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), HTTP1_1_ALPN_PROTOCOL),
+        Some(HTTP1_1_ALPN_PROTOCOL.to_vec())
+    );
+    assert_eq!(
+        get_negotiated_alpn_protocol(srv.addr(), CUSTOM_ALPN_PROTOCOL),
+        Some(CUSTOM_ALPN_PROTOCOL.to_vec())
+    );
+
+    let response = srv.sget("/").send().await.unwrap();
+    assert!(response.status().is_success());
+
+    Ok(())
+}
--- a/actix-http/tests/test_server.rs
+++ b/actix-http/tests/test_server.rs
@ -1,20 +1,26 @@
-use std::io::{Read, Write};
-use std::time::Duration;
-use std::{net, thread};
+use std::{
+    convert::Infallible,
+    io::{Read, Write},
+    net, thread,
+    time::Duration,
+};

+use actix_http::{
+    body::{AnyBody, Body, SizedStream},
+    header, http, Error, HttpMessage, HttpService, KeepAlive, Request, Response,
+    StatusCode,
+};
 use actix_http_test::test_server;
 use actix_rt::time::sleep;
 use actix_service::fn_service;
 use actix_utils::future::{err, ok, ready};
 use bytes::Bytes;
-use futures_util::stream::{once, StreamExt as _};
-use futures_util::FutureExt as _;
-use regex::Regex;
-
-use actix_http::HttpMessage;
-use actix_http::{
-    body, error, http, http::header, Error, HttpService, KeepAlive, Request, Response,
+use derive_more::{Display, Error};
+use futures_util::{
+    stream::{once, StreamExt as _},
+    FutureExt as _,
 };
+use regex::Regex;

 #[actix_rt::test]
 async fn test_h1() {
@ -25,7 +31,7 @@ async fn test_h1() {
            .client_disconnect(1000)
            .h1(|req: Request| {
                assert!(req.peer_addr().is_some());
-                ok::<_, ()>(Response::Ok().finish())
+                ok::<_, Infallible>(Response::ok())
            })
            .tcp()
    })
@ -45,7 +51,7 @@ async fn test_h1_2() {
            .finish(|req: Request| {
                assert!(req.peer_addr().is_some());
                assert_eq!(req.version(), http::Version::HTTP_11);
-                ok::<_, ()>(Response::Ok().finish())
+                ok::<_, Infallible>(Response::ok())
            })
            .tcp()
    })
@ -55,6 +61,16 @@ async fn test_h1_2() {
    assert!(response.status().is_success());
 }

+#[derive(Debug, Display, Error)]
+#[display(fmt = "expect failed")]
+struct ExpectFailed;
+
+impl From<ExpectFailed> for Response<AnyBody> {
+    fn from(_: ExpectFailed) -> Self {
+        Response::new(StatusCode::EXPECTATION_FAILED)
+    }
+}
+
 #[actix_rt::test]
 async fn test_expect_continue() {
    let srv = test_server(|| {
@ -63,10 +79,10 @@ async fn test_expect_continue() {
                if req.head().uri.query() == Some("yes=") {
                    ok(req)
                } else {
-                    err(error::ErrorPreconditionFailed("error"))
+                    err(ExpectFailed)
                }
            }))
-            .finish(|_| ok::<_, ()>(Response::Ok().finish()))
+            .finish(|_| ok::<_, Infallible>(Response::ok()))
            .tcp()
    })
    .await;
@ -75,7 +91,7 @@ async fn test_expect_continue() {
    let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
    let mut data = String::new();
    let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 412 Precondition Failed\r\ncontent-length"));
+    assert!(data.starts_with("HTTP/1.1 417 Expectation Failed\r\ncontent-length"));

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test?yes= HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
@ -93,11 +109,11 @@ async fn test_expect_continue_h1() {
                    if req.head().uri.query() == Some("yes=") {
                        ok(req)
                    } else {
-                        err(error::ErrorPreconditionFailed("error"))
+                        err(ExpectFailed)
                    }
                })
            }))
-            .h1(fn_service(|_| ok::<_, ()>(Response::Ok().finish())))
+            .h1(fn_service(|_| ok::<_, Infallible>(Response::ok())))
            .tcp()
    })
    .await;
@ -106,7 +122,7 @@ async fn test_expect_continue_h1() {
    let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
    let mut data = String::new();
    let _ = stream.read_to_string(&mut data);
-    assert!(data.starts_with("HTTP/1.1 412 Precondition Failed\r\ncontent-length"));
+    assert!(data.starts_with("HTTP/1.1 417 Expectation Failed\r\ncontent-length"));

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test?yes= HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
@ -131,7 +147,9 @@ async fn test_chunked_payload() {
                    })
                    .fold(0usize, |acc, chunk| ready(acc + chunk.len()))
                    .map(|req_size| {
-                        Ok::<_, Error>(Response::Ok().body(format!("size={}", req_size)))
+                        Ok::<_, Error>(
+                            Response::ok().set_body(format!("size={}", req_size)),
+                        )
                    })
            }))
            .tcp()
@ -176,7 +194,7 @@ async fn test_slow_request() {
    let srv = test_server(|| {
        HttpService::build()
            .client_timeout(100)
-            .finish(|_| ok::<_, ()>(Response::Ok().finish()))
+            .finish(|_| ok::<_, Infallible>(Response::ok()))
            .tcp()
    })
    .await;
@ -192,7 +210,7 @@ async fn test_slow_request() {
 async fn test_http1_malformed_request() {
    let srv = test_server(|| {
        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().finish()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
            .tcp()
    })
    .await;
@ -208,7 +226,7 @@ async fn test_http1_malformed_request() {
 async fn test_http1_keepalive() {
    let srv = test_server(|| {
        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().finish()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
            .tcp()
    })
    .await;
@ -230,7 +248,7 @@ async fn test_http1_keepalive_timeout() {
    let srv = test_server(|| {
        HttpService::build()
            .keep_alive(1)
-            .h1(|_| ok::<_, ()>(Response::Ok().finish()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
            .tcp()
    })
    .await;
@ -251,7 +269,7 @@ async fn test_http1_keepalive_timeout() {
 async fn test_http1_keepalive_close() {
    let srv = test_server(|| {
        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().finish()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
            .tcp()
    })
    .await;
@ -272,7 +290,7 @@ async fn test_http1_keepalive_close() {
 async fn test_http10_keepalive_default_close() {
    let srv = test_server(|| {
        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().finish()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
            .tcp()
    })
    .await;
@ -292,7 +310,7 @@ async fn test_http10_keepalive_default_close() {
 async fn test_http10_keepalive() {
    let srv = test_server(|| {
        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().finish()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
            .tcp()
    })
    .await;
@ -320,7 +338,7 @@ async fn test_http1_keepalive_disabled() {
    let srv = test_server(|| {
        HttpService::build()
            .keep_alive(KeepAlive::Disabled)
-            .h1(|_| ok::<_, ()>(Response::Ok().finish()))
+            .h1(|_| ok::<_, Infallible>(Response::ok()))
            .tcp()
    })
    .await;
@ -355,7 +373,7 @@ async fn test_content_length() {
                    StatusCode::OK,
                    StatusCode::NOT_FOUND,
                ];
-                ok::<_, ()>(Response::new(statuses[indx]))
+                ok::<_, Infallible>(Response::new(statuses[indx]))
            })
            .tcp()
    })
@ -391,7 +409,7 @@ async fn test_h1_headers() {
    let mut srv = test_server(move || {
        let data = data.clone();
        HttpService::build().h1(move |_| {
-            let mut builder = Response::Ok();
+            let mut builder = Response::build(StatusCode::OK);
            for idx in 0..90 {
                builder.insert_header((
                    format!("X-TEST-{}", idx).as_str(),
@ -410,7 +428,7 @@ async fn test_h1_headers() {
                        TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
                ));
            }
-            ok::<_, ()>(builder.body(data.clone()))
+            ok::<_, Infallible>(builder.body(data.clone()))
        }).tcp()
    }).await;

@ -448,7 +466,7 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
 async fn test_h1_body() {
    let mut srv = test_server(|| {
        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h1(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .tcp()
    })
    .await;
@ -465,7 +483,7 @@ async fn test_h1_body() {
 async fn test_h1_head_empty() {
    let mut srv = test_server(|| {
        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h1(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .tcp()
    })
    .await;
@ -490,7 +508,7 @@ async fn test_h1_head_empty() {
 async fn test_h1_head_binary() {
    let mut srv = test_server(|| {
        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h1(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .tcp()
    })
    .await;
@ -515,7 +533,7 @@ async fn test_h1_head_binary() {
 async fn test_h1_head_binary2() {
    let srv = test_server(|| {
        HttpService::build()
-            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
+            .h1(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
            .tcp()
    })
    .await;
@ -537,9 +555,9 @@ async fn test_h1_body_length() {
    let mut srv = test_server(|| {
        HttpService::build()
            .h1(|_| {
-                let body = once(ok(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
+                let body = once(ok::<_, Infallible>(Bytes::from_static(STR.as_ref())));
+                ok::<_, Infallible>(
+                    Response::ok().set_body(SizedStream::new(STR.len() as u64, body)),
                )
            })
            .tcp()
@ -560,8 +578,8 @@ async fn test_h1_body_chunked_explicit() {
        HttpService::build()
            .h1(|_| {
                let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(
-                    Response::Ok()
+                ok::<_, Infallible>(
+                    Response::build(StatusCode::OK)
                        .insert_header((header::TRANSFER_ENCODING, "chunked"))
                        .streaming(body),
                )
@ -595,7 +613,7 @@ async fn test_h1_body_chunked_implicit() {
        HttpService::build()
            .h1(|_| {
                let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
-                ok::<_, ()>(Response::Ok().streaming(body))
+                ok::<_, Infallible>(Response::build(StatusCode::OK).streaming(body))
            })
            .tcp()
    })
@ -624,8 +642,8 @@ async fn test_h1_response_http_error_handling() {
        HttpService::build()
            .h1(fn_service(|_| {
                let broken_header = Bytes::from_static(b"\0\0\0");
-                ok::<_, ()>(
-                    Response::Ok()
+                ok::<_, Infallible>(
+                    Response::build(StatusCode::OK)
                        .insert_header((http::header::CONTENT_TYPE, broken_header))
                        .body(STR),
                )
@ -639,14 +657,27 @@ async fn test_h1_response_http_error_handling() {

    // read response
    let bytes = srv.load_body(response).await.unwrap();
-    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
+    assert_eq!(
+        bytes,
+        Bytes::from_static(b"error processing HTTP: failed to parse header value")
+    );
+}
+
+#[derive(Debug, Display, Error)]
+#[display(fmt = "error")]
+struct BadRequest;
+
+impl From<BadRequest> for Response<AnyBody> {
+    fn from(_: BadRequest) -> Self {
+        Response::bad_request().set_body(AnyBody::from("error"))
+    }
 }

 #[actix_rt::test]
 async fn test_h1_service_error() {
    let mut srv = test_server(|| {
        HttpService::build()
-            .h1(|_| err::<Response, _>(error::ErrorBadRequest("error")))
+            .h1(|_| err::<Response<Body>, _>(BadRequest))
            .tcp()
    })
    .await;
@ -668,7 +699,7 @@ async fn test_h1_on_connect() {
            })
            .h1(|req: Request| {
                assert!(req.extensions().contains::<isize>());
-                ok::<_, ()>(Response::Ok().finish())
+                ok::<_, Infallible>(Response::ok())
            })
            .tcp()
    })
--- a/actix-http/tests/test_ws.rs
+++ b/actix-http/tests/test_ws.rs
@ -1,193 +1,196 @@
-use std::cell::Cell;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::sync::{Arc, Mutex};
-use std::task::{Context, Poll};
+use std::{
+    cell::Cell,
+    convert::Infallible,
+    task::{Context, Poll},
+};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_http::{body, h1, ws, Error, HttpService, Request, Response};
+use actix_http::{
+    body::{AnyBody, BodySize},
+    h1,
+    ws::{self, CloseCode, Frame, Item, Message},
+    Error, HttpService, Request, Response,
+};
 use actix_http_test::test_server;
 use actix_service::{fn_factory, Service};
-use actix_utils::future;
 use bytes::Bytes;
+use derive_more::{Display, Error, From};
+use futures_core::future::LocalBoxFuture;
 use futures_util::{SinkExt as _, StreamExt as _};

-use crate::ws::Dispatcher;
+#[derive(Clone)]
+struct WsService(Cell<bool>);

-struct WsService<T>(Arc<Mutex<(PhantomData<T>, Cell<bool>)>>);
-
-impl<T> WsService<T> {
+impl WsService {
    fn new() -> Self {
-        WsService(Arc::new(Mutex::new((PhantomData, Cell::new(false)))))
+        WsService(Cell::new(false))
    }

    fn set_polled(&self) {
-        *self.0.lock().unwrap().1.get_mut() = true;
+        self.0.set(true);
    }

    fn was_polled(&self) -> bool {
-        self.0.lock().unwrap().1.get()
+        self.0.get()
    }
 }

-impl<T> Clone for WsService<T> {
-    fn clone(&self) -> Self {
-        WsService(self.0.clone())
+#[derive(Debug, Display, Error, From)]
+enum WsServiceError {
+    #[display(fmt = "http error")]
+    Http(actix_http::Error),
+
+    #[display(fmt = "ws handshake error")]
+    Ws(actix_http::ws::HandshakeError),
+
+    #[display(fmt = "io error")]
+    Io(std::io::Error),
+
+    #[display(fmt = "dispatcher error")]
+    Dispatcher,
+}
+
+impl From<WsServiceError> for Response<AnyBody> {
+    fn from(err: WsServiceError) -> Self {
+        match err {
+            WsServiceError::Http(err) => err.into(),
+            WsServiceError::Ws(err) => err.into(),
+            WsServiceError::Io(_err) => unreachable!(),
+            WsServiceError::Dispatcher => Response::internal_server_error()
+                .set_body(AnyBody::from(format!("{}", err))),
+        }
    }
 }

-impl<T> Service<(Request, Framed<T, h1::Codec>)> for WsService<T>
+impl<T> Service<(Request, Framed<T, h1::Codec>)> for WsService
 where
    T: AsyncRead + AsyncWrite + Unpin + 'static,
 {
    type Response = ();
-    type Error = Error;
-    type Future = Pin<Box<dyn Future<Output = Result<(), Error>>>>;
+    type Error = WsServiceError;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

-    fn poll_ready(&self, _ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.set_polled();
        Poll::Ready(Ok(()))
    }

    fn call(&self, (req, mut framed): (Request, Framed<T, h1::Codec>)) -> Self::Future {
-        let fut = async move {
-            let res = ws::handshake(req.head()).unwrap().message_body(());
+        assert!(self.was_polled());

-            framed
-                .send((res, body::BodySize::None).into())
+        Box::pin(async move {
+            let res = ws::handshake(req.head())?.message_body(())?;
+
+            framed.send((res, BodySize::None).into()).await?;
+
+            let framed = framed.replace_codec(ws::Codec::new());
+
+            ws::Dispatcher::with(framed, service)
                .await
-                .unwrap();
+                .map_err(|_| WsServiceError::Dispatcher)?;

-            Dispatcher::with(framed.replace_codec(ws::Codec::new()), service)
-                .await
-                .map_err(|_| panic!())
-        };
-
-        Box::pin(fut)
+            Ok(())
+        })
    }
 }

-async fn service(msg: ws::Frame) -> Result<ws::Message, Error> {
+async fn service(msg: Frame) -> Result<Message, Error> {
    let msg = match msg {
-        ws::Frame::Ping(msg) => ws::Message::Pong(msg),
-        ws::Frame::Text(text) => {
-            ws::Message::Text(String::from_utf8_lossy(&text).into_owned().into())
+        Frame::Ping(msg) => Message::Pong(msg),
+        Frame::Text(text) => {
+            Message::Text(String::from_utf8_lossy(&text).into_owned().into())
        }
-        ws::Frame::Binary(bin) => ws::Message::Binary(bin),
-        ws::Frame::Continuation(item) => ws::Message::Continuation(item),
-        ws::Frame::Close(reason) => ws::Message::Close(reason),
-        _ => panic!(),
+        Frame::Binary(bin) => Message::Binary(bin),
+        Frame::Continuation(item) => Message::Continuation(item),
+        Frame::Close(reason) => Message::Close(reason),
+        _ => return Err(ws::ProtocolError::BadOpCode.into()),
    };
+
    Ok(msg)
 }

 #[actix_rt::test]
 async fn test_simple() {
-    let ws_service = WsService::new();
-    let mut srv = test_server({
-        let ws_service = ws_service.clone();
-        move || {
-            let ws_service = ws_service.clone();
-            HttpService::build()
-                .upgrade(fn_factory(move || future::ok::<_, ()>(ws_service.clone())))
-                .finish(|_| future::ok::<_, ()>(Response::NotFound()))
-                .tcp()
-        }
+    let mut srv = test_server(|| {
+        HttpService::build()
+            .upgrade(fn_factory(|| async {
+                Ok::<_, Infallible>(WsService::new())
+            }))
+            .finish(|_| async { Ok::<_, Infallible>(Response::not_found()) })
+            .tcp()
    })
    .await;

    // client service
    let mut framed = srv.ws().await.unwrap();
-    framed.send(ws::Message::Text("text".into())).await.unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Text(Bytes::from_static(b"text"))
-    );
+    framed.send(Message::Text("text".into())).await.unwrap();
+
+    let item = framed.next().await.unwrap().unwrap();
+    assert_eq!(item, Frame::Text(Bytes::from_static(b"text")));
+
+    framed.send(Message::Binary("text".into())).await.unwrap();
+
+    let item = framed.next().await.unwrap().unwrap();
+    assert_eq!(item, Frame::Binary(Bytes::from_static(&b"text"[..])));
+
+    framed.send(Message::Ping("text".into())).await.unwrap();
+    let item = framed.next().await.unwrap().unwrap();
+    assert_eq!(item, Frame::Pong("text".to_string().into()));

    framed
-        .send(ws::Message::Binary("text".into()))
+        .send(Message::Continuation(Item::FirstText("text".into())))
        .await
        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
+    let item = framed.next().await.unwrap().unwrap();
    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Binary(Bytes::from_static(&b"text"[..]))
-    );
-
-    framed.send(ws::Message::Ping("text".into())).await.unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Pong("text".to_string().into())
-    );
-
-    framed
-        .send(ws::Message::Continuation(ws::Item::FirstText(
-            "text".into(),
-        )))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Continuation(ws::Item::FirstText(Bytes::from_static(b"text")))
+        item,
+        Frame::Continuation(Item::FirstText(Bytes::from_static(b"text")))
    );

    assert!(framed
-        .send(ws::Message::Continuation(ws::Item::FirstText(
-            "text".into()
-        )))
+        .send(Message::Continuation(Item::FirstText("text".into())))
        .await
        .is_err());
    assert!(framed
-        .send(ws::Message::Continuation(ws::Item::FirstBinary(
-            "text".into()
-        )))
+        .send(Message::Continuation(Item::FirstBinary("text".into())))
        .await
        .is_err());

    framed
-        .send(ws::Message::Continuation(ws::Item::Continue("text".into())))
+        .send(Message::Continuation(Item::Continue("text".into())))
        .await
        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
+    let item = framed.next().await.unwrap().unwrap();
    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Continuation(ws::Item::Continue(Bytes::from_static(b"text")))
+        item,
+        Frame::Continuation(Item::Continue(Bytes::from_static(b"text")))
    );

    framed
-        .send(ws::Message::Continuation(ws::Item::Last("text".into())))
+        .send(Message::Continuation(Item::Last("text".into())))
        .await
        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
+    let item = framed.next().await.unwrap().unwrap();
    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Continuation(ws::Item::Last(Bytes::from_static(b"text")))
+        item,
+        Frame::Continuation(Item::Last(Bytes::from_static(b"text")))
    );

    assert!(framed
-        .send(ws::Message::Continuation(ws::Item::Continue("text".into())))
+        .send(Message::Continuation(Item::Continue("text".into())))
        .await
        .is_err());

    assert!(framed
-        .send(ws::Message::Continuation(ws::Item::Last("text".into())))
+        .send(Message::Continuation(Item::Last("text".into())))
        .await
        .is_err());

    framed
-        .send(ws::Message::Close(Some(ws::CloseCode::Normal.into())))
+        .send(Message::Close(Some(CloseCode::Normal.into())))
        .await
        .unwrap();

-    let (item, _framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Close(Some(ws::CloseCode::Normal.into()))
-    );
-
-    assert!(ws_service.was_polled());
+    let item = framed.next().await.unwrap().unwrap();
+    assert_eq!(item, Frame::Close(Some(CloseCode::Normal.into())));
 }
--- a/actix-multipart/CHANGES.md
+++ b/actix-multipart/CHANGES.md
@ -3,6 +3,14 @@
 ## Unreleased - 2021-xx-xx


+## 0.4.0-beta.5 - 2021-06-17
+* No notable changes.
+
+
+## 0.4.0-beta.4 - 2021-04-02
+* No notable changes.
+
+
 ## 0.4.0-beta.3 - 2021-03-09
 * No notable changes.

--- a/actix-multipart/Cargo.toml
+++ b/actix-multipart/Cargo.toml
@ -1,13 +1,13 @@
 [package]
 name = "actix-multipart"
-version = "0.4.0-beta.3"
+version = "0.4.0-beta.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Multipart form support for Actix Web"
 readme = "README.md"
 keywords = ["http", "web", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-multipart/"
+documentation = "https://docs.rs/actix-multipart"
 license = "MIT OR Apache-2.0"
 edition = "2018"

@ -16,8 +16,8 @@ name = "actix_multipart"
 path = "src/lib.rs"

 [dependencies]
-actix-web = { version = "4.0.0-beta.5", default-features = false }
-actix-utils = "3.0.0-beta.4"
+actix-web = { version = "4.0.0-beta.7", default-features = false }
+actix-utils = "3.0.0"

 bytes = "1"
 derive_more = "0.99.5"
@ -31,6 +31,6 @@ twoway = "0.2"

 [dev-dependencies]
 actix-rt = "2.2"
-actix-http = "3.0.0-beta.5"
+actix-http = "3.0.0-beta.7"
 tokio = { version = "1", features = ["sync"] }
 tokio-stream = "0.1"
--- a/actix-multipart/README.md
+++ b/actix-multipart/README.md
@ -3,11 +3,11 @@
 > 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.3)](https://docs.rs/actix-multipart/0.4.0-beta.3)
+[![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.4.0-beta.5)](https://docs.rs/actix-multipart/0.4.0-beta.5)
 [![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.3/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0-beta.3)
+[![dependency status](https://deps.rs/crate/actix-multipart/0.4.0-beta.5/status.svg)](https://deps.rs/crate/actix-multipart/0.4.0-beta.5)
 [![Download](https://img.shields.io/crates/d/actix-multipart.svg)](https://crates.io/crates/actix-multipart)

 ## Documentation & Resources
--- a/actix-multipart/src/error.rs
+++ b/actix-multipart/src/error.rs
@ -45,11 +45,10 @@ impl ResponseError for MultipartError {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use actix_web::HttpResponse;

    #[test]
    fn test_multipart_error() {
-        let resp: HttpResponse = MultipartError::Boundary.error_response();
+        let resp = MultipartError::Boundary.error_response();
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
    }
 }
--- a/actix-test/CHANGES.md
+++ b/actix-test/CHANGES.md
@ -1,6 +1,13 @@
 # Changes

 ## Unreleased - 2021-xx-xx
-* Move integration testing structs from `actix-web`. [#???]

-[#???]: https://github.com/actix/actix-web/pull/???
+
+## 0.1.0-beta.2 - 2021-04-17
+* No significant changes from `0.1.0-beta.1`.
+
+
+## 0.1.0-beta.1 - 2021-04-02
+* Move integration testing structs from `actix-web`. [#2112]
+
+[#2112]: https://github.com/actix/actix-web/pull/2112
--- a/actix-test/Cargo.toml
+++ b/actix-test/Cargo.toml
@ -1,7 +1,10 @@
 [package]
 name = "actix-test"
-version = "0.0.1"
-authors = ["Rob Ede <robjtede@icloud.com>"]
+version = "0.1.0-beta.2"
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Rob Ede <robjtede@icloud.com>",
+]
 edition = "2018"
 description = "Integration testing tools for Actix Web applications"
 license = "MIT OR Apache-2.0"
@ -16,14 +19,14 @@ rustls = ["tls-rustls", "actix-http/rustls"]
 openssl = ["tls-openssl", "actix-http/openssl"]

 [dependencies]
-actix-codec = "0.4.0-beta.1"
-actix-http = { version = "3.0.0-beta.5", features = ["cookies"] }
-actix-http-test = { version = "3.0.0-beta.3", features = [] }
-actix-service = "2.0.0-beta.4"
-actix-utils = "3.0.0-beta.2"
-actix-web = { version = "4.0.0-beta.5", default-features = false, features = ["cookies"] }
+actix-codec = "0.4.0"
+actix-http = "3.0.0-beta.7"
+actix-http-test = { version = "3.0.0-beta.4", features = [] }
+actix-service = "2.0.0"
+actix-utils = "3.0.0"
+actix-web = { version = "4.0.0-beta.7", default-features = false, features = ["cookies"] }
 actix-rt = "2.1"
-awc = { version = "3.0.0-beta.4", default-features = false, features = ["cookies"] }
+awc = { version = "3.0.0-beta.6", default-features = false, features = ["cookies"] }

 futures-core = { version = "0.3.7", default-features = false, features = ["std"] }
 futures-util = { version = "0.3.7", default-features = false, features = [] }
--- a/actix-test/src/lib.rs
+++ b/actix-test/src/lib.rs
@ -31,18 +31,18 @@ extern crate tls_openssl as openssl;
 #[cfg(feature = "rustls")]
 extern crate tls_rustls as rustls;

-use std::{fmt, net, sync::mpsc, thread, time};
+use std::{error::Error as StdError, fmt, net, sync::mpsc, thread, time};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 pub use actix_http::test::TestBuffer;
 use actix_http::{
    http::{HeaderMap, Method},
-    ws, HttpService, Request,
+    ws, HttpService, Request, Response,
 };
-use actix_service::{map_config, IntoServiceFactory, ServiceFactory};
+use actix_service::{map_config, IntoServiceFactory, ServiceFactory, ServiceFactoryExt as _};
 use actix_web::{
    dev::{AppConfig, MessageBody, Server, Service},
-    rt, web, Error, HttpResponse,
+    rt, web, Error,
 };
 use awc::{error::PayloadError, Client, ClientRequest, ClientResponse, Connector};
 use futures_core::Stream;
@ -83,9 +83,10 @@ where
    S: ServiceFactory<Request, Config = AppConfig> + 'static,
    S::Error: Into<Error> + 'static,
    S::InitError: fmt::Debug,
-    S::Response: Into<HttpResponse<B>> + 'static,
+    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
    start_with(TestServerConfig::default(), factory)
 }
@ -122,9 +123,10 @@ where
    S: ServiceFactory<Request, Config = AppConfig> + 'static,
    S::Error: Into<Error> + 'static,
    S::InitError: fmt::Debug,
-    S::Response: Into<HttpResponse<B>> + 'static,
+    S::Response: Into<Response<B>> + 'static,
    <S::Service as Service<Request>>::Future: 'static,
    B: MessageBody + 'static,
+    B::Error: Into<Box<dyn StdError>>,
 {
    let (tx, rx) = mpsc::channel();

@ -151,25 +153,40 @@ where
                HttpVer::Http1 => builder.listen("test", tcp, move || {
                    let app_cfg =
                        AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                    HttpService::build()
                        .client_timeout(timeout)
-                        .h1(map_config(factory(), move |_| app_cfg.clone()))
+                        .h1(map_config(fac, move |_| app_cfg.clone()))
                        .tcp()
                }),
                HttpVer::Http2 => builder.listen("test", tcp, move || {
                    let app_cfg =
                        AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                    HttpService::build()
                        .client_timeout(timeout)
-                        .h2(map_config(factory(), move |_| app_cfg.clone()))
+                        .h2(map_config(fac, move |_| app_cfg.clone()))
                        .tcp()
                }),
                HttpVer::Both => builder.listen("test", tcp, move || {
                    let app_cfg =
                        AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                    HttpService::build()
                        .client_timeout(timeout)
-                        .finish(map_config(factory(), move |_| app_cfg.clone()))
+                        .finish(map_config(fac, move |_| app_cfg.clone()))
                        .tcp()
                }),
            },
@ -178,25 +195,40 @@ where
                HttpVer::Http1 => builder.listen("test", tcp, move || {
                    let app_cfg =
                        AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                    HttpService::build()
                        .client_timeout(timeout)
-                        .h1(map_config(factory(), move |_| app_cfg.clone()))
+                        .h1(map_config(fac, move |_| app_cfg.clone()))
                        .openssl(acceptor.clone())
                }),
                HttpVer::Http2 => builder.listen("test", tcp, move || {
                    let app_cfg =
                        AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                    HttpService::build()
                        .client_timeout(timeout)
-                        .h2(map_config(factory(), move |_| app_cfg.clone()))
+                        .h2(map_config(fac, move |_| app_cfg.clone()))
                        .openssl(acceptor.clone())
                }),
                HttpVer::Both => builder.listen("test", tcp, move || {
                    let app_cfg =
                        AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                    HttpService::build()
                        .client_timeout(timeout)
-                        .finish(map_config(factory(), move |_| app_cfg.clone()))
+                        .finish(map_config(fac, move |_| app_cfg.clone()))
                        .openssl(acceptor.clone())
                }),
            },
@ -205,25 +237,40 @@ where
                HttpVer::Http1 => builder.listen("test", tcp, move || {
                    let app_cfg =
                        AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                    HttpService::build()
                        .client_timeout(timeout)
-                        .h1(map_config(factory(), move |_| app_cfg.clone()))
+                        .h1(map_config(fac, move |_| app_cfg.clone()))
                        .rustls(config.clone())
                }),
                HttpVer::Http2 => builder.listen("test", tcp, move || {
                    let app_cfg =
                        AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                    HttpService::build()
                        .client_timeout(timeout)
-                        .h2(map_config(factory(), move |_| app_cfg.clone()))
+                        .h2(map_config(fac, move |_| app_cfg.clone()))
                        .rustls(config.clone())
                }),
                HttpVer::Both => builder.listen("test", tcp, move || {
                    let app_cfg =
                        AppConfig::__priv_test_new(false, local_addr.to_string(), local_addr);
+
+                    let fac = factory()
+                        .into_factory()
+                        .map_err(|err| err.into().error_response());
+
                    HttpService::build()
                        .client_timeout(timeout)
-                        .finish(map_config(factory(), move |_| app_cfg.clone()))
+                        .finish(map_config(fac, move |_| app_cfg.clone()))
                        .rustls(config.clone())
                }),
            },
--- a/actix-web-actors/CHANGES.md
+++ b/actix-web-actors/CHANGES.md
@ -3,6 +3,14 @@
 ## Unreleased - 2021-xx-xx


+## 4.0.0-beta.5 - 2021-06-17
+* No notable changes.
+
+
+## 4.0.0-beta.4 - 2021-04-02
+* No notable changes.
+
+
 ## 4.0.0-beta.3 - 2021-03-09
 * No notable changes.

--- a/actix-web-actors/Cargo.toml
+++ b/actix-web-actors/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web-actors"
-version = "4.0.0-beta.3"
+version = "4.0.0-beta.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix actors support for Actix Web"
 readme = "README.md"
@ -17,9 +17,9 @@ path = "src/lib.rs"

 [dependencies]
 actix = { version = "0.11.0-beta.3", default-features = false }
-actix-codec = "0.4.0-beta.1"
-actix-http = "3.0.0-beta.5"
-actix-web = { version = "4.0.0-beta.5", default-features = false }
+actix-codec = "0.4.0"
+actix-http = "3.0.0-beta.7"
+actix-web = { version = "4.0.0-beta.7", default-features = false }

 bytes = "1"
 bytestring = "1"
@ -29,8 +29,8 @@ tokio = { version = "1", features = ["sync"] }

 [dev-dependencies]
 actix-rt = "2.2"
-actix-test = "0.0.1"
+actix-test = "0.1.0-beta.2"

-awc = { version = "3.0.0-beta.4", default-features = false }
+awc = { version = "3.0.0-beta.6", default-features = false }
 env_logger = "0.8"
 futures-util = { version = "0.3.7", default-features = false }
--- a/actix-web-actors/README.md
+++ b/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=4.0.0-beta.3)](https://docs.rs/actix-web-actors/4.0.0-beta.3)
+[![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=4.0.0-beta.5)](https://docs.rs/actix-web-actors/4.0.0-beta.5)
 [![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/4.0.0-beta.3/status.svg)](https://deps.rs/crate/actix-web-actors/4.0.0-beta.3)
+[![dependency status](https://deps.rs/crate/actix-web-actors/4.0.0-beta.5/status.svg)](https://deps.rs/crate/actix-web-actors/4.0.0-beta.5)
 [![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)

--- a/actix-web-actors/src/ws.rs
+++ b/actix-web-actors/src/ws.rs
@ -22,10 +22,11 @@ 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};
-use actix_web::{HttpRequest, HttpResponse};
+use actix_web::{
+    error::{Error, PayloadError},
+    http::{header, Method, StatusCode},
+    HttpRequest, HttpResponse, HttpResponseBuilder,
+};
 use bytes::{Bytes, BytesMut};
 use bytestring::ByteString;
 use futures_core::Stream;
--- a/actix-web-codegen/CHANGES.md
+++ b/actix-web-codegen/CHANGES.md
@ -3,6 +3,10 @@
 ## Unreleased - 2021-xx-xx


+## 0.5.0-beta.3 - 2021-06-17
+* No notable changes.
+
+
 ## 0.5.0-beta.2 - 2021-03-09
 * Preserve doc comments when using route macros. [#2022]
 * Add `name` attribute to `route` macro. [#1934]
--- a/actix-web-codegen/Cargo.toml
+++ b/actix-web-codegen/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web-codegen"
-version = "0.5.0-beta.2"
+version = "0.5.0-beta.3"
 description = "Routing and runtime macros for Actix Web"
 readme = "README.md"
 homepage = "https://actix.rs"
@ -20,9 +20,9 @@ proc-macro2 = "1"

 [dev-dependencies]
 actix-rt = "2.2"
-actix-test = "0.0.1"
-actix-utils = "3.0.0-beta.4"
-actix-web = "4.0.0-beta.5"
+actix-test = "0.1.0-beta.2"
+actix-utils = "3.0.0"
+actix-web = "4.0.0-beta.7"

 futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
 trybuild = "1"
--- a/actix-web-codegen/README.md
+++ b/actix-web-codegen/README.md
@ -3,11 +3,11 @@
 > Routing and runtime macros for Actix Web.

 [![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?version=0.5.0-beta.2)](https://docs.rs/actix-web-codegen/0.5.0-beta.2)
+[![Documentation](https://docs.rs/actix-web-codegen/badge.svg?version=0.5.0-beta.3)](https://docs.rs/actix-web-codegen/0.5.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-codegen.svg)
 <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)
+[![dependency status](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.3/status.svg)](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.3)
 [![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)

--- a/actix-web-codegen/src/lib.rs
+++ b/actix-web-codegen/src/lib.rs
@ -171,27 +171,10 @@ method_macro! {
 #[proc_macro_attribute]
 pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
    use quote::quote;
-
-    let mut input = syn::parse_macro_input!(item as syn::ItemFn);
-    let attrs = &input.attrs;
-    let vis = &input.vis;
-    let sig = &mut input.sig;
-    let body = &input.block;
-
-    if sig.asyncness.is_none() {
-        return syn::Error::new_spanned(sig.fn_token, "only async fn is supported")
-            .to_compile_error()
-            .into();
-    }
-
-    sig.asyncness = None;
-
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
    (quote! {
-        #(#attrs)*
-        #vis #sig {
-            actix_web::rt::System::new()
-                .block_on(async move { #body })
-        }
+        #[actix_web::rt::main(system = "::actix_web::rt::System")]
+        #input
    })
    .into()
 }
--- a/actix-web-codegen/tests/test_macro.rs
+++ b/actix-web-codegen/tests/test_macro.rs
@ -1,10 +1,15 @@
 use std::future::Future;
-use std::task::{Context, Poll};

-use actix_utils::future;
-use actix_web::dev::{Service, ServiceRequest, ServiceResponse, Transform};
-use actix_web::http::header::{HeaderName, HeaderValue};
-use actix_web::{http, web::Path, App, Error, HttpResponse, Responder};
+use actix_utils::future::{ok, Ready};
+use actix_web::{
+    dev::{Service, ServiceRequest, ServiceResponse, Transform},
+    http::{
+        self,
+        header::{HeaderName, HeaderValue},
+        StatusCode,
+    },
+    web, App, Error, HttpResponse, Responder,
+};
 use actix_web_codegen::{connect, delete, get, head, options, patch, post, put, route, trace};
 use futures_core::future::LocalBoxFuture;

@ -56,26 +61,26 @@ async fn trace_test() -> impl Responder {

 #[get("/test")]
 fn auto_async() -> impl Future<Output = Result<HttpResponse, actix_web::Error>> {
-    future::ok(HttpResponse::Ok().finish())
+    ok(HttpResponse::Ok().finish())
 }

 #[get("/test")]
 fn auto_sync() -> impl Future<Output = Result<HttpResponse, actix_web::Error>> {
-    future::ok(HttpResponse::Ok().finish())
+    ok(HttpResponse::Ok().finish())
 }

 #[put("/test/{param}")]
-async fn put_param_test(_: Path<String>) -> impl Responder {
+async fn put_param_test(_: web::Path<String>) -> impl Responder {
    HttpResponse::Created()
 }

 #[delete("/test/{param}")]
-async fn delete_param_test(_: Path<String>) -> impl Responder {
+async fn delete_param_test(_: web::Path<String>) -> impl Responder {
    HttpResponse::NoContent()
 }

 #[get("/test/{param}")]
-async fn get_param_test(_: Path<String>) -> impl Responder {
+async fn get_param_test(_: web::Path<String>) -> impl Responder {
    HttpResponse::Ok()
 }

@ -103,10 +108,10 @@ where
    type Error = Error;
    type Transform = ChangeStatusCodeMiddleware<S>;
    type InitError = ();
-    type Future = future::Ready<Result<Self::Transform, Self::InitError>>;
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
-        future::ok(ChangeStatusCodeMiddleware { service })
+        ok(ChangeStatusCodeMiddleware { service })
    }
 }

@ -124,9 +129,7 @@ where
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

-    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.service.poll_ready(cx)
-    }
+    actix_web::dev::forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        let fut = self.service.call(req);
@ -143,7 +146,8 @@ where
 }

 #[get("/test/wrap", wrap = "ChangeStatusCode")]
-async fn get_wrap(_: Path<String>) -> impl Responder {
+async fn get_wrap(_: web::Path<String>) -> impl Responder {
+    // panic!("actually never gets called because path failed to extract");
    HttpResponse::Ok()
 }

@ -257,6 +261,10 @@ async fn test_wrap() {
    let srv = actix_test::start(|| App::new().service(get_wrap));

    let request = srv.request(http::Method::GET, srv.url("/test/wrap"));
-    let response = request.send().await.unwrap();
+    let mut response = request.send().await.unwrap();
+    assert_eq!(response.status(), StatusCode::NOT_FOUND);
    assert!(response.headers().contains_key("custom-header"));
+    let body = response.body().await.unwrap();
+    let body = String::from_utf8(body.to_vec()).unwrap();
+    assert!(body.contains("wrong number of parameters"));
 }
--- a/actix-web-codegen/tests/trybuild.rs
+++ b/actix-web-codegen/tests/trybuild.rs
@ -1,3 +1,4 @@
+#[rustversion::stable(1.46)] // MSRV
 #[test]
 fn compile_macros() {
    let t = trybuild::TestCases::new();
@ -12,11 +13,3 @@ fn compile_macros() {

    t.pass("tests/trybuild/docstring-ok.rs");
 }
-
-// #[rustversion::not(nightly)]
-// fn skip_on_nightly(t: &trybuild::TestCases) {
-//
-// }
-
-// #[rustversion::nightly]
-// fn skip_on_nightly(_t: &trybuild::TestCases) {}
--- a/awc/CHANGES.md
+++ b/awc/CHANGES.md
@ -3,6 +3,17 @@
 ## Unreleased - 2021-xx-xx


+## 3.0.0-beta.6 - 2021-06-17
+* No significant changes since 3.0.0-beta.5.
+
+
+## 3.0.0-beta.5 - 2021-04-17
+### Removed
+* Deprecated methods on `ClientRequest`: `if_true`, `if_some`. [#2148]
+
+[#2148]: https://github.com/actix/actix-web/pull/2148
+
+
 ## 3.0.0-beta.4 - 2021-04-02
 ### Added
 * Add `Client::headers` to get default mut reference of `HeaderMap` of client object. [#2114]
--- a/awc/Cargo.toml
+++ b/awc/Cargo.toml
@ -1,22 +1,20 @@
 [package]
 name = "awc"
-version = "3.0.0-beta.4"
+version = "3.0.0-beta.6"
 authors = [
    "Nikolay Kim <fafhrd91@gmail.com>",
    "fakeshadow <24548779@qq.com>",
 ]
 description = "Async HTTP and WebSocket client library built on the Actix ecosystem"
-readme = "README.md"
 keywords = ["actix", "http", "framework", "async", "web"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/awc/"
 categories = [
    "network-programming",
    "asynchronous",
    "web-programming::http-client",
    "web-programming::websocket",
 ]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-web"
 license = "MIT OR Apache-2.0"
 edition = "2018"

@ -41,19 +39,20 @@ rustls = ["tls-rustls", "actix-http/rustls"]
 compress = ["actix-http/compress"]

 # cookie parsing and cookie jar
-cookies = ["actix-http/cookies"]
+cookies = ["cookie"]

 # 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.5"
+actix-codec = "0.4.0"
+actix-service = "2.0.0"
+actix-http = "3.0.0-beta.7"
 actix-rt = { version = "2.1", default-features = false }

 base64 = "0.13"
 bytes = "1"
+cookie = { version = "0.15", features = ["percent-encode"], optional = true }
 derive_more = "0.99.5"
 futures-core = { version = "0.3.7", default-features = false }
 itoa = "0.4"
@ -69,13 +68,13 @@ tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
 tls-rustls = { version = "0.19.0", package = "rustls", optional = true, features = ["dangerous_configuration"] }

 [dev-dependencies]
-actix-web = { version = "4.0.0-beta.5", features = ["openssl"] }
-actix-http = { version = "3.0.0-beta.5", features = ["openssl"] }
-actix-http-test = { version = "3.0.0-beta.3", features = ["openssl"] }
-actix-utils = "3.0.0-beta.4"
+actix-web = { version = "4.0.0-beta.7", features = ["openssl"] }
+actix-http = { version = "3.0.0-beta.7", features = ["openssl"] }
+actix-http-test = { version = "3.0.0-beta.4", features = ["openssl"] }
+actix-utils = "3.0.0"
 actix-server = "2.0.0-beta.3"
 actix-tls = { version = "3.0.0-beta.5", features = ["openssl", "rustls"] }
-actix-test = { version = "0.0.1", features = ["openssl", "rustls"] }
+actix-test = { version = "0.1.0-beta.2", features = ["openssl", "rustls"] }

 brotli2 = "0.3.2"
 env_logger = "0.8"
--- a/awc/README.md
+++ b/awc/README.md
@ -3,9 +3,9 @@
 > Async HTTP and WebSocket client library.

 [![crates.io](https://img.shields.io/crates/v/awc?label=latest)](https://crates.io/crates/awc)
-[![Documentation](https://docs.rs/awc/badge.svg?version=3.0.0-beta.3)](https://docs.rs/awc/3.0.0-beta.3)
+[![Documentation](https://docs.rs/awc/badge.svg?version=3.0.0-beta.6)](https://docs.rs/awc/3.0.0-beta.6)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/awc)
-[![Dependency Status](https://deps.rs/crate/awc/3.0.0-beta.3/status.svg)](https://deps.rs/crate/awc/3.0.0-beta.3)
+[![Dependency Status](https://deps.rs/crate/awc/3.0.0-beta.6/status.svg)](https://deps.rs/crate/awc/3.0.0-beta.6)
 [![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
--- a/awc/examples/client.rs
+++ b/awc/examples/client.rs
@ -1,7 +1,7 @@
-use actix_http::Error;
+use std::error::Error as StdError;

 #[actix_web::main]
-async fn main() -> Result<(), Error> {
+async fn main() -> Result<(), Box<dyn StdError>> {
    std::env::set_var("RUST_LOG", "actix_http=trace");
    env_logger::init();

--- a/awc/src/error.rs
+++ b/awc/src/error.rs
@ -6,7 +6,6 @@ pub use actix_http::http::Error as HttpError;
 pub use actix_http::ws::HandshakeError as WsHandshakeError;
 pub use actix_http::ws::ProtocolError as WsProtocolError;

-use actix_http::ResponseError;
 use serde_json::error::Error as JsonError;

 use actix_http::http::{header::HeaderValue, StatusCode};
@ -77,6 +76,3 @@ pub enum JsonPayloadError {
 }

 impl std::error::Error for JsonPayloadError {}
-
-/// Return `InternalServerError` for `JsonPayloadError`
-impl ResponseError for JsonPayloadError {}
--- a/awc/src/frozen.rs
+++ b/awc/src/frozen.rs
@ -1,21 +1,21 @@
-use std::convert::TryFrom;
-use std::net;
-use std::rc::Rc;
-use std::time::Duration;
+use std::{convert::TryFrom, error::Error as StdError, net, rc::Rc, time::Duration};

 use bytes::Bytes;
 use futures_core::Stream;
 use serde::Serialize;

-use actix_http::body::Body;
-use actix_http::http::header::IntoHeaderValue;
-use actix_http::http::{Error as HttpError, HeaderMap, HeaderName, Method, Uri};
-use actix_http::{Error, RequestHead};
+use actix_http::{
+    body::Body,
+    http::{header::IntoHeaderValue, Error as HttpError, HeaderMap, HeaderName, Method, Uri},
+    RequestHead,
+};

-use crate::sender::{RequestSender, SendClientRequest};
-use crate::ClientConfig;
+use crate::{
+    sender::{RequestSender, SendClientRequest},
+    ClientConfig,
+};

-/// `FrozenClientRequest` struct represents clonable client request.
+/// `FrozenClientRequest` struct represents cloneable client request.
 /// It could be used to send same request multiple times.
 #[derive(Clone)]
 pub struct FrozenClientRequest {
@ -82,7 +82,7 @@ impl FrozenClientRequest {
    pub fn send_stream<S, E>(&self, stream: S) -> SendClientRequest
    where
        S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
    {
        RequestSender::Rc(self.head.clone(), None).send_stream(
            self.addr,
@ -207,7 +207,7 @@ impl FrozenSendBuilder {
    pub fn send_stream<S, E>(self, stream: S) -> SendClientRequest
    where
        S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
    {
        if let Some(e) = self.err {
            return e.into();
--- a/awc/src/lib.rs
+++ b/awc/src/lib.rs
@ -93,12 +93,11 @@
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]

-use std::convert::TryFrom;
-use std::rc::Rc;
-use std::time::Duration;
+use std::{convert::TryFrom, rc::Rc, time::Duration};

 #[cfg(feature = "cookies")]
-pub use actix_http::cookie;
+pub use cookie;
+
 pub use actix_http::{client::Connector, http};

 use actix_http::{
@ -129,8 +128,7 @@ pub use self::sender::SendClientRequest;

 /// An asynchronous HTTP and WebSocket client.
 ///
-/// ## Examples
-///
+/// # Examples
 /// ```
 /// use awc::Client;
 ///
--- a/awc/src/request.rs
+++ b/awc/src/request.rs
@ -1,25 +1,26 @@
-use std::convert::TryFrom;
-use std::rc::Rc;
-use std::time::Duration;
-use std::{fmt, net};
+use std::{convert::TryFrom, error::Error as StdError, fmt, net, rc::Rc, time::Duration};

 use bytes::Bytes;
 use futures_core::Stream;
 use serde::Serialize;

-use actix_http::body::Body;
-#[cfg(feature = "cookies")]
-use actix_http::cookie::{Cookie, CookieJar};
-use actix_http::http::header::{self, IntoHeaderPair};
-use actix_http::http::{
-    uri, ConnectionType, Error as HttpError, HeaderMap, HeaderValue, Method, Uri, Version,
+use actix_http::{
+    body::Body,
+    http::{
+        header::{self, IntoHeaderPair},
+        uri, ConnectionType, Error as HttpError, HeaderMap, HeaderValue, Method, Uri, Version,
+    },
+    RequestHead,
 };
-use actix_http::{Error, RequestHead};

-use crate::error::{FreezeRequestError, InvalidUrl};
-use crate::frozen::FrozenClientRequest;
-use crate::sender::{PrepForSendingError, RequestSender, SendClientRequest};
-use crate::ClientConfig;
+#[cfg(feature = "cookies")]
+use crate::cookie::{Cookie, CookieJar};
+use crate::{
+    error::{FreezeRequestError, InvalidUrl},
+    frozen::FrozenClientRequest,
+    sender::{PrepForSendingError, RequestSender, SendClientRequest},
+    ClientConfig,
+};

 #[cfg(feature = "compress")]
 const HTTPS_ENCODING: &str = "br, gzip, deflate";
@ -271,7 +272,7 @@ impl ClientRequest {
    /// async fn main() {
    ///     let resp = awc::Client::new().get("https://www.rust-lang.org")
    ///         .cookie(
-    ///             awc::http::Cookie::build("name", "value")
+    ///             awc::cookie::Cookie::build("name", "value")
    ///                 .domain("www.rust-lang.org")
    ///                 .path("/")
    ///                 .secure(true)
@ -311,34 +312,6 @@ impl ClientRequest {
        self
    }

-    /// This method calls provided closure with builder reference if value is `true`.
-    #[doc(hidden)]
-    #[deprecated = "Use an if statement."]
-    pub fn if_true<F>(self, value: bool, f: F) -> Self
-    where
-        F: FnOnce(ClientRequest) -> ClientRequest,
-    {
-        if value {
-            f(self)
-        } else {
-            self
-        }
-    }
-
-    /// This method calls provided closure with builder reference if value is `Some`.
-    #[doc(hidden)]
-    #[deprecated = "Use an if-let construction."]
-    pub fn if_some<T, F>(self, value: Option<T>, f: F) -> Self
-    where
-        F: FnOnce(T, ClientRequest) -> ClientRequest,
-    {
-        if let Some(val) = value {
-            f(val, self)
-        } else {
-            self
-        }
-    }
-
    /// Sets the query part of the request
    pub fn query<T: Serialize>(
        mut self,
@ -436,7 +409,7 @@ impl ClientRequest {
    pub fn send_stream<S, E>(self, stream: S) -> SendClientRequest
    where
        S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
    {
        let slf = match self.prep_for_sending() {
            Ok(slf) => slf,
@ -494,7 +467,7 @@ impl ClientRequest {
            let cookie: String = jar
                .delta()
                // ensure only name=value is written to cookie header
-                .map(|c| Cookie::new(c.name(), c.value()).encoded().to_string())
+                .map(|c| c.stripped().encoded().to_string())
                .collect::<Vec<_>>()
                .join("; ");

--- a/awc/src/response.rs
+++ b/awc/src/response.rs
@ -20,8 +20,7 @@ use futures_core::{ready, Stream};
 use serde::de::DeserializeOwned;

 #[cfg(feature = "cookies")]
-use actix_http::{cookie::Cookie, error::CookieParseError};
-
+use crate::cookie::{Cookie, ParseError as CookieParseError};
 use crate::error::JsonPayloadError;

 /// Client Response
@ -80,24 +79,6 @@ impl<S> HttpMessage for ClientResponse<S> {
    fn extensions_mut(&self) -> RefMut<'_, Extensions> {
        self.head.extensions_mut()
    }
-
-    /// Load request cookies.
-    #[cfg(feature = "cookies")]
-    fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, CookieParseError> {
-        struct Cookies(Vec<Cookie<'static>>);
-
-        if self.extensions().get::<Cookies>().is_none() {
-            let mut cookies = Vec::new();
-            for hdr in self.headers().get_all(&header::SET_COOKIE) {
-                let s = std::str::from_utf8(hdr.as_bytes()).map_err(CookieParseError::from)?;
-                cookies.push(Cookie::parse_encoded(s)?.into_owned());
-            }
-            self.extensions_mut().insert(Cookies(cookies));
-        }
-        Ok(Ref::map(self.extensions(), |ext| {
-            &ext.get::<Cookies>().unwrap().0
-        }))
-    }
 }

 impl<S> ClientResponse<S> {
@ -180,6 +161,37 @@ impl<S> ClientResponse<S> {
        self.timeout = ResponseTimeout::Disabled(timeout);
        self
    }
+
+    /// Load request cookies.
+    #[cfg(feature = "cookies")]
+    pub fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, CookieParseError> {
+        struct Cookies(Vec<Cookie<'static>>);
+
+        if self.extensions().get::<Cookies>().is_none() {
+            let mut cookies = Vec::new();
+            for hdr in self.headers().get_all(&header::SET_COOKIE) {
+                let s = std::str::from_utf8(hdr.as_bytes()).map_err(CookieParseError::from)?;
+                cookies.push(Cookie::parse_encoded(s)?.into_owned());
+            }
+            self.extensions_mut().insert(Cookies(cookies));
+        }
+        Ok(Ref::map(self.extensions(), |ext| {
+            &ext.get::<Cookies>().unwrap().0
+        }))
+    }
+
+    /// Return request cookie.
+    #[cfg(feature = "cookies")]
+    pub fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
+        if let Ok(cookies) = self.cookies() {
+            for cookie in cookies.iter() {
+                if cookie.name() == name {
+                    return Some(cookie.to_owned());
+                }
+            }
+        }
+        None
+    }
 }

 impl<S> ClientResponse<S>
--- a/awc/src/sender.rs
+++ b/awc/src/sender.rs
@ -1,4 +1,5 @@
 use std::{
+    error::Error as StdError,
    future::Future,
    net,
    pin::Pin,
@ -24,22 +25,30 @@ use serde::Serialize;
 #[cfg(feature = "compress")]
 use actix_http::{encoding::Decoder, http::header::ContentEncoding, Payload, PayloadStream};

-use crate::connect::{ConnectRequest, ConnectResponse};
-use crate::error::{FreezeRequestError, InvalidUrl, SendRequestError};
-use crate::response::ClientResponse;
-use crate::ClientConfig;
+use crate::{
+    error::{FreezeRequestError, InvalidUrl, SendRequestError},
+    ClientConfig, ClientResponse, ConnectRequest, ConnectResponse,
+};

 #[derive(Debug, From)]
 pub(crate) enum PrepForSendingError {
    Url(InvalidUrl),
    Http(HttpError),
+    Json(serde_json::Error),
+    Form(serde_urlencoded::ser::Error),
 }

 impl From<PrepForSendingError> for FreezeRequestError {
    fn from(err: PrepForSendingError) -> FreezeRequestError {
        match err {
-            PrepForSendingError::Url(e) => FreezeRequestError::Url(e),
-            PrepForSendingError::Http(e) => FreezeRequestError::Http(e),
+            PrepForSendingError::Url(err) => FreezeRequestError::Url(err),
+            PrepForSendingError::Http(err) => FreezeRequestError::Http(err),
+            PrepForSendingError::Json(err) => {
+                FreezeRequestError::Custom(Box::new(err), Box::new("json serialization error"))
+            }
+            PrepForSendingError::Form(err) => {
+                FreezeRequestError::Custom(Box::new(err), Box::new("form serialization error"))
+            }
        }
    }
 }
@ -49,6 +58,12 @@ impl From<PrepForSendingError> for SendRequestError {
        match err {
            PrepForSendingError::Url(e) => SendRequestError::Url(e),
            PrepForSendingError::Http(e) => SendRequestError::Http(e),
+            PrepForSendingError::Json(err) => {
+                SendRequestError::Custom(Box::new(err), Box::new("json serialization error"))
+            }
+            PrepForSendingError::Form(err) => {
+                SendRequestError::Custom(Box::new(err), Box::new("form serialization error"))
+            }
        }
    }
 }
@ -209,7 +224,7 @@ impl RequestSender {
    ) -> SendClientRequest {
        let body = match serde_json::to_string(value) {
            Ok(body) => body,
-            Err(e) => return Error::from(e).into(),
+            Err(err) => return PrepForSendingError::Json(err).into(),
        };

        if let Err(e) = self.set_header_if_none(header::CONTENT_TYPE, "application/json") {
@ -235,7 +250,7 @@ impl RequestSender {
    ) -> SendClientRequest {
        let body = match serde_urlencoded::to_string(value) {
            Ok(body) => body,
-            Err(e) => return Error::from(e).into(),
+            Err(err) => return PrepForSendingError::Form(err).into(),
        };

        // set content-type
@ -264,7 +279,7 @@ impl RequestSender {
    ) -> SendClientRequest
    where
        S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
-        E: Into<Error> + 'static,
+        E: Into<Box<dyn StdError>> + 'static,
    {
        self.send_body(
            addr,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Rob Ede	c260fb1c48	beta.7 releases (#2266 )	2021-06-19 11:51:20 +01:00
Rob Ede	532f7b9923	refined error model (#2253 )	2021-06-17 17:57:58 +01:00
Rob Ede	bb0331ae28	fix cargo cache on msrv	2021-06-17 16:49:31 +01:00
Ali MJ Al-Nasrawy	8d124713fc	files: inline disposition for common web app file types (#2257 )	2021-06-16 20:33:22 +01:00
peter-formlogic	fb2b362b60	Adjust JSON limit to 2MB and report on sizes (#2162 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2021-06-16 15:52:49 +01:00
Victor Pirat	75f65fea4f	Extends Rustls ALPN protocols instead of replacing them when creating Rustls based services (#2226 )	2021-06-10 16:25:21 +01:00
Ali MJ Al-Nasrawy	812269d656	clarify docs for BodyEncoding::encoding() (#2258 )	2021-06-10 15:38:35 +01:00
Ibraheem Ahmed	e46cda5228	Deduplicate rt::main macro logic (#2255 )	2021-06-08 22:44:56 +01:00
Ibraheem Ahmed	2e1d761854	add Seal argument to sealed AsHeaderName methods (#2252 )	2021-06-08 12:57:19 +01:00
Thales	b1e841f168	Don't normalize URIs with no valid path (#2246 )	2021-06-05 17:19:45 +01:00
Yerkebulan Tulibergenov	0bb035cfa7	Add information about Actix discord server (#2247 )	2021-06-04 02:54:40 +01:00
Arthur Le Moigne	3479293416	Add zstd ContentEncoding support (#2244 ) Co-authored-by: Igor Aleksanov <popzxc@yandex.ru> Co-authored-by: Rob Ede <robjtede@icloud.com>	2021-06-03 21:32:52 +01:00
James Wright	136dac1352	Additional test coverage and tidyup (middleware::normalize) (#2243 )	2021-06-03 03:28:09 +01:00
Ali MJ Al-Nasrawy	e5b713b04a	files: Fix `redirect_to_slash_directory()` when used with `show_files_listing()` (#2225 )	2021-05-26 10:42:29 +01:00
fakeshadow	3847429d00	Response::from_error take impl Into<Error> (#2214 )	2021-05-26 13:41:48 +09:00
fakeshadow	bb7d33c9d4	refactor h2 dispatcher to async/await.reduce duplicate code (#2211 )	2021-05-25 03:21:20 +01:00
Yuki Okushi	4598a7c0cc	Only run UI tests on MSRV (#2232 )	2021-05-25 00:09:38 +09:00
Keita Nonaka	b1de196509	Fix clippy warnings (#2217 )	2021-05-15 01:13:33 +01:00
Rob Ede	2a8c650f2c	move internalerror to actix web (#2215 )	2021-05-14 16:40:00 +01:00
fakeshadow	f277b128b6	cleanup ws test (#2213 )	2021-05-13 12:24:32 +01:00
Rob Ede	4903950b22	update changelog	2021-05-09 20:15:49 +01:00
Rob Ede	f55e8d7a11	remove error field from response	2021-05-09 20:15:48 +01:00
Rob Ede	900c9e270e	remove responsebody indirection from response (#2201 )	2021-05-09 20:12:48 +01:00
Rob Ede	a9dc1586a0	remove rogue eprintln	2021-05-07 10:14:25 +01:00
Rob Ede	947caa3599	examples use info log level by default	2021-05-06 20:24:18 +01:00
fakeshadow	7d1d5c8acd	Expose SererBuilder::worker_max_blocking_threads (#2200 )	2021-05-06 18:35:04 +01:00
Rob Ede	ddaf8c3e43	add associated error type to MessageBody (#2183 )	2021-05-05 18:36:02 +01:00
Aaron Hill	dd1a3e7675	Fix loophole in soundness of `__private_get_type_id__` (#2199 )	2021-05-05 11:16:12 +01:00
Luca Palmieri	c17662fe39	Reduce the level of the emitted log line from `error` to `debug`. (#2196 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2021-05-03 00:58:14 +01:00
Ibraheem Ahmed	3a0fb3f89e	Static either extract future (#2184 )	2021-05-01 03:02:56 +01:00
Voldracarno Draconor	1fcf92e11f	Update dependency "language-tags" (#2188 )	2021-04-28 01:23:12 +01:00
Rob Ede	6a29a50f25	files doc wording	2021-04-22 18:37:45 +01:00
Rob Ede	75867bd073	clean up files service docs and rename method follow on from #2046	2021-04-22 18:31:21 +01:00
tglman	f44a0bc159	add support of filtering guards in Files of actix-files (#2046 ) Co-authored-by: Rob Ede <robjtede@icloud.com>	2021-04-22 18:13:13 +01:00
Ibraheem Ahmed	07036b5640	static form extract future (#2181 )	2021-04-22 13:54:29 +01:00
Rob Ede	a7cd4e85cf	use stable codec 0.4.0	2021-04-21 11:14:22 +01:00
Ibraheem Ahmed	6a9c4f1026	update awc docs link, formatting (#2180 )	2021-04-20 19:57:27 +01:00
Rob Ede	427fe6bd82	improve responseerror trait docs	2021-04-19 23:16:04 +01:00
fakeshadow	2aa674c1fd	Fix perf drop in HttpResponseBuilder (#2174 )	2021-04-19 23:15:57 +01:00
Rob Ede	52bb2b5daf	hide downcast macros	2021-04-19 03:42:53 +01:00
Rob Ede	db97974dc1	make some http re-exports more accessible (#2171 )	2021-04-19 03:29:38 +01:00
Rob Ede	b9dbc58e20	content disposition methods take impl AsRef<str>	2021-04-19 02:31:11 +01:00
Rob Ede	35f8188410	restore cookie methods on ServiceRequest	2021-04-19 02:24:20 +01:00
Rob Ede	8ffb1f2011	update files changelog	2021-04-19 02:11:07 +01:00
Ibraheem Ahmed	26e9c80626	Named file service (#2135 )	2021-04-18 23:34:51 +01:00
Rob Ede	f462aaa7b6	prepare actix-test release 0.1.0-beta.2	2021-04-17 15:53:54 +01:00
Rob Ede	5a162932f3	prepare awc release 3.0.0-beta.5	2021-04-17 15:30:31 +01:00
Rob Ede	b2d6b6a70c	prepare web release 4.0.0-beta.6	2021-04-17 15:28:13 +01:00
Rob Ede	f743e885a3	prepare http release 3.0.0-beta.6	2021-04-17 15:24:18 +01:00
Rob Ede	5747f84736	bump utils to stable v3	2021-04-17 02:07:33 +01:00
Rob Ede	879a4cbcd8	re-export ready boilerplate macros in dev	2021-04-16 23:21:02 +01:00
Rob Ede	2449f2555c	missed one pipeline_factory	2021-04-16 20:48:37 +01:00
Rob Ede	d8f56eee3e	bump service to stable v2	2021-04-16 20:28:21 +01:00
Rob Ede	8d88a0a9af	rename header generator macros	2021-04-16 19:15:10 +01:00
fakeshadow	845c02cb86	Add responder impl for Cow<str> (#2164 )	2021-04-16 00:54:51 +01:00
D.Loh	64bed506c2	chore: update benchmaks to round 20 (#2163 )	2021-04-15 19:11:30 +01:00
Rob Ede	ff65f1d006	non exhaustive http errors (#2161 )	2021-04-14 06:07:59 +01:00
fakeshadow	a9f26286f9	reduce branches in h1 dispatcher poll_keepalive (#2089 )	2021-04-14 05:20:45 +01:00
Rob Ede	037ac80a32	document messagebody trait items	2021-04-14 03:23:15 +01:00
Rob Ede	1bfdfd1f41	implement parts as assoc method	2021-04-14 02:57:28 +01:00
Rob Ede	5202bf03c1	add some doc examples to response builder	2021-04-14 02:45:58 +01:00
Rob Ede	387c229f28	move response builder code to own file	2021-04-14 02:12:47 +01:00
Rob Ede	23e0c9b6e0	remove http-codes builders from actix-http (#2159 )	2021-04-14 02:00:14 +01:00
Rob Ede	02ced426fd	add body to_bytes helper (#2158 )	2021-04-13 13:34:22 +01:00
Rob Ede	4442535a45	clippy	2021-04-13 12:44:38 +01:00
Rob Ede	edd9f14752	remove unpin from body types (#2152 )	2021-04-13 11:16:12 +01:00
Ali MJ Al-Nasrawy	ce50cc9523	files: Don't use canonical path when serving file (#2156 )	2021-04-13 05:28:30 +01:00
Rob Ede	981c54432c	remove json and url encoded form support from -http (#2148 )	2021-04-12 10:30:28 +01:00
Rob Ede	44c55dd036	remove cookie support from -http (#2065 )	2021-04-09 18:07:10 +01:00
Ibraheem Ahmed	c72d77065d	derive debug where possible (#2142 )	2021-04-09 03:22:51 +01:00
Ibraheem Ahmed	44a2d2214c	update year in MIT license (#2143 )	2021-04-09 01:28:35 +01:00
Ibraheem Ahmed	3f5a73793a	make module/crate re-exports doc inline (#2141 )	2021-04-08 20:51:16 +01:00
Rob Ede	e0b2246c68	prepare test release 0.1.0-beta.1	2021-04-02 10:03:01 +01:00
Rob Ede	e0ae8e59bf	prepare actors release 4.0.0-beta.4	2021-04-02 09:55:35 +01:00
Rob Ede	a9641e475a	prepare http-test release 3.0.0-beta.4	2021-04-02 09:54:35 +01:00
Rob Ede	05c7505563	prepare multipart release 0.4.0-beta.4	2021-04-02 09:45:31 +01:00
Rob Ede	8561263545	prepare files release 0.6.0-beta.4	2021-04-02 09:43:51 +01:00