Restructure folders (#411)

websockets/websocket/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "websocket"
+version = "2.0.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+edition = "2018"
+
+[[bin]]
+name = "websocket-server"
+path = "src/main.rs"
+
+[[bin]]
+name = "websocket-client"
+path = "src/client.rs"
+
+[dependencies]
+actix = "0.10"
+actix-codec = "0.3"
+actix-web = "3"
+actix-web-actors = "3"
+actix-files = "0.3"
+awc = "2"
+env_logger = "0.8"
+futures = "0.3.1"
+bytes = "0.5.3"

websockets/websocket/README.md

@@ -0,0 +1,34 @@
+# websocket
+
+Simple echo websocket server.
+
+## Usage
+
+### server
+
+```bash
+cd examples/websocket
+cargo run --bin websocket-server
+# Started http server: 127.0.0.1:8080
+```
+
+### web client
+
+- [http://localhost:8080/index.html](http://localhost:8080/index.html)
+
+### rust client
+
+```bash
+cd examples/websocket
+cargo run --bin websocket-client
+```
+
+### python client
+
+- ``pip install aiohttp``
+- ``python websocket-client.py``
+
+if ubuntu :
+
+- ``pip3 install aiohttp``
+- ``python3 websocket-client.py``

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
+}

websockets/websocket/static/index.html

@@ -0,0 +1,90 @@
+<!DOCTYPE html>
+<meta charset="utf-8" />
+<html>
+<head>
+<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js">
+</script>
+  <script language="javascript" type="text/javascript">
+    $(function() {
+      var conn = null;
+      function log(msg) {
+        var control = $('#log');
+        control.html(control.html() + msg + '<br/>');
+        control.scrollTop(control.scrollTop() + 1000);
+      }
+      function connect() {
+        disconnect();
+        var wsUri = (window.location.protocol=='https:'&&'wss://'||'ws://')+window.location.host + '/ws/';
+        conn = new WebSocket(wsUri);
+        log('Connecting...');
+        conn.onopen = function() {
+          log('Connected.');
+          update_ui();
+        };
+        conn.onmessage = function(e) {
+          log('Received: ' + e.data);
+        };
+        conn.onclose = function() {
+          log('Disconnected.');
+          conn = null;
+          update_ui();
+        };
+      }
+      function disconnect() {
+        if (conn != null) {
+          log('Disconnecting...');
+          conn.close();
+          conn = null;
+          update_ui();
+        }
+      }
+      function update_ui() {
+        var msg = '';
+        if (conn == null) {
+          $('#status').text('disconnected');
+          $('#connect').html('Connect');
+        } else {
+          $('#status').text('connected (' + conn.protocol + ')');
+          $('#connect').html('Disconnect');
+        }
+      }
+      $('#connect').click(function() {
+        if (conn == null) {
+          connect();
+        } else {
+          disconnect();
+        }
+        update_ui();
+        return false;
+      });
+      $('#send').click(function() {
+        var text = $('#text').val();
+        log('Sending: ' + text);
+        conn.send(text);
+        $('#text').val('').focus();
+        return false;
+      });
+      $('#text').keyup(function(e) {
+        if (e.keyCode === 13) {
+          $('#send').click();
+          return false;
+        }
+      });
+    });
+</script>
+</head>
+<body>
+<h3>Chat!</h3>
+<div>
+  <button id="connect">Connect</button>&nbsp;|&nbsp;Status:
+  <span id="status">disconnected</span>
+</div>
+<div id="log"
+     style="width:20em;height:15em;overflow:auto;border:1px solid black">
+</div>
+<form id="chatform" onsubmit="return false;">
+  <input id="text" type="text" />
+  <input id="send" type="button" value="Send" />
+</form>
+</body>
+</html>

websockets/websocket/websocket-client.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""websocket cmd client for wssrv.py example."""
+import argparse
+import asyncio
+import signal
+import sys
+
+import aiohttp
+
+
+def start_client(loop, url):
+    name = input('Please enter your name: ')
+
+    # send request
+    ws = yield from aiohttp.ClientSession().ws_connect(url, autoclose=False, autoping=False)
+
+    # input reader
+    def stdin_callback():
+        line = sys.stdin.buffer.readline().decode('utf-8')
+        if not line:
+            loop.stop()
+        else:
+            ws.send_str(name + ': ' + line)
+    loop.add_reader(sys.stdin.fileno(), stdin_callback)
+
+    @asyncio.coroutine
+    def dispatch():
+        while True:
+            msg = yield from ws.receive()
+
+            if msg.type == aiohttp.WSMsgType.TEXT:
+                print('Text: ', msg.data.strip())
+            elif msg.type == aiohttp.WSMsgType.BINARY:
+                print('Binary: ', msg.data)
+            elif msg.type == aiohttp.WSMsgType.PING:
+                ws.pong()
+            elif msg.type == aiohttp.WSMsgType.PONG:
+                print('Pong received')
+            else:
+                if msg.type == aiohttp.WSMsgType.CLOSE:
+                    yield from ws.close()
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    print('Error during receive %s' % ws.exception())
+                elif msg.type == aiohttp.WSMsgType.CLOSED:
+                    pass
+
+                break
+
+    yield from dispatch()
+
+
+ARGS = argparse.ArgumentParser(
+    description="websocket console client for wssrv.py example.")
+ARGS.add_argument(
+    '--host', action="store", dest='host',
+    default='127.0.0.1', help='Host name')
+ARGS.add_argument(
+    '--port', action="store", dest='port',
+    default=8080, type=int, help='Port number')
+
+if __name__ == '__main__':
+    args = ARGS.parse_args()
+    if ':' in args.host:
+        args.host, port = args.host.split(':', 1)
+        args.port = int(port)
+
+    url = 'http://{}:{}/ws/'.format(args.host, args.port)
+
+    loop = asyncio.get_event_loop()
+    loop.add_signal_handler(signal.SIGINT, loop.stop)
+    asyncio.Task(start_client(loop, url))
+    loop.run_forever()