convert server examples

examples/Cargo.toml

@@ -2,4 +2,5 @@
 members = [
   "application",
   "getting-started",
+  "server",
 ]

examples/application/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "application"
-version = "0.1.0"
+version = "0.6.0"
+workspace = "../"
 
 [dependencies]
 actix-web = "0.6"

examples/application/src/main.rs

@@ -1,16 +1,16 @@
 #![allow(unused)]
 extern crate actix_web;
-use actix_web::{App, Responder, HttpRequest, HttpResponse, server, http::Method};
+use actix_web::{http::Method, server, App, HttpRequest, HttpResponse, Responder};
 
 mod state;
 
 fn make_app() {
-// <make_app>
-fn index(req: HttpRequest) -> impl Responder {
-    "Hello world!"
-}
+    // <make_app>
+    fn index(req: HttpRequest) -> impl Responder {
+        "Hello world!"
+    }
 
-let app = App::new()
+    let app = App::new()
     .prefix("/app")
     .resource("/index.html", |r| r.method(Method::GET).f(index))
     .finish()
@@ -19,18 +19,19 @@ let app = App::new()
 }
 
 fn run_server() {
-// <run_server>
-let server = server::new(|| vec![
-    App::new()
-        .prefix("/app1")
-        .resource("/", |r| r.f(|r| HttpResponse::Ok())),
-    App::new()
-        .prefix("/app2")
-        .resource("/", |r| r.f(|r| HttpResponse::Ok())),
-    App::new()
-        .resource("/", |r| r.f(|r| HttpResponse::Ok())),
-]);
-// </run_server>
+    // <run_server>
+    let server = server::new(|| {
+        vec![
+            App::new()
+                .prefix("/app1")
+                .resource("/", |r| r.f(|r| HttpResponse::Ok())),
+            App::new()
+                .prefix("/app2")
+                .resource("/", |r| r.f(|r| HttpResponse::Ok())),
+            App::new().resource("/", |r| r.f(|r| HttpResponse::Ok())),
+        ]
+    });
+    // </run_server>
 }
 
 fn main() {

examples/application/src/state.rs

@@ -1,6 +1,6 @@
 // <setup>
+use actix_web::{http, App, HttpRequest};
 use std::cell::Cell;
-use actix_web::{App, HttpRequest, http};
 
 // This struct represents state
 struct AppState {
@@ -9,51 +9,48 @@ struct AppState {
 
 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
+    req.state().counter.set(count); // <- store new count in state
 
-    format!("Request number: {}", count)       // <- response with count
+    format!("Request number: {}", count) // <- response with count
 }
 // </setup>
 
 fn make_app() {
-
-// <make_app>
-App::with_state(AppState { counter: Cell::new(0) })
+    // <make_app>
+    App::with_state(AppState { counter: Cell::new(0) })
     .resource("/", |r| r.method(http::Method::GET).f(index))
     .finish()
 // </make_app>
 ;
-
 }
 
-
-use std::thread;
 use actix_web::{server, HttpResponse};
+use std::thread;
 
 fn combine() {
-thread::spawn(|| {
-// <combine>
-struct State1;
-struct State2;
+    thread::spawn(|| {
+        // <combine>
+        struct State1;
+        struct State2;
 
-fn main() {
-    server::new(|| {
-        vec![
-            App::with_state(State1)
-                 .prefix("/app1")
-                 .resource("/", |r| r.f(|r| HttpResponse::Ok()))
-                 .boxed(),
-            App::with_state(State2)
-                 .prefix("/app2")
-                 .resource("/", |r| r.f(|r| HttpResponse::Ok()))
-                 .boxed()
-        ]
-    })
-        .bind("127.0.0.1:8080").unwrap()
-        .run()
-}
-// </combine>
-});
+        fn main() {
+            server::new(|| {
+                vec![
+                    App::with_state(State1)
+                        .prefix("/app1")
+                        .resource("/", |r| r.f(|r| HttpResponse::Ok()))
+                        .boxed(),
+                    App::with_state(State2)
+                        .prefix("/app2")
+                        .resource("/", |r| r.f(|r| HttpResponse::Ok()))
+                        .boxed(),
+                ]
+            }).bind("127.0.0.1:8080")
+                .unwrap()
+                .run()
+        }
+        // </combine>
+    });
 }
 
 pub fn test() {

examples/getting-started/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "getting-started"
-version = "0.1.0"
+version = "0.6.0"
+workspace = "../"
 
 [dependencies]
 actix-web = "0.6"

examples/getting-started/src/main.rs

@@ -1,6 +1,6 @@
 // <setup>
 extern crate actix_web;
-use actix_web::{HttpRequest, App, server};
+use actix_web::{server, App, HttpRequest};
 
 fn index(_req: HttpRequest) -> &'static str {
     "Hello world!"
@@ -8,11 +8,9 @@ fn index(_req: HttpRequest) -> &'static str {
 // </setup>
 // <main>
 fn main() {
-    server::new(|| {
-        App::new()
-            .resource("/", |r| r.f(index))
-    })
-       .bind("127.0.0.1:8088").unwrap()
-       .run();
+    server::new(|| App::new().resource("/", |r| r.f(index)))
+        .bind("127.0.0.1:8088")
+        .unwrap()
+        .run();
 }
 // </main>

examples/rustfmt.toml

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

examples/server/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "server"
+version = "0.6.0"
+workspace = "../"
+
+[dependencies]
+actix = "0.5"
+actix-web = { version="0.6", features=["alpn"] }
+futures = "0.1"
+openssl = "0.10"

examples/server/src/ka.rs

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

@@ -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

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

examples/server/src/signals.rs

@@ -0,0 +1,28 @@
+use actix;
+use futures::Future;
+
+// <signals>
+use actix_web::{server, App, HttpResponse};
+use std::sync::mpsc;
+use std::thread;
+
+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()))
+        })
+            .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.send(server::StopServer { graceful: true }).wait(); // <- Send `StopServer` message to server.
+}
+// </signals>

examples/server/src/ssl.rs

@@ -0,0 +1,22 @@
+// <ssl>
+use actix_web::{server, App, HttpRequest, Responder};
+use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
+
+fn index(req: HttpRequest) -> impl Responder {
+    "Welcome!"
+}
+
+fn main() {
+    // load ssl keys
+    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)
+        .unwrap()
+        .run();
+}
+// </ssl>

examples/server/src/workers.rs

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