First pass at Handlers chapter.

examples/Cargo.toml

@@ -9,4 +9,10 @@ members = [
   "request-routing",
   "server",
   "url-dispatch",
+  "responder-trait",
+  "either"
+]
+exclude = [
+  "request-handlers",
+  "async-handlers",
 ]

examples/async-handlers/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "async-handlers"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+actix-web = "0.7"
+futures = "0.1"
+bytes = "0.4"

examples/async-handlers/src/async_stream.rs

@@ -0,0 +1,24 @@
+fn is_error() -> bool {
+    true
+}
+
+// <main>
+use actix_web::{error, App, Error, HttpRequest, HttpResponse};
+use futures::future::{result, Future};
+
+fn index(
+    _req: &HttpRequest,
+) -> Result<Box<Future<Item = HttpResponse, Error = Error>>, Error> {
+    if is_error() {
+        Err(error::ErrorBadRequest("bad request"))
+    } else {
+        Ok(Box::new(result(Ok(HttpResponse::Ok()
+            .content_type("text/html")
+            .body(format!("Hello!"))))))
+    }
+}
+// </main>
+
+pub fn main() {
+    App::new().resource("/", |r| r.route().f(index)).finish();
+}

examples/async-handlers/src/main.rs

@@ -0,0 +1,25 @@
+mod async_stream;
+mod stream;
+// <main>
+use actix_web::{App, AsyncResponder, Error, HttpRequest, HttpResponse};
+use futures::future::{result, Future};
+
+fn index(_req: &HttpRequest) -> Box<Future<Item = HttpResponse, Error = Error>> {
+    result(Ok(HttpResponse::Ok()
+        .content_type("text/html")
+        .body(format!("Hello!"))))
+    .responder()
+}
+
+fn index2(_req: &HttpRequest) -> Box<Future<Item = &'static str, Error = Error>> {
+    result(Ok("Welcome!")).responder()
+}
+
+fn main() {
+    App::new()
+        .resource("/async", |r| r.route().a(index))
+        .resource("/", |r| r.route().a(index2))
+        // .resource("/", |r| r.route().f(async_stream::index))
+        .finish();
+}
+// </main>

examples/async-handlers/src/stream.rs

@@ -0,0 +1,17 @@
+// <main>
+use actix_web::{App, Body, HttpRequest, HttpResponse};
+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)))
+}
+
+pub fn main() {
+    App::new().resource("/async", |r| r.f(index)).finish();
+}
+// </main>

examples/either/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "either"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+actix-web = "1.0"
+futures = "0.1"

examples/either/src/main.rs

@@ -0,0 +1,29 @@
+// <main>
+use actix_web::{web, App, Either, Error, HttpRequest, HttpResponse};
+use futures::future::{ok, Future};
+
+type RegisterResult =
+    Either<HttpResponse, Box<Future<Item = HttpResponse, Error = Error>>>;
+
+fn index(_req: HttpRequest) -> RegisterResult {
+    if is_a_variant() {
+        // <- choose variant A
+        Either::A(HttpResponse::BadRequest().body("Bad data"))
+    } else {
+        Either::B(
+            // <- variant B
+            Box::new(ok(HttpResponse::Ok()
+                .content_type("text/html")
+                .body(format!("Hello!")))),
+        )
+    }
+}
+
+fn main() {
+    App::new().route("/", web::get().to(index));
+}
+// </main>
+
+fn is_a_variant() -> bool {
+    true
+}

examples/request-handlers/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "request-handlers"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+actix-web = "0.7"
+actix = "0.7"

examples/request-handlers/src/handlers_arc.rs

@@ -0,0 +1,34 @@
+// <arc>
+use actix_web::{dev::Handler, server, App, HttpRequest, HttpResponse};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+
+struct MyHandler(Arc<AtomicUsize>);
+
+impl<S> Handler<S> for MyHandler {
+    type Result = HttpResponse;
+
+    /// Handle request
+    fn handle(&self, _req: &HttpRequest<S>) -> Self::Result {
+        self.0.fetch_add(1, Ordering::Relaxed);
+        HttpResponse::Ok().into()
+    }
+}
+
+pub fn main() {
+    let sys = actix::System::new("example");
+
+    let inc = Arc::new(AtomicUsize::new(0));
+
+    server::new(move || {
+        let cloned = inc.clone();
+        App::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");
+    let _ = sys.run();
+}
+// </arc>

examples/request-handlers/src/main.rs

@@ -0,0 +1,25 @@
+mod handlers_arc;
+// <main>
+use actix_web::{dev::Handler, server, App, HttpRequest, HttpResponse};
+use std::cell::Cell;
+
+struct MyHandler(Cell<usize>);
+
+impl<S> Handler<S> for MyHandler {
+    type Result = HttpResponse;
+
+    /// Handle request
+    fn handle(&self, _req: &HttpRequest<S>) -> Self::Result {
+        let i = self.0.get();
+        self.0.set(i + 1);
+        HttpResponse::Ok().into()
+    }
+}
+
+fn main() {
+    server::new(|| App::new().resource("/", |r| r.h(MyHandler(Cell::new(0))))) //use r.h() to bind handler, not the r.f()
+        .bind("127.0.0.1:8088")
+        .unwrap()
+        .run();
+}
+// </main>

examples/responder-trait/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "responder-trait"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+actix-web = "1.0"
+serde = "1.0"
+serde_json = "1.0"

examples/responder-trait/src/main.rs

@@ -0,0 +1,37 @@
+// <main>
+use actix_web::{web, App, Error, HttpRequest, HttpResponse, HttpServer, Responder};
+use serde::Serialize;
+use serde_json;
+
+#[derive(Serialize)]
+struct MyObj {
+    name: &'static str,
+}
+
+// Responder
+impl Responder for MyObj {
+    type Error = Error;
+    type Future = Result<HttpResponse, Error>;
+
+    fn respond_to(self, _req: &HttpRequest) -> Self::Future {
+        let body = serde_json::to_string(&self)?;
+
+        // Create response and set content type
+        Ok(HttpResponse::Ok()
+            .content_type("application/json")
+            .body(body))
+    }
+}
+
+fn index(_req: HttpRequest) -> impl Responder {
+    MyObj { name: "user" }
+}
+
+fn main() {
+    HttpServer::new(|| App::new().route("/", web::get().to(index)))
+        .bind("127.0.0.1:8088")
+        .unwrap()
+        .run()
+        .unwrap();
+}
+// </main>