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

replace typo `scoupe` with `scope`

.appveyor.yml

@@ -4,13 +4,13 @@ environment:
   matrix:
     # Stable channel
     - TARGET: i686-pc-windows-gnu
-      CHANNEL: 1.20.0
+      CHANNEL: 1.24.0
     - TARGET: i686-pc-windows-msvc
-      CHANNEL: 1.20.0
+      CHANNEL: 1.24.0
     - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: 1.20.0
+      CHANNEL: 1.24.0
     - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: 1.20.0
+      CHANNEL: 1.24.0
     # Stable channel
     - TARGET: i686-pc-windows-gnu
       CHANNEL: stable
@@ -59,6 +59,4 @@ build: false
 
 # Equivalent to Travis' `script` phase
 test_script:
-  - cargo build --no-default-features
-  - cargo clean
-  - cargo test --no-default-features
+  - cargo test --no-default-features --features="flate2-rust"

.travis.yml

@@ -8,23 +8,16 @@ cache:
 
 matrix:
   include:
-    - rust: 1.20.0
+    - rust: 1.24.0
     - rust: stable
     - rust: beta
     - rust: nightly
   allow_failures:
     - rust: nightly
-    - rust: beta
-
-#rust:
-#  - 1.20.0
-#  - stable
-#  - beta
-#  - nightly-2018-01-03
 
 env:
   global:
-    - RUSTFLAGS="-C link-dead-code"
+    # - RUSTFLAGS="-C link-dead-code"
     - OPENSSL_VERSION=openssl-1.0.2
 
 before_install:
@@ -34,57 +27,29 @@ before_install:
 
 # Add clippy
 before_script:
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
-        ( ( cargo install clippy && export CLIPPY=true ) || export CLIPPY=false );
-    fi
   - export PATH=$PATH:~/.cargo/bin
 
 script:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" == "stable" ]]; then
-       cargo clean
-       USE_SKEPTIC=1 cargo test --features=alpn
-    else
-       cargo clean
-       cargo test
-       # --features=alpn
-    fi
-
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" == "1.20.0" ]]; then
-      cd examples/basics && cargo check && cd ../..
-      cd examples/hello-world && cargo check && cd ../..
-      cd examples/multipart && cargo check && cd ../..
-      cd examples/json && cargo check && cd ../..
-      cd examples/template_tera && cargo check && cd ../..
-      cd examples/diesel && cargo check && cd ../..
-      cd examples/tls && cargo check && cd ../..
-      cd examples/websocket-chat && cargo check && cd ../..
-      cd examples/websocket && cargo check && cd ../..
+    if [[ "$TRAVIS_RUST_VERSION" != "beta" ]]; then
+    cargo clean
+    cargo test --features="alpn,tls" -- --nocapture
     fi
   - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly" && $CLIPPY ]]; then
-        cargo clippy
+    if [[ "$TRAVIS_RUST_VERSION" == "beta" ]]; then
+    bash <(curl https://raw.githubusercontent.com/xd009642/tarpaulin/master/travis-install.sh)
+    USE_SKEPTIC=1 cargo tarpaulin --out Xml
+    bash <(curl -s https://codecov.io/bash)
+    echo "Uploaded code coverage"
     fi
 
 # Upload docs
 after_success:
   - |
-    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "1.20.0" ]]; then
-      cargo doc --features alpn --no-deps &&
+    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "stable" ]]; then
+      cargo doc --features "alpn, tls, session" --no-deps &&
       echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html &&
-      cargo install mdbook &&
-      cd guide && mdbook build -d ../target/doc/guide && cd .. &&
       git clone https://github.com/davisp/ghp-import.git &&
       ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://"$GH_TOKEN"@github.com/"$TRAVIS_REPO_SLUG.git" target/doc &&
       echo "Uploaded documentation"
     fi
-
-  - |
-    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_RUST_VERSION" == "stable" ]]; then
-      bash <(curl https://raw.githubusercontent.com/xd009642/tarpaulin/master/travis-install.sh)
-      USE_SKEPTIC=1 cargo tarpaulin --out Xml
-      bash <(curl -s https://codecov.io/bash)
-      echo "Uploaded code coverage"
-    fi

CHANGES.md

@@ -1,5 +1,265 @@
 # Changes
 
+## 0.6.1 (2018-05-08)
+
+* Fix http/2 payload streaming #215
+
+* Fix connector's default `keep-alive` and `lifetime` settings #212
+
+* Send `ErrorNotFound` instead of `ErrorBadRequest` when path extractor fails #214
+
+* Allow to exclude certain endpoints from logging #211
+
+
+## 0.6.0 (2018-05-08)
+
+* Add route scopes #202
+
+* Allow to use ssl and non-ssl connections at the same time #206
+
+* Websocket CloseCode Empty/Status is ambiguous #193
+
+* Add Content-Disposition to NamedFile #204
+
+* Allow to access Error's backtrace object
+
+* Allow to override files listing renderer for `StaticFiles` #203
+
+* Various extractor usability improvements #207
+
+
+## 0.5.6 (2018-04-24)
+
+* Make flate2 crate optional #200
+
+
+## 0.5.5 (2018-04-24)
+
+* Fix panic when Websocket is closed with no error code #191
+
+* Allow to use rust backend for flate2 crate #199
+
+## 0.5.4 (2018-04-19)
+
+* Add identity service middleware
+
+* Middleware response() is not invoked if there was an error in async handler #187
+
+* Use Display formatting for InternalError Display implementation #188
+
+
+## 0.5.3 (2018-04-18)
+
+* Impossible to quote slashes in path parameters #182
+
+
+## 0.5.2 (2018-04-16)
+
+* Allow to configure StaticFiles's CpuPool, via static method or env variable
+
+* Add support for custom handling of Json extractor errors #181
+
+* Fix StaticFiles does not support percent encoded paths #177
+
+* Fix Client Request with custom Body Stream halting on certain size requests #176
+
+
+## 0.5.1 (2018-04-12)
+
+* Client connector provides stats, `ClientConnector::stats()`
+
+* Fix end-of-stream handling in parse_payload #173
+
+* Fix StaticFiles generate a lot of threads #174
+
+
+## 0.5.0 (2018-04-10)
+
+* Type-safe path/query/form parameter handling, using serde #70
+
+* HttpResponse builder's methods  `.body()`, `.finish()`, `.json()`
+  return `HttpResponse` instead of `Result`
+
+* Use more ergonomic `actix_web::Error` instead of `http::Error` for `ClientRequestBuilder::body()`
+
+* Added `signed` and `private` `CookieSessionBackend`s
+
+* Added `HttpRequest::resource()`, returns current matched resource
+
+* Added `ErrorHandlers` middleware
+
+* Fix router cannot parse Non-ASCII characters in URL #137
+
+* Fix client connection pooling
+
+* Fix long client urls #129
+
+* Fix panic on invalid URL characters #130
+
+* Fix logger request duration calculation #152
+
+* Fix prefix and static file serving #168
+
+
+## 0.4.10 (2018-03-20)
+
+* Use `Error` instead of `InternalError` for `error::ErrorXXXX` methods
+
+* Allow to set client request timeout
+
+* Allow to set client websocket handshake timeout
+
+* Refactor `TestServer` configuration
+
+* Fix server websockets big payloads support
+
+* Fix http/2 date header generation
+
+
+## 0.4.9 (2018-03-16)
+
+* Allow to disable http/2 support
+
+* Wake payload reading task when data is available
+
+* Fix server keep-alive handling
+
+* Send Query Parameters in client requests #120
+
+* Move brotli encoding to a feature
+
+* Add option of default handler for `StaticFiles` handler #57
+
+* Add basic client connection pooling
+
+
+## 0.4.8 (2018-03-12)
+
+* Allow to set read buffer capacity for server request
+
+* Handle WouldBlock error for socket accept call
+
+
+## 0.4.7 (2018-03-11)
+
+* Fix panic on unknown content encoding
+
+* Fix connection get closed too early
+
+* Fix streaming response handling for http/2
+
+* Better sleep on error support
+
+
+## 0.4.6 (2018-03-10)
+
+* Fix client cookie handling
+
+* Fix json content type detection
+
+* Fix CORS middleware #117
+
+* Optimize websockets stream support
+
+
+## 0.4.5 (2018-03-07)
+
+* Fix compression #103 and #104
+
+* Fix client cookie handling #111
+
+* Non-blocking processing of a `NamedFile`
+
+* Enable compression support for `NamedFile`
+
+* Better support for `NamedFile` type
+
+* Add `ResponseError` impl for `SendRequestError`. This improves ergonomics of the client.
+
+* Add native-tls support for client
+
+* Allow client connection timeout to be set #108
+
+* Allow to use std::net::TcpListener for HttpServer
+
+* Handle panics in worker threads
+
+
+## 0.4.4 (2018-03-04)
+
+* Allow to use Arc<Vec<u8>> as response/request body
+
+* Fix handling of requests with an encoded body with a length > 8192 #93
+
+## 0.4.3 (2018-03-03)
+
+* Fix request body read bug
+
+* Fix segmentation fault #79
+
+* Set reuse address before bind #90
+
+
+## 0.4.2 (2018-03-02)
+
+* Better naming for websockets implementation
+
+* Add `Pattern::with_prefix()`, make it more usable outside of actix
+
+* Add csrf middleware for filter for cross-site request forgery #89
+
+* Fix disconnect on idle connections
+
+
+## 0.4.1 (2018-03-01)
+
+* Rename `Route::p()` to `Route::filter()`
+
+* Better naming for http codes
+
+* Fix payload parse in situation when socket data is not ready.
+
+* Fix Session mutable borrow lifetime #87
+
+
+## 0.4.0 (2018-02-28)
+
+* Actix 0.5 compatibility
+
+* Fix request json/urlencoded loaders
+
+* Simplify HttpServer type definition
+
+* Added HttpRequest::encoding() method
+
+* Added HttpRequest::mime_type() method
+
+* Added HttpRequest::uri_mut(), allows to modify request uri
+
+* Added StaticFiles::index_file()
+
+* Added http client
+
+* Added websocket client
+
+* Added TestServer::ws(), test websockets client
+
+* Added TestServer http client support
+
+* Allow to override content encoding on application level
+
+
+## 0.3.3 (2018-01-25)
+
+* Stop processing any events after context stop
+
+* Re-enable write back-pressure for h1 connections
+
+* Refactor HttpServer::start_ssl() method
+
+* Upgrade openssl to 0.10
+
+
 ## 0.3.2 (2018-01-21)
 
 * Fix HEAD requests handling

CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at fafhrd91@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

Cargo.toml

@@ -1,18 +1,19 @@
 [package]
 name = "actix-web"
-version = "0.3.2"
+version = "0.6.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix web framework"
+description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
 keywords = ["http", "web", "framework", "async", "futures"]
 homepage = "https://github.com/actix/actix-web"
 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"]
+              "web-programming::http-server",
+              "web-programming::http-client",
+              "web-programming::websocket"]
 license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config",
-           "appveyor.yml", "/examples/**"]
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 build = "build.rs"
 
 [badges]
@@ -25,44 +26,66 @@ name = "actix_web"
 path = "src/lib.rs"
 
 [features]
-default = []
+default = ["session", "brotli", "flate2-c"]
 
 # tls
 tls = ["native-tls", "tokio-tls"]
 
 # openssl
-alpn = ["openssl", "openssl/v102", "openssl/v110", "tokio-openssl"]
+alpn = ["openssl", "tokio-openssl"]
+
+# sessions feature, session require "ring" crate and c compiler
+session = ["cookie/secure"]
+
+# brotli encoding, requires c compiler
+brotli = ["brotli2"]
+
+# miniz-sys backend for flate2 crate
+flate2-c = ["flate2/miniz-sys"]
+
+# rust backend for flate2 crate
+flate2-rust = ["flate2/rust_backend"]
 
 [dependencies]
-log = "0.4"
-failure = "0.1"
-failure_derive = "0.1"
+actix = "^0.5.5"
+
+base64 = "0.9"
+bitflags = "1.0"
+failure = "0.1.1"
 h2 = "0.1"
-http = "^0.1.2"
+http = "^0.1.5"
 httparse = "1.2"
 http-range = "0.1"
-time = "0.1"
-mime = "0.3"
-mime_guess = "1.8"
-regex = "0.2"
-sha1 = "0.4"
-url = "1.6"
 libc = "0.2"
+log = "0.4"
+mime = "0.3"
+mime_guess = "2.0.0-alpha"
+num_cpus = "1.0"
+percent-encoding = "1.0"
+rand = "0.4"
+regex = "1.0"
 serde = "1.0"
 serde_json = "1.0"
-brotli2 = "^0.3.2"
-percent-encoding = "1.0"
+serde_urlencoded = "0.5"
+sha1 = "0.6"
 smallvec = "0.6"
-bitflags = "1.0"
-num_cpus = "1.0"
-flate2 = "1.0"
-cookie = { version="0.10", features=["percent-encode", "secure"] }
+time = "0.1"
+encoding = "0.2"
+language-tags = "0.2"
+lazy_static = "1.0"
+url = { version="1.7", features=["query_encoding"] }
+cookie = { version="0.10", features=["percent-encode"] }
+brotli2 = { version="^0.3.2", optional = true }
+flate2 = { version="1.0", optional = true, default-features = false }
 
 # io
-mio = "0.6"
+mio = "^0.6.13"
 net2 = "0.2"
 bytes = "0.4"
+byteorder = "1"
 futures = "0.1"
+futures-cpupool = "0.1"
+slab = "0.4"
 tokio-io = "0.1"
 tokio-core = "0.1"
 
@@ -71,41 +94,23 @@ native-tls = { version="0.1", optional = true }
 tokio-tls = { version="0.1", optional = true }
 
 # openssl
-tokio-openssl = { version="0.1", optional = true }
-
-[dependencies.actix]
-version = "^0.4.2"
-
-[dependencies.openssl]
-version = "0.9"
-optional = true
+openssl = { version="0.10", optional = true }
+tokio-openssl = { version="0.2", optional = true }
 
 [dev-dependencies]
 env_logger = "0.5"
-reqwest = "0.8"
-skeptic = "0.13"
 serde_derive = "1.0"
 
 [build-dependencies]
-skeptic = "0.13"
 version_check = "0.1"
 
 [profile.release]
 lto = true
 opt-level = 3
-# debug = true
+codegen-units = 1
 
 [workspace]
 members = [
   "./",
-  "examples/basics",
-  "examples/diesel",
-  "examples/json",
-  "examples/hello-world",
-  "examples/multipart",
-  "examples/state",
-  "examples/template_tera",
-  "examples/tls",
-  "examples/websocket",
-  "examples/websocket-chat",
+  "tools/wsload/",
 ]

LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2017 Nikilay Kim
+Copyright (c) 2017 Nikolay Kim
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

MIGRATION.md

@@ -0,0 +1,80 @@
+## Migration from 0.5 to 0.6
+
+* `ws::Message::Close` now includes optional close reason.
+  `ws::CloseCode::Status` and `ws::CloseCode::Empty` have been removed.
+
+* `HttpServer::threads()` renamed to `HttpServer::workers()`.
+
+* `HttpServer::start_ssl()` and `HttpServer::start_tls()` deprecated.
+  Use `HttpServer::bind_ssl()` and `HttpServer::bind_tls()` instead.
+
+* `HttpRequest::extensions()` returns read only reference to the request's Extension
+  `HttpRequest::extensions_mut()` returns mutable reference.
+
+* Instead of 
+
+   `use actix_web::middleware::{
+        CookieSessionBackend, CookieSessionError, RequestSession,
+        Session, SessionBackend, SessionImpl, SessionStorage};`
+                                
+  use `actix_web::middleware::session`
+
+   `use actix_web::middleware::session{CookieSessionBackend, CookieSessionError,
+        RequestSession, Session, SessionBackend, SessionImpl, SessionStorage};`
+
+* `FromRequest::from_request()` accepts mutable reference to a request
+
+* `FromRequest::Result` has to implement `Into<Reply<Self>>`
+
+* [`Responder::respond_to()`](
+  https://actix.rs/actix-web/actix_web/trait.Responder.html#tymethod.respond_to)
+  is generic over `S`
+
+* `HttpRequest::query()` is deprecated. Use `Query` extractor.
+
+   ```rust
+   fn index(q: Query<HashMap<String, String>>) -> Result<..> {
+       ...
+   }
+   ```
+
+   or
+
+   ```rust
+   let q = Query::<HashMap<String, String>>::extract(req);
+   ```
+
+* Websocket operations are implemented as `WsWriter` trait.
+  you need to use `use actix_web::ws::WsWriter`
+
+
+## Migration from 0.4 to 0.5
+
+* `HttpResponseBuilder::body()`, `.finish()`, `.json()`
+   methods return `HttpResponse` instead of `Result<HttpResponse>`
+
+* `actix_web::Method`, `actix_web::StatusCode`, `actix_web::Version`
+   moved to `actix_web::http` module
+
+* `actix_web::header` moved to `actix_web::http::header`
+
+* `NormalizePath` moved to `actix_web::http` module
+
+* `HttpServer` moved to `actix_web::server`, added new `actix_web::server::new()` function,
+  shortcut for `actix_web::server::HttpServer::new()`
+
+* `DefaultHeaders` middleware does not use separate builder, all builder methods moved to type itself
+
+* `StaticFiles::new()`'s show_index parameter removed, use `show_files_listing()` method instead.
+
+* `CookieSessionBackendBuilder` removed, all methods moved to `CookieSessionBackend` type
+
+* `actix_web::httpcodes` module is deprecated, `HttpResponse::Ok()`, `HttpResponse::Found()` and other `HttpResponse::XXX()`
+   functions should be used instead
+
+* `ClientRequestBuilder::body()` returns `Result<_, actix_web::Error>`
+  instead of `Result<_, http::Error>`
+
+* `Application` renamed to a `App`
+
+* `actix_web::Reply`, `actix_web::Resource` moved to `actix_web::dev`

Makefile

@@ -10,17 +10,5 @@ build:
 test: build clippy
 	cargo test $(CARGO_FLAGS)
 
-skeptic:
-	USE_SKEPTIC=1 cargo test $(CARGO_FLAGS)
-
-# cd examples/word-count && python setup.py install && pytest -v tests
-
-clippy:
-	if $$CLIPPY; then cargo clippy $(CARGO_FLAGS); fi
-
 doc: build
 	cargo doc --no-deps $(CARGO_FLAGS)
-	cd guide; mdbook build -d ../target/doc/guide/; cd ..
-
-book:
-	cd guide; mdbook build -d ../target/doc/guide/; cd ..

README.md

@@ -1,65 +1,76 @@
-# Actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![Build status](https://ci.appveyor.com/api/projects/status/kkdb4yce7qhm5w85/branch/master?svg=true)](https://ci.appveyor.com/project/fafhrd91/actix-web-hdy9d/branch/master) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](http://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![Build status](https://ci.appveyor.com/api/projects/status/kkdb4yce7qhm5w85/branch/master?svg=true)](https://ci.appveyor.com/project/fafhrd91/actix-web-hdy9d/branch/master) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-Actix web is a small, fast, pragmatic, open source rust web framework.
+Actix web is a simple, pragmatic and extremely fast web framework for Rust.
 
-```rust,ignore
+* Supported *HTTP/1.x* and [*HTTP/2.0*](https://actix.rs/book/actix-web/sec-12-http2.html) protocols
+* Streaming and pipelining
+* Keep-alive and slow requests handling
+* Client/server [WebSockets](https://actix.rs/book/actix-web/sec-11-websockets.html) support
+* Transparent content compression/decompression (br, gzip, deflate)
+* Configurable [request routing](https://actix.rs/book/actix-web/sec-6-url-dispatch.html)
+* Graceful server shutdown
+* Multipart streams
+* Static assets
+* SSL support with OpenSSL or `native-tls`
+* Middlewares ([Logger](https://actix.rs/book/actix-web/sec-9-middlewares.html#logging),
+  [Session](https://actix.rs/book/actix-web/sec-9-middlewares.html#user-sessions),
+  [Redis sessions](https://github.com/actix/actix-redis),
+  [DefaultHeaders](https://actix.rs/book/actix-web/sec-9-middlewares.html#default-headers),
+  [CORS](https://actix.rs/actix-web/actix_web/middleware/cors/index.html),
+  [CSRF](https://actix.rs/actix-web/actix_web/middleware/csrf/index.html))
+* Built on top of [Actix actor framework](https://github.com/actix/actix)
+
+## Documentation & community resources
+
+* [User Guide](https://actix.rs/book/actix-web/)
+* [API Documentation (Development)](https://actix.rs/actix-web/actix_web/)
+* [API Documentation (Releases)](https://docs.rs/actix-web/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-web](https://crates.io/crates/actix-web)
+* Minimum supported Rust version: 1.24 or later
+
+## Example
+
+```rust
 extern crate actix_web;
-use actix_web::*;
+use actix_web::{http, server, App, Path};
 
-fn index(req: HttpRequest) -> String {
-    format!("Hello {}!", &req.match_info()["name"])
+fn index(info: Path<(u32, String)>) -> String {
+    format!("Hello {}! id:{}", info.0, info.1)
 }
 
 fn main() {
-    HttpServer::new(
-        || Application::new()
-            .resource("/{name}", |r| r.f(index)))
+    server::new(
+        || App::new()
+            .route("/{id}/{name}/index.html", http::Method::GET, index))
         .bind("127.0.0.1:8080").unwrap()
         .run();
 }
 ```
 
-## Documentation
+### More examples
 
-* [User Guide](http://actix.github.io/actix-web/guide/)
-* [API Documentation (Development)](http://actix.github.io/actix-web/actix_web/)
-* [API Documentation (Releases)](https://docs.rs/actix-web/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-web](https://crates.io/crates/actix-web)
-* Minimum supported Rust version: 1.20 or later
+* [Basics](https://github.com/actix/examples/tree/master/basics/)
+* [Stateful](https://github.com/actix/examples/tree/master/state/)
+* [Protobuf support](https://github.com/actix/examples/tree/master/protobuf/)
+* [Multipart streams](https://github.com/actix/examples/tree/master/multipart/)
+* [Simple websocket](https://github.com/actix/examples/tree/master/websocket/)
+* [Tera](https://github.com/actix/examples/tree/master/template_tera/) / 
+  [Askama](https://github.com/actix/examples/tree/master/template_askama/) templates
+* [Diesel integration](https://github.com/actix/examples/tree/master/diesel/)
+* [r2d2](https://github.com/actix/examples/tree/master/r2d2/)
+* [SSL / HTTP/2.0](https://github.com/actix/examples/tree/master/tls/)
+* [Tcp/Websocket chat](https://github.com/actix/examples/tree/master/websocket-chat/)
+* [Json](https://github.com/actix/examples/tree/master/json/)
 
-## Features
-
-* Supported *HTTP/1.x* and *HTTP/2.0* protocols
-* Streaming and pipelining
-* Keep-alive and slow requests handling
-* [WebSockets](https://actix.github.io/actix-web/actix_web/ws/index.html)
-* Transparent content compression/decompression (br, gzip, deflate)
-* Configurable request routing
-* Graceful server shutdown
-* Multipart streams
-* Middlewares ([Logger](https://actix.github.io/actix-web/guide/qs_10.html#logging),
-  [Session](https://actix.github.io/actix-web/guide/qs_10.html#user-sessions),
-  [DefaultHeaders](https://actix.github.io/actix-web/guide/qs_10.html#default-headers),
-  [CORS](https://actix.github.io/actix-web/actix_web/middleware/cors/index.html))
-* Built on top of [Actix](https://github.com/actix/actix).
+You may consider checking out
+[this directory](https://github.com/actix/examples/tree/master/) for more examples.
 
 ## Benchmarks
 
-Some basic benchmarks could be found in this [respository](https://github.com/fafhrd91/benchmarks).
+* [TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r15&hw=ph&test=plaintext)
 
-## Examples
-
-* [Basics](https://github.com/actix/actix-web/tree/master/examples/basics/)
-* [Stateful](https://github.com/actix/actix-web/tree/master/examples/state/)
-* [Mulitpart streams](https://github.com/actix/actix-web/tree/master/examples/multipart/)
-* [Simple websocket session](https://github.com/actix/actix-web/tree/master/examples/websocket/)
-* [Tera templates](https://github.com/actix/actix-web/tree/master/examples/template_tera/)
-* [Diesel integration](https://github.com/actix/actix-web/tree/master/examples/diesel/)
-* [SSL / HTTP/2.0](https://github.com/actix/actix-web/tree/master/examples/tls/)
-* [Tcp/Websocket chat](https://github.com/actix/actix-web/tree/master/examples/websocket-chat/)
-* [SockJS Server](https://github.com/actix/actix-sockjs)
-* [Json](https://github.com/actix/actix-web/tree/master/examples/json/)
+* Some basic benchmarks could be found in this [repository](https://github.com/fafhrd91/benchmarks).
 
 ## License
 
@@ -69,3 +80,9 @@ This project is licensed under either of
 * MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
 
 at your option.
+
+## Code of Conduct
+
+Contribution to the actix-web crate is organized under the terms of the
+Contributor Covenant, the maintainer of actix-web, @fafhrd91, promises to
+intervene to uphold that code of conduct.

build.rs

@@ -1,43 +1,5 @@
-extern crate skeptic;
 extern crate version_check;
 
-use std::{env, fs};
-
-
-#[cfg(unix)]
-fn main() {
-    let f = env::var("OUT_DIR").unwrap() + "/skeptic-tests.rs";
-    if env::var("USE_SKEPTIC").is_ok() {
-        let _ = fs::remove_file(f);
-        // generates doc tests for `README.md`.
-        skeptic::generate_doc_tests(
-            &["README.md",
-              "guide/src/qs_1.md",
-              "guide/src/qs_2.md",
-              "guide/src/qs_3.md",
-              "guide/src/qs_3_5.md",
-              "guide/src/qs_4.md",
-              "guide/src/qs_4_5.md",
-              "guide/src/qs_5.md",
-              "guide/src/qs_7.md",
-              "guide/src/qs_8.md",
-              "guide/src/qs_9.md",
-              "guide/src/qs_10.md",
-              "guide/src/qs_12.md",
-              "guide/src/qs_13.md",
-            ]);
-    } else {
-        let _ = fs::File::create(f);
-    }
-
-    match version_check::is_nightly() {
-        Some(true) => println!("cargo:rustc-cfg=actix_nightly"),
-        Some(false) => (),
-        None => (),
-    };
-}
-
-#[cfg(not(unix))]
 fn main() {
     match version_check::is_nightly() {
         Some(true) => println!("cargo:rustc-cfg=actix_nightly"),

examples/basics/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "basics"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-workspace = "../.."
-
-[dependencies]
-futures = "*"
-env_logger = "0.5"
-actix = "0.4"
-actix-web = { path="../.." }

examples/basics/README.md

@@ -1,20 +0,0 @@
-# basics
-
-## Usage
-
-### server
-
-```bash
-cd actix-web/examples/basics
-cargo run
-# Started http server: 127.0.0.1:8080
-```
-
-### web client
-
-- [http://localhost:8080/index.html](http://localhost:8080/index.html)
-- [http://localhost:8080/async/bob](http://localhost:8080/async/bob)
-- [http://localhost:8080/user/bob/](http://localhost:8080/user/bob/) plain/text download
-- [http://localhost:8080/test](http://localhost:8080/test) (return status switch GET or POST or other)
-- [http://localhost:8080/static/index.html](http://localhost:8080/static/index.html)
-- [http://localhost:8080/static/notexit](http://localhost:8080/static/notexit) display 404 page

examples/basics/src/main.rs

@@ -1,151 +0,0 @@
-#![allow(unused_variables)]
-#![cfg_attr(feature="cargo-clippy", allow(needless_pass_by_value))]
-
-extern crate actix;
-extern crate actix_web;
-extern crate env_logger;
-extern crate futures;
-use futures::Stream;
-
-use std::{io, env};
-use actix_web::*;
-use actix_web::middleware::RequestSession;
-use futures::future::{FutureResult, result};
-
-/// favicon handler
-fn favicon(req: HttpRequest) -> Result<fs::NamedFile> {
-    Ok(fs::NamedFile::open("../static/favicon.ico")?)
-}
-
-/// simple index handler
-fn index(mut req: HttpRequest) -> Result<HttpResponse> {
-    println!("{:?}", req);
-
-    // example of ...
-    if let Ok(ch) = req.payload_mut().readany().poll() {
-        if let futures::Async::Ready(Some(d)) = ch {
-            println!("{}", String::from_utf8_lossy(d.as_ref()));
-        }
-    }
-
-    // session
-    let mut counter = 1;
-    if let Some(count) = req.session().get::<i32>("counter")? {
-        println!("SESSION value: {}", count);
-        counter = count + 1;
-        req.session().set("counter", counter)?;
-    } else {
-        req.session().set("counter", counter)?;
-    }
-
-    // html
-    let html = format!(r#"<!DOCTYPE html><html><head><title>actix - basics</title><link rel="shortcut icon" type="image/x-icon" href="/favicon.ico" /></head>
-<body>
-    <h1>Welcome <img width="30px" height="30px" src="/static/actixLogo.png" /></h1>
-    session counter = {}
-</body>
-</html>"#, counter);
-
-    // response
-    Ok(HttpResponse::build(StatusCode::OK)
-        .content_type("text/html; charset=utf-8")
-        .body(&html).unwrap())
-
-}
-
-/// 404 handler
-fn p404(req: HttpRequest) -> Result<HttpResponse> {
-
-    // html
-    let html = r#"<!DOCTYPE html><html><head><title>actix - basics</title><link rel="shortcut icon" type="image/x-icon" href="/favicon.ico" /></head>
-<body>
-    <a href="index.html">back to home</a>
-    <h1>404</h1>
-</body>
-</html>"#;
-
-    // response
-    Ok(HttpResponse::build(StatusCode::NOT_FOUND)
-        .content_type("text/html; charset=utf-8")
-        .body(html).unwrap())
-}
-
-
-/// async handler
-fn index_async(req: HttpRequest) -> FutureResult<HttpResponse, Error>
-{
-    println!("{:?}", req);
-
-    result(HttpResponse::Ok()
-           .content_type("text/html")
-           .body(format!("Hello {}!", req.match_info().get("name").unwrap()))
-           .map_err(|e| e.into()))
-}
-
-/// handler with path parameters like `/user/{name}/`
-fn with_param(req: HttpRequest) -> Result<HttpResponse>
-{
-    println!("{:?}", req);
-
-    Ok(HttpResponse::Ok()
-       .content_type("test/plain")
-       .body(format!("Hello {}!", req.match_info().get("name").unwrap()))?)
-}
-
-fn main() {
-    env::set_var("RUST_LOG", "actix_web=debug");
-    env::set_var("RUST_BACKTRACE", "1");
-    env_logger::init();
-    let sys = actix::System::new("basic-example");
-
-    let addr = HttpServer::new(
-        || Application::new()
-            // enable logger
-            .middleware(middleware::Logger::default())
-            // cookie session middleware
-            .middleware(middleware::SessionStorage::new(
-                middleware::CookieSessionBackend::build(&[0; 32])
-                    .secure(false)
-                    .finish()
-            ))
-            // register favicon
-            .resource("/favicon.ico", |r| r.f(favicon))
-            // register simple route, handle all methods
-            .resource("/index.html", |r| r.f(index))
-            // with path parameters
-            .resource("/user/{name}/", |r| r.method(Method::GET).f(with_param))
-            // async handler
-            .resource("/async/{name}", |r| r.method(Method::GET).a(index_async))
-            .resource("/test", |r| r.f(|req| {
-                match *req.method() {
-                    Method::GET => httpcodes::HTTPOk,
-                    Method::POST => httpcodes::HTTPMethodNotAllowed,
-                    _ => httpcodes::HTTPNotFound,
-                }
-            }))
-            .resource("/error.html", |r| r.f(|req| {
-                error::ErrorBadRequest(io::Error::new(io::ErrorKind::Other, "test"))
-            }))
-            // static files
-            .handler("/static/", fs::StaticFiles::new("../static/", true))
-            // redirect
-            .resource("/", |r| r.method(Method::GET).f(|req| {
-                println!("{:?}", req);
-
-                HttpResponse::Found()
-                    .header("LOCATION", "/index.html")
-                    .finish()
-            }))
-            // default
-            .default_resource(|r| {
-                r.method(Method::GET).f(p404);
-                r.route().p(pred::Not(pred::Get())).f(|req| httpcodes::HTTPMethodNotAllowed);
-            }))
-
-        .bind("127.0.0.1:8080").expect("Can not bind to 127.0.0.1:8080")
-        .shutdown_timeout(0)    // <- Set shutdown timeout to 0 seconds (default 60s)
-        .start();
-
-    println!("Starting http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/diesel/.env

@@ -1 +0,0 @@
-DATABASE_URL=file:test.db

examples/diesel/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "diesel-example"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-workspace = "../.."
-
-[dependencies]
-env_logger = "0.5"
-actix = "0.4"
-actix-web = { path = "../../" }
-
-futures = "0.1"
-uuid = { version = "0.5", features = ["serde", "v4"] }
-serde = "1.0"
-serde_json = "1.0"
-serde_derive = "1.0"
-
-diesel = { version = "1.0.0-beta1", features = ["sqlite"] }
-dotenv = "0.10"

examples/diesel/README.md

@@ -1,43 +0,0 @@
-# diesel
-
-Diesel's `Getting Started` guide using SQLite for Actix web
-
-## Usage
-
-### init database sqlite
-
-```bash
-cargo install diesel_cli --no-default-features --features sqlite
-cd actix-web/examples/diesel
-echo "DATABASE_URL=file:test.db" > .env
-diesel migration run
-```
-
-### server
-
-```bash
-# if ubuntu : sudo apt-get install libsqlite3-dev
-# if fedora : sudo dnf install libsqlite3x-devel
-cd actix-web/examples/diesel
-cargo run (or ``cargo watch -x run``)
-# Started http server: 127.0.0.1:8080
-```
-
-### web client
-
-[http://127.0.0.1:8080/NAME](http://127.0.0.1:8080/NAME)
-
-### sqlite client
-
-```bash
-# if ubuntu : sudo apt-get install sqlite3
-# if fedora : sudo dnf install sqlite3x
-sqlite3 test.db
-sqlite> .tables
-sqlite> select * from users;
-```
-
-
-## Postgresql
-
-You will also find another complete example of diesel+postgresql on      [https://github.com/TechEmpower/FrameworkBenchmarks/tree/master/frameworks/Rust/actix](https://github.com/TechEmpower/FrameworkBenchmarks/tree/master/frameworks/Rust/actix)

examples/diesel/migrations/20170124012402_create_users/down.sql

@@ -1 +0,0 @@
-DROP TABLE users

examples/diesel/migrations/20170124012402_create_users/up.sql

@@ -1,4 +0,0 @@
-CREATE TABLE users (
-  id VARCHAR NOT NULL PRIMARY KEY,
-  name VARCHAR NOT NULL
-)

examples/diesel/src/db.rs

@@ -1,53 +0,0 @@
-//! Db executor actor
-use uuid;
-use diesel;
-use actix_web::*;
-use actix::prelude::*;
-use diesel::prelude::*;
-
-use models;
-use schema;
-
-/// This is db executor actor. We are going to run 3 of them in parallel.
-pub struct DbExecutor(pub SqliteConnection);
-
-/// This is only message that this actor can handle, but it is easy to extend number of
-/// messages.
-pub struct CreateUser {
-    pub name: String,
-}
-
-impl ResponseType for CreateUser {
-    type Item = models::User;
-    type Error = Error;
-}
-
-impl Actor for DbExecutor {
-    type Context = SyncContext<Self>;
-}
-
-impl Handler<CreateUser> for DbExecutor {
-    type Result = MessageResult<CreateUser>;
-
-    fn handle(&mut self, msg: CreateUser, _: &mut Self::Context) -> Self::Result {
-        use self::schema::users::dsl::*;
-
-        let uuid = format!("{}", uuid::Uuid::new_v4());
-        let new_user = models::NewUser {
-            id: &uuid,
-            name: &msg.name,
-        };
-
-        diesel::insert_into(users)
-            .values(&new_user)
-            .execute(&self.0)
-            .expect("Error inserting person");
-
-        let mut items = users
-            .filter(id.eq(&uuid))
-            .load::<models::User>(&self.0)
-            .expect("Error loading person");
-
-        Ok(items.pop().unwrap())
-    }
-}

examples/diesel/src/main.rs

@@ -1,73 +0,0 @@
-//! Actix web diesel example
-//!
-//! Diesel does not support tokio, so we have to run it in separate threads.
-//! Actix supports sync actors by default, so we going to create sync actor that will
-//! use diesel. Technically sync actors are worker style actors, multiple of them
-//! can run in parallel and process messages from same queue.
-extern crate serde;
-extern crate serde_json;
-#[macro_use]
-extern crate serde_derive;
-#[macro_use]
-extern crate diesel;
-extern crate uuid;
-extern crate futures;
-extern crate actix;
-extern crate actix_web;
-extern crate env_logger;
-
-use actix::*;
-use actix_web::*;
-
-use diesel::prelude::*;
-use futures::future::Future;
-
-mod db;
-mod models;
-mod schema;
-
-use db::{CreateUser, DbExecutor};
-
-
-/// State with DbExecutor address
-struct State {
-    db: SyncAddress<DbExecutor>,
-}
-
-/// Async request handler
-fn index(req: HttpRequest<State>) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    let name = &req.match_info()["name"];
-
-    req.state().db.call_fut(CreateUser{name: name.to_owned()})
-        .from_err()
-        .and_then(|res| {
-            match res {
-                Ok(user) => Ok(httpcodes::HTTPOk.build().json(user)?),
-                Err(_) => Ok(httpcodes::HTTPInternalServerError.into())
-            }
-        })
-        .responder()
-}
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("diesel-example");
-
-    // Start db executor actors
-    let addr = SyncArbiter::start(3, || {
-        DbExecutor(SqliteConnection::establish("test.db").unwrap())
-    });
-
-    // Start http server
-    let _addr = HttpServer::new(move || {
-        Application::with_state(State{db: addr.clone()})
-            // enable logger
-            .middleware(middleware::Logger::default())
-            .resource("/{name}", |r| r.method(Method::GET).a(index))})
-        .bind("127.0.0.1:8080").unwrap()
-        .start();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/diesel/src/models.rs

@@ -1,14 +0,0 @@
-use super::schema::users;
-
-#[derive(Serialize, Queryable)]
-pub struct User {
-    pub id: String,
-    pub name: String,
-}
-
-#[derive(Insertable)]
-#[table_name = "users"]
-pub struct NewUser<'a> {
-    pub id: &'a str,
-    pub name: &'a str,
-}

examples/diesel/src/schema.rs

@@ -1,6 +0,0 @@
-table! {
-    users (id) {
-        id -> Text,
-        name -> Text,
-    }
-}

examples/hello-world/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "hello-world"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-workspace = "../.."
-
-[dependencies]
-env_logger = "0.5"
-actix = "0.4"
-actix-web = { path = "../../" }

examples/hello-world/src/main.rs

@@ -1,28 +0,0 @@
-extern crate actix;
-extern crate actix_web;
-extern crate env_logger;
-
-use actix_web::*;
-
-
-fn index(_req: HttpRequest) -> &'static str {
-    "Hello world!"
-}
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("ws-example");
-
-    let _addr = HttpServer::new(
-        || Application::new()
-            // enable logger
-            .middleware(middleware::Logger::default())
-            .resource("/index.html", |r| r.f(|_| "Hello world!"))
-            .resource("/", |r| r.f(index)))
-        .bind("127.0.0.1:8080").unwrap()
-        .start();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/json/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "json-example"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-workspace = "../.."
-
-[dependencies]
-bytes = "0.4"
-futures = "0.1"
-env_logger = "*"
-
-serde = "1.0"
-serde_json = "1.0"
-serde_derive = "1.0"
-json = "*"
-
-actix = "0.4"
-actix-web = { path="../../" }

examples/json/README.md

@@ -1,48 +0,0 @@
-# json
-
-Json's `Getting Started` guide using json (serde-json or json-rust) for Actix web
-
-## Usage
-
-### server
-
-```bash
-cd actix-web/examples/json
-cargo run
-# Started http server: 127.0.0.1:8080
-```
-
-### web client
-
-With [Postman](https://www.getpostman.com/) or [Rested](moz-extension://60daeb1c-5b1b-4afd-9842-0579ed34dfcb/dist/index.html)
-
-- POST / (embed serde-json):
-
-  - method : ``POST``
-  - url : ``http://127.0.0.1:8080/``
-  - header : ``Content-Type`` = ``application/json``
-  - body (raw) : ``{"name": "Test user", "number": 100}``
-
-- POST /manual (manual serde-json):
-
-  - method : ``POST``
-  - url : ``http://127.0.0.1:8080/manual``
-  - header : ``Content-Type`` = ``application/json``
-  - body (raw) : ``{"name": "Test user", "number": 100}``
-
-- POST /mjsonrust (manual json-rust):
-
-  - method : ``POST``
-  - url : ``http://127.0.0.1:8080/mjsonrust``
-  - header : ``Content-Type`` = ``application/json``
-  - body (raw) : ``{"name": "Test user", "number": 100}`` (you can also test ``{notjson}``)
-
-### python client
-
-- ``pip install aiohttp``
-- ``python client.py``
-
-if ubuntu :
-
-- ``pip3 install aiohttp``
-- ``python3 client.py``

examples/json/client.py

@@ -1,18 +0,0 @@
-# This script could be used for actix-web multipart example test
-# just start server and run client.py
-
-import json
-import asyncio
-import aiohttp
-
-async def req():
-    resp = await aiohttp.ClientSession().request(
-        "post", 'http://localhost:8080/',
-        data=json.dumps({"name": "Test user", "number": 100}),
-        headers={"content-type": "application/json"})
-    print(str(resp))
-    print(await resp.text())
-    assert 200 == resp.status
-
-
-asyncio.get_event_loop().run_until_complete(req())

examples/json/src/main.rs

@@ -1,99 +0,0 @@
-extern crate actix;
-extern crate actix_web;
-extern crate bytes;
-extern crate futures;
-extern crate env_logger;
-extern crate serde_json;
-#[macro_use] extern crate serde_derive;
-#[macro_use] extern crate json;
-
-use actix_web::*;
-
-use bytes::BytesMut;
-use futures::{Future, Stream};
-use json::JsonValue;
-
-#[derive(Debug, Serialize, Deserialize)]
-struct MyObj {
-    name: String,
-    number: i32,
-}
-
-/// This handler uses `HttpRequest::json()` for loading serde json object.
-fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req.json()
-        .from_err()  // convert all errors into `Error`
-        .and_then(|val: MyObj| {
-            println!("model: {:?}", val);
-            Ok(httpcodes::HTTPOk.build().json(val)?)  // <- send response
-        })
-        .responder()
-}
-
-
-const MAX_SIZE: usize = 262_144;  // max payload size is 256k
-
-/// This handler manually load request payload and parse serde json
-fn index_manual(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    // readany() returns asynchronous stream of Bytes objects
-    req.payload_mut().readany()
-        // `Future::from_err` acts like `?` in that it coerces the error type from
-        // the future into the final error type
-        .from_err()
-
-        // `fold` will asynchronously read each chunk of the request body and
-        // call supplied closure, then it resolves to result of closure
-        .fold(BytesMut::new(), move |mut body, chunk| {
-            // limit max size of in-memory payload
-            if (body.len() + chunk.len()) > MAX_SIZE {
-                Err(error::ErrorBadRequest("overflow"))
-            } else {
-                body.extend_from_slice(&chunk);
-                Ok(body)
-            }
-        })
-        // `Future::and_then` can be used to merge an asynchronous workflow with a
-        // synchronous workflow
-        .and_then(|body| {
-            // body is loaded, now we can deserialize serde-json
-            let obj = serde_json::from_slice::<MyObj>(&body)?;
-            Ok(httpcodes::HTTPOk.build().json(obj)?) // <- send response
-        })
-        .responder()
-}
-
-/// This handler manually load request payload and parse json-rust
-fn index_mjsonrust(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req.payload_mut().readany().concat2()
-        .from_err()
-        .and_then(|body| {
-            // body is loaded, now we can deserialize json-rust
-            let result = json::parse(std::str::from_utf8(&body).unwrap()); // return Result
-            let injson: JsonValue = match result { Ok(v) => v, Err(e) => object!{"err" => e.to_string() } };
-            Ok(HttpResponse::build(StatusCode::OK)
-                .content_type("application/json")
-                .body(injson.dump()).unwrap())
-
-        })
-        .responder()
-}
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("json-example");
-
-    let addr = HttpServer::new(|| {
-        Application::new()
-            // enable logger
-            .middleware(middleware::Logger::default())
-            .resource("/manual", |r| r.method(Method::POST).f(index_manual))
-            .resource("/mjsonrust", |r| r.method(Method::POST).f(index_mjsonrust))
-            .resource("/", |r| r.method(Method::POST).f(index))})
-        .bind("127.0.0.1:8080").unwrap()
-        .shutdown_timeout(1)
-        .start();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/multipart/README.md

@@ -1,24 +0,0 @@
-# multipart
-
-Multipart's `Getting Started` guide for Actix web
-
-## Usage
-
-### server
-
-```bash
-cd actix-web/examples/multipart
-cargo run (or ``cargo watch -x run``)
-# Started http server: 127.0.0.1:8080
-```
-
-### client
-
-- ``pip install aiohttp``
-- ``python client.py``
-- you must see in server console multipart fields
-
-if ubuntu :
-
-- ``pip3 install aiohttp``
-- ``python3 client.py``

examples/multipart/client.py

@@ -1,34 +0,0 @@
-# This script could be used for actix-web multipart example test
-# just start server and run client.py
-
-import asyncio
-import aiohttp
-
-async def req1():
-    with aiohttp.MultipartWriter() as writer:
-        writer.append('test')
-        writer.append_json({'passed': True})
-
-    resp = await aiohttp.ClientSession().request(
-        "post", 'http://localhost:8080/multipart',
-        data=writer, headers=writer.headers)
-    print(resp)
-    assert 200 == resp.status
-
-
-async def req2():
-    with aiohttp.MultipartWriter() as writer:
-        writer.append('test')
-        writer.append_json({'passed': True})
-        writer.append(open('src/main.rs'))
-
-    resp = await aiohttp.ClientSession().request(
-        "post", 'http://localhost:8080/multipart',
-        data=writer, headers=writer.headers)
-    print(resp)
-    assert 200 == resp.status
-
-
-loop = asyncio.get_event_loop()
-loop.run_until_complete(req1())
-loop.run_until_complete(req2())

examples/multipart/src/main.rs

@@ -1,59 +0,0 @@
-#![allow(unused_variables)]
-extern crate actix;
-extern crate actix_web;
-extern crate env_logger;
-extern crate futures;
-
-use actix::*;
-use actix_web::*;
-
-use futures::{Future, Stream};
-use futures::future::{result, Either};
-
-
-fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>>
-{
-    println!("{:?}", req);
-
-    req.multipart()            // <- get multipart stream for current request
-        .from_err()            // <- convert multipart errors
-        .and_then(|item| {     // <- iterate over multipart items
-            match item {
-                // Handle multipart Field
-                multipart::MultipartItem::Field(field) => {
-                    println!("==== FIELD ==== {:?}", field);
-
-                    // Field in turn is stream of *Bytes* object
-                    Either::A(
-                        field.map_err(Error::from)
-                            .map(|chunk| {
-                                println!("-- CHUNK: \n{}",
-                                         std::str::from_utf8(&chunk).unwrap());})
-                            .finish())
-                },
-                multipart::MultipartItem::Nested(mp) => {
-                    // Or item could be nested Multipart stream
-                    Either::B(result(Ok(())))
-                }
-            }
-        })
-        .finish()  // <- Stream::finish() combinator from actix
-        .map(|_| httpcodes::HTTPOk.into())
-        .responder()
-}
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("multipart-example");
-
-    let addr = HttpServer::new(
-        || Application::new()
-            .middleware(middleware::Logger::default()) // <- logger
-            .resource("/multipart", |r| r.method(Method::POST).a(index)))
-        .bind("127.0.0.1:8080").unwrap()
-        .start();
-
-    println!("Starting http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/state/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "state"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-workspace = "../.."
-
-[dependencies]
-futures = "*"
-env_logger = "0.5"
-actix = "0.4"
-actix-web = { path = "../../" }

examples/state/README.md

@@ -1,15 +0,0 @@
-# state
-
-## Usage
-
-### server
-
-```bash
-cd actix-web/examples/state
-cargo run
-# Started http server: 127.0.0.1:8080
-```
-
-### web client
-
-- [http://localhost:8080/](http://localhost:8080/)

examples/state/src/main.rs

@@ -1,77 +0,0 @@
-#![cfg_attr(feature="cargo-clippy", allow(needless_pass_by_value))]
-//! There are two level of statefulness in actix-web. Application has state
-//! that is shared across all handlers within same Application.
-//! And individual handler can have state.
-
-extern crate actix;
-extern crate actix_web;
-extern crate env_logger;
-
-use std::cell::Cell;
-
-use actix::*;
-use actix_web::*;
-
-/// Application state
-struct AppState {
-    counter: Cell<usize>,
-}
-
-/// somple handle
-fn index(req: HttpRequest<AppState>) -> HttpResponse {
-    println!("{:?}", req);
-    req.state().counter.set(req.state().counter.get() + 1);
-
-    httpcodes::HTTPOk.with_body(
-        format!("Num of requests: {}", req.state().counter.get()))
-}
-
-/// `MyWebSocket` counts how many messages it receives from peer,
-/// websocket-client.py could be used for tests
-struct MyWebSocket {
-    counter: usize,
-}
-
-impl Actor for MyWebSocket {
-    type Context = ws::WebsocketContext<Self, AppState>;
-}
-
-impl Handler<ws::Message> for MyWebSocket {
-    type Result = ();
-
-    fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
-        self.counter += 1;
-        println!("WS({}): {:?}", self.counter, msg);
-        match msg {
-            ws::Message::Ping(msg) => ctx.pong(&msg),
-            ws::Message::Text(text) => ctx.text(&text),
-            ws::Message::Binary(bin) => ctx.binary(bin),
-            ws::Message::Closed | ws::Message::Error => {
-                ctx.stop();
-            }
-            _ => (),
-        }
-    }
-}
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("ws-example");
-
-    let addr = HttpServer::new(
-        || Application::with_state(AppState{counter: Cell::new(0)})
-            // enable logger
-            .middleware(middleware::Logger::default())
-            // websocket route
-            .resource(
-                "/ws/", |r|
-                r.method(Method::GET).f(|req| ws::start(req, MyWebSocket{counter: 0})))
-            // register simple handler, handle all methods
-            .resource("/", |r| r.f(index)))
-        .bind("127.0.0.1:8080").unwrap()
-        .start();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/static/index.html

@@ -1,90 +0,0 @@
-<!DOCTYPE html>
-<meta charset="utf-8" />
-<html>
-<head>
-<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js">
-</script>
-  <script language="javascript" type="text/javascript">
-    $(function() {
-      var conn = null;
-      function log(msg) {
-        var control = $('#log');
-        control.html(control.html() + msg + '<br/>');
-        control.scrollTop(control.scrollTop() + 1000);
-      }
-      function connect() {
-        disconnect();
-        var wsUri = (window.location.protocol=='https:'&&'wss://'||'ws://')+window.location.host + '/ws/';
-        conn = new WebSocket(wsUri);
-        log('Connecting...');
-        conn.onopen = function() {
-          log('Connected.');
-          update_ui();
-        };
-        conn.onmessage = function(e) {
-          log('Received: ' + e.data);
-        };
-        conn.onclose = function() {
-          log('Disconnected.');
-          conn = null;
-          update_ui();
-        };
-      }
-      function disconnect() {
-        if (conn != null) {
-          log('Disconnecting...');
-          conn.close();
-          conn = null;
-          update_ui();
-        }
-      }
-      function update_ui() {
-        var msg = '';
-        if (conn == null) {
-          $('#status').text('disconnected');
-          $('#connect').html('Connect');
-        } else {
-          $('#status').text('connected (' + conn.protocol + ')');
-          $('#connect').html('Disconnect');
-        }
-      }
-      $('#connect').click(function() {
-        if (conn == null) {
-          connect();
-        } else {
-          disconnect();
-        }
-        update_ui();
-        return false;
-      });
-      $('#send').click(function() {
-        var text = $('#text').val();
-        log('Sending: ' + text);
-        conn.send(text);
-        $('#text').val('').focus();
-        return false;
-      });
-      $('#text').keyup(function(e) {
-        if (e.keyCode === 13) {
-          $('#send').click();
-          return false;
-        }
-      });
-    });
-</script>
-</head>
-<body>
-<h3>Chat!</h3>
-<div>
-  <button id="connect">Connect</button>&nbsp;|&nbsp;Status:
-  <span id="status">disconnected</span>
-</div>
-<div id="log"
-     style="width:20em;height:15em;overflow:auto;border:1px solid black">
-</div>
-<form id="chatform" onsubmit="return false;">
-  <input id="text" type="text" />
-  <input id="send" type="button" value="Send" />
-</form>
-</body>
-</html>

examples/template_tera/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "template-tera"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-workspace = "../.."
-
-[dependencies]
-env_logger = "0.5"
-actix = "0.4"
-actix-web = { path = "../../" }
-tera = "*"

examples/template_tera/README.md

@@ -1,17 +0,0 @@
-# template_tera
-
-Minimal example of using the template [tera](https://github.com/Keats/tera) that displays a form.
-
-## Usage
-
-### server
-
-```bash
-cd actix-web/examples/template_tera
-cargo run (or ``cargo watch -x run``)
-# Started http server: 127.0.0.1:8080
-```
-
-### web client
-
-- [http://localhost:8080](http://localhost:8080)

examples/template_tera/src/main.rs

@@ -1,47 +0,0 @@
-extern crate actix;
-extern crate actix_web;
-extern crate env_logger;
-#[macro_use]
-extern crate tera;
-
-use actix_web::*;
-
-
-struct State {
-    template: tera::Tera,  // <- store tera template in application state
-}
-
-fn index(req: HttpRequest<State>) -> Result<HttpResponse> {
-    let s = if let Some(name) = req.query().get("name") { // <- submitted form
-        let mut ctx = tera::Context::new();
-        ctx.add("name", &name.to_owned());
-        ctx.add("text", &"Welcome!".to_owned());
-        req.state().template.render("user.html", &ctx)
-            .map_err(|_| error::ErrorInternalServerError("Template error"))?
-    } else {
-        req.state().template.render("index.html", &tera::Context::new())
-            .map_err(|_| error::ErrorInternalServerError("Template error"))?
-    };
-    Ok(httpcodes::HTTPOk.build()
-       .content_type("text/html")
-       .body(s)?)
-}
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("tera-example");
-
-    let addr = HttpServer::new(|| {
-        let tera = compile_templates!(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/**/*"));
-
-        Application::with_state(State{template: tera})
-            // enable logger
-            .middleware(middleware::Logger::default())
-            .resource("/", |r| r.method(Method::GET).f(index))})
-        .bind("127.0.0.1:8080").unwrap()
-        .start();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/template_tera/templates/index.html

@@ -1,17 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8" />
-  <title>Actix web</title>
-</head>
-<body>
-  <h1>Welcome!</h1>
-  <p>
-    <h3>What is your name?</h3>
-    <form>
-      <input type="text" name="name" /><br/>
-      <p><input type="submit"></p>
-    </form>
-  </p>
-</body>
-</html>

examples/template_tera/templates/user.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8" />
-  <title>Actix web</title>
-</head>
-<body>
-  <h1>Hi, {{ name }}!</h1>
-  <p>
-    {{ text }}
-  </p>
-</body>
-</html>

examples/tls/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "tls-example"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-workspace = "../.."
-
-[[bin]]
-name = "server"
-path = "src/main.rs"
-
-[dependencies]
-env_logger = "0.5"
-actix = "^0.4.2"
-actix-web = { path = "../../", features=["alpn"] }

examples/tls/README.md

@@ -1,16 +0,0 @@
-# tls example
-
-## Usage
-
-### server
-
-```bash
-cd actix-web/examples/tls
-cargo run (or ``cargo watch -x run``)
-# Started http server: 127.0.0.1:8443
-```
-
-### web client
-
-- curl: ``curl -v https://127.0.0.1:8443/index.html --compress -k``
-- browser: [https://127.0.0.1:8443/index.html](https://127.0.0.1:8080/index.html)

examples/tls/src/main.rs

@@ -1,51 +0,0 @@
-#![allow(unused_variables)]
-extern crate actix;
-extern crate actix_web;
-extern crate env_logger;
-
-use std::fs::File;
-use std::io::Read;
-
-use actix_web::*;
-
-
-/// simple handle
-fn index(req: HttpRequest) -> Result<HttpResponse> {
-    println!("{:?}", req);
-    Ok(httpcodes::HTTPOk
-       .build()
-       .content_type("text/plain")
-       .body("Welcome!")?)
-}
-
-fn main() {
-    if ::std::env::var("RUST_LOG").is_err() {
-        ::std::env::set_var("RUST_LOG", "actix_web=trace");
-    }
-    let _ = env_logger::init();
-    let sys = actix::System::new("ws-example");
-
-    let mut file = File::open("identity.pfx").unwrap();
-    let mut pkcs12 = vec![];
-    file.read_to_end(&mut pkcs12).unwrap();
-    let pkcs12 = Pkcs12::from_der(&pkcs12).unwrap().parse("12345").unwrap();
-
-    let addr = HttpServer::new(
-        || Application::new()
-            // enable logger
-            .middleware(middleware::Logger::default())
-            // register simple handler, handle all methods
-            .resource("/index.html", |r| r.f(index))
-            // with path parameters
-            .resource("/", |r| r.method(Method::GET).f(|req| {
-                httpcodes::HTTPFound
-                    .build()
-                    .header("LOCATION", "/index.html")
-                    .body(Body::Empty)
-            })))
-        .bind("127.0.0.1:8443").unwrap()
-        .start_ssl(&pkcs12).unwrap();
-
-    println!("Started http server: 127.0.0.1:8443");
-    let _ = sys.run();
-}

examples/websocket-chat/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "websocket-example"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-workspace = "../.."
-
-[[bin]]
-name = "server"
-path = "src/main.rs"
-
-[[bin]]
-name = "client"
-path = "src/client.rs"
-
-[dependencies]
-rand = "*"
-bytes = "0.4"
-byteorder = "1.1"
-futures = "0.1"
-tokio-io = "0.1"
-tokio-core = "0.1"
-env_logger = "*"
-
-serde = "1.0"
-serde_json = "1.0"
-serde_derive = "1.0"
-
-actix = "^0.4.2"
-actix-web = { path="../../" }

examples/websocket-chat/README.md

@@ -1,32 +0,0 @@
-# Websocket chat example
-
-This is extension of the
-[actix chat example](https://github.com/actix/actix/tree/master/examples/chat)
-
-Added features:
-
-* Browser WebSocket client
-* Chat server runs in separate thread
-* Tcp listener runs in separate thread
-
-## Server
-
-Chat server listens for incoming tcp connections. Server can access several types of message:
-
-* `\list` - list all available rooms
-* `\join name` - join room, if room does not exist, create new one
-* `\name name` - set session name
-* `some message` - just string, send message to all peers in same room
-* client has to send heartbeat `Ping` messages, if server does not receive a heartbeat message for 10 seconds connection gets dropped
-
-To start server use command: `cargo run --bin server`
-
-## Client
-
-Client connects to server. Reads input from stdin and sends to server.
-
-To run client use command: `cargo run --bin client`
-
-## WebSocket Browser Client
-
-Open url: [http://localhost:8080/](http://localhost:8080/)

examples/websocket-chat/client.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-"""websocket cmd client for wssrv.py example."""
-import argparse
-import asyncio
-import signal
-import sys
-
-import aiohttp
-
-
-def start_client(loop, url):
-    name = input('Please enter your name: ')
-
-    # send request
-    ws = yield from aiohttp.ClientSession().ws_connect(url, autoclose=False, autoping=False)
-
-    # input reader
-    def stdin_callback():
-        line = sys.stdin.buffer.readline().decode('utf-8')
-        if not line:
-            loop.stop()
-        else:
-            ws.send_str(name + ': ' + line)
-    loop.add_reader(sys.stdin.fileno(), stdin_callback)
-
-    @asyncio.coroutine
-    def dispatch():
-        while True:
-            msg = yield from ws.receive()
-
-            if msg.type == aiohttp.WSMsgType.TEXT:
-                print('Text: ', msg.data.strip())
-            elif msg.type == aiohttp.WSMsgType.BINARY:
-                print('Binary: ', msg.data)
-            elif msg.type == aiohttp.WSMsgType.PING:
-                ws.pong()
-            elif msg.type == aiohttp.WSMsgType.PONG:
-                print('Pong received')
-            else:
-                if msg.type == aiohttp.WSMsgType.CLOSE:
-                    yield from ws.close()
-                elif msg.type == aiohttp.WSMsgType.ERROR:
-                    print('Error during receive %s' % ws.exception())
-                elif msg.type == aiohttp.WSMsgType.CLOSED:
-                    pass
-
-                break
-
-    yield from dispatch()
-
-
-ARGS = argparse.ArgumentParser(
-    description="websocket console client for wssrv.py example.")
-ARGS.add_argument(
-    '--host', action="store", dest='host',
-    default='127.0.0.1', help='Host name')
-ARGS.add_argument(
-    '--port', action="store", dest='port',
-    default=8080, type=int, help='Port number')
-
-if __name__ == '__main__':
-    args = ARGS.parse_args()
-    if ':' in args.host:
-        args.host, port = args.host.split(':', 1)
-        args.port = int(port)
-
-    url = 'http://{}:{}/ws/'.format(args.host, args.port)
-
-    loop = asyncio.get_event_loop()
-    loop.add_signal_handler(signal.SIGINT, loop.stop)
-    asyncio.Task(start_client(loop, url))
-    loop.run_forever()

examples/websocket-chat/src/client.rs

@@ -1,149 +0,0 @@
-#[macro_use] extern crate actix;
-extern crate bytes;
-extern crate byteorder;
-extern crate futures;
-extern crate tokio_io;
-extern crate tokio_core;
-extern crate serde;
-extern crate serde_json;
-#[macro_use] extern crate serde_derive;
-
-use std::{io, net, process, thread};
-use std::str::FromStr;
-use std::time::Duration;
-use futures::Future;
-use tokio_core::net::TcpStream;
-use actix::prelude::*;
-
-mod codec;
-
-
-fn main() {
-    let sys = actix::System::new("chat-client");
-
-    // Connect to server
-    let addr = net::SocketAddr::from_str("127.0.0.1:12345").unwrap();
-    Arbiter::handle().spawn(
-        TcpStream::connect(&addr, Arbiter::handle())
-            .and_then(|stream| {
-                let addr: SyncAddress<_> = ChatClient.framed(stream, codec::ClientChatCodec);
-
-                // start console loop
-                thread::spawn(move|| {
-                    loop {
-                        let mut cmd = String::new();
-                        if io::stdin().read_line(&mut cmd).is_err() {
-                            println!("error");
-                            return
-                        }
-
-                        addr.send(ClientCommand(cmd));
-                    }
-                });
-
-                futures::future::ok(())
-            })
-            .map_err(|e| {
-                println!("Can not connect to server: {}", e);
-                process::exit(1)
-            })
-    );
-
-    println!("Running chat client");
-    sys.run();
-}
-
-
-struct ChatClient;
-
-#[derive(Message)]
-struct ClientCommand(String);
-
-impl Actor for ChatClient {
-    type Context = FramedContext<Self>;
-
-    fn started(&mut self, ctx: &mut FramedContext<Self>) {
-        // start heartbeats otherwise server will disconnect after 10 seconds
-        self.hb(ctx)
-    }
-
-    fn stopping(&mut self, _: &mut FramedContext<Self>) -> bool {
-        println!("Disconnected");
-
-        // Stop application on disconnect
-        Arbiter::system().send(actix::msgs::SystemExit(0));
-
-        true
-    }
-}
-
-impl ChatClient {
-    fn hb(&self, ctx: &mut FramedContext<Self>) {
-        ctx.run_later(Duration::new(1, 0), |act, ctx| {
-            if ctx.send(codec::ChatRequest::Ping).is_ok() {
-                act.hb(ctx);
-            }
-        });
-    }
-}
-
-/// Handle stdin commands
-impl Handler<ClientCommand> for ChatClient {
-    type Result = ();
-
-    fn handle(&mut self, msg: ClientCommand, ctx: &mut FramedContext<Self>) {
-        let m = msg.0.trim();
-        if m.is_empty() {
-            return
-        }
-
-        // we check for /sss type of messages
-        if m.starts_with('/') {
-            let v: Vec<&str> = m.splitn(2, ' ').collect();
-            match v[0] {
-                "/list" => {
-                    let _ = ctx.send(codec::ChatRequest::List);
-                },
-                "/join" => {
-                    if v.len() == 2 {
-                        let _ = ctx.send(codec::ChatRequest::Join(v[1].to_owned()));
-                    } else {
-                        println!("!!! room name is required");
-                    }
-                },
-                _ => println!("!!! unknown command"),
-            }
-        } else {
-            let _ = ctx.send(codec::ChatRequest::Message(m.to_owned()));
-        }
-    }
-}
-
-/// Server communication
-
-impl FramedActor for ChatClient {
-    type Io = TcpStream;
-    type Codec = codec::ClientChatCodec;
-
-    fn handle(&mut self, msg: io::Result<codec::ChatResponse>, ctx: &mut FramedContext<Self>) {
-        match msg {
-            Err(_) => ctx.stop(),
-            Ok(msg) => match msg {
-                codec::ChatResponse::Message(ref msg) => {
-                    println!("message: {}", msg);
-                }
-                codec::ChatResponse::Joined(ref msg) => {
-                    println!("!!! joined: {}", msg);
-                }
-                codec::ChatResponse::Rooms(rooms) => {
-                    println!("\n!!! Available rooms:");
-                    for room in rooms {
-                        println!("{}", room);
-                    }
-                    println!("");
-                }
-                _ => (),
-            }
-        }
-    }
-}

examples/websocket-chat/src/codec.rs

@@ -1,134 +0,0 @@
-#![allow(dead_code)]
-use std::io;
-use serde_json as json;
-use byteorder::{BigEndian , ByteOrder};
-use bytes::{BytesMut, BufMut};
-use tokio_io::codec::{Encoder, Decoder};
-use actix::ResponseType;
-
-/// Client request
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(tag="cmd", content="data")]
-pub enum ChatRequest {
-    /// List rooms
-    List,
-    /// Join rooms
-    Join(String),
-    /// Send message
-    Message(String),
-    /// Ping
-    Ping
-}
-
-impl ResponseType for ChatRequest {
-    type Item = ();
-    type Error = ();
-}
-
-/// Server response
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(tag="cmd", content="data")]
-pub enum ChatResponse {
-    Ping,
-
-    /// List of rooms
-    Rooms(Vec<String>),
-
-    /// Joined
-    Joined(String),
-
-    /// Message
-    Message(String),
-}
-
-impl ResponseType for ChatResponse {
-    type Item = ();
-    type Error = ();
-}
-
-/// Codec for Client -> Server transport
-pub struct ChatCodec;
-
-impl Decoder for ChatCodec
-{
-    type Item = ChatRequest;
-    type Error = io::Error;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        let size = {
-            if src.len() < 2 {
-                return Ok(None)
-            }
-            BigEndian::read_u16(src.as_ref()) as usize
-        };
-
-        if src.len() >= size + 2 {
-            src.split_to(2);
-            let buf = src.split_to(size);
-            Ok(Some(json::from_slice::<ChatRequest>(&buf)?))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-impl Encoder for ChatCodec
-{
-    type Item = ChatResponse;
-    type Error = io::Error;
-
-    fn encode(&mut self, msg: ChatResponse, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        let msg = json::to_string(&msg).unwrap();
-        let msg_ref: &[u8] = msg.as_ref();
-
-        dst.reserve(msg_ref.len() + 2);
-        dst.put_u16::<BigEndian>(msg_ref.len() as u16);
-        dst.put(msg_ref);
-
-        Ok(())
-    }
-}
-
-
-/// Codec for Server -> Client transport
-pub struct ClientChatCodec;
-
-impl Decoder for ClientChatCodec
-{
-    type Item = ChatResponse;
-    type Error = io::Error;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        let size = {
-            if src.len() < 2 {
-                return Ok(None)
-            }
-            BigEndian::read_u16(src.as_ref()) as usize
-        };
-
-        if src.len() >= size + 2 {
-            src.split_to(2);
-            let buf = src.split_to(size);
-            Ok(Some(json::from_slice::<ChatResponse>(&buf)?))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-impl Encoder for ClientChatCodec
-{
-    type Item = ChatRequest;
-    type Error = io::Error;
-
-    fn encode(&mut self, msg: ChatRequest, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        let msg = json::to_string(&msg).unwrap();
-        let msg_ref: &[u8] = msg.as_ref();
-
-        dst.reserve(msg_ref.len() + 2);
-        dst.put_u16::<BigEndian>(msg_ref.len() as u16);
-        dst.put(msg_ref);
-
-        Ok(())
-    }
-}

examples/websocket-chat/src/main.rs

@@ -1,210 +0,0 @@
-#![allow(unused_variables)]
-extern crate rand;
-extern crate bytes;
-extern crate byteorder;
-extern crate futures;
-extern crate tokio_io;
-extern crate tokio_core;
-extern crate env_logger;
-extern crate serde;
-extern crate serde_json;
-#[macro_use] extern crate serde_derive;
-
-#[macro_use]
-extern crate actix;
-extern crate actix_web;
-
-use std::time::Instant;
-
-use actix::*;
-use actix_web::*;
-
-mod codec;
-mod server;
-mod session;
-
-/// This is our websocket route state, this state is shared with all route instances
-/// via `HttpContext::state()`
-struct WsChatSessionState {
-    addr: SyncAddress<server::ChatServer>,
-}
-
-/// Entry point for our route
-fn chat_route(req: HttpRequest<WsChatSessionState>) -> Result<HttpResponse> {
-    ws::start(
-        req,
-        WsChatSession {
-            id: 0,
-            hb: Instant::now(),
-            room: "Main".to_owned(),
-            name: None})
-}
-
-struct WsChatSession {
-    /// unique session id
-    id: usize,
-    /// Client must send ping at least once per 10 seconds, otherwise we drop connection.
-    hb: Instant,
-    /// joined room
-    room: String,
-    /// peer name
-    name: Option<String>,
-}
-
-impl Actor for WsChatSession {
-    type Context = ws::WebsocketContext<Self, WsChatSessionState>;
-
-    /// Method is called on actor start.
-    /// We register ws session with ChatServer
-    fn started(&mut self, ctx: &mut Self::Context) {
-        // register self in chat server. `AsyncContext::wait` register
-        // future within context, but context waits until this future resolves
-        // before processing any other events.
-        // HttpContext::state() is instance of WsChatSessionState, state is shared across all
-        // routes within application
-        let subs = ctx.sync_subscriber();
-        ctx.state().addr.call(
-            self, server::Connect{addr: subs}).then(
-            |res, act, ctx| {
-                match res {
-                    Ok(Ok(res)) => act.id = res,
-                    // something is wrong with chat server
-                    _ => ctx.stop(),
-                }
-                fut::ok(())
-            }).wait(ctx);
-    }
-
-    fn stopping(&mut self, ctx: &mut Self::Context) -> bool {
-        // notify chat server
-        ctx.state().addr.send(server::Disconnect{id: self.id});
-        true
-    }
-}
-
-/// Handle messages from chat server, we simply send it to peer websocket
-impl Handler<session::Message> for WsChatSession {
-    type Result = ();
-
-    fn handle(&mut self, msg: session::Message, ctx: &mut Self::Context) {
-        ctx.text(&msg.0);
-    }
-}
-
-/// WebSocket message handler
-impl Handler<ws::Message> for WsChatSession {
-    type Result = ();
-
-    fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
-        println!("WEBSOCKET MESSAGE: {:?}", msg);
-        match msg {
-            ws::Message::Ping(msg) => ctx.pong(&msg),
-            ws::Message::Pong(msg) => self.hb = Instant::now(),
-            ws::Message::Text(text) => {
-                let m = text.trim();
-                // we check for /sss type of messages
-                if m.starts_with('/') {
-                    let v: Vec<&str> = m.splitn(2, ' ').collect();
-                    match v[0] {
-                        "/list" => {
-                            // Send ListRooms message to chat server and wait for response
-                            println!("List rooms");
-                            ctx.state().addr.call(self, server::ListRooms).then(|res, _, ctx| {
-                                match res {
-                                    Ok(Ok(rooms)) => {
-                                        for room in rooms {
-                                            ctx.text(&room);
-                                        }
-                                    },
-                                    _ => println!("Something is wrong"),
-                                }
-                                fut::ok(())
-                            }).wait(ctx)
-                            // .wait(ctx) pauses all events in context,
-                            // so actor wont receive any new messages until it get list
-                            // of rooms back
-                        },
-                        "/join" => {
-                            if v.len() == 2 {
-                                self.room = v[1].to_owned();
-                                ctx.state().addr.send(
-                                    server::Join{id: self.id, name: self.room.clone()});
-
-                                ctx.text("joined");
-                            } else {
-                                ctx.text("!!! room name is required");
-                            }
-                        },
-                        "/name" => {
-                            if v.len() == 2 {
-                                self.name = Some(v[1].to_owned());
-                            } else {
-                                ctx.text("!!! name is required");
-                            }
-                        },
-                        _ => ctx.text(&format!("!!! unknown command: {:?}", m)),
-                    }
-                } else {
-                    let msg = if let Some(ref name) = self.name {
-                        format!("{}: {}", name, m)
-                    } else {
-                        m.to_owned()
-                    };
-                    // send message to chat server
-                    ctx.state().addr.send(
-                        server::Message{id: self.id,
-                                        msg: msg,
-                                        room: self.room.clone()})
-                }
-            },
-            ws::Message::Binary(bin) =>
-                println!("Unexpected binary"),
-            ws::Message::Closed | ws::Message::Error => {
-                ctx.stop();
-            }
-            _ => (),
-        }
-    }
-}
-
-fn main() {
-    let _ = env_logger::init();
-    let sys = actix::System::new("websocket-example");
-
-    // Start chat server actor in separate thread
-    let server: SyncAddress<_> =
-        Arbiter::start(|_| server::ChatServer::default());
-
-    // Start tcp server in separate thread
-    let srv = server.clone();
-    Arbiter::new("tcp-server").send::<msgs::Execute>(
-        msgs::Execute::new(move || {
-            session::TcpServer::new("127.0.0.1:12345", srv);
-            Ok(())
-        }));
-
-    // Create Http server with websocket support
-    let addr = HttpServer::new(
-        move || {
-            // Websocket sessions state
-            let state = WsChatSessionState { addr: server.clone() };
-
-            Application::with_state(state)
-                // redirect to websocket.html
-                .resource("/", |r| r.method(Method::GET).f(|_| {
-                    httpcodes::HTTPFound
-                        .build()
-                        .header("LOCATION", "/static/websocket.html")
-                        .finish()
-                }))
-                // websocket
-                .resource("/ws/", |r| r.route().f(chat_route))
-                // static resources
-                .handler("/static/", fs::StaticFiles::new("static/", true))
-        })
-        .bind("127.0.0.1:8080").unwrap()
-        .start();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/websocket-chat/src/server.rs

@@ -1,204 +0,0 @@
-//! `ChatServer` is an actor. It maintains list of connection client session.
-//! And manages available rooms. Peers send messages to other peers in same
-//! room through `ChatServer`.
-
-use std::cell::RefCell;
-use std::collections::{HashMap, HashSet};
-use rand::{self, Rng, ThreadRng};
-use actix::prelude::*;
-
-use session;
-
-/// Message for chat server communications
-
-/// New chat session is created
-pub struct Connect {
-    pub addr: Box<actix::Subscriber<session::Message> + Send>,
-}
-
-/// Response type for Connect message
-///
-/// Chat server returns unique session id
-impl ResponseType for Connect  {
-    type Item = usize;
-    type Error = ();
-}
-
-/// Session is disconnected
-#[derive(Message)]
-pub struct Disconnect {
-    pub id: usize,
-}
-
-/// Send message to specific room
-#[derive(Message)]
-pub struct Message {
-    /// Id of the client session
-    pub id: usize,
-    /// Peer message
-    pub msg: String,
-    /// Room name
-    pub room: String,
-}
-
-/// List of available rooms
-pub struct ListRooms;
-
-impl ResponseType for ListRooms {
-    type Item = Vec<String>;
-    type Error = ();
-}
-
-/// Join room, if room does not exists create new one.
-#[derive(Message)]
-pub struct Join {
-    /// Client id
-    pub id: usize,
-    /// Room name
-    pub name: String,
-}
-
-/// `ChatServer` manages chat rooms and responsible for coordinating chat session.
-/// implementation is super primitive
-pub struct ChatServer {
-    sessions: HashMap<usize, Box<actix::Subscriber<session::Message> + Send>>,
-    rooms: HashMap<String, HashSet<usize>>,
-    rng: RefCell<ThreadRng>,
-}
-
-impl Default for ChatServer {
-    fn default() -> ChatServer {
-        // default room
-        let mut rooms = HashMap::new();
-        rooms.insert("Main".to_owned(), HashSet::new());
-
-        ChatServer {
-            sessions: HashMap::new(),
-            rooms: rooms,
-            rng: RefCell::new(rand::thread_rng()),
-        }
-    }
-}
-
-impl ChatServer {
-    /// Send message to all users in the room
-    fn send_message(&self, room: &str, message: &str, skip_id: usize) {
-        if let Some(sessions) = self.rooms.get(room) {
-            for id in sessions {
-                if *id != skip_id {
-                    if let Some(addr) = self.sessions.get(id) {
-                        let _ = addr.send(session::Message(message.to_owned()));
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Make actor from `ChatServer`
-impl Actor for ChatServer {
-    /// We are going to use simple Context, we just need ability to communicate
-    /// with other actors.
-    type Context = Context<Self>;
-}
-
-/// Handler for Connect message.
-///
-/// Register new session and assign unique id to this session
-impl Handler<Connect> for ChatServer {
-    type Result = MessageResult<Connect>;
-
-    fn handle(&mut self, msg: Connect, _: &mut Context<Self>) -> Self::Result {
-        println!("Someone joined");
-
-        // notify all users in same room
-        self.send_message(&"Main".to_owned(), "Someone joined", 0);
-
-        // register session with random id
-        let id = self.rng.borrow_mut().gen::<usize>();
-        self.sessions.insert(id, msg.addr);
-
-        // auto join session to Main room
-        self.rooms.get_mut(&"Main".to_owned()).unwrap().insert(id);
-
-        // send id back
-        Ok(id)
-    }
-}
-
-/// Handler for Disconnect message.
-impl Handler<Disconnect> for ChatServer {
-    type Result = ();
-
-    fn handle(&mut self, msg: Disconnect, _: &mut Context<Self>) {
-        println!("Someone disconnected");
-
-        let mut rooms: Vec<String> = Vec::new();
-
-        // remove address
-        if self.sessions.remove(&msg.id).is_some() {
-            // remove session from all rooms
-            for (name, sessions) in &mut self.rooms {
-                if sessions.remove(&msg.id) {
-                    rooms.push(name.to_owned());
-                }
-            }
-        }
-        // send message to other users
-        for room in rooms {
-            self.send_message(&room, "Someone disconnected", 0);
-        }
-    }
-}
-
-/// Handler for Message message.
-impl Handler<Message> for ChatServer {
-    type Result = ();
-
-    fn handle(&mut self, msg: Message, _: &mut Context<Self>) {
-        self.send_message(&msg.room, msg.msg.as_str(), msg.id);
-    }
-}
-
-/// Handler for `ListRooms` message.
-impl Handler<ListRooms> for ChatServer {
-    type Result = MessageResult<ListRooms>;
-
-    fn handle(&mut self, _: ListRooms, _: &mut Context<Self>) -> Self::Result {
-        let mut rooms = Vec::new();
-
-        for key in self.rooms.keys() {
-            rooms.push(key.to_owned())
-        }
-
-        Ok(rooms)
-    }
-}
-
-/// Join room, send disconnect message to old room
-/// send join message to new room
-impl Handler<Join> for ChatServer {
-    type Result = ();
-
-    fn handle(&mut self, msg: Join, _: &mut Context<Self>) {
-        let Join {id, name} = msg;
-        let mut rooms = Vec::new();
-
-        // remove session from all rooms
-        for (n, sessions) in &mut self.rooms {
-            if sessions.remove(&id) {
-                rooms.push(n.to_owned());
-            }
-        }
-        // send message to other users
-        for room in rooms {
-            self.send_message(&room, "Someone disconnected", 0);
-        }
-
-        if self.rooms.get_mut(&name).is_none() {
-            self.rooms.insert(name.clone(), HashSet::new());
-        }
-        self.send_message(&name, "Someone connected", id);
-        self.rooms.get_mut(&name).unwrap().insert(id);
-    }
-}

examples/websocket-chat/src/session.rs

@@ -1,197 +0,0 @@
-//! `ClientSession` is an actor, it manages peer tcp connection and
-//! proxies commands from peer to `ChatServer`.
-use std::{io, net};
-use std::str::FromStr;
-use std::time::{Instant, Duration};
-use futures::Stream;
-use tokio_core::net::{TcpStream, TcpListener};
-
-use actix::prelude::*;
-
-use server::{self, ChatServer};
-use codec::{ChatRequest, ChatResponse, ChatCodec};
-
-
-/// Chat server sends this messages to session
-#[derive(Message)]
-pub struct Message(pub String);
-
-/// `ChatSession` actor is responsible for tcp peer communications.
-pub struct ChatSession {
-    /// unique session id
-    id: usize,
-    /// this is address of chat server
-    addr: SyncAddress<ChatServer>,
-    /// Client must send ping at least once per 10 seconds, otherwise we drop connection.
-    hb: Instant,
-    /// joined room
-    room: String,
-}
-
-impl Actor for ChatSession {
-    /// For tcp communication we are going to use `FramedContext`.
-    /// It is convenient wrapper around `Framed` object from `tokio_io`
-    type Context = FramedContext<Self>;
-
-    fn started(&mut self, ctx: &mut Self::Context) {
-        // we'll start heartbeat process on session start.
-        self.hb(ctx);
-
-        // register self in chat server. `AsyncContext::wait` register
-        // future within context, but context waits until this future resolves
-        // before processing any other events.
-        let addr: SyncAddress<_> = ctx.address();
-        self.addr.call(self, server::Connect{addr: addr.subscriber()})
-            .then(|res, act, ctx| {
-                match res {
-                    Ok(Ok(res)) => act.id = res,
-                    // something is wrong with chat server
-                    _ => ctx.stop(),
-                }
-                actix::fut::ok(())
-            }).wait(ctx);
-    }
-
-    fn stopping(&mut self, ctx: &mut Self::Context) -> bool {
-        // notify chat server
-        self.addr.send(server::Disconnect{id: self.id});
-        true
-    }
-}
-
-/// To use `FramedContext` we have to define Io type and Codec
-impl FramedActor for ChatSession {
-    type Io = TcpStream;
-    type Codec= ChatCodec;
-
-    /// This is main event loop for client requests
-    fn handle(&mut self, msg: io::Result<ChatRequest>, ctx: &mut FramedContext<Self>) {
-        match msg {
-            Err(_) => ctx.stop(),
-            Ok(msg) => match msg {
-                ChatRequest::List => {
-                    // Send ListRooms message to chat server and wait for response
-                    println!("List rooms");
-                    self.addr.call(self, server::ListRooms).then(|res, _, ctx| {
-                        match res {
-                            Ok(Ok(rooms)) => {
-                                let _ = ctx.send(ChatResponse::Rooms(rooms));
-                            },
-                        _ => println!("Something is wrong"),
-                        }
-                        actix::fut::ok(())
-                    }).wait(ctx)
-                    // .wait(ctx) pauses all events in context,
-                    // so actor wont receive any new messages until it get list of rooms back
-                },
-                ChatRequest::Join(name) => {
-                    println!("Join to room: {}", name);
-                    self.room = name.clone();
-                    self.addr.send(server::Join{id: self.id, name: name.clone()});
-                    let _ = ctx.send(ChatResponse::Joined(name));
-                },
-                ChatRequest::Message(message) => {
-                    // send message to chat server
-                    println!("Peer message: {}", message);
-                    self.addr.send(
-                        server::Message{id: self.id,
-                                        msg: message, room:
-                                        self.room.clone()})
-                }
-                // we update heartbeat time on ping from peer
-                ChatRequest::Ping =>
-                    self.hb = Instant::now(),
-            }
-        }
-    }
-}
-
-/// Handler for Message, chat server sends this message, we just send string to peer
-impl Handler<Message> for ChatSession {
-    type Result = ();
-
-    fn handle(&mut self, msg: Message, ctx: &mut FramedContext<Self>) {
-        // send message to peer
-        let _ = ctx.send(ChatResponse::Message(msg.0));
-    }
-}
-
-/// Helper methods
-impl ChatSession {
-
-    pub fn new(addr: SyncAddress<ChatServer>) -> ChatSession {
-        ChatSession {id: 0, addr: addr, hb: Instant::now(), room: "Main".to_owned()}
-    }
-    
-    /// helper method that sends ping to client every second.
-    ///
-    /// also this method check heartbeats from client
-    fn hb(&self, ctx: &mut FramedContext<Self>) {
-        ctx.run_later(Duration::new(1, 0), |act, ctx| {
-            // check client heartbeats
-            if Instant::now().duration_since(act.hb) > Duration::new(10, 0) {
-                // heartbeat timed out
-                println!("Client heartbeat failed, disconnecting!");
-
-                // notify chat server
-                act.addr.send(server::Disconnect{id: act.id});
-
-                // stop actor
-                ctx.stop();
-            }
-
-            if ctx.send(ChatResponse::Ping).is_ok() {
-                // if we can not send message to sink, sink is closed (disconnected)
-                act.hb(ctx);
-            }
-        });
-    }
-}
-
-
-/// Define tcp server that will accept incoming tcp connection and create
-/// chat actors.
-pub struct TcpServer {
-    chat: SyncAddress<ChatServer>,
-}
-
-impl TcpServer {
-    pub fn new(s: &str, chat: SyncAddress<ChatServer>) {
-        // Create server listener
-        let addr = net::SocketAddr::from_str("127.0.0.1:12345").unwrap();
-        let listener = TcpListener::bind(&addr, Arbiter::handle()).unwrap();
-
-        // Our chat server `Server` is an actor, first we need to start it
-        // and then add stream on incoming tcp connections to it.
-        // TcpListener::incoming() returns stream of the (TcpStream, net::SocketAddr) items
-        // So to be able to handle this events `Server` actor has to implement
-        // stream handler `StreamHandler<(TcpStream, net::SocketAddr), io::Error>`
-        let _: () = TcpServer::create(|ctx| {
-            ctx.add_message_stream(listener.incoming()
-                                   .map_err(|_| ())
-                                   .map(|(t, a)| TcpConnect(t, a)));
-            TcpServer{chat: chat}
-        });
-    }
-}
-
-/// Make actor from `Server`
-impl Actor for TcpServer {
-    /// Every actor has to provide execution `Context` in which it can run.
-    type Context = Context<Self>;
-}
-
-#[derive(Message)]
-struct TcpConnect(TcpStream, net::SocketAddr);
-
-/// Handle stream of TcpStream's
-impl Handler<TcpConnect> for TcpServer {
-    type Result = ();
-
-    fn handle(&mut self, msg: TcpConnect, _: &mut Context<Self>) {
-        // For each incoming connection we create `ChatSession` actor
-        // with out chat server address.
-        let server = self.chat.clone();
-        let _: () = ChatSession::new(server).framed(msg.0, ChatCodec);
-    }
-}

examples/websocket-chat/static/websocket.html

@@ -1,90 +0,0 @@
-<!DOCTYPE html>
-<meta charset="utf-8" />
-<html>
-<head>
-<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js">
-</script>
-  <script language="javascript" type="text/javascript">
-    $(function() {
-      var conn = null;
-      function log(msg) {
-        var control = $('#log');
-        control.html(control.html() + msg + '<br/>');
-        control.scrollTop(control.scrollTop() + 1000);
-      }
-      function connect() {
-        disconnect();
-        var wsUri = (window.location.protocol=='https:'&&'wss://'||'ws://')+window.location.host + '/ws/';
-        conn = new WebSocket(wsUri);
-        log('Connecting...');
-        conn.onopen = function() {
-          log('Connected.');
-          update_ui();
-        };
-        conn.onmessage = function(e) {
-          log('Received: ' + e.data);
-        };
-        conn.onclose = function() {
-          log('Disconnected.');
-          conn = null;
-          update_ui();
-        };
-      }
-      function disconnect() {
-        if (conn != null) {
-          log('Disconnecting...');
-          conn.close();
-          conn = null;
-          update_ui();
-        }
-      }
-      function update_ui() {
-        var msg = '';
-        if (conn == null) {
-          $('#status').text('disconnected');
-          $('#connect').html('Connect');
-        } else {
-          $('#status').text('connected (' + conn.protocol + ')');
-          $('#connect').html('Disconnect');
-        }
-      }
-      $('#connect').click(function() {
-        if (conn == null) {
-          connect();
-        } else {
-          disconnect();
-        }
-        update_ui();
-        return false;
-      });
-      $('#send').click(function() {
-        var text = $('#text').val();
-        log('Sending: ' + text);
-        conn.send(text);
-        $('#text').val('').focus();
-        return false;
-      });
-      $('#text').keyup(function(e) {
-        if (e.keyCode === 13) {
-          $('#send').click();
-          return false;
-        }
-      });
-    });
-</script>
-</head>
-<body>
-<h3>Chat!</h3>
-<div>
-  <button id="connect">Connect</button>&nbsp;|&nbsp;Status:
-  <span id="status">disconnected</span>
-</div>
-<div id="log"
-     style="width:20em;height:15em;overflow:auto;border:1px solid black">
-</div>
-<form id="chatform" onsubmit="return false;">
-  <input id="text" type="text" />
-  <input id="send" type="button" value="Send" />
-</form>
-</body>
-</html>

examples/websocket/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "websocket"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-
-[[bin]]
-name = "server"
-path = "src/main.rs"
-
-[dependencies]
-env_logger = "*"
-futures = "0.1"
-actix = "^0.4.2"
-actix-web = { git = "https://github.com/actix/actix-web.git" }

examples/websocket/README.md

@@ -1,27 +0,0 @@
-# websockect
-
-Simple echo websocket server.
-
-## Usage
-
-### server
-
-```bash
-cd actix-web/examples/websocket
-cargo run
-# Started http server: 127.0.0.1:8080
-```
-
-### web client
-
-- [http://localhost:8080/ws/index.html](http://localhost:8080/ws/index.html)
-
-### python client
-
-- ``pip install aiohttp``
-- ``python websocket-client.py``
-
-if ubuntu :
-
-- ``pip3 install aiohttp``
-- ``python3 websocket-client.py``

examples/websocket/src/main.rs

@@ -1,65 +0,0 @@
-//! Simple echo websocket server.
-//! Open `http://localhost:8080/ws/index.html` in browser
-//! or [python console client](https://github.com/actix/actix-web/blob/master/examples/websocket-client.py)
-//! could be used for testing.
-
-#![allow(unused_variables)]
-extern crate actix;
-extern crate actix_web;
-extern crate env_logger;
-
-use actix::*;
-use actix_web::*;
-
-/// do websocket handshake and start `MyWebSocket` actor
-fn ws_index(r: HttpRequest) -> Result<HttpResponse> {
-    ws::start(r, MyWebSocket)
-}
-
-/// websocket connection is long running connection, it easier
-/// to handle with an actor
-struct MyWebSocket;
-
-impl Actor for MyWebSocket {
-    type Context = ws::WebsocketContext<Self>;
-}
-
-/// Handler for `ws::Message`
-impl Handler<ws::Message> for MyWebSocket {
-    type Result = ();
-
-    fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
-        // process websocket messages
-        println!("WS: {:?}", msg);
-        match msg {
-            ws::Message::Ping(msg) => ctx.pong(&msg),
-            ws::Message::Text(text) => ctx.text(&text),
-            ws::Message::Binary(bin) => ctx.binary(bin),
-            ws::Message::Closed | ws::Message::Error => {
-                ctx.stop();
-            }
-            _ => (),
-        }
-    }
-}
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=trace");
-    let _ = env_logger::init();
-    let sys = actix::System::new("ws-example");
-
-    let _addr = HttpServer::new(
-        || Application::new()
-            // enable logger
-            .middleware(middleware::Logger::default())
-            // websocket route
-            .resource("/ws/", |r| r.method(Method::GET).f(ws_index))
-            // static files
-            .handler("/", fs::StaticFiles::new("../static/", true)))
-        // start http server on 127.0.0.1:8080
-        .bind("127.0.0.1:8080").unwrap()
-        .start();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/websocket/websocket-client.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-"""websocket cmd client for wssrv.py example."""
-import argparse
-import asyncio
-import signal
-import sys
-
-import aiohttp
-
-
-def start_client(loop, url):
-    name = input('Please enter your name: ')
-
-    # send request
-    ws = yield from aiohttp.ClientSession().ws_connect(url, autoclose=False, autoping=False)
-
-    # input reader
-    def stdin_callback():
-        line = sys.stdin.buffer.readline().decode('utf-8')
-        if not line:
-            loop.stop()
-        else:
-            ws.send_str(name + ': ' + line)
-    loop.add_reader(sys.stdin.fileno(), stdin_callback)
-
-    @asyncio.coroutine
-    def dispatch():
-        while True:
-            msg = yield from ws.receive()
-
-            if msg.type == aiohttp.WSMsgType.TEXT:
-                print('Text: ', msg.data.strip())
-            elif msg.type == aiohttp.WSMsgType.BINARY:
-                print('Binary: ', msg.data)
-            elif msg.type == aiohttp.WSMsgType.PING:
-                ws.pong()
-            elif msg.type == aiohttp.WSMsgType.PONG:
-                print('Pong received')
-            else:
-                if msg.type == aiohttp.WSMsgType.CLOSE:
-                    yield from ws.close()
-                elif msg.type == aiohttp.WSMsgType.ERROR:
-                    print('Error during receive %s' % ws.exception())
-                elif msg.type == aiohttp.WSMsgType.CLOSED:
-                    pass
-
-                break
-
-    yield from dispatch()
-
-
-ARGS = argparse.ArgumentParser(
-    description="websocket console client for wssrv.py example.")
-ARGS.add_argument(
-    '--host', action="store", dest='host',
-    default='127.0.0.1', help='Host name')
-ARGS.add_argument(
-    '--port', action="store", dest='port',
-    default=8080, type=int, help='Port number')
-
-if __name__ == '__main__':
-    args = ARGS.parse_args()
-    if ':' in args.host:
-        args.host, port = args.host.split(':', 1)
-        args.port = int(port)
-
-    url = 'http://{}:{}/ws/'.format(args.host, args.port)
-
-    loop = asyncio.get_event_loop()
-    loop.add_signal_handler(signal.SIGINT, loop.stop)
-    asyncio.Task(start_client(loop, url))
-    loop.run_forever()

guide/book.toml

@@ -1,6 +0,0 @@
-title = "Actix web"
-description = "Actix web framework guide"
-author = "Actix Project and Contributors"
-
-[output.html]
-google-analytics = "UA-110322332-1"

guide/src/SUMMARY.md

@@ -1,16 +0,0 @@
-# Summary
-
-[Quickstart](./qs_1.md)
-- [Getting Started](./qs_2.md)
-- [Application](./qs_3.md)
-- [Server](./qs_3_5.md)
-- [Handler](./qs_4.md)
-- [Errors](./qs_4_5.md)
-- [URL Dispatch](./qs_5.md)
-- [Request & Response](./qs_7.md)
-- [Testing](./qs_8.md)
-- [Middlewares](./qs_10.md)
-- [Static file handling](./qs_12.md)
-- [WebSockets](./qs_9.md)
-- [HTTP/2](./qs_13.md)
-- [Database integration](./qs_14.md)

guide/src/qs_1.md

@@ -1,34 +0,0 @@
-# Quick start
-
-Before you can start writing a actix web application, you’ll need a version of Rust installed.
-We recommend you use rustup to install or configure such a version.
-
-## Install Rust
-
-Before we begin, we need to install Rust using the [rustup](https://www.rustup.rs/) installer:
-
-```bash
-curl https://sh.rustup.rs -sSf | sh
-```
-
-If you already have rustup installed, run this command to ensure you have the latest version of Rust:
-
-```bash
-rustup update
-```
-
-Actix web framework requires rust version 1.20 and up.
-
-## Running Examples
-
-The fastest way to start experimenting with actix web is to clone the actix web repository
-and run the included examples in the examples/ directory. The following set of
-commands runs the `basics` example:
-
-```bash
-git clone https://github.com/actix/actix-web
-cd actix-web/examples/basics
-cargo run
-```
-
-Check [examples/](https://github.com/actix/actix-web/tree/master/examples) directory for more examples.

guide/src/qs_10.md

@@ -1,206 +0,0 @@
-# Middlewares
-
-Actix middlewares system allows to add additional behavior to request/response processing.
-Middleware can hook into incoming request process and modify request or halt request 
-processing and return response early. Also it can hook into response processing.
-
-Typically middlewares involves in following actions:
-
-* Pre-process the Request
-* Post-process a Response
-* Modify application state
-* Access external services (redis, logging, sessions)
-
-Middlewares are registered for each application and get executed in same order as
-registration order. In general, *middleware* is a type that implements
-[*Middleware trait*](../actix_web/middlewares/trait.Middleware.html). Each method
-in this trait has default implementation. Each method can return result immediately
-or *future* object.
-
-Here is example of simple middleware that adds request and response headers:
-
-```rust
-# extern crate http;
-# extern crate actix_web;
-use http::{header, HttpTryFrom};
-use actix_web::*;
-use actix_web::middleware::{Middleware, Started, Response};
-
-struct Headers;  // <- Our middleware
-
-/// Middleware implementation, middlewares are generic over application state,
-/// so you can access state with `HttpRequest::state()` method.
-impl<S> Middleware<S> for Headers {
-
-    /// Method is called when request is ready. It may return
-    /// future, which should resolve before next middleware get called.
-    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
-        req.headers_mut().insert(
-            header::CONTENT_TYPE, header::HeaderValue::from_static("text/plain"));
-        Ok(Started::Done)
-    }
-
-    /// Method is called when handler returns response,
-    /// but before sending http message to peer.
-    fn response(&self, req: &mut HttpRequest<S>, mut resp: HttpResponse) -> Result<Response> {
-        resp.headers_mut().insert(
-            header::HeaderName::try_from("X-VERSION").unwrap(),
-            header::HeaderValue::from_static("0.2"));
-        Ok(Response::Done(resp))
-    }
-}
-
-fn main() {
-    Application::new()
-       .middleware(Headers)  // <- Register middleware, this method could be called multiple times
-       .resource("/", |r| r.h(httpcodes::HTTPOk));
-}
-```
-
-Active provides several useful middlewares, like *logging*, *user sessions*, etc.
-
-
-## Logging
-
-Logging is implemented as middleware. 
-It is common to register logging middleware as first middleware for application. 
-Logging middleware has to be registered for each application.
-
-### Usage
-
-Create `Logger` middleware with the specified `format`.
-Default `Logger` could be created with `default` method, it uses the default format:
-
-```ignore
-  %a %t "%r" %s %b "%{Referer}i" "%{User-Agent}i" %T
-```
-```rust
-# extern crate actix_web;
-use actix_web::Application;
-use actix_web::middleware::Logger;
-
-fn main() {
-    Application::new()
-       .middleware(Logger::default())
-       .middleware(Logger::new("%a %{User-Agent}i"))
-       .finish();
-}
-```
-
-Here is example of default logging format:
-
-```
-INFO:actix_web::middleware::logger: 127.0.0.1:59934 [02/Dec/2017:00:21:43 -0800] "GET / HTTP/1.1" 302 0 "-" "curl/7.54.0" 0.000397
-INFO:actix_web::middleware::logger: 127.0.0.1:59947 [02/Dec/2017:00:22:40 -0800] "GET /index.html HTTP/1.1" 200 0 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:57.0) Gecko/20100101 Firefox/57.0" 0.000646
-```
-
-### Format
-
- `%%`  The percent sign
-
- `%a`  Remote IP-address (IP-address of proxy if using reverse proxy)
-
- `%t`  Time when the request was started to process
-
- `%P`  The process ID of the child that serviced the request
-
- `%r`  First line of request
-
- `%s`  Response status code
-
- `%b`  Size of response in bytes, including HTTP headers
-
- `%T`  Time taken to serve the request, in seconds with floating fraction in .06f format
-
- `%D`  Time taken to serve the request, in milliseconds
-
- `%{FOO}i`  request.headers['FOO']
-
- `%{FOO}o`  response.headers['FOO']
-
- `%{FOO}e`  os.environ['FOO']
-
-
-## Default headers
-
-To set default response headers `DefaultHeaders` middleware could be used.
-*DefaultHeaders* middleware does not set header if response headers already contains
-specified header.
-
-```rust
-# extern crate actix_web;
-use actix_web::*;
-
-fn main() {
-    let app = Application::new()
-        .middleware(
-            middleware::DefaultHeaders::build()
-                .header("X-Version", "0.2")
-                .finish())
-        .resource("/test", |r| {
-             r.method(Method::GET).f(|req| httpcodes::HTTPOk);
-             r.method(Method::HEAD).f(|req| httpcodes::HTTPMethodNotAllowed);
-        })
-       .finish();
-}
-```
-
-## User sessions
-
-Actix provides general solution for session management. 
-[*Session storage*](../actix_web/middleware/struct.SessionStorage.html) middleware can be 
-use with different backend types to store session data in different backends. 
-By default only cookie session backend is implemented. Other backend implementations 
-could be added later.
-
-[*Cookie session backend*](../actix_web/middleware/struct.CookieSessionBackend.html)
-uses signed cookies as session storage. *Cookie session backend* creates sessions which
-are limited to storing fewer than 4000 bytes of data (as the payload must fit into a
-single cookie). Internal server error get generated if session contains more than 4000 bytes.
-
-You need to pass a random value to the constructor of *CookieSessionBackend*.
-This is private key for cookie session. When this value is changed, all session data is lost.
-Note that whatever you write into your session is visible by the user (but not modifiable).
-
-In general case, you create
-[*Session storage*](../actix_web/middleware/struct.SessionStorage.html) middleware
-and initializes it with specific backend implementation, like *CookieSessionBackend*.
-To access session data
-[*HttpRequest::session()*](../actix_web/middleware/trait.RequestSession.html#tymethod.session)
-method has to be used. This method returns
-[*Session*](../actix_web/middleware/struct.Session.html) object, which allows to get or set
-session data.
-
-```rust
-# extern crate actix;
-# extern crate actix_web;
-use actix_web::*;
-use actix_web::middleware::{RequestSession, SessionStorage, CookieSessionBackend};
-
-fn index(mut req: HttpRequest) -> Result<&'static str> {
-    // access session data
-    if let Some(count) = req.session().get::<i32>("counter")? {
-        println!("SESSION value: {}", count);
-        req.session().set("counter", count+1)?;
-    } else {
-        req.session().set("counter", 1)?;
-    }
-
-    Ok("Welcome!")
-}
-
-fn main() {
-#   let sys = actix::System::new("basic-example");
-    HttpServer::new(
-        || Application::new()
-            .middleware(SessionStorage::new(          // <- create session middleware
-                CookieSessionBackend::build(&[0; 32]) // <- create cookie session backend
-                    .secure(false)
-                    .finish()
-            )))
-        .bind("127.0.0.1:59880").unwrap()
-        .start();
-#     actix::Arbiter::system().send(actix::msgs::SystemExit(0));
-#     let _ = sys.run();
-}
-```

guide/src/qs_12.md

@@ -1,44 +0,0 @@
-# Static file handling
-
-## Individual file
-
-It is possible to serve static files with custom path pattern and `NamedFile`. To
-match path tail we can use `[.*]` regex.
-
-```rust
-# extern crate actix_web;
-use actix_web::*;
-use std::path::PathBuf;
-
-fn index(req: HttpRequest) -> Result<fs::NamedFile> {
-    let path: PathBuf = req.match_info().query("tail")?;
-    Ok(fs::NamedFile::open(path)?)
-}
-
-fn main() {
-    Application::new()
-        .resource(r"/a/{tail:.*}", |r| r.method(Method::GET).f(index))
-        .finish();
-}
-```
-
-## Directory
-
-To serve files from specific directory and sub-directories `StaticFiles` could be used. 
-`StaticFiles` must be registered with `Application::handler()` method otherwise
-it won't be able to server sub-paths.
-
-```rust
-# extern crate actix_web;
-use actix_web::*;
-
-fn main() {
-    Application::new()
-        .handler("/static", fs::StaticFiles::new(".", true))
-        .finish();
-}
-```
-
-First parameter is a base directory. Second parameter is *show_index*, if it is set to *true*
-directory listing would be returned for directories, if it is set to *false*
-then *404 Not Found* would be returned instead of directory listing.

guide/src/qs_13.md

@@ -1,42 +0,0 @@
-# HTTP/2.0
-
-Actix web automatically upgrades connection to *HTTP/2.0* if possible.
-
-## Negotiation
-
-*HTTP/2.0* protocol over tls without prior knowledge requires
-[tls alpn](https://tools.ietf.org/html/rfc7301). At the moment only
-`rust-openssl` has support. Turn on `alpn` feature to enable `alpn` negotiation.
-With enable `alpn` feature `HttpServer` provides
-[serve_tls](../actix_web/struct.HttpServer.html#method.serve_tls) method.
-
-```toml
-[dependencies]
-actix-web = { git = "https://github.com/actix/actix-web", features=["alpn"] }
-```
-
-```rust,ignore
-use std::fs::File;
-use actix_web::*;
-
-fn main() {
-    let mut file = File::open("identity.pfx").unwrap();
-    let mut pkcs12 = vec![];
-    file.read_to_end(&mut pkcs12).unwrap();
-    let pkcs12 = Pkcs12::from_der(&pkcs12).unwrap().parse("12345").unwrap();
-
-    HttpServer::new(
-        || Application::new()
-            .resource("/index.html", |r| r.f(index)))
-        .bind("127.0.0.1:8080").unwrap();
-        .serve_ssl(pkcs12).unwrap();
-}
-```
-
-Upgrade to *HTTP/2.0* schema described in
-[rfc section 3.2](https://http2.github.io/http2-spec/#rfc.section.3.2) is not supported.
-Starting *HTTP/2* with prior knowledge is supported for both clear text connection
-and tls connection. [rfc section 3.4](https://http2.github.io/http2-spec/#rfc.section.3.4)
-
-Please check [example](https://github.com/actix/actix-web/tree/master/examples/tls) 
-for concrete example.

guide/src/qs_14.md

@@ -1,125 +0,0 @@
-# Database integration
-
-## Diesel
-
-At the moment of 1.0 release Diesel does not support asynchronous operations.
-But it possible to use `actix` synchronous actor system as a db interface api.
-Technically sync actors are worker style actors, multiple of them
-can be run in parallel and process messages from same queue (sync actors work in mpmc mode).
-
-Let's create simple db api that can insert new user row into sqlite table.
-We have to define sync actor and connection that this actor will use. Same approach
-could used for other databases.
-
-```rust,ignore
-use actix::prelude::*;*
-
-struct DbExecutor(SqliteConnection);
-
-impl Actor for DbExecutor {
-    type Context = SyncContext<Self>;
-}
-```
-
-This is definition of our actor. Now we need to define *create user* message and response.
-
-```rust,ignore
-#[derive(Message)]
-#[rtype(User, Error)]
-struct CreateUser {
-    name: String,
-}
-```
-
-We can send `CreateUser` message to `DbExecutor` actor, and as result we get
-`User` model. Now we need to define actual handler implementation for this message.
-
-```rust,ignore
-impl Handler<CreateUser> for DbExecutor {
-    type Result = Result<User, Error>
-
-    fn handle(&mut self, msg: CreateUser, _: &mut Self::Context) -> Self::Result
-    {
-        use self::schema::users::dsl::*;
-
-        // Create insertion model
-        let uuid = format!("{}", uuid::Uuid::new_v4());
-        let new_user = models::NewUser {
-            id: &uuid,
-            name: &msg.name,
-        };
-
-        // normal diesl operations
-        diesel::insert_into(users)
-            .values(&new_user)
-            .execute(&self.0)
-            .expect("Error inserting person");
-
-        let mut items = users
-            .filter(id.eq(&uuid))
-            .load::<models::User>(&self.0)
-            .expect("Error loading person");
-
-        Ok(items.pop().unwrap())
-    }
-}
-```
-
-That is it. Now we can use *DbExecutor* actor from any http handler or middleware.
-All we need is to start *DbExecutor* actors and store address in a state where http handler 
-can access it.
-
-```rust,ignore
-/// This is state where we will store *DbExecutor* address.
-struct State {
-    db: SyncAddress<DbExecutor>,
-}
-
-fn main() {
-    let sys = actix::System::new("diesel-example");
-
-    // Start 3 parallel db executors
-    let addr = SyncArbiter::start(3, || {
-        DbExecutor(SqliteConnection::establish("test.db").unwrap())
-    });
-
-    // Start http server
-    HttpServer::new(move || {
-        Application::with_state(State{db: addr.clone()})
-            .resource("/{name}", |r| r.method(Method::GET).a(index))})
-        .bind("127.0.0.1:8080").unwrap()
-        .start().unwrap();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}
-```
-
-And finally we can use address in a request handler. We get message response
-asynchronously, so handler needs to return future object, also `Route::a()` needs to be 
-used for async handler registration.
-
-
-```rust,ignore
-/// Async handler
-fn index(req: HttpRequest<State>) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    let name = &req.match_info()["name"];
-
-    // Send message to `DbExecutor` actor
-    req.state().db.call_fut(CreateUser{name: name.to_owned()})
-        .from_err()
-        .and_then(|res| {
-            match res {
-                Ok(user) => Ok(httpcodes::HTTPOk.build().json(user)?),
-                Err(_) => Ok(httpcodes::HTTPInternalServerError.into())
-            }
-        })
-        .responder()
-}
-```
-
-Full example is available in 
-[examples directory](https://github.com/actix/actix-web/tree/master/examples/diesel/).
-
-More information on sync actors could be found in 
-[actix documentation](https://docs.rs/actix/0.3.3/actix/sync/index.html).

guide/src/qs_2.md

@@ -1,95 +0,0 @@
-# Getting Started
-
-Let’s create and run our first actix web application. We’ll create a new Cargo project
-that depends on actix web and then run the application.
-
-In previous section we already installed required rust version. Now let's create new cargo projects.
-
-## Hello, world! 
-
-Let’s write our first actix web application! Start by creating a new binary-based
-Cargo project and changing into the new directory:
-
-```bash
-cargo new hello-world --bin
-cd hello-world
-```
-
-Now, add actix and actix web as dependencies of your project by ensuring your Cargo.toml 
-contains the following:
-
-```toml
-[dependencies]
-actix = "0.4"
-actix-web = "0.3"
-```
-
-In order to implement a web server, first we need to create a request handler.
-
-A request handler is a function that accepts a `HttpRequest` instance as its only parameter 
-and returns a type that can be converted into `HttpResponse`:
-
-```rust
-# extern crate actix_web;
-# use actix_web::*;
-  fn index(req: HttpRequest) -> &'static str {
-      "Hello world!"
-  }
-# fn main() {}
-```
-
-Next, create an `Application` instance and register the
-request handler with the application's `resource` on a particular *HTTP method* and *path*::
-
-```rust
-# extern crate actix_web;
-# use actix_web::*;
-# fn index(req: HttpRequest) -> &'static str {
-#    "Hello world!"
-# }
-# fn main() {
-   Application::new()
-       .resource("/", |r| r.f(index));
-# }
-```
-
-After that, application instance can be used with `HttpServer` to listen for incoming
-connections. Server accepts function that should return `HttpHandler` instance:
-
-```rust,ignore
-   HttpServer::new(
-       || Application::new()
-           .resource("/", |r| r.f(index)))
-       .bind("127.0.0.1:8088")?
-       .run();
-```
-
-That's it. Now, compile and run the program with cargo run. 
-Head over to ``http://localhost:8088/`` to see the results.
-
-Here is full source of main.rs file:
-
-```rust
-# use std::thread;
-# extern crate actix_web;
-use actix_web::*;
-
-fn index(req: HttpRequest) -> &'static str {
-    "Hello world!"
-}
-
-fn main() {
-# thread::spawn(|| {
-    HttpServer::new(
-        || Application::new()
-            .resource("/", |r| r.f(index)))
-        .bind("127.0.0.1:8088").expect("Can not bind to 127.0.0.1:8088")
-        .run();
-# });
-}
-```
-
-Note on `actix` crate. Actix web framework is built on top of actix actor library. 
-`actix::System` initializes actor system, `HttpServer` is an actor and must run within
-properly configured actix system. For more information please check
-[actix documentation](https://actix.github.io/actix/actix/)

guide/src/qs_3.md

@@ -1,109 +0,0 @@
-# Application
-
-Actix web provides some primitives to build web servers and applications with Rust.
-It provides routing, middlewares, pre-processing of requests, and post-processing of responses,
-websocket protocol handling, multipart streams, etc.
-
-All actix web server is built around `Application` instance.
-It is used for registering routes for resources, middlewares.
-Also it stores application specific state that is shared across all handlers
-within same application.
-
-Application acts as namespace for all routes, i.e all routes for specific application
-has same url path prefix. Application prefix always contains leading "/" slash. 
-If supplied prefix does not contain leading slash, it get inserted. 
-Prefix should consists of value path segments. i.e for application with prefix `/app` 
-any request with following paths `/app`, `/app/` or `/app/test` would match,
-but path `/application` would not match.
-
-```rust,ignore
-# extern crate actix_web;
-# extern crate tokio_core;
-# use actix_web::*;
-# fn index(req: HttpRequest) -> &'static str {
-#    "Hello world!"
-# }
-# fn main() {
-   let app = Application::new()
-       .prefix("/app")
-       .resource("/index.html", |r| r.method(Method::GET).f(index))
-       .finish()
-# }
-```
-
-In this example application with `/app` prefix and `index.html` resource
-get created. This resource is available as on `/app/index.html` url.
-For more information check 
-[*URL Matching*](./qs_5.html#using-a-application-prefix-to-compose-applications) section.
-
-Multiple applications could be served with one server:
-
-```rust
-# extern crate actix_web;
-# extern crate tokio_core;
-# use tokio_core::net::TcpStream;
-# use std::net::SocketAddr;
-use actix_web::*;
-
-fn main() {
-    HttpServer::<TcpStream, SocketAddr, _, _>::new(|| vec![
-        Application::new()
-            .prefix("/app1")
-            .resource("/", |r| r.f(|r| httpcodes::HTTPOk)),
-        Application::new()
-            .prefix("/app2")
-            .resource("/", |r| r.f(|r| httpcodes::HTTPOk)),
-        Application::new()
-            .resource("/", |r| r.f(|r| httpcodes::HTTPOk)),
-    ]);
-}
-```
-
-All `/app1` requests route to first application, `/app2` to second and then all other to third.
-Applications get matched based on registration order, if application with more general
-prefix is registered before less generic, that would effectively block less generic
-application to get matched. For example if *application* with prefix "/" get registered
-as first application, it would match all incoming requests.
-
-## State
-
-Application state is shared with all routes and resources within same application.
-State could be accessed with `HttpRequest::state()` method as a read-only item
-but interior mutability pattern with `RefCell` could be used to archive state mutability.
-State could be accessed with `HttpContext::state()` in case of http actor.
-State also available to route matching predicates and middlewares.
-
-Let's write simple application that uses shared state. We are going to store requests count
-in the state:
-
-```rust
-# extern crate actix;
-# extern crate actix_web;
-#
-use actix_web::*;
-use std::cell::Cell;
-
-// This struct represents state
-struct AppState {
-    counter: Cell<usize>,
-}
-
-fn index(req: HttpRequest<AppState>) -> String {
-    let count = req.state().counter.get() + 1; // <- get count
-    req.state().counter.set(count);            // <- store new count in state
-
-    format!("Request number: {}", count)       // <- response with count
-}
-
-fn main() {
-    Application::with_state(AppState{counter: Cell::new(0)})
-        .resource("/", |r| r.method(Method::GET).f(index))
-        .finish();
-}
-```
-
-Note on application state, http server accepts application factory rather than application
-instance. Http server construct application instance for each thread, so application state
-must be constructed multiple times. If you want to share state between different thread
-shared object should be used, like `Arc`. Application state does not need to be `Send` and `Sync`
-but application factory must be `Send` + `Sync`.

guide/src/qs_3_5.md

@@ -1,197 +0,0 @@
-# Server
-
-[*HttpServer*](../actix_web/struct.HttpServer.html) type is responsible for
-serving http requests. *HttpServer* accept application factory as a parameter,
-Application factory must have `Send` + `Sync` boundaries. More about that in
-*multi-threading* section. To bind to specific socket address `bind()` must be used.
-This method could be called multiple times. To start http server one of the *start*
-methods could be used. `start()` method start simple server, `start_tls()` or `start_ssl()`
-starts ssl server. *HttpServer* is an actix actor, it has to be initialized
-within properly configured actix system:
-
-```rust
-# extern crate actix;
-# extern crate actix_web;
-use actix::*;
-use actix_web::*;
-
-fn main() {
-    let sys = actix::System::new("guide");
-
-    HttpServer::new(
-        || Application::new()
-            .resource("/", |r| r.h(httpcodes::HTTPOk)))
-        .bind("127.0.0.1:59080").unwrap()
-        .start();
-
-#     actix::Arbiter::system().send(actix::msgs::SystemExit(0));
-    let _ = sys.run();
-}
-```
-
-It is possible to start server in separate thread with *spawn()* method. In that
-case server spawns new thread and create new actix system in it. To stop
-this server send `StopServer` message.
-
-Http server is implemented as an actix actor. It is possible to communicate with server
-via messaging system. All start methods like `start()`, `start_ssl()`, etc returns
-address of the started http server. Actix http server accept several messages:
-
-* `PauseServer` - Pause accepting incoming connections
-* `ResumeServer` - Resume accepting incoming connections
-* `StopServer` - Stop incoming connection processing, stop all workers and exit
-
-```rust
-# extern crate futures;
-# extern crate actix;
-# extern crate actix_web;
-# use futures::Future;
-use actix_web::*;
-use std::thread;
-use std::sync::mpsc;
-
-fn main() {
-    let (tx, rx) = mpsc::channel();
-    
-    thread::spawn(move || {
-        let sys = actix::System::new("http-server");
-        let addr = HttpServer::new(
-            || Application::new()
-                .resource("/", |r| r.h(httpcodes::HTTPOk)))
-            .bind("127.0.0.1:0").expect("Can not bind to 127.0.0.1:0")
-            .shutdown_timeout(60)    // <- Set shutdown timeout to 60 seconds
-            .start();
-        let _ = tx.send(addr);
-        let _ = sys.run();
-    });
-
-    let addr = rx.recv().unwrap();
-    let _ = addr.call_fut(
-         server::StopServer{graceful:true}).wait(); // <- Send `StopServer` message to server.
-}
-```
-
-## Multi-threading
-
-Http server automatically starts number of http workers, by default
-this number is equal to number of logical cpu in the system. This number
-could be overridden with `HttpServer::threads()` method.
-
-```rust
-# extern crate actix_web;
-# extern crate tokio_core;
-# use tokio_core::net::TcpStream;
-# use std::net::SocketAddr;
-use actix_web::*;
-
-fn main() {
-    HttpServer::<TcpStream, SocketAddr, _, _>::new(
-        || Application::new()
-            .resource("/", |r| r.h(httpcodes::HTTPOk)))
-        .threads(4); // <- Start 4 workers
-}
-```
-
-Server create separate application instance for each created worker. Application state
-is not shared between threads, to share state `Arc` could be used. Application state
-does not need to be `Send` and `Sync` but application factory must be `Send` + `Sync`.
-
-## SSL
-
-There are two `tls` and `alpn` features for ssl server. `tls` feature is for `native-tls`
-integration and `alpn` is for `openssl`.
-
-```toml
-[dependencies]
-actix-web = { git = "https://github.com/actix/actix-web", features=["alpn"] }
-```
-
-```rust,ignore
-use std::fs::File;
-use actix_web::*;
-
-fn main() {
-    let mut file = File::open("identity.pfx").unwrap();
-    let mut pkcs12 = vec![];
-    file.read_to_end(&mut pkcs12).unwrap();
-    let pkcs12 = Pkcs12::from_der(&pkcs12).unwrap().parse("12345").unwrap();
-
-    HttpServer::new(
-        || Application::new()
-            .resource("/index.html", |r| r.f(index)))
-        .bind("127.0.0.1:8080").unwrap()
-        .serve_ssl(pkcs12).unwrap();
-}
-```
-
-Note on *HTTP/2.0* protocol over tls without prior knowledge, it requires
-[tls alpn](https://tools.ietf.org/html/rfc7301). At the moment only
-`openssl` has `alpn ` support.
-
-Please check [example](https://github.com/actix/actix-web/tree/master/examples/tls)
-for full example.
-
-## Keep-Alive
-
-Actix can wait for requests on a keep-alive connection. *Keep alive*
-connection behavior is defined by server settings.
-
- * `Some(75)` - enable 75 sec *keep alive* timer according request and response settings.
- * `Some(0)` - disable *keep alive*.
- * `None` - Use `SO_KEEPALIVE` socket option.
-
-```rust
-# extern crate actix_web;
-# extern crate tokio_core;
-# use tokio_core::net::TcpStream;
-# use std::net::SocketAddr;
-use actix_web::*;
-
-fn main() {
-    HttpServer::<TcpStream, SocketAddr, _, _>::new(||
-        Application::new()
-            .resource("/", |r| r.h(httpcodes::HTTPOk)))
-        .keep_alive(None); // <- Use `SO_KEEPALIVE` socket option.
-}
-```
-
-If first option is selected then *keep alive* state
-calculated based on response's *connection-type*. By default
-`HttpResponse::connection_type` is not defined in that case *keep alive*
-defined by request's http version. Keep alive is off for *HTTP/1.0*
-and is on for *HTTP/1.1* and "HTTP/2.0".
-
-*Connection type* could be change with `HttpResponseBuilder::connection_type()` method.
-
-```rust
-# extern crate actix_web;
-# use actix_web::httpcodes::*;
-use actix_web::*;
-
-fn index(req: HttpRequest) -> HttpResponse {
-    HTTPOk.build()
-        .connection_type(headers::ConnectionType::Close) // <- Close connection
-        .force_close()                                   // <- Alternative method
-        .finish().unwrap()
-}
-# fn main() {}
-```
-
-## Graceful shutdown
-
-Actix http server support graceful shutdown. After receiving a stop signal, workers
-have specific amount of time to finish serving requests. Workers still alive after the
-timeout are force dropped. By default shutdown timeout sets to 30 seconds.
-You can change this parameter with `HttpServer::shutdown_timeout()` method.
-
-You can send stop message to server with server address and specify if you what
-graceful shutdown or not. `start()` methods return address of the server.
-
-Http server handles several OS signals. *CTRL-C* is available on all OSs,
-other signals are available on unix systems.
-
-* *SIGINT* - Force shutdown workers
-* *SIGTERM* - Graceful shutdown workers
-* *SIGQUIT* - Force shutdown workers
-
-It is possible to disable signals handling with `HttpServer::disable_signals()` method.

guide/src/qs_4.md

@@ -1,237 +0,0 @@
-# Handler
-
-A request handler can by any object that implements 
-[*Handler trait*](../actix_web/dev/trait.Handler.html).
-Request handling happen in two stages. First handler object get called. 
-Handle can return any object that implements 
-[*Responder trait*](../actix_web/trait.Responder.html#foreign-impls).
-Then `respond_to()` get called on returned object. And finally
-result of the `respond_to()` call get converted to `Reply` object.
-
-By default actix provides `Responder` implementations for some standard types, 
-like `&'static str`, `String`, etc.
-For complete list of implementations check 
-[*Responder documentation*](../actix_web/trait.Responder.html#foreign-impls).
-
-Examples of valid handlers:
-
-```rust,ignore
-fn index(req: HttpRequest) -> &'static str {
-    "Hello world!"
-}
-```
-
-```rust,ignore
-fn index(req: HttpRequest) -> String {
-    "Hello world!".to_owned()
-}
-```
-
-```rust,ignore
-fn index(req: HttpRequest) -> Bytes {
-    Bytes::from_static("Hello world!")
-}
-```
-
-```rust,ignore
-fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    ...
-}
-```
-
-Some notes on shared application state and handler state. If you noticed
-*Handler* trait is generic over *S*, which defines application state type. So
-application state is accessible from handler with `HttpRequest::state()` method. 
-But state is accessible as a read-only reference, if you need mutable access to state
-you have to implement it yourself. On other hand handler can mutable access it's own state
-as `handle` method takes mutable reference to *self*. Beware, actix creates multiple copies
-of application state and handlers, unique for each thread, so if you run your
-application in several threads actix will create same amount as number of threads 
-of application state objects and handler objects.
-
-Here is example of handler that stores number of processed requests:
-
-```rust
-# extern crate actix;
-# extern crate actix_web;
-use actix_web::*;
-use actix_web::dev::Handler;
-
-struct MyHandler(usize);
-
-impl<S> Handler<S> for MyHandler {
-    type Result = HttpResponse;
-
-    /// Handle request
-    fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
-        self.0 += 1;
-        httpcodes::HTTPOk.into()
-    }
-}
-# fn main() {}
-```
-
-This handler will work, but `self.0` value will be different depends on number of threads and
-number of requests processed per thread. Proper implementation would use `Arc` and `AtomicUsize`
-
-```rust
-# extern crate actix;
-# extern crate actix_web;
-use actix_web::*;
-use actix_web::dev::Handler;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-struct MyHandler(Arc<AtomicUsize>);
-
-impl<S> Handler<S> for MyHandler {
-    type Result = HttpResponse;
-
-    /// Handle request
-    fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
-        let num = self.0.load(Ordering::Relaxed) + 1;
-        self.0.store(num, Ordering::Relaxed);
-        httpcodes::HTTPOk.into()
-    }
-}
-
-fn main() {
-    let sys = actix::System::new("example");
-
-    let inc = Arc::new(AtomicUsize::new(0));
-
-    HttpServer::new(
-        move || { 
-            let cloned = inc.clone();
-            Application::new()
-                .resource("/", move |r| r.h(MyHandler(cloned)))
-        })
-        .bind("127.0.0.1:8088").unwrap()
-        .start();
-
-    println!("Started http server: 127.0.0.1:8088");
-#    actix::Arbiter::system().send(actix::msgs::SystemExit(0));
-    let _ = sys.run();
-}
-```
-
-Be careful with synchronization primitives like *Mutex* or *RwLock*. Actix web framework
-handles request asynchronously, by blocking thread execution all concurrent
-request handling processes would block. If you need to share or update some state 
-from multiple threads consider using [actix](https://actix.github.io/actix/actix/)  actor system.
-
-## Response with custom type
-
-To return custom type directly from handler function, type needs to implement `Responder` trait.
-Let's create response for custom type that serializes to `application/json` response:
-
-```rust
-# extern crate actix;
-# extern crate actix_web;
-extern crate serde;
-extern crate serde_json;
-#[macro_use] extern crate serde_derive;
-use actix_web::*;
-
-#[derive(Serialize)]
-struct MyObj {
-    name: &'static str,
-}
-
-/// Responder
-impl Responder for MyObj {
-    type Item = HttpResponse;
-    type Error = Error;
-
-    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse> {
-        let body = serde_json::to_string(&self)?;
-
-        // Create response and set content type
-        Ok(HttpResponse::Ok()
-            .content_type("application/json")
-            .body(body)?)
-    }
-}
-
-/// Because `MyObj` implements `Responder`, it is possible to return it directly
-fn index(req: HttpRequest) -> MyObj {
-    MyObj{name: "user"}
-}
-
-fn main() {
-    let sys = actix::System::new("example");
-
-    HttpServer::new(
-        || Application::new()
-            .resource("/", |r| r.method(Method::GET).f(index)))
-        .bind("127.0.0.1:8088").unwrap()
-        .start();
-
-    println!("Started http server: 127.0.0.1:8088");
-#    actix::Arbiter::system().send(actix::msgs::SystemExit(0));
-    let _ = sys.run();
-}
-```
-
-## Async handlers
-
-There are two different types of async handlers. 
-
-Response object could be generated asynchronously or more precisely, any type
-that implements [*Responder*](../actix_web/trait.Responder.html) trait. In this case handle must
-return `Future` object that resolves to *Responder* type, i.e:
-
-```rust
-# extern crate actix_web;
-# extern crate futures;
-# extern crate bytes;
-# use actix_web::*;
-# use bytes::Bytes;
-# use futures::stream::once;
-# use futures::future::{FutureResult, result};
-fn index(req: HttpRequest) -> FutureResult<HttpResponse, Error> {
-
-    result(HttpResponse::Ok()
-           .content_type("text/html")
-           .body(format!("Hello!"))
-           .map_err(|e| e.into()))
-}
-
-fn index2(req: HttpRequest) -> FutureResult<&'static str, Error> {
-    result(Ok("Welcome!"))
-}
-
-fn main() {
-    Application::new()
-        .resource("/async", |r| r.route().a(index))
-        .resource("/", |r| r.route().a(index2))
-        .finish();
-}
-```
-
-Or response body can be generated asynchronously. In this case body
-must implement stream trait `Stream<Item=Bytes, Error=Error>`, i.e:
-
-```rust
-# extern crate actix_web;
-# extern crate futures;
-# extern crate bytes;
-# use actix_web::*;
-# use bytes::Bytes;
-# use futures::stream::once;
-fn index(req: HttpRequest) -> HttpResponse {
-    let body = once(Ok(Bytes::from_static(b"test")));
-
-    HttpResponse::Ok()
-       .content_type("application/json")
-       .body(Body::Streaming(Box::new(body))).unwrap()
-}
-
-fn main() {
-    Application::new()
-        .resource("/async", |r| r.f(index))
-        .finish();
-}
-```
-
-Both methods could be combined. (i.e Async response with streaming body)

guide/src/qs_4_5.md

@@ -1,151 +0,0 @@
-# Errors
-
-Actix uses [`Error` type](../actix_web/error/struct.Error.html) 
-and [`ResponseError` trait](../actix_web/error/trait.ResponseError.html) 
-for handling handler's errors.
-Any error that implements `ResponseError` trait can be returned as error value.
-*Handler* can return *Result* object, actix by default provides 
-`Responder` implementation for compatible result object. Here is implementation
-definition:
-
-```rust,ignore
-impl<T: Responder, E: Into<Error>> Responder for Result<T, E>
-```
-
-And any error that implements `ResponseError` can be converted into `Error` object.
-For example if *handler* function returns `io::Error`, it would be converted
-into `HTTPInternalServerError` response. Implementation for `io::Error` is provided 
-by default.
-
-```rust
-# extern crate actix_web;
-# use actix_web::*;
-use std::io;
-
-fn index(req: HttpRequest) -> io::Result<fs::NamedFile> {
-    Ok(fs::NamedFile::open("static/index.html")?)
-}
-#
-# fn main() {
-#     Application::new()
-#         .resource(r"/a/index.html", |r| r.f(index))
-#         .finish();
-# }
-```
-
-## Custom error response
-
-To add support for custom errors, all we need to do is just implement `ResponseError` trait
-for custom error. `ResponseError` trait has default implementation
-for `error_response()` method, it generates *500* response.
-
-```rust
-# extern crate actix_web;
-#[macro_use] extern crate failure;
-use actix_web::*;
-
-#[derive(Fail, Debug)]
-#[fail(display="my error")]
-struct MyError {
-   name: &'static str
-}
-
-/// Use default implementation for `error_response()` method
-impl error::ResponseError for MyError {}
-
-fn index(req: HttpRequest) -> Result<&'static str, MyError> {
-    Err(MyError{name: "test"})
-}
-#
-# fn main() {
-#     Application::new()
-#         .resource(r"/a/index.html", |r| r.f(index))
-#         .finish();
-# }
-```
-
-In this example *index* handler will always return *500* response. But it is easy
-to return different responses for different type of errors.
-
-```rust
-# extern crate actix_web;
-#[macro_use] extern crate failure;
-use actix_web::*;
-
-#[derive(Fail, Debug)]
-enum MyError {
-   #[fail(display="internal error")]
-   InternalError,
-   #[fail(display="bad request")]
-   BadClientData,
-   #[fail(display="timeout")]
-   Timeout,
-}
-
-impl error::ResponseError for MyError {
-    fn error_response(&self) -> HttpResponse {
-       match *self {
-          MyError::InternalError => HttpResponse::new(
-              StatusCode::INTERNAL_SERVER_ERROR, Body::Empty),
-          MyError::BadClientData => HttpResponse::new(
-              StatusCode::BAD_REQUEST, Body::Empty),
-          MyError::Timeout => HttpResponse::new(
-              StatusCode::GATEWAY_TIMEOUT, Body::Empty),
-       }
-    }
-}
-
-fn index(req: HttpRequest) -> Result<&'static str, MyError> {
-    Err(MyError::BadClientData)
-}
-#
-# fn main() {
-#     Application::new()
-#         .resource(r"/a/index.html", |r| r.f(index))
-#         .finish();
-# }
-```
-
-## Error helpers
-
-Actix provides set of error helper types. It is possible to use them to generate
-specific error response. We can use helper types for first example with custom error.
-
-```rust
-# extern crate actix_web;
-#[macro_use] extern crate failure;
-use actix_web::*;
-
-#[derive(Debug)]
-struct MyError {
-   name: &'static str
-}
-
-fn index(req: HttpRequest) -> Result<&'static str> {
-    let result: Result<&'static str, MyError> = Err(MyError{name: "test"});
-    
-    Ok(result.map_err(error::ErrorBadRequest)?)
-}
-# fn main() {
-#     Application::new()
-#         .resource(r"/a/index.html", |r| r.f(index))
-#         .finish();
-# }
-```
-
-In this example *BAD REQUEST* response get generated for `MyError` error.
-
-## Error logging
-
-Actix logs all errors with `WARN` log level. If log level set to `DEBUG`
-and `RUST_BACKTRACE` is enabled, backtrace get logged. The Error type uses
-cause's error backtrace if available, if the underlying failure does not provide
-a backtrace, a new backtrace is constructed pointing to that conversion point
-(rather than the origin of the error). This construction only happens if there
-is no underlying backtrace; if it does have a backtrace no new backtrace is constructed.
-
-You can enable backtrace and debug logging with following command: 
-
-```
->> RUST_BACKTRACE=1 RUST_LOG=actix_web=debug cargo run
-```

guide/src/qs_5.md

@@ -1,578 +0,0 @@
-# URL Dispatch
-
-URL dispatch provides a simple way to map URLs to `Handler` code using a simple pattern matching
-language. *Regex* crate and it's
-[*RegexSet*](https://doc.rust-lang.org/regex/regex/struct.RegexSet.html) is being used for
-pattern matching. If one of the patterns matches the path information associated with a request,
-a particular handler object is invoked. A handler is a specific object that implements
-`Handler` trait, defined in your application, that receives the request and returns
-a response object. More information is available in [handler section](../qs_4.html).
-
-## Resource configuration
-
-Resource configuration is the act of adding a new resource to an application.
-A resource has a name, which acts as an identifier to be used for URL generation.
-The name also allows developers to add routes to existing resources.
-A resource also has a pattern, meant to match against the *PATH* portion of a *URL*,
-it does not match against *QUERY* portion (the portion following the scheme and
-port, e.g., */foo/bar* in the *URL* *http://localhost:8080/foo/bar?q=value*).
-
-The [Application::resource](../actix_web/struct.Application.html#method.resource) methods
-add a single resource to application routing table. This method accepts *path pattern*
-and resource configuration function.
-
-```rust
-# extern crate actix_web;
-# use actix_web::*;
-# use actix_web::httpcodes::*;
-#
-# fn index(req: HttpRequest) -> HttpResponse {
-#   unimplemented!()
-# }
-#
-fn main() {
-    Application::new()
-        .resource("/prefix", |r| r.f(index))
-        .resource("/user/{name}",
-             |r| r.method(Method::GET).f(|req| HTTPOk))
-        .finish();
-}
-```
-
-*Configuration function* has following type:
-
-```rust,ignore
-   FnOnce(&mut Resource<_>) -> ()
-```
-
-*Configuration function* can set name and register specific routes.
-If resource does not contain any route or does not have any matching routes it
-returns *NOT FOUND* http resources.
-
-## Configuring a Route
-
-Resource contains set of routes. Each route in turn has set of predicates and handler.
-New route could be created with `Resource::route()` method which returns reference
-to new *Route* instance. By default *route* does not contain any predicates, so matches
-all requests and default handler is `HTTPNotFound`.
-
-Application routes incoming requests based on route criteria which is defined during
-resource registration and route registration. Resource matches all routes it contains in
-the order that the routes were registered via `Resource::route()`. *Route* can contain
-any number of *predicates* but only one handler.
-
-```rust
-# extern crate actix_web;
-# use actix_web::*;
-# use actix_web::httpcodes::*;
-
-fn main() {
-    Application::new()
-        .resource("/path", |resource|
-            resource.route()
-              .p(pred::Get())
-              .p(pred::Header("content-type", "text/plain"))
-              .f(|req| HTTPOk)
-        )
-        .finish();
-}
-```
-
-In this example `index` get called for *GET* request,
-if request contains `Content-Type` header and value of this header is *text/plain*
-and path equals to `/test`. Resource calls handle of the first matches route.
-If resource can not match any route "NOT FOUND" response get returned.
-
-[*Resource::route()*](../actix_web/struct.Resource.html#method.route) method returns
-[*Route*](../actix_web/struct.Route.html) object. Route can be configured with
-builder-like pattern. Following configuration methods are available:
-
-* [*Route::p()*](../actix_web/struct.Route.html#method.p) method registers new predicate,
-  any number of predicates could be registered for each route.
-
-* [*Route::f()*](../actix_web/struct.Route.html#method.f) method registers handler function
-  for this route. Only one handler could be registered. Usually handler registration
-  is the last config operation. Handler function could be function or closure and has type
-  `Fn(HttpRequest<S>) -> R + 'static`
-
-* [*Route::h()*](../actix_web/struct.Route.html#method.h) method registers handler object
-  that implements `Handler` trait. This is similar to `f()` method, only one handler could
-  be registered. Handler registration is the last config operation.
-
-* [*Route::a()*](../actix_web/struct.Route.html#method.a) method registers async handler
-  function for this route. Only one handler could be registered. Handler registration
-  is the last config operation. Handler function could be function or closure and has type
-  `Fn(HttpRequest<S>) -> Future<Item = HttpResponse, Error = Error> + 'static`
-
-## Route matching
-
-The main purpose of route configuration is to match (or not match) the request's `path`
-against a URL path pattern. `path` represents the path portion of the URL that was requested.
-
-The way that *actix* does this is very simple. When a request enters the system,
-for each resource configuration registration present in the system, actix checks
-the request's path against the pattern declared. *Regex* crate and it's
-[*RegexSet*](https://doc.rust-lang.org/regex/regex/struct.RegexSet.html) is being used for
-pattern matching. If resource could not be found, *default resource* get used as matched
-resource.
-
-When a route configuration is declared, it may contain route predicate arguments. All route
-predicates associated with a route declaration must be `true` for the route configuration to
-be used for a given request during a check. If any predicate in the set of route predicate
-arguments provided to a route configuration returns `false` during a check, that route is
-skipped and route matching continues through the ordered set of routes.
-
-If any route matches, the route matching process stops and the handler associated with
-route get invoked.
-
-If no route matches after all route patterns are exhausted, *NOT FOUND* response get returned.
-
-## Resource pattern syntax
-
-The syntax of the pattern matching language used by the actix in the pattern
-argument is straightforward.
-
-The pattern used in route configuration may start with a slash character. If the pattern
-does not start with a slash character, an implicit slash will be prepended
-to it at matching time. For example, the following patterns are equivalent:
-
-```
-{foo}/bar/baz
-```
-
-and:
-
-```
-/{foo}/bar/baz
-```
-
-A *variable part* (replacement marker) is specified in the form *{identifier}*,
-where this means "accept any characters up to the next slash character and use this
-as the name in the `HttpRequest.match_info()` object".
-
-A replacement marker in a pattern matches the regular expression `[^{}/]+`.
-
-A match_info is the `Params` object representing the dynamic parts extracted from a
-*URL* based on the routing pattern. It is available as *request.match_info*. For example, the
-following pattern defines one literal segment (foo) and two replacement markers (baz, and bar):
-
-```
-foo/{baz}/{bar}
-```
-
-The above pattern will match these URLs, generating the following match information:
-
-```
-foo/1/2        -> Params {'baz':'1', 'bar':'2'}
-foo/abc/def    -> Params {'baz':'abc', 'bar':'def'}
-```
-
-It will not match the following patterns however:
-
-```
-foo/1/2/        -> No match (trailing slash)
-bar/abc/def     -> First segment literal mismatch
-```
-
-The match for a segment replacement marker in a segment will be done only up to
-the first non-alphanumeric character in the segment in the pattern. So, for instance,
-if this route pattern was used:
-
-```
-foo/{name}.html
-```
-
-The literal path */foo/biz.html* will match the above route pattern, and the match result
-will be `Params{'name': 'biz'}`. However, the literal path */foo/biz* will not match,
-because it does not contain a literal *.html* at the end of the segment represented
-by *{name}.html* (it only contains biz, not biz.html).
-
-To capture both segments, two replacement markers can be used:
-
-```
-foo/{name}.{ext}
-```
-
-The literal path */foo/biz.html* will match the above route pattern, and the match
-result will be *Params{'name': 'biz', 'ext': 'html'}*. This occurs because there is a
-literal part of *.* (period) between the two replacement markers *{name}* and *{ext}*.
-
-Replacement markers can optionally specify a regular expression which will be used to decide
-whether a path segment should match the marker. To specify that a replacement marker should
-match only a specific set of characters as defined by a regular expression, you must use a
-slightly extended form of replacement marker syntax. Within braces, the replacement marker
-name must be followed by a colon, then directly thereafter, the regular expression. The default
-regular expression associated with a replacement marker *[^/]+* matches one or more characters
-which are not a slash. For example, under the hood, the replacement marker *{foo}* can more
-verbosely be spelled as *{foo:[^/]+}*. You can change this to be an arbitrary regular expression
-to match an arbitrary sequence of characters, such as *{foo:\d+}* to match only digits.
-
-Segments must contain at least one character in order to match a segment replacement marker.
-For example, for the URL */abc/*:
-
-* */abc/{foo}* will not match.
-* */{foo}/* will match.
-
-Note that path will be URL-unquoted and decoded into valid unicode string before
-matching pattern and values representing matched path segments will be URL-unquoted too.
-So for instance, the following pattern:
-
-```
-foo/{bar}
-```
-
-When matching the following URL:
-
-```
-http://example.com/foo/La%20Pe%C3%B1a
-```
-
-The matchdict will look like so (the value is URL-decoded):
-
-```
-Params{'bar': 'La Pe\xf1a'}
-```
-
-Literal strings in the path segment should represent the decoded value of the
-path provided to actix. You don't want to use a URL-encoded value in the pattern.
-For example, rather than this:
-
-```
-/Foo%20Bar/{baz}
-```
-
-You'll want to use something like this:
-
-```
-/Foo Bar/{baz}
-```
-
-It is possible to get "tail match". For this purpose custom regex has to be used.
-
-```
-foo/{bar}/{tail:.*}
-```
-
-The above pattern will match these URLs, generating the following match information:
-
-```
-foo/1/2/           -> Params{'bar':'1', 'tail': '2/'}
-foo/abc/def/a/b/c  -> Params{'bar':u'abc', 'tail': 'def/a/b/c'}
-```
-
-## Match information
-
-All values representing matched path segments are available in
-[`HttpRequest::match_info`](../actix_web/struct.HttpRequest.html#method.match_info).
-Specific value can be received with
-[`Params::get()`](../actix_web/dev/struct.Params.html#method.get) method.
-
-Any matched parameter can be deserialized into specific type if this type
-implements `FromParam` trait. For example most of standard integer types
-implements `FromParam` trait. i.e.:
-
-```rust
-# extern crate actix_web;
-use actix_web::*;
-
-fn index(req: HttpRequest) -> Result<String> {
-    let v1: u8 = req.match_info().query("v1")?;
-    let v2: u8 = req.match_info().query("v2")?;
-    Ok(format!("Values {} {}", v1, v2))
-}
-
-fn main() {
-    Application::new()
-        .resource(r"/a/{v1}/{v2}/", |r| r.f(index))
-        .finish();
-}
-```
-
-For this example for path '/a/1/2/', values v1 and v2 will resolve to "1" and "2".
-
-It is possible to create a `PathBuf` from a tail path parameter. The returned `PathBuf` is
-percent-decoded. If a segment is equal to "..", the previous segment (if
-any) is skipped.
-
-For security purposes, if a segment meets any of the following conditions,
-an `Err` is returned indicating the condition met:
-
-  * Decoded segment starts with any of: `.` (except `..`), `*`
-  * Decoded segment ends with any of: `:`, `>`, `<`
-  * Decoded segment contains any of: `/`
-  * On Windows, decoded segment contains any of: '\'
-  * Percent-encoding results in invalid UTF8.
-
-As a result of these conditions, a `PathBuf` parsed from request path parameter is
-safe to interpolate within, or use as a suffix of, a path without additional checks.
-
-```rust
-# extern crate actix_web;
-use actix_web::*;
-use std::path::PathBuf;
-
-fn index(req: HttpRequest) -> Result<String> {
-    let path: PathBuf = req.match_info().query("tail")?;
-    Ok(format!("Path {:?}", path))
-}
-
-fn main() {
-    Application::new()
-        .resource(r"/a/{tail:.*}", |r| r.method(Method::GET).f(index))
-        .finish();
-}
-```
-
-List of `FromParam` implementation could be found in
-[api docs](../actix_web/dev/trait.FromParam.html#foreign-impls)
-
-## Generating resource URLs
-
-Use the [HttpRequest.url_for()](../actix_web/struct.HttpRequest.html#method.url_for)
-method to generate URLs based on resource patterns. For example, if you've configured a
-resource with the name "foo" and the pattern "{a}/{b}/{c}", you might do this.
-
-```rust
-# extern crate actix_web;
-# use actix_web::*;
-# use actix_web::httpcodes::*;
-#
-fn index(req: HttpRequest) -> HttpResponse {
-    let url = req.url_for("foo", &["1", "2", "3"]); // <- generate url for "foo" resource
-    HTTPOk.into()
-}
-
-fn main() {
-    let app = Application::new()
-        .resource("/test/{a}/{b}/{c}", |r| {
-             r.name("foo");  // <- set resource name, then it could be used in `url_for`
-             r.method(Method::GET).f(|_| httpcodes::HTTPOk);
-        })
-        .finish();
-}
-```
-
-This would return something like the string *http://example.com/test/1/2/3* (at least if
-the current protocol and hostname implied http://example.com).
-`url_for()` method return [*Url object*](https://docs.rs/url/1.6.0/url/struct.Url.html) so you
-can modify this url (add query parameters, anchor, etc).
-`url_for()` could be called only for *named* resources otherwise error get returned.
-
-## External resources
-
-Resources that are valid URLs, could be registered as external resources. They are useful
-for URL generation purposes only and are never considered for matching at request time.
-
-```rust
-# extern crate actix_web;
-use actix_web::*;
-
-fn index(mut req: HttpRequest) -> Result<HttpResponse> {
-    let url = req.url_for("youtube", &["oHg5SJYRHA0"])?;
-    assert_eq!(url.as_str(), "https://youtube.com/watch/oHg5SJYRHA0");
-    Ok(httpcodes::HTTPOk.into())
-}
-
-fn main() {
-    let app = Application::new()
-        .resource("/index.html", |r| r.f(index))
-        .external_resource("youtube", "https://youtube.com/watch/{video_id}")
-        .finish();
-}
-```
-
-## Path normalization and redirecting to slash-appended routes
-
-By normalizing it means:
-
- - Add a trailing slash to the path.
- - Double slashes are replaced by one.
-
-The handler returns as soon as it finds a path that resolves
-correctly. The order if all enable is 1) merge, 3) both merge and append
-and 3) append. If the path resolves with
-at least one of those conditions, it will redirect to the new path.
-
-If *append* is *true* append slash when needed. If a resource is
-defined with trailing slash and the request comes without it, it will
-append it automatically.
-
-If *merge* is *true*, merge multiple consecutive slashes in the path into one.
-
-This handler designed to be use as a handler for application's *default resource*.
-
-```rust
-# extern crate actix_web;
-# #[macro_use] extern crate serde_derive;
-# use actix_web::*;
-#
-# fn index(req: HttpRequest) -> httpcodes::StaticResponse {
-#    httpcodes::HTTPOk
-# }
-fn main() {
-    let app = Application::new()
-        .resource("/resource/", |r| r.f(index))
-        .default_resource(|r| r.h(NormalizePath::default()))
-        .finish();
-}
-```
-
-In this example `/resource`, `//resource///` will be redirected to `/resource/` url.
-
-In this example path normalization handler get registered for all method,
-but you should not rely on this mechanism to redirect *POST* requests. The redirect of the
-slash-appending *Not Found* will turn a *POST* request into a GET, losing any
-*POST* data in the original request.
-
-It is possible to register path normalization only for *GET* requests only
-
-```rust
-# extern crate actix_web;
-# #[macro_use] extern crate serde_derive;
-# use actix_web::*;
-#
-# fn index(req: HttpRequest) -> httpcodes::StaticResponse {
-#    httpcodes::HTTPOk
-# }
-fn main() {
-    let app = Application::new()
-        .resource("/resource/", |r| r.f(index))
-        .default_resource(|r| r.method(Method::GET).h(NormalizePath::default()))
-        .finish();
-}
-```
-
-## Using a Application Prefix to Compose Applications
-
-The `Application::prefix()`" method allows to set specific application prefix.
-This prefix represents a resource prefix that will be prepended to all resource patterns added
-by the resource configuration. This can be used to help mount a set of routes at a different
-location than the included callable's author intended while still maintaining the same
-resource names.
-
-For example:
-
-```rust
-# extern crate actix_web;
-# use actix_web::*;
-#
-fn show_users(req: HttpRequest) -> HttpResponse {
-   unimplemented!()
-}
-
-fn main() {
-    Application::new()
-        .prefix("/users")
-        .resource("/show", |r| r.f(show_users))
-        .finish();
-}
-```
-
-In the above example, the *show_users* route will have an effective route pattern of
-*/users/show* instead of */show* because the application's prefix argument will be prepended
-to the pattern. The route will then only match if the URL path is */users/show*,
-and when the `HttpRequest.url_for()` function is called with the route name show_users,
-it will generate a URL with that same path.
-
-## Custom route predicates
-
-You can think of predicate as simple function that accept *request* object reference
-and returns *true* or *false*. Formally predicate is any object that implements
-[`Predicate`](../actix_web/pred/trait.Predicate.html) trait. Actix provides
-several predicates, you can check [functions section](../actix_web/pred/index.html#functions)
-of api docs.
-
-Here is simple predicates that check that request contains specific *header*:
-
-```rust
-# extern crate actix_web;
-# extern crate http;
-# use actix_web::*;
-# use actix_web::httpcodes::*;
-use http::header::CONTENT_TYPE;
-use actix_web::pred::Predicate;
-
-struct ContentTypeHeader;
-
-impl<S: 'static> Predicate<S> for ContentTypeHeader {
-
-    fn check(&self, req: &mut HttpRequest<S>) -> bool {
-       req.headers().contains_key(CONTENT_TYPE)
-    }
-}
-
-fn main() {
-    Application::new()
-        .resource("/index.html", |r|
-           r.route()
-              .p(ContentTypeHeader)
-              .h(HTTPOk));
-}
-```
-
-In this example *index* handler will be called only if request contains *CONTENT-TYPE* header.
-
-Predicates can have access to application's state via `HttpRequest::state()` method.
-Also predicates can store extra information in
-[requests`s extensions](../actix_web/struct.HttpRequest.html#method.extensions).
-
-### Modifying predicate values
-
-You can invert the meaning of any predicate value by wrapping it in a `Not` predicate.
-For example if you want to return "METHOD NOT ALLOWED" response for all methods
-except "GET":
-
-```rust
-# extern crate actix_web;
-# extern crate http;
-# use actix_web::*;
-# use actix_web::httpcodes::*;
-use actix_web::pred;
-
-fn main() {
-    Application::new()
-        .resource("/index.html", |r|
-           r.route()
-              .p(pred::Not(pred::Get()))
-              .f(|req| HTTPMethodNotAllowed))
-        .finish();
-}
-```
-
-`Any` predicate accept list of predicates and matches if any of the supplied
-predicates match. i.e:
-
-```rust,ignore
-    pred::Any(pred::Get()).or(pred::Post())
-```
-
-`All` predicate accept list of predicates and matches if all of the supplied
-predicates match. i.e:
-
-```rust,ignore
-    pred::All(pred::Get()).and(pred::Header("content-type", "plain/text"))
-```
-
-## Changing the default Not Found response
-
-If path pattern can not be found in routing table or resource can not find matching
-route, default resource is used. Default response is *NOT FOUND* response.
-It is possible to override *NOT FOUND* response with `Application::default_resource()` method.
-This method accepts *configuration function* same as normal resource configuration
-with `Application::resource()` method.
-
-```rust
-# extern crate actix_web;
-# extern crate http;
-use actix_web::*;
-use actix_web::httpcodes::*;
-
-fn main() {
-    Application::new()
-        .default_resource(|r| {
-              r.method(Method::GET).f(|req| HTTPNotFound);
-              r.route().p(pred::Not(pred::Get())).f(|req| HTTPMethodNotAllowed);
-         })
-#        .finish();
-}
-```

guide/src/qs_7.md

@@ -1,297 +0,0 @@
-# Request & Response
-
-## Response
-
-Builder-like patter is used to construct an instance of `HttpResponse`.
-`HttpResponse` provides several method that returns `HttpResponseBuilder` instance,
-which is implements various convenience methods that helps build response.
-Check [documentation](../actix_web/dev/struct.HttpResponseBuilder.html)
-for type description. Methods `.body`, `.finish`, `.json` finalizes response creation and
-returns constructed *HttpResponse* instance. if this methods get called for the same
-builder instance multiple times, builder will panic.
-
-```rust
-# extern crate actix_web;
-use actix_web::*;
-use actix_web::headers::ContentEncoding;
-
-fn index(req: HttpRequest) -> HttpResponse {
-    HttpResponse::Ok()
-        .content_encoding(ContentEncoding::Br)
-        .content_type("plain/text")
-        .header("X-Hdr", "sample")
-        .body("data").unwrap()
-}
-# fn main() {}
-```
-
-## Content encoding
-
-Actix automatically *compress*/*decompress* payload. Following codecs are supported: 
-
- * Brotli
- * Gzip
- * Deflate
- * Identity
- 
- If request headers contains `Content-Encoding` header, request payload get decompressed
- according to header value. Multiple codecs are not supported, i.e: `Content-Encoding: br, gzip`.
- 
-Response payload get compressed based on *content_encoding* parameter. 
-By default `ContentEncoding::Auto` is used. If `ContentEncoding::Auto` is selected
-then compression depends on request's `Accept-Encoding` header. 
-`ContentEncoding::Identity` could be used to disable compression.
-If other content encoding is selected the compression is enforced for this codec. For example,
-to enable `brotli` response's body compression use `ContentEncoding::Br`:
-
-```rust
-# extern crate actix_web;
-use actix_web::*;
-use actix_web::headers::ContentEncoding;
-
-fn index(req: HttpRequest) -> HttpResponse {
-    HttpResponse::Ok()
-        .content_encoding(ContentEncoding::Br)
-        .body("data").unwrap()
-}
-# fn main() {}
-```
-
-
-## JSON Request
-
-There are two options of json body deserialization. 
-
-First option is to use *HttpResponse::json()* method. This method returns
-[*JsonBody*](../actix_web/dev/struct.JsonBody.html) object which resolves into 
-deserialized value.
-
-```rust
-# extern crate actix;
-# extern crate actix_web;
-# extern crate futures;
-# extern crate serde_json;
-# #[macro_use] extern crate serde_derive;
-# use actix_web::*;
-# use futures::Future;
-#[derive(Debug, Serialize, Deserialize)]
-struct MyObj {
-    name: String,
-    number: i32,
-}
-
-fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req.json().from_err()
-        .and_then(|val: MyObj| {
-            println!("model: {:?}", val);
-            Ok(httpcodes::HTTPOk.build().json(val)?)  // <- send response
-        })
-        .responder()
-}
-# fn main() {}
-```
-
-Or you can manually load payload into memory and then deserialize it.
-Here is simple example. We will deserialize *MyObj* struct. We need to load request
-body first and then deserialize json into object.
-
-```rust
-# extern crate actix_web;
-# extern crate futures;
-# use actix_web::*;
-# #[macro_use] extern crate serde_derive;
-extern crate serde_json;
-use futures::{Future, Stream};
-
-#[derive(Serialize, Deserialize)]
-struct MyObj {name: String, number: i32}
-
-fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-   // `concat2` will asynchronously read each chunk of the request body and
-   // return a single, concatenated, chunk
-   req.payload_mut().readany().concat2()
-      // `Future::from_err` acts like `?` in that it coerces the error type from
-      // the future into the final error type
-      .from_err()
-      // `Future::and_then` can be used to merge an asynchronous workflow with a
-      // synchronous workflow
-      .and_then(|body| {                           // <- body is loaded, now we can deserialize json
-          let obj = serde_json::from_slice::<MyObj>(&body)?;
-          Ok(httpcodes::HTTPOk.build().json(obj)?) // <- send response
-      })
-      .responder()
-}
-# fn main() {}
-```
-
-Complete example for both options is available in 
-[examples directory](https://github.com/actix/actix-web/tree/master/examples/json/).
-
-
-## JSON Response
-
-The `Json` type allows you to respond with well-formed JSON data: simply return a value of 
-type Json<T> where T is the type of a structure to serialize into *JSON*. The 
-type `T` must implement the `Serialize` trait from *serde*.
-
-```rust
-# extern crate actix_web;
-#[macro_use] extern crate serde_derive;
-use actix_web::*;
-
-#[derive(Serialize)]
-struct MyObj {
-    name: String,
-}
-
-fn index(req: HttpRequest) -> Result<Json<MyObj>> {
-    Ok(Json(MyObj{name: req.match_info().query("name")?}))
-}
-
-fn main() {
-    Application::new()
-        .resource(r"/a/{name}", |r| r.method(Method::GET).f(index))
-        .finish();
-}
-```
-
-## Chunked transfer encoding
-
-Actix automatically decode *chunked* encoding. `HttpRequest::payload()` already contains
-decoded bytes stream. If request payload compressed with one of supported
-compression codecs (br, gzip, deflate) bytes stream get decompressed.
-
-Chunked encoding on response could be enabled with `HttpResponseBuilder::chunked()` method.
-But this takes effect only for `Body::Streaming(BodyStream)` or `Body::StreamingContext` bodies.
-Also if response payload compression is enabled and streaming body is used, chunked encoding
-get enabled automatically.
-
-Enabling chunked encoding for *HTTP/2.0* responses is forbidden.
-
-```rust
-# extern crate actix_web;
-use actix_web::*;
-
-fn index(req: HttpRequest) -> HttpResponse {
-    HttpResponse::Ok()
-        .chunked()
-        .body(Body::Streaming(payload::Payload::empty().stream())).unwrap()
-}
-# fn main() {}
-```
-
-## Multipart body
-
-Actix provides multipart stream support. 
-[*Multipart*](../actix_web/multipart/struct.Multipart.html) is implemented as 
-a stream of multipart items, each item could be
-[*Field*](../actix_web/multipart/struct.Field.html) or nested *Multipart* stream.
-`HttpResponse::multipart()` method returns *Multipart* stream for current request.
-
-In simple form multipart stream handling could be implemented similar to this example
-
-```rust,ignore
-# extern crate actix_web;
-use actix_web::*;
-
-fn index(req: HttpRequest) -> Box<Future<...>> {
-    req.multipart()        // <- get multipart stream for current request
-       .and_then(|item| {  // <- iterate over multipart items
-           match item {
-                           // Handle multipart Field
-              multipart::MultipartItem::Field(field) => {
-                 println!("==== FIELD ==== {:?} {:?}", field.headers(), field.content_type());
-                 
-                 Either::A(
-                           // Field in turn is a stream of *Bytes* objects
-                   field.map(|chunk| {
-                        println!("-- CHUNK: \n{}",
-                                 std::str::from_utf8(&chunk).unwrap());})
-                      .fold((), |_, _| result(Ok(()))))
-                },
-              multipart::MultipartItem::Nested(mp) => {
-                         // Or item could be nested Multipart stream 
-                 Either::B(result(Ok(())))
-              }
-         }
-   })
-}
-```
-
-Full example is available in 
-[examples directory](https://github.com/actix/actix-web/tree/master/examples/multipart/).
-
-## Urlencoded body
-
-Actix provides support for *application/x-www-form-urlencoded* encoded body.
-`HttpResponse::urlencoded()` method returns
-[*UrlEncoded*](../actix_web/dev/struct.UrlEncoded.html) future, it resolves 
-into `HashMap<String, String>` which contains decoded parameters.
-*UrlEncoded* future can resolve into a error in several cases:
-
-* content type is not `application/x-www-form-urlencoded`
-* transfer encoding is `chunked`.
-* content-length is greater than 256k
-* payload terminates with error.
-
-
-```rust
-# extern crate actix_web;
-# extern crate futures;
-use actix_web::*;
-use futures::future::{Future, ok};
-
-fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req.urlencoded()         // <- get UrlEncoded future
-       .from_err()
-       .and_then(|params| {  // <- url encoded parameters
-             println!("==== BODY ==== {:?}", params);
-             ok(httpcodes::HTTPOk.into())
-       })
-       .responder()
-}
-# fn main() {}
-```
-
-
-## Streaming request
-
-Actix uses [*Payload*](../actix_web/payload/struct.Payload.html) object as request payload stream.
-*HttpRequest* provides several methods, which can be used for payload access.
-At the same time *Payload* implements *Stream* trait, so it could be used with various
-stream combinators. Also *Payload* provides several convenience methods that return
-future object that resolve to Bytes object.
-
-* *readany()* method returns *Stream* of *Bytes* objects.
-
-* *readexactly()* method returns *Future* that resolves when specified number of bytes
-  get received.
-  
-* *readline()* method returns *Future* that resolves when `\n` get received.
-
-* *readuntil()* method returns *Future* that resolves when specified bytes string
-  matches in input bytes stream
-
-In this example handle reads request payload chunk by chunk and prints every chunk.
-
-```rust
-# extern crate actix_web;
-# extern crate futures;
-# use futures::future::result;
-use actix_web::*;
-use futures::{Future, Stream};
-
-
-fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req.payload()
-       .readany()
-       .from_err()
-       .fold((), |_, chunk| {
-            println!("Chunk: {:?}", chunk);
-            result::<_, error::PayloadError>(Ok(()))
-        })
-       .map(|_| HttpResponse::Ok().finish().unwrap())
-       .responder()
-}
-# fn main() {}
-```

guide/src/qs_8.md

@@ -1,97 +0,0 @@
-# Testing
-
-Every application should be well tested and. Actix provides the tools to perform unit and
-integration tests.
-
-## Unit tests
-
-For unit testing actix provides request builder type and simple handler runner.
-[*TestRequest*](../actix_web/test/struct.TestRequest.html) implements builder-like pattern.
-You can generate `HttpRequest` instance with `finish()` method or you can
-run your handler with `run()` or `run_async()` methods.
-
-```rust
-# extern crate http;
-# extern crate actix_web;
-use http::{header, StatusCode};
-use actix_web::*;
-use actix_web::test::TestRequest;
-
-fn index(req: HttpRequest) -> HttpResponse {
-     if let Some(hdr) = req.headers().get(header::CONTENT_TYPE) {
-        if let Ok(s) = hdr.to_str() {
-            return httpcodes::HTTPOk.into()
-        }
-     }
-     httpcodes::HTTPBadRequest.into()
-}
-
-fn main() {
-    let resp = TestRequest::with_header("content-type", "text/plain")
-        .run(index)
-        .unwrap();
-    assert_eq!(resp.status(), StatusCode::OK);
-
-    let resp = TestRequest::default()
-        .run(index)
-        .unwrap();
-    assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-}
-```
-
-
-## Integration tests
-
-There are several methods how you can test your application. Actix provides 
-[*TestServer*](../actix_web/test/struct.TestServer.html)
-server that could be used to run whole application of just specific handlers
-in real http server. At the moment it is required to use third-party libraries
-to make actual requests, libraries like [reqwest](https://crates.io/crates/reqwest).
-
-In simple form *TestServer* could be configured to use handler. *TestServer::new* method
-accepts configuration function, only argument for this function is *test application*
-instance. You can check [api documentation](../actix_web/test/struct.TestApp.html)
-for more information.
-
-```rust
-# extern crate actix_web;
-extern crate reqwest;
-use actix_web::*;
-use actix_web::test::TestServer;
-
-fn index(req: HttpRequest) -> HttpResponse {
-     httpcodes::HTTPOk.into()
-}
-
-fn main() {
-    let srv = TestServer::new(|app| app.handler(index));        // <- Start new test server
-    let url = srv.url("/");                                     // <- get handler url
-    assert!(reqwest::get(&url).unwrap().status().is_success()); // <- make request
-}
-```
-
-Other option is to use application factory. In this case you need to pass factory function
-same as you use for real http server configuration.
-
-```rust
-# extern crate actix_web;
-extern crate reqwest;
-use actix_web::*;
-use actix_web::test::TestServer;
-
-fn index(req: HttpRequest) -> HttpResponse {
-     httpcodes::HTTPOk.into()
-}
-
-/// This function get called by http server.
-fn create_app() -> Application {
-    Application::new()
-        .resource("/test", |r| r.h(index))
-}
-
-fn main() {
-    let srv = TestServer::with_factory(create_app);             // <- Start new test server
-    let url = srv.url("/test");                                 // <- get handler url
-    assert!(reqwest::get(&url).unwrap().status().is_success()); // <- make request
-}
-```

guide/src/qs_9.md

@@ -1,49 +0,0 @@
-# WebSockets
-
-Actix supports WebSockets out-of-the-box. It is possible to convert request's `Payload`
-to a stream of [*ws::Message*](../actix_web/ws/enum.Message.html) with 
-a [*ws::WsStream*](../actix_web/ws/struct.WsStream.html) and then use stream
-combinators to handle actual messages. But it is simpler to handle websocket communications
-with http actor.
-
-This is example of simple websocket echo server:
-
-```rust
-# extern crate actix;
-# extern crate actix_web;
-use actix::*;
-use actix_web::*;
-
-/// Define http actor
-struct Ws;
-
-impl Actor for Ws {
-    type Context = ws::WebsocketContext<Self>;
-}
-
-/// Define Handler for ws::Message message
-impl Handler<ws::Message> for Ws {
-    type Result=();
-
-    fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
-        match msg {
-            ws::Message::Ping(msg) => ctx.pong(&msg),
-            ws::Message::Text(text) => ctx.text(&text),
-            ws::Message::Binary(bin) => ctx.binary(bin),
-            _ => (),
-        }
-    }
-}
-
-fn main() {
-    Application::new()
-      .resource("/ws/", |r| r.f(|req| ws::start(req, Ws)))  // <- register websocket route
-      .finish();
-}
-```
-
-Simple websocket echo server example is available in 
-[examples directory](https://github.com/actix/actix-web/blob/master/examples/websocket.rs).
-
-Example chat server with ability to chat over websocket connection or tcp connection
-is available in [websocket-chat directory](https://github.com/actix/actix-web/tree/master/examples/websocket-chat/)

rustfmt.toml

@@ -0,0 +1,5 @@
+max_width = 89
+reorder_imports = true
+wrap_comments = true
+fn_args_density = "Compressed"
+#use_small_heuristics = false

src/body.rs

@@ -1,14 +1,17 @@
-use std::{fmt, mem};
-use std::rc::Rc;
-use std::sync::Arc;
 use bytes::{Bytes, BytesMut};
 use futures::Stream;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::{fmt, mem};
 
-use error::Error;
 use context::ActorHttpContext;
+use error::Error;
+use handler::Responder;
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
 
 /// Type represent streaming body
-pub type BodyStream = Box<Stream<Item=Bytes, Error=Error>>;
+pub type BodyStream = Box<Stream<Item = Bytes, Error = Error>>;
 
 /// Represents various types of http message body.
 pub enum Body {
@@ -36,6 +39,8 @@ pub enum Binary {
     /// Shared string body
     #[doc(hidden)]
     ArcSharedString(Arc<String>),
+    /// Shared vec body
+    SharedVec(Arc<Vec<u8>>),
 }
 
 impl Body {
@@ -44,7 +49,7 @@ impl Body {
     pub fn is_streaming(&self) -> bool {
         match *self {
             Body::Streaming(_) | Body::Actor(_) => true,
-            _ => false
+            _ => false,
         }
     }
 
@@ -53,7 +58,7 @@ impl Body {
     pub fn is_binary(&self) -> bool {
         match *self {
             Body::Binary(_) => true,
-            _ => false
+            _ => false,
         }
     }
 
@@ -90,7 +95,10 @@ impl fmt::Debug for Body {
     }
 }
 
-impl<T> From<T> for Body where T: Into<Binary>{
+impl<T> From<T> for Body
+where
+    T: Into<Binary>,
+{
     fn from(b: T) -> Body {
         Body::Binary(b.into())
     }
@@ -115,6 +123,7 @@ impl Binary {
             Binary::Slice(slice) => slice.len(),
             Binary::SharedString(ref s) => s.len(),
             Binary::ArcSharedString(ref s) => s.len(),
+            Binary::SharedVec(ref s) => s.len(),
         }
     }
 
@@ -134,8 +143,9 @@ impl Clone for Binary {
         match *self {
             Binary::Bytes(ref bytes) => Binary::Bytes(bytes.clone()),
             Binary::Slice(slice) => Binary::Bytes(Bytes::from(slice)),
-            Binary::SharedString(ref s) => Binary::Bytes(Bytes::from(s.as_str())),
-            Binary::ArcSharedString(ref s) => Binary::Bytes(Bytes::from(s.as_str())),
+            Binary::SharedString(ref s) => Binary::SharedString(s.clone()),
+            Binary::ArcSharedString(ref s) => Binary::ArcSharedString(s.clone()),
+            Binary::SharedVec(ref s) => Binary::SharedVec(s.clone()),
         }
     }
 }
@@ -147,6 +157,7 @@ impl Into<Bytes> for Binary {
             Binary::Slice(slice) => Bytes::from(slice),
             Binary::SharedString(s) => Bytes::from(s.as_str()),
             Binary::ArcSharedString(s) => Bytes::from(s.as_str()),
+            Binary::SharedVec(s) => Bytes::from(AsRef::<[u8]>::as_ref(s.as_ref())),
         }
     }
 }
@@ -217,17 +228,42 @@ impl<'a> From<&'a Arc<String>> for Binary {
     }
 }
 
+impl From<Arc<Vec<u8>>> for Binary {
+    fn from(body: Arc<Vec<u8>>) -> Binary {
+        Binary::SharedVec(body)
+    }
+}
+
+impl<'a> From<&'a Arc<Vec<u8>>> for Binary {
+    fn from(body: &'a Arc<Vec<u8>>) -> Binary {
+        Binary::SharedVec(Arc::clone(body))
+    }
+}
+
 impl AsRef<[u8]> for Binary {
+    #[inline]
     fn as_ref(&self) -> &[u8] {
         match *self {
             Binary::Bytes(ref bytes) => bytes.as_ref(),
             Binary::Slice(slice) => slice,
             Binary::SharedString(ref s) => s.as_bytes(),
             Binary::ArcSharedString(ref s) => s.as_bytes(),
+            Binary::SharedVec(ref s) => s.as_ref().as_ref(),
         }
     }
 }
 
+impl Responder for Binary {
+    type Item = HttpResponse;
+    type Error = Error;
+
+    fn respond_to<S>(self, req: &HttpRequest<S>) -> Result<HttpResponse, Error> {
+        Ok(HttpResponse::build_from(req)
+            .content_type("application/octet-stream")
+            .body(self))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -247,68 +283,77 @@ mod tests {
     #[test]
     fn test_static_str() {
         assert_eq!(Binary::from("test").len(), 4);
-        assert_eq!(Binary::from("test").as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from("test").as_ref(), b"test");
     }
 
     #[test]
     fn test_static_bytes() {
         assert_eq!(Binary::from(b"test".as_ref()).len(), 4);
-        assert_eq!(Binary::from(b"test".as_ref()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b"test".as_ref()).as_ref(), b"test");
         assert_eq!(Binary::from_slice(b"test".as_ref()).len(), 4);
-        assert_eq!(Binary::from_slice(b"test".as_ref()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from_slice(b"test".as_ref()).as_ref(), b"test");
     }
 
     #[test]
     fn test_vec() {
         assert_eq!(Binary::from(Vec::from("test")).len(), 4);
-        assert_eq!(Binary::from(Vec::from("test")).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(Vec::from("test")).as_ref(), b"test");
     }
 
     #[test]
     fn test_bytes() {
         assert_eq!(Binary::from(Bytes::from("test")).len(), 4);
-        assert_eq!(Binary::from(Bytes::from("test")).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(Bytes::from("test")).as_ref(), b"test");
     }
 
     #[test]
     fn test_ref_string() {
         let b = Rc::new("test".to_owned());
         assert_eq!(Binary::from(&b).len(), 4);
-        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).as_ref(), b"test");
     }
 
     #[test]
     fn test_rc_string() {
         let b = Rc::new("test".to_owned());
         assert_eq!(Binary::from(b.clone()).len(), 4);
-        assert_eq!(Binary::from(b.clone()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b.clone()).as_ref(), b"test");
         assert_eq!(Binary::from(&b).len(), 4);
-        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).as_ref(), b"test");
     }
 
     #[test]
     fn test_arc_string() {
         let b = Arc::new("test".to_owned());
         assert_eq!(Binary::from(b.clone()).len(), 4);
-        assert_eq!(Binary::from(b.clone()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b.clone()).as_ref(), b"test");
         assert_eq!(Binary::from(&b).len(), 4);
-        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).as_ref(), b"test");
     }
 
     #[test]
     fn test_string() {
         let b = "test".to_owned();
         assert_eq!(Binary::from(b.clone()).len(), 4);
-        assert_eq!(Binary::from(b.clone()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b.clone()).as_ref(), b"test");
         assert_eq!(Binary::from(&b).len(), 4);
-        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).as_ref(), b"test");
+    }
+
+    #[test]
+    fn test_shared_vec() {
+        let b = Arc::new(Vec::from(&b"test"[..]));
+        assert_eq!(Binary::from(b.clone()).len(), 4);
+        assert_eq!(Binary::from(b.clone()).as_ref(), &b"test"[..]);
+        assert_eq!(Binary::from(&b).len(), 4);
+        assert_eq!(Binary::from(&b).as_ref(), &b"test"[..]);
     }
 
     #[test]
     fn test_bytes_mut() {
-        let b =  BytesMut::from("test");
+        let b = BytesMut::from("test");
         assert_eq!(Binary::from(b.clone()).len(), 4);
-        assert_eq!(Binary::from(b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b).as_ref(), b"test");
     }
 
     #[test]

src/client/mod.rs

@@ -0,0 +1,118 @@
+//! Http client api
+//!
+//! ```rust
+//! # extern crate actix;
+//! # extern crate actix_web;
+//! # extern crate futures;
+//! # use futures::Future;
+//! use actix_web::client;
+//!
+//! fn main() {
+//!     let sys = actix::System::new("test");
+//!
+//!     actix::Arbiter::handle().spawn({
+//!         client::get("http://www.rust-lang.org")   // <- Create request builder
+//!             .header("User-Agent", "Actix-web")
+//!             .finish().unwrap()
+//!             .send()                               // <- Send http request
+//!             .map_err(|_| ())
+//!             .and_then(|response| {                // <- server http response
+//!                 println!("Response: {:?}", response);
+//! #               actix::Arbiter::system().do_send(actix::msgs::SystemExit(0));
+//!                 Ok(())
+//!             })
+//!     });
+//!
+//!     sys.run();
+//! }
+//! ```
+mod connector;
+mod parser;
+mod pipeline;
+mod request;
+mod response;
+mod writer;
+
+pub use self::connector::{ClientConnector, ClientConnectorError, ClientConnectorStats,
+                          Connect, Connection, Pause, Resume};
+pub(crate) use self::parser::{HttpResponseParser, HttpResponseParserError};
+pub use self::pipeline::{SendRequest, SendRequestError};
+pub use self::request::{ClientRequest, ClientRequestBuilder};
+pub use self::response::ClientResponse;
+pub(crate) use self::writer::HttpClientWriter;
+
+use error::ResponseError;
+use http::Method;
+use httpresponse::HttpResponse;
+
+/// Convert `SendRequestError` to a `HttpResponse`
+impl ResponseError for SendRequestError {
+    fn error_response(&self) -> HttpResponse {
+        match *self {
+            SendRequestError::Connector(_) => HttpResponse::BadGateway(),
+            _ => HttpResponse::InternalServerError(),
+        }.into()
+    }
+}
+
+/// Create request builder for `GET` requests
+///
+/// ```rust
+/// # extern crate actix;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # use futures::Future;
+/// use actix_web::client;
+///
+/// fn main() {
+///     let sys = actix::System::new("test");
+///
+///     actix::Arbiter::handle().spawn({
+///         client::get("http://www.rust-lang.org")   // <- Create request builder
+///             .header("User-Agent", "Actix-web")
+///             .finish().unwrap()
+///             .send()                               // <- Send http request
+///             .map_err(|_| ())
+///             .and_then(|response| {  // <- server http response
+///                 println!("Response: {:?}", response);
+/// #               actix::Arbiter::system().do_send(actix::msgs::SystemExit(0));
+///                 Ok(())
+///             })
+///     });
+///
+///     sys.run();
+/// }
+/// ```
+pub fn get<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::GET).uri(uri);
+    builder
+}
+
+/// Create request builder for `HEAD` requests
+pub fn head<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::HEAD).uri(uri);
+    builder
+}
+
+/// Create request builder for `POST` requests
+pub fn post<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::POST).uri(uri);
+    builder
+}
+
+/// Create request builder for `PUT` requests
+pub fn put<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::PUT).uri(uri);
+    builder
+}
+
+/// Create request builder for `DELETE` requests
+pub fn delete<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::DELETE).uri(uri);
+    builder
+}

src/client/parser.rs

@@ -0,0 +1,219 @@
+use bytes::{Bytes, BytesMut};
+use futures::{Async, Poll};
+use http::header::{self, HeaderName, HeaderValue};
+use http::{HeaderMap, HttpTryFrom, StatusCode, Version};
+use httparse;
+use std::mem;
+
+use error::{ParseError, PayloadError};
+
+use server::h1decoder::EncodingDecoder;
+use server::{utils, IoStream};
+
+use super::response::ClientMessage;
+use super::ClientResponse;
+
+const MAX_BUFFER_SIZE: usize = 131_072;
+const MAX_HEADERS: usize = 96;
+
+#[derive(Default)]
+pub struct HttpResponseParser {
+    decoder: Option<EncodingDecoder>,
+}
+
+#[derive(Debug, Fail)]
+pub enum HttpResponseParserError {
+    /// Server disconnected
+    #[fail(display = "Server disconnected")]
+    Disconnect,
+    #[fail(display = "{}", _0)]
+    Error(#[cause] ParseError),
+}
+
+impl HttpResponseParser {
+    pub fn parse<T>(
+        &mut self, io: &mut T, buf: &mut BytesMut,
+    ) -> Poll<ClientResponse, HttpResponseParserError>
+    where
+        T: IoStream,
+    {
+        // if buf is empty parse_message will always return NotReady, let's avoid that
+        if buf.is_empty() {
+            match utils::read_from_io(io, buf) {
+                Ok(Async::Ready(0)) => return Err(HttpResponseParserError::Disconnect),
+                Ok(Async::Ready(_)) => (),
+                Ok(Async::NotReady) => return Ok(Async::NotReady),
+                Err(err) => return Err(HttpResponseParserError::Error(err.into())),
+            }
+        }
+
+        loop {
+            match HttpResponseParser::parse_message(buf)
+                .map_err(HttpResponseParserError::Error)?
+            {
+                Async::Ready((msg, decoder)) => {
+                    self.decoder = decoder;
+                    return Ok(Async::Ready(msg));
+                }
+                Async::NotReady => {
+                    if buf.capacity() >= MAX_BUFFER_SIZE {
+                        return Err(HttpResponseParserError::Error(ParseError::TooLarge));
+                    }
+                    match utils::read_from_io(io, buf) {
+                        Ok(Async::Ready(0)) => {
+                            return Err(HttpResponseParserError::Disconnect)
+                        }
+                        Ok(Async::Ready(_)) => (),
+                        Ok(Async::NotReady) => return Ok(Async::NotReady),
+                        Err(err) => {
+                            return Err(HttpResponseParserError::Error(err.into()))
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn parse_payload<T>(
+        &mut self, io: &mut T, buf: &mut BytesMut,
+    ) -> Poll<Option<Bytes>, PayloadError>
+    where
+        T: IoStream,
+    {
+        if self.decoder.is_some() {
+            loop {
+                // read payload
+                let (not_ready, stream_finished) = match utils::read_from_io(io, buf) {
+                    Ok(Async::Ready(0)) => (false, true),
+                    Err(err) => return Err(err.into()),
+                    Ok(Async::NotReady) => (true, false),
+                    _ => (false, false),
+                };
+
+                match self.decoder.as_mut().unwrap().decode(buf) {
+                    Ok(Async::Ready(Some(b))) => return Ok(Async::Ready(Some(b))),
+                    Ok(Async::Ready(None)) => {
+                        self.decoder.take();
+                        return Ok(Async::Ready(None));
+                    }
+                    Ok(Async::NotReady) => {
+                        if not_ready {
+                            return Ok(Async::NotReady);
+                        }
+                        if stream_finished {
+                            return Err(PayloadError::Incomplete);
+                        }
+                    }
+                    Err(err) => return Err(err.into()),
+                }
+            }
+        } else {
+            Ok(Async::Ready(None))
+        }
+    }
+
+    fn parse_message(
+        buf: &mut BytesMut,
+    ) -> Poll<(ClientResponse, Option<EncodingDecoder>), ParseError> {
+        // Parse http message
+        let bytes_ptr = buf.as_ref().as_ptr() as usize;
+        let mut headers: [httparse::Header; MAX_HEADERS] =
+            unsafe { mem::uninitialized() };
+
+        let (len, version, status, headers_len) = {
+            let b = unsafe {
+                let b: &[u8] = buf;
+                &*(b as *const _)
+            };
+            let mut resp = httparse::Response::new(&mut headers);
+            match resp.parse(b)? {
+                httparse::Status::Complete(len) => {
+                    let version = if resp.version.unwrap_or(1) == 1 {
+                        Version::HTTP_11
+                    } else {
+                        Version::HTTP_10
+                    };
+                    let status = StatusCode::from_u16(resp.code.unwrap())
+                        .map_err(|_| ParseError::Status)?;
+
+                    (len, version, status, resp.headers.len())
+                }
+                httparse::Status::Partial => return Ok(Async::NotReady),
+            }
+        };
+
+        let slice = buf.split_to(len).freeze();
+
+        // convert headers
+        let mut hdrs = HeaderMap::new();
+        for header in headers[..headers_len].iter() {
+            if let Ok(name) = HeaderName::try_from(header.name) {
+                let v_start = header.value.as_ptr() as usize - bytes_ptr;
+                let v_end = v_start + header.value.len();
+                let value = unsafe {
+                    HeaderValue::from_shared_unchecked(slice.slice(v_start, v_end))
+                };
+                hdrs.append(name, value);
+            } else {
+                return Err(ParseError::Header);
+            }
+        }
+
+        let decoder = if status == StatusCode::SWITCHING_PROTOCOLS {
+            Some(EncodingDecoder::eof())
+        } else if let Some(len) = hdrs.get(header::CONTENT_LENGTH) {
+            // Content-Length
+            if let Ok(s) = len.to_str() {
+                if let Ok(len) = s.parse::<u64>() {
+                    Some(EncodingDecoder::length(len))
+                } else {
+                    debug!("illegal Content-Length: {:?}", len);
+                    return Err(ParseError::Header);
+                }
+            } else {
+                debug!("illegal Content-Length: {:?}", len);
+                return Err(ParseError::Header);
+            }
+        } else if chunked(&hdrs)? {
+            // Chunked encoding
+            Some(EncodingDecoder::chunked())
+        } else {
+            None
+        };
+
+        if let Some(decoder) = decoder {
+            Ok(Async::Ready((
+                ClientResponse::new(ClientMessage {
+                    status,
+                    version,
+                    headers: hdrs,
+                    cookies: None,
+                }),
+                Some(decoder),
+            )))
+        } else {
+            Ok(Async::Ready((
+                ClientResponse::new(ClientMessage {
+                    status,
+                    version,
+                    headers: hdrs,
+                    cookies: None,
+                }),
+                None,
+            )))
+        }
+    }
+}
+
+/// Check if request has chunked transfer encoding
+pub fn chunked(headers: &HeaderMap) -> Result<bool, ParseError> {
+    if let Some(encodings) = headers.get(header::TRANSFER_ENCODING) {
+        if let Ok(s) = encodings.to_str() {
+            Ok(s.to_lowercase().contains("chunked"))
+        } else {
+            Err(ParseError::Header)
+        }
+    } else {
+        Ok(false)
+    }
+}

src/client/pipeline.rs

@@ -0,0 +1,507 @@
+use bytes::{Bytes, BytesMut};
+use futures::unsync::oneshot;
+use futures::{Async, Future, Poll};
+use http::header::CONTENT_ENCODING;
+use std::time::Duration;
+use std::{io, mem};
+use tokio_core::reactor::Timeout;
+
+use actix::prelude::*;
+
+use super::HttpClientWriter;
+use super::{ClientConnector, ClientConnectorError, Connect, Connection};
+use super::{ClientRequest, ClientResponse};
+use super::{HttpResponseParser, HttpResponseParserError};
+use body::{Body, BodyStream};
+use context::{ActorHttpContext, Frame};
+use error::Error;
+use error::PayloadError;
+use header::ContentEncoding;
+use httpmessage::HttpMessage;
+use server::encoding::PayloadStream;
+use server::shared::SharedBytes;
+use server::WriterState;
+
+/// A set of errors that can occur during request sending and response reading
+#[derive(Fail, Debug)]
+pub enum SendRequestError {
+    /// Response took too long
+    #[fail(display = "Timeout while waiting for response")]
+    Timeout,
+    /// Failed to connect to host
+    #[fail(display = "Failed to connect to host: {}", _0)]
+    Connector(#[cause] ClientConnectorError),
+    /// Error parsing response
+    #[fail(display = "{}", _0)]
+    ParseError(#[cause] HttpResponseParserError),
+    /// Error reading response payload
+    #[fail(display = "Error reading response payload: {}", _0)]
+    Io(#[cause] io::Error),
+}
+
+impl From<io::Error> for SendRequestError {
+    fn from(err: io::Error) -> SendRequestError {
+        SendRequestError::Io(err)
+    }
+}
+
+impl From<ClientConnectorError> for SendRequestError {
+    fn from(err: ClientConnectorError) -> SendRequestError {
+        match err {
+            ClientConnectorError::Timeout => SendRequestError::Timeout,
+            _ => SendRequestError::Connector(err),
+        }
+    }
+}
+
+enum State {
+    New,
+    Connect(actix::dev::Request<Unsync, ClientConnector, Connect>),
+    Connection(Connection),
+    Send(Box<Pipeline>),
+    None,
+}
+
+/// `SendRequest` is a `Future` which represents an asynchronous
+/// request sending process.
+#[must_use = "SendRequest does nothing unless polled"]
+pub struct SendRequest {
+    req: ClientRequest,
+    state: State,
+    conn: Addr<Unsync, ClientConnector>,
+    conn_timeout: Duration,
+    wait_timeout: Duration,
+    timeout: Option<Timeout>,
+}
+
+impl SendRequest {
+    pub(crate) fn new(req: ClientRequest) -> SendRequest {
+        SendRequest::with_connector(req, ClientConnector::from_registry())
+    }
+
+    pub(crate) fn with_connector(
+        req: ClientRequest, conn: Addr<Unsync, ClientConnector>,
+    ) -> SendRequest {
+        SendRequest {
+            req,
+            conn,
+            state: State::New,
+            timeout: None,
+            wait_timeout: Duration::from_secs(5),
+            conn_timeout: Duration::from_secs(1),
+        }
+    }
+
+    pub(crate) fn with_connection(req: ClientRequest, conn: Connection) -> SendRequest {
+        SendRequest {
+            req,
+            state: State::Connection(conn),
+            conn: ClientConnector::from_registry(),
+            timeout: None,
+            wait_timeout: Duration::from_secs(5),
+            conn_timeout: Duration::from_secs(1),
+        }
+    }
+
+    /// Set request timeout
+    ///
+    /// Request timeout is the total time before a response must be received.
+    /// Default value is 5 seconds.
+    pub fn timeout(mut self, timeout: Duration) -> Self {
+        self.timeout = Some(Timeout::new(timeout, Arbiter::handle()).unwrap());
+        self
+    }
+
+    /// Set connection timeout
+    ///
+    /// Connection timeout includes resolving hostname and actual connection to
+    /// the host.
+    /// Default value is 1 second.
+    pub fn conn_timeout(mut self, timeout: Duration) -> Self {
+        self.conn_timeout = timeout;
+        self
+    }
+
+    /// Set wait timeout
+    ///
+    /// If connections pool limits are enabled, wait time indicates max time
+    /// to wait for available connection. Default value is 5 seconds.
+    pub fn wait_timeout(mut self, timeout: Duration) -> Self {
+        self.wait_timeout = timeout;
+        self
+    }
+}
+
+impl Future for SendRequest {
+    type Item = ClientResponse;
+    type Error = SendRequestError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        loop {
+            let state = mem::replace(&mut self.state, State::None);
+
+            match state {
+                State::New => {
+                    self.state = State::Connect(self.conn.send(Connect {
+                        uri: self.req.uri().clone(),
+                        wait_timeout: self.wait_timeout,
+                        conn_timeout: self.conn_timeout,
+                    }))
+                }
+                State::Connect(mut conn) => match conn.poll() {
+                    Ok(Async::NotReady) => {
+                        self.state = State::Connect(conn);
+                        return Ok(Async::NotReady);
+                    }
+                    Ok(Async::Ready(result)) => match result {
+                        Ok(stream) => self.state = State::Connection(stream),
+                        Err(err) => return Err(err.into()),
+                    },
+                    Err(_) => {
+                        return Err(SendRequestError::Connector(
+                            ClientConnectorError::Disconnected,
+                        ))
+                    }
+                },
+                State::Connection(conn) => {
+                    let mut writer = HttpClientWriter::new(SharedBytes::default());
+                    writer.start(&mut self.req)?;
+
+                    let body = match self.req.replace_body(Body::Empty) {
+                        Body::Streaming(stream) => IoBody::Payload(stream),
+                        Body::Actor(ctx) => IoBody::Actor(ctx),
+                        _ => IoBody::Done,
+                    };
+
+                    let timeout = self.timeout.take().unwrap_or_else(|| {
+                        Timeout::new(Duration::from_secs(5), Arbiter::handle()).unwrap()
+                    });
+
+                    let pl = Box::new(Pipeline {
+                        body,
+                        writer,
+                        conn: Some(conn),
+                        parser: Some(HttpResponseParser::default()),
+                        parser_buf: BytesMut::new(),
+                        disconnected: false,
+                        body_completed: false,
+                        drain: None,
+                        decompress: None,
+                        should_decompress: self.req.response_decompress(),
+                        write_state: RunningState::Running,
+                        timeout: Some(timeout),
+                    });
+                    self.state = State::Send(pl);
+                }
+                State::Send(mut pl) => {
+                    pl.poll_write().map_err(|e| {
+                        io::Error::new(io::ErrorKind::Other, format!("{}", e).as_str())
+                    })?;
+
+                    match pl.parse() {
+                        Ok(Async::Ready(mut resp)) => {
+                            resp.set_pipeline(pl);
+                            return Ok(Async::Ready(resp));
+                        }
+                        Ok(Async::NotReady) => {
+                            self.state = State::Send(pl);
+                            return Ok(Async::NotReady);
+                        }
+                        Err(err) => return Err(SendRequestError::ParseError(err)),
+                    }
+                }
+                State::None => unreachable!(),
+            }
+        }
+    }
+}
+
+pub(crate) struct Pipeline {
+    body: IoBody,
+    body_completed: bool,
+    conn: Option<Connection>,
+    writer: HttpClientWriter,
+    parser: Option<HttpResponseParser>,
+    parser_buf: BytesMut,
+    disconnected: bool,
+    drain: Option<oneshot::Sender<()>>,
+    decompress: Option<PayloadStream>,
+    should_decompress: bool,
+    write_state: RunningState,
+    timeout: Option<Timeout>,
+}
+
+enum IoBody {
+    Payload(BodyStream),
+    Actor(Box<ActorHttpContext>),
+    Done,
+}
+
+#[derive(Debug, PartialEq)]
+enum RunningState {
+    Running,
+    Paused,
+    Done,
+}
+
+impl RunningState {
+    #[inline]
+    fn pause(&mut self) {
+        if *self != RunningState::Done {
+            *self = RunningState::Paused
+        }
+    }
+    #[inline]
+    fn resume(&mut self) {
+        if *self != RunningState::Done {
+            *self = RunningState::Running
+        }
+    }
+}
+
+impl Pipeline {
+    fn release_conn(&mut self) {
+        if let Some(conn) = self.conn.take() {
+            conn.release()
+        }
+    }
+
+    #[inline]
+    fn parse(&mut self) -> Poll<ClientResponse, HttpResponseParserError> {
+        if let Some(ref mut conn) = self.conn {
+            match self.parser
+                .as_mut()
+                .unwrap()
+                .parse(conn, &mut self.parser_buf)
+            {
+                Ok(Async::Ready(resp)) => {
+                    // check content-encoding
+                    if self.should_decompress {
+                        if let Some(enc) = resp.headers().get(CONTENT_ENCODING) {
+                            if let Ok(enc) = enc.to_str() {
+                                match ContentEncoding::from(enc) {
+                                    ContentEncoding::Auto
+                                    | ContentEncoding::Identity => (),
+                                    enc => {
+                                        self.decompress = Some(PayloadStream::new(enc))
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    Ok(Async::Ready(resp))
+                }
+                val => val,
+            }
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+
+    #[inline]
+    pub fn poll(&mut self) -> Poll<Option<Bytes>, PayloadError> {
+        if self.conn.is_none() {
+            return Ok(Async::Ready(None));
+        }
+        let conn: &mut Connection =
+            unsafe { &mut *(self.conn.as_mut().unwrap() as *mut _) };
+
+        let mut need_run = false;
+
+        // need write?
+        match self.poll_write()
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("{}", e)))?
+        {
+            Async::NotReady => need_run = true,
+            Async::Ready(_) => {
+                let _ = self.poll_timeout().map_err(|e| {
+                    io::Error::new(io::ErrorKind::Other, format!("{}", e))
+                })?;
+            }
+        }
+
+        // need read?
+        if self.parser.is_some() {
+            loop {
+                match self.parser
+                    .as_mut()
+                    .unwrap()
+                    .parse_payload(conn, &mut self.parser_buf)?
+                {
+                    Async::Ready(Some(b)) => {
+                        if let Some(ref mut decompress) = self.decompress {
+                            match decompress.feed_data(b) {
+                                Ok(Some(b)) => return Ok(Async::Ready(Some(b))),
+                                Ok(None) => return Ok(Async::NotReady),
+                                Err(ref err)
+                                    if err.kind() == io::ErrorKind::WouldBlock =>
+                                {
+                                    continue
+                                }
+                                Err(err) => return Err(err.into()),
+                            }
+                        } else {
+                            return Ok(Async::Ready(Some(b)));
+                        }
+                    }
+                    Async::Ready(None) => {
+                        let _ = self.parser.take();
+                        break;
+                    }
+                    Async::NotReady => return Ok(Async::NotReady),
+                }
+            }
+        }
+
+        // eof
+        if let Some(mut decompress) = self.decompress.take() {
+            let res = decompress.feed_eof();
+            if let Some(b) = res? {
+                self.release_conn();
+                return Ok(Async::Ready(Some(b)));
+            }
+        }
+
+        if need_run {
+            Ok(Async::NotReady)
+        } else {
+            self.release_conn();
+            Ok(Async::Ready(None))
+        }
+    }
+
+    fn poll_timeout(&mut self) -> Poll<(), SendRequestError> {
+        if self.timeout.is_some() {
+            match self.timeout.as_mut().unwrap().poll() {
+                Ok(Async::Ready(())) => Err(SendRequestError::Timeout),
+                Ok(Async::NotReady) => Ok(Async::NotReady),
+                Err(_) => unreachable!(),
+            }
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+
+    #[inline]
+    fn poll_write(&mut self) -> Poll<(), Error> {
+        if self.write_state == RunningState::Done || self.conn.is_none() {
+            return Ok(Async::Ready(()));
+        }
+
+        let mut done = false;
+        if self.drain.is_none() && self.write_state != RunningState::Paused {
+            'outter: loop {
+                let result = match mem::replace(&mut self.body, IoBody::Done) {
+                    IoBody::Payload(mut body) => match body.poll()? {
+                        Async::Ready(None) => {
+                            self.writer.write_eof()?;
+                            self.body_completed = true;
+                            break;
+                        }
+                        Async::Ready(Some(chunk)) => {
+                            self.body = IoBody::Payload(body);
+                            self.writer.write(chunk.into())?
+                        }
+                        Async::NotReady => {
+                            done = true;
+                            self.body = IoBody::Payload(body);
+                            break;
+                        }
+                    },
+                    IoBody::Actor(mut ctx) => {
+                        if self.disconnected {
+                            ctx.disconnected();
+                        }
+                        match ctx.poll()? {
+                            Async::Ready(Some(vec)) => {
+                                if vec.is_empty() {
+                                    self.body = IoBody::Actor(ctx);
+                                    break;
+                                }
+                                let mut res = None;
+                                for frame in vec {
+                                    match frame {
+                                        Frame::Chunk(None) => {
+                                            self.body_completed = true;
+                                            self.writer.write_eof()?;
+                                            break 'outter;
+                                        }
+                                        Frame::Chunk(Some(chunk)) => {
+                                            res = Some(self.writer.write(chunk)?)
+                                        }
+                                        Frame::Drain(fut) => self.drain = Some(fut),
+                                    }
+                                }
+                                self.body = IoBody::Actor(ctx);
+                                if self.drain.is_some() {
+                                    self.write_state.resume();
+                                    break;
+                                }
+                                res.unwrap()
+                            }
+                            Async::Ready(None) => {
+                                done = true;
+                                break;
+                            }
+                            Async::NotReady => {
+                                done = true;
+                                self.body = IoBody::Actor(ctx);
+                                break;
+                            }
+                        }
+                    }
+                    IoBody::Done => {
+                        self.body_completed = true;
+                        done = true;
+                        break;
+                    }
+                };
+
+                match result {
+                    WriterState::Pause => {
+                        self.write_state.pause();
+                        break;
+                    }
+                    WriterState::Done => self.write_state.resume(),
+                }
+            }
+        }
+
+        // flush io but only if we need to
+        match self.writer
+            .poll_completed(self.conn.as_mut().unwrap(), false)
+        {
+            Ok(Async::Ready(_)) => {
+                if self.disconnected
+                    || (self.body_completed && self.writer.is_completed())
+                {
+                    self.write_state = RunningState::Done;
+                } else {
+                    self.write_state.resume();
+                }
+
+                // resolve drain futures
+                if let Some(tx) = self.drain.take() {
+                    let _ = tx.send(());
+                }
+                // restart io processing
+                if !done || self.write_state == RunningState::Done {
+                    self.poll_write()
+                } else {
+                    Ok(Async::NotReady)
+                }
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Err(err) => Err(err.into()),
+        }
+    }
+}
+
+impl Drop for Pipeline {
+    fn drop(&mut self) {
+        if let Some(conn) = self.conn.take() {
+            conn.close()
+        }
+    }
+}

src/client/request.rs

@@ -0,0 +1,725 @@
+use std::fmt::Write as FmtWrite;
+use std::io::Write;
+use std::time::Duration;
+use std::{fmt, mem};
+
+use actix::{Addr, Unsync};
+use bytes::{BufMut, Bytes, BytesMut};
+use cookie::{Cookie, CookieJar};
+use futures::Stream;
+use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};
+use serde::Serialize;
+use serde_json;
+use url::Url;
+
+use super::connector::{ClientConnector, Connection};
+use super::pipeline::SendRequest;
+use body::Body;
+use error::Error;
+use header::{ContentEncoding, Header, IntoHeaderValue};
+use http::header::{self, HeaderName, HeaderValue};
+use http::{uri, Error as HttpError, HeaderMap, HttpTryFrom, Method, Uri, Version};
+use httpmessage::HttpMessage;
+use httprequest::HttpRequest;
+
+/// An HTTP Client Request
+///
+/// ```rust
+/// # extern crate actix;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # use futures::Future;
+/// use actix_web::client::ClientRequest;
+///
+/// fn main() {
+///     let sys = actix::System::new("test");
+///
+///     actix::Arbiter::handle().spawn({
+///         ClientRequest::get("http://www.rust-lang.org") // <- Create request builder
+///             .header("User-Agent", "Actix-web")
+///             .finish().unwrap()
+///             .send()                                    // <- Send http request
+///             .map_err(|_| ())
+///             .and_then(|response| {  // <- server http response
+///                 println!("Response: {:?}", response);
+/// #               actix::Arbiter::system().do_send(actix::msgs::SystemExit(0));
+///                 Ok(())
+///             })
+///     });
+///
+///     sys.run();
+/// }
+/// ```
+pub struct ClientRequest {
+    uri: Uri,
+    method: Method,
+    version: Version,
+    headers: HeaderMap,
+    body: Body,
+    chunked: bool,
+    upgrade: bool,
+    timeout: Option<Duration>,
+    encoding: ContentEncoding,
+    response_decompress: bool,
+    buffer_capacity: usize,
+    conn: ConnectionType,
+}
+
+enum ConnectionType {
+    Default,
+    Connector(Addr<Unsync, ClientConnector>),
+    Connection(Connection),
+}
+
+impl Default for ClientRequest {
+    fn default() -> ClientRequest {
+        ClientRequest {
+            uri: Uri::default(),
+            method: Method::default(),
+            version: Version::HTTP_11,
+            headers: HeaderMap::with_capacity(16),
+            body: Body::Empty,
+            chunked: false,
+            upgrade: false,
+            timeout: None,
+            encoding: ContentEncoding::Auto,
+            response_decompress: true,
+            buffer_capacity: 32_768,
+            conn: ConnectionType::Default,
+        }
+    }
+}
+
+impl ClientRequest {
+    /// Create request builder for `GET` request
+    pub fn get<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+        let mut builder = ClientRequest::build();
+        builder.method(Method::GET).uri(uri);
+        builder
+    }
+
+    /// Create request builder for `HEAD` request
+    pub fn head<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+        let mut builder = ClientRequest::build();
+        builder.method(Method::HEAD).uri(uri);
+        builder
+    }
+
+    /// Create request builder for `POST` request
+    pub fn post<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+        let mut builder = ClientRequest::build();
+        builder.method(Method::POST).uri(uri);
+        builder
+    }
+
+    /// Create request builder for `PUT` request
+    pub fn put<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+        let mut builder = ClientRequest::build();
+        builder.method(Method::PUT).uri(uri);
+        builder
+    }
+
+    /// Create request builder for `DELETE` request
+    pub fn delete<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+        let mut builder = ClientRequest::build();
+        builder.method(Method::DELETE).uri(uri);
+        builder
+    }
+}
+
+impl ClientRequest {
+    /// Create client request builder
+    pub fn build() -> ClientRequestBuilder {
+        ClientRequestBuilder {
+            request: Some(ClientRequest::default()),
+            err: None,
+            cookies: None,
+            default_headers: true,
+        }
+    }
+
+    /// Create client request builder
+    pub fn build_from<T: Into<ClientRequestBuilder>>(source: T) -> ClientRequestBuilder {
+        source.into()
+    }
+
+    /// Get the request URI
+    #[inline]
+    pub fn uri(&self) -> &Uri {
+        &self.uri
+    }
+
+    /// Set client request URI
+    #[inline]
+    pub fn set_uri(&mut self, uri: Uri) {
+        self.uri = uri
+    }
+
+    /// Get the request method
+    #[inline]
+    pub fn method(&self) -> &Method {
+        &self.method
+    }
+
+    /// Set HTTP `Method` for the request
+    #[inline]
+    pub fn set_method(&mut self, method: Method) {
+        self.method = method
+    }
+
+    /// Get HTTP version for the request
+    #[inline]
+    pub fn version(&self) -> Version {
+        self.version
+    }
+
+    /// Set http `Version` for the request
+    #[inline]
+    pub fn set_version(&mut self, version: Version) {
+        self.version = version
+    }
+
+    /// Get the headers from the request
+    #[inline]
+    pub fn headers(&self) -> &HeaderMap {
+        &self.headers
+    }
+
+    /// Get a mutable reference to the headers
+    #[inline]
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
+        &mut self.headers
+    }
+
+    /// is chunked encoding enabled
+    #[inline]
+    pub fn chunked(&self) -> bool {
+        self.chunked
+    }
+
+    /// is upgrade request
+    #[inline]
+    pub fn upgrade(&self) -> bool {
+        self.upgrade
+    }
+
+    /// Content encoding
+    #[inline]
+    pub fn content_encoding(&self) -> ContentEncoding {
+        self.encoding
+    }
+
+    /// Decompress response payload
+    #[inline]
+    pub fn response_decompress(&self) -> bool {
+        self.response_decompress
+    }
+
+    /// Requested write buffer capacity
+    pub fn write_buffer_capacity(&self) -> usize {
+        self.buffer_capacity
+    }
+
+    /// Get body of this response
+    #[inline]
+    pub fn body(&self) -> &Body {
+        &self.body
+    }
+
+    /// Set a body
+    pub fn set_body<B: Into<Body>>(&mut self, body: B) {
+        self.body = body.into();
+    }
+
+    /// Extract body, replace it with `Empty`
+    pub(crate) fn replace_body(&mut self, body: Body) -> Body {
+        mem::replace(&mut self.body, body)
+    }
+
+    /// Send request
+    ///
+    /// This method returns a future that resolves to a ClientResponse
+    pub fn send(mut self) -> SendRequest {
+        let timeout = self.timeout.take();
+        let send = match mem::replace(&mut self.conn, ConnectionType::Default) {
+            ConnectionType::Default => SendRequest::new(self),
+            ConnectionType::Connector(conn) => SendRequest::with_connector(self, conn),
+            ConnectionType::Connection(conn) => SendRequest::with_connection(self, conn),
+        };
+        if let Some(timeout) = timeout {
+            send.timeout(timeout)
+        } else {
+            send
+        }
+    }
+}
+
+impl fmt::Debug for ClientRequest {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let res = writeln!(
+            f,
+            "\nClientRequest {:?} {}:{}",
+            self.version, self.method, self.uri
+        );
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in self.headers.iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
+        }
+        res
+    }
+}
+
+/// An HTTP Client request builder
+///
+/// This type can be used to construct an instance of `ClientRequest` through a
+/// builder-like pattern.
+pub struct ClientRequestBuilder {
+    request: Option<ClientRequest>,
+    err: Option<HttpError>,
+    cookies: Option<CookieJar>,
+    default_headers: bool,
+}
+
+impl ClientRequestBuilder {
+    /// Set HTTP URI of request.
+    #[inline]
+    pub fn uri<U: AsRef<str>>(&mut self, uri: U) -> &mut Self {
+        match Url::parse(uri.as_ref()) {
+            Ok(url) => self._uri(url.as_str()),
+            Err(_) => self._uri(uri.as_ref()),
+        }
+    }
+
+    fn _uri(&mut self, url: &str) -> &mut Self {
+        match Uri::try_from(url) {
+            Ok(uri) => {
+                // set request host header
+                if let Some(host) = uri.host() {
+                    self.set_header(header::HOST, host);
+                }
+                if let Some(parts) = parts(&mut self.request, &self.err) {
+                    parts.uri = uri;
+                }
+            }
+            Err(e) => self.err = Some(e.into()),
+        }
+        self
+    }
+
+    /// Set HTTP method of this request.
+    #[inline]
+    pub fn method(&mut self, method: Method) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.method = method;
+        }
+        self
+    }
+
+    /// Set HTTP method of this request.
+    #[inline]
+    pub fn get_method(&mut self) -> &Method {
+        let parts =
+            parts(&mut self.request, &self.err).expect("cannot reuse request builder");
+        &parts.method
+    }
+
+    /// Set HTTP version of this request.
+    ///
+    /// By default requests's HTTP version depends on network stream
+    #[inline]
+    pub fn version(&mut self, version: Version) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.version = version;
+        }
+        self
+    }
+
+    /// Set a header.
+    ///
+    /// ```rust
+    /// # extern crate mime;
+    /// # extern crate actix_web;
+    /// # use actix_web::client::*;
+    /// #
+    /// use actix_web::{client, http};
+    ///
+    /// fn main() {
+    ///     let req = client::ClientRequest::build()
+    ///         .set(http::header::Date::now())
+    ///         .set(http::header::ContentType(mime::TEXT_HTML))
+    ///         .finish().unwrap();
+    /// }
+    /// ```
+    #[doc(hidden)]
+    pub fn set<H: Header>(&mut self, hdr: H) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            match hdr.try_into() {
+                Ok(value) => {
+                    parts.headers.insert(H::name(), value);
+                }
+                Err(e) => self.err = Some(e.into()),
+            }
+        }
+        self
+    }
+
+    /// Append a header.
+    ///
+    /// Header gets appended to existing header.
+    /// To override header use `set_header()` method.
+    ///
+    /// ```rust
+    /// # extern crate http;
+    /// # extern crate actix_web;
+    /// # use actix_web::client::*;
+    /// #
+    /// use http::header;
+    ///
+    /// fn main() {
+    ///     let req = ClientRequest::build()
+    ///         .header("X-TEST", "value")
+    ///         .header(header::CONTENT_TYPE, "application/json")
+    ///         .finish().unwrap();
+    /// }
+    /// ```
+    pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
+    where
+        HeaderName: HttpTryFrom<K>,
+        V: IntoHeaderValue,
+    {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            match HeaderName::try_from(key) {
+                Ok(key) => match value.try_into() {
+                    Ok(value) => {
+                        parts.headers.append(key, value);
+                    }
+                    Err(e) => self.err = Some(e.into()),
+                },
+                Err(e) => self.err = Some(e.into()),
+            };
+        }
+        self
+    }
+
+    /// Set a header.
+    pub fn set_header<K, V>(&mut self, key: K, value: V) -> &mut Self
+    where
+        HeaderName: HttpTryFrom<K>,
+        V: IntoHeaderValue,
+    {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            match HeaderName::try_from(key) {
+                Ok(key) => match value.try_into() {
+                    Ok(value) => {
+                        parts.headers.insert(key, value);
+                    }
+                    Err(e) => self.err = Some(e.into()),
+                },
+                Err(e) => self.err = Some(e.into()),
+            };
+        }
+        self
+    }
+
+    /// Set content encoding.
+    ///
+    /// By default `ContentEncoding::Identity` is used.
+    #[inline]
+    pub fn content_encoding(&mut self, enc: ContentEncoding) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.encoding = enc;
+        }
+        self
+    }
+
+    /// Enables automatic chunked transfer encoding
+    #[inline]
+    pub fn chunked(&mut self) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.chunked = true;
+        }
+        self
+    }
+
+    /// Enable connection upgrade
+    #[inline]
+    pub fn upgrade(&mut self) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.upgrade = true;
+        }
+        self
+    }
+
+    /// Set request's content type
+    #[inline]
+    pub fn content_type<V>(&mut self, value: V) -> &mut Self
+    where
+        HeaderValue: HttpTryFrom<V>,
+    {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            match HeaderValue::try_from(value) {
+                Ok(value) => {
+                    parts.headers.insert(header::CONTENT_TYPE, value);
+                }
+                Err(e) => self.err = Some(e.into()),
+            };
+        }
+        self
+    }
+
+    /// Set content length
+    #[inline]
+    pub fn content_length(&mut self, len: u64) -> &mut Self {
+        let mut wrt = BytesMut::new().writer();
+        let _ = write!(wrt, "{}", len);
+        self.header(header::CONTENT_LENGTH, wrt.get_mut().take().freeze())
+    }
+
+    /// Set a cookie
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::{client, http};
+    ///
+    /// fn main() {
+    ///     let req = client::ClientRequest::build()
+    ///         .cookie(
+    ///             http::Cookie::build("name", "value")
+    ///                 .domain("www.rust-lang.org")
+    ///                 .path("/")
+    ///                 .secure(true)
+    ///                 .http_only(true)
+    ///                 .finish())
+    ///         .finish().unwrap();
+    /// }
+    /// ```
+    pub fn cookie<'c>(&mut self, cookie: Cookie<'c>) -> &mut Self {
+        if self.cookies.is_none() {
+            let mut jar = CookieJar::new();
+            jar.add(cookie.into_owned());
+            self.cookies = Some(jar)
+        } else {
+            self.cookies
+                .as_mut()
+                .unwrap()
+                .add(cookie.into_owned());
+        }
+        self
+    }
+
+    /// Do not add default request headers.
+    /// By default `Accept-Encoding` header is set.
+    pub fn no_default_headers(&mut self) -> &mut Self {
+        self.default_headers = false;
+        self
+    }
+
+    /// Disable automatic decompress response body
+    pub fn disable_decompress(&mut self) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.response_decompress = false;
+        }
+        self
+    }
+
+    /// Set write buffer capacity
+    ///
+    /// Default buffer capacity is 32kb
+    pub fn write_buffer_capacity(&mut self, cap: usize) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.buffer_capacity = cap;
+        }
+        self
+    }
+
+    /// Set request timeout
+    ///
+    /// Request timeout is a total time before response should be received.
+    /// Default value is 5 seconds.
+    pub fn timeout(&mut self, timeout: Duration) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.timeout = Some(timeout);
+        }
+        self
+    }
+
+    /// Send request using custom connector
+    pub fn with_connector(&mut self, conn: Addr<Unsync, ClientConnector>) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.conn = ConnectionType::Connector(conn);
+        }
+        self
+    }
+
+    /// Send request using existing `Connection`
+    pub fn with_connection(&mut self, conn: Connection) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.conn = ConnectionType::Connection(conn);
+        }
+        self
+    }
+
+    /// This method calls provided closure with builder reference if
+    /// value is `true`.
+    pub fn if_true<F>(&mut self, value: bool, f: F) -> &mut Self
+    where
+        F: FnOnce(&mut ClientRequestBuilder),
+    {
+        if value {
+            f(self);
+        }
+        self
+    }
+
+    /// This method calls provided closure with builder reference if
+    /// value is `Some`.
+    pub fn if_some<T, F>(&mut self, value: Option<T>, f: F) -> &mut Self
+    where
+        F: FnOnce(T, &mut ClientRequestBuilder),
+    {
+        if let Some(val) = value {
+            f(val, self);
+        }
+        self
+    }
+
+    /// Set a body and generate `ClientRequest`.
+    ///
+    /// `ClientRequestBuilder` can not be used after this call.
+    pub fn body<B: Into<Body>>(&mut self, body: B) -> Result<ClientRequest, Error> {
+        if let Some(e) = self.err.take() {
+            return Err(e.into());
+        }
+
+        if self.default_headers {
+            // enable br only for https
+            let https = if let Some(parts) = parts(&mut self.request, &self.err) {
+                parts
+                    .uri
+                    .scheme_part()
+                    .map(|s| s == &uri::Scheme::HTTPS)
+                    .unwrap_or(true)
+            } else {
+                true
+            };
+
+            if https {
+                self.header(header::ACCEPT_ENCODING, "br, gzip, deflate");
+            } else {
+                self.header(header::ACCEPT_ENCODING, "gzip, deflate");
+            }
+        }
+
+        let mut request = self.request
+            .take()
+            .expect("cannot reuse request builder");
+
+        // set cookies
+        if let Some(ref mut jar) = self.cookies {
+            let mut cookie = String::new();
+            for c in jar.delta() {
+                let name = percent_encode(c.name().as_bytes(), USERINFO_ENCODE_SET);
+                let value = percent_encode(c.value().as_bytes(), USERINFO_ENCODE_SET);
+                let _ = write!(&mut cookie, "; {}={}", name, value);
+            }
+            request.headers.insert(
+                header::COOKIE,
+                HeaderValue::from_str(&cookie.as_str()[2..]).unwrap(),
+            );
+        }
+        request.body = body.into();
+        Ok(request)
+    }
+
+    /// Set a JSON body and generate `ClientRequest`
+    ///
+    /// `ClientRequestBuilder` can not be used after this call.
+    pub fn json<T: Serialize>(&mut self, value: T) -> Result<ClientRequest, Error> {
+        let body = serde_json::to_string(&value)?;
+
+        let contains = if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.headers.contains_key(header::CONTENT_TYPE)
+        } else {
+            true
+        };
+        if !contains {
+            self.header(header::CONTENT_TYPE, "application/json");
+        }
+
+        self.body(body)
+    }
+
+    /// Set a streaming body and generate `ClientRequest`.
+    ///
+    /// `ClientRequestBuilder` can not be used after this call.
+    pub fn streaming<S, E>(&mut self, stream: S) -> Result<ClientRequest, Error>
+    where
+        S: Stream<Item = Bytes, Error = E> + 'static,
+        E: Into<Error>,
+    {
+        self.body(Body::Streaming(Box::new(
+            stream.map_err(|e| e.into()),
+        )))
+    }
+
+    /// Set an empty body and generate `ClientRequest`
+    ///
+    /// `ClientRequestBuilder` can not be used after this call.
+    pub fn finish(&mut self) -> Result<ClientRequest, Error> {
+        self.body(Body::Empty)
+    }
+
+    /// This method construct new `ClientRequestBuilder`
+    pub fn take(&mut self) -> ClientRequestBuilder {
+        ClientRequestBuilder {
+            request: self.request.take(),
+            err: self.err.take(),
+            cookies: self.cookies.take(),
+            default_headers: self.default_headers,
+        }
+    }
+}
+
+#[inline]
+fn parts<'a>(
+    parts: &'a mut Option<ClientRequest>, err: &Option<HttpError>,
+) -> Option<&'a mut ClientRequest> {
+    if err.is_some() {
+        return None;
+    }
+    parts.as_mut()
+}
+
+impl fmt::Debug for ClientRequestBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(ref parts) = self.request {
+            let res = writeln!(
+                f,
+                "\nClientRequestBuilder {:?} {}:{}",
+                parts.version, parts.method, parts.uri
+            );
+            let _ = writeln!(f, "  headers:");
+            for (key, val) in parts.headers.iter() {
+                let _ = writeln!(f, "    {:?}: {:?}", key, val);
+            }
+            res
+        } else {
+            write!(f, "ClientRequestBuilder(Consumed)")
+        }
+    }
+}
+
+/// Create `ClientRequestBuilder` from `HttpRequest`
+///
+/// It is useful for proxy requests. This implementation
+/// copies all request headers and the method.
+impl<'a, S: 'static> From<&'a HttpRequest<S>> for ClientRequestBuilder {
+    fn from(req: &'a HttpRequest<S>) -> ClientRequestBuilder {
+        let mut builder = ClientRequest::build();
+        for (key, value) in req.headers() {
+            builder.header(key.clone(), value.clone());
+        }
+        builder.method(req.method().clone());
+        builder
+    }
+}

src/client/response.rs

@@ -0,0 +1,153 @@
+use std::cell::UnsafeCell;
+use std::rc::Rc;
+use std::{fmt, str};
+
+use bytes::Bytes;
+use cookie::Cookie;
+use futures::{Async, Poll, Stream};
+use http::header::{self, HeaderValue};
+use http::{HeaderMap, StatusCode, Version};
+
+use error::{CookieParseError, PayloadError};
+use httpmessage::HttpMessage;
+
+use super::pipeline::Pipeline;
+
+pub(crate) struct ClientMessage {
+    pub status: StatusCode,
+    pub version: Version,
+    pub headers: HeaderMap<HeaderValue>,
+    pub cookies: Option<Vec<Cookie<'static>>>,
+}
+
+impl Default for ClientMessage {
+    fn default() -> ClientMessage {
+        ClientMessage {
+            status: StatusCode::OK,
+            version: Version::HTTP_11,
+            headers: HeaderMap::with_capacity(16),
+            cookies: None,
+        }
+    }
+}
+
+/// An HTTP Client response
+pub struct ClientResponse(Rc<UnsafeCell<ClientMessage>>, Option<Box<Pipeline>>);
+
+impl HttpMessage for ClientResponse {
+    /// Get the headers from the response.
+    #[inline]
+    fn headers(&self) -> &HeaderMap {
+        &self.as_ref().headers
+    }
+}
+
+impl ClientResponse {
+    pub(crate) fn new(msg: ClientMessage) -> ClientResponse {
+        ClientResponse(Rc::new(UnsafeCell::new(msg)), None)
+    }
+
+    pub(crate) fn set_pipeline(&mut self, pl: Box<Pipeline>) {
+        self.1 = Some(pl);
+    }
+
+    #[inline]
+    fn as_ref(&self) -> &ClientMessage {
+        unsafe { &*self.0.get() }
+    }
+
+    #[inline]
+    #[cfg_attr(feature = "cargo-clippy", allow(mut_from_ref))]
+    fn as_mut(&self) -> &mut ClientMessage {
+        unsafe { &mut *self.0.get() }
+    }
+
+    /// Get the HTTP version of this response.
+    #[inline]
+    pub fn version(&self) -> Version {
+        self.as_ref().version
+    }
+
+    /// Get the status from the server.
+    #[inline]
+    pub fn status(&self) -> StatusCode {
+        self.as_ref().status
+    }
+
+    /// Load response cookies.
+    pub fn cookies(&self) -> Result<&Vec<Cookie<'static>>, CookieParseError> {
+        if self.as_ref().cookies.is_none() {
+            let msg = self.as_mut();
+            let mut cookies = Vec::new();
+            for val in msg.headers.get_all(header::SET_COOKIE).iter() {
+                let s = str::from_utf8(val.as_bytes()).map_err(CookieParseError::from)?;
+                cookies.push(Cookie::parse_encoded(s)?.into_owned());
+            }
+            msg.cookies = Some(cookies)
+        }
+        Ok(self.as_ref().cookies.as_ref().unwrap())
+    }
+
+    /// Return request cookie.
+    pub fn cookie(&self, name: &str) -> Option<&Cookie> {
+        if let Ok(cookies) = self.cookies() {
+            for cookie in cookies {
+                if cookie.name() == name {
+                    return Some(cookie);
+                }
+            }
+        }
+        None
+    }
+}
+
+impl fmt::Debug for ClientResponse {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let res = writeln!(
+            f,
+            "\nClientResponse {:?} {}",
+            self.version(),
+            self.status()
+        );
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in self.headers().iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
+        }
+        res
+    }
+}
+
+/// Future that resolves to a complete request body.
+impl Stream for ClientResponse {
+    type Item = Bytes;
+    type Error = PayloadError;
+
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        if let Some(ref mut pl) = self.1 {
+            pl.poll()
+        } else {
+            Ok(Async::Ready(None))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_debug() {
+        let resp = ClientResponse::new(ClientMessage::default());
+        resp.as_mut().headers.insert(
+            header::COOKIE,
+            HeaderValue::from_static("cookie1=value1"),
+        );
+        resp.as_mut().headers.insert(
+            header::COOKIE,
+            HeaderValue::from_static("cookie2=value2"),
+        );
+
+        let dbg = format!("{:?}", resp);
+        assert!(dbg.contains("ClientResponse"));
+    }
+}

src/client/writer.rs

@@ -0,0 +1,397 @@
+#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
+
+use std::cell::RefCell;
+use std::fmt::Write as FmtWrite;
+use std::io::{self, Write};
+
+#[cfg(feature = "brotli")]
+use brotli2::write::BrotliEncoder;
+use bytes::{BufMut, BytesMut};
+#[cfg(feature = "flate2")]
+use flate2::write::{DeflateEncoder, GzEncoder};
+#[cfg(feature = "flate2")]
+use flate2::Compression;
+use futures::{Async, Poll};
+use http::header::{HeaderValue, CONNECTION, CONTENT_ENCODING, CONTENT_LENGTH, DATE,
+                   TRANSFER_ENCODING};
+use http::{HttpTryFrom, Version};
+use time::{self, Duration};
+use tokio_io::AsyncWrite;
+
+use body::{Binary, Body};
+use header::ContentEncoding;
+use server::encoding::{ContentEncoder, TransferEncoding};
+use server::shared::SharedBytes;
+use server::WriterState;
+
+use client::ClientRequest;
+
+const AVERAGE_HEADER_SIZE: usize = 30;
+
+bitflags! {
+    struct Flags: u8 {
+        const STARTED = 0b0000_0001;
+        const UPGRADE = 0b0000_0010;
+        const KEEPALIVE = 0b0000_0100;
+        const DISCONNECTED = 0b0000_1000;
+    }
+}
+
+pub(crate) struct HttpClientWriter {
+    flags: Flags,
+    written: u64,
+    headers_size: u32,
+    buffer: SharedBytes,
+    buffer_capacity: usize,
+    encoder: ContentEncoder,
+}
+
+impl HttpClientWriter {
+    pub fn new(buffer: SharedBytes) -> HttpClientWriter {
+        let encoder = ContentEncoder::Identity(TransferEncoding::eof(buffer.clone()));
+        HttpClientWriter {
+            flags: Flags::empty(),
+            written: 0,
+            headers_size: 0,
+            buffer_capacity: 0,
+            buffer,
+            encoder,
+        }
+    }
+
+    pub fn disconnected(&mut self) {
+        self.buffer.take();
+    }
+
+    pub fn is_completed(&self) -> bool {
+        self.buffer.is_empty()
+    }
+
+    // pub fn keepalive(&self) -> bool {
+    // self.flags.contains(Flags::KEEPALIVE) &&
+    // !self.flags.contains(Flags::UPGRADE) }
+
+    fn write_to_stream<T: AsyncWrite>(
+        &mut self, stream: &mut T,
+    ) -> io::Result<WriterState> {
+        while !self.buffer.is_empty() {
+            match stream.write(self.buffer.as_ref()) {
+                Ok(0) => {
+                    self.disconnected();
+                    return Ok(WriterState::Done);
+                }
+                Ok(n) => {
+                    let _ = self.buffer.split_to(n);
+                }
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                    if self.buffer.len() > self.buffer_capacity {
+                        return Ok(WriterState::Pause);
+                    } else {
+                        return Ok(WriterState::Done);
+                    }
+                }
+                Err(err) => return Err(err),
+            }
+        }
+        Ok(WriterState::Done)
+    }
+}
+
+impl HttpClientWriter {
+    pub fn start(&mut self, msg: &mut ClientRequest) -> io::Result<()> {
+        // prepare task
+        self.flags.insert(Flags::STARTED);
+        self.encoder = content_encoder(self.buffer.clone(), msg);
+
+        if msg.upgrade() {
+            self.flags.insert(Flags::UPGRADE);
+        }
+
+        // render message
+        {
+            // status line
+            writeln!(
+                self.buffer,
+                "{} {} {:?}\r",
+                msg.method(),
+                msg.uri()
+                    .path_and_query()
+                    .map(|u| u.as_str())
+                    .unwrap_or("/"),
+                msg.version()
+            )?;
+
+            // write headers
+            let mut buffer = self.buffer.get_mut();
+            if let Body::Binary(ref bytes) = *msg.body() {
+                buffer.reserve(msg.headers().len() * AVERAGE_HEADER_SIZE + bytes.len());
+            } else {
+                buffer.reserve(msg.headers().len() * AVERAGE_HEADER_SIZE);
+            }
+
+            for (key, value) in msg.headers() {
+                let v = value.as_ref();
+                let k = key.as_str().as_bytes();
+                buffer.reserve(k.len() + v.len() + 4);
+                buffer.put_slice(k);
+                buffer.put_slice(b": ");
+                buffer.put_slice(v);
+                buffer.put_slice(b"\r\n");
+            }
+
+            // set date header
+            if !msg.headers().contains_key(DATE) {
+                buffer.extend_from_slice(b"date: ");
+                set_date(&mut buffer);
+                buffer.extend_from_slice(b"\r\n\r\n");
+            } else {
+                buffer.extend_from_slice(b"\r\n");
+            }
+            self.headers_size = buffer.len() as u32;
+
+            if msg.body().is_binary() {
+                if let Body::Binary(bytes) = msg.replace_body(Body::Empty) {
+                    self.written += bytes.len() as u64;
+                    self.encoder.write(bytes)?;
+                }
+            } else {
+                self.buffer_capacity = msg.write_buffer_capacity();
+            }
+        }
+        Ok(())
+    }
+
+    pub fn write(&mut self, payload: Binary) -> io::Result<WriterState> {
+        self.written += payload.len() as u64;
+        if !self.flags.contains(Flags::DISCONNECTED) {
+            if self.flags.contains(Flags::UPGRADE) {
+                self.buffer.extend(payload);
+            } else {
+                self.encoder.write(payload)?;
+            }
+        }
+
+        if self.buffer.len() > self.buffer_capacity {
+            Ok(WriterState::Pause)
+        } else {
+            Ok(WriterState::Done)
+        }
+    }
+
+    pub fn write_eof(&mut self) -> io::Result<()> {
+        self.encoder.write_eof()?;
+
+        if self.encoder.is_eof() {
+            Ok(())
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::Other,
+                "Last payload item, but eof is not reached",
+            ))
+        }
+    }
+
+    #[inline]
+    pub fn poll_completed<T: AsyncWrite>(
+        &mut self, stream: &mut T, shutdown: bool,
+    ) -> Poll<(), io::Error> {
+        match self.write_to_stream(stream) {
+            Ok(WriterState::Done) => {
+                if shutdown {
+                    stream.shutdown()
+                } else {
+                    Ok(Async::Ready(()))
+                }
+            }
+            Ok(WriterState::Pause) => Ok(Async::NotReady),
+            Err(err) => Err(err),
+        }
+    }
+}
+
+fn content_encoder(buf: SharedBytes, req: &mut ClientRequest) -> ContentEncoder {
+    let version = req.version();
+    let mut body = req.replace_body(Body::Empty);
+    let mut encoding = req.content_encoding();
+
+    let transfer = match body {
+        Body::Empty => {
+            req.headers_mut().remove(CONTENT_LENGTH);
+            TransferEncoding::length(0, buf)
+        }
+        Body::Binary(ref mut bytes) => {
+            if encoding.is_compression() {
+                let tmp = SharedBytes::default();
+                let transfer = TransferEncoding::eof(tmp.clone());
+                let mut enc = match encoding {
+                    #[cfg(feature = "flate2")]
+                    ContentEncoding::Deflate => ContentEncoder::Deflate(
+                        DeflateEncoder::new(transfer, Compression::default()),
+                    ),
+                    #[cfg(feature = "flate2")]
+                    ContentEncoding::Gzip => ContentEncoder::Gzip(GzEncoder::new(
+                        transfer,
+                        Compression::default(),
+                    )),
+                    #[cfg(feature = "brotli")]
+                    ContentEncoding::Br => {
+                        ContentEncoder::Br(BrotliEncoder::new(transfer, 5))
+                    }
+                    ContentEncoding::Identity => ContentEncoder::Identity(transfer),
+                    ContentEncoding::Auto => unreachable!(),
+                };
+                // TODO return error!
+                let _ = enc.write(bytes.clone());
+                let _ = enc.write_eof();
+                *bytes = Binary::from(tmp.take());
+
+                req.headers_mut().insert(
+                    CONTENT_ENCODING,
+                    HeaderValue::from_static(encoding.as_str()),
+                );
+                encoding = ContentEncoding::Identity;
+            }
+            let mut b = BytesMut::new();
+            let _ = write!(b, "{}", bytes.len());
+            req.headers_mut().insert(
+                CONTENT_LENGTH,
+                HeaderValue::try_from(b.freeze()).unwrap(),
+            );
+            TransferEncoding::eof(buf)
+        }
+        Body::Streaming(_) | Body::Actor(_) => {
+            if req.upgrade() {
+                if version == Version::HTTP_2 {
+                    error!("Connection upgrade is forbidden for HTTP/2");
+                } else {
+                    req.headers_mut()
+                        .insert(CONNECTION, HeaderValue::from_static("upgrade"));
+                }
+                if encoding != ContentEncoding::Identity {
+                    encoding = ContentEncoding::Identity;
+                    req.headers_mut().remove(CONTENT_ENCODING);
+                }
+                TransferEncoding::eof(buf)
+            } else {
+                streaming_encoding(buf, version, req)
+            }
+        }
+    };
+
+    if encoding.is_compression() {
+        req.headers_mut().insert(
+            CONTENT_ENCODING,
+            HeaderValue::from_static(encoding.as_str()),
+        );
+    }
+
+    req.replace_body(body);
+    match encoding {
+        #[cfg(feature = "flate2")]
+        ContentEncoding::Deflate => ContentEncoder::Deflate(DeflateEncoder::new(
+            transfer,
+            Compression::default(),
+        )),
+        #[cfg(feature = "flate2")]
+        ContentEncoding::Gzip => {
+            ContentEncoder::Gzip(GzEncoder::new(transfer, Compression::default()))
+        }
+        #[cfg(feature = "brotli")]
+        ContentEncoding::Br => ContentEncoder::Br(BrotliEncoder::new(transfer, 5)),
+        ContentEncoding::Identity | ContentEncoding::Auto => {
+            ContentEncoder::Identity(transfer)
+        }
+    }
+}
+
+fn streaming_encoding(
+    buf: SharedBytes, version: Version, req: &mut ClientRequest,
+) -> TransferEncoding {
+    if req.chunked() {
+        // Enable transfer encoding
+        req.headers_mut().remove(CONTENT_LENGTH);
+        if version == Version::HTTP_2 {
+            req.headers_mut().remove(TRANSFER_ENCODING);
+            TransferEncoding::eof(buf)
+        } else {
+            req.headers_mut()
+                .insert(TRANSFER_ENCODING, HeaderValue::from_static("chunked"));
+            TransferEncoding::chunked(buf)
+        }
+    } else {
+        // if Content-Length is specified, then use it as length hint
+        let (len, chunked) = if let Some(len) = req.headers().get(CONTENT_LENGTH) {
+            // Content-Length
+            if let Ok(s) = len.to_str() {
+                if let Ok(len) = s.parse::<u64>() {
+                    (Some(len), false)
+                } else {
+                    error!("illegal Content-Length: {:?}", len);
+                    (None, false)
+                }
+            } else {
+                error!("illegal Content-Length: {:?}", len);
+                (None, false)
+            }
+        } else {
+            (None, true)
+        };
+
+        if !chunked {
+            if let Some(len) = len {
+                TransferEncoding::length(len, buf)
+            } else {
+                TransferEncoding::eof(buf)
+            }
+        } else {
+            // Enable transfer encoding
+            match version {
+                Version::HTTP_11 => {
+                    req.headers_mut()
+                        .insert(TRANSFER_ENCODING, HeaderValue::from_static("chunked"));
+                    TransferEncoding::chunked(buf)
+                }
+                _ => {
+                    req.headers_mut().remove(TRANSFER_ENCODING);
+                    TransferEncoding::eof(buf)
+                }
+            }
+        }
+    }
+}
+
+// "Sun, 06 Nov 1994 08:49:37 GMT".len()
+pub const DATE_VALUE_LENGTH: usize = 29;
+
+fn set_date(dst: &mut BytesMut) {
+    CACHED.with(|cache| {
+        let mut cache = cache.borrow_mut();
+        let now = time::get_time();
+        if now > cache.next_update {
+            cache.update(now);
+        }
+        dst.extend_from_slice(cache.buffer());
+    })
+}
+
+struct CachedDate {
+    bytes: [u8; DATE_VALUE_LENGTH],
+    next_update: time::Timespec,
+}
+
+thread_local!(static CACHED: RefCell<CachedDate> = RefCell::new(CachedDate {
+    bytes: [0; DATE_VALUE_LENGTH],
+    next_update: time::Timespec::new(0, 0),
+}));
+
+impl CachedDate {
+    fn buffer(&self) -> &[u8] {
+        &self.bytes[..]
+    }
+
+    fn update(&mut self, now: time::Timespec) {
+        write!(&mut self.bytes[..], "{}", time::at_utc(now).rfc822()).unwrap();
+        self.next_update = now + Duration::seconds(1);
+        self.next_update.nsec = 0;
+    }
+}

src/context.rs

@@ -1,24 +1,21 @@
-use std;
-use std::marker::PhantomData;
-use futures::{Async, Future, Poll};
 use futures::sync::oneshot::Sender;
 use futures::unsync::oneshot;
+use futures::{Async, Future, Poll};
 use smallvec::SmallVec;
+use std::marker::PhantomData;
 
-use actix::{Actor, ActorState, ActorContext, AsyncContext,
-            Address, SyncAddress, Handler, Subscriber, ResponseType, SpawnHandle};
+use actix::dev::{ContextImpl, SyncEnvelope, ToEnvelope};
 use actix::fut::ActorFuture;
-use actix::dev::{queue, AsyncContextApi,
-                 ContextImpl, ContextProtocol, Envelope, ToEnvelope, RemoteEnvelope};
+use actix::{Actor, ActorContext, ActorState, Addr, AsyncContext, Handler, Message,
+            SpawnHandle, Syn, Unsync};
 
-use body::{Body, Binary};
-use error::{Error, Result, ErrorInternalServerError};
+use body::{Binary, Body};
+use error::{Error, ErrorInternalServerError};
 use httprequest::HttpRequest;
 
-
 pub trait ActorHttpContext: 'static {
     fn disconnected(&mut self);
-    fn poll(&mut self) -> Poll<Option<SmallVec<[Frame; 2]>>, Error>;
+    fn poll(&mut self) -> Poll<Option<SmallVec<[Frame; 4]>>, Error>;
 }
 
 #[derive(Debug)]
@@ -27,16 +24,29 @@ pub enum Frame {
     Drain(oneshot::Sender<()>),
 }
 
-/// Http actor execution context
-pub struct HttpContext<A, S=()> where A: Actor<Context=HttpContext<A, S>>,
+impl Frame {
+    pub fn len(&self) -> usize {
+        match *self {
+            Frame::Chunk(Some(ref bin)) => bin.len(),
+            _ => 0,
+        }
+    }
+}
+
+/// Execution context for http actors
+pub struct HttpContext<A, S = ()>
+where
+    A: Actor<Context = HttpContext<A, S>>,
 {
     inner: ContextImpl<A>,
-    stream: Option<SmallVec<[Frame; 2]>>,
+    stream: Option<SmallVec<[Frame; 4]>>,
     request: HttpRequest<S>,
     disconnected: bool,
 }
 
-impl<A, S> ActorContext for HttpContext<A, S> where A: Actor<Context=Self>
+impl<A, S> ActorContext for HttpContext<A, S>
+where
+    A: Actor<Context = Self>,
 {
     fn stop(&mut self) {
         self.inner.stop();
@@ -49,41 +59,50 @@ impl<A, S> ActorContext for HttpContext<A, S> where A: Actor<Context=Self>
     }
 }
 
-impl<A, S> AsyncContext<A> for HttpContext<A, S> where A: Actor<Context=Self>
+impl<A, S> AsyncContext<A> for HttpContext<A, S>
+where
+    A: Actor<Context = Self>,
 {
+    #[inline]
     fn spawn<F>(&mut self, fut: F) -> SpawnHandle
-        where F: ActorFuture<Item=(), Error=(), Actor=A> + 'static
+    where
+        F: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
     {
         self.inner.spawn(fut)
     }
+    #[inline]
     fn wait<F>(&mut self, fut: F)
-        where F: ActorFuture<Item=(), Error=(), Actor=A> + 'static
+    where
+        F: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
     {
         self.inner.wait(fut)
     }
+    #[doc(hidden)]
+    #[inline]
+    fn waiting(&self) -> bool {
+        self.inner.waiting() || self.inner.state() == ActorState::Stopping
+            || self.inner.state() == ActorState::Stopped
+    }
+    #[inline]
     fn cancel_future(&mut self, handle: SpawnHandle) -> bool {
         self.inner.cancel_future(handle)
     }
-}
-
-#[doc(hidden)]
-impl<A, S> AsyncContextApi<A> for HttpContext<A, S> where A: Actor<Context=Self> {
+    #[doc(hidden)]
     #[inline]
-    fn unsync_sender(&mut self) -> queue::unsync::UnboundedSender<ContextProtocol<A>> {
-        self.inner.unsync_sender()
-    }
-    #[inline]
-    fn unsync_address(&mut self) -> Address<A> {
+    fn unsync_address(&mut self) -> Addr<Unsync, A> {
         self.inner.unsync_address()
     }
+    #[doc(hidden)]
     #[inline]
-    fn sync_address(&mut self) -> SyncAddress<A> {
+    fn sync_address(&mut self) -> Addr<Syn, A> {
         self.inner.sync_address()
     }
 }
 
-impl<A, S: 'static> HttpContext<A, S> where A: Actor<Context=Self> {
-
+impl<A, S: 'static> HttpContext<A, S>
+where
+    A: Actor<Context = Self>,
+{
     #[inline]
     pub fn new(req: HttpRequest<S>, actor: A) -> HttpContext<A, S> {
         HttpContext::from_request(req).actor(actor)
@@ -103,8 +122,10 @@ impl<A, S: 'static> HttpContext<A, S> where A: Actor<Context=Self> {
     }
 }
 
-impl<A, S> HttpContext<A, S> where A: Actor<Context=Self> {
-
+impl<A, S> HttpContext<A, S>
+where
+    A: Actor<Context = Self>,
+{
     /// Shared application state
     #[inline]
     pub fn state(&self) -> &S {
@@ -152,47 +173,39 @@ impl<A, S> HttpContext<A, S> where A: Actor<Context=Self> {
         if self.stream.is_none() {
             self.stream = Some(SmallVec::new());
         }
-        self.stream.as_mut().map(|s| s.push(frame));
+        if let Some(s) = self.stream.as_mut() {
+            s.push(frame)
+        }
+        self.inner.modify();
+    }
+
+    /// Handle of the running future
+    ///
+    /// SpawnHandle is the handle returned by `AsyncContext::spawn()` method.
+    pub fn handle(&self) -> SpawnHandle {
+        self.inner.curr_handle()
     }
 }
 
-impl<A, S> HttpContext<A, S> where A: Actor<Context=Self> {
-
-    #[inline]
-    #[doc(hidden)]
-    pub fn subscriber<M>(&mut self) -> Box<Subscriber<M>>
-        where A: Handler<M>, M: ResponseType + 'static
-    {
-        self.inner.subscriber()
-    }
-
-    #[inline]
-    #[doc(hidden)]
-    pub fn sync_subscriber<M>(&mut self) -> Box<Subscriber<M> + Send>
-        where A: Handler<M>,
-              M: ResponseType + Send + 'static, M::Item: Send, M::Error: Send,
-    {
-        self.inner.sync_subscriber()
-    }
-}
-
-impl<A, S> ActorHttpContext for HttpContext<A, S> where A: Actor<Context=Self>, S: 'static {
-
+impl<A, S> ActorHttpContext for HttpContext<A, S>
+where
+    A: Actor<Context = Self>,
+    S: 'static,
+{
     #[inline]
     fn disconnected(&mut self) {
         self.disconnected = true;
         self.stop();
     }
 
-    fn poll(&mut self) -> Poll<Option<SmallVec<[Frame; 2]>>, Error> {
-        let ctx: &mut HttpContext<A, S> = unsafe {
-            std::mem::transmute(self as &mut HttpContext<A, S>)
-        };
+    fn poll(&mut self) -> Poll<Option<SmallVec<[Frame; 4]>>, Error> {
+        let ctx: &mut HttpContext<A, S> =
+            unsafe { &mut *(self as &mut HttpContext<A, S> as *mut _) };
 
         if self.inner.alive() {
             match self.inner.poll(ctx) {
                 Ok(Async::NotReady) | Ok(Async::Ready(())) => (),
-                Err(_) => return Err(ErrorInternalServerError("error").into()),
+                Err(_) => return Err(ErrorInternalServerError("error")),
             }
         }
 
@@ -207,22 +220,21 @@ impl<A, S> ActorHttpContext for HttpContext<A, S> where A: Actor<Context=Self>,
     }
 }
 
-impl<A, S> ToEnvelope<A> for HttpContext<A, S>
-    where A: Actor<Context=HttpContext<A, S>>,
+impl<A, M, S> ToEnvelope<Syn, A, M> for HttpContext<A, S>
+where
+    A: Actor<Context = HttpContext<A, S>> + Handler<M>,
+    M: Message + Send + 'static,
+    M::Result: Send,
 {
-    #[inline]
-    fn pack<M>(msg: M, tx: Option<Sender<Result<M::Item, M::Error>>>,
-               channel_on_drop: bool) -> Envelope<A>
-        where A: Handler<M>,
-              M: ResponseType + Send + 'static, M::Item: Send, M::Error: Send
-    {
-        RemoteEnvelope::new(msg, tx, channel_on_drop).into()
+    fn pack(msg: M, tx: Option<Sender<M::Result>>) -> SyncEnvelope<A> {
+        SyncEnvelope::new(msg, tx)
     }
 }
 
 impl<A, S> From<HttpContext<A, S>> for Body
-    where A: Actor<Context=HttpContext<A, S>>,
-          S: 'static
+where
+    A: Actor<Context = HttpContext<A, S>>,
+    S: 'static,
 {
     fn from(ctx: HttpContext<A, S>) -> Body {
         Body::Actor(Box::new(ctx))
@@ -237,8 +249,8 @@ pub struct Drain<A> {
 impl<A> Drain<A> {
     pub fn new(fut: oneshot::Receiver<()>) -> Self {
         Drain {
-            fut: fut,
-            _a: PhantomData
+            fut,
+            _a: PhantomData,
         }
     }
 }
@@ -249,10 +261,9 @@ impl<A: Actor> ActorFuture for Drain<A> {
     type Actor = A;
 
     #[inline]
-    fn poll(&mut self,
-            _: &mut A,
-            _: &mut <Self::Actor as Actor>::Context) -> Poll<Self::Item, Self::Error>
-    {
+    fn poll(
+        &mut self, _: &mut A, _: &mut <Self::Actor as Actor>::Context,
+    ) -> Poll<Self::Item, Self::Error> {
         self.fut.poll().map_err(|_| ())
     }
 }

src/de.rs

@@ -0,0 +1,456 @@
+use serde::de::{self, Deserializer, Error as DeError, Visitor};
+use std::borrow::Cow;
+use std::convert::AsRef;
+use std::slice::Iter;
+
+use httprequest::HttpRequest;
+
+macro_rules! unsupported_type {
+    ($trait_fn:ident, $name:expr) => {
+        fn $trait_fn<V>(self, _: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            Err(de::value::Error::custom(concat!("unsupported type: ", $name)))
+        }
+    };
+}
+
+macro_rules! parse_single_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            if self.req.match_info().len() != 1 {
+                Err(de::value::Error::custom(
+                    format!("wrong number of parameters: {} expected 1",
+                            self.req.match_info().len()).as_str()))
+            } else {
+                let v = self.req.match_info()[0].parse().map_err(
+                    |_| de::value::Error::custom(
+                        format!("can not parse {:?} to a {}",
+                                &self.req.match_info()[0], $tp)))?;
+                visitor.$visit_fn(v)
+            }
+        }
+    }
+}
+
+pub struct PathDeserializer<'de, S: 'de> {
+    req: &'de HttpRequest<S>,
+}
+
+impl<'de, S: 'de> PathDeserializer<'de, S> {
+    pub fn new(req: &'de HttpRequest<S>) -> Self {
+        PathDeserializer { req }
+    }
+}
+
+impl<'de, S: 'de> Deserializer<'de> for PathDeserializer<'de, S> {
+    type Error = de::value::Error;
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_map(ParamsDeserializer {
+            params: self.req.match_info().iter(),
+            current: None,
+        })
+    }
+
+    fn deserialize_struct<V>(
+        self, _: &'static str, _: &'static [&'static str], visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_map(visitor)
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(
+        self, _: &'static str, visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_unit(visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self, _: &'static str, visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(
+        self, len: usize, visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.req.match_info().len() < len {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected {}",
+                    self.req.match_info().len(),
+                    len
+                ).as_str(),
+            ))
+        } else {
+            visitor.visit_seq(ParamsSeq {
+                params: self.req.match_info().iter(),
+            })
+        }
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self, _: &'static str, len: usize, visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.req.match_info().len() < len {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected {}",
+                    self.req.match_info().len(),
+                    len
+                ).as_str(),
+            ))
+        } else {
+            visitor.visit_seq(ParamsSeq {
+                params: self.req.match_info().iter(),
+            })
+        }
+    }
+
+    fn deserialize_enum<V>(
+        self, _: &'static str, _: &'static [&'static str], _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: enum"))
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.req.match_info().len() != 1 {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected 1",
+                    self.req.match_info().len()
+                ).as_str(),
+            ))
+        } else {
+            visitor.visit_str(&self.req.match_info()[0])
+        }
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_seq(ParamsSeq {
+            params: self.req.match_info().iter(),
+        })
+    }
+
+    unsupported_type!(deserialize_any, "'any'");
+    unsupported_type!(deserialize_bytes, "bytes");
+    unsupported_type!(deserialize_option, "Option<T>");
+    unsupported_type!(deserialize_identifier, "identifier");
+    unsupported_type!(deserialize_ignored_any, "ignored_any");
+
+    parse_single_value!(deserialize_bool, visit_bool, "bool");
+    parse_single_value!(deserialize_i8, visit_i8, "i8");
+    parse_single_value!(deserialize_i16, visit_i16, "i16");
+    parse_single_value!(deserialize_i32, visit_i32, "i16");
+    parse_single_value!(deserialize_i64, visit_i64, "i64");
+    parse_single_value!(deserialize_u8, visit_u8, "u8");
+    parse_single_value!(deserialize_u16, visit_u16, "u16");
+    parse_single_value!(deserialize_u32, visit_u32, "u32");
+    parse_single_value!(deserialize_u64, visit_u64, "u64");
+    parse_single_value!(deserialize_f32, visit_f32, "f32");
+    parse_single_value!(deserialize_f64, visit_f64, "f64");
+    parse_single_value!(deserialize_string, visit_string, "String");
+    parse_single_value!(deserialize_byte_buf, visit_string, "String");
+    parse_single_value!(deserialize_char, visit_char, "char");
+}
+
+struct ParamsDeserializer<'de> {
+    params: Iter<'de, (Cow<'de, str>, Cow<'de, str>)>,
+    current: Option<(&'de str, &'de str)>,
+}
+
+impl<'de> de::MapAccess<'de> for ParamsDeserializer<'de> {
+    type Error = de::value::Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+    where
+        K: de::DeserializeSeed<'de>,
+    {
+        self.current = self.params
+            .next()
+            .map(|&(ref k, ref v)| (k.as_ref(), v.as_ref()));
+        match self.current {
+            Some((key, _)) => Ok(Some(seed.deserialize(Key { key })?)),
+            None => Ok(None),
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        if let Some((_, value)) = self.current.take() {
+            seed.deserialize(Value { value })
+        } else {
+            Err(de::value::Error::custom("unexpected item"))
+        }
+    }
+}
+
+struct Key<'de> {
+    key: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Key<'de> {
+    type Error = de::value::Error;
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_str(self.key)
+    }
+
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("Unexpected"))
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+            byte_buf option unit unit_struct newtype_struct seq tuple
+            tuple_struct map struct enum ignored_any
+    }
+}
+
+macro_rules! parse_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            let v = self.value.parse().map_err(
+                |_| de::value::Error::custom(
+                    format!("can not parse {:?} to a {}", self.value, $tp)))?;
+            visitor.$visit_fn(v)
+        }
+    }
+}
+
+struct Value<'de> {
+    value: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Value<'de> {
+    type Error = de::value::Error;
+
+    parse_value!(deserialize_bool, visit_bool, "bool");
+    parse_value!(deserialize_i8, visit_i8, "i8");
+    parse_value!(deserialize_i16, visit_i16, "i16");
+    parse_value!(deserialize_i32, visit_i32, "i16");
+    parse_value!(deserialize_i64, visit_i64, "i64");
+    parse_value!(deserialize_u8, visit_u8, "u8");
+    parse_value!(deserialize_u16, visit_u16, "u16");
+    parse_value!(deserialize_u32, visit_u32, "u32");
+    parse_value!(deserialize_u64, visit_u64, "u64");
+    parse_value!(deserialize_f32, visit_f32, "f32");
+    parse_value!(deserialize_f64, visit_f64, "f64");
+    parse_value!(deserialize_string, visit_string, "String");
+    parse_value!(deserialize_byte_buf, visit_string, "String");
+    parse_value!(deserialize_char, visit_char, "char");
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(
+        self, _: &'static str, visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_bytes(self.value.as_bytes())
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_str(self.value)
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_some(self)
+    }
+
+    fn deserialize_enum<V>(
+        self, _: &'static str, _: &'static [&'static str], visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_enum(ValueEnum {
+            value: self.value,
+        })
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self, _: &'static str, visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: tuple"))
+    }
+
+    fn deserialize_struct<V>(
+        self, _: &'static str, _: &'static [&'static str], _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: struct"))
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self, _: &'static str, _: usize, _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom(
+            "unsupported type: tuple struct",
+        ))
+    }
+
+    unsupported_type!(deserialize_any, "any");
+    unsupported_type!(deserialize_seq, "seq");
+    unsupported_type!(deserialize_map, "map");
+    unsupported_type!(deserialize_identifier, "identifier");
+}
+
+struct ParamsSeq<'de> {
+    params: Iter<'de, (Cow<'de, str>, Cow<'de, str>)>,
+}
+
+impl<'de> de::SeqAccess<'de> for ParamsSeq<'de> {
+    type Error = de::value::Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        match self.params.next() {
+            Some(item) => Ok(Some(seed.deserialize(Value {
+                value: item.1.as_ref(),
+            })?)),
+            None => Ok(None),
+        }
+    }
+}
+
+struct ValueEnum<'de> {
+    value: &'de str,
+}
+
+impl<'de> de::EnumAccess<'de> for ValueEnum<'de> {
+    type Error = de::value::Error;
+    type Variant = UnitVariant;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        Ok((
+            seed.deserialize(Key { key: self.value })?,
+            UnitVariant,
+        ))
+    }
+}
+
+struct UnitVariant;
+
+impl<'de> de::VariantAccess<'de> for UnitVariant {
+    type Error = de::value::Error;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn struct_variant<V>(
+        self, _: &'static [&'static str], _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+}

src/error.rs

@@ -1,38 +1,37 @@
 //! Error and Result module
-use std::{io, fmt, result};
+use std::cell::RefCell;
+use std::io::Error as IoError;
 use std::str::Utf8Error;
 use std::string::FromUtf8Error;
-use std::io::Error as IoError;
-
-#[cfg(actix_nightly)]
-use std::error::Error as StdError;
+use std::{fmt, io, result};
 
+use actix::MailboxError;
 use cookie;
-use httparse;
+use failure::{self, Backtrace, Fail};
 use futures::Canceled;
-use failure::{Fail, Backtrace};
+use http::uri::InvalidUri;
+use http::{header, Error as HttpError, StatusCode};
 use http2::Error as Http2Error;
-use http::{header, StatusCode, Error as HttpError};
-use http::uri::InvalidUriBytes;
 use http_range::HttpRangeParseError;
+use httparse;
+use serde::de::value::Error as DeError;
 use serde_json::error::Error as JsonError;
-use url::ParseError as UrlParseError;
+pub use url::ParseError as UrlParseError;
 
 // re-exports
-pub use cookie::{ParseError as CookieParseError};
+pub use cookie::ParseError as CookieParseError;
 
-use body::Body;
 use handler::Responder;
 use httprequest::HttpRequest;
 use httpresponse::HttpResponse;
-use httpcodes::{HTTPBadRequest, HTTPMethodNotAllowed, HTTPExpectationFailed};
 
 /// A specialized [`Result`](https://doc.rust-lang.org/std/result/enum.Result.html)
 /// for actix web operations
 ///
-/// This typedef is generally used to avoid writing out `actix_web::error::Error` directly and
-/// is otherwise a direct mapping to `Result`.
-pub type Result<T, E=Error> = result::Result<T, E>;
+/// This typedef is generally used to avoid writing out
+/// `actix_web::error::Error` directly and is otherwise a direct mapping to
+/// `Result`.
+pub type Result<T, E = Error> = result::Result<T, E>;
 
 /// General purpose actix web error
 pub struct Error {
@@ -41,22 +40,30 @@ pub struct Error {
 }
 
 impl Error {
-
     /// Returns a reference to the underlying cause of this Error.
     // this should return &Fail but needs this https://github.com/rust-lang/rust/issues/5665
     pub fn cause(&self) -> &ResponseError {
         self.cause.as_ref()
     }
+
+    /// Returns a reference to the Backtrace carried by this error, if it
+    /// carries one.
+    pub fn backtrace(&self) -> &Backtrace {
+        if let Some(bt) = self.cause.backtrace() {
+            bt
+        } else {
+            self.backtrace.as_ref().unwrap()
+        }
+    }
 }
 
 /// Error that can be converted to `HttpResponse`
 pub trait ResponseError: Fail {
-
     /// Create response for error
     ///
     /// Internal server error is generated by default.
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR, Body::Empty)
+        HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR)
     }
 }
 
@@ -71,7 +78,12 @@ impl fmt::Debug for Error {
         if let Some(bt) = self.cause.backtrace() {
             write!(f, "{:?}\n\n{:?}", &self.cause, bt)
         } else {
-            write!(f, "{:?}\n\n{:?}", &self.cause, self.backtrace.as_ref().unwrap())
+            write!(
+                f,
+                "{:?}\n\n{:?}",
+                &self.cause,
+                self.backtrace.as_ref().unwrap()
+            )
         }
     }
 }
@@ -91,86 +103,122 @@ impl<T: ResponseError> From<T> for Error {
         } else {
             None
         };
-        Error { cause: Box::new(err), backtrace: backtrace }
+        Error {
+            cause: Box::new(err),
+            backtrace,
+        }
     }
 }
 
-/// Default error is `InternalServerError`
-#[cfg(actix_nightly)]
-default impl<T: StdError + Sync + Send + 'static> ResponseError for T {
-    fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR, Body::Empty)
+/// Compatibility for `failure::Error`
+impl<T> ResponseError for failure::Compat<T>
+where
+    T: fmt::Display + fmt::Debug + Sync + Send + 'static,
+{
+}
+
+impl From<failure::Error> for Error {
+    fn from(err: failure::Error) -> Error {
+        err.compat().into()
     }
 }
 
 /// `InternalServerError` for `JsonError`
 impl ResponseError for JsonError {}
 
+/// `InternalServerError` for `UrlParseError`
+impl ResponseError for UrlParseError {}
+
+/// Return `BAD_REQUEST` for `de::value::Error`
+impl ResponseError for DeError {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST)
+    }
+}
+
+/// Return `BAD_REQUEST` for `Utf8Error`
+impl ResponseError for Utf8Error {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST)
+    }
+}
+
 /// Return `InternalServerError` for `HttpError`,
 /// Response generation can return `HttpError`, so it is internal error
 impl ResponseError for HttpError {}
 
 /// Return `InternalServerError` for `io::Error`
 impl ResponseError for io::Error {
-
     fn error_response(&self) -> HttpResponse {
         match self.kind() {
-            io::ErrorKind::NotFound =>
-                HttpResponse::new(StatusCode::NOT_FOUND, Body::Empty),
-            io::ErrorKind::PermissionDenied =>
-                HttpResponse::new(StatusCode::FORBIDDEN, Body::Empty),
-            _ =>
-                HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR, Body::Empty)
+            io::ErrorKind::NotFound => HttpResponse::new(StatusCode::NOT_FOUND),
+            io::ErrorKind::PermissionDenied => HttpResponse::new(StatusCode::FORBIDDEN),
+            _ => HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR),
         }
     }
 }
 
-/// `InternalServerError` for `InvalidHeaderValue`
-impl ResponseError for header::InvalidHeaderValue {}
+/// `BadRequest` for `InvalidHeaderValue`
+impl ResponseError for header::InvalidHeaderValue {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST)
+    }
+}
+
+/// `BadRequest` for `InvalidHeaderValue`
+impl ResponseError for header::InvalidHeaderValueBytes {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST)
+    }
+}
 
 /// `InternalServerError` for `futures::Canceled`
 impl ResponseError for Canceled {}
 
+/// `InternalServerError` for `actix::MailboxError`
+impl ResponseError for MailboxError {}
+
 /// A set of errors that can occur during parsing HTTP streams
 #[derive(Fail, Debug)]
 pub enum ParseError {
     /// An invalid `Method`, such as `GE.T`.
-    #[fail(display="Invalid Method specified")]
+    #[fail(display = "Invalid Method specified")]
     Method,
     /// An invalid `Uri`, such as `exam ple.domain`.
-    #[fail(display="Uri error: {}", _0)]
-    Uri(InvalidUriBytes),
+    #[fail(display = "Uri error: {}", _0)]
+    Uri(InvalidUri),
     /// An invalid `HttpVersion`, such as `HTP/1.1`
-    #[fail(display="Invalid HTTP version specified")]
+    #[fail(display = "Invalid HTTP version specified")]
     Version,
     /// An invalid `Header`.
-    #[fail(display="Invalid Header provided")]
+    #[fail(display = "Invalid Header provided")]
     Header,
     /// A message head is too large to be reasonable.
-    #[fail(display="Message head is too large")]
+    #[fail(display = "Message head is too large")]
     TooLarge,
     /// A message reached EOF, but is not complete.
-    #[fail(display="Message is incomplete")]
+    #[fail(display = "Message is incomplete")]
     Incomplete,
     /// An invalid `Status`, such as `1337 ELITE`.
-    #[fail(display="Invalid Status provided")]
+    #[fail(display = "Invalid Status provided")]
     Status,
     /// A timeout occurred waiting for an IO event.
     #[allow(dead_code)]
-    #[fail(display="Timeout")]
+    #[fail(display = "Timeout")]
     Timeout,
-    /// An `io::Error` that occurred while trying to read or write to a network stream.
-    #[fail(display="IO error: {}", _0)]
+    /// An `io::Error` that occurred while trying to read or write to a network
+    /// stream.
+    #[fail(display = "IO error: {}", _0)]
     Io(#[cause] IoError),
     /// Parsing a field as string failed
-    #[fail(display="UTF8 error: {}", _0)]
+    #[fail(display = "UTF8 error: {}", _0)]
     Utf8(#[cause] Utf8Error),
 }
 
 /// Return `BadRequest` for `ParseError`
 impl ResponseError for ParseError {
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
@@ -180,6 +228,12 @@ impl From<IoError> for ParseError {
     }
 }
 
+impl From<InvalidUri> for ParseError {
+    fn from(err: InvalidUri) -> ParseError {
+        ParseError::Uri(err)
+    }
+}
+
 impl From<Utf8Error> for ParseError {
     fn from(err: Utf8Error) -> ParseError {
         ParseError::Utf8(err)
@@ -195,8 +249,10 @@ impl From<FromUtf8Error> for ParseError {
 impl From<httparse::Error> for ParseError {
     fn from(err: httparse::Error) -> ParseError {
         match err {
-            httparse::Error::HeaderName | httparse::Error::HeaderValue |
-                httparse::Error::NewLine | httparse::Error::Token => ParseError::Header,
+            httparse::Error::HeaderName
+            | httparse::Error::HeaderValue
+            | httparse::Error::NewLine
+            | httparse::Error::Token => ParseError::Header,
             httparse::Error::Status => ParseError::Status,
             httparse::Error::TooManyHeaders => ParseError::TooLarge,
             httparse::Error::Version => ParseError::Version,
@@ -208,28 +264,28 @@ impl From<httparse::Error> for ParseError {
 /// A set of errors that can occur during payload parsing
 pub enum PayloadError {
     /// A payload reached EOF, but is not complete.
-    #[fail(display="A payload reached EOF, but is not complete.")]
+    #[fail(display = "A payload reached EOF, but is not complete.")]
     Incomplete,
     /// Content encoding stream corruption
-    #[fail(display="Can not decode content-encoding.")]
+    #[fail(display = "Can not decode content-encoding.")]
     EncodingCorrupted,
     /// A payload reached size limit.
-    #[fail(display="A payload reached size limit.")]
+    #[fail(display = "A payload reached size limit.")]
     Overflow,
     /// A payload length is unknown.
-    #[fail(display="A payload length is unknown.")]
+    #[fail(display = "A payload length is unknown.")]
     UnknownLength,
-    /// Parse error
-    #[fail(display="{}", _0)]
-    ParseError(#[cause] IoError),
+    /// Io error
+    #[fail(display = "{}", _0)]
+    Io(#[cause] IoError),
     /// Http2 error
-    #[fail(display="{}", _0)]
+    #[fail(display = "{}", _0)]
     Http2(#[cause] Http2Error),
 }
 
 impl From<IoError> for PayloadError {
     fn from(err: IoError) -> PayloadError {
-        PayloadError::ParseError(err)
+        PayloadError::Io(err)
     }
 }
 
@@ -239,7 +295,7 @@ impl ResponseError for PayloadError {}
 /// Return `BadRequest` for `cookie::ParseError`
 impl ResponseError for cookie::ParseError {
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
@@ -247,20 +303,24 @@ impl ResponseError for cookie::ParseError {
 #[derive(Fail, PartialEq, Debug)]
 pub enum HttpRangeError {
     /// Returned if range is invalid.
-    #[fail(display="Range header is invalid")]
+    #[fail(display = "Range header is invalid")]
     InvalidRange,
     /// Returned if first-byte-pos of all of the byte-range-spec
     /// values is greater than the content size.
     /// See `https://github.com/golang/go/commit/aa9b3d7`
-    #[fail(display="First-byte-pos of all of the byte-range-spec values is greater than the content size")]
+    #[fail(
+        display = "First-byte-pos of all of the byte-range-spec values is greater than the content size"
+    )]
     NoOverlap,
 }
 
 /// Return `BadRequest` for `HttpRangeError`
 impl ResponseError for HttpRangeError {
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(
-            StatusCode::BAD_REQUEST, Body::from("Invalid Range header provided"))
+        HttpResponse::with_body(
+            StatusCode::BAD_REQUEST,
+            "Invalid Range header provided",
+        )
     }
 }
 
@@ -277,19 +337,22 @@ impl From<HttpRangeParseError> for HttpRangeError {
 #[derive(Fail, Debug)]
 pub enum MultipartError {
     /// Content-Type header is not found
-    #[fail(display="No Content-type header found")]
+    #[fail(display = "No Content-type header found")]
     NoContentType,
     /// Can not parse Content-Type header
-    #[fail(display="Can not parse Content-Type header")]
+    #[fail(display = "Can not parse Content-Type header")]
     ParseContentType,
     /// Multipart boundary is not found
-    #[fail(display="Multipart boundary is not found")]
+    #[fail(display = "Multipart boundary is not found")]
     Boundary,
+    /// Multipart stream is incomplete
+    #[fail(display = "Multipart stream is incomplete")]
+    Incomplete,
     /// Error during field parsing
-    #[fail(display="{}", _0)]
+    #[fail(display = "{}", _0)]
     Parse(#[cause] ParseError),
     /// Payload error
-    #[fail(display="{}", _0)]
+    #[fail(display = "{}", _0)]
     Payload(#[cause] PayloadError),
 }
 
@@ -307,9 +370,8 @@ impl From<PayloadError> for MultipartError {
 
 /// Return `BadRequest` for `MultipartError`
 impl ResponseError for MultipartError {
-
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
@@ -317,65 +379,34 @@ impl ResponseError for MultipartError {
 #[derive(Fail, PartialEq, Debug)]
 pub enum ExpectError {
     /// Expect header value can not be converted to utf8
-    #[fail(display="Expect header value can not be converted to utf8")]
+    #[fail(display = "Expect header value can not be converted to utf8")]
     Encoding,
     /// Unknown expect value
-    #[fail(display="Unknown expect value")]
+    #[fail(display = "Unknown expect value")]
     UnknownExpect,
 }
 
 impl ResponseError for ExpectError {
-
     fn error_response(&self) -> HttpResponse {
-        HTTPExpectationFailed.with_body("Unknown Expect")
+        HttpResponse::with_body(StatusCode::EXPECTATION_FAILED, "Unknown Expect")
     }
 }
 
-/// Websocket handshake errors
+/// A set of error that can occure during parsing content type
 #[derive(Fail, PartialEq, Debug)]
-pub enum WsHandshakeError {
-    /// Only get method is allowed
-    #[fail(display="Method not allowed")]
-    GetMethodRequired,
-    /// Upgrade header if not set to websocket
-    #[fail(display="Websocket upgrade is expected")]
-    NoWebsocketUpgrade,
-    /// Connection header is not set to upgrade
-    #[fail(display="Connection upgrade is expected")]
-    NoConnectionUpgrade,
-    /// Websocket version header is not set
-    #[fail(display="Websocket version header is required")]
-    NoVersionHeader,
-    /// Unsupported websocket version
-    #[fail(display="Unsupported version")]
-    UnsupportedVersion,
-    /// Websocket key is not set or wrong
-    #[fail(display="Unknown websocket key")]
-    BadWebsocketKey,
+pub enum ContentTypeError {
+    /// Can not parse content type
+    #[fail(display = "Can not parse content type")]
+    ParseError,
+    /// Unknown content encoding
+    #[fail(display = "Unknown content encoding")]
+    UnknownEncoding,
 }
 
-impl ResponseError for WsHandshakeError {
-
+/// Return `BadRequest` for `ContentTypeError`
+impl ResponseError for ContentTypeError {
     fn error_response(&self) -> HttpResponse {
-        match *self {
-            WsHandshakeError::GetMethodRequired => {
-                HTTPMethodNotAllowed
-                    .build()
-                    .header(header::ALLOW, "GET")
-                    .finish()
-                    .unwrap()
-            }
-            WsHandshakeError::NoWebsocketUpgrade =>
-                HTTPBadRequest.with_reason("No WebSocket UPGRADE header found"),
-            WsHandshakeError::NoConnectionUpgrade =>
-                HTTPBadRequest.with_reason("No CONNECTION upgrade"),
-            WsHandshakeError::NoVersionHeader =>
-                HTTPBadRequest.with_reason("Websocket version header is required"),
-            WsHandshakeError::UnsupportedVersion =>
-                HTTPBadRequest.with_reason("Unsupported version"),
-            WsHandshakeError::BadWebsocketKey =>
-                HTTPBadRequest.with_reason("Handshake error"),
-        }
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
@@ -383,27 +414,37 @@ impl ResponseError for WsHandshakeError {
 #[derive(Fail, Debug)]
 pub enum UrlencodedError {
     /// Can not decode chunked transfer encoding
-    #[fail(display="Can not decode chunked transfer encoding")]
+    #[fail(display = "Can not decode chunked transfer encoding")]
     Chunked,
     /// Payload size is bigger than 256k
-    #[fail(display="Payload size is bigger than 256k")]
+    #[fail(display = "Payload size is bigger than 256k")]
     Overflow,
     /// Payload size is now known
-    #[fail(display="Payload size is now known")]
+    #[fail(display = "Payload size is now known")]
     UnknownLength,
     /// Content type error
-    #[fail(display="Content type error")]
+    #[fail(display = "Content type error")]
     ContentType,
+    /// Parse error
+    #[fail(display = "Parse error")]
+    Parse,
     /// Payload error
-    #[fail(display="Error that occur during reading payload")]
-    Payload(PayloadError),
+    #[fail(display = "Error that occur during reading payload: {}", _0)]
+    Payload(#[cause] PayloadError),
 }
 
 /// Return `BadRequest` for `UrlencodedError`
 impl ResponseError for UrlencodedError {
-
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        match *self {
+            UrlencodedError::Overflow => {
+                HttpResponse::new(StatusCode::PAYLOAD_TOO_LARGE)
+            }
+            UrlencodedError::UnknownLength => {
+                HttpResponse::new(StatusCode::LENGTH_REQUIRED)
+            }
+            _ => HttpResponse::new(StatusCode::BAD_REQUEST),
+        }
     }
 }
 
@@ -417,24 +458,28 @@ impl From<PayloadError> for UrlencodedError {
 #[derive(Fail, Debug)]
 pub enum JsonPayloadError {
     /// Payload size is bigger than 256k
-    #[fail(display="Payload size is bigger than 256k")]
+    #[fail(display = "Payload size is bigger than 256k")]
     Overflow,
     /// Content type error
-    #[fail(display="Content type error")]
+    #[fail(display = "Content type error")]
     ContentType,
     /// Deserialize error
-    #[fail(display="Json deserialize error")]
-    Deserialize(JsonError),
+    #[fail(display = "Json deserialize error: {}", _0)]
+    Deserialize(#[cause] JsonError),
     /// Payload error
-    #[fail(display="Error that occur during reading payload")]
-    Payload(PayloadError),
+    #[fail(display = "Error that occur during reading payload: {}", _0)]
+    Payload(#[cause] PayloadError),
 }
 
 /// Return `BadRequest` for `UrlencodedError`
 impl ResponseError for JsonPayloadError {
-
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        match *self {
+            JsonPayloadError::Overflow => {
+                HttpResponse::new(StatusCode::PAYLOAD_TOO_LARGE)
+            }
+            _ => HttpResponse::new(StatusCode::BAD_REQUEST),
+        }
     }
 }
 
@@ -455,34 +500,33 @@ impl From<JsonError> for JsonPayloadError {
 #[derive(Fail, Debug, PartialEq)]
 pub enum UriSegmentError {
     /// The segment started with the wrapped invalid character.
-    #[fail(display="The segment started with the wrapped invalid character")]
+    #[fail(display = "The segment started with the wrapped invalid character")]
     BadStart(char),
     /// The segment contained the wrapped invalid character.
-    #[fail(display="The segment contained the wrapped invalid character")]
+    #[fail(display = "The segment contained the wrapped invalid character")]
     BadChar(char),
     /// The segment ended with the wrapped invalid character.
-    #[fail(display="The segment ended with the wrapped invalid character")]
+    #[fail(display = "The segment ended with the wrapped invalid character")]
     BadEnd(char),
 }
 
 /// Return `BadRequest` for `UriSegmentError`
 impl ResponseError for UriSegmentError {
-
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
 /// Errors which can occur when attempting to generate resource uri.
 #[derive(Fail, Debug, PartialEq)]
 pub enum UrlGenerationError {
-    #[fail(display="Resource not found")]
+    #[fail(display = "Resource not found")]
     ResourceNotFound,
-    #[fail(display="Not all path pattern covered")]
+    #[fail(display = "Not all path pattern covered")]
     NotEnoughElements,
-    #[fail(display="Router is not available")]
+    #[fail(display = "Router is not available")]
     RouterNotAvailable,
-    #[fail(display="{}", _0)]
+    #[fail(display = "{}", _0)]
     ParseError(#[cause] UrlParseError),
 }
 
@@ -497,8 +541,9 @@ impl From<UrlParseError> for UrlGenerationError {
 
 /// Helper type that can wrap any error and generate custom response.
 ///
-/// In following example any `io::Error` will be converted into "BAD REQUEST" response
-/// as opposite to *INNTERNAL SERVER ERROR* which is defined by default.
+/// In following example any `io::Error` will be converted into "BAD REQUEST"
+/// response as opposite to *INTERNAL SERVER ERROR* which is defined by
+/// default.
 ///
 /// ```rust
 /// # extern crate actix_web;
@@ -513,25 +558,41 @@ impl From<UrlParseError> for UrlGenerationError {
 /// ```
 pub struct InternalError<T> {
     cause: T,
-    status: StatusCode,
+    status: InternalErrorType,
     backtrace: Backtrace,
 }
 
 unsafe impl<T> Sync for InternalError<T> {}
 unsafe impl<T> Send for InternalError<T> {}
 
+enum InternalErrorType {
+    Status(StatusCode),
+    Response(RefCell<Option<HttpResponse>>),
+}
+
 impl<T> InternalError<T> {
-    pub fn new(err: T, status: StatusCode) -> Self {
+    /// Create `InternalError` instance
+    pub fn new(cause: T, status: StatusCode) -> Self {
         InternalError {
-            cause: err,
-            status: status,
+            cause,
+            status: InternalErrorType::Status(status),
+            backtrace: Backtrace::new(),
+        }
+    }
+
+    /// Create `InternalError` with predefined `HttpResponse`.
+    pub fn from_response(cause: T, response: HttpResponse) -> Self {
+        InternalError {
+            cause,
+            status: InternalErrorType::Response(RefCell::new(Some(response))),
             backtrace: Backtrace::new(),
         }
     }
 }
 
 impl<T> Fail for InternalError<T>
-    where T: Send + Sync + fmt::Debug + 'static
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
 {
     fn backtrace(&self) -> Option<&Backtrace> {
         Some(&self.backtrace)
@@ -539,7 +600,8 @@ impl<T> Fail for InternalError<T>
 }
 
 impl<T> fmt::Debug for InternalError<T>
-    where T: Send + Sync + fmt::Debug + 'static
+where
+    T: Send + Sync + fmt::Debug + 'static,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(&self.cause, f)
@@ -547,111 +609,170 @@ impl<T> fmt::Debug for InternalError<T>
 }
 
 impl<T> fmt::Display for InternalError<T>
-    where T: Send + Sync + fmt::Debug + 'static
+where
+    T: Send + Sync + fmt::Display + 'static,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self.cause, f)
+        fmt::Display::fmt(&self.cause, f)
     }
 }
 
 impl<T> ResponseError for InternalError<T>
-    where T: Send + Sync + fmt::Debug + 'static
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
 {
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(self.status, Body::Empty)
+        match self.status {
+            InternalErrorType::Status(st) => HttpResponse::new(st),
+            InternalErrorType::Response(ref resp) => {
+                if let Some(resp) = resp.borrow_mut().take() {
+                    resp
+                } else {
+                    HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR)
+                }
+            }
+        }
     }
 }
 
 impl<T> Responder for InternalError<T>
-    where T: Send + Sync + fmt::Debug + 'static
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
 {
     type Item = HttpResponse;
     type Error = Error;
 
-    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, Error> {
+    fn respond_to<S>(self, _: &HttpRequest<S>) -> Result<HttpResponse, Error> {
         Err(self.into())
     }
 }
 
-/// Helper function that creates wrapper of any error and generate *BAD REQUEST* response.
+/// Helper function that creates wrapper of any error and generate *BAD
+/// REQUEST* response.
 #[allow(non_snake_case)]
-pub fn ErrorBadRequest<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::BAD_REQUEST)
+pub fn ErrorBadRequest<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::BAD_REQUEST).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *UNAUTHORIZED* response.
+/// Helper function that creates wrapper of any error and generate
+/// *UNAUTHORIZED* response.
 #[allow(non_snake_case)]
-pub fn ErrorUnauthorized<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::UNAUTHORIZED)
+pub fn ErrorUnauthorized<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::UNAUTHORIZED).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *FORBIDDEN* response.
+/// Helper function that creates wrapper of any error and generate *FORBIDDEN*
+/// response.
 #[allow(non_snake_case)]
-pub fn ErrorForbidden<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::FORBIDDEN)
+pub fn ErrorForbidden<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::FORBIDDEN).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *NOT FOUND* response.
+/// Helper function that creates wrapper of any error and generate *NOT FOUND*
+/// response.
 #[allow(non_snake_case)]
-pub fn ErrorNotFound<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::NOT_FOUND)
+pub fn ErrorNotFound<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::NOT_FOUND).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *METHOD NOT ALLOWED* response.
+/// Helper function that creates wrapper of any error and generate *METHOD NOT
+/// ALLOWED* response.
 #[allow(non_snake_case)]
-pub fn ErrorMethodNotAllowed<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::METHOD_NOT_ALLOWED)
+pub fn ErrorMethodNotAllowed<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::METHOD_NOT_ALLOWED).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *REQUEST TIMEOUT* response.
+/// Helper function that creates wrapper of any error and generate *REQUEST
+/// TIMEOUT* response.
 #[allow(non_snake_case)]
-pub fn ErrorRequestTimeout<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::REQUEST_TIMEOUT)
+pub fn ErrorRequestTimeout<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::REQUEST_TIMEOUT).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *CONFLICT* response.
+/// Helper function that creates wrapper of any error and generate *CONFLICT*
+/// response.
 #[allow(non_snake_case)]
-pub fn ErrorConflict<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::CONFLICT)
+pub fn ErrorConflict<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::CONFLICT).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *GONE* response.
+/// Helper function that creates wrapper of any error and generate *GONE*
+/// response.
 #[allow(non_snake_case)]
-pub fn ErrorGone<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::GONE)
+pub fn ErrorGone<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::GONE).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *PRECONDITION FAILED* response.
+/// Helper function that creates wrapper of any error and generate
+/// *PRECONDITION FAILED* response.
 #[allow(non_snake_case)]
-pub fn ErrorPreconditionFailed<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::PRECONDITION_FAILED)
+pub fn ErrorPreconditionFailed<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::PRECONDITION_FAILED).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *EXPECTATION FAILED* response.
+/// Helper function that creates wrapper of any error and generate
+/// *EXPECTATION FAILED* response.
 #[allow(non_snake_case)]
-pub fn ErrorExpectationFailed<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::EXPECTATION_FAILED)
+pub fn ErrorExpectationFailed<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::EXPECTATION_FAILED).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *INTERNAL SERVER ERROR* response.
+/// Helper function that creates wrapper of any error and
+/// generate *INTERNAL SERVER ERROR* response.
 #[allow(non_snake_case)]
-pub fn ErrorInternalServerError<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::INTERNAL_SERVER_ERROR)
+pub fn ErrorInternalServerError<T>(err: T) -> Error
+where
+    T: Send + Sync + fmt::Debug + fmt::Display + 'static,
+{
+    InternalError::new(err, StatusCode::INTERNAL_SERVER_ERROR).into()
 }
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+    use cookie::ParseError as CookieParseError;
+    use failure;
+    use http::{Error as HttpError, StatusCode};
+    use httparse;
+    use std::env;
     use std::error::Error as StdError;
     use std::io;
-    use httparse;
-    use http::{StatusCode, Error as HttpError};
-    use cookie::ParseError as CookieParseError;
-    use super::*;
 
     #[test]
     #[cfg(actix_nightly)]
     fn test_nightly() {
-        let resp: HttpResponse = IoError::new(io::ErrorKind::Other, "test").error_response();
+        let resp: HttpResponse =
+            IoError::new(io::ErrorKind::Other, "test").error_response();
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
@@ -682,6 +803,12 @@ mod tests {
         assert_eq!(format!("{}", e.cause().unwrap()), desc);
     }
 
+    #[test]
+    fn test_backtrace() {
+        let e = ErrorBadRequest("err");
+        let _ = e.backtrace();
+    }
+
     #[test]
     fn test_error_cause() {
         let orig = io::Error::new(io::ErrorKind::Other, "other");
@@ -722,31 +849,15 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::EXPECTATION_FAILED);
     }
 
-    #[test]
-    fn test_wserror_http_response() {
-        let resp: HttpResponse = WsHandshakeError::GetMethodRequired.error_response();
-        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
-        let resp: HttpResponse = WsHandshakeError::NoWebsocketUpgrade.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: HttpResponse = WsHandshakeError::NoConnectionUpgrade.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: HttpResponse = WsHandshakeError::NoVersionHeader.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: HttpResponse = WsHandshakeError::UnsupportedVersion.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: HttpResponse = WsHandshakeError::BadWebsocketKey.error_response();
-        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-    }
-
     macro_rules! from {
         ($from:expr => $error:pat) => {
             match ParseError::from($from) {
                 e @ $error => {
                     assert!(format!("{}", e).len() >= 5);
-                } ,
-                e => panic!("{:?}", e)
+                }
+                e => unreachable!("{:?}", e),
             }
-        }
+        };
     }
 
     macro_rules! from_and_cause {
@@ -755,10 +866,10 @@ mod tests {
                 e @ $error => {
                     let desc = format!("{}", e.cause().unwrap());
                     assert_eq!(desc, $from.description().to_owned());
-                },
-                _ => panic!("{:?}", $from)
+                }
+                _ => unreachable!("{:?}", $from),
             }
-        }
+        };
     }
 
     #[test]
@@ -774,4 +885,31 @@ mod tests {
         from!(httparse::Error::TooManyHeaders => ParseError::TooLarge);
         from!(httparse::Error::Version => ParseError::Version);
     }
+
+    #[test]
+    fn failure_error() {
+        const NAME: &str = "RUST_BACKTRACE";
+        let old_tb = env::var(NAME);
+        env::set_var(NAME, "0");
+        let error = failure::err_msg("Hello!");
+        let resp: Error = error.into();
+        assert_eq!(
+            format!("{:?}", resp),
+            "Compat { error: ErrorMessage { msg: \"Hello!\" } }\n\n"
+        );
+        match old_tb {
+            Ok(x) => env::set_var(NAME, x),
+            _ => env::remove_var(NAME),
+        }
+    }
+
+    #[test]
+    fn test_internal_error() {
+        let err = InternalError::from_response(
+            ExpectError::Encoding,
+            HttpResponse::Ok().into(),
+        );
+        let resp: HttpResponse = err.error_response();
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
 }

src/extractor.rs

@@ -0,0 +1,763 @@
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+use std::str;
+
+use bytes::Bytes;
+use encoding::all::UTF_8;
+use encoding::types::{DecoderTrap, Encoding};
+use futures::{Async, Future, Poll};
+use mime::Mime;
+use serde::de::{self, DeserializeOwned};
+use serde_urlencoded;
+
+use de::PathDeserializer;
+use error::{Error, ErrorNotFound, ErrorBadRequest};
+use handler::{AsyncResult, FromRequest};
+use httpmessage::{HttpMessage, MessageBody, UrlEncoded};
+use httprequest::HttpRequest;
+
+/// Extract typed information from the request's path.
+///
+/// ## Example
+///
+/// ```rust
+/// # extern crate bytes;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// use actix_web::{App, Path, Result, http};
+///
+/// /// extract path info from "/{username}/{count}/index.html" url
+/// /// {username} - deserializes to a String
+/// /// {count} -  - deserializes to a u32
+/// fn index(info: Path<(String, u32)>) -> Result<String> {
+///     Ok(format!("Welcome {}! {}", info.0, info.1))
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/{username}/{count}/index.html",              // <- define path parameters
+///        |r| r.method(http::Method::GET).with(index));  // <- use `with` extractor
+/// }
+/// ```
+///
+/// It is possible to extract path information to a specific type that
+/// implements `Deserialize` trait from *serde*.
+///
+/// ```rust
+/// # extern crate bytes;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Path, Result, http};
+///
+/// #[derive(Deserialize)]
+/// struct Info {
+///     username: String,
+/// }
+///
+/// /// extract path info using serde
+/// fn index(info: Path<Info>) -> Result<String> {
+///     Ok(format!("Welcome {}!", info.username))
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/{username}/index.html",                // <- define path parameters
+///        |r| r.method(http::Method::GET).with(index));  // <- use `with` extractor
+/// }
+/// ```
+pub struct Path<T> {
+    inner: T,
+}
+
+impl<T> AsRef<T> for Path<T> {
+    fn as_ref(&self) -> &T {
+        &self.inner
+    }
+}
+
+impl<T> Deref for Path<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for Path<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+}
+
+impl<T> Path<T> {
+    /// Deconstruct to an inner value
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+}
+
+impl<T, S> FromRequest<S> for Path<T>
+where
+    T: DeserializeOwned,
+{
+    type Config = ();
+    type Result = Result<Self, Error>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
+        let req = req.clone();
+        de::Deserialize::deserialize(PathDeserializer::new(&req))
+            .map_err(ErrorNotFound)
+            .map(|inner| Path { inner })
+    }
+}
+
+/// Extract typed information from from the request's query.
+///
+/// ## Example
+///
+/// ```rust
+/// # extern crate bytes;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Query, http};
+///
+/// #[derive(Deserialize)]
+/// struct Info {
+///     username: String,
+/// }
+///
+/// // use `with` extractor for query info
+/// // this handler get called only if request's query contains `username` field
+/// fn index(info: Query<Info>) -> String {
+///     format!("Welcome {}!", info.username)
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/index.html",
+///        |r| r.method(http::Method::GET).with(index)); // <- use `with` extractor
+/// }
+/// ```
+pub struct Query<T>(T);
+
+impl<T> Deref for Query<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for Query<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+}
+
+impl<T> Query<T> {
+    /// Deconstruct to a inner value
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+impl<T, S> FromRequest<S> for Query<T>
+where
+    T: de::DeserializeOwned,
+{
+    type Config = ();
+    type Result = Result<Self, Error>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
+        let req = req.clone();
+        serde_urlencoded::from_str::<T>(req.query_string())
+            .map_err(|e| e.into())
+            .map(Query)
+    }
+}
+
+/// Extract typed information from the request's body.
+///
+/// To extract typed information from request's body, the type `T` must
+/// implement the `Deserialize` trait from *serde*.
+///
+/// [**FormConfig**](dev/struct.FormConfig.html) allows to configure extraction
+/// process.
+///
+/// ## Example
+///
+/// ```rust
+/// # extern crate actix_web;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Form, Result};
+///
+/// #[derive(Deserialize)]
+/// struct FormData {
+///     username: String,
+/// }
+///
+/// /// extract form data using serde
+/// /// this handler get called only if content type is *x-www-form-urlencoded*
+/// /// and content of the request could be deserialized to a `FormData` struct
+/// fn index(form: Form<FormData>) -> Result<String> {
+///     Ok(format!("Welcome {}!", form.username))
+/// }
+/// # fn main() {}
+/// ```
+pub struct Form<T>(pub T);
+
+impl<T> Form<T> {
+    /// Deconstruct to an inner value
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+impl<T> Deref for Form<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for Form<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+}
+
+impl<T, S> FromRequest<S> for Form<T>
+where
+    T: DeserializeOwned + 'static,
+    S: 'static,
+{
+    type Config = FormConfig;
+    type Result = Box<Future<Item = Self, Error = Error>>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
+        Box::new(
+            UrlEncoded::new(req.clone())
+                .limit(cfg.limit)
+                .from_err()
+                .map(Form),
+        )
+    }
+}
+
+/// Form extractor configuration
+///
+/// ```rust
+/// # extern crate actix_web;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Form, Result, http};
+///
+/// #[derive(Deserialize)]
+/// struct FormData {
+///     username: String,
+/// }
+///
+/// /// extract form data using serde.
+/// /// custom configuration is used for this handler, max payload size is 4k
+/// fn index(form: Form<FormData>) -> Result<String> {
+///     Ok(format!("Welcome {}!", form.username))
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/index.html", |r| {
+///            r.method(http::Method::GET)
+///              .with(index)
+///              .limit(4096);} // <- change form extractor configuration
+///     );
+/// }
+/// ```
+pub struct FormConfig {
+    limit: usize,
+}
+
+impl FormConfig {
+    /// Change max size of payload. By default max size is 256Kb
+    pub fn limit(&mut self, limit: usize) -> &mut Self {
+        self.limit = limit;
+        self
+    }
+}
+
+impl Default for FormConfig {
+    fn default() -> Self {
+        FormConfig { limit: 262_144 }
+    }
+}
+
+/// Request payload extractor.
+///
+/// Loads request's payload and construct Bytes instance.
+///
+/// [**PayloadConfig**](dev/struct.PayloadConfig.html) allows to configure
+/// extraction process.
+///
+/// ## Example
+///
+/// ```rust
+/// extern crate bytes;
+/// # extern crate actix_web;
+/// use actix_web::{http, App, Result};
+///
+/// /// extract text data from request
+/// fn index(body: bytes::Bytes) -> Result<String> {
+///     Ok(format!("Body {:?}!", body))
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/index.html", |r|
+///            r.method(http::Method::GET).with(index));
+/// }
+/// ```
+impl<S: 'static> FromRequest<S> for Bytes {
+    type Config = PayloadConfig;
+    type Result = Result<Box<Future<Item = Self, Error = Error>>, Error>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
+        // check content-type
+        cfg.check_mimetype(req)?;
+
+        Ok(Box::new(
+            MessageBody::new(req.clone())
+                .limit(cfg.limit)
+                .from_err(),
+        ))
+    }
+}
+
+/// Extract text information from the request's body.
+///
+/// Text extractor automatically decode body according to the request's charset.
+///
+/// [**PayloadConfig**](dev/struct.PayloadConfig.html) allows to configure
+/// extraction process.
+///
+/// ## Example
+///
+/// ```rust
+/// # extern crate actix_web;
+/// use actix_web::{http, App, Result};
+///
+/// /// extract text data from request
+/// fn index(body: String) -> Result<String> {
+///     Ok(format!("Body {}!", body))
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/index.html", |r| {
+///            r.method(http::Method::GET)
+///                .with(index)   // <- register handler with extractor params
+///                .limit(4096);  // <- limit size of the payload
+///        });
+/// }
+/// ```
+impl<S: 'static> FromRequest<S> for String {
+    type Config = PayloadConfig;
+    type Result = Result<Box<Future<Item = String, Error = Error>>, Error>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
+        // check content-type
+        cfg.check_mimetype(req)?;
+
+        // check charset
+        let encoding = req.encoding()?;
+
+        Ok(Box::new(
+            MessageBody::new(req.clone())
+                .limit(cfg.limit)
+                .from_err()
+                .and_then(move |body| {
+                    let enc: *const Encoding = encoding as *const Encoding;
+                    if enc == UTF_8 {
+                        Ok(str::from_utf8(body.as_ref())
+                            .map_err(|_| ErrorBadRequest("Can not decode body"))?
+                            .to_owned())
+                    } else {
+                        Ok(encoding
+                            .decode(&body, DecoderTrap::Strict)
+                            .map_err(|_| ErrorBadRequest("Can not decode body"))?)
+                    }
+                }),
+        ))
+    }
+}
+
+/// Payload configuration for request's payload.
+pub struct PayloadConfig {
+    limit: usize,
+    mimetype: Option<Mime>,
+}
+
+impl PayloadConfig {
+    /// Change max size of payload. By default max size is 256Kb
+    pub fn limit(&mut self, limit: usize) -> &mut Self {
+        self.limit = limit;
+        self
+    }
+
+    /// Set required mime-type of the request. By default mime type is not
+    /// enforced.
+    pub fn mimetype(&mut self, mt: Mime) -> &mut Self {
+        self.mimetype = Some(mt);
+        self
+    }
+
+    fn check_mimetype<S>(&self, req: &HttpRequest<S>) -> Result<(), Error> {
+        // check content-type
+        if let Some(ref mt) = self.mimetype {
+            match req.mime_type() {
+                Ok(Some(ref req_mt)) => {
+                    if mt != req_mt {
+                        return Err(ErrorBadRequest("Unexpected Content-Type"));
+                    }
+                }
+                Ok(None) => {
+                    return Err(ErrorBadRequest("Content-Type is expected"));
+                }
+                Err(err) => {
+                    return Err(err.into());
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Default for PayloadConfig {
+    fn default() -> Self {
+        PayloadConfig {
+            limit: 262_144,
+            mimetype: None,
+        }
+    }
+}
+
+macro_rules! tuple_from_req ({$fut_type:ident, $(($n:tt, $T:ident)),+} => {
+
+    /// FromRequest implementation for tuple
+    impl<S, $($T: FromRequest<S> + 'static),+> FromRequest<S> for ($($T,)+)
+    where
+        S: 'static,
+    {
+        type Config = ($($T::Config,)+);
+        type Result = Box<Future<Item = ($($T,)+), Error = Error>>;
+
+        fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
+            Box::new($fut_type {
+                s: PhantomData,
+                items: <($(Option<$T>,)+)>::default(),
+                futs: ($(Some($T::from_request(req, &cfg.$n).into()),)+),
+            })
+        }
+    }
+
+    struct $fut_type<S, $($T: FromRequest<S>),+>
+    where
+        S: 'static,
+    {
+        s: PhantomData<S>,
+        items: ($(Option<$T>,)+),
+        futs: ($(Option<AsyncResult<$T>>,)+),
+    }
+
+    impl<S, $($T: FromRequest<S>),+> Future for $fut_type<S, $($T),+>
+    where
+        S: 'static,
+    {
+        type Item = ($($T,)+);
+        type Error = Error;
+
+        fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+            let mut ready = true;
+
+            $(
+                if self.futs.$n.is_some() {
+                    match self.futs.$n.as_mut().unwrap().poll() {
+                        Ok(Async::Ready(item)) => {
+                            self.items.$n = Some(item);
+                            self.futs.$n.take();
+                        }
+                        Ok(Async::NotReady) => ready = false,
+                        Err(e) => return Err(e),
+                    }
+                }
+            )+
+
+                if ready {
+                    Ok(Async::Ready(
+                        ($(self.items.$n.take().unwrap(),)+)
+                    ))
+                } else {
+                    Ok(Async::NotReady)
+                }
+        }
+    }
+});
+
+tuple_from_req!(TupleFromRequest1, (0, A));
+tuple_from_req!(TupleFromRequest2, (0, A), (1, B));
+tuple_from_req!(TupleFromRequest3, (0, A), (1, B), (2, C));
+tuple_from_req!(TupleFromRequest4, (0, A), (1, B), (2, C), (3, D));
+tuple_from_req!(
+    TupleFromRequest5,
+    (0, A),
+    (1, B),
+    (2, C),
+    (3, D),
+    (4, E)
+);
+tuple_from_req!(
+    TupleFromRequest6,
+    (0, A),
+    (1, B),
+    (2, C),
+    (3, D),
+    (4, E),
+    (5, F)
+);
+tuple_from_req!(
+    TupleFromRequest7,
+    (0, A),
+    (1, B),
+    (2, C),
+    (3, D),
+    (4, E),
+    (5, F),
+    (6, G)
+);
+tuple_from_req!(
+    TupleFromRequest8,
+    (0, A),
+    (1, B),
+    (2, C),
+    (3, D),
+    (4, E),
+    (5, F),
+    (6, G),
+    (7, H)
+);
+tuple_from_req!(
+    TupleFromRequest9,
+    (0, A),
+    (1, B),
+    (2, C),
+    (3, D),
+    (4, E),
+    (5, F),
+    (6, G),
+    (7, H),
+    (8, I)
+);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bytes::Bytes;
+    use futures::{Async, Future};
+    use http::header;
+    use mime;
+    use resource::ResourceHandler;
+    use router::{Resource, Router};
+    use server::ServerSettings;
+    use test::TestRequest;
+
+    #[derive(Deserialize, Debug, PartialEq)]
+    struct Info {
+        hello: String,
+    }
+
+    #[test]
+    fn test_bytes() {
+        let cfg = PayloadConfig::default();
+        let mut req = TestRequest::with_header(header::CONTENT_LENGTH, "11").finish();
+        req.payload_mut()
+            .unread_data(Bytes::from_static(b"hello=world"));
+
+        match Bytes::from_request(&req, &cfg)
+            .unwrap()
+            .poll()
+            .unwrap()
+        {
+            Async::Ready(s) => {
+                assert_eq!(s, Bytes::from_static(b"hello=world"));
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_string() {
+        let cfg = PayloadConfig::default();
+        let mut req = TestRequest::with_header(header::CONTENT_LENGTH, "11").finish();
+        req.payload_mut()
+            .unread_data(Bytes::from_static(b"hello=world"));
+
+        match String::from_request(&req, &cfg)
+            .unwrap()
+            .poll()
+            .unwrap()
+        {
+            Async::Ready(s) => {
+                assert_eq!(s, "hello=world");
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_form() {
+        let mut req = TestRequest::with_header(
+            header::CONTENT_TYPE,
+            "application/x-www-form-urlencoded",
+        ).header(header::CONTENT_LENGTH, "11")
+            .finish();
+        req.payload_mut()
+            .unread_data(Bytes::from_static(b"hello=world"));
+
+        let mut cfg = FormConfig::default();
+        cfg.limit(4096);
+        match Form::<Info>::from_request(&req, &cfg).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s.hello, "world");
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_payload_config() {
+        let req = HttpRequest::default();
+        let mut cfg = PayloadConfig::default();
+        cfg.mimetype(mime::APPLICATION_JSON);
+        assert!(cfg.check_mimetype(&req).is_err());
+
+        let req = TestRequest::with_header(
+            header::CONTENT_TYPE,
+            "application/x-www-form-urlencoded",
+        ).finish();
+        assert!(cfg.check_mimetype(&req).is_err());
+
+        let req =
+            TestRequest::with_header(header::CONTENT_TYPE, "application/json").finish();
+        assert!(cfg.check_mimetype(&req).is_ok());
+    }
+
+    #[derive(Deserialize)]
+    struct MyStruct {
+        key: String,
+        value: String,
+    }
+
+    #[derive(Deserialize)]
+    struct Id {
+        id: String,
+    }
+
+    #[derive(Deserialize)]
+    struct Test2 {
+        key: String,
+        value: u32,
+    }
+
+    #[test]
+    fn test_request_extract() {
+        let mut req = TestRequest::with_uri("/name/user1/?id=test").finish();
+
+        let mut resource = ResourceHandler::<()>::default();
+        resource.name("index");
+        let mut routes = Vec::new();
+        routes.push((
+            Resource::new("index", "/{key}/{value}/"),
+            Some(resource),
+        ));
+        let (router, _) = Router::new("", ServerSettings::default(), routes);
+        assert!(router.recognize(&mut req).is_some());
+
+        let s = Path::<MyStruct>::from_request(&req, &()).unwrap();
+        assert_eq!(s.key, "name");
+        assert_eq!(s.value, "user1");
+
+        let s = Path::<(String, String)>::from_request(&req, &()).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, "user1");
+
+        let s = Query::<Id>::from_request(&req, &()).unwrap();
+        assert_eq!(s.id, "test");
+
+        let mut req = TestRequest::with_uri("/name/32/").finish();
+        assert!(router.recognize(&mut req).is_some());
+
+        let s = Path::<Test2>::from_request(&req, &()).unwrap();
+        assert_eq!(s.as_ref().key, "name");
+        assert_eq!(s.value, 32);
+
+        let s = Path::<(String, u8)>::from_request(&req, &()).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
+        let res = Path::<Vec<String>>::extract(&req).unwrap();
+        assert_eq!(res[0], "name".to_owned());
+        assert_eq!(res[1], "32".to_owned());
+    }
+
+    #[test]
+    fn test_extract_path_single() {
+        let mut resource = ResourceHandler::<()>::default();
+        resource.name("index");
+        let mut routes = Vec::new();
+        routes.push((Resource::new("index", "/{value}/"), Some(resource)));
+        let (router, _) = Router::new("", ServerSettings::default(), routes);
+
+        let mut req = TestRequest::with_uri("/32/").finish();
+        assert!(router.recognize(&mut req).is_some());
+
+        assert_eq!(*Path::<i8>::from_request(&mut req, &()).unwrap(), 32);
+    }
+
+    #[test]
+    fn test_tuple_extract() {
+        let mut req = TestRequest::with_uri("/name/user1/?id=test").finish();
+
+        let mut resource = ResourceHandler::<()>::default();
+        resource.name("index");
+        let mut routes = Vec::new();
+        routes.push((
+            Resource::new("index", "/{key}/{value}/"),
+            Some(resource),
+        ));
+        let (router, _) = Router::new("", ServerSettings::default(), routes);
+        assert!(router.recognize(&mut req).is_some());
+
+        let res = match <(Path<(String, String)>,)>::extract(&req).poll() {
+            Ok(Async::Ready(res)) => res,
+            _ => panic!("error"),
+        };
+        assert_eq!((res.0).0, "name");
+        assert_eq!((res.0).1, "user1");
+
+        let res = match <(Path<(String, String)>, Path<(String, String)>)>::extract(&req)
+            .poll()
+        {
+            Ok(Async::Ready(res)) => res,
+            _ => panic!("error"),
+        };
+        assert_eq!((res.0).0, "name");
+        assert_eq!((res.0).1, "user1");
+        assert_eq!((res.1).0, "name");
+        assert_eq!((res.1).1, "user1");
+    }
+}

src/handler.rs

@@ -1,10 +1,9 @@
 use std::marker::PhantomData;
+use std::ops::Deref;
 
-use regex::Regex;
-use futures::future::{Future, ok, err};
-use http::{header, StatusCode, Error as HttpError};
+use futures::future::{err, ok, Future};
+use futures::{Async, Poll};
 
-use body::Body;
 use error::Error;
 use httprequest::HttpRequest;
 use httpresponse::HttpResponse;
@@ -12,7 +11,6 @@ use httpresponse::HttpResponse;
 /// Trait defines object that could be registered as route handler
 #[allow(unused_variables)]
 pub trait Handler<S>: 'static {
-
     /// The type of value that handler will return.
     type Result: Responder;
 
@@ -25,35 +23,161 @@ pub trait Handler<S>: 'static {
 /// Types that implement this trait can be used as the return type of a handler.
 pub trait Responder {
     /// The associated item which can be returned.
-    type Item: Into<Reply>;
+    type Item: Into<AsyncResult<HttpResponse>>;
 
     /// The associated error which can be returned.
     type Error: Into<Error>;
 
-    /// Convert itself to `Reply` or `Error`.
-    fn respond_to(self, req: HttpRequest) -> Result<Self::Item, Self::Error>;
+    /// Convert itself to `AsyncResult` or `Error`.
+    fn respond_to<S: 'static>(
+        self, req: &HttpRequest<S>,
+    ) -> Result<Self::Item, Self::Error>;
 }
 
-#[doc(hidden)]
-/// Convenience trait that convert `Future` object into `Boxed` future
+/// Trait implemented by types that can be extracted from request.
+///
+/// Types that implement this trait can be used with `Route::with()` method.
+pub trait FromRequest<S>: Sized {
+    /// Configuration for conversion process
+    type Config: Default;
+
+    /// Future that resolves to a Self
+    type Result: Into<AsyncResult<Self>>;
+
+    /// Convert request to a Self
+    fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result;
+
+    /// Convert request to a Self
+    ///
+    /// This method uses default extractor configuration
+    fn extract(req: &HttpRequest<S>) -> Self::Result {
+        Self::from_request(req, &Self::Config::default())
+    }
+}
+
+/// Combines two different responder types into a single type
+///
+/// ```rust
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # use futures::future::Future;
+/// use futures::future::result;
+/// use actix_web::{Either, Error, HttpRequest, HttpResponse, AsyncResponder};
+///
+/// type RegisterResult = Either<HttpResponse, Box<Future<Item=HttpResponse, Error=Error>>>;
+///
+///
+/// fn index(req: HttpRequest) -> RegisterResult {
+///     if is_a_variant() { // <- choose variant A
+///         Either::A(
+///             HttpResponse::BadRequest().body("Bad data"))
+///     } else {
+///         Either::B(      // <- variant B
+///             result(Ok(HttpResponse::Ok()
+///                    .content_type("text/html")
+///                    .body("Hello!")))
+///                    .responder())
+///     }
+/// }
+/// # fn is_a_variant() -> bool { true }
+/// # fn main() {}
+/// ```
+#[derive(Debug)]
+pub enum Either<A, B> {
+    /// First branch of the type
+    A(A),
+    /// Second branch of the type
+    B(B),
+}
+
+impl<A, B> Responder for Either<A, B>
+where
+    A: Responder,
+    B: Responder,
+{
+    type Item = AsyncResult<HttpResponse>;
+    type Error = Error;
+
+    fn respond_to<S: 'static>(
+        self, req: &HttpRequest<S>,
+    ) -> Result<AsyncResult<HttpResponse>, Error> {
+        match self {
+            Either::A(a) => match a.respond_to(req) {
+                Ok(val) => Ok(val.into()),
+                Err(err) => Err(err.into()),
+            },
+            Either::B(b) => match b.respond_to(req) {
+                Ok(val) => Ok(val.into()),
+                Err(err) => Err(err.into()),
+            },
+        }
+    }
+}
+
+impl<A, B, I, E> Future for Either<A, B>
+where
+    A: Future<Item = I, Error = E>,
+    B: Future<Item = I, Error = E>,
+{
+    type Item = I;
+    type Error = E;
+
+    fn poll(&mut self) -> Poll<I, E> {
+        match *self {
+            Either::A(ref mut fut) => fut.poll(),
+            Either::B(ref mut fut) => fut.poll(),
+        }
+    }
+}
+
+/// Convenience trait that converts `Future` object to a `Boxed` future
+///
+/// For example loading json from request's body is async operation.
+///
+/// ```rust
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # #[macro_use] extern crate serde_derive;
+/// use futures::future::Future;
+/// use actix_web::{
+///     App, HttpRequest, HttpResponse, HttpMessage, Error, AsyncResponder};
+///
+/// #[derive(Deserialize, Debug)]
+/// struct MyObj {
+///     name: String,
+/// }
+///
+/// fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+///     req.json()                   // <- get JsonBody future
+///        .from_err()
+///        .and_then(|val: MyObj| {  // <- deserialized value
+///            Ok(HttpResponse::Ok().into())
+///        })
+///     // Construct boxed future by using `AsyncResponder::responder()` method
+///     .responder()
+/// }
+/// # fn main() {}
+/// ```
 pub trait AsyncResponder<I, E>: Sized {
-    fn responder(self) -> Box<Future<Item=I, Error=E>>;
+    fn responder(self) -> Box<Future<Item = I, Error = E>>;
 }
 
 impl<F, I, E> AsyncResponder<I, E> for F
-    where F: Future<Item=I, Error=E> + 'static,
-          I: Responder + 'static,
-          E: Into<Error> + 'static,
+where
+    F: Future<Item = I, Error = E> + 'static,
+    I: Responder + 'static,
+    E: Into<Error> + 'static,
 {
-    fn responder(self) -> Box<Future<Item=I, Error=E>> {
+    fn responder(self) -> Box<Future<Item = I, Error = E>> {
         Box::new(self)
     }
 }
 
 /// Handler<S> for Fn()
 impl<F, R, S> Handler<S> for F
-    where F: Fn(HttpRequest<S>) -> R + 'static,
-          R: Responder + 'static
+where
+    F: Fn(HttpRequest<S>) -> R + 'static,
+    R: Responder + 'static,
 {
     type Result = R;
 
@@ -62,77 +186,117 @@ impl<F, R, S> Handler<S> for F
     }
 }
 
-/// Represents response process.
-pub struct Reply(ReplyItem);
+/// Represents async result
+///
+/// Result could be in tree different forms.
+/// * Ok(T) - ready item
+/// * Err(E) - error happen during reply process
+/// * Future<T, E> - reply process completes in the future
+pub struct AsyncResult<I, E = Error>(Option<AsyncResultItem<I, E>>);
 
-pub(crate) enum ReplyItem {
-    Message(HttpResponse),
-    Future(Box<Future<Item=HttpResponse, Error=Error>>),
+impl<I, E> Future for AsyncResult<I, E> {
+    type Item = I;
+    type Error = E;
+
+    fn poll(&mut self) -> Poll<I, E> {
+        let res = self.0.take().expect("use after resolve");
+        match res {
+            AsyncResultItem::Ok(msg) => Ok(Async::Ready(msg)),
+            AsyncResultItem::Err(err) => Err(err),
+            AsyncResultItem::Future(mut fut) => match fut.poll() {
+                Ok(Async::NotReady) => {
+                    self.0 = Some(AsyncResultItem::Future(fut));
+                    Ok(Async::NotReady)
+                }
+                Ok(Async::Ready(msg)) => Ok(Async::Ready(msg)),
+                Err(err) => Err(err),
+            },
+        }
+    }
 }
 
-impl Reply {
+pub(crate) enum AsyncResultItem<I, E> {
+    Ok(I),
+    Err(E),
+    Future(Box<Future<Item = I, Error = E>>),
+}
 
+impl<I, E> AsyncResult<I, E> {
     /// Create async response
     #[inline]
-    pub fn async<F>(fut: F) -> Reply
-        where F: Future<Item=HttpResponse, Error=Error> + 'static
-    {
-        Reply(ReplyItem::Future(Box::new(fut)))
+    pub fn async(fut: Box<Future<Item = I, Error = E>>) -> AsyncResult<I, E> {
+        AsyncResult(Some(AsyncResultItem::Future(fut)))
     }
 
     /// Send response
     #[inline]
-    pub fn response<R: Into<HttpResponse>>(response: R) -> Reply {
-        Reply(ReplyItem::Message(response.into()))
+    pub fn ok<R: Into<I>>(ok: R) -> AsyncResult<I, E> {
+        AsyncResult(Some(AsyncResultItem::Ok(ok.into())))
+    }
+
+    /// Send error
+    #[inline]
+    pub fn err<R: Into<E>>(err: R) -> AsyncResult<I, E> {
+        AsyncResult(Some(AsyncResultItem::Err(err.into())))
     }
 
     #[inline]
-    pub(crate) fn into(self) -> ReplyItem {
-        self.0
+    pub(crate) fn into(self) -> AsyncResultItem<I, E> {
+        self.0.expect("use after resolve")
     }
 
     #[cfg(test)]
-    pub(crate) fn as_response(&self) -> Option<&HttpResponse> {
-        match self.0 {
-            ReplyItem::Message(ref resp) => Some(resp),
+    pub(crate) fn as_msg(&self) -> &I {
+        match self.0.as_ref().unwrap() {
+            &AsyncResultItem::Ok(ref resp) => resp,
+            _ => panic!(),
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn as_err(&self) -> Option<&E> {
+        match self.0.as_ref().unwrap() {
+            &AsyncResultItem::Err(ref err) => Some(err),
             _ => None,
         }
     }
 }
 
-impl Responder for Reply {
-    type Item = Reply;
+impl Responder for AsyncResult<HttpResponse> {
+    type Item = AsyncResult<HttpResponse>;
     type Error = Error;
 
-    fn respond_to(self, _: HttpRequest) -> Result<Reply, Error> {
+    fn respond_to<S>(
+        self, _: &HttpRequest<S>,
+    ) -> Result<AsyncResult<HttpResponse>, Error> {
         Ok(self)
     }
 }
 
 impl Responder for HttpResponse {
-    type Item = Reply;
+    type Item = AsyncResult<HttpResponse>;
     type Error = Error;
 
     #[inline]
-    fn respond_to(self, _: HttpRequest) -> Result<Reply, Error> {
-        Ok(Reply(ReplyItem::Message(self)))
+    fn respond_to<S>(
+        self, _: &HttpRequest<S>,
+    ) -> Result<AsyncResult<HttpResponse>, Error> {
+        Ok(AsyncResult(Some(AsyncResultItem::Ok(self))))
     }
 }
 
-impl From<HttpResponse> for Reply {
-
+impl<T> From<T> for AsyncResult<T> {
     #[inline]
-    fn from(resp: HttpResponse) -> Reply {
-        Reply(ReplyItem::Message(resp))
+    fn from(resp: T) -> AsyncResult<T> {
+        AsyncResult(Some(AsyncResultItem::Ok(resp)))
     }
 }
 
-impl<T: Responder, E: Into<Error>> Responder for Result<T, E>
-{
+impl<T: Responder, E: Into<Error>> Responder for Result<T, E> {
     type Item = <T as Responder>::Item;
     type Error = Error;
 
-    fn respond_to(self, req: HttpRequest) -> Result<Self::Item, Self::Error> {
+    fn respond_to<S: 'static>(self, req: &HttpRequest<S>) -> Result<Self::Item, Error> {
         match self {
             Ok(val) => match val.respond_to(req) {
                 Ok(val) => Ok(val),
@@ -143,420 +307,217 @@ impl<T: Responder, E: Into<Error>> Responder for Result<T, E>
     }
 }
 
-impl<E: Into<Error>> From<Result<Reply, E>> for Reply {
+impl<T, E: Into<Error>> From<Result<AsyncResult<T>, E>> for AsyncResult<T> {
     #[inline]
-    fn from(res: Result<Reply, E>) -> Self {
+    fn from(res: Result<AsyncResult<T>, E>) -> Self {
         match res {
             Ok(val) => val,
-            Err(err) => Reply(ReplyItem::Message(err.into().into())),
+            Err(err) => AsyncResult(Some(AsyncResultItem::Err(err.into()))),
         }
     }
 }
 
-impl<E: Into<Error>> From<Result<HttpResponse, E>> for Reply {
+impl<T, E: Into<Error>> From<Result<T, E>> for AsyncResult<T> {
     #[inline]
-    fn from(res: Result<HttpResponse, E>) -> Self {
+    fn from(res: Result<T, E>) -> Self {
         match res {
-            Ok(val) => Reply(ReplyItem::Message(val)),
-            Err(err) => Reply(ReplyItem::Message(err.into().into())),
+            Ok(val) => AsyncResult(Some(AsyncResultItem::Ok(val))),
+            Err(err) => AsyncResult(Some(AsyncResultItem::Err(err.into()))),
         }
     }
 }
 
-impl From<Box<Future<Item=HttpResponse, Error=Error>>> for Reply {
+impl<T, E: Into<Error>> From<Result<Box<Future<Item = T, Error = Error>>, E>>
+    for AsyncResult<T>
+{
     #[inline]
-    fn from(fut: Box<Future<Item=HttpResponse, Error=Error>>) -> Reply {
-        Reply(ReplyItem::Future(fut))
+    fn from(res: Result<Box<Future<Item = T, Error = Error>>, E>) -> Self {
+        match res {
+            Ok(fut) => AsyncResult(Some(AsyncResultItem::Future(fut))),
+            Err(err) => AsyncResult(Some(AsyncResultItem::Err(err.into()))),
+        }
     }
 }
 
-impl<I, E> Responder for Box<Future<Item=I, Error=E>>
-    where I: Responder + 'static,
-          E: Into<Error> + 'static
+impl<T> From<Box<Future<Item = T, Error = Error>>> for AsyncResult<T> {
+    #[inline]
+    fn from(fut: Box<Future<Item = T, Error = Error>>) -> AsyncResult<T> {
+        AsyncResult(Some(AsyncResultItem::Future(fut)))
+    }
+}
+
+/// Convenience type alias
+pub type FutureResponse<I, E = Error> = Box<Future<Item = I, Error = E>>;
+
+impl<I, E> Responder for Box<Future<Item = I, Error = E>>
+where
+    I: Responder + 'static,
+    E: Into<Error> + 'static,
 {
-    type Item = Reply;
+    type Item = AsyncResult<HttpResponse>;
     type Error = Error;
 
     #[inline]
-    fn respond_to(self, req: HttpRequest) -> Result<Reply, Error> {
+    fn respond_to<S: 'static>(
+        self, req: &HttpRequest<S>,
+    ) -> Result<AsyncResult<HttpResponse>, Error> {
+        let req = req.clone();
         let fut = self.map_err(|e| e.into())
-            .then(move |r| {
-                match r.respond_to(req) {
-                    Ok(reply) => match reply.into().0 {
-                        ReplyItem::Message(resp) => ok(resp),
-                        _ => panic!("Nested async replies are not supported"),
-                    },
-                    Err(e) => err(e),
-                }
+            .then(move |r| match r.respond_to(&req) {
+                Ok(reply) => match reply.into().into() {
+                    AsyncResultItem::Ok(resp) => ok(resp),
+                    _ => panic!("Nested async replies are not supported"),
+                },
+                Err(e) => err(e),
             });
-        Ok(Reply::async(fut))
+        Ok(AsyncResult::async(Box::new(fut)))
     }
 }
 
-/// Trait defines object that could be registered as resource route
+// /// Trait defines object that could be registered as resource route
 pub(crate) trait RouteHandler<S>: 'static {
-    fn handle(&mut self, req: HttpRequest<S>) -> Reply;
+    fn handle(&mut self, req: HttpRequest<S>) -> AsyncResult<HttpResponse>;
 }
 
 /// Route handler wrapper for Handler
-pub(crate)
-struct WrapHandler<S, H, R>
-    where H: Handler<S, Result=R>,
-          R: Responder,
-          S: 'static,
+pub(crate) struct WrapHandler<S, H, R>
+where
+    H: Handler<S, Result = R>,
+    R: Responder,
+    S: 'static,
 {
     h: H,
     s: PhantomData<S>,
 }
 
 impl<S, H, R> WrapHandler<S, H, R>
-    where H: Handler<S, Result=R>,
-          R: Responder,
-          S: 'static,
+where
+    H: Handler<S, Result = R>,
+    R: Responder,
+    S: 'static,
 {
     pub fn new(h: H) -> Self {
-        WrapHandler{h: h, s: PhantomData}
+        WrapHandler {
+            h,
+            s: PhantomData,
+        }
     }
 }
 
 impl<S, H, R> RouteHandler<S> for WrapHandler<S, H, R>
-    where H: Handler<S, Result=R>,
-          R: Responder + 'static,
-          S: 'static,
+where
+    H: Handler<S, Result = R>,
+    R: Responder + 'static,
+    S: 'static,
 {
-    fn handle(&mut self, req: HttpRequest<S>) -> Reply {
-        let req2 = req.clone_without_state();
-        match self.h.handle(req).respond_to(req2) {
+    fn handle(&mut self, req: HttpRequest<S>) -> AsyncResult<HttpResponse> {
+        match self.h.handle(req.clone()).respond_to(&req) {
             Ok(reply) => reply.into(),
-            Err(err) => Reply::response(err.into()),
+            Err(err) => AsyncResult::err(err.into()),
         }
     }
 }
 
 /// Async route handler
-pub(crate)
-struct AsyncHandler<S, H, F, R, E>
-    where H: Fn(HttpRequest<S>) -> F + 'static,
-          F: Future<Item=R, Error=E> + 'static,
-          R: Responder + 'static,
-          E: Into<Error> + 'static,
-          S: 'static,
+pub(crate) struct AsyncHandler<S, H, F, R, E>
+where
+    H: Fn(HttpRequest<S>) -> F + 'static,
+    F: Future<Item = R, Error = E> + 'static,
+    R: Responder + 'static,
+    E: Into<Error> + 'static,
+    S: 'static,
 {
     h: Box<H>,
     s: PhantomData<S>,
 }
 
 impl<S, H, F, R, E> AsyncHandler<S, H, F, R, E>
-    where H: Fn(HttpRequest<S>) -> F + 'static,
-          F: Future<Item=R, Error=E> + 'static,
-          R: Responder + 'static,
-          E: Into<Error> + 'static,
-          S: 'static,
+where
+    H: Fn(HttpRequest<S>) -> F + 'static,
+    F: Future<Item = R, Error = E> + 'static,
+    R: Responder + 'static,
+    E: Into<Error> + 'static,
+    S: 'static,
 {
     pub fn new(h: H) -> Self {
-        AsyncHandler{h: Box::new(h), s: PhantomData}
+        AsyncHandler {
+            h: Box::new(h),
+            s: PhantomData,
+        }
     }
 }
 
 impl<S, H, F, R, E> RouteHandler<S> for AsyncHandler<S, H, F, R, E>
-    where H: Fn(HttpRequest<S>) -> F + 'static,
-          F: Future<Item=R, Error=E> + 'static,
-          R: Responder + 'static,
-          E: Into<Error> + 'static,
-          S: 'static,
+where
+    H: Fn(HttpRequest<S>) -> F + 'static,
+    F: Future<Item = R, Error = E> + 'static,
+    R: Responder + 'static,
+    E: Into<Error> + 'static,
+    S: 'static,
 {
-    fn handle(&mut self, req: HttpRequest<S>) -> Reply {
-        let req2 = req.clone_without_state();
-        let fut = (self.h)(req)
+    fn handle(&mut self, req: HttpRequest<S>) -> AsyncResult<HttpResponse> {
+        let fut = (self.h)(req.clone())
             .map_err(|e| e.into())
-            .then(move |r| {
-                match r.respond_to(req2) {
-                    Ok(reply) => match reply.into().0 {
-                        ReplyItem::Message(resp) => ok(resp),
-                        _ => panic!("Nested async replies are not supported"),
-                    },
-                    Err(e) => err(e),
-                }
+            .then(move |r| match r.respond_to(&req) {
+                Ok(reply) => match reply.into().into() {
+                    AsyncResultItem::Ok(resp) => Either::A(ok(resp)),
+                    AsyncResultItem::Err(e) => Either::A(err(e)),
+                    AsyncResultItem::Future(fut) => Either::B(fut),
+                },
+                Err(e) => Either::A(err(e)),
             });
-        Reply::async(fut)
+        AsyncResult::async(Box::new(fut))
     }
 }
 
-/// Path normalization helper
+/// Access an application state
 ///
-/// By normalizing it means:
+/// `S` - application state type
 ///
-/// - Add a trailing slash to the path.
-/// - Double slashes are replaced by one.
-///
-/// The handler returns as soon as it finds a path that resolves
-/// correctly. The order if all enable is 1) merge, 3) both merge and append
-/// and 3) append. If the path resolves with
-/// at least one of those conditions, it will redirect to the new path.
-///
-/// If *append* is *true* append slash when needed. If a resource is
-/// defined with trailing slash and the request comes without it, it will
-/// append it automatically.
-///
-/// If *merge* is *true*, merge multiple consecutive slashes in the path into one.
-///
-/// This handler designed to be use as a handler for application's *default resource*.
+/// ## Example
 ///
 /// ```rust
+/// # extern crate bytes;
 /// # extern crate actix_web;
-/// # #[macro_use] extern crate serde_derive;
-/// # use actix_web::*;
-/// #
-/// # fn index(req: HttpRequest) -> httpcodes::StaticResponse {
-/// #     httpcodes::HTTPOk
-/// # }
+/// # extern crate futures;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Path, State, http};
+///
+/// /// Application state
+/// struct MyApp {msg: &'static str}
+///
+/// #[derive(Deserialize)]
+/// struct Info {
+///     username: String,
+/// }
+///
+/// /// extract path info using serde
+/// fn index(state: State<MyApp>, info: Path<Info>) -> String {
+///     format!("{} {}!", state.msg, info.username)
+/// }
+///
 /// fn main() {
-///     let app = Application::new()
-///         .resource("/test/", |r| r.f(index))
-///         .default_resource(|r| r.h(NormalizePath::default()))
-///         .finish();
+///     let app = App::with_state(MyApp{msg: "Welcome"}).resource(
+///        "/{username}/index.html",                      // <- define path parameters
+///        |r| r.method(http::Method::GET).with2(index)); // <- use `with` extractor
 /// }
 /// ```
-/// In this example `/test`, `/test///` will be redirected to `/test/` url.
-pub struct NormalizePath {
-    append: bool,
-    merge: bool,
-    re_merge: Regex,
-    redirect: StatusCode,
-    not_found: StatusCode,
-}
+pub struct State<S>(HttpRequest<S>);
 
-impl Default for NormalizePath {
-    /// Create default `NormalizePath` instance, *append* is set to *true*,
-    /// *merge* is set to *true* and *redirect* is set to `StatusCode::MOVED_PERMANENTLY`
-    fn default() -> NormalizePath {
-        NormalizePath {
-            append: true,
-            merge: true,
-            re_merge: Regex::new("//+").unwrap(),
-            redirect: StatusCode::MOVED_PERMANENTLY,
-            not_found: StatusCode::NOT_FOUND,
-        }
+impl<S> Deref for State<S> {
+    type Target = S;
+
+    fn deref(&self) -> &S {
+        self.0.state()
     }
 }
 
-impl NormalizePath {
-    /// Create new `NormalizePath` instance
-    pub fn new(append: bool, merge: bool, redirect: StatusCode) -> NormalizePath {
-        NormalizePath {
-            append: append,
-            merge: merge,
-            re_merge: Regex::new("//+").unwrap(),
-            redirect: redirect,
-            not_found: StatusCode::NOT_FOUND,
-        }
+impl<S> FromRequest<S> for State<S> {
+    type Config = ();
+    type Result = State<S>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
+        State(req.clone())
     }
 }
-
-impl<S> Handler<S> for NormalizePath {
-    type Result = Result<HttpResponse, HttpError>;
-
-    fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
-        if let Some(router) = req.router() {
-            let query = req.query_string();
-            if self.merge {
-                // merge slashes
-                let p = self.re_merge.replace_all(req.path(), "/");
-                if p.len() != req.path().len() {
-                    if router.has_route(p.as_ref()) {
-                        let p = if !query.is_empty() { p + "?" + query } else { p };
-                        return HttpResponse::build(self.redirect)
-                            .header(header::LOCATION, p.as_ref())
-                            .body(Body::Empty);
-                    }
-                    // merge slashes and append trailing slash
-                    if self.append && !p.ends_with('/') {
-                        let p = p.as_ref().to_owned() + "/";
-                        if router.has_route(&p) {
-                            let p = if !query.is_empty() { p + "?" + query } else { p };
-                            return HttpResponse::build(self.redirect)
-                                .header(header::LOCATION, p.as_str())
-                                .body(Body::Empty);
-                        }
-                    }
-                }
-            }
-            // append trailing slash
-            if self.append && !req.path().ends_with('/') {
-                let p = req.path().to_owned() + "/";
-                if router.has_route(&p) {
-                    let p = if !query.is_empty() { p + "?" + query } else { p };
-                    return HttpResponse::build(self.redirect)
-                        .header(header::LOCATION, p.as_str())
-                        .body(Body::Empty);
-                }
-            }
-        }
-        Ok(HttpResponse::new(self.not_found, Body::Empty))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use http::{header, Method};
-    use test::TestRequest;
-    use application::Application;
-
-    fn index(_req: HttpRequest) -> HttpResponse {
-        HttpResponse::new(StatusCode::OK, Body::Empty)
-    }
-
-    #[test]
-    fn test_normalize_path_trailing_slashes() {
-        let mut app = Application::new()
-            .resource("/resource1", |r| r.method(Method::GET).f(index))
-            .resource("/resource2/", |r| r.method(Method::GET).f(index))
-            .default_resource(|r| r.h(NormalizePath::default()))
-            .finish();
-
-        // trailing slashes
-        let params = vec![("/resource1", "", StatusCode::OK),
-                          ("/resource1/", "", StatusCode::NOT_FOUND),
-                          ("/resource2", "/resource2/", StatusCode::MOVED_PERMANENTLY),
-                          ("/resource2/", "", StatusCode::OK),
-                          ("/resource1?p1=1&p2=2", "", StatusCode::OK),
-                          ("/resource1/?p1=1&p2=2", "", StatusCode::NOT_FOUND),
-                          ("/resource2?p1=1&p2=2", "/resource2/?p1=1&p2=2",
-                           StatusCode::MOVED_PERMANENTLY),
-                          ("/resource2/?p1=1&p2=2", "", StatusCode::OK)
-        ];
-        for (path, target, code) in params {
-            let req = app.prepare_request(TestRequest::with_uri(path).finish());
-            let resp = app.run(req);
-            let r = resp.as_response().unwrap();
-            assert_eq!(r.status(), code);
-            if !target.is_empty() {
-                assert_eq!(
-                    target,
-                    r.headers().get(header::LOCATION).unwrap().to_str().unwrap());
-            }
-        }
-    }
-
-    #[test]
-    fn test_normalize_path_trailing_slashes_disabled() {
-        let mut app = Application::new()
-            .resource("/resource1", |r| r.method(Method::GET).f(index))
-            .resource("/resource2/", |r| r.method(Method::GET).f(index))
-            .default_resource(|r| r.h(
-                NormalizePath::new(false, true, StatusCode::MOVED_PERMANENTLY)))
-            .finish();
-
-        // trailing slashes
-        let params = vec![("/resource1", StatusCode::OK),
-                          ("/resource1/", StatusCode::NOT_FOUND),
-                          ("/resource2", StatusCode::NOT_FOUND),
-                          ("/resource2/", StatusCode::OK),
-                          ("/resource1?p1=1&p2=2", StatusCode::OK),
-                          ("/resource1/?p1=1&p2=2", StatusCode::NOT_FOUND),
-                          ("/resource2?p1=1&p2=2", StatusCode::NOT_FOUND),
-                          ("/resource2/?p1=1&p2=2", StatusCode::OK)
-        ];
-        for (path, code) in params {
-            let req = app.prepare_request(TestRequest::with_uri(path).finish());
-            let resp = app.run(req);
-            let r = resp.as_response().unwrap();
-            assert_eq!(r.status(), code);
-        }
-    }
-
-    #[test]
-    fn test_normalize_path_merge_slashes() {
-        let mut app = Application::new()
-            .resource("/resource1", |r| r.method(Method::GET).f(index))
-            .resource("/resource1/a/b", |r| r.method(Method::GET).f(index))
-            .default_resource(|r| r.h(NormalizePath::default()))
-            .finish();
-
-        // trailing slashes
-        let params = vec![
-            ("/resource1/a/b", "", StatusCode::OK),
-            ("//resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("//resource1//a//b/", "", StatusCode::NOT_FOUND),
-            ("///resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a//b/", "", StatusCode::NOT_FOUND),
-            ("/resource1/a/b?p=1", "", StatusCode::OK),
-            ("//resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource1//a//b/?p=1", "", StatusCode::NOT_FOUND),
-            ("///resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a//b/?p=1", "", StatusCode::NOT_FOUND),
-        ];
-        for (path, target, code) in params {
-            let req = app.prepare_request(TestRequest::with_uri(path).finish());
-            let resp = app.run(req);
-            let r = resp.as_response().unwrap();
-            assert_eq!(r.status(), code);
-            if !target.is_empty() {
-                assert_eq!(
-                    target,
-                    r.headers().get(header::LOCATION).unwrap().to_str().unwrap());
-            }
-        }
-    }
-
-    #[test]
-    fn test_normalize_path_merge_and_append_slashes() {
-        let mut app = Application::new()
-            .resource("/resource1", |r| r.method(Method::GET).f(index))
-            .resource("/resource2/", |r| r.method(Method::GET).f(index))
-            .resource("/resource1/a/b", |r| r.method(Method::GET).f(index))
-            .resource("/resource2/a/b/", |r| r.method(Method::GET).f(index))
-            .default_resource(|r| r.h(NormalizePath::default()))
-            .finish();
-
-        // trailing slashes
-        let params = vec![
-            ("/resource1/a/b", "", StatusCode::OK),
-            ("/resource1/a/b/", "", StatusCode::NOT_FOUND),
-            ("//resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b/", "", StatusCode::NOT_FOUND),
-            ("/////resource1/a///b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b/", "", StatusCode::NOT_FOUND),
-            ("/resource2/a/b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("/resource2/a/b/", "", StatusCode::OK),
-            ("//resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("///resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("///resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource2/a///b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource2/a///b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("/resource1/a/b?p=1", "", StatusCode::OK),
-            ("/resource1/a/b/?p=1", "", StatusCode::NOT_FOUND),
-            ("//resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b/?p=1", "", StatusCode::NOT_FOUND),
-            ("/////resource1/a///b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b/?p=1", "", StatusCode::NOT_FOUND),
-            ("/resource2/a/b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("///resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("///resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource2/a///b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource2/a///b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-        ];
-        for (path, target, code) in params {
-            let req = app.prepare_request(TestRequest::with_uri(path).finish());
-            let resp = app.run(req);
-            let r = resp.as_response().unwrap();
-            assert_eq!(r.status(), code);
-            if !target.is_empty() {
-                assert_eq!(
-                    target, r.headers().get(header::LOCATION).unwrap().to_str().unwrap());
-            }
-        }
-    }
-
-
-}

src/header/common/accept.rs

@@ -0,0 +1,159 @@
+use header::{qitem, QualityItem};
+use http::header as http;
+use mime::{self, Mime};
+
+header! {
+    /// `Accept` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.2)
+    ///
+    /// The `Accept` header field can be used by user agents to specify
+    /// response media types that are acceptable.  Accept header fields can
+    /// be used to indicate that the request is specifically limited to a
+    /// small set of desired types, as in the case of a request for an
+    /// in-line image
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept = #( media-range [ accept-params ] )
+    ///
+    /// media-range    = ( "*/*"
+    ///                  / ( type "/" "*" )
+    ///                  / ( type "/" subtype )
+    ///                  ) *( OWS ";" OWS parameter )
+    /// accept-params  = weight *( accept-ext )
+    /// accept-ext = OWS ";" OWS token [ "=" ( token / quoted-string ) ]
+    /// ```
+    ///
+    /// # Example values
+    /// * `audio/*; q=0.2, audio/basic`
+    /// * `text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c`
+    ///
+    /// # Examples
+    /// ```rust
+    /// # extern crate actix_web;
+    /// extern crate mime;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{Accept, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    ///
+    /// builder.set(
+    ///     Accept(vec![
+    ///         qitem(mime::TEXT_HTML),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// extern crate mime;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{Accept, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    ///
+    /// builder.set(
+    ///     Accept(vec![
+    ///         qitem(mime::APPLICATION_JSON),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// extern crate mime;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{Accept, QualityItem, q, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    ///
+    /// builder.set(
+    ///     Accept(vec![
+    ///         qitem(mime::TEXT_HTML),
+    ///         qitem("application/xhtml+xml".parse().unwrap()),
+    ///         QualityItem::new(
+    ///             mime::TEXT_XML,
+    ///             q(900)
+    ///         ),
+    ///         qitem("image/webp".parse().unwrap()),
+    ///         QualityItem::new(
+    ///             mime::STAR_STAR,
+    ///             q(800)
+    ///         ),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (Accept, http::ACCEPT) => (QualityItem<Mime>)+
+
+    test_accept {
+        // Tests from the RFC
+         test_header!(
+            test1,
+            vec![b"audio/*; q=0.2, audio/basic"],
+            Some(HeaderField(vec![
+                QualityItem::new("audio/*".parse().unwrap(), q(200)),
+                qitem("audio/basic".parse().unwrap()),
+                ])));
+        test_header!(
+            test2,
+            vec![b"text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c"],
+            Some(HeaderField(vec![
+                QualityItem::new(TEXT_PLAIN, q(500)),
+                qitem(TEXT_HTML),
+                QualityItem::new(
+                    "text/x-dvi".parse().unwrap(),
+                    q(800)),
+                qitem("text/x-c".parse().unwrap()),
+                ])));
+        // Custom tests
+        test_header!(
+            test3,
+            vec![b"text/plain; charset=utf-8"],
+            Some(Accept(vec![
+                qitem(TEXT_PLAIN_UTF_8),
+                ])));
+        test_header!(
+            test4,
+            vec![b"text/plain; charset=utf-8; q=0.5"],
+            Some(Accept(vec![
+                QualityItem::new(TEXT_PLAIN_UTF_8,
+                    q(500)),
+            ])));
+
+        #[test]
+        fn test_fuzzing1() {
+            use test::TestRequest;
+            let req = TestRequest::with_header(super::http::ACCEPT, "chunk#;e").finish();
+            let header = Accept::parse(&req);
+            assert!(header.is_ok());
+        }
+    }
+}
+
+impl Accept {
+    /// A constructor to easily create `Accept: */*`.
+    pub fn star() -> Accept {
+        Accept(vec![qitem(mime::STAR_STAR)])
+    }
+
+    /// A constructor to easily create `Accept: application/json`.
+    pub fn json() -> Accept {
+        Accept(vec![qitem(mime::APPLICATION_JSON)])
+    }
+
+    /// A constructor to easily create `Accept: text/*`.
+    pub fn text() -> Accept {
+        Accept(vec![qitem(mime::TEXT_STAR)])
+    }
+
+    /// A constructor to easily create `Accept: image/*`.
+    pub fn image() -> Accept {
+        Accept(vec![qitem(mime::IMAGE_STAR)])
+    }
+}

src/header/common/accept_charset.rs

@@ -0,0 +1,69 @@
+use header::{Charset, QualityItem, ACCEPT_CHARSET};
+
+header! {
+    /// `Accept-Charset` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.3)
+    ///
+    /// The `Accept-Charset` header field can be sent by a user agent to
+    /// indicate what charsets are acceptable in textual response content.
+    /// This field allows user agents capable of understanding more
+    /// comprehensive or special-purpose charsets to signal that capability
+    /// to an origin server that is capable of representing information in
+    /// those charsets.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept-Charset = 1#( ( charset / "*" ) [ weight ] )
+    /// ```
+    ///
+    /// # Example values
+    /// * `iso-8859-5, unicode-1-1;q=0.8`
+    ///
+    /// # Examples
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptCharset, Charset, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     AcceptCharset(vec![qitem(Charset::Us_Ascii)])
+    /// );
+    /// # }
+    /// ```
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptCharset, Charset, q, QualityItem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     AcceptCharset(vec![
+    ///         QualityItem::new(Charset::Us_Ascii, q(900)),
+    ///         QualityItem::new(Charset::Iso_8859_10, q(200)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptCharset, Charset, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     AcceptCharset(vec![qitem(Charset::Ext("utf-8".to_owned()))])
+    /// );
+    /// # }
+    /// ```
+    (AcceptCharset, ACCEPT_CHARSET) => (QualityItem<Charset>)+
+
+    test_accept_charset {
+        /// Test case from RFC
+        test_header!(test1, vec![b"iso-8859-5, unicode-1-1;q=0.8"]);
+    }
+}

src/header/common/accept_encoding.rs

@@ -0,0 +1,72 @@
+use header::{Encoding, QualityItem};
+
+header! {
+    /// `Accept-Encoding` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.4)
+    ///
+    /// The `Accept-Encoding` header field can be used by user agents to
+    /// indicate what response content-codings are
+    /// acceptable in the response.  An  `identity` token is used as a synonym
+    /// for "no encoding" in order to communicate when no encoding is
+    /// preferred.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept-Encoding  = #( codings [ weight ] )
+    /// codings          = content-coding / "identity" / "*"
+    /// ```
+    ///
+    /// # Example values
+    /// * `compress, gzip`
+    /// * ``
+    /// * `*`
+    /// * `compress;q=0.5, gzip;q=1`
+    /// * `gzip;q=1.0, identity; q=0.5, *;q=0`
+    ///
+    /// # Examples
+    /// ```
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, qitem};
+    ///
+    /// let mut headers = Headers::new();
+    /// headers.set(
+    ///     AcceptEncoding(vec![qitem(Encoding::Chunked)])
+    /// );
+    /// ```
+    /// ```
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, qitem};
+    ///
+    /// let mut headers = Headers::new();
+    /// headers.set(
+    ///     AcceptEncoding(vec![
+    ///         qitem(Encoding::Chunked),
+    ///         qitem(Encoding::Gzip),
+    ///         qitem(Encoding::Deflate),
+    ///     ])
+    /// );
+    /// ```
+    /// ```
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, QualityItem, q, qitem};
+    ///
+    /// let mut headers = Headers::new();
+    /// headers.set(
+    ///     AcceptEncoding(vec![
+    ///         qitem(Encoding::Chunked),
+    ///         QualityItem::new(Encoding::Gzip, q(600)),
+    ///         QualityItem::new(Encoding::EncodingExt("*".to_owned()), q(0)),
+    ///     ])
+    /// );
+    /// ```
+    (AcceptEncoding, "Accept-Encoding") => (QualityItem<Encoding>)*
+
+    test_accept_encoding {
+        // From the RFC
+        test_header!(test1, vec![b"compress, gzip"]);
+        test_header!(test2, vec![b""], Some(AcceptEncoding(vec![])));
+        test_header!(test3, vec![b"*"]);
+        // Note: Removed quality 1 from gzip
+        test_header!(test4, vec![b"compress;q=0.5, gzip"]);
+        // Note: Removed quality 1 from gzip
+        test_header!(test5, vec![b"gzip, identity; q=0.5, *;q=0"]);
+    }
+}

src/header/common/accept_language.rs

@@ -0,0 +1,75 @@
+use header::{QualityItem, ACCEPT_LANGUAGE};
+use language_tags::LanguageTag;
+
+header! {
+    /// `Accept-Language` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.5)
+    ///
+    /// The `Accept-Language` header field can be used by user agents to
+    /// indicate the set of natural languages that are preferred in the
+    /// response.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept-Language = 1#( language-range [ weight ] )
+    /// language-range  = <language-range, see [RFC4647], Section 2.1>
+    /// ```
+    ///
+    /// # Example values
+    /// * `da, en-gb;q=0.8, en;q=0.7`
+    /// * `en-us;q=1.0, en;q=0.5, fr`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # extern crate language_tags;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptLanguage, LanguageTag, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// let mut langtag: LanguageTag = Default::default();
+    /// langtag.language = Some("en".to_owned());
+    /// langtag.region = Some("US".to_owned());
+    /// builder.set(
+    ///     AcceptLanguage(vec![
+    ///         qitem(langtag),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptLanguage, QualityItem, q, qitem};
+    /// #
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     AcceptLanguage(vec![
+    ///         qitem(langtag!(da)),
+    ///         QualityItem::new(langtag!(en;;;GB), q(800)),
+    ///         QualityItem::new(langtag!(en), q(700)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (AcceptLanguage, ACCEPT_LANGUAGE) => (QualityItem<LanguageTag>)+
+
+    test_accept_language {
+        // From the RFC
+        test_header!(test1, vec![b"da, en-gb;q=0.8, en;q=0.7"]);
+        // Own test
+        test_header!(
+            test2, vec![b"en-US, en; q=0.5, fr"],
+            Some(AcceptLanguage(vec![
+                qitem("en-US".parse().unwrap()),
+                QualityItem::new("en".parse().unwrap(), q(500)),
+                qitem("fr".parse().unwrap()),
+        ])));
+    }
+}

src/header/common/allow.rs

@@ -0,0 +1,85 @@
+use http::Method;
+use http::header;
+
+header! {
+    /// `Allow` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.4.1)
+    ///
+    /// The `Allow` header field lists the set of methods advertised as
+    /// supported by the target resource.  The purpose of this field is
+    /// strictly to inform the recipient of valid request methods associated
+    /// with the resource.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Allow = #method
+    /// ```
+    ///
+    /// # Example values
+    /// * `GET, HEAD, PUT`
+    /// * `OPTIONS, GET, PUT, POST, DELETE, HEAD, TRACE, CONNECT, PATCH, fOObAr`
+    /// * ``
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate http;
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::Allow;
+    /// use http::Method;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     Allow(vec![Method::GET])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate http;
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::Allow;
+    /// use http::Method;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     Allow(vec![
+    ///         Method::GET,
+    ///         Method::POST,
+    ///         Method::PATCH,
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (Allow, header::ALLOW) => (Method)*
+
+    test_allow {
+        // From the RFC
+        test_header!(
+            test1,
+            vec![b"GET, HEAD, PUT"],
+            Some(HeaderField(vec![Method::GET, Method::HEAD, Method::PUT])));
+        // Own tests
+        test_header!(
+            test2,
+            vec![b"OPTIONS, GET, PUT, POST, DELETE, HEAD, TRACE, CONNECT, PATCH"],
+            Some(HeaderField(vec![
+                Method::OPTIONS,
+                Method::GET,
+                Method::PUT,
+                Method::POST,
+                Method::DELETE,
+                Method::HEAD,
+                Method::TRACE,
+                Method::CONNECT,
+                Method::PATCH])));
+        test_header!(
+            test3,
+            vec![b""],
+            Some(HeaderField(Vec::<Method>::new())));
+    }
+}

src/header/common/cache_control.rs

@@ -0,0 +1,254 @@
+use header::{Header, IntoHeaderValue, Writer};
+use header::{fmt_comma_delimited, from_comma_delimited};
+use http::header;
+use std::fmt::{self, Write};
+use std::str::FromStr;
+
+/// `Cache-Control` header, defined in [RFC7234](https://tools.ietf.org/html/rfc7234#section-5.2)
+///
+/// The `Cache-Control` header field is used to specify directives for
+/// caches along the request/response chain.  Such cache directives are
+/// unidirectional in that the presence of a directive in a request does
+/// not imply that the same directive is to be given in the response.
+///
+/// # ABNF
+///
+/// ```text
+/// Cache-Control   = 1#cache-directive
+/// cache-directive = token [ "=" ( token / quoted-string ) ]
+/// ```
+///
+/// # Example values
+///
+/// * `no-cache`
+/// * `private, community="UCI"`
+/// * `max-age=30`
+///
+/// # Examples
+/// ```rust
+/// use actix_web::HttpResponse;
+/// use actix_web::http::header::{CacheControl, CacheDirective};
+///
+/// let mut builder = HttpResponse::Ok();
+/// builder.set(CacheControl(vec![CacheDirective::MaxAge(86400u32)]));
+/// ```
+///
+/// ```rust
+/// use actix_web::HttpResponse;
+/// use actix_web::http::header::{CacheControl, CacheDirective};
+///
+/// let mut builder = HttpResponse::Ok();
+/// builder.set(CacheControl(vec![
+///     CacheDirective::NoCache,
+///     CacheDirective::Private,
+///     CacheDirective::MaxAge(360u32),
+///     CacheDirective::Extension("foo".to_owned(), Some("bar".to_owned())),
+/// ]));
+/// ```
+#[derive(PartialEq, Clone, Debug)]
+pub struct CacheControl(pub Vec<CacheDirective>);
+
+__hyper__deref!(CacheControl => Vec<CacheDirective>);
+
+//TODO: this could just be the header! macro
+impl Header for CacheControl {
+    fn name() -> header::HeaderName {
+        header::CACHE_CONTROL
+    }
+
+    #[inline]
+    fn parse<T>(msg: &T) -> Result<Self, ::error::ParseError>
+    where
+        T: ::HttpMessage,
+    {
+        let directives = from_comma_delimited(msg.headers().get_all(Self::name()))?;
+        if !directives.is_empty() {
+            Ok(CacheControl(directives))
+        } else {
+            Err(::error::ParseError::Header)
+        }
+    }
+}
+
+impl fmt::Display for CacheControl {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt_comma_delimited(f, &self[..])
+    }
+}
+
+impl IntoHeaderValue for CacheControl {
+    type Error = header::InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<header::HeaderValue, Self::Error> {
+        let mut writer = Writer::new();
+        let _ = write!(&mut writer, "{}", self);
+        header::HeaderValue::from_shared(writer.take())
+    }
+}
+
+/// `CacheControl` contains a list of these directives.
+#[derive(PartialEq, Clone, Debug)]
+pub enum CacheDirective {
+    /// "no-cache"
+    NoCache,
+    /// "no-store"
+    NoStore,
+    /// "no-transform"
+    NoTransform,
+    /// "only-if-cached"
+    OnlyIfCached,
+
+    // request directives
+    /// "max-age=delta"
+    MaxAge(u32),
+    /// "max-stale=delta"
+    MaxStale(u32),
+    /// "min-fresh=delta"
+    MinFresh(u32),
+
+    // response directives
+    /// "must-revalidate"
+    MustRevalidate,
+    /// "public"
+    Public,
+    /// "private"
+    Private,
+    /// "proxy-revalidate"
+    ProxyRevalidate,
+    /// "s-maxage=delta"
+    SMaxAge(u32),
+
+    /// Extension directives. Optionally include an argument.
+    Extension(String, Option<String>),
+}
+
+impl fmt::Display for CacheDirective {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use self::CacheDirective::*;
+        fmt::Display::fmt(
+            match *self {
+                NoCache => "no-cache",
+                NoStore => "no-store",
+                NoTransform => "no-transform",
+                OnlyIfCached => "only-if-cached",
+
+                MaxAge(secs) => return write!(f, "max-age={}", secs),
+                MaxStale(secs) => return write!(f, "max-stale={}", secs),
+                MinFresh(secs) => return write!(f, "min-fresh={}", secs),
+
+                MustRevalidate => "must-revalidate",
+                Public => "public",
+                Private => "private",
+                ProxyRevalidate => "proxy-revalidate",
+                SMaxAge(secs) => return write!(f, "s-maxage={}", secs),
+
+                Extension(ref name, None) => &name[..],
+                Extension(ref name, Some(ref arg)) => {
+                    return write!(f, "{}={}", name, arg)
+                }
+            },
+            f,
+        )
+    }
+}
+
+impl FromStr for CacheDirective {
+    type Err = Option<<u32 as FromStr>::Err>;
+    fn from_str(s: &str) -> Result<CacheDirective, Option<<u32 as FromStr>::Err>> {
+        use self::CacheDirective::*;
+        match s {
+            "no-cache" => Ok(NoCache),
+            "no-store" => Ok(NoStore),
+            "no-transform" => Ok(NoTransform),
+            "only-if-cached" => Ok(OnlyIfCached),
+            "must-revalidate" => Ok(MustRevalidate),
+            "public" => Ok(Public),
+            "private" => Ok(Private),
+            "proxy-revalidate" => Ok(ProxyRevalidate),
+            "" => Err(None),
+            _ => match s.find('=') {
+                Some(idx) if idx + 1 < s.len() => {
+                    match (&s[..idx], (&s[idx + 1..]).trim_matches('"')) {
+                        ("max-age", secs) => secs.parse().map(MaxAge).map_err(Some),
+                        ("max-stale", secs) => secs.parse().map(MaxStale).map_err(Some),
+                        ("min-fresh", secs) => secs.parse().map(MinFresh).map_err(Some),
+                        ("s-maxage", secs) => secs.parse().map(SMaxAge).map_err(Some),
+                        (left, right) => {
+                            Ok(Extension(left.to_owned(), Some(right.to_owned())))
+                        }
+                    }
+                }
+                Some(_) => Err(None),
+                None => Ok(Extension(s.to_owned(), None)),
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use header::Header;
+    use test::TestRequest;
+
+    #[test]
+    fn test_parse_multiple_headers() {
+        let req = TestRequest::with_header(header::CACHE_CONTROL, "no-cache, private")
+            .finish();
+        let cache = Header::parse(&req);
+        assert_eq!(
+            cache.ok(),
+            Some(CacheControl(vec![
+                CacheDirective::NoCache,
+                CacheDirective::Private,
+            ]))
+        )
+    }
+
+    #[test]
+    fn test_parse_argument() {
+        let req =
+            TestRequest::with_header(header::CACHE_CONTROL, "max-age=100, private")
+                .finish();
+        let cache = Header::parse(&req);
+        assert_eq!(
+            cache.ok(),
+            Some(CacheControl(vec![
+                CacheDirective::MaxAge(100),
+                CacheDirective::Private,
+            ]))
+        )
+    }
+
+    #[test]
+    fn test_parse_quote_form() {
+        let req =
+            TestRequest::with_header(header::CACHE_CONTROL, "max-age=\"200\"").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(
+            cache.ok(),
+            Some(CacheControl(vec![CacheDirective::MaxAge(200)]))
+        )
+    }
+
+    #[test]
+    fn test_parse_extension() {
+        let req =
+            TestRequest::with_header(header::CACHE_CONTROL, "foo, bar=baz").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(
+            cache.ok(),
+            Some(CacheControl(vec![
+                CacheDirective::Extension("foo".to_owned(), None),
+                CacheDirective::Extension("bar".to_owned(), Some("baz".to_owned())),
+            ]))
+        )
+    }
+
+    #[test]
+    fn test_parse_bad_syntax() {
+        let req = TestRequest::with_header(header::CACHE_CONTROL, "foo=").finish();
+        let cache: Result<CacheControl, _> = Header::parse(&req);
+        assert_eq!(cache.ok(), None)
+    }
+}

src/header/common/content_disposition.rs

@@ -0,0 +1,264 @@
+// # References
+//
+// "The Content-Disposition Header Field" https://www.ietf.org/rfc/rfc2183.txt
+// "The Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)" https://www.ietf.org/rfc/rfc6266.txt
+// "Returning Values from Forms: multipart/form-data" https://www.ietf.org/rfc/rfc2388.txt
+// Browser conformance tests at: http://greenbytes.de/tech/tc2231/
+// IANA assignment: http://www.iana.org/assignments/cont-disp/cont-disp.xhtml
+
+use language_tags::LanguageTag;
+use std::fmt;
+use unicase;
+
+use header::{Header, Raw, parsing};
+use header::parsing::{parse_extended_value, http_percent_encode};
+use header::shared::Charset;
+
+/// The implied disposition of the content of the HTTP body.
+#[derive(Clone, Debug, PartialEq)]
+pub enum DispositionType {
+    /// Inline implies default processing
+    Inline,
+    /// Attachment implies that the recipient should prompt the user to save the response locally,
+    /// rather than process it normally (as per its media type).
+    Attachment,
+    /// Extension type.  Should be handled by recipients the same way as Attachment
+    Ext(String)
+}
+
+/// A parameter to the disposition type.
+#[derive(Clone, Debug, PartialEq)]
+pub enum DispositionParam {
+    /// A Filename consisting of a Charset, an optional LanguageTag, and finally a sequence of
+    /// bytes representing the filename
+    Filename(Charset, Option<LanguageTag>, Vec<u8>),
+    /// Extension type consisting of token and value.  Recipients should ignore unrecognized
+    /// parameters.
+    Ext(String, String)
+}
+
+/// A `Content-Disposition` header, (re)defined in [RFC6266](https://tools.ietf.org/html/rfc6266).
+///
+/// The Content-Disposition response header field is used to convey
+/// additional information about how to process the response payload, and
+/// also can be used to attach additional metadata, such as the filename
+/// to use when saving the response payload locally.
+///
+/// # ABNF
+
+/// ```text
+/// content-disposition = "Content-Disposition" ":"
+///                       disposition-type *( ";" disposition-parm )
+///
+/// disposition-type    = "inline" | "attachment" | disp-ext-type
+///                       ; case-insensitive
+///
+/// disp-ext-type       = token
+///
+/// disposition-parm    = filename-parm | disp-ext-parm
+///
+/// filename-parm       = "filename" "=" value
+///                     | "filename*" "=" ext-value
+///
+/// disp-ext-parm       = token "=" value
+///                     | ext-token "=" ext-value
+///
+/// ext-token           = <the characters in token, followed by "*">
+/// ```
+///
+/// # Example
+///
+/// ```
+/// use hyper::header::{Headers, ContentDisposition, DispositionType, DispositionParam, Charset};
+///
+/// let mut headers = Headers::new();
+/// headers.set(ContentDisposition {
+///     disposition: DispositionType::Attachment,
+///     parameters: vec![DispositionParam::Filename(
+///       Charset::Iso_8859_1, // The character set for the bytes of the filename
+///       None, // The optional language tag (see `language-tag` crate)
+///       b"\xa9 Copyright 1989.txt".to_vec() // the actual bytes of the filename
+///     )]
+/// });
+/// ```
+#[derive(Clone, Debug, PartialEq)]
+pub struct ContentDisposition {
+    /// The disposition
+    pub disposition: DispositionType,
+    /// Disposition parameters
+    pub parameters: Vec<DispositionParam>,
+}
+
+impl Header for ContentDisposition {
+    fn header_name() -> &'static str {
+        static NAME: &'static str = "Content-Disposition";
+        NAME
+    }
+
+    fn parse_header(raw: &Raw) -> ::Result<ContentDisposition> {
+        parsing::from_one_raw_str(raw).and_then(|s: String| {
+            let mut sections = s.split(';');
+            let disposition = match sections.next() {
+                Some(s) => s.trim(),
+                None => return Err(::Error::Header),
+            };
+
+            let mut cd = ContentDisposition {
+                disposition: if unicase::eq_ascii(&*disposition, "inline") {
+                    DispositionType::Inline
+                } else if unicase::eq_ascii(&*disposition, "attachment") {
+                    DispositionType::Attachment
+                } else {
+                    DispositionType::Ext(disposition.to_owned())
+                },
+                parameters: Vec::new(),
+            };
+
+            for section in sections {
+                let mut parts = section.splitn(2, '=');
+
+                let key = if let Some(key) = parts.next() {
+                    key.trim()
+                } else {
+                    return Err(::Error::Header);
+                };
+
+                let val = if let Some(val) = parts.next() {
+                    val.trim()
+                } else {
+                    return Err(::Error::Header);
+                };
+
+                cd.parameters.push(
+                    if unicase::eq_ascii(&*key, "filename") {
+                        DispositionParam::Filename(
+                            Charset::Ext("UTF-8".to_owned()), None,
+                            val.trim_matches('"').as_bytes().to_owned())
+                    } else if unicase::eq_ascii(&*key, "filename*") {
+                        let extended_value = try!(parse_extended_value(val));
+                        DispositionParam::Filename(extended_value.charset, extended_value.language_tag, extended_value.value)
+                    } else {
+                        DispositionParam::Ext(key.to_owned(), val.trim_matches('"').to_owned())
+                    }
+                );
+            }
+
+            Ok(cd)
+        })
+    }
+
+    #[inline]
+    fn fmt_header(&self, f: &mut ::header::Formatter) -> fmt::Result {
+        f.fmt_line(self)
+    }
+}
+
+impl fmt::Display for ContentDisposition {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.disposition {
+            DispositionType::Inline => try!(write!(f, "inline")),
+            DispositionType::Attachment => try!(write!(f, "attachment")),
+            DispositionType::Ext(ref s) => try!(write!(f, "{}", s)),
+        }
+        for param in &self.parameters {
+            match *param {
+                DispositionParam::Filename(ref charset, ref opt_lang, ref bytes) => {
+                    let mut use_simple_format: bool = false;
+                    if opt_lang.is_none() {
+                        if let Charset::Ext(ref ext) = *charset {
+                            if unicase::eq_ascii(&**ext, "utf-8") {
+                                use_simple_format = true;
+                            }
+                        }
+                    }
+                    if use_simple_format {
+                        try!(write!(f, "; filename=\"{}\"",
+                                    match String::from_utf8(bytes.clone()) {
+                                        Ok(s) => s,
+                                        Err(_) => return Err(fmt::Error),
+                                    }));
+                    } else {
+                        try!(write!(f, "; filename*={}'", charset));
+                        if let Some(ref lang) = *opt_lang {
+                            try!(write!(f, "{}", lang));
+                        };
+                        try!(write!(f, "'"));
+                        try!(http_percent_encode(f, bytes))
+                    }
+                },
+                DispositionParam::Ext(ref k, ref v) => try!(write!(f, "; {}=\"{}\"", k, v)),
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{ContentDisposition,DispositionType,DispositionParam};
+    use ::header::Header;
+    use ::header::shared::Charset;
+
+    #[test]
+    fn test_parse_header() {
+        assert!(ContentDisposition::parse_header(&"".into()).is_err());
+
+        let a = "form-data; dummy=3; name=upload;\r\n filename=\"sample.png\"".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let b = ContentDisposition {
+            disposition: DispositionType::Ext("form-data".to_owned()),
+            parameters: vec![
+                DispositionParam::Ext("dummy".to_owned(), "3".to_owned()),
+                DispositionParam::Ext("name".to_owned(), "upload".to_owned()),
+                DispositionParam::Filename(
+                    Charset::Ext("UTF-8".to_owned()),
+                    None,
+                    "sample.png".bytes().collect()) ]
+        };
+        assert_eq!(a, b);
+
+        let a = "attachment; filename=\"image.jpg\"".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let b = ContentDisposition {
+            disposition: DispositionType::Attachment,
+            parameters: vec![
+                DispositionParam::Filename(
+                    Charset::Ext("UTF-8".to_owned()),
+                    None,
+                    "image.jpg".bytes().collect()) ]
+        };
+        assert_eq!(a, b);
+
+        let a = "attachment; filename*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let b = ContentDisposition {
+            disposition: DispositionType::Attachment,
+            parameters: vec![
+                DispositionParam::Filename(
+                    Charset::Ext("UTF-8".to_owned()),
+                    None,
+                    vec![0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20,
+                         0xe2, 0x82, 0xac, 0x20, b'r', b'a', b't', b'e', b's']) ]
+        };
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    fn test_display() {
+        let as_string = "attachment; filename*=UTF-8'en'%C2%A3%20and%20%E2%82%AC%20rates";
+        let a = as_string.into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let display_rendered = format!("{}",a);
+        assert_eq!(as_string, display_rendered);
+
+        let a = "attachment; filename*=UTF-8''black%20and%20white.csv".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let display_rendered = format!("{}",a);
+        assert_eq!("attachment; filename=\"black and white.csv\"".to_owned(), display_rendered);
+
+        let a = "attachment; filename=colourful.csv".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let display_rendered = format!("{}",a);
+        assert_eq!("attachment; filename=\"colourful.csv\"".to_owned(), display_rendered);
+    }
+}

src/header/common/content_language.rs

@@ -0,0 +1,65 @@
+use header::{QualityItem, CONTENT_LANGUAGE};
+use language_tags::LanguageTag;
+
+header! {
+    /// `Content-Language` header, defined in
+    /// [RFC7231](https://tools.ietf.org/html/rfc7231#section-3.1.3.2)
+    ///
+    /// The `Content-Language` header field describes the natural language(s)
+    /// of the intended audience for the representation.  Note that this
+    /// might not be equivalent to all the languages used within the
+    /// representation.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Content-Language = 1#language-tag
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `da`
+    /// * `mi, en`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_web::HttpResponse;
+    /// # use actix_web::http::header::{ContentLanguage, qitem};
+    /// #
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     ContentLanguage(vec![
+    ///         qitem(langtag!(en)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_web::HttpResponse;
+    /// # use actix_web::http::header::{ContentLanguage, qitem};
+    /// #
+    /// # fn main() {
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     ContentLanguage(vec![
+    ///         qitem(langtag!(da)),
+    ///         qitem(langtag!(en;;;GB)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (ContentLanguage, CONTENT_LANGUAGE) => (QualityItem<LanguageTag>)+
+
+    test_content_language {
+        test_header!(test1, vec![b"da"]);
+        test_header!(test2, vec![b"mi, en"]);
+    }
+}