First pass at Server section.

examples/server/Cargo.toml

@@ -2,9 +2,10 @@
 name = "server"
 version = "0.7.0"
 workspace = "../"
+edition = "2018"
 
 [dependencies]
-actix = "0.7"
-actix-web = "1.0"
+actix-rt = "0.2"
+actix-web = { version = "1.0", features = ["ssl"] }
 futures = "0.1"
 openssl = "0.10"

examples/server/rustfmt.toml

@@ -0,0 +1 @@
+max_width = 80

examples/server/src/ka.rs

@@ -1,14 +0,0 @@
-// <ka>
-use actix_web::{server, App, HttpResponse};
-
-fn main() {
-    server::new(|| App::new().resource("/", |r| r.f(|_| HttpResponse::Ok())))
-        .keep_alive(75); // <- Set keep-alive to 75 seconds
-
-    server::new(|| App::new().resource("/", |r| r.f(|_| HttpResponse::Ok())))
-        .keep_alive(server::KeepAlive::Tcp(75)); // <- Use `SO_KEEPALIVE` socket option.
-
-    server::new(|| App::new().resource("/", |r| r.f(|_| HttpResponse::Ok())))
-        .keep_alive(None); // <- Disable keep-alive
-}
-// </ka>

examples/server/src/ka_tp.rs

@@ -1,7 +1,7 @@
 // <example>
 use actix_web::{http, HttpRequest, HttpResponse};
 
-fn index(req: HttpRequest) -> HttpResponse {
+pub fn index(req: HttpRequest) -> HttpResponse {
     HttpResponse::Ok()
         .connection_type(http::ConnectionType::Close) // <- Close connection
         .force_close()                                // <- Alternative method

examples/server/src/keep_alive.rs

@@ -0,0 +1,20 @@
+// <keep-alive>
+use actix_web::{web, App, HttpResponse, HttpServer};
+
+fn main() {
+    HttpServer::new(|| {
+        App::new().route("/", web::get().to(|| HttpResponse::Ok()))
+    })
+    .keep_alive(75); // <- Set keep-alive to 75 seconds
+
+    HttpServer::new(|| {
+        App::new().route("/", web::get().to(|| HttpResponse::Ok()))
+    })
+    .keep_alive(server::KeepAlive::Tcp(75)); // <- Use `SO_KEEPALIVE` socket option.
+
+    HttpServer::new(|| {
+        App::new().route("/", web::get().to(|| HttpResponse::Ok()))
+    })
+    .keep_alive(None); // <- Disable keep-alive
+}
+// </keep-alive>

examples/server/src/keep_alive_tp.rs

@@ -0,0 +1,10 @@
+// <example>
+use actix_web::{http, HttpRequest, HttpResponse};
+
+fn index(req: HttpRequest) -> HttpResponse {
+    HttpResponse::Ok()
+        .connection_type(http::ConnectionType::Close) // <- Close connection
+        .force_close() // <- Alternative method
+        .finish()
+}
+// </example>

examples/server/src/main.rs

@@ -1,24 +1,21 @@
-extern crate actix;
-extern crate actix_web;
-extern crate futures;
-extern crate openssl;
-
-mod ka;
-mod ka_tp;
+mod keep_alive;
+mod keep_alive_tp;
 mod signals;
 mod ssl;
 mod workers;
 
 // <main>
-use actix_web::{server::HttpServer, App, HttpResponse};
+use actix_web::{web, App, HttpResponse, HttpServer};
 
 fn main() {
-    let sys = actix::System::new("guide");
+    let sys = actix_rt::System::new("example");
 
-    HttpServer::new(|| App::new().resource("/", |r| r.f(|_| HttpResponse::Ok())))
-        .bind("127.0.0.1:59080")
-        .unwrap()
-        .start();
+    HttpServer::new(|| {
+        App::new().route("/", web::get().to(|| HttpResponse::Ok()))
+    })
+    .bind("127.0.0.1:8088")
+    .unwrap()
+    .start();
 
     let _ = sys.run();
 }

examples/server/src/signals.rs

@@ -1,28 +1,41 @@
-use actix;
+use actix_rt;
 use futures::Future;
 
 // <signals>
-use actix_web::{server, App, HttpResponse};
+use actix_web::{web, App, HttpResponse, HttpServer};
 use std::sync::mpsc;
 use std::thread;
 
-fn main() {
+pub fn main() {
     let (tx, rx) = mpsc::channel();
 
     thread::spawn(move || {
-        let sys = actix::System::new("http-server");
-        let addr = server::new(|| {
-            App::new()
-                .resource("/", |r| r.f(|_| HttpResponse::Ok()))
+        let sys = actix_rt::System::new("http-server");
+
+        let addr = HttpServer::new(|| {
+            App::new().route("/", web::get().to(|| HttpResponse::Ok()))
         })
-            .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();
+        .bind("127.0.0.1:8088")
+        .unwrap()
+        .shutdown_timeout(60) // <- Set shutdown timeout to 60 seconds
+        .start();
+
         let _ = tx.send(addr);
         let _ = sys.run();
     });
 
     let addr = rx.recv().unwrap();
-    let _ = addr.send(server::StopServer { graceful: true }).wait(); // <- Send `StopServer` message to server.
+    let _ = addr
+        .pause()
+        .wait()
+        .map(|_| println!("`actix_server::ServerCommand::Pause`"));
+    let _ = addr
+        .resume()
+        .wait()
+        .map(|_| println!("`actix_server::ServerCommand::Resume`"));
+    let _ = addr
+        .stop(true)
+        .wait()
+        .map(|_| println!("`actix_server::ServerCommand::Stop`"));
 }
 // </signals>

examples/server/src/ssl.rs

@@ -1,22 +1,26 @@
 // <ssl>
-use actix_web::{server, App, HttpRequest, Responder};
+use actix_web::{web, App, HttpRequest, HttpServer, Responder};
 use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
 
-fn index(req: &HttpRequest) -> impl Responder {
+fn index(_req: HttpRequest) -> impl Responder {
     "Welcome!"
 }
 
-fn main() {
+pub fn main() {
     // load ssl keys
-    let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
+    let mut builder =
+        SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
     builder
         .set_private_key_file("key.pem", SslFiletype::PEM)
         .unwrap();
     builder.set_certificate_chain_file("cert.pem").unwrap();
 
-    server::new(|| App::new().resource("/index.html", |r| r.f(index)))
-        .bind_ssl("127.0.0.1:8080", builder)
+    HttpServer::new(|| App::new().route("/", web::get().to(index)))
+        .bind_ssl("127.0.0.1:8088", builder)
         .unwrap()
-        .run();
+        .run()
+        .unwrap();
 }
 // </ssl>
+//
+// sssl rust-tls

examples/server/src/workers.rs

@@ -1,8 +1,10 @@
 // <workers>
-use actix_web::{server::HttpServer, App, HttpResponse};
+use actix_web::{web, App, HttpResponse, HttpServer};
 
-fn main() {
-    HttpServer::new(|| App::new().resource("/", |r| r.f(|_| HttpResponse::Ok())))
-        .workers(4); // <- Start 4 workers
+pub fn main() {
+    HttpServer::new(|| {
+        App::new().route("/", web::get().to(|| HttpResponse::Ok()))
+    })
+    .workers(4); // <- Start 4 workers
 }
 // </workers>