exclude examples

spelling check

.appveyor.yml

@@ -3,6 +3,15 @@ environment:
     PROJECT_NAME: actix
   matrix:
     # Stable channel
+    - TARGET: i686-pc-windows-gnu
+      CHANNEL: 1.20.0
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: 1.20.0
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: 1.20.0
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: 1.20.0
+    # Stable channel
     - TARGET: i686-pc-windows-gnu
       CHANNEL: stable
     - TARGET: i686-pc-windows-msvc
@@ -22,17 +31,23 @@ environment:
       CHANNEL: beta
     # Nightly channel
     - TARGET: i686-pc-windows-gnu
-      CHANNEL: nightly
+      CHANNEL: nightly-2017-12-21
     - TARGET: i686-pc-windows-msvc
-      CHANNEL: nightly
+      CHANNEL: nightly-2017-12-21
     - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: nightly
+      CHANNEL: nightly-2017-12-21
     - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: nightly
+      CHANNEL: nightly-2017-12-21
 
 # Install Rust and Cargo
 # (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
 install:
+  - ps: >-
+        If ($Env:TARGET -eq 'x86_64-pc-windows-gnu') {
+           $Env:PATH += ';C:\msys64\mingw64\bin'
+        } ElseIf ($Env:TARGET -eq 'i686-pc-windows-gnu') {
+           $Env:PATH += ';C:\MinGW\bin'
+        }
   - curl -sSf -o rustup-init.exe https://win.rustup.rs
   - rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
   - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin

.gitignore

@@ -1,7 +1,7 @@
-target/
 Cargo.lock
+target/
+guide/build/
 /gh-pages
-__pycache__
 
 *.so
 *.out
@@ -9,7 +9,6 @@ __pycache__
 *.pid
 *.sock
 *~
-*.egg-info/
 
 # These are backup files generated by rustfmt
 **/*.rs.bk

.travis.yml

@@ -1,28 +1,36 @@
 language: rust
-
-rust:
-  - 1.20.0
-  - stable
-  - beta
-  - nightly
-
-sudo: required
+sudo: false
 dist: trusty
 
+cache:
+  cargo: true
+  apt: true
+
+matrix:
+  include:
+    - rust: 1.20.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"
+    - OPENSSL_VERSION=openssl-1.0.2
 
-addons:
-  apt:
-    packages:
-      - libcurl4-openssl-dev
-      - libelf-dev
-      - libdw-dev
-      - cmake
-      - gcc
-      - binutils-dev
-      - libiberty-dev
+before_install:
+  - sudo add-apt-repository -y ppa:0k53d-karl-f830m/openssl
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
 
 # Add clippy
 before_script:
@@ -33,7 +41,28 @@ before_script:
   - export PATH=$PATH:~/.cargo/bin
 
 script:
-  - USE_SKEPTIC=1 cargo test --no-default-features
+  - |
+    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 ../..
+    fi
   - |
     if [[ "$TRAVIS_RUST_VERSION" == "nightly" && $CLIPPY ]]; then
         cargo clippy
@@ -42,9 +71,11 @@ script:
 # Upload docs
 after_success:
   - |
-    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
-      cargo doc --no-deps &&
+    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 &&
       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"
@@ -52,18 +83,8 @@ after_success:
 
   - |
     if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_RUST_VERSION" == "stable" ]]; then
-      wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz &&
-      tar xzf master.tar.gz &&
-      cd kcov-master &&
-      mkdir build &&
-      cd build &&
-      cmake .. &&
-      make &&
-      make install DESTDIR=../../kcov-build &&
-      cd ../.. &&
-      rm -rf kcov-master &&
-      for file in target/debug/actix_web-*[^\.d]; do mkdir -p "target/cov/$(basename $file)"; ./kcov-build/usr/local/bin/kcov --exclude-pattern=/.cargo,/usr/lib --verify "target/cov/$(basename $file)" "$file"; done &&
-      for file in target/debug/test_*[^\.d]; do mkdir -p "target/cov/$(basename $file)"; ./kcov-build/usr/local/bin/kcov --exclude-pattern=/.cargo,/usr/lib --verify "target/cov/$(basename $file)" "$file"; done &&
-      bash <(curl -s https://codecov.io/bash) &&
+      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,45 @@
 # Changes
 
+## 0.3.2 (2018-01-21)
+
+* Fix HEAD requests handling
+
+* Log request processing errors
+
+* Always enable content encoding if encoding explicitly selected
+
+* Allow multiple Applications on a single server with different state #49
+
+* CORS middleware: allowed_headers is defaulting to None #50
+
+
+## 0.3.1 (2018-01-13)
+
+* Fix directory entry path #47
+
+* Do not enable chunked encoding for HTTP/1.0
+
+* Allow explicitly disable chunked encoding
+
+
+## 0.3.0 (2018-01-12)
+
+* HTTP/2 Support
+
+* Refactor streaming responses
+
+* Refactor error handling
+
+* Asynchronous middlewares
+
+* Refactor logger middleware
+
+* Content compression/decompression (br, gzip, deflate)
+
+* Server multi-threading
+
+* Gracefull shutdown support
+
 
 ## 0.2.1 (2017-11-03)
 
@@ -9,6 +49,7 @@
 
 * Add conversion impl from `HttpResponse` and `BinaryBody` to a `Frame`
 
+
 ## 0.2.0 (2017-10-30)
 
 * Do not use `http::Uri` as it can not parse some valid paths

Cargo.toml

@@ -1,16 +1,18 @@
 [package]
 name = "actix-web"
-version = "0.2.1"
+version = "0.3.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web framework"
 readme = "README.md"
-keywords = ["actor", "http", "web"]
+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"]
-license = "Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+categories = ["network-programming", "asynchronous",
+              "web-programming::http-server", "web-programming::websocket"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config",
+           "appveyor.yml", "/examples/**"]
 build = "build.rs"
 
 [badges]
@@ -28,49 +30,82 @@ default = []
 # tls
 tls = ["native-tls", "tokio-tls"]
 
-# http2 = ["h2"]
+# openssl
+alpn = ["openssl", "openssl/v102", "openssl/v110", "tokio-openssl"]
 
 [dependencies]
-log = "0.3"
-time = "0.1"
-http = "0.1"
-httparse = "0.1"
+log = "0.4"
+failure = "0.1"
+failure_derive = "0.1"
+h2 = "0.1"
+http = "^0.1.2"
+httparse = "1.2"
 http-range = "0.1"
+time = "0.1"
 mime = "0.3"
 mime_guess = "1.8"
-cookie = { version="0.10", features=["percent-encode"] }
 regex = "0.2"
-sha1 = "0.2"
-url = "1.5"
+sha1 = "0.4"
+url = "1.6"
+libc = "0.2"
+serde = "1.0"
+serde_json = "1.0"
+brotli2 = "^0.3.2"
 percent-encoding = "1.0"
+smallvec = "0.6"
+bitflags = "1.0"
+num_cpus = "1.0"
+flate2 = "1.0"
+cookie = { version="0.10", features=["percent-encode", "secure"] }
 
-# tokio
+# io
+mio = "0.6"
+net2 = "0.2"
 bytes = "0.4"
 futures = "0.1"
 tokio-io = "0.1"
 tokio-core = "0.1"
-# h2 = { git = 'https://github.com/carllerche/h2', optional = true }
 
-# tls
+# native-tls
 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.3.1"
-#path = "../actix"
-#git = "https://github.com/actix/actix.git"
-default-features = false
-features = []
+version = "^0.4.2"
+
+[dependencies.openssl]
+version = "0.9"
+optional = true
 
 [dev-dependencies]
-env_logger = "0.4"
+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
+# debug = true
+
+[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",
+]

LICENSE-MIT

@@ -0,0 +1,25 @@
+Copyright (c) 2017 Nikilay Kim
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

Makefile

@@ -1,6 +1,6 @@
-.PHONY: default build test doc clean
+.PHONY: default build test doc book clean
 
-CARGO_FLAGS := --features "$(FEATURES)"
+CARGO_FLAGS := --features "$(FEATURES) alpn"
 
 default: test
 
@@ -20,3 +20,7 @@ clippy:
 
 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,123 +1,71 @@
-# 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)
+# 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)
 
-Asynchronous web framework for [Actix](https://github.com/actix/actix).
+Actix web is a small, fast, pragmatic, open source rust web framework.
 
-* [API Documentation (Development)](http://actix.github.io/actix-web/actix_web/)
-* [API Documentation (Releases)](https://docs.rs/actix-web/)
-* Cargo package: [actix-web](https://crates.io/crates/actix-web)
-* Minimum supported Rust version: 1.20 or later
-
----
-
-Actix web is licensed under the [Apache-2.0 license](http://opensource.org/licenses/APACHE-2.0).
-
-## Features
-
-  * HTTP 1.1 and 1.0 support
-  * Streaming and pipelining support
-  * Keep-alive and slow requests support
-  * [WebSockets support](https://actix.github.io/actix-web/actix_web/ws/index.html)
-  * Configurable request routing
-  * Multipart streams
-  * Middlewares
-
-## Usage
-
-To use `actix-web`, add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-actix-web = "0.2"
-```
-
-## Example
-
-* [Basic](https://github.com/actix/actix-web/tree/master/examples/basic.rs)
-* [Stateful](https://github.com/actix/actix-web/tree/master/examples/state.rs)
-* [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.rs)
-* [Tcp/Websocket chat](https://github.com/actix/actix-web/tree/master/examples/websocket-chat)
-* [SockJS Server](https://github.com/fafhrd91/actix-sockjs)
-
-
-```rust
-extern crate actix;
+```rust,ignore
 extern crate actix_web;
-extern crate env_logger;
-
-use actix::*;
 use actix_web::*;
 
-
-struct MyWebSocket;
-
-/// Actor with http context
-impl Actor for MyWebSocket {
-    type Context = HttpContext<Self>;
-}
-
-/// Http route handler
-impl Route for MyWebSocket {
-    type State = ();
-
-    fn request(req: &mut HttpRequest,
-               payload: Payload, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
-    {
-        // websocket handshake
-        let resp = ws::handshake(req)?;
-        // send HttpResponse back to peer
-        ctx.start(resp);
-        // convert bytes stream to a stream of `ws::Message` and handle stream
-        ctx.add_stream(ws::WsStream::new(payload));
-        Reply::async(MyWebSocket)
-    }
-}
-
-/// Standard actix's stream handler for a stream of `ws::Message`
-impl StreamHandler<ws::Message> for MyWebSocket {
-    fn started(&mut self, ctx: &mut Self::Context) {
-        println!("WebSocket session openned");
-    }
-
-    fn finished(&mut self, ctx: &mut Self::Context) {
-        println!("WebSocket session closed");
-    }
-}
-
-impl Handler<ws::Message> for MyWebSocket {
-    fn handle(&mut self, msg: ws::Message, ctx: &mut HttpContext<Self>)
-              -> Response<Self, ws::Message>
-    {
-        // process websocket messages
-        println!("WS: {:?}", msg);
-        match msg {
-            ws::Message::Ping(msg) => ws::WsWriter::pong(ctx, &msg),
-            ws::Message::Text(text) => ws::WsWriter::text(ctx, &text),
-            ws::Message::Binary(bin) => ws::WsWriter::binary(ctx, bin),
-            ws::Message::Closed | ws::Message::Error => {
-                ctx.stop();
-            }
-            _ => (),
-        }
-        Self::empty()
-    }
+fn index(req: HttpRequest) -> String {
+    format!("Hello {}!", &req.match_info()["name"])
 }
 
 fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("ws-example");
-
     HttpServer::new(
-        Application::default("/")
-            // enable logger
-            .middleware(Logger::new(None))
-            // websocket route
-            .resource("/ws/", |r| r.get::<MyWebSocket>())
-            .route_handler("/", StaticFiles::new("examples/static/", true)))
-        .serve::<_, ()>("127.0.0.1:8080").unwrap();
-
-    Arbiter::system().send(msgs::SystemExit(0));
-    let _ = sys.run();
+        || Application::new()
+            .resource("/{name}", |r| r.f(index)))
+        .bind("127.0.0.1:8080").unwrap()
+        .run();
 }
 ```
+
+## Documentation
+
+* [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
+
+## 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).
+
+## Benchmarks
+
+Some basic benchmarks could be found in this [respository](https://github.com/fafhrd91/benchmarks).
+
+## 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/)
+
+## License
+
+This project is licensed under either of
+
+* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
+* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
+
+at your option.

build.rs

@@ -1,18 +1,47 @@
 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"]);
+        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 f = env::var("OUT_DIR").unwrap() + "/skeptic-tests.rs";
         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"),
+        Some(false) => (),
+        None => (),
+    };
 }

cov.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-for file in target/debug/actix_web-*[^\.d]; do mkdir -p "target/cov/$(basename $file)"; /usr/local/bin/kcov --exclude-pattern=/.cargo,/usr/lib --verify "target/cov/$(basename $file)" "$file"; done &&
-for file in target/debug/test_*[^\.d]; do mkdir -p "target/cov/$(basename $file)"; /usr/local/bin/kcov --exclude-pattern=/.cargo,/usr/lib --verify "target/cov/$(basename $file)" "$file"; done

examples/basic.rs

@@ -1,69 +0,0 @@
-#![allow(unused_variables)]
-extern crate actix;
-extern crate actix_web;
-extern crate env_logger;
-extern crate futures;
-
-use actix_web::*;
-use futures::stream::{once, Once};
-
-/// somple handle
-fn index(req: &mut HttpRequest, _payload: Payload, state: &()) -> HttpResponse {
-    println!("{:?}", req);
-    httpcodes::HTTPOk.into()
-}
-
-/// somple handle
-fn index_async(req: &mut HttpRequest, _payload: Payload, state: &()) -> Once<actix_web::Frame, ()>
-{
-    println!("{:?}", req);
-
-    once(Ok(HttpResponse::builder(StatusCode::OK)
-            .content_type("text/html")
-            .body(format!("Hello {}!", req.match_info().get("name").unwrap()))
-            .unwrap()
-            .into()))
-}
-
-/// handle with path parameters like `/name/{name}/`
-fn with_param(req: &mut HttpRequest, _payload: Payload, state: &())
-              -> HandlerResult<HttpResponse>
-{
-    println!("{:?}", req);
-
-    Ok(HttpResponse::builder(StatusCode::OK)
-       .content_type("test/plain")
-       .body(format!("Hello {}!", req.match_info().get("name").unwrap()))?)
-}
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("ws-example");
-
-    HttpServer::new(
-        Application::default("/")
-            // enable logger
-            .middleware(Logger::new(None))
-            // register simple handler, handle all methods
-            .handler("/index.html", index)
-            // with path parameters
-            .resource("/user/{name}/", |r| r.handler(Method::GET, with_param))
-            // async handler
-            .resource("/async/{name}", |r| r.async(Method::GET, index_async))
-            // redirect
-            .resource("/", |r| r.handler(Method::GET, |req, _, _| {
-                println!("{:?}", req);
-
-                Ok(httpcodes::HTTPFound
-                   .builder()
-                   .header("LOCATION", "/index.html")
-                   .body(Body::Empty)?)
-            }))
-            // static files
-            .route_handler("/static", StaticFiles::new("examples/static/", true)))
-        .serve::<_, ()>("127.0.0.1:8080").unwrap();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/basics/Cargo.toml

@@ -0,0 +1,11 @@
+[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

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,151 @@
+#![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

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

examples/diesel/Cargo.toml

@@ -0,0 +1,19 @@
+[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

@@ -0,0 +1,43 @@
+# 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

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

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

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

examples/diesel/src/db.rs

@@ -0,0 +1,53 @@
+//! 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

@@ -0,0 +1,73 @@
+//! 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

@@ -0,0 +1,14 @@
+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

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

examples/hello-world/Cargo.toml

@@ -0,0 +1,10 @@
+[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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,18 @@
+[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

@@ -0,0 +1,48 @@
+# 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

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,99 @@
+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/Cargo.toml

@@ -2,6 +2,7 @@
 name = "multipart-example"
 version = "0.1.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+workspace = "../.."
 
 [[bin]]
 name = "multipart"
@@ -9,6 +10,6 @@ path = "src/main.rs"
 
 [dependencies]
 env_logger = "*"
-#actix = "0.3"
-actix = { git = "https://github.com/actix/actix.git" }
-actix-web = { path = "../../" }
+futures = "0.1"
+actix = "0.4"
+actix-web = { path="../../" }

examples/multipart/README.md

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

examples/multipart/src/main.rs

@@ -2,77 +2,58 @@
 extern crate actix;
 extern crate actix_web;
 extern crate env_logger;
+extern crate futures;
 
 use actix::*;
 use actix_web::*;
 
-struct MyRoute;
+use futures::{Future, Stream};
+use futures::future::{result, Either};
 
-impl Actor for MyRoute {
-    type Context = HttpContext<Self>;
-}
 
-impl Route for MyRoute {
-    type State = ();
+fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>>
+{
+    println!("{:?}", req);
 
-    fn request(req: &mut HttpRequest, payload: Payload,
-               ctx: &mut HttpContext<Self>) -> RouteResult<Self> {
-        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);
 
-        let multipart = req.multipart(payload)?;
-
-        // get Multipart stream
-        WrapStream::<MyRoute>::actstream(multipart)
-            .and_then(|item, act, ctx| {
-                // Multipart stream is a stream of Fields and nested Multiparts
-                match item {
-                    multipart::MultipartItem::Field(field) => {
-                        println!("==== FIELD ==== {:?}", field);
-
-                        // Read field's stream
-                        fut::Either::A(
-                            field.actstream()
-                                .map(|chunk, act, ctx| {
-                                    println!(
-                                        "-- CHUNK: \n{}",
-                                        std::str::from_utf8(&chunk.0).unwrap());
-                                })
-                                .finish())
-                    },
-                    multipart::MultipartItem::Nested(mp) => {
-                        // Do nothing for nested multipart stream
-                        fut::Either::B(fut::ok(()))
-                    }
+                    // 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(())))
                 }
-            })
-            // wait until stream finish
-            .finish()
-            .map_err(|e, act, ctx| {
-                ctx.start(httpcodes::HTTPBadRequest);
-                ctx.write_eof();
-            })
-            .map(|_, act, ctx| {
-                ctx.start(httpcodes::HTTPOk);
-                ctx.write_eof();
-            })
-            .spawn(ctx);
-
-        Reply::async(MyRoute)
-    }
+            }
+        })
+        .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");
 
-    HttpServer::new(
-        vec![
-            Application::default("/")
-                .resource("/multipart", |r| {
-                    r.post::<MyRoute>();
-                }).finish()
-        ])
-        .serve::<_, ()>("127.0.0.1:8080").unwrap();
+    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.rs

@@ -1,86 +0,0 @@
-//! There are two level of statfulness 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 actix::*;
-use actix_web::*;
-use std::cell::Cell;
-
-struct AppState {
-    counter: Cell<usize>,
-}
-
-/// somple handle
-fn index(req: &mut HttpRequest, _: Payload, state: &AppState) -> HttpResponse {
-    println!("{:?}", req);
-    state.counter.set(state.counter.get() + 1);
-    httpcodes::HTTPOk.with_body(
-        format!("Num of requests: {}", 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 = HttpContext<Self>;
-}
-
-impl Route for MyWebSocket {
-    /// Shared application state
-    type State = AppState;
-
-    fn request(req: &mut HttpRequest,
-               payload: Payload, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
-    {
-        let resp = ws::handshake(req)?;
-        ctx.start(resp);
-        ctx.add_stream(ws::WsStream::new(payload));
-        Reply::async(MyWebSocket{counter: 0})
-    }
-}
-impl StreamHandler<ws::Message> for MyWebSocket {}
-impl Handler<ws::Message> for MyWebSocket {
-    fn handle(&mut self, msg: ws::Message, ctx: &mut HttpContext<Self>)
-              -> Response<Self, ws::Message>
-    {
-        self.counter += 1;
-        println!("WS({}): {:?}", self.counter, msg);
-        match msg {
-            ws::Message::Ping(msg) => ws::WsWriter::pong(ctx, &msg),
-            ws::Message::Text(text) => ws::WsWriter::text(ctx, &text),
-            ws::Message::Binary(bin) => ws::WsWriter::binary(ctx, bin),
-            ws::Message::Closed | ws::Message::Error => {
-                ctx.stop();
-            }
-            _ => (),
-        }
-        Self::empty()
-    }
-}
-
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("ws-example");
-
-    HttpServer::new(
-        Application::builder("/", AppState{counter: Cell::new(0)})
-            // enable logger
-            .middleware(Logger::new(None))
-            // websocket route
-            .resource("/ws/", |r| r.get::<MyWebSocket>())
-            // register simple handler, handle all methods
-            .handler("/", index))
-        .serve::<_, ()>("127.0.0.1:8080").unwrap();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/state/Cargo.toml

@@ -0,0 +1,11 @@
+[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

@@ -0,0 +1,15 @@
+# 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

@@ -0,0 +1,77 @@
+#![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/template_tera/Cargo.toml

@@ -0,0 +1,11 @@
+[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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,17 @@
+<!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

@@ -0,0 +1,13 @@
+<!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 +1,14 @@
 [package]
-name = "ssl-example"
+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.4"
-
-actix = "0.3.1"
-actix-web = { path = "../../", features=["tls"] }
+env_logger = "0.5"
+actix = "^0.4.2"
+actix-web = { path = "../../", features=["alpn"] }

examples/tls/README.md

@@ -0,0 +1,16 @@
+# 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

@@ -3,44 +3,49 @@ extern crate actix;
 extern crate actix_web;
 extern crate env_logger;
 
-//use tokio_tls;
 use std::fs::File;
 use std::io::Read;
-// use native_tls::{TlsAcceptor, TlsStream};
 
 use actix_web::*;
 
-/// somple handle
-fn index(req: &mut HttpRequest, _payload: Payload, state: &()) -> HttpResponse {
+
+/// simple handle
+fn index(req: HttpRequest) -> Result<HttpResponse> {
     println!("{:?}", req);
-    httpcodes::HTTPOk.with_body("Welcome!")
+    Ok(httpcodes::HTTPOk
+       .build()
+       .content_type("text/plain")
+       .body("Welcome!")?)
 }
 
 fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    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, "12345").unwrap();
+    let pkcs12 = Pkcs12::from_der(&pkcs12).unwrap().parse("12345").unwrap();
 
-    HttpServer::new(
-        Application::default("/")
+    let addr = HttpServer::new(
+        || Application::new()
             // enable logger
-            .middleware(Logger::new(None))
+            .middleware(middleware::Logger::default())
             // register simple handler, handle all methods
-            .handler("/index.html", index)
+            .resource("/index.html", |r| r.f(index))
             // with path parameters
-            .resource("/", |r| r.handler(Method::GET, |req, _, _| {
-                Ok(httpcodes::HTTPFound
-                   .builder()
-                   .header("LOCATION", "/index.html")
-                   .body(Body::Empty)?)
+            .resource("/", |r| r.method(Method::GET).f(|req| {
+                httpcodes::HTTPFound
+                    .build()
+                    .header("LOCATION", "/index.html")
+                    .body(Body::Empty)
             })))
-        .serve_tls::<_, ()>("127.0.0.1:8080", pkcs12).unwrap();
+        .bind("127.0.0.1:8443").unwrap()
+        .start_ssl(&pkcs12).unwrap();
 
-    println!("Started http server: 127.0.0.1:8080");
+    println!("Started http server: 127.0.0.1:8443");
     let _ = sys.run();
 }

examples/websocket-chat/Cargo.toml

@@ -2,6 +2,7 @@
 name = "websocket-example"
 version = "0.1.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+workspace = "../.."
 
 [[bin]]
 name = "server"
@@ -24,6 +25,5 @@ serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"
 
-#actix = "0.3"
-actix = { git = "https://github.com/actix/actix.git" }
-actix-web = { path = "../../" }
+actix = "^0.4.2"
+actix-web = { path="../../" }

examples/websocket-chat/README.md

@@ -1,6 +1,6 @@
 # Websocket chat example
 
-This is extension of the 
+This is extension of the
 [actix chat example](https://github.com/actix/actix/tree/master/examples/chat)
 
 Added features:
@@ -9,18 +9,16 @@ Added features:
 * 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 messsage 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 droppped
-  
+* `\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
@@ -29,7 +27,6 @@ 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/
+Open url: [http://localhost:8080/](http://localhost:8080/)

examples/websocket-chat/src/client.rs

@@ -1,4 +1,4 @@
-extern crate actix;
+#[macro_use] extern crate actix;
 extern crate bytes;
 extern crate byteorder;
 extern crate futures;
@@ -56,13 +56,9 @@ fn main() {
 
 struct ChatClient;
 
+#[derive(Message)]
 struct ClientCommand(String);
 
-impl ResponseType for ClientCommand {
-    type Item = ();
-    type Error = ();
-}
-
 impl Actor for ChatClient {
     type Context = FramedContext<Self>;
 
@@ -70,6 +66,15 @@ impl Actor for ChatClient {
         // 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 {
@@ -83,14 +88,13 @@ impl ChatClient {
 }
 
 /// Handle stdin commands
-impl Handler<ClientCommand> for ChatClient
-{
-    fn handle(&mut self, msg: ClientCommand, ctx: &mut FramedContext<Self>)
-              -> Response<Self, ClientCommand>
-    {
+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 Self::empty()
+            return
         }
 
         // we check for /sss type of messages
@@ -112,8 +116,6 @@ impl Handler<ClientCommand> for ChatClient
         } else {
             let _ = ctx.send(codec::ChatRequest::Message(m.to_owned()));
         }
-
-        Self::empty()
     }
 }
 
@@ -122,40 +124,26 @@ impl Handler<ClientCommand> for ChatClient
 impl FramedActor for ChatClient {
     type Io = TcpStream;
     type Codec = codec::ClientChatCodec;
-}
 
-impl StreamHandler<codec::ChatResponse, io::Error> for ChatClient {
-
-    fn finished(&mut self, _: &mut FramedContext<Self>) {
-        println!("Disconnected");
-
-        // Stop application on disconnect
-        Arbiter::system().send(msgs::SystemExit(0));
-    }
-}
-
-impl Handler<codec::ChatResponse, io::Error> for ChatClient {
-
-    fn handle(&mut self, msg: codec::ChatResponse, _: &mut FramedContext<Self>)
-              -> Response<Self, codec::ChatResponse>
-    {
+    fn handle(&mut self, msg: io::Result<codec::ChatResponse>, ctx: &mut FramedContext<Self>) {
         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);
+            Err(_) => ctx.stop(),
+            Ok(msg) => match msg {
+                codec::ChatResponse::Message(ref msg) => {
+                    println!("message: {}", msg);
                 }
-                println!("");
+                codec::ChatResponse::Joined(ref msg) => {
+                    println!("!!! joined: {}", msg);
+                }
+                codec::ChatResponse::Rooms(rooms) => {
+                    println!("\n!!! Available rooms:");
+                    for room in rooms {
+                        println!("{}", room);
+                    }
+                    println!("");
+                }
+                _ => (),
             }
-            _ => (),
         }
-
-        Self::empty()
     }
 }

examples/websocket-chat/src/main.rs

@@ -10,6 +10,7 @@ extern crate serde;
 extern crate serde_json;
 #[macro_use] extern crate serde_derive;
 
+#[macro_use]
 extern crate actix;
 extern crate actix_web;
 
@@ -22,13 +23,23 @@ 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,
@@ -41,50 +52,54 @@ struct WsChatSession {
 }
 
 impl Actor for WsChatSession {
-    type Context = HttpContext<Self>;
-}
+    type Context = ws::WebsocketContext<Self, WsChatSessionState>;
 
-/// Entry point for our route
-impl Route for WsChatSession {
-    type State = 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 request(req: &mut HttpRequest,
-               payload: Payload, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
-    {
-        // websocket handshakre, it may fail if request is not websocket request
-        let resp = ws::handshake(&req)?;
-        ctx.start(resp);
-        ctx.add_stream(ws::WsStream::new(payload));
-        Reply::async(
-            WsChatSession {
-                id: 0,
-                hb: Instant::now(),
-                room: "Main".to_owned(),
-                name: None})
+    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 {
-    fn handle(&mut self, msg: session::Message, ctx: &mut HttpContext<Self>)
-              -> Response<Self, session::Message>
-    {
-        ws::WsWriter::text(ctx, &msg.0);
-        Self::empty()
+    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 {
-    fn handle(&mut self, msg: ws::Message, ctx: &mut HttpContext<Self>)
-              -> Response<Self, ws::Message>
-    {
+    type Result = ();
+
+    fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         println!("WEBSOCKET MESSAGE: {:?}", msg);
         match msg {
-            ws::Message::Ping(msg) =>
-                ws::WsWriter::pong(ctx, &msg),
-            ws::Message::Pong(msg) =>
-                self.hb = Instant::now(),
+            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
@@ -98,7 +113,7 @@ impl Handler<ws::Message> for WsChatSession {
                                 match res {
                                     Ok(Ok(rooms)) => {
                                         for room in rooms {
-                                            ws::WsWriter::text(ctx, &room);
+                                            ctx.text(&room);
                                         }
                                     },
                                     _ => println!("Something is wrong"),
@@ -115,20 +130,19 @@ impl Handler<ws::Message> for WsChatSession {
                                 ctx.state().addr.send(
                                     server::Join{id: self.id, name: self.room.clone()});
 
-                                ws::WsWriter::text(ctx, "joined");
+                                ctx.text("joined");
                             } else {
-                                ws::WsWriter::text(ctx, "!!! room name is required");
+                                ctx.text("!!! room name is required");
                             }
                         },
                         "/name" => {
                             if v.len() == 2 {
                                 self.name = Some(v[1].to_owned());
                             } else {
-                                ws::WsWriter::text(ctx, "!!! name is required");
+                                ctx.text("!!! name is required");
                             }
                         },
-                        _ => ws::WsWriter::text(
-                            ctx, &format!("!!! unknown command: {:?}", m)),
+                        _ => ctx.text(&format!("!!! unknown command: {:?}", m)),
                     }
                 } else {
                     let msg = if let Some(ref name) = self.name {
@@ -150,42 +164,9 @@ impl Handler<ws::Message> for WsChatSession {
             }
             _ => (),
         }
-        Self::empty()
     }
 }
 
-impl StreamHandler<ws::Message> for WsChatSession
-{
-    /// Method is called when stream get polled first time.
-    /// 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);
-    }
-
-    /// Method is called when stream finishes, even if stream finishes with error.
-    fn finished(&mut self, ctx: &mut Self::Context) {
-        // notify chat server
-        ctx.state().addr.send(server::Disconnect{id: self.id});
-        ctx.stop()
-    }
-}
-
-
 fn main() {
     let _ = env_logger::init();
     let sys = actix::System::new("websocket-example");
@@ -202,25 +183,28 @@ fn main() {
             Ok(())
         }));
 
-    // Websocket sessions state
-    let state = WsChatSessionState { addr: server };
-
     // Create Http server with websocket support
-    HttpServer::new(
-        Application::builder("/", state)
-            // redirect to websocket.html
-            .resource("/", |r|
-                      r.handler(Method::GET, |req, payload, state| {
-                          Ok(httpcodes::HTTPFound
-                             .builder()
-                             .header("LOCATION", "/static/websocket.html")
-                             .body(Body::Empty)?)
-                      }))
-            // websocket
-            .resource("/ws/", |r| r.get::<WsChatSession>())
-            // static resources
-            .route_handler("/static", StaticFiles::new("static/", true)))
-        .serve::<_, ()>("127.0.0.1:8080").unwrap();
+    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

@@ -13,7 +13,7 @@ use session;
 
 /// New chat session is created
 pub struct Connect {
-    pub addr: Box<Subscriber<session::Message> + Send>,
+    pub addr: Box<actix::Subscriber<session::Message> + Send>,
 }
 
 /// Response type for Connect message
@@ -25,16 +25,13 @@ impl ResponseType for Connect  {
 }
 
 /// Session is disconnected
+#[derive(Message)]
 pub struct Disconnect {
     pub id: usize,
 }
 
-impl ResponseType for Disconnect {
-    type Item = ();
-    type Error = ();
-}
-
 /// Send message to specific room
+#[derive(Message)]
 pub struct Message {
     /// Id of the client session
     pub id: usize,
@@ -44,11 +41,6 @@ pub struct Message {
     pub room: String,
 }
 
-impl ResponseType for Message {
-    type Item = ();
-    type Error = ();
-}
-
 /// List of available rooms
 pub struct ListRooms;
 
@@ -58,6 +50,7 @@ impl ResponseType for ListRooms {
 }
 
 /// Join room, if room does not exists create new one.
+#[derive(Message)]
 pub struct Join {
     /// Client id
     pub id: usize,
@@ -65,15 +58,10 @@ pub struct Join {
     pub name: String,
 }
 
-impl ResponseType for Join {
-    type Item = ();
-    type Error = ();
-}
-
 /// `ChatServer` manages chat rooms and responsible for coordinating chat session.
 /// implementation is super primitive
 pub struct ChatServer {
-    sessions: HashMap<usize, Box<Subscriber<session::Message> + Send>>,
+    sessions: HashMap<usize, Box<actix::Subscriber<session::Message> + Send>>,
     rooms: HashMap<String, HashSet<usize>>,
     rng: RefCell<ThreadRng>,
 }
@@ -118,8 +106,9 @@ impl Actor for ChatServer {
 ///
 /// 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>) -> Response<Self, Connect> {
+    fn handle(&mut self, msg: Connect, _: &mut Context<Self>) -> Self::Result {
         println!("Someone joined");
 
         // notify all users in same room
@@ -133,14 +122,15 @@ impl Handler<Connect> for ChatServer {
         self.rooms.get_mut(&"Main".to_owned()).unwrap().insert(id);
 
         // send id back
-        Self::reply(id)
+        Ok(id)
     }
 }
 
 /// Handler for Disconnect message.
 impl Handler<Disconnect> for ChatServer {
+    type Result = ();
 
-    fn handle(&mut self, msg: Disconnect, _: &mut Context<Self>) -> Response<Self, Disconnect> {
+    fn handle(&mut self, msg: Disconnect, _: &mut Context<Self>) {
         println!("Someone disconnected");
 
         let mut rooms: Vec<String> = Vec::new();
@@ -158,40 +148,39 @@ impl Handler<Disconnect> for ChatServer {
         for room in rooms {
             self.send_message(&room, "Someone disconnected", 0);
         }
-
-        Self::empty()
     }
 }
 
 /// Handler for Message message.
 impl Handler<Message> for ChatServer {
+    type Result = ();
 
-    fn handle(&mut self, msg: Message, _: &mut Context<Self>) -> Response<Self, Message> {
+    fn handle(&mut self, msg: Message, _: &mut Context<Self>) {
         self.send_message(&msg.room, msg.msg.as_str(), msg.id);
-
-        Self::empty()
     }
 }
 
 /// Handler for `ListRooms` message.
 impl Handler<ListRooms> for ChatServer {
+    type Result = MessageResult<ListRooms>;
 
-    fn handle(&mut self, _: ListRooms, _: &mut Context<Self>) -> Response<Self, 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())
         }
 
-        Self::reply(rooms)
+        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>) -> Response<Self, Join> {
+    fn handle(&mut self, msg: Join, _: &mut Context<Self>) {
         let Join {id, name} = msg;
         let mut rooms = Vec::new();
 
@@ -211,7 +200,5 @@ impl Handler<Join> for ChatServer {
         }
         self.send_message(&name, "Someone connected", id);
         self.rooms.get_mut(&name).unwrap().insert(id);
-
-        Self::empty()
     }
 }

examples/websocket-chat/src/session.rs

@@ -6,21 +6,17 @@ use std::time::{Instant, Duration};
 use futures::Stream;
 use tokio_core::net::{TcpStream, TcpListener};
 
-use actix::*;
+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);
 
-impl ResponseType for Message {
-    type Item = ();
-    type Error = ();
-}
-
-/// `ChatSession` actor is responsible for tcp peer communitions.
+/// `ChatSession` actor is responsible for tcp peer communications.
 pub struct ChatSession {
     /// unique session id
     id: usize,
@@ -34,106 +30,89 @@ pub struct ChatSession {
 
 impl Actor for ChatSession {
     /// For tcp communication we are going to use `FramedContext`.
-    /// It is convinient wrapper around `Framed` object from `tokio_io`
+    /// It is convenient wrapper around `Framed` object from `tokio_io`
     type Context = FramedContext<Self>;
-}
 
-/// To use `FramedContext` we have to define Io type and Codec
-impl FramedActor for ChatSession {
-    type Io = TcpStream;
-    type Codec= ChatCodec;
-}
-
-/// Also `FramedContext` requires Actor which is able to handle stream
-/// of `<Codec as Decoder>::Item` items.
-impl StreamHandler<ChatRequest, io::Error> for ChatSession {
-
-    fn started(&mut self, ctx: &mut 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.
-        self.addr.call(self, server::Connect{addr: ctx.sync_subscriber()}).then(|res, act, ctx| {
-            match res {
-                Ok(Ok(res)) => act.id = res,
-                // something is wrong with chat server
-                _ => ctx.stop(),
-            }
-            fut::ok(())
-        }).wait(ctx);
+        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 finished(&mut self, ctx: &mut FramedContext<Self>) {
+    fn stopping(&mut self, ctx: &mut Self::Context) -> bool {
         // notify chat server
         self.addr.send(server::Disconnect{id: self.id});
-
-        ctx.stop()
+        true
     }
 }
 
-impl Handler<ChatRequest, io::Error> for ChatSession {
-
-    /// We'll stop chat session actor on any error, high likely it is just
-    /// termination of the tcp stream.
-    fn error(&mut self, _: io::Error, ctx: &mut FramedContext<Self>) {
-        ctx.stop()
-    }
+/// 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: ChatRequest, ctx: &mut FramedContext<Self>)
-              -> Response<Self, ChatRequest>
-    {
+    fn handle(&mut self, msg: io::Result<ChatRequest>, ctx: &mut FramedContext<Self>) {
         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));
-                        },
+            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"),
-                    }
-                    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()})
+                        }
+                        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(),
             }
-            // we update heartbeat time on ping from peer
-            ChatRequest::Ping =>
-                self.hb = Instant::now(),
         }
-
-        Self::empty()
     }
 }
 
 /// 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>)
-              -> Response<Self, Message>
-    {
+    fn handle(&mut self, msg: Message, ctx: &mut FramedContext<Self>) {
         // send message to peer
         let _ = ctx.send(ChatResponse::Message(msg.0));
-
-        Self::empty()
     }
 }
 
@@ -170,7 +149,7 @@ impl ChatSession {
 }
 
 
-/// Define tcp server that will accept incomint tcp connection and create
+/// Define tcp server that will accept incoming tcp connection and create
 /// chat actors.
 pub struct TcpServer {
     chat: SyncAddress<ChatServer>,
@@ -188,7 +167,9 @@ impl TcpServer {
         // 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_stream(listener.incoming().map(|(t, a)| TcpConnect(t, a)));
+            ctx.add_message_stream(listener.incoming()
+                                   .map_err(|_| ())
+                                   .map(|(t, a)| TcpConnect(t, a)));
             TcpServer{chat: chat}
         });
     }
@@ -200,27 +181,17 @@ impl Actor for TcpServer {
     type Context = Context<Self>;
 }
 
+#[derive(Message)]
 struct TcpConnect(TcpStream, net::SocketAddr);
 
-impl ResponseType for TcpConnect {
-    type Item = ();
-    type Error = ();
-}
-
 /// Handle stream of TcpStream's
-impl StreamHandler<TcpConnect, io::Error> for TcpServer {}
+impl Handler<TcpConnect> for TcpServer {
+    type Result = ();
 
-impl Handler<TcpConnect, io::Error> for TcpServer {
-
-    fn handle(&mut self, msg: TcpConnect, _: &mut Context<Self>) -> Response<Self, TcpConnect>
-    {
+    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);
-
-        // this is response for message, which is defined by `ResponseType` trait
-        // in this case we just return unit.
-        Self::empty()
     }
 }

examples/websocket.rs

@@ -1,85 +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::*;
-
-
-struct MyWebSocket;
-
-impl Actor for MyWebSocket {
-    type Context = HttpContext<Self>;
-}
-
-/// Http route handler
-impl Route for MyWebSocket {
-    type State = ();
-
-    fn request(req: &mut HttpRequest,
-               payload: Payload, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
-    {
-        // websocket handshake
-        let resp = ws::handshake(req)?;
-        // send HttpResponse back to peer
-        ctx.start(resp);
-        // convert bytes stream to a stream of `ws::Message` and register it
-        ctx.add_stream(ws::WsStream::new(payload));
-        Reply::async(MyWebSocket)
-    }
-}
-
-/// Standard actix's stream handler for a stream of `ws::Message`
-impl StreamHandler<ws::Message> for MyWebSocket {
-    fn started(&mut self, ctx: &mut Self::Context) {
-        println!("WebSocket session openned");
-    }
-
-    fn finished(&mut self, ctx: &mut Self::Context) {
-        println!("WebSocket session closed");
-    }
-}
-
-impl Handler<ws::Message> for MyWebSocket {
-    fn handle(&mut self, msg: ws::Message, ctx: &mut HttpContext<Self>)
-              -> Response<Self, ws::Message>
-    {
-        // process websocket messages
-        println!("WS: {:?}", msg);
-        match msg {
-            ws::Message::Ping(msg) => ws::WsWriter::pong(ctx, &msg),
-            ws::Message::Text(text) => ws::WsWriter::text(ctx, &text),
-            ws::Message::Binary(bin) => ws::WsWriter::binary(ctx, bin),
-            ws::Message::Closed | ws::Message::Error => {
-                ctx.stop();
-            }
-            _ => (),
-        }
-        Self::empty()
-    }
-}
-
-fn main() {
-    ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("ws-example");
-
-    HttpServer::new(
-        Application::default("/")
-            // enable logger
-            .middleware(Logger::new(None))
-            // websocket route
-            .resource("/ws/", |r| r.get::<MyWebSocket>())
-            .route_handler("/", StaticFiles::new("examples/static/", true)))
-        // start http server on 127.0.0.1:8080
-        .serve::<_, ()>("127.0.0.1:8080").unwrap();
-
-    println!("Started http server: 127.0.0.1:8080");
-    let _ = sys.run();
-}

examples/websocket/Cargo.toml

@@ -0,0 +1,14 @@
+[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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,65 @@
+//! 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();
+}

guide/book.toml

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

guide/src/SUMMARY.md

@@ -0,0 +1,16 @@
+# 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

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,206 @@
+# 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

@@ -0,0 +1,44 @@
+# 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

@@ -0,0 +1,42 @@
+# 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

@@ -0,0 +1,125 @@
+# 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

@@ -0,0 +1,95 @@
+# 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

@@ -0,0 +1,109 @@
+# 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

@@ -0,0 +1,197 @@
+# 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

@@ -0,0 +1,237 @@
+# 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

@@ -0,0 +1,151 @@
+# 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

@@ -0,0 +1,578 @@
+# 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

@@ -0,0 +1,297 @@
+# 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

@@ -0,0 +1,97 @@
+# 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

@@ -0,0 +1,49 @@
+# 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/)

src/application.rs

@@ -1,139 +1,196 @@
+use std::mem;
 use std::rc::Rc;
-use std::string::ToString;
+use std::cell::RefCell;
 use std::collections::HashMap;
 
-use task::Task;
-use payload::Payload;
-use route::{RouteHandler, FnHandler};
+use handler::Reply;
+use router::{Router, Pattern};
 use resource::Resource;
-use recognizer::{RouteRecognizer, check_pattern};
+use handler::{Handler, RouteHandler, WrapHandler};
 use httprequest::HttpRequest;
-use httpresponse::HttpResponse;
-use server::HttpHandler;
-
-
-/// Middleware definition
-#[allow(unused_variables)]
-pub trait Middleware {
-
-    /// Method is called when request is ready.
-    fn start(&self, req: &mut HttpRequest) -> Result<(), HttpResponse> {
-        Ok(())
-    }
-
-    /// Method is called when handler returns response,
-    /// but before sending body streams to peer.
-    fn response(&self, req: &mut HttpRequest, resp: HttpResponse) -> HttpResponse {
-        resp
-    }
-
-    /// Http interation is finished
-    fn finish(&self, req: &mut HttpRequest, resp: &HttpResponse) {}
-}
+use pipeline::{Pipeline, PipelineHandler};
+use middleware::Middleware;
+use server::{HttpHandler, IntoHttpHandler, HttpHandlerTask, ServerSettings};
 
 /// Application
-pub struct Application<S> {
+pub struct HttpApplication<S=()> {
     state: Rc<S>,
     prefix: String,
-    default: Resource<S>,
-    handlers: HashMap<String, Box<RouteHandler<S>>>,
-    router: RouteRecognizer<Resource<S>>,
-    middlewares: Rc<Vec<Box<Middleware>>>,
+    router: Router,
+    inner: Rc<RefCell<Inner<S>>>,
+    middlewares: Rc<Vec<Box<Middleware<S>>>>,
 }
 
-impl<S: 'static> Application<S> {
+pub(crate) struct Inner<S> {
+    prefix: usize,
+    default: Resource<S>,
+    router: Router,
+    resources: Vec<Resource<S>>,
+    handlers: Vec<(String, Box<RouteHandler<S>>)>,
+}
 
-    fn run(&self, req: &mut HttpRequest, payload: Payload) -> Task {
-        if let Some((params, h)) = self.router.recognize(req.path()) {
-            if let Some(params) = params {
-                req.set_match_info(params);
-            }
-            h.handle(req, payload, Rc::clone(&self.state))
+impl<S: 'static> PipelineHandler<S> for Inner<S> {
+
+    fn handle(&mut self, mut req: HttpRequest<S>) -> Reply {
+        if let Some(idx) = self.router.recognize(&mut req) {
+            self.resources[idx].handle(req.clone(), Some(&mut self.default))
         } else {
-            for (prefix, handler) in &self.handlers {
-                if req.path().starts_with(prefix) {
-                    return handler.handle(req, payload, Rc::clone(&self.state))
+            for &mut (ref prefix, ref mut handler) in &mut self.handlers {
+                let m = {
+                    let path = &req.path()[self.prefix..];
+                    path.starts_with(prefix) && (path.len() == prefix.len() ||
+                                                 path.split_at(prefix.len()).1.starts_with('/'))
+                };
+                if m {
+                    let path: &'static str = unsafe {
+                        mem::transmute(&req.path()[self.prefix+prefix.len()..]) };
+                    if path.is_empty() {
+                        req.match_info_mut().add("tail", "");
+                    } else {
+                        req.match_info_mut().add("tail", path.split_at(1).1);
+                    }
+                    return handler.handle(req)
                 }
             }
-            self.default.handle(req, payload, Rc::clone(&self.state))
+            self.default.handle(req, None)
         }
     }
 }
 
-impl<S: 'static> HttpHandler for Application<S> {
-
-    fn prefix(&self) -> &str {
-        &self.prefix
+#[cfg(test)]
+impl<S: 'static> HttpApplication<S> {
+ #[cfg(test)]
+    pub(crate) fn run(&mut self, req: HttpRequest<S>) -> Reply {
+        self.inner.borrow_mut().handle(req)
     }
-    
-    fn handle(&self, req: &mut HttpRequest, payload: Payload) -> Task {
-        // run middlewares
-        if !self.middlewares.is_empty() {
-            for middleware in self.middlewares.iter() {
-                if let Err(resp) = middleware.start(req) {
-                    return Task::reply(resp)
-                };
-            }
-            let mut task = self.run(req, payload);
-            task.set_middlewares(Rc::clone(&self.middlewares));
-            task
+    #[cfg(test)]
+    pub(crate) fn prepare_request(&self, req: HttpRequest) -> HttpRequest<S> {
+        req.with_state(Rc::clone(&self.state), self.router.clone())
+    }
+}
+
+impl<S: 'static> HttpHandler for HttpApplication<S> {
+
+    fn handle(&mut self, req: HttpRequest) -> Result<Box<HttpHandlerTask>, HttpRequest> {
+        let m = {
+            let path = req.path();
+            path.starts_with(&self.prefix) && (
+                path.len() == self.prefix.len() ||
+                    path.split_at(self.prefix.len()).1.starts_with('/'))
+        };
+        if m {
+            let inner = Rc::clone(&self.inner);
+            let req = req.with_state(Rc::clone(&self.state), self.router.clone());
+
+            Ok(Box::new(Pipeline::new(req, Rc::clone(&self.middlewares), inner)))
         } else {
-            self.run(req, payload)
+            Err(req)
         }
     }
 }
 
+struct ApplicationParts<S> {
+    state: S,
+    prefix: String,
+    settings: ServerSettings,
+    default: Resource<S>,
+    resources: HashMap<Pattern, Option<Resource<S>>>,
+    handlers: Vec<(String, Box<RouteHandler<S>>)>,
+    external: HashMap<String, Pattern>,
+    middlewares: Vec<Box<Middleware<S>>>,
+}
+
+/// Structure that follows the builder pattern for building `Application` structs.
+pub struct Application<S=()> {
+    parts: Option<ApplicationParts<S>>,
+}
+
 impl Application<()> {
 
-    /// Create default `ApplicationBuilder` with no state
-    pub fn default<T: ToString>(prefix: T) -> ApplicationBuilder<()> {
-        ApplicationBuilder {
-            parts: Some(ApplicationBuilderParts {
+    /// Create application with empty state. Application can
+    /// be configured with builder-like pattern.
+    pub fn new() -> Application<()> {
+        Application {
+            parts: Some(ApplicationParts {
                 state: (),
-                prefix: prefix.to_string(),
+                prefix: "/".to_owned(),
+                settings: ServerSettings::default(),
                 default: Resource::default_not_found(),
-                handlers: HashMap::new(),
                 resources: HashMap::new(),
+                handlers: Vec::new(),
+                external: HashMap::new(),
                 middlewares: Vec::new(),
             })
         }
     }
 }
 
+impl Default for Application<()> {
+    fn default() -> Self {
+        Application::new()
+    }
+}
+
 impl<S> Application<S> where S: 'static {
 
-    /// Create application builder with specific state. State is shared with all
-    /// routes within same application and could be
-    /// accessed with `HttpContext::state()` method.
-    pub fn builder<T: ToString>(prefix: T, state: S) -> ApplicationBuilder<S> {
-        ApplicationBuilder {
-            parts: Some(ApplicationBuilderParts {
+    /// Create application with specific state. Application can be
+    /// configured with builder-like pattern.
+    ///
+    /// State is shared with all resources within same application and could be
+    /// accessed with `HttpRequest::state()` method.
+    pub fn with_state(state: S) -> Application<S> {
+        Application {
+            parts: Some(ApplicationParts {
                 state: state,
-                prefix: prefix.to_string(),
+                prefix: "/".to_owned(),
+                settings: ServerSettings::default(),
                 default: Resource::default_not_found(),
-                handlers: HashMap::new(),
                 resources: HashMap::new(),
+                handlers: Vec::new(),
+                external: HashMap::new(),
                 middlewares: Vec::new(),
             })
         }
     }
-}
 
-struct ApplicationBuilderParts<S> {
-    state: S,
-    prefix: String,
-    default: Resource<S>,
-    handlers: HashMap<String, Box<RouteHandler<S>>>,
-    resources: HashMap<String, Resource<S>>,
-    middlewares: Vec<Box<Middleware>>,
-}
-
-/// Application builder
-pub struct ApplicationBuilder<S=()> {
-    parts: Option<ApplicationBuilderParts<S>>,
-}
-
-impl<S> ApplicationBuilder<S> where S: 'static {
+    /// Set application prefix
+    ///
+    /// Only requests that matches application's prefix get processed by this application.
+    /// Application prefix always contains leading "/" slash. If supplied prefix
+    /// does not contain leading slash, it get inserted. Prefix should
+    /// consists valid 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.
+    ///
+    /// In the following example only requests with "/app/" path prefix
+    /// get handled. Request with path "/app/test/" would be handled,
+    /// but request with path "/application" or "/other/..." would return *NOT FOUND*
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::*;
+    ///
+    /// fn main() {
+    ///     let app = Application::new()
+    ///         .prefix("/app")
+    ///         .resource("/test", |r| {
+    ///              r.method(Method::GET).f(|_| httpcodes::HTTPOk);
+    ///              r.method(Method::HEAD).f(|_| httpcodes::HTTPMethodNotAllowed);
+    ///         })
+    ///         .finish();
+    /// }
+    /// ```
+    pub fn prefix<P: Into<String>>(mut self, prefix: P) -> Application<S> {
+        {
+            let parts = self.parts.as_mut().expect("Use after finish");
+            let mut prefix = prefix.into();
+            if !prefix.starts_with('/') {
+                prefix.insert(0, '/')
+            }
+            parts.prefix = prefix;
+        }
+        self
+    }
 
     /// Configure resource for specific path.
     ///
@@ -144,7 +201,7 @@ impl<S> ApplicationBuilder<S> where S: 'static {
     /// A variable part is specified in the form `{identifier}`, where
     /// the identifier can be used later in a request handler to access the matched
     /// value for that part. This is done by looking up the identifier
-    /// in the `Params` object returned by `Request.match_info()` method.
+    /// in the `Params` object returned by `HttpRequest.match_info()` method.
     ///
     /// By default, each part matches the regular expression `[^{}/]+`.
     ///
@@ -154,57 +211,39 @@ impl<S> ApplicationBuilder<S> where S: 'static {
     /// store userid and friend in the exposed Params object:
     ///
     /// ```rust
-    /// extern crate actix;
-    /// extern crate actix_web;
-    ///
-    /// use actix::*;
+    /// # extern crate actix_web;
     /// use actix_web::*;
     ///
-    /// struct MyRoute;
-    ///
-    /// impl Actor for MyRoute {
-    ///     type Context = HttpContext<Self>;
-    /// }
-    ///
-    /// impl Route for MyRoute {
-    ///     type State = ();
-    ///
-    ///     fn request(req: &mut HttpRequest,
-    ///                payload: Payload,
-    ///                ctx: &mut HttpContext<Self>) -> RouteResult<Self> {
-    ///         Reply::reply(httpcodes::HTTPOk)
-    ///     }
-    /// }
     /// fn main() {
-    ///     let app = Application::default("/")
+    ///     let app = Application::new()
     ///         .resource("/test", |r| {
-    ///              r.get::<MyRoute>();
-    ///              r.handler(Method::HEAD, |req, payload, state| {
-    ///                  Ok(httpcodes::HTTPMethodNotAllowed)
-    ///              });
-    ///         })
-    ///         .finish();
+    ///              r.method(Method::GET).f(|_| httpcodes::HTTPOk);
+    ///              r.method(Method::HEAD).f(|_| httpcodes::HTTPMethodNotAllowed);
+    ///         });
     /// }
     /// ```
-    pub fn resource<F, P: ToString>(&mut self, path: P, f: F) -> &mut Self
+    pub fn resource<F>(mut self, path: &str, f: F) -> Application<S>
         where F: FnOnce(&mut Resource<S>) + 'static
     {
         {
             let parts = self.parts.as_mut().expect("Use after finish");
 
             // add resource
-            let path = path.to_string();
-            if !parts.resources.contains_key(&path) {
-                check_pattern(&path);
-                parts.resources.insert(path.clone(), Resource::default());
+            let mut resource = Resource::default();
+            f(&mut resource);
+
+            let pattern = Pattern::new(resource.get_name(), path, "^/");
+            if parts.resources.contains_key(&pattern) {
+                panic!("Resource {:?} is registered.", path);
             }
-            f(parts.resources.get_mut(&path).unwrap());
+
+            parts.resources.insert(pattern, Some(resource));
         }
         self
     }
 
-    /// Default resource is used if no matches route could be found.
-    pub fn default_resource<F>(&mut self, f: F) -> &mut Self
+    /// Default resource is used if no matched route could be found.
+    pub fn default_resource<F>(mut self, f: F) -> Application<S>
         where F: FnOnce(&mut Resource<S>) + 'static
     {
         {
@@ -214,100 +253,174 @@ impl<S> ApplicationBuilder<S> where S: 'static {
         self
     }
 
-    /// This method register handler for specified path prefix.
-    /// Any path that starts with this prefix matches handler.
+    /// Register external resource.
+    ///
+    /// External resources are useful for URL generation purposes only and
+    /// are never considered for matching at request time.
+    /// Call to `HttpRequest::url_for()` will work as expected.
     ///
     /// ```rust
-    /// extern crate actix_web;
+    /// # 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::default("/")
-    ///         .handler("/test", |req, payload, state| {
-    ///              match *req.method() {
-    ///                  Method::GET => httpcodes::HTTPOk,
-    ///                  Method::POST => httpcodes::HTTPMethodNotAllowed,
-    ///                  _ => httpcodes::HTTPNotFound,
-    ///              }
-    ///         })
+    ///     let app = Application::new()
+    ///         .resource("/index.html", |r| r.f(index))
+    ///         .external_resource("youtube", "https://youtube.com/watch/{video_id}")
     ///         .finish();
     /// }
     /// ```
-    pub fn handler<P, F, R>(&mut self, path: P, handler: F) -> &mut Self
-        where F: Fn(&mut HttpRequest, Payload, &S) -> R + 'static,
-              R: Into<HttpResponse> + 'static,
-              P: ToString,
-    {
-        self.parts.as_mut().expect("Use after finish")
-            .handlers.insert(path.to_string(), Box::new(FnHandler::new(handler)));
-        self
-    }
-
-    /// Add path handler
-    pub fn route_handler<H, P>(&mut self, path: P, h: H) -> &mut Self
-        where H: RouteHandler<S> + 'static, P: ToString
+    pub fn external_resource<T, U>(mut self, name: T, url: U) -> Application<S>
+        where T: AsRef<str>, U: AsRef<str>
     {
         {
-            // add resource
             let parts = self.parts.as_mut().expect("Use after finish");
-            let path = path.to_string();
-            if parts.handlers.contains_key(&path) {
-                panic!("Handler already registered: {:?}", path);
+
+            if parts.external.contains_key(name.as_ref()) {
+                panic!("External resource {:?} is registered.", name.as_ref());
             }
-            parts.handlers.insert(path, Box::new(h));
+            parts.external.insert(
+                String::from(name.as_ref()), Pattern::new(name.as_ref(), url.as_ref(), "^/"));
         }
         self
     }
 
-    /// Construct application
-    pub fn middleware<T>(&mut self, mw: T) -> &mut Self
-        where T: Middleware + 'static
+    /// Configure handler for specific path prefix.
+    ///
+    /// Path prefix consists valid path segments. i.e for prefix `/app`
+    /// any request with following paths `/app`, `/app/` or `/app/test`
+    /// would match, but path `/application` would not match.
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::*;
+    ///
+    /// fn main() {
+    ///     let app = Application::new()
+    ///         .handler("/app", |req: HttpRequest| {
+    ///             match *req.method() {
+    ///                 Method::GET => httpcodes::HTTPOk,
+    ///                 Method::POST => httpcodes::HTTPMethodNotAllowed,
+    ///                 _ => httpcodes::HTTPNotFound,
+    ///         }});
+    /// }
+    /// ```
+    pub fn handler<H: Handler<S>>(mut self, path: &str, handler: H) -> Application<S>
     {
+        {
+            let path = path.trim().trim_right_matches('/').to_owned();
+            let parts = self.parts.as_mut().expect("Use after finish");
+            parts.handlers.push((path, Box::new(WrapHandler::new(handler))));
+        }
+        self
+    }
+
+    /// Register a middleware
+    pub fn middleware<M: Middleware<S>>(mut self, mw: M) -> Application<S> {
         self.parts.as_mut().expect("Use after finish")
             .middlewares.push(Box::new(mw));
         self
     }
 
-    /// Construct application
-    pub fn finish(&mut self) -> Application<S> {
+    /// Finish application configuration and create HttpHandler object
+    pub fn finish(&mut self) -> HttpApplication<S> {
         let parts = self.parts.take().expect("Use after finish");
+        let prefix = parts.prefix.trim().trim_right_matches('/');
 
-        let mut handlers = HashMap::new();
-        let prefix = if parts.prefix.ends_with('/') {
-            parts.prefix
-        } else {
-            parts.prefix + "/"
-        };
-
-        let mut routes = Vec::new();
-        for (path, handler) in parts.resources {
-            routes.push((path, handler))
+        let mut resources = parts.resources;
+        for (_, pattern) in parts.external {
+            resources.insert(pattern, None);
         }
 
-        for (path, mut handler) in parts.handlers {
-            let path = prefix.clone() + path.trim_left_matches('/');
-            handler.set_prefix(path.clone());
-            handlers.insert(path, handler);
-        }
-        Application {
+        let (router, resources) = Router::new(prefix, parts.settings, resources);
+
+        let inner = Rc::new(RefCell::new(
+            Inner {
+                prefix: prefix.len(),
+                default: parts.default,
+                router: router.clone(),
+                resources: resources,
+                handlers: parts.handlers,
+            }
+        ));
+
+        HttpApplication {
             state: Rc::new(parts.state),
-            prefix: prefix.clone(),
-            default: parts.default,
-            handlers: handlers,
-            router: RouteRecognizer::new(prefix, routes),
+            prefix: prefix.to_owned(),
+            inner: inner,
+            router: router.clone(),
             middlewares: Rc::new(parts.middlewares),
         }
     }
-}
 
-impl<S: 'static> From<ApplicationBuilder<S>> for Application<S> {
-    fn from(mut builder: ApplicationBuilder<S>) -> Application<S> {
-        builder.finish()
+    /// Convenience method for creating `Box<HttpHandler>` instance.
+    ///
+    /// This method is useful if you need to register several application instances
+    /// with different state.
+    ///
+    /// ```rust
+    /// # use std::thread;
+    /// # extern crate actix_web;
+    /// use actix_web::*;
+    ///
+    /// struct State1;
+    ///
+    /// struct State2;
+    ///
+    /// fn main() {
+    /// # thread::spawn(|| {
+    ///     HttpServer::new(|| { vec![
+    ///         Application::with_state(State1)
+    ///              .prefix("/app1")
+    ///              .resource("/", |r| r.h(httpcodes::HTTPOk))
+    ///              .boxed(),
+    ///         Application::with_state(State2)
+    ///              .prefix("/app2")
+    ///              .resource("/", |r| r.h(httpcodes::HTTPOk))
+    ///              .boxed() ]})
+    ///         .bind("127.0.0.1:8080").unwrap()
+    ///         .run()
+    /// # });
+    /// }
+    /// ```
+    pub fn boxed(mut self) -> Box<HttpHandler> {
+        Box::new(self.finish())
     }
 }
 
-impl<S: 'static> Iterator for ApplicationBuilder<S> {
-    type Item = Application<S>;
+impl<S: 'static> IntoHttpHandler for Application<S> {
+    type Handler = HttpApplication<S>;
+
+    fn into_handler(mut self, settings: ServerSettings) -> HttpApplication<S> {
+        {
+            let parts = self.parts.as_mut().expect("Use after finish");
+            parts.settings = settings;
+        }
+        self.finish()
+    }
+}
+
+impl<'a, S: 'static> IntoHttpHandler for &'a mut Application<S> {
+    type Handler = HttpApplication<S>;
+
+    fn into_handler(self, settings: ServerSettings) -> HttpApplication<S> {
+        {
+            let parts = self.parts.as_mut().expect("Use after finish");
+            parts.settings = settings;
+        }
+        self.finish()
+    }
+}
+
+#[doc(hidden)]
+impl<S: 'static> Iterator for Application<S> {
+    type Item = HttpApplication<S>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.parts.is_some() {
@@ -317,3 +430,138 @@ impl<S: 'static> Iterator for ApplicationBuilder<S> {
         }
     }
 }
+
+
+#[cfg(test)]
+mod tests {
+    use http::StatusCode;
+    use super::*;
+    use test::TestRequest;
+    use httprequest::HttpRequest;
+    use httpcodes;
+
+    #[test]
+    fn test_default_resource() {
+        let mut app = Application::new()
+            .resource("/test", |r| r.h(httpcodes::HTTPOk))
+            .finish();
+
+        let req = TestRequest::with_uri("/test").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/blah").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+
+        let mut app = Application::new()
+            .default_resource(|r| r.h(httpcodes::HTTPMethodNotAllowed))
+            .finish();
+        let req = TestRequest::with_uri("/blah").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::METHOD_NOT_ALLOWED);
+    }
+
+    #[test]
+    fn test_unhandled_prefix() {
+        let mut app = Application::new()
+            .prefix("/test")
+            .resource("/test", |r| r.h(httpcodes::HTTPOk))
+            .finish();
+        assert!(app.handle(HttpRequest::default()).is_err());
+    }
+
+    #[test]
+    fn test_state() {
+        let mut app = Application::with_state(10)
+            .resource("/", |r| r.h(httpcodes::HTTPOk))
+            .finish();
+        let req = HttpRequest::default().with_state(Rc::clone(&app.state), app.router.clone());
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+    }
+
+    #[test]
+    fn test_prefix() {
+        let mut app = Application::new()
+            .prefix("/test")
+            .resource("/blah", |r| r.h(httpcodes::HTTPOk))
+            .finish();
+        let req = TestRequest::with_uri("/test").finish();
+        let resp = app.handle(req);
+        assert!(resp.is_ok());
+
+        let req = TestRequest::with_uri("/test/").finish();
+        let resp = app.handle(req);
+        assert!(resp.is_ok());
+
+        let req = TestRequest::with_uri("/test/blah").finish();
+        let resp = app.handle(req);
+        assert!(resp.is_ok());
+
+        let req = TestRequest::with_uri("/testing").finish();
+        let resp = app.handle(req);
+        assert!(resp.is_err());
+    }
+
+    #[test]
+    fn test_handler() {
+        let mut app = Application::new()
+            .handler("/test", httpcodes::HTTPOk)
+            .finish();
+
+        let req = TestRequest::with_uri("/test").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/test/").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/test/app").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/testapp").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+
+        let req = TestRequest::with_uri("/blah").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+    }
+
+    #[test]
+    fn test_handler_prefix() {
+        let mut app = Application::new()
+            .prefix("/app")
+            .handler("/test", httpcodes::HTTPOk)
+            .finish();
+
+        let req = TestRequest::with_uri("/test").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+
+        let req = TestRequest::with_uri("/app/test").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/app/test/").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/app/test/app").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/app/testapp").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+
+        let req = TestRequest::with_uri("/app/blah").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+
+    }
+
+}

src/body.rs

@@ -1,195 +1,230 @@
+use std::{fmt, mem};
 use std::rc::Rc;
 use std::sync::Arc;
 use bytes::{Bytes, BytesMut};
+use futures::Stream;
 
-use route::Frame;
+use error::Error;
+use context::ActorHttpContext;
 
+/// Type represent streaming body
+pub type BodyStream = Box<Stream<Item=Bytes, Error=Error>>;
 
 /// Represents various types of http message body.
-#[derive(Debug)]
 pub enum Body {
     /// Empty response. `Content-Length` header is set to `0`
     Empty,
     /// Specific response body.
-    Binary(BinaryBody),
-    /// Streaming response body with specified length.
-    Length(u64),
+    Binary(Binary),
     /// Unspecified streaming response. Developer is responsible for setting
     /// right `Content-Length` or `Transfer-Encoding` headers.
-    Streaming,
-    /// Upgrade connection.
-    Upgrade,
+    Streaming(BodyStream),
+    /// Special body type for actor response.
+    Actor(Box<ActorHttpContext>),
 }
 
 /// Represents various types of binary body.
 /// `Content-Length` header is set to length of the body.
-#[derive(Debug)]
-pub enum BinaryBody {
+#[derive(Debug, PartialEq)]
+pub enum Binary {
     /// Bytes body
     Bytes(Bytes),
     /// Static slice
     Slice(&'static [u8]),
-    /// Shared bytes body
-    SharedBytes(Rc<Bytes>),
-    /// Shared stirng body
+    /// Shared string body
     SharedString(Rc<String>),
-    /// Shared bytes body
-    #[doc(hidden)]
-    ArcSharedBytes(Arc<Bytes>),
     /// Shared string body
     #[doc(hidden)]
     ArcSharedString(Arc<String>),
 }
 
 impl Body {
-    /// Does this body have payload.
-    pub fn has_body(&self) -> bool {
+    /// Does this body streaming.
+    #[inline]
+    pub fn is_streaming(&self) -> bool {
         match *self {
-            Body::Length(_) | Body::Streaming => true,
+            Body::Streaming(_) | Body::Actor(_) => true,
+            _ => false
+        }
+    }
+
+    /// Is this binary body.
+    #[inline]
+    pub fn is_binary(&self) -> bool {
+        match *self {
+            Body::Binary(_) => true,
             _ => false
         }
     }
 
     /// Create body from slice (copy)
     pub fn from_slice(s: &[u8]) -> Body {
-        Body::Binary(BinaryBody::Bytes(Bytes::from(s)))
+        Body::Binary(Binary::Bytes(Bytes::from(s)))
     }
 }
 
-impl<T> From<T> for Body where T: Into<BinaryBody>{
+impl PartialEq for Body {
+    fn eq(&self, other: &Body) -> bool {
+        match *self {
+            Body::Empty => match *other {
+                Body::Empty => true,
+                _ => false,
+            },
+            Body::Binary(ref b) => match *other {
+                Body::Binary(ref b2) => b == b2,
+                _ => false,
+            },
+            Body::Streaming(_) | Body::Actor(_) => false,
+        }
+    }
+}
+
+impl fmt::Debug for Body {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Body::Empty => write!(f, "Body::Empty"),
+            Body::Binary(ref b) => write!(f, "Body::Binary({:?})", b),
+            Body::Streaming(_) => write!(f, "Body::Streaming(_)"),
+            Body::Actor(_) => write!(f, "Body::Actor(_)"),
+        }
+    }
+}
+
+impl<T> From<T> for Body where T: Into<Binary>{
     fn from(b: T) -> Body {
         Body::Binary(b.into())
     }
 }
 
-impl BinaryBody {
+impl From<Box<ActorHttpContext>> for Body {
+    fn from(ctx: Box<ActorHttpContext>) -> Body {
+        Body::Actor(ctx)
+    }
+}
+
+impl Binary {
+    #[inline]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
+    #[inline]
     pub fn len(&self) -> usize {
         match *self {
-            BinaryBody::Bytes(ref bytes) => bytes.len(),
-            BinaryBody::Slice(slice) => slice.len(),
-            BinaryBody::SharedBytes(ref bytes) => bytes.len(),
-            BinaryBody::ArcSharedBytes(ref bytes) => bytes.len(),
-            BinaryBody::SharedString(ref s) => s.len(),
-            BinaryBody::ArcSharedString(ref s) => s.len(),
+            Binary::Bytes(ref bytes) => bytes.len(),
+            Binary::Slice(slice) => slice.len(),
+            Binary::SharedString(ref s) => s.len(),
+            Binary::ArcSharedString(ref s) => s.len(),
         }
     }
 
     /// Create binary body from slice
-    pub fn from_slice(s: &[u8]) -> BinaryBody {
-        BinaryBody::Bytes(Bytes::from(s))
+    pub fn from_slice(s: &[u8]) -> Binary {
+        Binary::Bytes(Bytes::from(s))
+    }
+
+    /// Convert Binary to a Bytes instance
+    pub fn take(&mut self) -> Bytes {
+        mem::replace(self, Binary::Slice(b"")).into()
     }
 }
 
-impl From<&'static str> for BinaryBody {
-    fn from(s: &'static str) -> BinaryBody {
-        BinaryBody::Slice(s.as_ref())
-    }
-}
-
-impl From<&'static [u8]> for BinaryBody {
-    fn from(s: &'static [u8]) -> BinaryBody {
-        BinaryBody::Slice(s)
-    }
-}
-
-impl From<Vec<u8>> for BinaryBody {
-    fn from(vec: Vec<u8>) -> BinaryBody {
-        BinaryBody::Bytes(Bytes::from(vec))
-    }
-}
-
-impl From<String> for BinaryBody {
-    fn from(s: String) -> BinaryBody {
-        BinaryBody::Bytes(Bytes::from(s))
-    }
-}
-
-impl<'a> From<&'a String> for BinaryBody {
-    fn from(s: &'a String) -> BinaryBody {
-        BinaryBody::Bytes(Bytes::from(AsRef::<[u8]>::as_ref(&s)))
-    }
-}
-
-impl From<Bytes> for BinaryBody {
-    fn from(s: Bytes) -> BinaryBody {
-        BinaryBody::Bytes(s)
-    }
-}
-
-impl From<BytesMut> for BinaryBody {
-    fn from(s: BytesMut) -> BinaryBody {
-        BinaryBody::Bytes(s.freeze())
-    }
-}
-
-impl From<Rc<Bytes>> for BinaryBody {
-    fn from(body: Rc<Bytes>) -> BinaryBody {
-        BinaryBody::SharedBytes(body)
-    }
-}
-
-impl<'a> From<&'a Rc<Bytes>> for BinaryBody {
-    fn from(body: &'a Rc<Bytes>) -> BinaryBody {
-        BinaryBody::SharedBytes(Rc::clone(body))
-    }
-}
-
-impl From<Arc<Bytes>> for BinaryBody {
-    fn from(body: Arc<Bytes>) -> BinaryBody {
-        BinaryBody::ArcSharedBytes(body)
-    }
-}
-
-impl<'a> From<&'a Arc<Bytes>> for BinaryBody {
-    fn from(body: &'a Arc<Bytes>) -> BinaryBody {
-        BinaryBody::ArcSharedBytes(Arc::clone(body))
-    }
-}
-
-impl From<Rc<String>> for BinaryBody {
-    fn from(body: Rc<String>) -> BinaryBody {
-        BinaryBody::SharedString(body)
-    }
-}
-
-impl<'a> From<&'a Rc<String>> for BinaryBody {
-    fn from(body: &'a Rc<String>) -> BinaryBody {
-        BinaryBody::SharedString(Rc::clone(body))
-    }
-}
-
-impl From<Arc<String>> for BinaryBody {
-    fn from(body: Arc<String>) -> BinaryBody {
-        BinaryBody::ArcSharedString(body)
-    }
-}
-
-impl<'a> From<&'a Arc<String>> for BinaryBody {
-    fn from(body: &'a Arc<String>) -> BinaryBody {
-        BinaryBody::ArcSharedString(Arc::clone(body))
-    }
-}
-
-impl AsRef<[u8]> for BinaryBody {
-    fn as_ref(&self) -> &[u8] {
+impl Clone for Binary {
+    fn clone(&self) -> Binary {
         match *self {
-            BinaryBody::Bytes(ref bytes) => bytes.as_ref(),
-            BinaryBody::Slice(slice) => slice,
-            BinaryBody::SharedBytes(ref bytes) => bytes.as_ref(),
-            BinaryBody::ArcSharedBytes(ref bytes) => bytes.as_ref(),
-            BinaryBody::SharedString(ref s) => s.as_bytes(),
-            BinaryBody::ArcSharedString(ref s) => s.as_bytes(),
+            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())),
         }
     }
 }
 
-impl From<BinaryBody> for Frame {
-    fn from(b: BinaryBody) -> Frame {
-        Frame::Payload(Some(b))
+impl Into<Bytes> for Binary {
+    fn into(self) -> Bytes {
+        match self {
+            Binary::Bytes(bytes) => bytes,
+            Binary::Slice(slice) => Bytes::from(slice),
+            Binary::SharedString(s) => Bytes::from(s.as_str()),
+            Binary::ArcSharedString(s) => Bytes::from(s.as_str()),
+        }
+    }
+}
+
+impl From<&'static str> for Binary {
+    fn from(s: &'static str) -> Binary {
+        Binary::Slice(s.as_ref())
+    }
+}
+
+impl From<&'static [u8]> for Binary {
+    fn from(s: &'static [u8]) -> Binary {
+        Binary::Slice(s)
+    }
+}
+
+impl From<Vec<u8>> for Binary {
+    fn from(vec: Vec<u8>) -> Binary {
+        Binary::Bytes(Bytes::from(vec))
+    }
+}
+
+impl From<String> for Binary {
+    fn from(s: String) -> Binary {
+        Binary::Bytes(Bytes::from(s))
+    }
+}
+
+impl<'a> From<&'a String> for Binary {
+    fn from(s: &'a String) -> Binary {
+        Binary::Bytes(Bytes::from(AsRef::<[u8]>::as_ref(&s)))
+    }
+}
+
+impl From<Bytes> for Binary {
+    fn from(s: Bytes) -> Binary {
+        Binary::Bytes(s)
+    }
+}
+
+impl From<BytesMut> for Binary {
+    fn from(s: BytesMut) -> Binary {
+        Binary::Bytes(s.freeze())
+    }
+}
+
+impl From<Rc<String>> for Binary {
+    fn from(body: Rc<String>) -> Binary {
+        Binary::SharedString(body)
+    }
+}
+
+impl<'a> From<&'a Rc<String>> for Binary {
+    fn from(body: &'a Rc<String>) -> Binary {
+        Binary::SharedString(Rc::clone(body))
+    }
+}
+
+impl From<Arc<String>> for Binary {
+    fn from(body: Arc<String>) -> Binary {
+        Binary::ArcSharedString(body)
+    }
+}
+
+impl<'a> From<&'a Arc<String>> for Binary {
+    fn from(body: &'a Arc<String>) -> Binary {
+        Binary::ArcSharedString(Arc::clone(body))
+    }
+}
+
+impl AsRef<[u8]> for Binary {
+    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(),
+        }
     }
 }
 
@@ -197,72 +232,91 @@ impl From<BinaryBody> for Frame {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_body_is_streaming() {
+        assert_eq!(Body::Empty.is_streaming(), false);
+        assert_eq!(Body::Binary(Binary::from("")).is_streaming(), false);
+    }
+
+    #[test]
+    fn test_is_empty() {
+        assert_eq!(Binary::from("").is_empty(), true);
+        assert_eq!(Binary::from("test").is_empty(), false);
+    }
+
     #[test]
     fn test_static_str() {
-        assert_eq!(BinaryBody::from("test").len(), 4);
-        assert_eq!(BinaryBody::from("test").as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from("test").len(), 4);
+        assert_eq!(Binary::from("test").as_ref(), "test".as_bytes());
     }
 
     #[test]
     fn test_static_bytes() {
-        assert_eq!(BinaryBody::from(b"test".as_ref()).len(), 4);
-        assert_eq!(BinaryBody::from(b"test".as_ref()).as_ref(), "test".as_bytes());
-        assert_eq!(BinaryBody::from_slice(b"test".as_ref()).len(), 4);
-        assert_eq!(BinaryBody::from_slice(b"test".as_ref()).as_ref(), "test".as_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_slice(b"test".as_ref()).len(), 4);
+        assert_eq!(Binary::from_slice(b"test".as_ref()).as_ref(), "test".as_bytes());
     }
 
     #[test]
     fn test_vec() {
-        assert_eq!(BinaryBody::from(Vec::from("test")).len(), 4);
-        assert_eq!(BinaryBody::from(Vec::from("test")).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(Vec::from("test")).len(), 4);
+        assert_eq!(Binary::from(Vec::from("test")).as_ref(), "test".as_bytes());
     }
 
     #[test]
     fn test_bytes() {
-        assert_eq!(BinaryBody::from(Bytes::from("test")).len(), 4);
-        assert_eq!(BinaryBody::from(Bytes::from("test")).as_ref(), "test".as_bytes());
-    }
-
-    #[test]
-    fn test_rc_bytes() {
-        let b = Rc::new(Bytes::from("test"));
-        assert_eq!(BinaryBody::from(b.clone()).len(), 4);
-        assert_eq!(BinaryBody::from(b.clone()).as_ref(), "test".as_bytes());
-        assert_eq!(BinaryBody::from(&b).len(), 4);
-        assert_eq!(BinaryBody::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(Bytes::from("test")).len(), 4);
+        assert_eq!(Binary::from(Bytes::from("test")).as_ref(), "test".as_bytes());
     }
 
     #[test]
     fn test_ref_string() {
         let b = Rc::new("test".to_owned());
-        assert_eq!(BinaryBody::from(&b).len(), 4);
-        assert_eq!(BinaryBody::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).len(), 4);
+        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
     }
 
     #[test]
     fn test_rc_string() {
         let b = Rc::new("test".to_owned());
-        assert_eq!(BinaryBody::from(b.clone()).len(), 4);
-        assert_eq!(BinaryBody::from(b.clone()).as_ref(), "test".as_bytes());
-        assert_eq!(BinaryBody::from(&b).len(), 4);
-        assert_eq!(BinaryBody::from(&b).as_ref(), "test".as_bytes());
-    }
-
-    #[test]
-    fn test_arc_bytes() {
-        let b = Arc::new(Bytes::from("test"));
-        assert_eq!(BinaryBody::from(b.clone()).len(), 4);
-        assert_eq!(BinaryBody::from(b.clone()).as_ref(), "test".as_bytes());
-        assert_eq!(BinaryBody::from(&b).len(), 4);
-        assert_eq!(BinaryBody::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b.clone()).len(), 4);
+        assert_eq!(Binary::from(b.clone()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).len(), 4);
+        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
     }
 
     #[test]
     fn test_arc_string() {
         let b = Arc::new("test".to_owned());
-        assert_eq!(BinaryBody::from(b.clone()).len(), 4);
-        assert_eq!(BinaryBody::from(b.clone()).as_ref(), "test".as_bytes());
-        assert_eq!(BinaryBody::from(&b).len(), 4);
-        assert_eq!(BinaryBody::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b.clone()).len(), 4);
+        assert_eq!(Binary::from(b.clone()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).len(), 4);
+        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+    }
+
+    #[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).len(), 4);
+        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+    }
+
+    #[test]
+    fn test_bytes_mut() {
+        let b =  BytesMut::from("test");
+        assert_eq!(Binary::from(b.clone()).len(), 4);
+        assert_eq!(Binary::from(b).as_ref(), "test".as_bytes());
+    }
+
+    #[test]
+    fn test_binary_into() {
+        let bytes = Bytes::from_static(b"test");
+        let b: Bytes = Binary::from("test").into();
+        assert_eq!(b, bytes);
+        let b: Bytes = Binary::from(bytes.clone()).into();
+        assert_eq!(b, bytes);
     }
 }

src/context.rs

@@ -1,309 +1,258 @@
 use std;
-use std::rc::Rc;
-use std::cell::RefCell;
-use std::collections::VecDeque;
 use std::marker::PhantomData;
-use futures::{Async, Future, Stream, Poll};
+use futures::{Async, Future, Poll};
 use futures::sync::oneshot::Sender;
+use futures::unsync::oneshot;
+use smallvec::SmallVec;
 
 use actix::{Actor, ActorState, ActorContext, AsyncContext,
-            Handler, Subscriber, ResponseType};
+            Address, SyncAddress, Handler, Subscriber, ResponseType, SpawnHandle};
 use actix::fut::ActorFuture;
-use actix::dev::{AsyncContextApi, ActorAddressCell, ActorItemsCell, ActorWaitCell, SpawnHandle,
-                 Envelope, ToEnvelope, RemoteEnvelope};
+use actix::dev::{queue, AsyncContextApi,
+                 ContextImpl, ContextProtocol, Envelope, ToEnvelope, RemoteEnvelope};
 
-use task::{IoContext, DrainFut};
-use body::BinaryBody;
-use route::{Route, Frame};
-use httpresponse::HttpResponse;
+use body::{Body, Binary};
+use error::{Error, Result, ErrorInternalServerError};
+use httprequest::HttpRequest;
 
 
-/// Actor execution context
-pub struct HttpContext<A> where A: Actor<Context=HttpContext<A>> + Route,
+pub trait ActorHttpContext: 'static {
+    fn disconnected(&mut self);
+    fn poll(&mut self) -> Poll<Option<SmallVec<[Frame; 2]>>, Error>;
+}
+
+#[derive(Debug)]
+pub enum Frame {
+    Chunk(Option<Binary>),
+    Drain(oneshot::Sender<()>),
+}
+
+/// Http actor execution context
+pub struct HttpContext<A, S=()> where A: Actor<Context=HttpContext<A, S>>,
 {
-    act: Option<A>,
-    state: ActorState,
-    modified: bool,
-    items: ActorItemsCell<A>,
-    address: ActorAddressCell<A>,
-    stream: VecDeque<Frame>,
-    wait: ActorWaitCell<A>,
-    app_state: Rc<<A as Route>::State>,
+    inner: ContextImpl<A>,
+    stream: Option<SmallVec<[Frame; 2]>>,
+    request: HttpRequest<S>,
     disconnected: bool,
 }
 
-impl<A> IoContext for HttpContext<A> where A: Actor<Context=Self> + Route {
-
-    fn disconnected(&mut self) {
-        self.items.stop();
-        self.disconnected = true;
-        if self.state == ActorState::Running {
-            self.state = ActorState::Stopping;
-        }
-    }
-}
-
-impl<A> ActorContext for HttpContext<A> where A: Actor<Context=Self> + Route
+impl<A, S> ActorContext for HttpContext<A, S> where A: Actor<Context=Self>
 {
-    /// Stop actor execution
     fn stop(&mut self) {
-        self.items.stop();
-        self.address.close();
-        if self.state == ActorState::Running {
-            self.state = ActorState::Stopping;
-        }
+        self.inner.stop();
     }
-
-    /// Terminate actor execution
     fn terminate(&mut self) {
-        self.address.close();
-        self.items.close();
-        self.state = ActorState::Stopped;
+        self.inner.terminate()
     }
-
-    /// Actor execution state
     fn state(&self) -> ActorState {
-        self.state
+        self.inner.state()
     }
 }
 
-impl<A> AsyncContext<A> for HttpContext<A> where A: Actor<Context=Self> + Route
+impl<A, S> AsyncContext<A> for HttpContext<A, S> where A: Actor<Context=Self>
 {
     fn spawn<F>(&mut self, fut: F) -> SpawnHandle
         where F: ActorFuture<Item=(), Error=(), Actor=A> + 'static
     {
-        self.modified = true;
-        self.items.spawn(fut)
+        self.inner.spawn(fut)
     }
-
     fn wait<F>(&mut self, fut: F)
         where F: ActorFuture<Item=(), Error=(), Actor=A> + 'static
     {
-        self.modified = true;
-        self.wait.add(fut);
+        self.inner.wait(fut)
     }
-
     fn cancel_future(&mut self, handle: SpawnHandle) -> bool {
-        self.modified = true;
-        self.items.cancel_future(handle)
-    }
-
-    fn cancel_future_on_stop(&mut self, handle: SpawnHandle) {
-        self.items.cancel_future_on_stop(handle)
+        self.inner.cancel_future(handle)
     }
 }
 
 #[doc(hidden)]
-impl<A> AsyncContextApi<A> for HttpContext<A> where A: Actor<Context=Self> + Route {
-    fn address_cell(&mut self) -> &mut ActorAddressCell<A> {
-        &mut self.address
+impl<A, S> AsyncContextApi<A> for HttpContext<A, S> where A: Actor<Context=Self> {
+    #[inline]
+    fn unsync_sender(&mut self) -> queue::unsync::UnboundedSender<ContextProtocol<A>> {
+        self.inner.unsync_sender()
+    }
+    #[inline]
+    fn unsync_address(&mut self) -> Address<A> {
+        self.inner.unsync_address()
+    }
+    #[inline]
+    fn sync_address(&mut self) -> SyncAddress<A> {
+        self.inner.sync_address()
     }
 }
 
-impl<A> HttpContext<A> where A: Actor<Context=Self> + Route {
+impl<A, S: 'static> HttpContext<A, S> where A: Actor<Context=Self> {
 
-    pub fn new(state: Rc<<A as Route>::State>) -> HttpContext<A>
-    {
+    #[inline]
+    pub fn new(req: HttpRequest<S>, actor: A) -> HttpContext<A, S> {
+        HttpContext::from_request(req).actor(actor)
+    }
+    pub fn from_request(req: HttpRequest<S>) -> HttpContext<A, S> {
         HttpContext {
-            act: None,
-            state: ActorState::Started,
-            modified: false,
-            items: ActorItemsCell::default(),
-            address: ActorAddressCell::default(),
-            wait: ActorWaitCell::default(),
-            stream: VecDeque::new(),
-            app_state: state,
+            inner: ContextImpl::new(None),
+            stream: None,
+            request: req,
             disconnected: false,
         }
     }
-
-    pub(crate) fn set_actor(&mut self, act: A) {
-        self.act = Some(act)
+    #[inline]
+    pub fn actor(mut self, actor: A) -> HttpContext<A, S> {
+        self.inner.set_actor(actor);
+        self
     }
 }
 
-impl<A> HttpContext<A> where A: Actor<Context=Self> + Route {
+impl<A, S> HttpContext<A, S> where A: Actor<Context=Self> {
 
     /// Shared application state
-    pub fn state(&self) -> &<A as Route>::State {
-        &self.app_state
+    #[inline]
+    pub fn state(&self) -> &S {
+        self.request.state()
     }
-    
-    /// Start response processing
-    pub fn start<R: Into<HttpResponse>>(&mut self, response: R) {
-        self.stream.push_back(Frame::Message(response.into()))
+
+    /// Incoming request
+    #[inline]
+    pub fn request(&mut self) -> &mut HttpRequest<S> {
+        &mut self.request
     }
 
     /// Write payload
-    pub fn write<B: Into<BinaryBody>>(&mut self, data: B) {
-        self.stream.push_back(Frame::Payload(Some(data.into())))
+    #[inline]
+    pub fn write<B: Into<Binary>>(&mut self, data: B) {
+        if !self.disconnected {
+            self.add_frame(Frame::Chunk(Some(data.into())));
+        } else {
+            warn!("Trying to write to disconnected response");
+        }
     }
 
-    /// Indicate end of streamimng payload. Also this method calls `Self::close`.
+    /// Indicate end of streaming payload. Also this method calls `Self::close`.
+    #[inline]
     pub fn write_eof(&mut self) {
-        self.stream.push_back(Frame::Payload(None));
-        self.stop();
+        self.add_frame(Frame::Chunk(None));
     }
 
     /// Returns drain future
     pub fn drain(&mut self) -> Drain<A> {
-        let fut = Rc::new(RefCell::new(DrainFut::default()));
-        self.stream.push_back(Frame::Drain(Rc::clone(&fut)));
-        self.modified = true;
-        Drain{ a: PhantomData, inner: fut }
+        let (tx, rx) = oneshot::channel();
+        self.inner.modify();
+        self.add_frame(Frame::Drain(tx));
+        Drain::new(rx)
     }
 
     /// Check if connection still open
+    #[inline]
     pub fn connected(&self) -> bool {
         !self.disconnected
     }
+
+    #[inline]
+    fn add_frame(&mut self, frame: Frame) {
+        if self.stream.is_none() {
+            self.stream = Some(SmallVec::new());
+        }
+        self.stream.as_mut().map(|s| s.push(frame));
+    }
 }
 
-impl<A> HttpContext<A> where A: Actor<Context=Self> + Route {
+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,
+        where A: Handler<M>, M: ResponseType + 'static
     {
-        Box::new(self.address.unsync_address())
+        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,
+              M: ResponseType + Send + 'static, M::Item: Send, M::Error: Send,
     {
-        Box::new(self.address.sync_address())
+        self.inner.sync_subscriber()
     }
 }
 
-#[doc(hidden)]
-impl<A> Stream for HttpContext<A> where A: Actor<Context=Self> + Route
-{
-    type Item = Frame;
-    type Error = std::io::Error;
+impl<A, S> ActorHttpContext for HttpContext<A, S> where A: Actor<Context=Self>, S: 'static {
 
-    fn poll(&mut self) -> Poll<Option<Frame>, std::io::Error> {
-        if self.act.is_none() {
-            return Ok(Async::NotReady)
-        }
-        let act: &mut A = unsafe {
-            std::mem::transmute(self.act.as_mut().unwrap() as &mut A)
-        };
-        let ctx: &mut HttpContext<A> = unsafe {
-            std::mem::transmute(self as &mut HttpContext<A>)
+    #[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>)
         };
 
-        // update state
-        match self.state {
-            ActorState::Started => {
-                Actor::started(act, ctx);
-                self.state = ActorState::Running;
-            },
-            ActorState::Stopping => {
-                Actor::stopping(act, ctx);
+        if self.inner.alive() {
+            match self.inner.poll(ctx) {
+                Ok(Async::NotReady) | Ok(Async::Ready(())) => (),
+                Err(_) => return Err(ErrorInternalServerError("error").into()),
             }
-            _ => ()
         }
 
-        let mut prep_stop = false;
-        loop {
-            self.modified = false;
-
-            // check wait futures
-            if self.wait.poll(act, ctx) {
-                // get frame
-                if let Some(frame) = self.stream.pop_front() {
-                    return Ok(Async::Ready(Some(frame)))
-                }
-                return Ok(Async::NotReady)
-            }
-
-            // incoming messages
-            self.address.poll(act, ctx);
-
-            // spawned futures and streams
-            self.items.poll(act, ctx);
-
-            // are we done
-            if self.modified {
-                continue
-            }
-
-            // get frame
-            if let Some(frame) = self.stream.pop_front() {
-                return Ok(Async::Ready(Some(frame)))
-            }
-
-            // check state
-            match self.state {
-                ActorState::Stopped => {
-                    self.state = ActorState::Stopped;
-                    Actor::stopped(act, ctx);
-                    return Ok(Async::Ready(None))
-                },
-                ActorState::Stopping => {
-                    if prep_stop {
-                        if self.address.connected() || !self.items.is_empty() {
-                            self.state = ActorState::Running;
-                            continue
-                        } else {
-                            self.state = ActorState::Stopped;
-                            Actor::stopped(act, ctx);
-                            return Ok(Async::Ready(None))
-                        }
-                    } else {
-                        Actor::stopping(act, ctx);
-                        prep_stop = true;
-                        continue
-                    }
-                },
-                ActorState::Running => {
-                    if !self.address.connected() && self.items.is_empty() {
-                        self.state = ActorState::Stopping;
-                        Actor::stopping(act, ctx);
-                        prep_stop = true;
-                        continue
-                    }
-                },
-                _ => (),
-            }
-
-            return Ok(Async::NotReady)
+        // frames
+        if let Some(data) = self.stream.take() {
+            Ok(Async::Ready(Some(data)))
+        } else if self.inner.alive() {
+            Ok(Async::NotReady)
+        } else {
+            Ok(Async::Ready(None))
         }
     }
 }
 
-impl<A> ToEnvelope<A> for HttpContext<A>
-    where A: Actor<Context=HttpContext<A>> + Route,
+impl<A, S> ToEnvelope<A> for HttpContext<A, S>
+    where A: Actor<Context=HttpContext<A, S>>,
 {
-    fn pack<M>(msg: M, tx: Option<Sender<Result<M::Item, M::Error>>>) -> Envelope<A>
+    #[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
+              M: ResponseType + Send + 'static, M::Item: Send, M::Error: Send
     {
-        RemoteEnvelope::new(msg, tx).into()
+        RemoteEnvelope::new(msg, tx, channel_on_drop).into()
     }
 }
 
+impl<A, S> From<HttpContext<A, S>> for Body
+    where A: Actor<Context=HttpContext<A, S>>,
+          S: 'static
+{
+    fn from(ctx: HttpContext<A, S>) -> Body {
+        Body::Actor(Box::new(ctx))
+    }
+}
 
 pub struct Drain<A> {
-    a: PhantomData<A>,
-    inner: Rc<RefCell<DrainFut>>
+    fut: oneshot::Receiver<()>,
+    _a: PhantomData<A>,
 }
 
-impl<A> ActorFuture for Drain<A>
-    where A: Actor
-{
+impl<A> Drain<A> {
+    pub fn new(fut: oneshot::Receiver<()>) -> Self {
+        Drain {
+            fut: fut,
+            _a: PhantomData
+        }
+    }
+}
+
+impl<A: Actor> ActorFuture for Drain<A> {
     type Item = ();
     type Error = ();
     type Actor = A;
 
-    fn poll(&mut self, _: &mut A, _: &mut <Self::Actor as Actor>::Context) -> Poll<(), ()> {
-        self.inner.borrow_mut().poll()
+    #[inline]
+    fn poll(&mut self,
+            _: &mut A,
+            _: &mut <Self::Actor as Actor>::Context) -> Poll<Self::Item, Self::Error>
+    {
+        self.fut.poll().map_err(|_| ())
     }
 }

src/date.rs

@@ -1,69 +0,0 @@
-use std::cell::RefCell;
-use std::fmt::{self, Write};
-use std::str;
-
-use time::{self, Duration};
-use bytes::BytesMut;
-
-// "Sun, 06 Nov 1994 08:49:37 GMT".len()
-pub const DATE_VALUE_LENGTH: usize = 29;
-
-pub fn extend(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],
-    pos: usize,
-    next_update: time::Timespec,
-}
-
-thread_local!(static CACHED: RefCell<CachedDate> = RefCell::new(CachedDate {
-    bytes: [0; DATE_VALUE_LENGTH],
-    pos: 0,
-    next_update: time::Timespec::new(0, 0),
-}));
-
-impl CachedDate {
-    fn buffer(&self) -> &[u8] {
-        &self.bytes[..]
-    }
-
-    fn update(&mut self, now: time::Timespec) {
-        self.pos = 0;
-        write!(self, "{}", time::at_utc(now).rfc822()).unwrap();
-        assert_eq!(self.pos, DATE_VALUE_LENGTH);
-        self.next_update = now + Duration::seconds(1);
-        self.next_update.nsec = 0;
-    }
-}
-
-impl fmt::Write for CachedDate {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        let len = s.len();
-        self.bytes[self.pos..self.pos + len].copy_from_slice(s.as_bytes());
-        self.pos += len;
-        Ok(())
-    }
-}
-
-#[test]
-fn test_date_len() {
-    assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
-}
-
-#[test]
-fn test_date() {
-    let mut buf1 = BytesMut::new();
-    extend(&mut buf1);
-    let mut buf2 = BytesMut::new();
-    extend(&mut buf2);
-    assert_eq!(buf1, buf2);
-}

src/decode.rs

@@ -1,271 +0,0 @@
-#![allow(dead_code)]
-
-use std::{io, usize};
-
-use futures::{Async, Poll};
-use bytes::{Bytes, BytesMut};
-
-use self::Kind::{Length, Chunked, Eof};
-
-/// Decoders to handle different Transfer-Encodings.
-///
-/// If a message body does not include a Transfer-Encoding, it *should*
-/// include a Content-Length header.
-#[derive(Debug, Clone, PartialEq)]
-pub struct Decoder {
-    kind: Kind,
-}
-
-impl Decoder {
-    pub fn length(x: u64) -> Decoder {
-        Decoder { kind: Kind::Length(x) }
-    }
-
-    pub fn chunked() -> Decoder {
-        Decoder { kind: Kind::Chunked(ChunkedState::Size, 0) }
-    }
-
-    pub fn eof() -> Decoder {
-        Decoder { kind: Kind::Eof(false) }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-enum Kind {
-    /// A Reader used when a Content-Length header is passed with a positive integer.
-    Length(u64),
-    /// A Reader used when Transfer-Encoding is `chunked`.
-    Chunked(ChunkedState, u64),
-    /// A Reader used for responses that don't indicate a length or chunked.
-    ///
-    /// Note: This should only used for `Response`s. It is illegal for a
-    /// `Request` to be made with both `Content-Length` and
-    /// `Transfer-Encoding: chunked` missing, as explained from the spec:
-    ///
-    /// > If a Transfer-Encoding header field is present in a response and
-    /// > the chunked transfer coding is not the final encoding, the
-    /// > message body length is determined by reading the connection until
-    /// > it is closed by the server.  If a Transfer-Encoding header field
-    /// > is present in a request and the chunked transfer coding is not
-    /// > the final encoding, the message body length cannot be determined
-    /// > reliably; the server MUST respond with the 400 (Bad Request)
-    /// > status code and then close the connection.
-    Eof(bool),
-}
-
-#[derive(Debug, PartialEq, Clone)]
-enum ChunkedState {
-    Size,
-    SizeLws,
-    Extension,
-    SizeLf,
-    Body,
-    BodyCr,
-    BodyLf,
-    EndCr,
-    EndLf,
-    End,
-}
-
-impl Decoder {
-    pub fn is_eof(&self) -> bool {
-        trace!("is_eof? {:?}", self);
-        match self.kind {
-            Length(0) |
-            Chunked(ChunkedState::End, _) |
-            Eof(true) => true,
-            _ => false,
-        }
-    }
-}
-
-impl Decoder {
-    pub fn decode(&mut self, body: &mut BytesMut) -> Poll<Option<Bytes>, io::Error> {
-        match self.kind {
-            Length(ref mut remaining) => {
-                trace!("Sized read, remaining={:?}", remaining);
-                if *remaining == 0 {
-                    Ok(Async::Ready(None))
-                } else {
-                    if body.is_empty() {
-                        return Ok(Async::NotReady)
-                    }
-                    let len = body.len() as u64;
-                    let buf;
-                    if *remaining > len {
-                        buf = body.take().freeze();
-                        *remaining -= len;
-                    } else {
-                        buf = body.split_to(*remaining as usize).freeze();
-                        *remaining = 0;
-                    }
-                    trace!("Length read: {}", buf.len());
-                    Ok(Async::Ready(Some(buf)))
-                }
-            }
-            Chunked(ref mut state, ref mut size) => {
-                loop {
-                    let mut buf = None;
-                    // advances the chunked state
-                    *state = try_ready!(state.step(body, size, &mut buf));
-                    if *state == ChunkedState::End {
-                        trace!("End of chunked stream");
-                        return Ok(Async::Ready(None));
-                    }
-                    if let Some(buf) = buf {
-                        return Ok(Async::Ready(Some(buf)));
-                    }
-                    if body.is_empty() {
-                        return Ok(Async::NotReady);
-                    }
-                }
-            }
-            Eof(ref mut is_eof) => {
-                if *is_eof {
-                    Ok(Async::Ready(None))
-                } else if !body.is_empty() {
-                    Ok(Async::Ready(Some(body.take().freeze())))
-                } else {
-                    Ok(Async::NotReady)
-                }
-            }
-        }
-    }
-}
-
-macro_rules! byte (
-    ($rdr:ident) => ({
-        if $rdr.len() > 0 {
-            let b = $rdr[0];
-            $rdr.split_to(1);
-            b
-        } else {
-            return Ok(Async::NotReady)
-        }
-    })
-);
-
-impl ChunkedState {
-    fn step(&self, body: &mut BytesMut, size: &mut u64, buf: &mut Option<Bytes>)
-            -> Poll<ChunkedState, io::Error>
-    {
-        use self::ChunkedState::*;
-        match *self {
-            Size => ChunkedState::read_size(body, size),
-            SizeLws => ChunkedState::read_size_lws(body),
-            Extension => ChunkedState::read_extension(body),
-            SizeLf => ChunkedState::read_size_lf(body, size),
-            Body => ChunkedState::read_body(body, size, buf),
-            BodyCr => ChunkedState::read_body_cr(body),
-            BodyLf => ChunkedState::read_body_lf(body),
-            EndCr => ChunkedState::read_end_cr(body),
-            EndLf => ChunkedState::read_end_lf(body),
-            End => Ok(Async::Ready(ChunkedState::End)),
-        }
-    }
-    fn read_size(rdr: &mut BytesMut, size: &mut u64) -> Poll<ChunkedState, io::Error> {
-        trace!("Read chunk hex size");
-        let radix = 16;
-        match byte!(rdr) {
-            b @ b'0'...b'9' => {
-                *size *= radix;
-                *size += u64::from(b - b'0');
-            }
-            b @ b'a'...b'f' => {
-                *size *= radix;
-                *size += u64::from(b + 10 - b'a');
-            }
-            b @ b'A'...b'F' => {
-                *size *= radix;
-                *size += u64::from(b + 10 - b'A');
-            }
-            b'\t' | b' ' => return Ok(Async::Ready(ChunkedState::SizeLws)),
-            b';' => return Ok(Async::Ready(ChunkedState::Extension)),
-            b'\r' => return Ok(Async::Ready(ChunkedState::SizeLf)),
-            _ => {
-                return Err(io::Error::new(io::ErrorKind::InvalidInput,
-                                          "Invalid chunk size line: Invalid Size"));
-            }
-        }
-        Ok(Async::Ready(ChunkedState::Size))
-    }
-    fn read_size_lws(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
-        trace!("read_size_lws");
-        match byte!(rdr) {
-            // LWS can follow the chunk size, but no more digits can come
-            b'\t' | b' ' => Ok(Async::Ready(ChunkedState::SizeLws)),
-            b';' => Ok(Async::Ready(ChunkedState::Extension)),
-            b'\r' => Ok(Async::Ready(ChunkedState::SizeLf)),
-            _ => {
-                Err(io::Error::new(io::ErrorKind::InvalidInput,
-                                   "Invalid chunk size linear white space"))
-            }
-        }
-    }
-    fn read_extension(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
-        trace!("read_extension");
-        match byte!(rdr) {
-            b'\r' => Ok(Async::Ready(ChunkedState::SizeLf)),
-            _ => Ok(Async::Ready(ChunkedState::Extension)), // no supported extensions
-        }
-    }
-    fn read_size_lf(rdr: &mut BytesMut, size: &mut u64) -> Poll<ChunkedState, io::Error> {
-        trace!("Chunk size is {:?}", size);
-        match byte!(rdr) {
-            b'\n' if *size > 0 => Ok(Async::Ready(ChunkedState::Body)),
-            b'\n' if *size == 0 => Ok(Async::Ready(ChunkedState::EndCr)),
-            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk size LF")),
-        }
-    }
-
-    fn read_body(rdr: &mut BytesMut, rem: &mut u64, buf: &mut Option<Bytes>)
-                 -> Poll<ChunkedState, io::Error>
-    {
-        trace!("Chunked read, remaining={:?}", rem);
-
-        let len = rdr.len() as u64;
-        if len == 0 {
-            Ok(Async::Ready(ChunkedState::Body))
-        } else {
-            let slice;
-            if *rem > len {
-                slice = rdr.take().freeze();
-                *rem -= len;
-            } else {
-                slice = rdr.split_to(*rem as usize).freeze();
-                *rem = 0;
-            }
-            *buf = Some(slice);
-            if *rem > 0 {
-                Ok(Async::Ready(ChunkedState::Body))
-            } else {
-                Ok(Async::Ready(ChunkedState::BodyCr))
-            }
-        }
-    }
-
-    fn read_body_cr(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
-        match byte!(rdr) {
-            b'\r' => Ok(Async::Ready(ChunkedState::BodyLf)),
-            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk body CR")),
-        }
-    }
-    fn read_body_lf(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
-        match byte!(rdr) {
-            b'\n' => Ok(Async::Ready(ChunkedState::Size)),
-            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk body LF")),
-        }
-    }
-    fn read_end_cr(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
-        match byte!(rdr) {
-            b'\r' => Ok(Async::Ready(ChunkedState::EndLf)),
-            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk end CR")),
-        }
-    }
-    fn read_end_lf(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
-        match byte!(rdr) {
-            b'\n' => Ok(Async::Ready(ChunkedState::End)),
-            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk end LF")),
-        }
-    }
-}

src/dev.rs

@@ -1,15 +0,0 @@
-//! The `actix-web` prelude for library developers
-//!
-//! The purpose of this module is to alleviate imports of many common actix traits
-//! by adding a glob import to the top of actix heavy modules:
-//!
-//! ```
-//! # #![allow(unused_imports)]
-//! use actix_web::dev::*;
-//! ```
-
-pub use super::*;
-
-// dev specific
-pub use task::Task;
-pub use recognizer::RouteRecognizer;

src/error.rs

@@ -1,78 +1,176 @@
-//! Error and Result module.
-use std::error::Error as StdError;
-use std::fmt;
-use std::io::Error as IoError;
+//! Error and Result module
+use std::{io, fmt, result};
 use std::str::Utf8Error;
 use std::string::FromUtf8Error;
+use std::io::Error as IoError;
+
+#[cfg(actix_nightly)]
+use std::error::Error as StdError;
 
 use cookie;
 use httparse;
-use http::{StatusCode, Error as HttpError};
+use futures::Canceled;
+use failure::{Fail, Backtrace};
+use http2::Error as Http2Error;
+use http::{header, StatusCode, Error as HttpError};
+use http::uri::InvalidUriBytes;
+use http_range::HttpRangeParseError;
+use serde_json::error::Error as JsonError;
+use url::ParseError as UrlParseError;
+
+// re-exports
+pub use cookie::{ParseError as CookieParseError};
 
-use HttpRangeParseError;
-use multipart::MultipartError;
 use body::Body;
-use httpresponse::{HttpResponse};
+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>;
 
-/// A set of errors that can occur during parsing HTTP streams.
-#[derive(Debug)]
+/// General purpose actix web error
+pub struct Error {
+    cause: Box<ResponseError>,
+    backtrace: Option<Backtrace>,
+}
+
+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()
+    }
+}
+
+/// 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)
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.cause, f)
+    }
+}
+
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        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())
+        }
+    }
+}
+
+/// `HttpResponse` for `Error`
+impl From<Error> for HttpResponse {
+    fn from(err: Error) -> Self {
+        HttpResponse::from_error(err)
+    }
+}
+
+/// `Error` for any error that implements `ResponseError`
+impl<T: ResponseError> From<T> for Error {
+    fn from(err: T) -> Error {
+        let backtrace = if err.backtrace().is_none() {
+            Some(Backtrace::new())
+        } else {
+            None
+        };
+        Error { cause: Box::new(err), backtrace: 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)
+    }
+}
+
+/// `InternalServerError` for `JsonError`
+impl ResponseError for JsonError {}
+
+/// 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)
+        }
+    }
+}
+
+/// `InternalServerError` for `InvalidHeaderValue`
+impl ResponseError for header::InvalidHeaderValue {}
+
+/// `InternalServerError` for `futures::Canceled`
+impl ResponseError for Canceled {}
+
+/// A set of errors that can occur during parsing HTTP streams
+#[derive(Fail, Debug)]
 pub enum ParseError {
-    /// An invalid `Method`, such as `GE,T`.
+    /// An invalid `Method`, such as `GE.T`.
+    #[fail(display="Invalid Method specified")]
     Method,
     /// An invalid `Uri`, such as `exam ple.domain`.
-    Uri,
+    #[fail(display="Uri error: {}", _0)]
+    Uri(InvalidUriBytes),
     /// An invalid `HttpVersion`, such as `HTP/1.1`
+    #[fail(display="Invalid HTTP version specified")]
     Version,
     /// An invalid `Header`.
+    #[fail(display="Invalid Header provided")]
     Header,
     /// A message head is too large to be reasonable.
+    #[fail(display="Message head is too large")]
     TooLarge,
     /// A message reached EOF, but is not complete.
+    #[fail(display="Message is incomplete")]
     Incomplete,
     /// An invalid `Status`, such as `1337 ELITE`.
+    #[fail(display="Invalid Status provided")]
     Status,
     /// A timeout occurred waiting for an IO event.
     #[allow(dead_code)]
+    #[fail(display="Timeout")]
     Timeout,
     /// An `io::Error` that occurred while trying to read or write to a network stream.
-    Io(IoError),
+    #[fail(display="IO error: {}", _0)]
+    Io(#[cause] IoError),
     /// Parsing a field as string failed
-    Utf8(Utf8Error),
+    #[fail(display="UTF8 error: {}", _0)]
+    Utf8(#[cause] Utf8Error),
 }
 
-impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ParseError::Io(ref e) => fmt::Display::fmt(e, f),
-            ParseError::Utf8(ref e) => fmt::Display::fmt(e, f),
-            ref e => f.write_str(e.description()),
-        }
-    }
-}
-
-impl StdError for ParseError {
-    fn description(&self) -> &str {
-        match *self {
-            ParseError::Method => "Invalid Method specified",
-            ParseError::Version => "Invalid HTTP version specified",
-            ParseError::Header => "Invalid Header provided",
-            ParseError::TooLarge => "Message head is too large",
-            ParseError::Status => "Invalid Status provided",
-            ParseError::Incomplete => "Message is incomplete",
-            ParseError::Timeout => "Timeout",
-            ParseError::Uri => "Uri error",
-            ParseError::Io(ref e) => e.description(),
-            ParseError::Utf8(ref e) => e.description(),
-        }
-    }
-
-    fn cause(&self) -> Option<&StdError> {
-        match *self {
-            ParseError::Io(ref error) => Some(error),
-            ParseError::Utf8(ref error) => Some(error),
-            _ => None,
-        }
+/// Return `BadRequest` for `ParseError`
+impl ResponseError for ParseError {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
     }
 }
 
@@ -97,10 +195,8 @@ 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,
@@ -108,50 +204,441 @@ impl From<httparse::Error> for ParseError {
     }
 }
 
-/// Return `BadRequest` for `ParseError`
-impl From<ParseError> for HttpResponse {
-    fn from(err: ParseError) -> Self {
-        HttpResponse::from_error(StatusCode::BAD_REQUEST, err)
+#[derive(Fail, Debug)]
+/// 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.")]
+    Incomplete,
+    /// Content encoding stream corruption
+    #[fail(display="Can not decode content-encoding.")]
+    EncodingCorrupted,
+    /// 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.")]
+    UnknownLength,
+    /// Parse error
+    #[fail(display="{}", _0)]
+    ParseError(#[cause] IoError),
+    /// Http2 error
+    #[fail(display="{}", _0)]
+    Http2(#[cause] Http2Error),
+}
+
+impl From<IoError> for PayloadError {
+    fn from(err: IoError) -> PayloadError {
+        PayloadError::ParseError(err)
     }
 }
 
-/// Return `InternalServerError` for `HttpError`,
-/// Response generation can return `HttpError`, so it is internal error
-impl From<HttpError> for HttpResponse {
-    fn from(err: HttpError) -> Self {
-        HttpResponse::from_error(StatusCode::INTERNAL_SERVER_ERROR, err)
-    }
-}
-
-/// Return `InternalServerError` for `io::Error`
-impl From<IoError> for HttpResponse {
-    fn from(err: IoError) -> Self {
-        HttpResponse::from_error(StatusCode::INTERNAL_SERVER_ERROR, err)
-    }
-}
+/// `InternalServerError` for `PayloadError`
+impl ResponseError for PayloadError {}
 
 /// Return `BadRequest` for `cookie::ParseError`
-impl From<cookie::ParseError> for HttpResponse {
-    fn from(err: cookie::ParseError) -> Self {
-        HttpResponse::from_error(StatusCode::BAD_REQUEST, err)
+impl ResponseError for cookie::ParseError {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+    }
+}
+
+/// Http range header parsing error
+#[derive(Fail, PartialEq, Debug)]
+pub enum HttpRangeError {
+    /// Returned if range 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")]
+    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"))
+    }
+}
+
+impl From<HttpRangeParseError> for HttpRangeError {
+    fn from(err: HttpRangeParseError) -> HttpRangeError {
+        match err {
+            HttpRangeParseError::InvalidRange => HttpRangeError::InvalidRange,
+            HttpRangeParseError::NoOverlap => HttpRangeError::NoOverlap,
+        }
+    }
+}
+
+/// A set of errors that can occur during parsing multipart streams
+#[derive(Fail, Debug)]
+pub enum MultipartError {
+    /// Content-Type header is not found
+    #[fail(display="No Content-type header found")]
+    NoContentType,
+    /// 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")]
+    Boundary,
+    /// Error during field parsing
+    #[fail(display="{}", _0)]
+    Parse(#[cause] ParseError),
+    /// Payload error
+    #[fail(display="{}", _0)]
+    Payload(#[cause] PayloadError),
+}
+
+impl From<ParseError> for MultipartError {
+    fn from(err: ParseError) -> MultipartError {
+        MultipartError::Parse(err)
+    }
+}
+
+impl From<PayloadError> for MultipartError {
+    fn from(err: PayloadError) -> MultipartError {
+        MultipartError::Payload(err)
     }
 }
 
 /// Return `BadRequest` for `MultipartError`
-impl From<MultipartError> for HttpResponse {
-    fn from(err: MultipartError) -> Self {
-        HttpResponse::from_error(StatusCode::BAD_REQUEST, err)
+impl ResponseError for MultipartError {
+
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
     }
 }
 
-/// Return `BadRequest` for `HttpRangeParseError`
-impl From<HttpRangeParseError> for HttpResponse {
-    fn from(_: HttpRangeParseError) -> Self {
-        HttpResponse::new(
-            StatusCode::BAD_REQUEST, Body::from("Invalid Range header provided"))
+/// Error during handling `Expect` header
+#[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")]
+    Encoding,
+    /// Unknown expect value
+    #[fail(display="Unknown expect value")]
+    UnknownExpect,
+}
+
+impl ResponseError for ExpectError {
+
+    fn error_response(&self) -> HttpResponse {
+        HTTPExpectationFailed.with_body("Unknown Expect")
     }
 }
 
+/// Websocket handshake errors
+#[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,
+}
+
+impl ResponseError for WsHandshakeError {
+
+    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"),
+        }
+    }
+}
+
+/// A set of errors that can occur during parsing urlencoded payloads
+#[derive(Fail, Debug)]
+pub enum UrlencodedError {
+    /// 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")]
+    Overflow,
+    /// Payload size is now known
+    #[fail(display="Payload size is now known")]
+    UnknownLength,
+    /// Content type error
+    #[fail(display="Content type error")]
+    ContentType,
+    /// Payload error
+    #[fail(display="Error that occur during reading payload")]
+    Payload(PayloadError),
+}
+
+/// Return `BadRequest` for `UrlencodedError`
+impl ResponseError for UrlencodedError {
+
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+    }
+}
+
+impl From<PayloadError> for UrlencodedError {
+    fn from(err: PayloadError) -> UrlencodedError {
+        UrlencodedError::Payload(err)
+    }
+}
+
+/// A set of errors that can occur during parsing json payloads
+#[derive(Fail, Debug)]
+pub enum JsonPayloadError {
+    /// Payload size is bigger than 256k
+    #[fail(display="Payload size is bigger than 256k")]
+    Overflow,
+    /// Content type error
+    #[fail(display="Content type error")]
+    ContentType,
+    /// Deserialize error
+    #[fail(display="Json deserialize error")]
+    Deserialize(JsonError),
+    /// Payload error
+    #[fail(display="Error that occur during reading payload")]
+    Payload(PayloadError),
+}
+
+/// Return `BadRequest` for `UrlencodedError`
+impl ResponseError for JsonPayloadError {
+
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+    }
+}
+
+impl From<PayloadError> for JsonPayloadError {
+    fn from(err: PayloadError) -> JsonPayloadError {
+        JsonPayloadError::Payload(err)
+    }
+}
+
+impl From<JsonError> for JsonPayloadError {
+    fn from(err: JsonError) -> JsonPayloadError {
+        JsonPayloadError::Deserialize(err)
+    }
+}
+
+/// Errors which can occur when attempting to interpret a segment string as a
+/// valid path segment.
+#[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")]
+    BadStart(char),
+    /// 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")]
+    BadEnd(char),
+}
+
+/// Return `BadRequest` for `UriSegmentError`
+impl ResponseError for UriSegmentError {
+
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+    }
+}
+
+/// Errors which can occur when attempting to generate resource uri.
+#[derive(Fail, Debug, PartialEq)]
+pub enum UrlGenerationError {
+    #[fail(display="Resource not found")]
+    ResourceNotFound,
+    #[fail(display="Not all path pattern covered")]
+    NotEnoughElements,
+    #[fail(display="Router is not available")]
+    RouterNotAvailable,
+    #[fail(display="{}", _0)]
+    ParseError(#[cause] UrlParseError),
+}
+
+/// `InternalServerError` for `UrlGeneratorError`
+impl ResponseError for UrlGenerationError {}
+
+impl From<UrlParseError> for UrlGenerationError {
+    fn from(err: UrlParseError) -> Self {
+        UrlGenerationError::ParseError(err)
+    }
+}
+
+/// 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.
+///
+/// ```rust
+/// # extern crate actix_web;
+/// # use actix_web::*;
+/// use actix_web::fs::NamedFile;
+///
+/// fn index(req: HttpRequest) -> Result<fs::NamedFile> {
+///    let f = NamedFile::open("test.txt").map_err(error::ErrorBadRequest)?;
+///    Ok(f)
+/// }
+/// # fn main() {}
+/// ```
+pub struct InternalError<T> {
+    cause: T,
+    status: StatusCode,
+    backtrace: Backtrace,
+}
+
+unsafe impl<T> Sync for InternalError<T> {}
+unsafe impl<T> Send for InternalError<T> {}
+
+impl<T> InternalError<T> {
+    pub fn new(err: T, status: StatusCode) -> Self {
+        InternalError {
+            cause: err,
+            status: status,
+            backtrace: Backtrace::new(),
+        }
+    }
+}
+
+impl<T> Fail for InternalError<T>
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    fn backtrace(&self) -> Option<&Backtrace> {
+        Some(&self.backtrace)
+    }
+}
+
+impl<T> fmt::Debug for InternalError<T>
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.cause, f)
+    }
+}
+
+impl<T> fmt::Display for InternalError<T>
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.cause, f)
+    }
+}
+
+impl<T> ResponseError for InternalError<T>
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(self.status, Body::Empty)
+    }
+}
+
+impl<T> Responder for InternalError<T>
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    type Item = HttpResponse;
+    type Error = Error;
+
+    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, Error> {
+        Err(self.into())
+    }
+}
+
+/// 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)
+}
+
+///  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)
+}
+
+///  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)
+}
+
+///  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)
+}
+
+///  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)
+}
+
+///  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)
+}
+
+///  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)
+}
+
+///  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)
+}
+
+///  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)
+}
+
+///  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)
+}
+
+///  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)
+}
+
 #[cfg(test)]
 mod tests {
     use std::error::Error as StdError;
@@ -159,24 +646,31 @@ mod tests {
     use httparse;
     use http::{StatusCode, Error as HttpError};
     use cookie::ParseError as CookieParseError;
-    use super::{ParseError, HttpResponse, HttpRangeParseError, MultipartError};
+    use super::*;
+
+    #[test]
+    #[cfg(actix_nightly)]
+    fn test_nightly() {
+        let resp: HttpResponse = IoError::new(io::ErrorKind::Other, "test").error_response();
+        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
 
     #[test]
     fn test_into_response() {
-        let resp: HttpResponse = ParseError::Incomplete.into();
+        let resp: HttpResponse = ParseError::Incomplete.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
 
-        let resp: HttpResponse = HttpRangeParseError::InvalidRange.into();
+        let resp: HttpResponse = HttpRangeError::InvalidRange.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
 
-        let resp: HttpResponse = CookieParseError::EmptyName.into();
+        let resp: HttpResponse = CookieParseError::EmptyName.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
 
-        let resp: HttpResponse = MultipartError::Boundary.into();
+        let resp: HttpResponse = MultipartError::Boundary.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
 
         let err: HttpError = StatusCode::from_u16(10000).err().unwrap().into();
-        let resp: HttpResponse = err.into();
+        let resp: HttpResponse = err.error_response();
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
     }
 
@@ -185,14 +679,70 @@ mod tests {
         let orig = io::Error::new(io::ErrorKind::Other, "other");
         let desc = orig.description().to_owned();
         let e = ParseError::Io(orig);
-        assert_eq!(e.cause().unwrap().description(), desc);
+        assert_eq!(format!("{}", e.cause().unwrap()), desc);
+    }
+
+    #[test]
+    fn test_error_cause() {
+        let orig = io::Error::new(io::ErrorKind::Other, "other");
+        let desc = orig.description().to_owned();
+        let e = Error::from(orig);
+        assert_eq!(format!("{}", e.cause()), desc);
+    }
+
+    #[test]
+    fn test_error_display() {
+        let orig = io::Error::new(io::ErrorKind::Other, "other");
+        let desc = orig.description().to_owned();
+        let e = Error::from(orig);
+        assert_eq!(format!("{}", e), desc);
+    }
+
+    #[test]
+    fn test_error_http_response() {
+        let orig = io::Error::new(io::ErrorKind::Other, "other");
+        let e = Error::from(orig);
+        let resp: HttpResponse = e.into();
+        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
+
+    #[test]
+    fn test_range_error() {
+        let e: HttpRangeError = HttpRangeParseError::InvalidRange.into();
+        assert_eq!(e, HttpRangeError::InvalidRange);
+        let e: HttpRangeError = HttpRangeParseError::NoOverlap.into();
+        assert_eq!(e, HttpRangeError::NoOverlap);
+    }
+
+    #[test]
+    fn test_expect_error() {
+        let resp: HttpResponse = ExpectError::Encoding.error_response();
+        assert_eq!(resp.status(), StatusCode::EXPECTATION_FAILED);
+        let resp: HttpResponse = ExpectError::UnknownExpect.error_response();
+        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!(e.description().len() >= 5);
+                    assert!(format!("{}", e).len() >= 5);
                 } ,
                 e => panic!("{:?}", e)
             }
@@ -203,9 +753,8 @@ mod tests {
         ($from:expr => $error:pat) => {
             match ParseError::from($from) {
                 e @ $error => {
-                    let desc = e.cause().unwrap().description();
+                    let desc = format!("{}", e.cause().unwrap());
                     assert_eq!(desc, $from.description().to_owned());
-                    assert_eq!(desc, e.description());
                 },
                 _ => panic!("{:?}", $from)
             }

src/fs.rs

@@ -0,0 +1,321 @@
+//! Static files support.
+
+// //! TODO: needs to re-implement actual files handling, current impl blocks
+use std::io;
+use std::io::Read;
+use std::fmt::Write;
+use std::fs::{File, DirEntry};
+use std::path::{Path, PathBuf};
+use std::ops::{Deref, DerefMut};
+
+use mime_guess::get_mime_type;
+
+use param::FromParam;
+use handler::{Handler, Responder};
+use headers::ContentEncoding;
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
+use httpcodes::HTTPOk;
+
+/// A file with an associated name; responds with the Content-Type based on the
+/// file extension.
+#[derive(Debug)]
+pub struct NamedFile(PathBuf, File);
+
+impl NamedFile {
+    /// Attempts to open a file in read-only mode.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use actix_web::fs::NamedFile;
+    ///
+    /// # #[allow(unused_variables)]
+    /// let file = NamedFile::open("foo.txt");
+    /// ```
+    pub fn open<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
+        let file = File::open(path.as_ref())?;
+        Ok(NamedFile(path.as_ref().to_path_buf(), file))
+    }
+
+    /// Returns reference to the underlying `File` object.
+    #[inline]
+    pub fn file(&self) -> &File {
+        &self.1
+    }
+
+    /// Retrieve the path of this file.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use std::io;
+    /// use actix_web::fs::NamedFile;
+    ///
+    /// # #[allow(dead_code)]
+    /// # fn path() -> io::Result<()> {
+    /// let file = NamedFile::open("test.txt")?;
+    /// assert_eq!(file.path().as_os_str(), "foo.txt");
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[inline]
+    pub fn path(&self) -> &Path {
+        self.0.as_path()
+    }
+}
+
+impl Deref for NamedFile {
+    type Target = File;
+
+    fn deref(&self) -> &File {
+        &self.1
+    }
+}
+
+impl DerefMut for NamedFile {
+    fn deref_mut(&mut self) -> &mut File {
+        &mut self.1
+    }
+}
+
+impl Responder for NamedFile {
+    type Item = HttpResponse;
+    type Error = io::Error;
+
+    fn respond_to(mut self, _: HttpRequest) -> Result<HttpResponse, io::Error> {
+        let mut resp = HTTPOk.build();
+        resp.content_encoding(ContentEncoding::Identity);
+        if let Some(ext) = self.path().extension() {
+            let mime = get_mime_type(&ext.to_string_lossy());
+            resp.content_type(format!("{}", mime).as_str());
+        }
+        let mut data = Vec::new();
+        let _ = self.1.read_to_end(&mut data);
+        Ok(resp.body(data).unwrap())
+    }
+}
+
+/// A directory; responds with the generated directory listing.
+#[derive(Debug)]
+pub struct Directory{
+    base: PathBuf,
+    path: PathBuf
+}
+
+impl Directory {
+    pub fn new(base: PathBuf, path: PathBuf) -> Directory {
+        Directory {
+            base: base,
+            path: path
+        }
+    }
+
+    fn can_list(&self, entry: &io::Result<DirEntry>) -> bool {
+        if let Ok(ref entry) = *entry {
+            if let Some(name) = entry.file_name().to_str() {
+                if name.starts_with('.') {
+                    return false
+                }
+            }
+            if let Ok(ref md) = entry.metadata() {
+                let ft = md.file_type();
+                return ft.is_dir() || ft.is_file() || ft.is_symlink()
+            }
+        }
+        false
+    }
+}
+
+impl Responder for Directory {
+    type Item = HttpResponse;
+    type Error = io::Error;
+
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, io::Error> {
+        let index_of = format!("Index of {}", req.path());
+        let mut body = String::new();
+        let base = Path::new(req.path());
+
+        for entry in self.path.read_dir()? {
+            if self.can_list(&entry) {
+                let entry = entry.unwrap();
+                let p = match entry.path().strip_prefix(&self.path) {
+                    Ok(p) => base.join(p),
+                    Err(_) => continue
+                };
+                // show file url as relative to static path
+                let file_url = format!("{}", p.to_string_lossy());
+
+                // if file is a directory, add '/' to the end of the name
+                if let Ok(metadata) = entry.metadata() {
+                    if metadata.is_dir() {
+                        let _ = write!(body, "<li><a href=\"{}\">{}/</a></li>",
+                                       file_url, entry.file_name().to_string_lossy());
+                    } else {
+                        let _ = write!(body, "<li><a href=\"{}\">{}</a></li>",
+                                       file_url, entry.file_name().to_string_lossy());
+                    }
+                } else {
+                    continue
+                }
+            }
+        }
+
+        let html = format!("<html>\
+                            <head><title>{}</title></head>\
+                            <body><h1>{}</h1>\
+                            <ul>\
+                            {}\
+                            </ul></body>\n</html>", index_of, index_of, body);
+        Ok(HTTPOk.build()
+           .content_type("text/html; charset=utf-8")
+           .body(html).unwrap())
+    }
+}
+
+/// This enum represents all filesystem elements.
+pub enum FilesystemElement {
+    File(NamedFile),
+    Directory(Directory),
+}
+
+impl Responder for FilesystemElement {
+    type Item = HttpResponse;
+    type Error = io::Error;
+
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, io::Error> {
+        match self {
+            FilesystemElement::File(file) => file.respond_to(req),
+            FilesystemElement::Directory(dir) => dir.respond_to(req),
+        }
+    }
+}
+
+
+/// Static files handling
+///
+/// `StaticFile` handler must be registered with `Application::handler()` method,
+/// because `StaticFile` handler requires access sub-path information.
+///
+/// ```rust
+/// # extern crate actix_web;
+/// use actix_web::{fs, Application};
+///
+/// fn main() {
+///     let app = Application::new()
+///         .handler("/static", fs::StaticFiles::new(".", true))
+///         .finish();
+/// }
+/// ```
+pub struct StaticFiles {
+    directory: PathBuf,
+    accessible: bool,
+    show_index: bool,
+    _chunk_size: usize,
+    _follow_symlinks: bool,
+}
+
+impl StaticFiles {
+    /// Create new `StaticFiles` instance
+    ///
+    /// `dir` - base directory
+    ///
+    /// `index` - show index for directory
+    pub fn new<D: Into<PathBuf>>(dir: D, index: bool) -> StaticFiles {
+        let dir = dir.into();
+
+        let (dir, access) = match dir.canonicalize() {
+            Ok(dir) => {
+                if dir.is_dir() {
+                    (dir, true)
+                } else {
+                    warn!("Is not directory `{:?}`", dir);
+                    (dir, false)
+                }
+            },
+            Err(err) => {
+                warn!("Static files directory `{:?}` error: {}", dir, err);
+                (dir, false)
+            }
+        };
+
+        StaticFiles {
+            directory: dir,
+            accessible: access,
+            show_index: index,
+            _chunk_size: 0,
+            _follow_symlinks: false,
+        }
+    }
+
+}
+
+impl<S> Handler<S> for StaticFiles {
+    type Result = Result<FilesystemElement, io::Error>;
+
+    fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
+        if !self.accessible {
+            Err(io::Error::new(io::ErrorKind::NotFound, "not found"))
+        } else {
+            let path = if let Some(path) = req.match_info().get("tail") {
+                path
+            } else {
+                return Err(io::Error::new(io::ErrorKind::NotFound, "not found"))
+            };
+
+            let relpath = PathBuf::from_param(path)
+                .map_err(|_| io::Error::new(io::ErrorKind::NotFound, "not found"))?;
+
+            // full filepath
+            let path = self.directory.join(&relpath).canonicalize()?;
+
+            if path.is_dir() {
+                if self.show_index {
+                    Ok(FilesystemElement::Directory(Directory::new(self.directory.clone(), path)))
+                } else {
+                    Err(io::Error::new(io::ErrorKind::NotFound, "not found"))
+                }
+            } else {
+                Ok(FilesystemElement::File(NamedFile::open(path)?))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::header;
+
+    #[test]
+    fn test_named_file() {
+        assert!(NamedFile::open("test--").is_err());
+        let mut file = NamedFile::open("Cargo.toml").unwrap();
+        { file.file();
+          let _f: &File = &file; }
+        { let _f: &mut File = &mut file; }
+
+        let resp = file.respond_to(HttpRequest::default()).unwrap();
+        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "text/x-toml")
+    }
+
+    #[test]
+    fn test_static_files() {
+        let mut st = StaticFiles::new(".", true);
+        st.accessible = false;
+        assert!(st.handle(HttpRequest::default()).is_err());
+
+        st.accessible = true;
+        st.show_index = false;
+        assert!(st.handle(HttpRequest::default()).is_err());
+
+        let mut req = HttpRequest::default();
+        req.match_info_mut().add("tail", "");
+
+        st.show_index = true;
+        let resp = st.handle(req).respond_to(HttpRequest::default()).unwrap();
+        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "text/html; charset=utf-8");
+        assert!(resp.body().is_binary());
+        assert!(format!("{:?}", resp.body()).contains("README.md"));
+    }
+}

src/handler.rs

@@ -0,0 +1,562 @@
+use std::marker::PhantomData;
+
+use regex::Regex;
+use futures::future::{Future, ok, err};
+use http::{header, StatusCode, Error as HttpError};
+
+use body::Body;
+use error::Error;
+use httprequest::HttpRequest;
+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;
+
+    /// Handle request
+    fn handle(&mut self, req: HttpRequest<S>) -> Self::Result;
+}
+
+/// Trait implemented by types that generate responses for clients.
+///
+/// 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>;
+
+    /// 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>;
+}
+
+#[doc(hidden)]
+/// Convenience trait that convert `Future` object into `Boxed` future
+pub trait AsyncResponder<I, E>: Sized {
+    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,
+{
+    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
+{
+    type Result = R;
+
+    fn handle(&mut self, req: HttpRequest<S>) -> R {
+        (self)(req)
+    }
+}
+
+/// Represents response process.
+pub struct Reply(ReplyItem);
+
+pub(crate) enum ReplyItem {
+    Message(HttpResponse),
+    Future(Box<Future<Item=HttpResponse, Error=Error>>),
+}
+
+impl Reply {
+
+    /// 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)))
+    }
+
+    /// Send response
+    #[inline]
+    pub fn response<R: Into<HttpResponse>>(response: R) -> Reply {
+        Reply(ReplyItem::Message(response.into()))
+    }
+
+    #[inline]
+    pub(crate) fn into(self) -> ReplyItem {
+        self.0
+    }
+
+    #[cfg(test)]
+    pub(crate) fn as_response(&self) -> Option<&HttpResponse> {
+        match self.0 {
+            ReplyItem::Message(ref resp) => Some(resp),
+            _ => None,
+        }
+    }
+}
+
+impl Responder for Reply {
+    type Item = Reply;
+    type Error = Error;
+
+    fn respond_to(self, _: HttpRequest) -> Result<Reply, Error> {
+        Ok(self)
+    }
+}
+
+impl Responder for HttpResponse {
+    type Item = Reply;
+    type Error = Error;
+
+    #[inline]
+    fn respond_to(self, _: HttpRequest) -> Result<Reply, Error> {
+        Ok(Reply(ReplyItem::Message(self)))
+    }
+}
+
+impl From<HttpResponse> for Reply {
+
+    #[inline]
+    fn from(resp: HttpResponse) -> Reply {
+        Reply(ReplyItem::Message(resp))
+    }
+}
+
+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> {
+        match self {
+            Ok(val) => match val.respond_to(req) {
+                Ok(val) => Ok(val),
+                Err(err) => Err(err.into()),
+            },
+            Err(err) => Err(err.into()),
+        }
+    }
+}
+
+impl<E: Into<Error>> From<Result<Reply, E>> for Reply {
+    #[inline]
+    fn from(res: Result<Reply, E>) -> Self {
+        match res {
+            Ok(val) => val,
+            Err(err) => Reply(ReplyItem::Message(err.into().into())),
+        }
+    }
+}
+
+impl<E: Into<Error>> From<Result<HttpResponse, E>> for Reply {
+    #[inline]
+    fn from(res: Result<HttpResponse, E>) -> Self {
+        match res {
+            Ok(val) => Reply(ReplyItem::Message(val)),
+            Err(err) => Reply(ReplyItem::Message(err.into().into())),
+        }
+    }
+}
+
+impl From<Box<Future<Item=HttpResponse, Error=Error>>> for Reply {
+    #[inline]
+    fn from(fut: Box<Future<Item=HttpResponse, Error=Error>>) -> Reply {
+        Reply(ReplyItem::Future(fut))
+    }
+}
+
+impl<I, E> Responder for Box<Future<Item=I, Error=E>>
+    where I: Responder + 'static,
+          E: Into<Error> + 'static
+{
+    type Item = Reply;
+    type Error = Error;
+
+    #[inline]
+    fn respond_to(self, req: HttpRequest) -> Result<Reply, Error> {
+        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),
+                }
+            });
+        Ok(Reply::async(fut))
+    }
+}
+
+/// Trait defines object that could be registered as resource route
+pub(crate) trait RouteHandler<S>: 'static {
+    fn handle(&mut self, req: HttpRequest<S>) -> Reply;
+}
+
+/// Route handler wrapper for Handler
+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,
+{
+    pub fn new(h: H) -> Self {
+        WrapHandler{h: 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,
+{
+    fn handle(&mut self, req: HttpRequest<S>) -> Reply {
+        let req2 = req.clone_without_state();
+        match self.h.handle(req).respond_to(req2) {
+            Ok(reply) => reply.into(),
+            Err(err) => Reply::response(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,
+{
+    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,
+{
+    pub fn new(h: H) -> Self {
+        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,
+{
+    fn handle(&mut self, req: HttpRequest<S>) -> Reply {
+        let req2 = req.clone_without_state();
+        let fut = (self.h)(req)
+            .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),
+                }
+            });
+        Reply::async(fut)
+    }
+}
+
+/// Path normalization helper
+///
+/// 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("/test/", |r| r.f(index))
+///         .default_resource(|r| r.h(NormalizePath::default()))
+///         .finish();
+/// }
+/// ```
+/// 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,
+}
+
+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 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> 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/helpers.rs

@@ -0,0 +1,338 @@
+use std::{str, mem, ptr, slice};
+use std::cell::RefCell;
+use std::fmt::{self, Write};
+use std::rc::Rc;
+use std::ops::{Deref, DerefMut};
+use std::collections::VecDeque;
+use time;
+use bytes::{BufMut, BytesMut};
+use http::Version;
+
+use httprequest::HttpMessage;
+
+// "Sun, 06 Nov 1994 08:49:37 GMT".len()
+pub(crate) const DATE_VALUE_LENGTH: usize = 29;
+
+pub(crate) fn date(dst: &mut BytesMut) {
+    CACHED.with(|cache| {
+        let mut buf: [u8; 39] = unsafe { mem::uninitialized() };
+        buf[..6].copy_from_slice(b"date: ");
+        buf[6..35].copy_from_slice(cache.borrow().buffer());
+        buf[35..].copy_from_slice(b"\r\n\r\n");
+        dst.extend_from_slice(&buf);
+    })
+}
+
+pub(crate) fn date_value(dst: &mut BytesMut) {
+    CACHED.with(|cache| {
+        dst.extend_from_slice(cache.borrow().buffer());
+    })
+}
+
+pub(crate) fn update_date() {
+    CACHED.with(|cache| {
+        cache.borrow_mut().update();
+    });
+}
+
+struct CachedDate {
+    bytes: [u8; DATE_VALUE_LENGTH],
+    pos: usize,
+}
+
+thread_local!(static CACHED: RefCell<CachedDate> = RefCell::new(CachedDate {
+    bytes: [0; DATE_VALUE_LENGTH],
+    pos: 0,
+}));
+
+impl CachedDate {
+    fn buffer(&self) -> &[u8] {
+        &self.bytes[..]
+    }
+
+    fn update(&mut self) {
+        self.pos = 0;
+        write!(self, "{}", time::at_utc(time::get_time()).rfc822()).unwrap();
+        assert_eq!(self.pos, DATE_VALUE_LENGTH);
+    }
+}
+
+impl fmt::Write for CachedDate {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        let len = s.len();
+        self.bytes[self.pos..self.pos + len].copy_from_slice(s.as_bytes());
+        self.pos += len;
+        Ok(())
+    }
+}
+
+/// Internal use only! unsafe
+pub(crate) struct SharedMessagePool(RefCell<VecDeque<Rc<HttpMessage>>>);
+
+impl SharedMessagePool {
+    pub fn new() -> SharedMessagePool {
+        SharedMessagePool(RefCell::new(VecDeque::with_capacity(128)))
+    }
+
+    pub fn get(&self) -> Rc<HttpMessage> {
+        if let Some(msg) = self.0.borrow_mut().pop_front() {
+            msg
+        } else {
+            Rc::new(HttpMessage::default())
+        }
+    }
+
+    pub fn release(&self, mut msg: Rc<HttpMessage>) {
+        let v = &mut self.0.borrow_mut();
+        if v.len() < 128 {
+            Rc::get_mut(&mut msg).unwrap().reset();
+            v.push_front(msg);
+        }
+    }
+}
+
+pub(crate) struct SharedHttpMessage(
+    Option<Rc<HttpMessage>>, Option<Rc<SharedMessagePool>>);
+
+impl Drop for SharedHttpMessage {
+    fn drop(&mut self) {
+        if let Some(ref pool) = self.1 {
+            if let Some(msg) = self.0.take() {
+                if Rc::strong_count(&msg) == 1 {
+                    pool.release(msg);
+                }
+            }
+        }
+    }
+}
+
+impl Deref for SharedHttpMessage {
+    type Target = HttpMessage;
+
+    fn deref(&self) -> &HttpMessage {
+        self.get_ref()
+    }
+}
+
+impl DerefMut for SharedHttpMessage {
+
+    fn deref_mut(&mut self) -> &mut HttpMessage {
+        self.get_mut()
+    }
+}
+
+impl Clone for SharedHttpMessage {
+
+    fn clone(&self) -> SharedHttpMessage {
+        SharedHttpMessage(self.0.clone(), self.1.clone())
+    }
+}
+
+impl Default for SharedHttpMessage {
+
+    fn default() -> SharedHttpMessage {
+        SharedHttpMessage(Some(Rc::new(HttpMessage::default())), None)
+    }
+}
+
+impl SharedHttpMessage {
+
+    pub fn from_message(msg: HttpMessage) -> SharedHttpMessage {
+        SharedHttpMessage(Some(Rc::new(msg)), None)
+    }
+
+    pub fn new(msg: Rc<HttpMessage>, pool: Rc<SharedMessagePool>) -> SharedHttpMessage {
+        SharedHttpMessage(Some(msg), Some(pool))
+    }
+
+    #[inline(always)]
+    #[allow(mutable_transmutes)]
+    #[cfg_attr(feature = "cargo-clippy", allow(mut_from_ref, inline_always))]
+    pub fn get_mut(&self) -> &mut HttpMessage {
+        let r: &HttpMessage = self.0.as_ref().unwrap().as_ref();
+        unsafe{mem::transmute(r)}
+    }
+
+    #[inline(always)]
+    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
+    pub fn get_ref(&self) -> &HttpMessage {
+        self.0.as_ref().unwrap()
+    }
+}
+
+const DEC_DIGITS_LUT: &[u8] =
+    b"0001020304050607080910111213141516171819\
+      2021222324252627282930313233343536373839\
+      4041424344454647484950515253545556575859\
+      6061626364656667686970717273747576777879\
+      8081828384858687888990919293949596979899";
+
+pub(crate) fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
+    let mut buf: [u8; 13] = [b'H', b'T', b'T', b'P', b'/', b'1', b'.', b'1',
+                             b' ', b' ', b' ', b' ', b' '];
+    match version {
+        Version::HTTP_2 => buf[5] = b'2',
+        Version::HTTP_10 => buf[7] = b'0',
+        Version::HTTP_09 => {buf[5] = b'0'; buf[7] = b'9';},
+        _ => (),
+    }
+
+    let mut curr: isize = 12;
+    let buf_ptr = buf.as_mut_ptr();
+    let lut_ptr = DEC_DIGITS_LUT.as_ptr();
+    let four = n > 999;
+
+    unsafe {
+        // decode 2 more chars, if > 2 chars
+        let d1 = (n % 100) << 1;
+        n /= 100;
+        curr -= 2;
+        ptr::copy_nonoverlapping(lut_ptr.offset(d1 as isize), buf_ptr.offset(curr), 2);
+
+        // decode last 1 or 2 chars
+        if n < 10 {
+            curr -= 1;
+            *buf_ptr.offset(curr) = (n as u8) + b'0';
+        } else {
+            let d1 = n << 1;
+            curr -= 2;
+            ptr::copy_nonoverlapping(lut_ptr.offset(d1 as isize), buf_ptr.offset(curr), 2);
+        }
+    }
+
+    bytes.extend_from_slice(&buf);
+    if four {
+        bytes.put(b' ');
+    }
+}
+
+pub(crate) fn write_content_length(mut n: usize, bytes: &mut BytesMut) {
+    if n < 10 {
+        let mut buf: [u8; 21] = [b'\r',b'\n',b'c',b'o',b'n',b't',b'e',
+                                 b'n',b't',b'-',b'l',b'e',b'n',b'g',
+                                 b't',b'h',b':',b' ',b'0',b'\r',b'\n'];
+        buf[18] = (n as u8) + b'0';
+        bytes.extend_from_slice(&buf);
+    } else if n < 100 {
+        let mut buf: [u8; 22] = [b'\r',b'\n',b'c',b'o',b'n',b't',b'e',
+                                 b'n',b't',b'-',b'l',b'e',b'n',b'g',
+                                 b't',b'h',b':',b' ',b'0',b'0',b'\r',b'\n'];
+        let d1 = n << 1;
+        unsafe {
+            ptr::copy_nonoverlapping(
+                DEC_DIGITS_LUT.as_ptr().offset(d1 as isize), buf.as_mut_ptr().offset(18), 2);
+        }
+        bytes.extend_from_slice(&buf);
+    } else if n < 1000 {
+        let mut buf: [u8; 23] = [b'\r',b'\n',b'c',b'o',b'n',b't',b'e',
+                                 b'n',b't',b'-',b'l',b'e',b'n',b'g',
+                                 b't',b'h',b':',b' ',b'0',b'0',b'0',b'\r',b'\n'];
+        // decode 2 more chars, if > 2 chars
+        let d1 = (n % 100) << 1;
+        n /= 100;
+        unsafe {ptr::copy_nonoverlapping(
+            DEC_DIGITS_LUT.as_ptr().offset(d1 as isize), buf.as_mut_ptr().offset(19), 2)};
+
+        // decode last 1
+        buf[18] = (n as u8) + b'0';
+
+        bytes.extend_from_slice(&buf);
+    } else {
+        bytes.extend_from_slice(b"\r\ncontent-length: ");
+        convert_usize(n, bytes);
+    }
+}
+
+pub(crate) fn convert_usize(mut n: usize, bytes: &mut BytesMut) {
+    let mut curr: isize = 39;
+    let mut buf: [u8; 41] = unsafe { mem::uninitialized() };
+    buf[39] = b'\r';
+    buf[40] = b'\n';
+    let buf_ptr = buf.as_mut_ptr();
+    let lut_ptr = DEC_DIGITS_LUT.as_ptr();
+
+    unsafe {
+        // eagerly decode 4 characters at a time
+        while n >= 10_000 {
+            let rem = (n % 10_000) as isize;
+            n /= 10_000;
+
+            let d1 = (rem / 100) << 1;
+            let d2 = (rem % 100) << 1;
+            curr -= 4;
+            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+            ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);
+        }
+
+        // if we reach here numbers are <= 9999, so at most 4 chars long
+        let mut n = n as isize; // possibly reduce 64bit math
+
+        // decode 2 more chars, if > 2 chars
+        if n >= 100 {
+            let d1 = (n % 100) << 1;
+            n /= 100;
+            curr -= 2;
+            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+        }
+
+        // decode last 1 or 2 chars
+        if n < 10 {
+            curr -= 1;
+            *buf_ptr.offset(curr) = (n as u8) + b'0';
+        } else {
+            let d1 = n << 1;
+            curr -= 2;
+            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+        }
+    }
+
+    unsafe {
+        bytes.extend_from_slice(
+            slice::from_raw_parts(buf_ptr.offset(curr), 41 - curr as usize));
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_date_len() {
+        assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
+    }
+
+    #[test]
+    fn test_date() {
+        let mut buf1 = BytesMut::new();
+        date(&mut buf1);
+        let mut buf2 = BytesMut::new();
+        date(&mut buf2);
+        assert_eq!(buf1, buf2);
+    }
+
+    #[test]
+    fn test_write_content_length() {
+        let mut bytes = BytesMut::new();
+        write_content_length(0, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 0\r\n"[..]);
+        write_content_length(9, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 9\r\n"[..]);
+        write_content_length(10, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 10\r\n"[..]);
+        write_content_length(99, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 99\r\n"[..]);
+        write_content_length(100, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 100\r\n"[..]);
+        write_content_length(101, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 101\r\n"[..]);
+        write_content_length(998, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 998\r\n"[..]);
+        write_content_length(1000, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 1000\r\n"[..]);
+        write_content_length(1001, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 1001\r\n"[..]);
+        write_content_length(5909, &mut bytes);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 5909\r\n"[..]);
+    }
+}

src/httpcodes.rs

@@ -1,12 +1,9 @@
 //! Basic http responses
 #![allow(non_upper_case_globals)]
-use std::rc::Rc;
-use http::StatusCode;
+use http::{StatusCode, Error as HttpError};
 
 use body::Body;
-use task::Task;
-use route::RouteHandler;
-use payload::Payload;
+use handler::{Reply, Handler, RouteHandler, Responder};
 use httprequest::HttpRequest;
 use httpresponse::{HttpResponse, HttpResponseBuilder};
 
@@ -51,14 +48,12 @@ pub const HTTPInternalServerError: StaticResponse =
     StaticResponse(StatusCode::INTERNAL_SERVER_ERROR);
 
 
+#[derive(Copy, Clone, Debug)]
 pub struct StaticResponse(StatusCode);
 
 impl StaticResponse {
-    pub fn builder(&self) -> HttpResponseBuilder {
-        HttpResponse::builder(self.0)
-    }
-    pub fn response(&self) -> HttpResponse {
-        HttpResponse::new(self.0, Body::Empty)
+    pub fn build(&self) -> HttpResponseBuilder {
+        HttpResponse::build(self.0)
     }
     pub fn with_reason(self, reason: &'static str) -> HttpResponse {
         let mut resp = HttpResponse::new(self.0, Body::Empty);
@@ -70,18 +65,84 @@ impl StaticResponse {
     }
 }
 
+impl<S> Handler<S> for StaticResponse {
+    type Result = HttpResponse;
+
+    fn handle(&mut self, _: HttpRequest<S>) -> HttpResponse {
+        HttpResponse::new(self.0, Body::Empty)
+    }
+}
+
 impl<S> RouteHandler<S> for StaticResponse {
-    fn handle(&self, _: &mut HttpRequest, _: Payload, _: Rc<S>) -> Task {
-        Task::reply(HttpResponse::new(self.0, Body::Empty))
+    fn handle(&mut self, _: HttpRequest<S>) -> Reply {
+        Reply::response(HttpResponse::new(self.0, Body::Empty))
+    }
+}
+
+impl Responder for StaticResponse {
+    type Item = HttpResponse;
+    type Error = HttpError;
+
+    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
+        self.build().body(Body::Empty)
     }
 }
 
 impl From<StaticResponse> for HttpResponse {
     fn from(st: StaticResponse) -> Self {
-        st.response()
+        HttpResponse::new(st.0, Body::Empty)
     }
 }
 
+impl From<StaticResponse> for Reply {
+    fn from(st: StaticResponse) -> Self {
+        HttpResponse::new(st.0, Body::Empty).into()
+    }
+}
+
+macro_rules! STATIC_RESP {
+    ($name:ident, $status:expr) => {
+        #[allow(non_snake_case)]
+        pub fn $name() -> HttpResponseBuilder {
+            HttpResponse::build($status)
+        }
+    }
+}
+
+impl HttpResponse {
+    STATIC_RESP!(Ok, StatusCode::OK);
+    STATIC_RESP!(Created, StatusCode::CREATED);
+    STATIC_RESP!(NoContent, StatusCode::NO_CONTENT);
+
+    STATIC_RESP!(MultipleChoices, StatusCode::MULTIPLE_CHOICES);
+    STATIC_RESP!(MovedPermanenty, StatusCode::MOVED_PERMANENTLY);
+    STATIC_RESP!(Found, StatusCode::FOUND);
+    STATIC_RESP!(SeeOther, StatusCode::SEE_OTHER);
+    STATIC_RESP!(NotModified, StatusCode::NOT_MODIFIED);
+    STATIC_RESP!(UseProxy, StatusCode::USE_PROXY);
+    STATIC_RESP!(TemporaryRedirect, StatusCode::TEMPORARY_REDIRECT);
+    STATIC_RESP!(PermanentRedirect, StatusCode::PERMANENT_REDIRECT);
+
+    STATIC_RESP!(BadRequest, StatusCode::BAD_REQUEST);
+    STATIC_RESP!(NotFound, StatusCode::NOT_FOUND);
+    STATIC_RESP!(Unauthorized, StatusCode::UNAUTHORIZED);
+    STATIC_RESP!(PaymentRequired, StatusCode::PAYMENT_REQUIRED);
+    STATIC_RESP!(Forbidden, StatusCode::FORBIDDEN);
+
+    STATIC_RESP!(MethodNotAllowed, StatusCode::METHOD_NOT_ALLOWED);
+    STATIC_RESP!(NotAcceptable, StatusCode::NOT_ACCEPTABLE);
+    STATIC_RESP!(ProxyAuthenticationRequired, StatusCode::PROXY_AUTHENTICATION_REQUIRED);
+    STATIC_RESP!(RequestTimeout, StatusCode::REQUEST_TIMEOUT);
+    STATIC_RESP!(Conflict, StatusCode::CONFLICT);
+    STATIC_RESP!(Gone, StatusCode::GONE);
+    STATIC_RESP!(LengthRequired, StatusCode::LENGTH_REQUIRED);
+    STATIC_RESP!(PreconditionFailed, StatusCode::PRECONDITION_FAILED);
+    STATIC_RESP!(PayloadTooLarge, StatusCode::PAYLOAD_TOO_LARGE);
+    STATIC_RESP!(UriTooLong, StatusCode::URI_TOO_LONG);
+    STATIC_RESP!(ExpectationFailed, StatusCode::EXPECTATION_FAILED);
+
+    STATIC_RESP!(InternalServerError, StatusCode::INTERNAL_SERVER_ERROR);
+}
 
 #[cfg(test)]
 mod tests {
@@ -89,14 +150,14 @@ mod tests {
     use super::{HTTPOk, HTTPBadRequest, Body, HttpResponse};
 
     #[test]
-    fn test_builder() {
-        let resp = HTTPOk.builder().body(Body::Empty).unwrap();
+    fn test_build() {
+        let resp = HTTPOk.build().body(Body::Empty).unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
     #[test]
     fn test_response() {
-        let resp = HTTPOk.response();
+        let resp: HttpResponse = HTTPOk.into();
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
@@ -108,8 +169,8 @@ mod tests {
 
     #[test]
     fn test_with_reason() {
-        let resp = HTTPOk.response();
-        assert_eq!(resp.reason(), "");
+        let resp: HttpResponse = HTTPOk.into();
+        assert_eq!(resp.reason(), "OK");
 
         let resp = HTTPBadRequest.with_reason("test");
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);

src/info.rs

@@ -0,0 +1,213 @@
+use std::str::FromStr;
+use http::header::{self, HeaderName};
+use httprequest::HttpRequest;
+
+const X_FORWARDED_FOR: &str = "X-FORWARDED-FOR";
+const X_FORWARDED_HOST: &str = "X-FORWARDED-HOST";
+const X_FORWARDED_PROTO: &str = "X-FORWARDED-PROTO";
+
+
+/// `HttpRequest` connection information
+pub struct ConnectionInfo<'a> {
+    scheme: &'a str,
+    host: &'a str,
+    remote: Option<&'a str>,
+    peer: Option<String>,
+}
+
+impl<'a> ConnectionInfo<'a> {
+
+    /// Create *ConnectionInfo* instance for a request.
+    #[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
+    pub fn new<S>(req: &'a HttpRequest<S>) -> ConnectionInfo<'a> {
+        let mut host = None;
+        let mut scheme = None;
+        let mut remote = None;
+        let mut peer = None;
+
+        // load forwarded header
+        for hdr in req.headers().get_all(header::FORWARDED) {
+            if let Ok(val) = hdr.to_str() {
+                for pair in val.split(';') {
+                    for el in pair.split(',') {
+                        let mut items = el.trim().splitn(2, '=');
+                        if let Some(name) = items.next() {
+                            if let Some(val) = items.next() {
+                                match &name.to_lowercase() as &str {
+                                    "for" => if remote.is_none() {
+                                        remote = Some(val.trim());
+                                    },
+                                    "proto" => if scheme.is_none() {
+                                        scheme = Some(val.trim());
+                                    },
+                                    "host" => if host.is_none() {
+                                        host = Some(val.trim());
+                                    },
+                                    _ => (),
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // scheme
+        if scheme.is_none() {
+            if let Some(h) = req.headers().get(
+                HeaderName::from_str(X_FORWARDED_PROTO).unwrap()) {
+                if let Ok(h) = h.to_str() {
+                    scheme = h.split(',').next().map(|v| v.trim());
+                }
+            }
+            if scheme.is_none() {
+                scheme = req.uri().scheme_part().map(|a| a.as_str());
+                if scheme.is_none() {
+                    if let Some(router) = req.router() {
+                        if router.server_settings().secure() {
+                            scheme = Some("https")
+                        }
+                    }
+                }
+            }
+        }
+
+        // host
+        if host.is_none() {
+            if let Some(h) = req.headers().get(HeaderName::from_str(X_FORWARDED_HOST).unwrap()) {
+                if let Ok(h) = h.to_str() {
+                    host = h.split(',').next().map(|v| v.trim());
+                }
+            }
+            if host.is_none() {
+                if let Some(h) = req.headers().get(header::HOST) {
+                    host = h.to_str().ok();
+                }
+                if host.is_none() {
+                    host = req.uri().authority_part().map(|a| a.as_str());
+                    if host.is_none() {
+                        if let Some(router) = req.router() {
+                            host = Some(router.server_settings().host());
+                        }
+                    }
+                }
+            }
+        }
+
+        // remote addr
+        if remote.is_none() {
+            if let Some(h) = req.headers().get(
+                HeaderName::from_str(X_FORWARDED_FOR).unwrap()) {
+                if let Ok(h) = h.to_str() {
+                    remote = h.split(',').next().map(|v| v.trim());
+                }
+            }
+            if remote.is_none() { // get peeraddr from socketaddr
+                peer = req.peer_addr().map(|addr| format!("{}", addr));
+            }
+        }
+
+        ConnectionInfo {
+            scheme: scheme.unwrap_or("http"),
+            host: host.unwrap_or("localhost"),
+            remote: remote,
+            peer: peer,
+        }
+    }
+
+    /// Scheme of the request.
+    ///
+    /// Scheme is resolved through the following headers, in this order:
+    ///
+    /// - Forwarded
+    /// - X-Forwarded-Proto
+    /// - Uri
+    #[inline]
+    pub fn scheme(&self) -> &str {
+        self.scheme
+    }
+
+    /// Hostname of the request.
+    ///
+    /// Hostname is resolved through the following headers, in this order:
+    ///
+    /// - Forwarded
+    /// - X-Forwarded-Host
+    /// - Host
+    /// - Uri
+    /// - Server hostname
+    pub fn host(&self) -> &str {
+        self.host
+    }
+
+    /// Remote IP of client initiated HTTP request.
+    ///
+    /// The IP is resolved through the following headers, in this order:
+    ///
+    /// - Forwarded
+    /// - X-Forwarded-For
+    /// - peername of opened socket
+    #[inline]
+    pub fn remote(&self) -> Option<&str> {
+        if let Some(r) = self.remote {
+            Some(r)
+        } else if let Some(ref peer) = self.peer {
+            Some(peer)
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::header::HeaderValue;
+
+    #[test]
+    fn test_forwarded() {
+        let req = HttpRequest::default();
+        let info = ConnectionInfo::new(&req);
+        assert_eq!(info.scheme(), "http");
+        assert_eq!(info.host(), "localhost");
+
+        let mut req = HttpRequest::default();
+        req.headers_mut().insert(
+            header::FORWARDED,
+            HeaderValue::from_static(
+                "for=192.0.2.60; proto=https; by=203.0.113.43; host=rust-lang.org"));
+
+        let info = ConnectionInfo::new(&req);
+        assert_eq!(info.scheme(), "https");
+        assert_eq!(info.host(), "rust-lang.org");
+        assert_eq!(info.remote(), Some("192.0.2.60"));
+
+        let mut req = HttpRequest::default();
+        req.headers_mut().insert(
+            header::HOST, HeaderValue::from_static("rust-lang.org"));
+
+        let info = ConnectionInfo::new(&req);
+        assert_eq!(info.scheme(), "http");
+        assert_eq!(info.host(), "rust-lang.org");
+        assert_eq!(info.remote(), None);
+
+        let mut req = HttpRequest::default();
+        req.headers_mut().insert(
+            HeaderName::from_str(X_FORWARDED_FOR).unwrap(), HeaderValue::from_static("192.0.2.60"));
+        let info = ConnectionInfo::new(&req);
+        assert_eq!(info.remote(), Some("192.0.2.60"));
+
+        let mut req = HttpRequest::default();
+        req.headers_mut().insert(
+            HeaderName::from_str(X_FORWARDED_HOST).unwrap(), HeaderValue::from_static("192.0.2.60"));
+        let info = ConnectionInfo::new(&req);
+        assert_eq!(info.host(), "192.0.2.60");
+        assert_eq!(info.remote(), None);
+
+        let mut req = HttpRequest::default();
+        req.headers_mut().insert(
+            HeaderName::from_str(X_FORWARDED_PROTO).unwrap(), HeaderValue::from_static("https"));
+        let info = ConnectionInfo::new(&req);
+        assert_eq!(info.scheme(), "https");
+    }
+}

src/json.rs

@@ -0,0 +1,215 @@
+use bytes::BytesMut;
+use futures::{Poll, Future, Stream};
+use http::header::CONTENT_LENGTH;
+
+use serde_json;
+use serde::Serialize;
+use serde::de::DeserializeOwned;
+
+use error::{Error, JsonPayloadError};
+use handler::Responder;
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
+
+/// Json response helper
+///
+/// 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() {}
+/// ```
+pub struct Json<T: Serialize> (pub T);
+
+impl<T: Serialize> Responder for Json<T> {
+    type Item = HttpResponse;
+    type Error = Error;
+
+    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, Error> {
+        let body = serde_json::to_string(&self.0)?;
+
+        Ok(HttpResponse::Ok()
+           .content_type("application/json")
+           .body(body)?)
+    }
+}
+
+/// Request payload json parser that resolves to a deserialized `T` value.
+///
+/// Returns error:
+///
+/// * content type is not `application/json`
+/// * content length is greater than 256k
+///
+/// ```rust
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # #[macro_use] extern crate serde_derive;
+/// use actix_web::*;
+/// use futures::future::Future;
+///
+/// #[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
+///            println!("==== BODY ==== {:?}", val);
+///            Ok(httpcodes::HTTPOk.into())
+///        }).responder()
+/// }
+/// # fn main() {}
+/// ```
+pub struct JsonBody<S, T: DeserializeOwned>{
+    limit: usize,
+    ct: &'static str,
+    req: Option<HttpRequest<S>>,
+    fut: Option<Box<Future<Item=T, Error=JsonPayloadError>>>,
+}
+
+impl<S, T: DeserializeOwned> JsonBody<S, T> {
+
+    /// Create `JsonBody` for request.
+    pub fn from_request(req: &HttpRequest<S>) -> Self {
+        JsonBody{
+            limit: 262_144,
+            req: Some(req.clone()),
+            fut: None,
+            ct: "application/json",
+        }
+    }
+
+    /// Change max size of payload. By default max size is 256Kb
+    pub fn limit(mut self, limit: usize) -> Self {
+        self.limit = limit;
+        self
+    }
+
+    /// Set allowed content type.
+    ///
+    /// By default *application/json* content type is used. Set content type
+    /// to empty string if you want to disable content type check.
+    pub fn content_type(mut self, ct: &'static str) -> Self {
+        self.ct = ct;
+        self
+    }
+}
+
+impl<S, T: DeserializeOwned + 'static> Future for JsonBody<S, T> {
+    type Item = T;
+    type Error = JsonPayloadError;
+
+    fn poll(&mut self) -> Poll<T, JsonPayloadError> {
+        if let Some(req) = self.req.take() {
+            if let Some(len) = req.headers().get(CONTENT_LENGTH) {
+                if let Ok(s) = len.to_str() {
+                    if let Ok(len) = s.parse::<usize>() {
+                        if len > self.limit {
+                            return Err(JsonPayloadError::Overflow);
+                        }
+                    } else {
+                        return Err(JsonPayloadError::Overflow);
+                    }
+                }
+            }
+            // check content-type
+            if !self.ct.is_empty() && req.content_type() != self.ct {
+                return Err(JsonPayloadError::ContentType)
+            }
+
+            let limit = self.limit;
+            let fut = req.payload().readany()
+                .from_err()
+                .fold(BytesMut::new(), move |mut body, chunk| {
+                    if (body.len() + chunk.len()) > limit {
+                        Err(JsonPayloadError::Overflow)
+                    } else {
+                        body.extend_from_slice(&chunk);
+                        Ok(body)
+                    }
+                })
+                .and_then(|body| Ok(serde_json::from_slice::<T>(&body)?));
+            self.fut = Some(Box::new(fut));
+        }
+
+        self.fut.as_mut().expect("JsonBody could not be used second time").poll()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bytes::Bytes;
+    use http::header;
+    use futures::Async;
+
+    impl PartialEq for JsonPayloadError {
+        fn eq(&self, other: &JsonPayloadError) -> bool {
+            match *self {
+                JsonPayloadError::Overflow => match *other {
+                    JsonPayloadError::Overflow => true,
+                    _ => false,
+                },
+                JsonPayloadError::ContentType => match *other {
+                    JsonPayloadError::ContentType => true,
+                    _ => false,
+                },
+                _ => false,
+            }
+        }
+    }
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct MyObject {
+        name: String,
+    }
+
+    #[test]
+    fn test_json() {
+        let json = Json(MyObject{name: "test".to_owned()});
+        let resp = json.respond_to(HttpRequest::default()).unwrap();
+        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "application/json");
+    }
+
+    #[test]
+    fn test_json_body() {
+        let mut req = HttpRequest::default();
+        let mut json = req.json::<MyObject>();
+        assert_eq!(json.poll().err().unwrap(), JsonPayloadError::ContentType);
+
+        let mut json = req.json::<MyObject>().content_type("text/json");
+        req.headers_mut().insert(header::CONTENT_TYPE,
+                                 header::HeaderValue::from_static("application/json"));
+        assert_eq!(json.poll().err().unwrap(), JsonPayloadError::ContentType);
+
+        let mut json = req.json::<MyObject>().limit(100);
+        req.headers_mut().insert(header::CONTENT_TYPE,
+                                 header::HeaderValue::from_static("application/json"));
+        req.headers_mut().insert(header::CONTENT_LENGTH,
+                                 header::HeaderValue::from_static("10000"));
+        assert_eq!(json.poll().err().unwrap(), JsonPayloadError::Overflow);
+
+        req.headers_mut().insert(header::CONTENT_LENGTH,
+                                 header::HeaderValue::from_static("16"));
+        req.payload_mut().unread_data(Bytes::from_static(b"{\"name\": \"test\"}"));
+        let mut json = req.json::<MyObject>();
+        assert_eq!(json.poll().ok().unwrap(), Async::Ready(MyObject{name: "test".to_owned()}));
+    }
+
+}

src/lib.rs

@@ -1,4 +1,48 @@
-//! Web framework for [Actix](https://github.com/actix/actix)
+//! Actix web is a small, fast, pragmatic, open source rust web framework.
+//!
+//! ```rust
+//! use actix_web::*;
+//! # use std::thread;
+//!
+//! fn index(req: HttpRequest) -> String {
+//!     format!("Hello {}!", &req.match_info()["name"])
+//! }
+//!
+//! fn main() {
+//! # thread::spawn(|| {
+//!     HttpServer::new(
+//!         || Application::new()
+//!             .resource("/{name}", |r| r.f(index)))
+//!         .bind("127.0.0.1:8080").unwrap()
+//!         .run();
+//! # });
+//! }
+//! ```
+//!
+//! ## Documentation
+//!
+//! * [User Guide](http://actix.github.io/actix-web/guide/)
+//! * [Chat on gitter](https://gitter.im/actix/actix)
+//! * [GitHub repository](https://github.com/actix/actix-web)
+//! * Cargo package: [actix-web](https://crates.io/crates/actix-web)
+//! * Supported Rust version: 1.20 or later
+//!
+//! ## Features
+//!
+//! * Supported *HTTP/1.x* and *HTTP/2.0* protocols
+//! * Streaming and pipelining
+//! * Keep-alive and slow requests handling
+//! * `WebSockets`
+//! * Transparent content compression/decompression (br, gzip, deflate)
+//! * Configurable request routing
+//! * Multipart streams
+//! * Middlewares (`Logger`, `Session`, `DefaultHeaders`)
+//! * Graceful server shutdown
+//! * Built on top of [Actix](https://github.com/actix/actix).
+
+#![cfg_attr(actix_nightly, feature(
+    specialization, // for impl ErrorResponse for std::error::Error
+))]
 
 #[macro_use]
 extern crate log;
@@ -7,10 +51,15 @@ extern crate bytes;
 extern crate sha1;
 extern crate regex;
 #[macro_use]
+extern crate bitflags;
+#[macro_use]
+extern crate failure;
+#[macro_use]
 extern crate futures;
 extern crate tokio_io;
 extern crate tokio_core;
-
+extern crate mio;
+extern crate net2;
 extern crate cookie;
 extern crate http;
 extern crate httparse;
@@ -18,57 +67,119 @@ extern crate http_range;
 extern crate mime;
 extern crate mime_guess;
 extern crate url;
+extern crate libc;
+extern crate serde;
+extern crate serde_json;
+extern crate flate2;
+extern crate brotli2;
 extern crate percent_encoding;
-extern crate actix;
+extern crate smallvec;
+extern crate num_cpus;
+extern crate h2 as http2;
+#[macro_use] extern crate actix;
+
+#[cfg(test)]
+#[macro_use] extern crate serde_derive;
 
 #[cfg(feature="tls")]
 extern crate native_tls;
 #[cfg(feature="tls")]
 extern crate tokio_tls;
 
+#[cfg(feature="openssl")]
+extern crate openssl;
+#[cfg(feature="openssl")]
+extern crate tokio_openssl;
+
 mod application;
 mod body;
 mod context;
-mod error;
-mod date;
-mod decode;
+mod helpers;
 mod httprequest;
 mod httpresponse;
-mod logger;
-mod payload;
-mod resource;
-mod recognizer;
+mod info;
+mod json;
 mod route;
-mod reader;
-mod task;
-mod staticfiles;
-mod server;
-mod wsframe;
-mod wsproto;
+mod router;
+mod param;
+mod resource;
+mod handler;
+mod pipeline;
 
+pub mod fs;
 pub mod ws;
-pub mod dev;
+pub mod error;
 pub mod httpcodes;
 pub mod multipart;
-pub use error::ParseError;
-pub use body::{Body, BinaryBody};
-pub use application::{Application, ApplicationBuilder, Middleware};
-pub use httprequest::{HttpRequest, UrlEncoded};
-pub use httpresponse::{HttpResponse, HttpResponseBuilder};
-pub use payload::{Payload, PayloadItem, PayloadError};
-pub use route::{Frame, Route, RouteFactory, RouteHandler, RouteResult};
-pub use resource::{Reply, Resource, HandlerResult};
-pub use recognizer::{Params, RouteRecognizer};
-pub use logger::Logger;
-pub use server::HttpServer;
+pub mod middleware;
+pub mod pred;
+pub mod test;
+pub mod payload;
+pub mod server;
+pub use error::{Error, Result, ResponseError};
+pub use body::{Body, Binary};
+pub use json::Json;
+pub use application::Application;
+pub use httprequest::HttpRequest;
+pub use httpresponse::HttpResponse;
+pub use handler::{Reply, Responder, NormalizePath, AsyncResponder};
+pub use route::Route;
+pub use resource::Resource;
 pub use context::HttpContext;
-pub use staticfiles::StaticFiles;
+pub use server::HttpServer;
 
 // re-exports
 pub use http::{Method, StatusCode, Version};
-pub use cookie::{Cookie, CookieBuilder};
-pub use cookie::{ParseError as CookieParseError};
-pub use http_range::{HttpRange, HttpRangeParseError};
 
+#[doc(hidden)]
 #[cfg(feature="tls")]
 pub use native_tls::Pkcs12;
+
+#[doc(hidden)]
+#[cfg(feature="openssl")]
+pub use openssl::pkcs12::Pkcs12;
+
+pub mod headers {
+//! Headers implementation
+
+    pub use httpresponse::ConnectionType;
+
+    pub use cookie::{Cookie, CookieBuilder};
+    pub use http_range::HttpRange;
+
+    /// Represents supported types of content encodings
+    #[derive(Copy, Clone, PartialEq, Debug)]
+    pub enum ContentEncoding {
+        /// Automatically select encoding based on encoding negotiation
+        Auto,
+        /// A format using the Brotli algorithm
+        Br,
+        /// A format using the zlib structure with deflate algorithm
+        Deflate,
+        /// Gzip algorithm
+        Gzip,
+        /// Indicates the identity function (i.e. no compression, nor modification)
+        Identity,
+    }
+}
+
+pub mod dev {
+//! The `actix-web` prelude for library developers
+//!
+//! The purpose of this module is to alleviate imports of many common actix traits
+//! by adding a glob import to the top of actix heavy modules:
+//!
+//! ```
+//! # #![allow(unused_imports)]
+//! use actix_web::dev::*;
+//! ```
+
+    pub use body::BodyStream;
+    pub use info::ConnectionInfo;
+    pub use handler::Handler;
+    pub use json::JsonBody;
+    pub use router::{Router, Pattern};
+    pub use param::{FromParam, Params};
+    pub use httprequest::{UrlEncoded, RequestBody};
+    pub use httpresponse::HttpResponseBuilder;
+}

src/logger.rs

@@ -1,279 +0,0 @@
-//! Request logging middleware
-use std::fmt;
-use std::str::Chars;
-use std::iter::Peekable;
-use std::fmt::{Display, Formatter};
-
-use time;
-
-use application::Middleware;
-use httprequest::HttpRequest;
-use httpresponse::HttpResponse;
-
-/// `Middleware` for logging request and response info to the terminal.
-pub struct Logger {
-    format: Format,
-}
-
-impl Logger {
-    /// Create `Logger` middlewares with the specified `format`.
-    /// If a `None` is passed in, uses the default format:
-    ///
-    /// ```ignore
-    /// {method} {uri} -> {status} ({response-time} ms)
-    /// ```
-    ///
-    /// ```rust,ignore
-    /// let app = Application::default("/")
-    ///     .middleware(Logger::new(None))
-    ///     .finish()
-    /// ```
-    pub fn new(format: Option<Format>) -> Logger {
-        let format = format.unwrap_or_default();
-        Logger { format: format.clone() }
-    }
-}
-
-struct StartTime(time::Tm);
-
-impl Logger {
-    fn initialise(&self, req: &mut HttpRequest) {
-        req.extensions().insert(StartTime(time::now()));
-    }
-
-    fn log(&self, req: &mut HttpRequest, resp: &HttpResponse) {
-        let entry_time = req.extensions().get::<StartTime>().unwrap().0;
-
-        let response_time = time::now() - entry_time;
-        let response_time_ms = (response_time.num_seconds() * 1000) as f64 + (response_time.num_nanoseconds().unwrap_or(0) as f64) / 1000000.0;
-
-        {
-            let render = |fmt: &mut Formatter, text: &FormatText| {
-                match *text {
-                    FormatText::Str(ref string) => fmt.write_str(string),
-                    FormatText::Method => req.method().fmt(fmt),
-                    FormatText::URI => {
-                        if req.query_string().is_empty() {
-                            fmt.write_fmt(format_args!("{}", req.path()))
-                        } else {
-                            fmt.write_fmt(format_args!("{}?{}", req.path(), req.query_string()))
-                        }
-                    },
-                    FormatText::Status => resp.status().fmt(fmt),
-                    FormatText::ResponseTime =>
-                        fmt.write_fmt(format_args!("{} ms", response_time_ms)),
-                    FormatText::RemoteAddr => Ok(()), //req.remote_addr.fmt(fmt),
-                    FormatText::RequestTime => {
-                        entry_time.strftime("%Y-%m-%dT%H:%M:%S.%fZ%z")
-                            .unwrap()
-                            .fmt(fmt)
-                    }
-                }
-            };
-
-            info!("{}", self.format.display_with(&render));
-        }
-    }
-}
-
-impl Middleware for Logger {
-    fn start(&self, req: &mut HttpRequest) -> Result<(), HttpResponse> {
-        self.initialise(req);
-        Ok(())
-    }
-
-    fn finish(&self, req: &mut HttpRequest, resp: &HttpResponse) {
-        self.log(req, resp);
-    }
-}
-
-
-use self::FormatText::{Method, URI, Status, ResponseTime, RemoteAddr, RequestTime};
-
-/// A formatting style for the `Logger`, consisting of multiple
-/// `FormatText`s concatenated into one line.
-#[derive(Clone)]
-#[doc(hidden)]
-pub struct Format(Vec<FormatText>);
-
-impl Default for Format {
-    /// Return the default formatting style for the `Logger`:
-    ///
-    /// ```ignore
-    /// {method} {uri} -> {status} ({response-time})
-    /// // This will be written as: {method} {uri} -> {status} ({response-time})
-    /// ```
-    fn default() -> Format {
-        Format::new("{method} {uri} {status} ({response-time})").unwrap()
-    }
-}
-
-impl Format {
-    /// Create a `Format` from a format string, which can contain the fields
-    /// `{method}`, `{uri}`, `{status}`, `{response-time}`, `{ip-addr}` and
-    /// `{request-time}`.
-    ///
-    /// Returns `None` if the format string syntax is incorrect.
-    pub fn new(s: &str) -> Option<Format> {
-
-        let parser = FormatParser::new(s.chars().peekable());
-
-        let mut results = Vec::new();
-
-        for unit in parser {
-            match unit {
-                Some(unit) => results.push(unit),
-                None => return None
-            }
-        }
-
-        Some(Format(results))
-    }
-}
-
-pub(crate) trait ContextDisplay<'a> {
-    type Item;
-    type Display: fmt::Display;
-    fn display_with(&'a self,
-                    render: &'a Fn(&mut Formatter, &Self::Item) -> Result<(), fmt::Error>)
-                    -> Self::Display;
-}
-
-impl<'a> ContextDisplay<'a> for Format {
-    type Item = FormatText;
-    type Display = FormatDisplay<'a>;
-    fn display_with(&'a self,
-                    render: &'a Fn(&mut Formatter, &FormatText) -> Result<(), fmt::Error>)
-                    -> FormatDisplay<'a> {
-        FormatDisplay {
-            format: self,
-            render: render,
-        }
-    }
-}
-
-struct FormatParser<'a> {
-    // The characters of the format string.
-    chars: Peekable<Chars<'a>>,
-
-    // A reusable buffer for parsing style attributes.
-    object_buffer: String,
-
-    finished: bool
-}
-
-impl<'a> FormatParser<'a> {
-    fn new(chars: Peekable<Chars>) -> FormatParser {
-        FormatParser {
-            chars: chars,
-
-            // No attributes are longer than 14 characters, so we can avoid reallocating.
-            object_buffer: String::with_capacity(14),
-
-            finished: false
-        }
-    }
-}
-
-// Some(None) means there was a parse error and this FormatParser should be abandoned.
-impl<'a> Iterator for FormatParser<'a> {
-    type Item = Option<FormatText>;
-
-    fn next(&mut self) -> Option<Option<FormatText>> {
-        // If the parser has been cancelled or errored for some reason.
-        if self.finished { return None }
-
-        // Try to parse a new FormatText.
-        match self.chars.next() {
-            // Parse a recognized object.
-            //
-            // The allowed forms are:
-            //   - {method}
-            //   - {uri}
-            //   - {status}
-            //   - {response-time}
-            //   - {ip-addr}
-            //   - {request-time}
-            Some('{') => {
-                self.object_buffer.clear();
-
-                let mut chr = self.chars.next();
-                while chr != None {
-                    match chr.unwrap() {
-                        // Finished parsing, parse buffer.
-                        '}' => break,
-                        c => self.object_buffer.push(c)
-                    }
-
-                    chr = self.chars.next();
-                }
-
-                let text = match self.object_buffer.as_ref() {
-                    "method" => Method,
-                    "uri" => URI,
-                    "status" => Status,
-                    "response-time" => ResponseTime,
-                    "request-time" => RequestTime,
-                    "ip-addr" => RemoteAddr,
-                    _ => {
-                        // Error, so mark as finished.
-                        self.finished = true;
-                        return Some(None);
-                    }
-                };
-
-                Some(Some(text))
-            }
-
-            // Parse a regular string part of the format string.
-            Some(c) => {
-                let mut buffer = String::new();
-                buffer.push(c);
-
-                loop {
-                    match self.chars.peek() {
-                        // Done parsing.
-                        Some(&'{') | None => return Some(Some(FormatText::Str(buffer))),
-
-                        Some(_) => {
-                            buffer.push(self.chars.next().unwrap())
-                        }
-                    }
-                }
-            },
-
-            // Reached end of the format string.
-            None => None
-        }
-    }
-}
-
-/// A string of text to be logged. This is either one of the data
-/// fields supported by the `Logger`, or a custom `String`.
-#[derive(Clone)]
-#[doc(hidden)]
-pub enum FormatText {
-    Str(String),
-    Method,
-    URI,
-    Status,
-    ResponseTime,
-    RemoteAddr,
-    RequestTime
-}
-
-
-pub(crate) struct FormatDisplay<'a> {
-    format: &'a Format,
-    render: &'a Fn(&mut Formatter, &FormatText) -> Result<(), fmt::Error>,
-}
-
-impl<'a> fmt::Display for FormatDisplay<'a> {
-    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
-        let Format(ref format) = *self.format;
-        for unit in format {
-            (self.render)(fmt, unit)?;
-        }
-        Ok(())
-    }
-}

src/middleware/cors.rs

@@ -0,0 +1,853 @@
+//! Cross-origin resource sharing (CORS) for Actix applications
+//!
+//! CORS middleware could be used with application and with resource.
+//! First you need to construct CORS middleware instance.
+//!
+//! To construct a cors:
+//!
+//!   1. Call [`Cors::build`](struct.Cors.html#method.build) to start building.
+//!   2. Use any of the builder methods to set fields in the backend.
+//!   3. Call [finish](struct.Cors.html#method.finish) to retrieve the constructed backend.
+//!
+//! Cors middleware could be used as parameter for `Application::middleware()` or
+//! `Resource::middleware()` methods. But you have to use `Cors::register()` method to
+//! support *preflight* OPTIONS request.
+//!
+//!
+//! # Example
+//!
+//! ```rust
+//! # extern crate http;
+//! # extern crate actix_web;
+//! # use actix_web::*;
+//! use http::header;
+//! use actix_web::middleware::cors;
+//!
+//! fn index(mut req: HttpRequest) -> &'static str {
+//!    "Hello world"
+//! }
+//!
+//! fn main() {
+//!     let app = Application::new()
+//!         .resource("/index.html", |r| {
+//!              cors::Cors::build()                   // <- Construct CORS middleware
+//!                  .allowed_origin("https://www.rust-lang.org/")
+//!                  .allowed_methods(vec!["GET", "POST"])
+//!                  .allowed_headers(vec![header::AUTHORIZATION, header::ACCEPT])
+//!                  .allowed_header(header::CONTENT_TYPE)
+//!                  .max_age(3600)
+//!                  .finish().expect("Can not create CORS middleware")
+//!                  .register(r);                     // <- Register CORS middleware
+//!              r.method(Method::GET).f(|_| httpcodes::HTTPOk);
+//!              r.method(Method::HEAD).f(|_| httpcodes::HTTPMethodNotAllowed);
+//!         })
+//!         .finish();
+//! }
+//! ```
+//! In this example custom *CORS* middleware get registered for "/index.html" endpoint.
+//!
+//! Cors middleware automatically handle *OPTIONS* preflight request.
+use std::collections::HashSet;
+use std::iter::FromIterator;
+
+use http::{self, Method, HttpTryFrom, Uri};
+use http::header::{self, HeaderName, HeaderValue};
+
+use error::{Result, ResponseError};
+use resource::Resource;
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
+use httpcodes::{HTTPOk, HTTPBadRequest};
+use middleware::{Middleware, Response, Started};
+
+/// A set of errors that can occur during processing CORS
+#[derive(Debug, Fail)]
+pub enum CorsError {
+    /// The HTTP request header `Origin` is required but was not provided
+    #[fail(display="The HTTP request header `Origin` is required but was not provided")]
+    MissingOrigin,
+    /// The HTTP request header `Origin` could not be parsed correctly.
+    #[fail(display="The HTTP request header `Origin` could not be parsed correctly.")]
+    BadOrigin,
+    /// The request header `Access-Control-Request-Method` is required but is missing
+    #[fail(display="The request header `Access-Control-Request-Method` is required but is missing")]
+    MissingRequestMethod,
+    /// The request header `Access-Control-Request-Method` has an invalid value
+    #[fail(display="The request header `Access-Control-Request-Method` has an invalid value")]
+    BadRequestMethod,
+    /// The request header `Access-Control-Request-Headers`  has an invalid value
+    #[fail(display="The request header `Access-Control-Request-Headers`  has an invalid value")]
+    BadRequestHeaders,
+    /// The request header `Access-Control-Request-Headers`  is required but is missing.
+    #[fail(display="The request header `Access-Control-Request-Headers`  is required but is
+                     missing")]
+    MissingRequestHeaders,
+    /// Origin is not allowed to make this request
+    #[fail(display="Origin is not allowed to make this request")]
+    OriginNotAllowed,
+    /// Requested method is not allowed
+    #[fail(display="Requested method is not allowed")]
+    MethodNotAllowed,
+    /// One or more headers requested are not allowed
+    #[fail(display="One or more headers requested are not allowed")]
+    HeadersNotAllowed,
+}
+
+/// A set of errors that can occur during building CORS middleware
+#[derive(Debug, Fail)]
+pub enum CorsBuilderError {
+    #[fail(display="Parse error: {}", _0)]
+    ParseError(http::Error),
+    /// Credentials are allowed, but the Origin is set to "*". This is not allowed by W3C
+    ///
+    /// This is a misconfiguration. Check the documentation for `Cors`.
+    #[fail(display="Credentials are allowed, but the Origin is set to \"*\"")]
+    CredentialsWithWildcardOrigin,
+}
+
+
+impl ResponseError for CorsError {
+
+    fn error_response(&self) -> HttpResponse {
+        HTTPBadRequest.build().body(format!("{}", self)).unwrap()
+    }
+}
+
+/// An enum signifying that some of type T is allowed, or `All` (everything is allowed).
+///
+/// `Default` is implemented for this enum and is `All`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum AllOrSome<T> {
+    /// Everything is allowed. Usually equivalent to the "*" value.
+    All,
+    /// Only some of `T` is allowed
+    Some(T),
+}
+
+impl<T> Default for AllOrSome<T> {
+    fn default() -> Self {
+        AllOrSome::All
+    }
+}
+
+impl<T> AllOrSome<T> {
+    /// Returns whether this is an `All` variant
+    pub fn is_all(&self) -> bool {
+        match *self {
+            AllOrSome::All => true,
+            AllOrSome::Some(_) => false,
+        }
+    }
+
+    /// Returns whether this is a `Some` variant
+    pub fn is_some(&self) -> bool {
+        !self.is_all()
+    }
+
+    /// Returns &T
+    pub fn as_ref(&self) -> Option<&T> {
+        match *self {
+            AllOrSome::All => None,
+            AllOrSome::Some(ref t) => Some(t),
+        }
+    }
+}
+
+/// `Middleware` for Cross-origin resource sharing support
+///
+/// The Cors struct contains the settings for CORS requests to be validated and
+/// for responses to be generated.
+pub struct Cors {
+    methods: HashSet<Method>,
+    origins: AllOrSome<HashSet<String>>,
+    origins_str: Option<HeaderValue>,
+    headers: AllOrSome<HashSet<HeaderName>>,
+    expose_hdrs: Option<String>,
+    max_age: Option<usize>,
+    preflight: bool,
+    send_wildcard: bool,
+    supports_credentials: bool,
+    vary_header: bool,
+}
+
+impl Default for Cors {
+    fn default() -> Cors {
+        Cors {
+            origins: AllOrSome::default(),
+            origins_str: None,
+            methods: HashSet::from_iter(
+                vec![Method::GET, Method::HEAD,
+                     Method::POST, Method::OPTIONS, Method::PUT,
+                     Method::PATCH, Method::DELETE].into_iter()),
+            headers: AllOrSome::All,
+            expose_hdrs: None,
+            max_age: None,
+            preflight: true,
+            send_wildcard: false,
+            supports_credentials: false,
+            vary_header: true,
+        }
+    }
+}
+
+impl Cors {
+    pub fn build() -> CorsBuilder {
+        CorsBuilder {
+            cors: Some(Cors {
+                origins: AllOrSome::All,
+                origins_str: None,
+                methods: HashSet::new(),
+                headers: AllOrSome::All,
+                expose_hdrs: None,
+                max_age: None,
+                preflight: true,
+                send_wildcard: false,
+                supports_credentials: false,
+                vary_header: true,
+            }),
+            methods: false,
+            error: None,
+            expose_hdrs: HashSet::new(),
+        }
+    }
+
+    /// This method register cors middleware with resource and
+    /// adds route for *OPTIONS* preflight requests.
+    ///
+    /// It is possible to register *Cors* middleware with `Resource::middleware()`
+    /// method, but in that case *Cors* middleware wont be able to handle *OPTIONS*
+    /// requests.
+    pub fn register<S: 'static>(self, resource: &mut Resource<S>) {
+        resource.method(Method::OPTIONS).h(HTTPOk);
+        resource.middleware(self);
+    }
+
+    fn validate_origin<S>(&self, req: &mut HttpRequest<S>) -> Result<(), CorsError> {
+        if let Some(hdr) = req.headers().get(header::ORIGIN) {
+            if let Ok(origin) = hdr.to_str() {
+                return match self.origins {
+                    AllOrSome::All => Ok(()),
+                    AllOrSome::Some(ref allowed_origins) => {
+                        allowed_origins
+                            .get(origin)
+                            .and_then(|_| Some(()))
+                            .ok_or_else(|| CorsError::OriginNotAllowed)
+                    }
+                };
+            }
+            Err(CorsError::BadOrigin)
+        } else {
+            return match self.origins {
+                AllOrSome::All => Ok(()),
+                _ => Err(CorsError::MissingOrigin)
+            }
+        }
+    }
+
+    fn validate_allowed_method<S>(&self, req: &mut HttpRequest<S>) -> Result<(), CorsError> {
+        if let Some(hdr) = req.headers().get(header::ACCESS_CONTROL_REQUEST_METHOD) {
+            if let Ok(meth) = hdr.to_str() {
+                if let Ok(method) = Method::try_from(meth) {
+                    return self.methods.get(&method)
+                        .and_then(|_| Some(()))
+                        .ok_or_else(|| CorsError::MethodNotAllowed);
+                }
+            }
+            Err(CorsError::BadRequestMethod)
+        } else {
+            Err(CorsError::MissingRequestMethod)
+        }
+    }
+
+    fn validate_allowed_headers<S>(&self, req: &mut HttpRequest<S>) -> Result<(), CorsError> {
+        match self.headers {
+            AllOrSome::All => Ok(()),
+            AllOrSome::Some(ref allowed_headers) => {
+                if let Some(hdr) = req.headers().get(header::ACCESS_CONTROL_REQUEST_HEADERS) {
+                    if let Ok(headers) = hdr.to_str() {
+                        let mut hdrs = HashSet::new();
+                        for hdr in headers.split(',') {
+                            match HeaderName::try_from(hdr.trim()) {
+                                Ok(hdr) => hdrs.insert(hdr),
+                                Err(_) => return Err(CorsError::BadRequestHeaders)
+                            };
+                        }
+
+                        if !hdrs.is_empty() && !hdrs.is_subset(allowed_headers) {
+                            return Err(CorsError::HeadersNotAllowed)
+                        }
+                        return Ok(())
+                    }
+                    Err(CorsError::BadRequestHeaders)
+                } else {
+                    Err(CorsError::MissingRequestHeaders)
+                }
+            }
+        }
+    }
+}
+
+impl<S> Middleware<S> for Cors {
+
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
+        if self.preflight && Method::OPTIONS == *req.method() {
+            self.validate_origin(req)?;
+            self.validate_allowed_method(req)?;
+            self.validate_allowed_headers(req)?;
+
+            // allowed headers
+            let headers = if let Some(headers) = self.headers.as_ref() {
+                Some(HeaderValue::try_from(&headers.iter().fold(
+                    String::new(), |s, v| s + "," + v.as_str()).as_str()[1..]).unwrap())
+            } else if let Some(hdr) = req.headers().get(header::ACCESS_CONTROL_REQUEST_HEADERS) {
+                Some(hdr.clone())
+            } else {
+                None
+            };
+
+            Ok(Started::Response(
+                HTTPOk.build()
+                    .if_some(self.max_age.as_ref(), |max_age, resp| {
+                        let _ = resp.header(
+                            header::ACCESS_CONTROL_MAX_AGE, format!("{}", max_age).as_str());})
+                    .if_some(headers, |headers, resp| {
+                        let _ = resp.header(header::ACCESS_CONTROL_ALLOW_HEADERS, headers); })
+                    .if_true(self.origins.is_all(), |resp| {
+                        if self.send_wildcard {
+                            resp.header(header::ACCESS_CONTROL_ALLOW_ORIGIN, "*");
+                        } else {
+                            let origin = req.headers().get(header::ORIGIN).unwrap();
+                            resp.header(
+                                header::ACCESS_CONTROL_ALLOW_ORIGIN, origin.clone());
+                        }
+                    })
+                    .if_true(self.origins.is_some(), |resp| {
+                        resp.header(
+                            header::ACCESS_CONTROL_ALLOW_ORIGIN,
+                            self.origins_str.as_ref().unwrap().clone());
+                    })
+                    .if_true(self.supports_credentials, |resp| {
+                        resp.header(header::ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");
+                    })
+                    .header(
+                        header::ACCESS_CONTROL_ALLOW_METHODS,
+                        &self.methods.iter().fold(
+                            String::new(), |s, v| s + "," + v.as_str()).as_str()[1..])
+                    .finish()
+                    .unwrap()))
+        } else {
+            self.validate_origin(req)?;
+
+            Ok(Started::Done)
+        }
+    }
+
+    fn response(&self, req: &mut HttpRequest<S>, mut resp: HttpResponse) -> Result<Response> {
+        match self.origins {
+            AllOrSome::All => {
+                if self.send_wildcard {
+                    resp.headers_mut().insert(
+                        header::ACCESS_CONTROL_ALLOW_ORIGIN, HeaderValue::from_static("*"));
+                } else {
+                    let origin = req.headers().get(header::ORIGIN).unwrap();
+                    resp.headers_mut().insert(
+                        header::ACCESS_CONTROL_ALLOW_ORIGIN, origin.clone());
+                }
+            }
+            AllOrSome::Some(_) => {
+                resp.headers_mut().insert(
+                    header::ACCESS_CONTROL_ALLOW_ORIGIN,
+                    self.origins_str.as_ref().unwrap().clone());
+            }
+        }
+
+        if let Some(ref expose) = self.expose_hdrs {
+            resp.headers_mut().insert(
+                header::ACCESS_CONTROL_EXPOSE_HEADERS,
+                HeaderValue::try_from(expose.as_str()).unwrap());
+        }
+        if self.supports_credentials {
+            resp.headers_mut().insert(
+                header::ACCESS_CONTROL_ALLOW_CREDENTIALS, HeaderValue::from_static("true"));
+        }
+        if self.vary_header {
+            let value = if let Some(hdr) = resp.headers_mut().get(header::VARY) {
+                let mut val: Vec<u8> = Vec::with_capacity(hdr.as_bytes().len() + 8);
+                val.extend(hdr.as_bytes());
+                val.extend(b", Origin");
+                HeaderValue::try_from(&val[..]).unwrap()
+            } else {
+                HeaderValue::from_static("Origin")
+            };
+            resp.headers_mut().insert(header::VARY, value);
+        }
+        Ok(Response::Done(resp))
+    }
+}
+
+/// Structure that follows the builder pattern for building `Cors` middleware structs.
+///
+/// To construct a cors:
+///
+///   1. Call [`Cors::build`](struct.Cors.html#method.build) to start building.
+///   2. Use any of the builder methods to set fields in the backend.
+///   3. Call [finish](struct.Cors.html#method.finish) to retrieve the constructed backend.
+///
+/// # Example
+///
+/// ```rust
+/// # extern crate http;
+/// # extern crate actix_web;
+/// use http::header;
+/// use actix_web::middleware::cors;
+///
+/// # fn main() {
+/// let cors = cors::Cors::build()
+///     .allowed_origin("https://www.rust-lang.org/")
+///     .allowed_methods(vec!["GET", "POST"])
+///     .allowed_headers(vec![header::AUTHORIZATION, header::ACCEPT])
+///     .allowed_header(header::CONTENT_TYPE)
+///     .max_age(3600)
+///     .finish().unwrap();
+/// # }
+/// ```
+pub struct CorsBuilder {
+    cors: Option<Cors>,
+    methods: bool,
+    error: Option<http::Error>,
+    expose_hdrs: HashSet<HeaderName>,
+}
+
+fn cors<'a>(parts: &'a mut Option<Cors>, err: &Option<http::Error>) -> Option<&'a mut Cors> {
+    if err.is_some() {
+        return None
+    }
+    parts.as_mut()
+}
+
+impl CorsBuilder {
+
+    /// Add an origin that are allowed to make requests.
+    /// Will be verified against the `Origin` request header.
+    ///
+    /// When `All` is set, and `send_wildcard` is set, "*" will be sent in
+    /// the `Access-Control-Allow-Origin` response header. Otherwise, the client's `Origin` request
+    /// header will be echoed back in the `Access-Control-Allow-Origin` response header.
+    ///
+    /// When `Some` is set, the client's `Origin` request header will be checked in a
+    /// case-sensitive manner.
+    ///
+    /// This is the `list of origins` in the
+    /// [Resource Processing Model](https://www.w3.org/TR/cors/#resource-processing-model).
+    ///
+    /// Defaults to `All`.
+    /// ```
+    pub fn allowed_origin(&mut self, origin: &str) -> &mut CorsBuilder {
+        if let Some(cors) = cors(&mut self.cors, &self.error) {
+            match Uri::try_from(origin) {
+                Ok(_) => {
+                    if cors.origins.is_all() {
+                        cors.origins = AllOrSome::Some(HashSet::new());
+                    }
+                    if let AllOrSome::Some(ref mut origins) = cors.origins {
+                        origins.insert(origin.to_owned());
+                    }
+                }
+                Err(e) => {
+                    self.error = Some(e.into());
+                }
+            }
+        }
+        self
+    }
+
+    /// Set a list of methods which the allowed origins are allowed to access for
+    /// requests.
+    ///
+    /// This is the `list of methods` in the
+    /// [Resource Processing Model](https://www.w3.org/TR/cors/#resource-processing-model).
+    ///
+    /// Defaults to `[GET, HEAD, POST, OPTIONS, PUT, PATCH, DELETE]`
+    pub fn allowed_methods<U, M>(&mut self, methods: U) -> &mut CorsBuilder
+        where U: IntoIterator<Item=M>, Method: HttpTryFrom<M>
+    {
+        self.methods = true;
+        if let Some(cors) = cors(&mut self.cors, &self.error) {
+            for m in methods {
+                match Method::try_from(m) {
+                    Ok(method) => {
+                        cors.methods.insert(method);
+                    },
+                    Err(e) => {
+                        self.error = Some(e.into());
+                        break
+                    }
+                }
+            };
+        }
+        self
+    }
+
+    /// Set an allowed header
+    pub fn allowed_header<H>(&mut self, header: H) -> &mut CorsBuilder
+        where HeaderName: HttpTryFrom<H>
+    {
+        if let Some(cors) = cors(&mut self.cors, &self.error) {
+            match HeaderName::try_from(header) {
+                Ok(method) => {
+                    if cors.headers.is_all() {
+                        cors.headers = AllOrSome::Some(HashSet::new());
+                    }
+                    if let AllOrSome::Some(ref mut headers) = cors.headers {
+                        headers.insert(method);
+                    }
+                }
+                Err(e) => self.error = Some(e.into()),
+            }
+        }
+        self
+    }
+
+    /// Set a list of header field names which can be used when
+    /// this resource is accessed by allowed origins.
+    ///
+    /// If `All` is set, whatever is requested by the client in `Access-Control-Request-Headers`
+    /// will be echoed back in the `Access-Control-Allow-Headers` header.
+    ///
+    /// This is the `list of headers` in the
+    /// [Resource Processing Model](https://www.w3.org/TR/cors/#resource-processing-model).
+    ///
+    /// Defaults to `All`.
+    pub fn allowed_headers<U, H>(&mut self, headers: U) -> &mut CorsBuilder
+        where U: IntoIterator<Item=H>, HeaderName: HttpTryFrom<H>
+    {
+        if let Some(cors) = cors(&mut self.cors, &self.error) {
+            for h in headers {
+                match HeaderName::try_from(h) {
+                    Ok(method) => {
+                        if cors.headers.is_all() {
+                            cors.headers = AllOrSome::Some(HashSet::new());
+                        }
+                        if let AllOrSome::Some(ref mut headers) = cors.headers {
+                            headers.insert(method);
+                        }
+                    }
+                    Err(e) => {
+                        self.error = Some(e.into());
+                        break
+                    }
+                }
+            };
+        }
+        self
+    }
+
+    /// Set a list of headers which are safe to expose to the API of a CORS API specification.
+    /// This corresponds to the `Access-Control-Expose-Headers` response header.
+    ///
+    /// This is the `list of exposed headers` in the
+    /// [Resource Processing Model](https://www.w3.org/TR/cors/#resource-processing-model).
+    ///
+    /// This defaults to an empty set.
+    pub fn expose_headers<U, H>(&mut self, headers: U) -> &mut CorsBuilder
+        where U: IntoIterator<Item=H>, HeaderName: HttpTryFrom<H>
+    {
+        for h in headers {
+            match HeaderName::try_from(h) {
+                Ok(method) => {
+                    self.expose_hdrs.insert(method);
+                },
+                Err(e) => {
+                    self.error = Some(e.into());
+                    break
+                }
+            }
+        }
+        self
+    }
+
+    /// Set a maximum time for which this CORS request maybe cached.
+    /// This value is set as the `Access-Control-Max-Age` header.
+    ///
+    /// This defaults to `None` (unset).
+    pub fn max_age(&mut self, max_age: usize) -> &mut CorsBuilder {
+        if let Some(cors) = cors(&mut self.cors, &self.error) {
+            cors.max_age = Some(max_age)
+        }
+        self
+    }
+
+    /// Set a wildcard origins
+    ///
+    /// If send widlcard is set and the `allowed_origins` parameter is `All`, a wildcard
+    /// `Access-Control-Allow-Origin` response header is sent, rather than the request’s
+    /// `Origin` header.
+    ///
+    /// This is the `supports credentials flag` in the
+    /// [Resource Processing Model](https://www.w3.org/TR/cors/#resource-processing-model).
+    ///
+    /// This **CANNOT** be used in conjunction with `allowed_origins` set to `All` and
+    /// `allow_credentials` set to `true`. Depending on the mode of usage, this will either result
+    /// in an `Error::CredentialsWithWildcardOrigin` error during actix launch or runtime.
+    ///
+    /// Defaults to `false`.
+    pub fn send_wildcard(&mut self) -> &mut CorsBuilder {
+        if let Some(cors) = cors(&mut self.cors, &self.error) {
+            cors.send_wildcard = true
+        }
+        self
+    }
+
+    /// Allows users to make authenticated requests
+    ///
+    /// If true, injects the `Access-Control-Allow-Credentials` header in responses.
+    /// This allows cookies and credentials to be submitted across domains.
+    ///
+    /// This option cannot be used in conjuction with an `allowed_origin` set to `All`
+    /// and `send_wildcards` set to `true`.
+    ///
+    /// Defaults to `false`.
+    pub fn supports_credentials(&mut self) -> &mut CorsBuilder {
+        if let Some(cors) = cors(&mut self.cors, &self.error) {
+            cors.supports_credentials = true
+        }
+        self
+    }
+
+    /// Disable `Vary` header support.
+    ///
+    /// When enabled the header `Vary: Origin` will be returned as per the W3
+    /// implementation guidelines.
+    ///
+    /// Setting this header when the `Access-Control-Allow-Origin` is
+    /// dynamically generated (e.g. when there is more than one allowed
+    /// origin, and an Origin than '*' is returned) informs CDNs and other
+    /// caches that the CORS headers are dynamic, and cannot be cached.
+    ///
+    /// By default `vary` header support is enabled.
+    pub fn disable_vary_header(&mut self) -> &mut CorsBuilder {
+        if let Some(cors) = cors(&mut self.cors, &self.error) {
+            cors.vary_header = false
+        }
+        self
+    }
+
+    /// Disable *preflight* request support.
+    ///
+    /// When enabled cors middleware automatically handles *OPTIONS* request.
+    /// This is useful application level middleware.
+    ///
+    /// By default *preflight* support is enabled.
+    pub fn disable_preflight(&mut self) -> &mut CorsBuilder {
+        if let Some(cors) = cors(&mut self.cors, &self.error) {
+            cors.preflight = false
+        }
+        self
+    }
+
+    /// Finishes building and returns the built `Cors` instance.
+    pub fn finish(&mut self) -> Result<Cors, CorsBuilderError> {
+        if !self.methods {
+            self.allowed_methods(vec![Method::GET, Method::HEAD,
+                                    Method::POST, Method::OPTIONS, Method::PUT,
+                                    Method::PATCH, Method::DELETE]);
+        }
+
+        if let Some(e) = self.error.take() {
+            return Err(CorsBuilderError::ParseError(e))
+        }
+
+        let mut cors = self.cors.take().expect("cannot reuse CorsBuilder");
+
+        if cors.supports_credentials && cors.send_wildcard && cors.origins.is_all() {
+            return Err(CorsBuilderError::CredentialsWithWildcardOrigin)
+        }
+
+        if let AllOrSome::Some(ref origins) = cors.origins {
+            let s = origins.iter().fold(String::new(), |s, v| s + &format!("{}", v));
+            cors.origins_str = Some(HeaderValue::try_from(s.as_str()).unwrap());
+        }
+
+        if !self.expose_hdrs.is_empty() {
+            cors.expose_hdrs = Some(
+                self.expose_hdrs.iter().fold(
+                    String::new(), |s, v| s + v.as_str())[1..].to_owned());
+        }
+        Ok(cors)
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test::TestRequest;
+
+    impl Started {
+        fn is_done(&self) -> bool {
+            match *self {
+                Started::Done => true,
+                _ => false,
+            }
+        }
+        fn response(self) -> HttpResponse {
+            match self {
+                Started::Response(resp) => resp,
+                _ => panic!(),
+            }
+        }
+    }
+    impl Response {
+        fn response(self) -> HttpResponse {
+            match self {
+                Response::Done(resp) => resp,
+                _ => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    #[should_panic(expected = "CredentialsWithWildcardOrigin")]
+    fn cors_validates_illegal_allow_credentials() {
+        Cors::build()
+            .supports_credentials()
+            .send_wildcard()
+            .finish()
+            .unwrap();
+    }
+
+    #[test]
+    fn validate_origin_allows_all_origins() {
+        let cors = Cors::default();
+        let mut req = TestRequest::with_header(
+            "Origin", "https://www.example.com").finish();
+
+        assert!(cors.start(&mut req).ok().unwrap().is_done())
+    }
+
+    #[test]
+    fn test_preflight() {
+        let mut cors = Cors::build()
+            .send_wildcard()
+            .max_age(3600)
+            .allowed_methods(vec![Method::GET, Method::OPTIONS, Method::POST])
+            .allowed_headers(vec![header::AUTHORIZATION, header::ACCEPT])
+            .allowed_header(header::CONTENT_TYPE)
+            .finish().unwrap();
+
+        let mut req = TestRequest::with_header(
+            "Origin", "https://www.example.com")
+            .method(Method::OPTIONS)
+            .finish();
+
+        assert!(cors.start(&mut req).is_err());
+
+        let mut req = TestRequest::with_header("Origin", "https://www.example.com")
+            .header(header::ACCESS_CONTROL_REQUEST_METHOD, "put")
+            .method(Method::OPTIONS)
+            .finish();
+
+        assert!(cors.start(&mut req).is_err());
+
+        let mut req = TestRequest::with_header("Origin", "https://www.example.com")
+            .header(header::ACCESS_CONTROL_REQUEST_METHOD, "POST")
+            .header(header::ACCESS_CONTROL_REQUEST_HEADERS, "AUTHORIZATION,ACCEPT")
+            .method(Method::OPTIONS)
+            .finish();
+
+        let resp = cors.start(&mut req).unwrap().response();
+        assert_eq!(
+            &b"*"[..],
+            resp.headers().get(header::ACCESS_CONTROL_ALLOW_ORIGIN).unwrap().as_bytes());
+        assert_eq!(
+            &b"3600"[..],
+            resp.headers().get(header::ACCESS_CONTROL_MAX_AGE).unwrap().as_bytes());
+        //assert_eq!(
+        //    &b"authorization,accept,content-type"[..],
+        //    resp.headers().get(header::ACCESS_CONTROL_ALLOW_HEADERS).unwrap().as_bytes());
+        //assert_eq!(
+        //    &b"POST,GET,OPTIONS"[..],
+        //    resp.headers().get(header::ACCESS_CONTROL_ALLOW_METHODS).unwrap().as_bytes());
+
+        cors.preflight = false;
+        assert!(cors.start(&mut req).unwrap().is_done());
+    }
+
+    #[test]
+    #[should_panic(expected = "MissingOrigin")]
+    fn test_validate_missing_origin() {
+        let cors = Cors::build()
+            .allowed_origin("https://www.example.com").finish().unwrap();
+
+        let mut req = HttpRequest::default();
+        cors.start(&mut req).unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "OriginNotAllowed")]
+    fn test_validate_not_allowed_origin() {
+        let cors = Cors::build()
+            .allowed_origin("https://www.example.com").finish().unwrap();
+
+        let mut req = TestRequest::with_header("Origin", "https://www.unknown.com")
+            .method(Method::GET)
+            .finish();
+        cors.start(&mut req).unwrap();
+    }
+
+    #[test]
+    fn test_validate_origin() {
+        let cors = Cors::build()
+            .allowed_origin("https://www.example.com").finish().unwrap();
+
+        let mut req = TestRequest::with_header("Origin", "https://www.example.com")
+            .method(Method::GET)
+            .finish();
+
+        assert!(cors.start(&mut req).unwrap().is_done());
+    }
+
+    #[test]
+    fn test_response() {
+        let cors = Cors::build()
+            .send_wildcard()
+            .disable_preflight()
+            .max_age(3600)
+            .allowed_methods(vec![Method::GET, Method::OPTIONS, Method::POST])
+            .allowed_headers(vec![header::AUTHORIZATION, header::ACCEPT])
+            .allowed_header(header::CONTENT_TYPE)
+            .finish().unwrap();
+
+        let mut req = TestRequest::with_header(
+            "Origin", "https://www.example.com")
+            .method(Method::OPTIONS)
+            .finish();
+
+        let resp: HttpResponse = HTTPOk.into();
+        let resp = cors.response(&mut req, resp).unwrap().response();
+        assert_eq!(
+            &b"*"[..],
+            resp.headers().get(header::ACCESS_CONTROL_ALLOW_ORIGIN).unwrap().as_bytes());
+        assert_eq!(
+            &b"Origin"[..],
+            resp.headers().get(header::VARY).unwrap().as_bytes());
+
+        let resp: HttpResponse = HTTPOk.build()
+            .header(header::VARY, "Accept")
+            .finish().unwrap();
+        let resp = cors.response(&mut req, resp).unwrap().response();
+        assert_eq!(
+            &b"Accept, Origin"[..],
+            resp.headers().get(header::VARY).unwrap().as_bytes());
+
+        let cors = Cors::build()
+            .disable_vary_header()
+            .allowed_origin("https://www.example.com")
+            .finish().unwrap();
+        let resp: HttpResponse = HTTPOk.into();
+        let resp = cors.response(&mut req, resp).unwrap().response();
+        assert_eq!(
+            &b"https://www.example.com"[..],
+            resp.headers().get(header::ACCESS_CONTROL_ALLOW_ORIGIN).unwrap().as_bytes());
+    }
+}

src/middleware/defaultheaders.rs

@@ -0,0 +1,129 @@
+//! Default response headers
+use http::{HeaderMap, HttpTryFrom};
+use http::header::{HeaderName, HeaderValue, CONTENT_TYPE};
+
+use error::Result;
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
+use middleware::{Response, Middleware};
+
+/// `Middleware` for setting default response headers.
+///
+/// This middleware does not set header if response headers already contains it.
+///
+/// ```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(|_| httpcodes::HTTPOk);
+///              r.method(Method::HEAD).f(|_| httpcodes::HTTPMethodNotAllowed);
+///         })
+///         .finish();
+/// }
+/// ```
+pub struct DefaultHeaders{
+    ct: bool,
+    headers: HeaderMap,
+}
+
+impl DefaultHeaders {
+    pub fn build() -> DefaultHeadersBuilder {
+        DefaultHeadersBuilder{ct: false, headers: Some(HeaderMap::new())}
+    }
+}
+
+impl<S> Middleware<S> for DefaultHeaders {
+
+    fn response(&self, _: &mut HttpRequest<S>, mut resp: HttpResponse) -> Result<Response> {
+        for (key, value) in self.headers.iter() {
+            if !resp.headers().contains_key(key) {
+                resp.headers_mut().insert(key, value.clone());
+            }
+        }
+        // default content-type
+        if self.ct && !resp.headers().contains_key(CONTENT_TYPE) {
+            resp.headers_mut().insert(
+                CONTENT_TYPE, HeaderValue::from_static("application/octet-stream"));
+        }
+        Ok(Response::Done(resp))
+    }
+}
+
+/// Structure that follows the builder pattern for building `DefaultHeaders` middleware.
+#[derive(Debug)]
+pub struct DefaultHeadersBuilder {
+    ct: bool,
+    headers: Option<HeaderMap>,
+}
+
+impl DefaultHeadersBuilder {
+
+    /// Set a header.
+    #[inline]
+    #[cfg_attr(feature = "cargo-clippy", allow(match_wild_err_arm))]
+    pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
+        where HeaderName: HttpTryFrom<K>,
+              HeaderValue: HttpTryFrom<V>
+    {
+        if let Some(ref mut headers) = self.headers {
+            match HeaderName::try_from(key) {
+                Ok(key) => {
+                    match HeaderValue::try_from(value) {
+                        Ok(value) => { headers.append(key, value); }
+                        Err(_) => panic!("Can not create header value"),
+                    }
+                },
+                Err(_) => panic!("Can not create header name"),
+            };
+        }
+        self
+    }
+
+    /// Set *CONTENT-TYPE* header if response does not contain this header.
+    pub fn content_type(&mut self) -> &mut Self {
+        self.ct = true;
+        self
+    }
+
+    /// Finishes building and returns the built `DefaultHeaders` middleware.
+    pub fn finish(&mut self) -> DefaultHeaders {
+        let headers = self.headers.take().expect("cannot reuse middleware builder");
+        DefaultHeaders{ ct: self.ct, headers: headers }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::header::CONTENT_TYPE;
+
+    #[test]
+    fn test_default_headers() {
+        let mw = DefaultHeaders::build()
+            .header(CONTENT_TYPE, "0001")
+            .finish();
+
+        let mut req = HttpRequest::default();
+
+        let resp = HttpResponse::Ok().finish().unwrap();
+        let resp = match mw.response(&mut req, resp) {
+            Ok(Response::Done(resp)) => resp,
+            _ => panic!(),
+        };
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
+
+        let resp = HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish().unwrap();
+        let resp = match mw.response(&mut req, resp) {
+            Ok(Response::Done(resp)) => resp,
+            _ => panic!(),
+        };
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0002");
+    }
+}

src/middleware/logger.rs

@@ -0,0 +1,366 @@
+//! Request logging middleware
+use std::env;
+use std::fmt;
+use std::fmt::{Display, Formatter};
+
+use libc;
+use time;
+use regex::Regex;
+
+use error::Result;
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
+use middleware::{Middleware, Started, Finished};
+
+/// `Middleware` for logging request and response info to the terminal.
+///
+/// ## 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() {
+///     let app = Application::new()
+///         .middleware(Logger::default())
+///         .middleware(Logger::new("%a %{User-Agent}i"))
+///         .finish();
+/// }
+/// ```
+///
+/// ## 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']
+///
+pub struct Logger {
+    format: Format,
+}
+
+impl Logger {
+    /// Create `Logger` middleware with the specified `format`.
+    pub fn new(format: &str) -> Logger {
+        Logger { format: Format::new(format) }
+    }
+}
+
+impl Default for Logger {
+    /// Create `Logger` middleware with format:
+    ///
+    /// ```ignore
+    /// %a %t "%r" %s %b "%{Referer}i" "%{User-Agent}i" %T
+    /// ```
+    fn default() -> Logger {
+        Logger { format: Format::default() }
+    }
+}
+
+struct StartTime(time::Tm);
+
+impl Logger {
+
+    fn log<S>(&self, req: &mut HttpRequest<S>, resp: &HttpResponse) {
+        let entry_time = req.extensions().get::<StartTime>().unwrap().0;
+
+        let render = |fmt: &mut Formatter| {
+            for unit in &self.format.0 {
+                unit.render(fmt, req, resp, entry_time)?;
+            }
+            Ok(())
+        };
+        info!("{}", FormatDisplay(&render));
+    }
+}
+
+impl<S> Middleware<S> for Logger {
+
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
+        req.extensions().insert(StartTime(time::now()));
+        Ok(Started::Done)
+    }
+
+    fn finish(&self, req: &mut HttpRequest<S>, resp: &HttpResponse) -> Finished {
+        self.log(req, resp);
+        Finished::Done
+    }
+}
+
+/// A formatting style for the `Logger`, consisting of multiple
+/// `FormatText`s concatenated into one line.
+#[derive(Clone)]
+#[doc(hidden)]
+struct Format(Vec<FormatText>);
+
+impl Default for Format {
+    /// Return the default formatting style for the `Logger`:
+    fn default() -> Format {
+        Format::new(r#"%a %t "%r" %s %b "%{Referer}i" "%{User-Agent}i" %T"#)
+    }
+}
+
+impl Format {
+    /// Create a `Format` from a format string.
+    ///
+    /// Returns `None` if the format string syntax is incorrect.
+    pub fn new(s: &str) -> Format {
+        trace!("Access log format: {}", s);
+        let fmt = Regex::new(r"%(\{([A-Za-z0-9\-_]+)\}([ioe])|[atPrsbTD]?)").unwrap();
+
+        let mut idx = 0;
+        let mut results = Vec::new();
+        for cap in fmt.captures_iter(s) {
+            let m = cap.get(0).unwrap();
+            let pos = m.start();
+            if idx != pos {
+                results.push(FormatText::Str(s[idx..pos].to_owned()));
+            }
+            idx = m.end();
+
+            if let Some(key) = cap.get(2) {
+                results.push(
+                    match cap.get(3).unwrap().as_str() {
+                        "i" => FormatText::RequestHeader(key.as_str().to_owned()),
+                        "o" => FormatText::ResponseHeader(key.as_str().to_owned()),
+                        "e" => FormatText::EnvironHeader(key.as_str().to_owned()),
+                        _ => unreachable!(),
+                    })
+            } else {
+                let m = cap.get(1).unwrap();
+                results.push(
+                    match m.as_str() {
+                        "%" => FormatText::Percent,
+                        "a" => FormatText::RemoteAddr,
+                        "t" => FormatText::RequestTime,
+                        "P" => FormatText::Pid,
+                        "r" => FormatText::RequestLine,
+                        "s" => FormatText::ResponseStatus,
+                        "b" => FormatText::ResponseSize,
+                        "T" => FormatText::Time,
+                        "D" => FormatText::TimeMillis,
+                        _ => FormatText::Str(m.as_str().to_owned()),
+                    }
+                );
+            }
+        }
+        if idx != s.len() {
+            results.push(FormatText::Str(s[idx..].to_owned()));
+        }
+
+        Format(results)
+    }
+}
+
+/// A string of text to be logged. This is either one of the data
+/// fields supported by the `Logger`, or a custom `String`.
+#[doc(hidden)]
+#[derive(Debug, Clone)]
+pub enum FormatText {
+    Str(String),
+    Pid,
+    Percent,
+    RequestLine,
+    RequestTime,
+    ResponseStatus,
+    ResponseSize,
+    Time,
+    TimeMillis,
+    RemoteAddr,
+    RequestHeader(String),
+    ResponseHeader(String),
+    EnvironHeader(String),
+}
+
+impl FormatText {
+
+    fn render<S>(&self, fmt: &mut Formatter,
+                 req: &HttpRequest<S>,
+                 resp: &HttpResponse,
+                 entry_time: time::Tm) -> Result<(), fmt::Error>
+    {
+        match *self {
+            FormatText::Str(ref string) => fmt.write_str(string),
+            FormatText::Percent => "%".fmt(fmt),
+            FormatText::RequestLine => {
+                if req.query_string().is_empty() {
+                    fmt.write_fmt(format_args!(
+                        "{} {} {:?}",
+                        req.method(), req.path(), req.version()))
+                } else {
+                    fmt.write_fmt(format_args!(
+                        "{} {}?{} {:?}",
+                        req.method(), req.path(), req.query_string(), req.version()))
+                }
+            },
+            FormatText::ResponseStatus => resp.status().as_u16().fmt(fmt),
+            FormatText::ResponseSize => resp.response_size().fmt(fmt),
+            FormatText::Pid => unsafe{libc::getpid().fmt(fmt)},
+            FormatText::Time => {
+                let response_time = time::now() - entry_time;
+                let response_time = response_time.num_seconds() as f64 +
+                    (response_time.num_nanoseconds().unwrap_or(0) as f64) / 1000000000.0;
+
+                fmt.write_fmt(format_args!("{:.6}", response_time))
+            },
+            FormatText::TimeMillis => {
+                let response_time = time::now() - entry_time;
+                let response_time_ms = (response_time.num_seconds() * 1000) as f64 +
+                    (response_time.num_nanoseconds().unwrap_or(0) as f64) / 1000000.0;
+
+                fmt.write_fmt(format_args!("{:.6}", response_time_ms))
+            },
+            FormatText::RemoteAddr => {
+                if let Some(remote) = req.connection_info().remote() {
+                    return remote.fmt(fmt);
+                } else {
+                    "-".fmt(fmt)
+                }
+            }
+            FormatText::RequestTime => {
+                entry_time.strftime("[%d/%b/%Y:%H:%M:%S %z]")
+                    .unwrap()
+                    .fmt(fmt)
+            }
+            FormatText::RequestHeader(ref name) => {
+                let s = if let Some(val) = req.headers().get(name) {
+                    if let Ok(s) = val.to_str() { s } else { "-" }
+                } else {
+                    "-"
+                };
+                fmt.write_fmt(format_args!("{}", s))
+            }
+            FormatText::ResponseHeader(ref name) => {
+                let s = if let Some(val) = resp.headers().get(name) {
+                    if let Ok(s) = val.to_str() { s } else { "-" }
+                } else {
+                    "-"
+                };
+                fmt.write_fmt(format_args!("{}", s))
+            }
+            FormatText::EnvironHeader(ref name) => {
+                if let Ok(val) = env::var(name) {
+                    fmt.write_fmt(format_args!("{}", val))
+                } else {
+                    "-".fmt(fmt)
+                }
+            }
+        }
+    }
+}
+
+pub(crate) struct FormatDisplay<'a>(
+    &'a Fn(&mut Formatter) -> Result<(), fmt::Error>);
+
+impl<'a> fmt::Display for FormatDisplay<'a> {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+        (self.0)(fmt)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use Body;
+    use super::*;
+    use std::str::FromStr;
+    use time;
+    use http::{Method, Version, StatusCode, Uri};
+    use http::header::{self, HeaderMap};
+
+    #[test]
+    fn test_logger() {
+        let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test");
+
+        let mut headers = HeaderMap::new();
+        headers.insert(header::USER_AGENT, header::HeaderValue::from_static("ACTIX-WEB"));
+        let mut req = HttpRequest::new(
+            Method::GET, Uri::from_str("/").unwrap(), Version::HTTP_11, headers, None);
+        let resp = HttpResponse::build(StatusCode::OK)
+            .header("X-Test", "ttt")
+            .force_close().body(Body::Empty).unwrap();
+
+        match logger.start(&mut req) {
+            Ok(Started::Done) => (),
+            _ => panic!(),
+        };
+        match logger.finish(&mut req, &resp) {
+            Finished::Done => (),
+            _ => panic!(),
+        }
+        let entry_time = time::now();
+        let render = |fmt: &mut Formatter| {
+            for unit in logger.format.0.iter() {
+                unit.render(fmt, &req, &resp, entry_time)?;
+            }
+            Ok(())
+        };
+        let s = format!("{}", FormatDisplay(&render));
+        assert!(s.contains("ACTIX-WEB ttt"));
+    }
+
+    #[test]
+    fn test_default_format() {
+        let format = Format::default();
+
+        let mut headers = HeaderMap::new();
+        headers.insert(header::USER_AGENT, header::HeaderValue::from_static("ACTIX-WEB"));
+        let req = HttpRequest::new(
+            Method::GET, Uri::from_str("/").unwrap(), Version::HTTP_11, headers, None);
+        let resp = HttpResponse::build(StatusCode::OK)
+            .force_close().body(Body::Empty).unwrap();
+        let entry_time = time::now();
+
+        let render = |fmt: &mut Formatter| {
+            for unit in format.0.iter() {
+                unit.render(fmt, &req, &resp, entry_time)?;
+            }
+            Ok(())
+        };
+        let s = format!("{}", FormatDisplay(&render));
+        assert!(s.contains("GET / HTTP/1.1"));
+        assert!(s.contains("200 0"));
+        assert!(s.contains("ACTIX-WEB"));
+
+        let req = HttpRequest::new(
+            Method::GET, Uri::from_str("/?test").unwrap(),
+            Version::HTTP_11, HeaderMap::new(), None);
+        let resp = HttpResponse::build(StatusCode::OK)
+            .force_close().body(Body::Empty).unwrap();
+        let entry_time = time::now();
+
+        let render = |fmt: &mut Formatter| {
+            for unit in format.0.iter() {
+                unit.render(fmt, &req, &resp, entry_time)?;
+            }
+            Ok(())
+        };
+        let s = format!("{}", FormatDisplay(&render));
+        assert!(s.contains("GET /?test HTTP/1.1"));
+    }
+}

src/middleware/mod.rs

@@ -0,0 +1,64 @@
+//! Middlewares
+use futures::Future;
+
+use error::{Error, Result};
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
+
+mod logger;
+mod session;
+mod defaultheaders;
+pub mod cors;
+pub use self::logger::Logger;
+pub use self::defaultheaders::{DefaultHeaders, DefaultHeadersBuilder};
+pub use self::session::{RequestSession, Session, SessionImpl, SessionBackend, SessionStorage,
+                        CookieSessionError, CookieSessionBackend, CookieSessionBackendBuilder};
+
+/// Middleware start result
+pub enum Started {
+    /// Execution completed
+    Done,
+    /// New http response got generated. If middleware generates response
+    /// handler execution halts.
+    Response(HttpResponse),
+    /// Execution completed, runs future to completion.
+    Future(Box<Future<Item=Option<HttpResponse>, Error=Error>>),
+}
+
+/// Middleware execution result
+pub enum Response {
+    /// New http response got generated
+    Done(HttpResponse),
+    /// Result is a future that resolves to a new http response
+    Future(Box<Future<Item=HttpResponse, Error=Error>>),
+}
+
+/// Middleware finish result
+pub enum Finished {
+    /// Execution completed
+    Done,
+    /// Execution completed, but run future to completion
+    Future(Box<Future<Item=(), Error=Error>>),
+}
+
+/// Middleware definition
+#[allow(unused_variables)]
+pub trait Middleware<S>: 'static {
+
+    /// 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> {
+        Ok(Started::Done)
+    }
+
+    /// Method is called when handler returns response,
+    /// but before sending http message to peer.
+    fn response(&self, req: &mut HttpRequest<S>, resp: HttpResponse) -> Result<Response> {
+        Ok(Response::Done(resp))
+    }
+
+    /// Method is called after body stream get sent to peer.
+    fn finish(&self, req: &mut HttpRequest<S>, resp: &HttpResponse) -> Finished {
+        Finished::Done
+    }
+}

src/middleware/session.rs

@@ -0,0 +1,445 @@
+#![allow(dead_code, unused_imports, unused_variables)]
+
+use std::any::Any;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::marker::PhantomData;
+use std::collections::HashMap;
+
+use serde_json;
+use serde_json::error::Error as JsonError;
+use serde::{Serialize, Deserialize};
+use http::header::{self, HeaderValue};
+use cookie::{CookieJar, Cookie, Key};
+use futures::Future;
+use futures::future::{FutureResult, ok as FutOk, err as FutErr};
+
+use error::{Result, Error, ResponseError};
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
+use middleware::{Middleware, Started, Response};
+
+/// The helper trait to obtain your session data from a request.
+///
+/// ```rust
+/// use actix_web::*;
+/// use actix_web::middleware::RequestSession;
+///
+/// fn index(mut req: HttpRequest) -> Result<&'static str> {
+///     // access session data
+///     if let Some(count) = req.session().get::<i32>("counter")? {
+///         req.session().set("counter", count+1)?;
+///     } else {
+///         req.session().set("counter", 1)?;
+///     }
+///
+///     Ok("Welcome!")
+/// }
+/// # fn main() {}
+/// ```
+pub trait RequestSession {
+    fn session(&mut self) -> Session;
+}
+
+impl<S> RequestSession for HttpRequest<S> {
+
+    fn session(&mut self) -> Session {
+        if let Some(s_impl) = self.extensions().get_mut::<Arc<SessionImplBox>>() {
+            if let Some(s) = Arc::get_mut(s_impl) {
+                return Session(s.0.as_mut())
+            }
+        }
+        //Session(&mut DUMMY)
+        unreachable!()
+    }
+}
+
+/// The high-level interface you use to modify session data.
+///
+/// Session object could be obtained with
+/// [`RequestSession::session`](trait.RequestSession.html#tymethod.session)
+/// method. `RequestSession` trait is implemented for `HttpRequest`.
+///
+/// ```rust
+/// use actix_web::*;
+/// use actix_web::middleware::RequestSession;
+///
+/// fn index(mut req: HttpRequest) -> Result<&'static str> {
+///     // access session data
+///     if let Some(count) = req.session().get::<i32>("counter")? {
+///         req.session().set("counter", count+1)?;
+///     } else {
+///         req.session().set("counter", 1)?;
+///     }
+///
+///     Ok("Welcome!")
+/// }
+/// # fn main() {}
+/// ```
+pub struct Session<'a>(&'a mut SessionImpl);
+
+impl<'a> Session<'a> {
+
+    /// Get a `value` from the session.
+    pub fn get<T: Deserialize<'a>>(&'a self, key: &str) -> Result<Option<T>> {
+        if let Some(s) = self.0.get(key) {
+            Ok(Some(serde_json::from_str(s)?))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Set a `value` from the session.
+    pub fn set<T: Serialize>(&'a mut self, key: &str, value: T) -> Result<()> {
+        self.0.set(key, serde_json::to_string(&value)?);
+        Ok(())
+    }
+
+    /// Remove value from the session.
+    pub fn remove(&'a mut self, key: &str) {
+        self.0.remove(key)
+    }
+
+    /// Clear the session.
+    pub fn clear(&'a mut self) {
+        self.0.clear()
+    }
+}
+
+struct SessionImplBox(Box<SessionImpl>);
+
+#[doc(hidden)]
+unsafe impl Send for SessionImplBox {}
+#[doc(hidden)]
+unsafe impl Sync for SessionImplBox {}
+
+/// Session storage middleware
+///
+/// ```rust
+/// # extern crate actix;
+/// # extern crate actix_web;
+/// # use actix_web::middleware::{SessionStorage, CookieSessionBackend};
+/// use actix_web::*;
+///
+/// fn main() {
+///    let app = Application::new().middleware(
+///        SessionStorage::new(                      // <- create session middleware
+///            CookieSessionBackend::build(&[0; 32]) // <- create cookie session backend
+///               .secure(false)
+///               .finish())
+///    );
+/// }
+/// ```
+pub struct SessionStorage<T, S>(T, PhantomData<S>);
+
+impl<S, T: SessionBackend<S>> SessionStorage<T, S> {
+    /// Create session storage
+    pub fn new(backend: T) -> SessionStorage<T, S> {
+        SessionStorage(backend, PhantomData)
+    }
+}
+
+impl<S: 'static, T: SessionBackend<S>> Middleware<S> for SessionStorage<T, S> {
+
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
+        let mut req = req.clone();
+
+        let fut = self.0.from_request(&mut req)
+            .then(move |res| {
+                match res {
+                    Ok(sess) => {
+                        req.extensions().insert(Arc::new(SessionImplBox(Box::new(sess))));
+                        FutOk(None)
+                    },
+                    Err(err) => FutErr(err)
+                }
+            });
+        Ok(Started::Future(Box::new(fut)))
+    }
+
+    fn response(&self, req: &mut HttpRequest<S>, resp: HttpResponse) -> Result<Response> {
+        if let Some(s_box) = req.extensions().remove::<Arc<SessionImplBox>>() {
+            s_box.0.write(resp)
+        } else {
+            Ok(Response::Done(resp))
+        }
+    }
+}
+
+/// A simple key-value storage interface that is internally used by `Session`.
+#[doc(hidden)]
+pub trait SessionImpl: 'static {
+
+    fn get(&self, key: &str) -> Option<&str>;
+
+    fn set(&mut self, key: &str, value: String);
+
+    fn remove(&mut self, key: &str);
+
+    fn clear(&mut self);
+
+    /// Write session to storage backend.
+    fn write(&self, resp: HttpResponse) -> Result<Response>;
+}
+
+/// Session's storage backend trait definition.
+#[doc(hidden)]
+pub trait SessionBackend<S>: Sized + 'static {
+    type Session: SessionImpl;
+    type ReadFuture: Future<Item=Self::Session, Error=Error>;
+
+    /// Parse the session from request and load data from a storage backend.
+    fn from_request(&self, request: &mut HttpRequest<S>) -> Self::ReadFuture;
+}
+
+/// Dummy session impl, does not do anything
+struct DummySessionImpl;
+
+static DUMMY: DummySessionImpl = DummySessionImpl;
+
+impl SessionImpl for DummySessionImpl {
+
+    fn get(&self, key: &str) -> Option<&str> {
+        None
+    }
+    fn set(&mut self, key: &str, value: String) {}
+    fn remove(&mut self, key: &str) {}
+    fn clear(&mut self) {}
+    fn write(&self, resp: HttpResponse) -> Result<Response> {
+        Ok(Response::Done(resp))
+    }
+}
+
+/// Session that uses signed cookies as session storage
+pub struct CookieSession {
+    changed: bool,
+    state: HashMap<String, String>,
+    inner: Rc<CookieSessionInner>,
+}
+
+/// Errors that can occur during handling cookie session
+#[derive(Fail, Debug)]
+pub enum CookieSessionError {
+    /// Size of the serialized session is greater than 4000 bytes.
+    #[fail(display="Size of the serialized session is greater than 4000 bytes.")]
+    Overflow,
+    /// Fail to serialize session.
+    #[fail(display="Fail to serialize session")]
+    Serialize(JsonError),
+}
+
+impl ResponseError for CookieSessionError {}
+
+impl SessionImpl for CookieSession {
+
+    fn get(&self, key: &str) -> Option<&str> {
+        if let Some(s) = self.state.get(key) {
+            Some(s)
+        } else {
+            None
+        }
+    }
+
+    fn set(&mut self, key: &str, value: String) {
+        self.changed = true;
+        self.state.insert(key.to_owned(), value);
+    }
+
+    fn remove(&mut self, key: &str) {
+        self.changed = true;
+        self.state.remove(key);
+    }
+
+    fn clear(&mut self) {
+        self.changed = true;
+        self.state.clear()
+    }
+
+    fn write(&self, mut resp: HttpResponse) -> Result<Response> {
+        if self.changed {
+            let _ = self.inner.set_cookie(&mut resp, &self.state);
+        }
+        Ok(Response::Done(resp))
+    }
+}
+
+struct CookieSessionInner {
+    key: Key,
+    name: String,
+    path: String,
+    domain: Option<String>,
+    secure: bool,
+}
+
+impl CookieSessionInner {
+
+    fn new(key: &[u8]) -> CookieSessionInner {
+        CookieSessionInner {
+            key: Key::from_master(key),
+            name: "actix-session".to_owned(),
+            path: "/".to_owned(),
+            domain: None,
+            secure: true }
+    }
+
+    fn set_cookie(&self, resp: &mut HttpResponse, state: &HashMap<String, String>) -> Result<()> {
+        let value = serde_json::to_string(&state)
+            .map_err(CookieSessionError::Serialize)?;
+        if value.len() > 4064 {
+            return Err(CookieSessionError::Overflow.into())
+        }
+
+        let mut cookie = Cookie::new(self.name.clone(), value);
+        cookie.set_path(self.path.clone());
+        cookie.set_secure(self.secure);
+        cookie.set_http_only(true);
+
+        if let Some(ref domain) = self.domain {
+            cookie.set_domain(domain.clone());
+        }
+
+        let mut jar = CookieJar::new();
+        jar.signed(&self.key).add(cookie);
+
+        for cookie in jar.delta() {
+            let val = HeaderValue::from_str(&cookie.to_string())?;
+            resp.headers_mut().append(header::SET_COOKIE, val);
+        }
+
+        Ok(())
+    }
+
+    fn load<S>(&self, req: &mut HttpRequest<S>) -> HashMap<String, String> {
+        if let Ok(cookies) = req.cookies() {
+            for cookie in cookies {
+                if cookie.name() == self.name {
+                    let mut jar = CookieJar::new();
+                    jar.add_original(cookie.clone());
+                    if let Some(cookie) = jar.signed(&self.key).get(&self.name) {
+                        if let Ok(val) = serde_json::from_str(cookie.value()) {
+                            return val;
+                        }
+                    }
+                }
+            }
+        }
+        HashMap::new()
+    }
+}
+
+/// Use signed cookies as session storage.
+///
+/// `CookieSessionBackend` 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).
+///
+/// Constructor panics if key length is less than 32 bytes.
+pub struct CookieSessionBackend(Rc<CookieSessionInner>);
+
+impl CookieSessionBackend {
+
+    /// Construct new `CookieSessionBackend` instance.
+    ///
+    /// Panics if key length is less than 32 bytes.
+    pub fn new(key: &[u8]) -> CookieSessionBackend {
+        CookieSessionBackend(
+            Rc::new(CookieSessionInner::new(key)))
+    }
+
+    /// Creates a new `CookieSessionBackendBuilder` instance from the given key.
+    ///
+    /// Panics if key length is less than 32 bytes.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use actix_web::middleware::CookieSessionBackend;
+    ///
+    /// let backend = CookieSessionBackend::build(&[0; 32]).finish();
+    /// ```
+    pub fn build(key: &[u8]) -> CookieSessionBackendBuilder {
+        CookieSessionBackendBuilder::new(key)
+    }
+}
+
+impl<S> SessionBackend<S> for CookieSessionBackend {
+
+    type Session = CookieSession;
+    type ReadFuture = FutureResult<CookieSession, Error>;
+
+    fn from_request(&self, req: &mut HttpRequest<S>) -> Self::ReadFuture {
+        let state = self.0.load(req);
+        FutOk(
+            CookieSession {
+                changed: false,
+                state: state,
+                inner: Rc::clone(&self.0),
+            })
+    }
+}
+
+/// Structure that follows the builder pattern for building `CookieSessionBackend` structs.
+///
+/// To construct a backend:
+///
+///   1. Call [`CookieSessionBackend::build`](struct.CookieSessionBackend.html#method.build) to start building.
+///   2. Use any of the builder methods to set fields in the backend.
+///   3. Call [finish](#method.finish) to retrieve the constructed backend.
+///
+/// # Example
+///
+/// ```rust
+/// # extern crate actix_web;
+/// use actix_web::middleware::CookieSessionBackend;
+///
+/// # fn main() {
+/// let backend: CookieSessionBackend = CookieSessionBackend::build(&[0; 32])
+///     .domain("www.rust-lang.org")
+///     .name("actix_session")
+///     .path("/")
+///     .secure(true)
+///     .finish();
+/// # }
+/// ```
+pub struct CookieSessionBackendBuilder(CookieSessionInner);
+
+impl CookieSessionBackendBuilder {
+    pub fn new(key: &[u8]) -> CookieSessionBackendBuilder {
+        CookieSessionBackendBuilder(
+            CookieSessionInner::new(key))
+    }
+
+    /// Sets the `path` field in the session cookie being built.
+    pub fn path<S: Into<String>>(mut self, value: S) -> CookieSessionBackendBuilder {
+        self.0.path = value.into();
+        self
+    }
+
+    /// Sets the `name` field in the session cookie being built.
+    pub fn name<S: Into<String>>(mut self, value: S) -> CookieSessionBackendBuilder {
+        self.0.name = value.into();
+        self
+    }
+
+    /// Sets the `domain` field in the session cookie being built.
+    pub fn domain<S: Into<String>>(mut self, value: S) -> CookieSessionBackendBuilder {
+        self.0.domain = Some(value.into());
+        self
+    }
+
+    /// Sets the `secure` field in the session cookie being built.
+    pub fn secure(mut self, value: bool) -> CookieSessionBackendBuilder {
+        self.0.secure = value;
+        self
+    }
+
+    /// Finishes building and returns the built `CookieSessionBackend`.
+    pub fn finish(self) -> CookieSessionBackend {
+        CookieSessionBackend(Rc::new(self.0))
+    }
+}

src/multipart.rs

@@ -1,8 +1,7 @@
-//! Multipart requests support.
+//! Multipart requests support
 use std::{cmp, fmt};
 use std::rc::Rc;
 use std::cell::RefCell;
-use std::error::Error;
 use std::marker::PhantomData;
 
 use mime;
@@ -10,72 +9,15 @@ use httparse;
 use bytes::Bytes;
 use http::HttpTryFrom;
 use http::header::{self, HeaderMap, HeaderName, HeaderValue};
-use futures::{Async, Stream, Poll};
+use futures::{Async, Future, Stream, Poll};
 use futures::task::{Task, current as current_task};
 
-use error::ParseError;
-use payload::{Payload, PayloadError};
+use error::{ParseError, PayloadError, MultipartError};
+use payload::Payload;
+use httprequest::HttpRequest;
 
 const MAX_HEADERS: usize = 32;
 
-/// A set of errors that can occur during parsing multipart streams.
-#[derive(Debug)]
-pub enum MultipartError {
-    /// Content-Type header is not found
-    NoContentType,
-    /// Can not parse Content-Type header
-    ParseContentType,
-    /// Multipart boundary is not found
-    Boundary,
-    /// Error during field parsing
-    Parse(ParseError),
-    /// Payload error
-    Payload(PayloadError),
-}
-
-impl fmt::Display for MultipartError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            MultipartError::Parse(ref e) => fmt::Display::fmt(e, f),
-            MultipartError::Payload(ref e) => fmt::Display::fmt(e, f),
-            ref e => f.write_str(e.description()),
-        }
-    }
-}
-
-impl Error for MultipartError {
-    fn description(&self) -> &str {
-        match *self {
-            MultipartError::NoContentType => "No Content-type header found",
-            MultipartError::ParseContentType => "Can not parse Content-Type header",
-            MultipartError::Boundary => "Multipart boundary is not found",
-            MultipartError::Parse(ref e) => e.description(),
-            MultipartError::Payload(ref e) => e.description(),
-        }
-    }
-
-    fn cause(&self) -> Option<&Error> {
-        match *self {
-            MultipartError::Parse(ref error) => Some(error),
-            MultipartError::Payload(ref error) => Some(error),
-            _ => None,
-        }
-    }
-}
-
-
-impl From<ParseError> for MultipartError {
-    fn from(err: ParseError) -> MultipartError {
-        MultipartError::Parse(err)
-    }
-}
-
-impl From<PayloadError> for MultipartError {
-    fn from(err: PayloadError) -> MultipartError {
-        MultipartError::Payload(err)
-    }
-}
-
 /// The server-side implementation of `multipart/form-data` requests.
 ///
 /// This will parse the incoming stream into `MultipartItem` instances via its
@@ -85,7 +27,8 @@ impl From<PayloadError> for MultipartError {
 #[derive(Debug)]
 pub struct Multipart {
     safety: Safety,
-    inner: Rc<RefCell<InnerMultipart>>,
+    error: Option<MultipartError>,
+    inner: Option<Rc<RefCell<InnerMultipart>>>,
 }
 
 ///
@@ -125,17 +68,32 @@ struct InnerMultipart {
 }
 
 impl Multipart {
+
     /// Create multipart instance for boundary.
     pub fn new(boundary: String, payload: Payload) -> Multipart {
         Multipart {
+            error: None,
             safety: Safety::new(),
-            inner: Rc::new(RefCell::new(
+            inner: Some(Rc::new(RefCell::new(
                 InnerMultipart {
                     payload: PayloadRef::new(payload),
                     boundary: boundary,
                     state: InnerState::FirstBoundary,
                     item: InnerMultipartItem::None,
-                }))
+                })))
+        }
+    }
+
+    /// Create multipart instance for request.
+    pub fn from_request<S>(req: &mut HttpRequest<S>) -> Multipart {
+        match Multipart::boundary(req.headers()) {
+            Ok(boundary) => Multipart::new(boundary, req.payload().clone()),
+            Err(err) =>
+                Multipart {
+                    error: Some(err),
+                    safety: Safety::new(),
+                    inner: None,
+                }
         }
     }
 
@@ -166,8 +124,10 @@ impl Stream for Multipart {
     type Error = MultipartError;
 
     fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.safety.current() {
-            self.inner.borrow_mut().poll(&self.safety)
+        if let Some(err) = self.error.take() {
+            Err(err)
+        } else if self.safety.current() {
+            self.inner.as_mut().unwrap().borrow_mut().poll(&self.safety)
         } else {
             Ok(Async::NotReady)
         }
@@ -178,7 +138,7 @@ impl InnerMultipart {
 
     fn read_headers(payload: &mut Payload) -> Poll<HeaderMap, MultipartError>
     {
-        match payload.readuntil(b"\r\n\r\n")? {
+        match payload.readuntil(b"\r\n\r\n").poll()? {
             Async::NotReady => Ok(Async::NotReady),
             Async::Ready(bytes) => {
                 let mut hdrs = [httparse::EMPTY_HEADER; MAX_HEADERS];
@@ -209,7 +169,7 @@ impl InnerMultipart {
     fn read_boundary(payload: &mut Payload, boundary: &str) -> Poll<bool, MultipartError>
     {
         // TODO: need to read epilogue
-        match payload.readline()? {
+        match payload.readline().poll()? {
             Async::NotReady => Ok(Async::NotReady),
             Async::Ready(chunk) => {
                 if chunk.len() == boundary.len() + 4 &&
@@ -234,7 +194,7 @@ impl InnerMultipart {
     {
         let mut eof = false;
         loop {
-            if let Async::Ready(chunk) = payload.readline()? {
+            if let Async::Ready(chunk) = payload.readline().poll()? {
                 if chunk.is_empty() {
                     //ValueError("Could not find starting boundary %r"
                     //% (self._boundary))
@@ -386,7 +346,9 @@ impl InnerMultipart {
 
                 Ok(Async::Ready(Some(
                     MultipartItem::Nested(
-                        Multipart{safety: safety.clone(), inner: inner}))))
+                        Multipart{safety: safety.clone(),
+                                  error: None,
+                                  inner: Some(inner)}))))
             } else {
                 let field = Rc::new(RefCell::new(InnerField::new(
                     self.payload.clone(), self.boundary.clone(), &headers)?));
@@ -415,10 +377,6 @@ pub struct Field {
     safety: Safety,
 }
 
-/// A field's chunk
-#[derive(PartialEq, Debug)]
-pub struct FieldChunk(pub Bytes);
-
 impl Field {
 
     fn new(safety: Safety, headers: HeaderMap,
@@ -441,7 +399,7 @@ impl Field {
 }
 
 impl Stream for Field {
-    type Item = FieldChunk;
+    type Item = Bytes;
     type Error = MultipartError;
 
     fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
@@ -511,15 +469,15 @@ impl InnerField {
         if *size == 0 {
             Ok(Async::Ready(None))
         } else {
-            match payload.readany() {
+            match payload.readany().poll() {
                 Ok(Async::NotReady) => Ok(Async::NotReady),
                 Ok(Async::Ready(None)) => Ok(Async::Ready(None)),
                 Ok(Async::Ready(Some(mut chunk))) => {
-                    let len = cmp::min(chunk.0.len() as u64, *size);
+                    let len = cmp::min(chunk.len() as u64, *size);
                     *size -= len;
-                    let ch = chunk.0.split_to(len as usize);
-                    if !chunk.0.is_empty() {
-                        payload.unread_data(chunk.0);
+                    let ch = chunk.split_to(len as usize);
+                    if !chunk.is_empty() {
+                        payload.unread_data(chunk);
                     }
                     Ok(Async::Ready(Some(ch)))
                 },
@@ -532,12 +490,12 @@ impl InnerField {
     /// The `Content-Length` header for body part is not necessary.
     fn read_stream(payload: &mut Payload, boundary: &str) -> Poll<Option<Bytes>, MultipartError>
     {
-        match payload.readuntil(b"\r")? {
+        match payload.readuntil(b"\r").poll()? {
             Async::NotReady => Ok(Async::NotReady),
             Async::Ready(mut chunk) => {
                 if chunk.len() == 1 {
                     payload.unread_data(chunk);
-                    match payload.readexactly(boundary.len() + 4)? {
+                    match payload.readexactly(boundary.len() + 4).poll()? {
                         Async::NotReady => Ok(Async::NotReady),
                         Async::Ready(chunk) => {
                             if &chunk[..2] == b"\r\n" && &chunk[2..4] == b"--" &&
@@ -560,13 +518,13 @@ impl InnerField {
         }
     }
 
-    fn poll(&mut self, s: &Safety) -> Poll<Option<FieldChunk>, MultipartError> {
+    fn poll(&mut self, s: &Safety) -> Poll<Option<Bytes>, MultipartError> {
         if self.payload.is_none() {
             return Ok(Async::Ready(None))
         }
         if self.eof {
             if let Some(payload) = self.payload.as_ref().unwrap().get_mut(s) {
-                match payload.readline()? {
+                match payload.readline().poll()? {
                     Async::NotReady =>
                         return Ok(Async::NotReady),
                     Async::Ready(chunk) => {
@@ -592,10 +550,10 @@ impl InnerField {
 
             match res {
                 Async::NotReady => Async::NotReady,
-                Async::Ready(Some(bytes)) => Async::Ready(Some(FieldChunk(bytes))),
+                Async::Ready(Some(bytes)) => Async::Ready(Some(bytes)),
                 Async::Ready(None) => {
                     self.eof = true;
-                    match payload.readline()? {
+                    match payload.readline().poll()? {
                         Async::NotReady => Async::NotReady,
                         Async::Ready(chunk) => {
                             assert_eq!(
@@ -707,7 +665,7 @@ mod tests {
     use bytes::Bytes;
     use futures::future::{lazy, result};
     use tokio_core::reactor::Core;
-    use payload::Payload;
+    use payload::{Payload, PayloadWriter};
 
     #[test]
     fn test_boundary() {
@@ -765,7 +723,6 @@ mod tests {
                 "abbc761f78ff4d7cb7573b5a23f96ef0".to_owned(), payload);
             match multipart.poll() {
                 Ok(Async::Ready(Some(item))) => {
-                    println!("{:?}", item);
                     match item {
                         MultipartItem::Field(mut field) => {
                             assert_eq!(field.content_type().type_(), mime::TEXT);
@@ -773,7 +730,7 @@ mod tests {
 
                             match field.poll() {
                                 Ok(Async::Ready(Some(chunk))) =>
-                                    assert_eq!(chunk.0, "test"),
+                                    assert_eq!(chunk, "test"),
                                 _ => unreachable!()
                             }
                             match field.poll() {
@@ -796,7 +753,7 @@ mod tests {
 
                             match field.poll() {
                                 Ok(Async::Ready(Some(chunk))) =>
-                                    assert_eq!(chunk.0, "data"),
+                                    assert_eq!(chunk, "data"),
                                 _ => unreachable!()
                             }
                             match field.poll() {

src/param.rs

@@ -0,0 +1,190 @@
+use std;
+use std::ops::Index;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::slice::Iter;
+use std::borrow::Cow;
+use smallvec::SmallVec;
+
+use error::{ResponseError, UriSegmentError, InternalError, ErrorBadRequest};
+
+
+/// A trait to abstract the idea of creating a new instance of a type from a path parameter.
+pub trait FromParam: Sized {
+    /// The associated error which can be returned from parsing.
+    type Err: ResponseError;
+
+    /// Parses a string `s` to return a value of this type.
+    fn from_param(s: &str) -> Result<Self, Self::Err>;
+}
+
+/// Route match information
+///
+/// If resource path contains variable patterns, `Params` stores this variables.
+#[derive(Debug)]
+pub struct Params<'a>(SmallVec<[(Cow<'a, str>, Cow<'a, str>); 3]>);
+
+impl<'a> Params<'a> {
+
+    pub(crate) fn new() -> Params<'a> {
+        Params(SmallVec::new())
+    }
+
+    pub(crate) fn clear(&mut self) {
+        self.0.clear();
+    }
+
+    pub(crate) fn add<N, V>(&mut self, name: N, value: V)
+        where N: Into<Cow<'a, str>>, V: Into<Cow<'a, str>>,
+    {
+        self.0.push((name.into(), value.into()));
+    }
+
+    /// Check if there are any matched patterns
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Get matched parameter by name without type conversion
+    pub fn get(&'a self, key: &str) -> Option<&'a str> {
+        for item in self.0.iter() {
+            if key == item.0 {
+                return Some(item.1.as_ref())
+            }
+        }
+        None
+    }
+
+    /// Get matched `FromParam` compatible parameter by name.
+    ///
+    /// If keyed parameter is not available empty string is used as default value.
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # use actix_web::*;
+    /// fn index(req: HttpRequest) -> Result<String> {
+    ///    let ivalue: isize = req.match_info().query("val")?;
+    ///    Ok(format!("isuze value: {:?}", ivalue))
+    /// }
+    /// # fn main() {}
+    /// ```
+    pub fn query<T: FromParam>(&'a self, key: &str) -> Result<T, <T as FromParam>::Err>
+    {
+        if let Some(s) = self.get(key) {
+            T::from_param(s)
+        } else {
+            T::from_param("")
+        }
+    }
+
+    /// Return iterator to items in parameter container
+    pub fn iter(&self) -> Iter<(Cow<'a, str>, Cow<'a, str>)> {
+        self.0.iter()
+    }
+}
+
+impl<'a, 'b, 'c: 'a> Index<&'b str> for &'c Params<'a> {
+    type Output = str;
+
+    fn index(&self, name: &'b str) -> &str {
+        self.get(name).expect("Value for parameter is not available")
+    }
+}
+
+/// Creates a `PathBuf` from a 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.
+impl FromParam for PathBuf {
+    type Err = UriSegmentError;
+
+    fn from_param(val: &str) -> Result<PathBuf, UriSegmentError> {
+        let mut buf = PathBuf::new();
+        for segment in val.split('/') {
+            if segment == ".." {
+                buf.pop();
+            } else if segment.starts_with('.') {
+                return Err(UriSegmentError::BadStart('.'))
+            } else if segment.starts_with('*') {
+                return Err(UriSegmentError::BadStart('*'))
+            } else if segment.ends_with(':') {
+                return Err(UriSegmentError::BadEnd(':'))
+            } else if segment.ends_with('>') {
+                return Err(UriSegmentError::BadEnd('>'))
+            } else if segment.ends_with('<') {
+                return Err(UriSegmentError::BadEnd('<'))
+            } else if segment.is_empty() {
+                continue
+            } else if cfg!(windows) && segment.contains('\\') {
+                return Err(UriSegmentError::BadChar('\\'))
+            } else {
+                buf.push(segment)
+            }
+        }
+
+        Ok(buf)
+    }
+}
+
+macro_rules! FROM_STR {
+    ($type:ty) => {
+        impl FromParam for $type {
+            type Err = InternalError<<$type as FromStr>::Err>;
+
+            fn from_param(val: &str) -> Result<Self, Self::Err> {
+                <$type as FromStr>::from_str(val).map_err(ErrorBadRequest)
+            }
+        }
+    }
+}
+
+FROM_STR!(u8);
+FROM_STR!(u16);
+FROM_STR!(u32);
+FROM_STR!(u64);
+FROM_STR!(usize);
+FROM_STR!(i8);
+FROM_STR!(i16);
+FROM_STR!(i32);
+FROM_STR!(i64);
+FROM_STR!(isize);
+FROM_STR!(f32);
+FROM_STR!(f64);
+FROM_STR!(String);
+FROM_STR!(std::net::IpAddr);
+FROM_STR!(std::net::Ipv4Addr);
+FROM_STR!(std::net::Ipv6Addr);
+FROM_STR!(std::net::SocketAddr);
+FROM_STR!(std::net::SocketAddrV4);
+FROM_STR!(std::net::SocketAddrV6);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::iter::FromIterator;
+
+    #[test]
+    fn test_path_buf() {
+        assert_eq!(PathBuf::from_param("/test/.tt"), Err(UriSegmentError::BadStart('.')));
+        assert_eq!(PathBuf::from_param("/test/*tt"), Err(UriSegmentError::BadStart('*')));
+        assert_eq!(PathBuf::from_param("/test/tt:"), Err(UriSegmentError::BadEnd(':')));
+        assert_eq!(PathBuf::from_param("/test/tt<"), Err(UriSegmentError::BadEnd('<')));
+        assert_eq!(PathBuf::from_param("/test/tt>"), Err(UriSegmentError::BadEnd('>')));
+        assert_eq!(PathBuf::from_param("/seg1/seg2/"),
+                   Ok(PathBuf::from_iter(vec!["seg1", "seg2"])));
+        assert_eq!(PathBuf::from_param("/seg1/../seg2/"),
+                   Ok(PathBuf::from_iter(vec!["seg2"])));
+    }
+}