Middleware section is done-ish.

examples/middleware/src/default_headers.rs

@@ -1,16 +1,24 @@
 // <default-headers>
-use actix_web::{http, middleware, web, App, HttpResponse};
+use actix_web::{http, middleware, HttpResponse};
 
 pub fn main() {
-    App::new()
-        .wrap(middleware::DefaultHeaders::new().header("X-Version", "0.2"))
-        .service(
-            web::resource("/test")
-                .route(web::get().to(|| HttpResponse::Ok()))
-                .route(
-                    web::method(http::Method::HEAD)
-                        .to(|| HttpResponse::MethodNotAllowed()),
-                ),
-        );
+    use actix_web::{web, App, HttpServer};
+
+    HttpServer::new(|| {
+        App::new()
+            .wrap(middleware::DefaultHeaders::new().header("X-Version", "0.2"))
+            .service(
+                web::resource("/test")
+                    .route(web::get().to(|| HttpResponse::Ok()))
+                    .route(
+                        web::method(http::Method::HEAD)
+                            .to(|| HttpResponse::MethodNotAllowed()),
+                    ),
+            )
+    })
+    .bind("127.0.0.1:8088")
+    .unwrap()
+    .run()
+    .unwrap();
 }
 // </default-headers>

examples/middleware/src/errorhandler.rs

@@ -1,6 +1,6 @@
 // <error-handler>
 use actix_web::middleware::errhandlers::{ErrorHandlerResponse, ErrorHandlers};
-use actix_web::{dev, http, web, App, HttpResponse, Result};
+use actix_web::{dev, http, HttpResponse, Result};
 
 fn render_500<B>(mut res: dev::ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
     res.response_mut().headers_mut().insert(
@@ -11,15 +11,23 @@ fn render_500<B>(mut res: dev::ServiceResponse<B>) -> Result<ErrorHandlerRespons
 }
 
 pub fn main() {
-    App::new()
-        .wrap(
-            ErrorHandlers::new()
-                .handler(http::StatusCode::INTERNAL_SERVER_ERROR, render_500),
-        )
-        .service(
-            web::resource("/test")
-                .route(web::get().to(|| HttpResponse::Ok()))
-                .route(web::head().to(|| HttpResponse::MethodNotAllowed())),
-        );
+    use actix_web::{web, App, HttpServer};
+
+    HttpServer::new(|| {
+        App::new()
+            .wrap(
+                ErrorHandlers::new()
+                    .handler(http::StatusCode::INTERNAL_SERVER_ERROR, render_500),
+            )
+            .service(
+                web::resource("/test")
+                    .route(web::get().to(|| HttpResponse::Ok()))
+                    .route(web::head().to(|| HttpResponse::MethodNotAllowed())),
+            )
+    })
+    .bind("127.0.0.1:8088")
+    .unwrap()
+    .run()
+    .unwrap();
 }
 // </error-handler>

examples/middleware/src/logger.rs

@@ -1,14 +1,21 @@
 // <logger>
 use actix_web::middleware::Logger;
-use actix_web::App;
 use env_logger;
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     std::env::set_var("RUST_LOG", "actix_web=info");
     env_logger::init();
 
-    App::new()
-        .wrap(Logger::default())
-        .wrap(Logger::new("%a %{User-Agent}i"));
+    HttpServer::new(|| {
+        App::new()
+            .wrap(Logger::default())
+            .wrap(Logger::new("%a %{User-Agent}i"))
+    })
+    .bind("127.0.0.1:8088")
+    .unwrap()
+    .run()
+    .unwrap();
 }
 // </logger>

examples/middleware/src/main.rs

@@ -2,9 +2,10 @@ pub mod default_headers;
 pub mod errorhandler;
 pub mod logger;
 pub mod user_sessions;
-// <main>
+
+// <simple>
 use actix_service::{Service, Transform};
-use actix_web::{dev::ServiceRequest, dev::ServiceResponse, web, App, Error};
+use actix_web::{dev::ServiceRequest, dev::ServiceResponse, Error};
 use futures::future::{ok, FutureResult};
 use futures::{Future, Poll};
 
@@ -63,10 +64,19 @@ where
         }))
     }
 }
-// </main>
+// </simple>
+
 fn main() {
-    App::new().wrap(SayHi).service(
-        web::resource("/")
-            .to(|| "Hello, middleware! Check the console where the server is run."),
-    );
+    use actix_web::{web, App, HttpServer};
+
+    HttpServer::new(|| {
+        App::new().wrap(SayHi).service(
+            web::resource("/")
+                .to(|| "Hello, middleware! Check the console where the server is run."),
+        )
+    })
+    .bind("127.0.0.1:8088")
+    .unwrap()
+    .run()
+    .unwrap();
 }

examples/middleware/src/user_sessions.rs

@@ -1,37 +1,33 @@
 // <user-session>
 use actix_session::{CookieSession, Session};
-use actix_web::{middleware::Logger, web, App, HttpRequest, HttpServer, Result};
+use actix_web::{web, App, Error, HttpResponse, HttpServer};
 
-/// simple index handler with session
-fn index(session: Session, req: HttpRequest) -> Result<&'static str> {
-    println!("{:?}", req);
-
-    // RequestSession trait is used for session access
-    let mut counter = 1;
+pub fn index(session: Session) -> Result<HttpResponse, Error> {
+    // access session data
     if let Some(count) = session.get::<i32>("counter")? {
-        println!("SESSION value: {}", count);
-        counter = count + 1;
-        session.set("counter", counter)?;
+        session.set("counter", count + 1)?;
     } else {
-        session.set("counter", counter)?;
+        session.set("counter", 1)?;
     }
 
-    Ok("welcome!")
+    Ok(HttpResponse::Ok().body(format!(
+        "Count is {:?}!",
+        session.get::<i32>("counter")?.unwrap()
+    )))
 }
 
-pub fn main() -> std::io::Result<()> {
-    std::env::set_var("RUST_LOG", "actix_web=info");
-    env_logger::init();
-
+pub fn main() {
     HttpServer::new(|| {
         App::new()
-            // enable logger
-            .wrap(Logger::default())
-            // cookie session middleware
-            .wrap(CookieSession::signed(&[0; 32]).secure(false))
+            .wrap(
+                CookieSession::signed(&[0; 32]) // <- create cookie based session middleware
+                    .secure(false),
+            )
             .service(web::resource("/").to(index))
     })
-    .bind("127.0.0.1:8080")?
+    .bind("127.0.0.1:8088")
+    .unwrap()
     .run()
+    .unwrap();
 }
 // </user-session>