From 0b9d7ab85554b11bf254f29e68cf060dc040f867 Mon Sep 17 00:00:00 2001
From: Nikolay Kim <fafhrd91@gmail.com>
Date: Wed, 2 May 2018 06:20:43 -0700
Subject: [PATCH] update state example

---
 state/src/main.rs | 54 +++++++++++++----------------------------------
 1 file changed, 15 insertions(+), 39 deletions(-)

diff --git a/state/src/main.rs b/state/src/main.rs
index 804b68c6..44032312 100644
--- a/state/src/main.rs
+++ b/state/src/main.rs
@@ -1,7 +1,15 @@
-#![cfg_attr(feature="cargo-clippy", allow(needless_pass_by_value))]
+#![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.
+//!
+//! > **Note**: http server accepts an application factory rather than an application
+//! > instance. Http server constructs an application instance for each thread,
+//! > thus application state
+//! > must be constructed multiple times. If you want to share state between different
+//! > threads, a shared object should be used, e.g. `Arc`.
+//!
+//! Check [user guide](https://actix.rs/book/actix-web/sec-2-application.html) for more info.
 
 extern crate actix;
 extern crate actix_web;
@@ -10,8 +18,7 @@ extern crate env_logger;
 use std::cell::Cell;
 
 use actix::prelude::*;
-use actix_web::{
-    http, server, ws, middleware, App, HttpRequest, HttpResponse};
+use actix_web::{http, middleware, server, ws, App, HttpRequest, HttpResponse};
 
 /// Application state
 struct AppState {
@@ -26,50 +33,19 @@ fn index(req: HttpRequest<AppState>) -> HttpResponse {
     HttpResponse::Ok().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 StreamHandler<ws::Message, ws::ProtocolError> for MyWebSocket {
-
-    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::Close(_) => {
-                ctx.stop();
-            }
-            _ => (),
-        }
-    }
-}
-
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
     env_logger::init();
     let sys = actix::System::new("ws-example");
 
-    server::new(
-        || App::with_state(AppState{counter: Cell::new(0)})
+    server::new(|| {
+        App::with_state(AppState{counter: Cell::new(0)}) // <- create app with state
             // enable logger
             .middleware(middleware::Logger::default())
-            // websocket route
-            .resource(
-                "/ws/", |r|
-                r.method(http::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()
+            .resource("/", |r| r.f(index))
+    }).bind("127.0.0.1:8080")
+        .unwrap()
         .start();
 
     println!("Started http server: 127.0.0.1:8080");