Restructure folders (#411)

websockets/websocket/src/client.rs

@@ -0,0 +1,113 @@
+//! Simple websocket client.
+use std::time::Duration;
+use std::{io, thread};
+
+use actix::io::SinkWrite;
+use actix::*;
+use actix_codec::Framed;
+use awc::{
+    error::WsProtocolError,
+    ws::{Codec, Frame, Message},
+    BoxedSocket, Client,
+};
+use bytes::Bytes;
+use futures::stream::{SplitSink, StreamExt};
+
+fn main() {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+
+    let sys = System::new("websocket-client");
+
+    Arbiter::spawn(async {
+        let (response, framed) = Client::new()
+            .ws("http://127.0.0.1:8080/ws/")
+            .connect()
+            .await
+            .map_err(|e| {
+                println!("Error: {}", e);
+            })
+            .unwrap();
+
+        println!("{:?}", response);
+        let (sink, stream) = framed.split();
+        let addr = ChatClient::create(|ctx| {
+            ChatClient::add_stream(stream, ctx);
+            ChatClient(SinkWrite::new(sink, ctx))
+        });
+
+        // start console loop
+        thread::spawn(move || loop {
+            let mut cmd = String::new();
+            if io::stdin().read_line(&mut cmd).is_err() {
+                println!("error");
+                return;
+            }
+            addr.do_send(ClientCommand(cmd));
+        });
+    });
+    sys.run().unwrap();
+}
+
+struct ChatClient(SinkWrite<Message, SplitSink<Framed<BoxedSocket, Codec>, Message>>);
+
+#[derive(Message)]
+#[rtype(result = "()")]
+struct ClientCommand(String);
+
+impl Actor for ChatClient {
+    type Context = Context<Self>;
+
+    fn started(&mut self, ctx: &mut Context<Self>) {
+        // start heartbeats otherwise server will disconnect after 10 seconds
+        self.hb(ctx)
+    }
+
+    fn stopped(&mut self, _: &mut Context<Self>) {
+        println!("Disconnected");
+
+        // Stop application on disconnect
+        System::current().stop();
+    }
+}
+
+impl ChatClient {
+    fn hb(&self, ctx: &mut Context<Self>) {
+        ctx.run_later(Duration::new(1, 0), |act, ctx| {
+            act.0.write(Message::Ping(Bytes::from_static(b"")));
+            act.hb(ctx);
+
+            // client should also check for a timeout here, similar to the
+            // server code
+        });
+    }
+}
+
+/// Handle stdin commands
+impl Handler<ClientCommand> for ChatClient {
+    type Result = ();
+
+    fn handle(&mut self, msg: ClientCommand, _ctx: &mut Context<Self>) {
+        self.0.write(Message::Text(msg.0));
+    }
+}
+
+/// Handle server websocket messages
+impl StreamHandler<Result<Frame, WsProtocolError>> for ChatClient {
+    fn handle(&mut self, msg: Result<Frame, WsProtocolError>, _: &mut Context<Self>) {
+        if let Ok(Frame::Text(txt)) = msg {
+            println!("Server: {:?}", txt)
+        }
+    }
+
+    fn started(&mut self, _ctx: &mut Context<Self>) {
+        println!("Connected");
+    }
+
+    fn finished(&mut self, ctx: &mut Context<Self>) {
+        println!("Server disconnected");
+        ctx.stop()
+    }
+}
+
+impl actix::io::WriteHandler<WsProtocolError> for ChatClient {}

websockets/websocket/src/main.rs

@@ -0,0 +1,116 @@
+//! Simple echo websocket server.
+//! Open `http://localhost:8080/ws/index.html` in browser
+//! or [python console client](https://github.com/actix/examples/blob/master/websocket/websocket-client.py)
+//! could be used for testing.
+
+use std::time::{Duration, Instant};
+
+use actix::prelude::*;
+use actix_files as fs;
+use actix_web::{middleware, web, App, Error, HttpRequest, HttpResponse, HttpServer};
+use actix_web_actors::ws;
+
+/// How often heartbeat pings are sent
+const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5);
+/// How long before lack of client response causes a timeout
+const CLIENT_TIMEOUT: Duration = Duration::from_secs(10);
+
+/// do websocket handshake and start `MyWebSocket` actor
+async fn ws_index(r: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
+    println!("{:?}", r);
+    let res = ws::start(MyWebSocket::new(), &r, stream);
+    println!("{:?}", res);
+    res
+}
+
+/// websocket connection is long running connection, it easier
+/// to handle with an actor
+struct MyWebSocket {
+    /// Client must send ping at least once per 10 seconds (CLIENT_TIMEOUT),
+    /// otherwise we drop connection.
+    hb: Instant,
+}
+
+impl Actor for MyWebSocket {
+    type Context = ws::WebsocketContext<Self>;
+
+    /// Method is called on actor start. We start the heartbeat process here.
+    fn started(&mut self, ctx: &mut Self::Context) {
+        self.hb(ctx);
+    }
+}
+
+/// Handler for `ws::Message`
+impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWebSocket {
+    fn handle(
+        &mut self,
+        msg: Result<ws::Message, ws::ProtocolError>,
+        ctx: &mut Self::Context,
+    ) {
+        // process websocket messages
+        println!("WS: {:?}", msg);
+        match msg {
+            Ok(ws::Message::Ping(msg)) => {
+                self.hb = Instant::now();
+                ctx.pong(&msg);
+            }
+            Ok(ws::Message::Pong(_)) => {
+                self.hb = Instant::now();
+            }
+            Ok(ws::Message::Text(text)) => ctx.text(text),
+            Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
+            Ok(ws::Message::Close(reason)) => {
+                ctx.close(reason);
+                ctx.stop();
+            }
+            _ => ctx.stop(),
+        }
+    }
+}
+
+impl MyWebSocket {
+    fn new() -> Self {
+        Self { hb: Instant::now() }
+    }
+
+    /// helper method that sends ping to client every second.
+    ///
+    /// also this method checks heartbeats from client
+    fn hb(&self, ctx: &mut <Self as Actor>::Context) {
+        ctx.run_interval(HEARTBEAT_INTERVAL, |act, ctx| {
+            // check client heartbeats
+            if Instant::now().duration_since(act.hb) > CLIENT_TIMEOUT {
+                // heartbeat timed out
+                println!("Websocket Client heartbeat failed, disconnecting!");
+
+                // stop actor
+                ctx.stop();
+
+                // don't try to send a ping
+                return;
+            }
+
+            ctx.ping(b"");
+        });
+    }
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_server=info,actix_web=info");
+    env_logger::init();
+
+    HttpServer::new(|| {
+        App::new()
+            // enable logger
+            .wrap(middleware::Logger::default())
+            // websocket route
+            .service(web::resource("/ws/").route(web::get().to(ws_index)))
+            // static files
+            .service(fs::Files::new("/", "static/").index_file("index.html"))
+    })
+    // start http server on 127.0.0.1:8080
+    .bind("127.0.0.1:8080")?
+    .run()
+    .await
+}