From 2f9e5dfaac05538fdf4513569b4df6872ee85b89 Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Wed, 15 May 2019 23:46:11 +0200
Subject: Add web client functionality

additionally added -r feature to build.sh, which reverses build
output.
---
 game_server/src/gameserver.rs | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 game_server/src/gameserver.rs

(limited to 'game_server/src/gameserver.rs')

diff --git a/game_server/src/gameserver.rs b/game_server/src/gameserver.rs
new file mode 100644
index 0000000..e69de29
-- 
cgit v1.2.3-54-g00ecf


From 921d023a7652be5b1232ac41aeb2646b5f83ceb5 Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Fri, 17 May 2019 20:59:10 +0200
Subject: Add WebSocket server functionality

and a WebSocket javascript test suite
---
 game_server/build.sh          |  6 ++--
 game_server/src/gameserver.rs | 44 +++++++++++++++++++++++++++++
 game_server/src/main.rs       | 14 +++++++---
 game_server/src/ws_test.html  | 65 +++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 122 insertions(+), 7 deletions(-)
 create mode 100644 game_server/src/ws_test.html

(limited to 'game_server/src/gameserver.rs')

diff --git a/game_server/build.sh b/game_server/build.sh
index 5929e29..1eb61a1 100755
--- a/game_server/build.sh
+++ b/game_server/build.sh
@@ -2,9 +2,9 @@
 
 case $1 in
     ("")
-        if rustup run nightly cargo --color always build; then
+        if rustup run stable cargo --color always build; then
             echo build success!
-            RUST_LOG=info target/debug/game-server
+            RUST_LOG=debug target/debug/game-server
         else
             echo build failed!
         fi
@@ -13,7 +13,7 @@ case $1 in
         sh build.sh &> err && cat err | tac
         ;;
     -c)
-        rustup run nightly cargo clean
+        rustup run stable cargo clean
         ;;
     *)
         echo invalid argument
diff --git a/game_server/src/gameserver.rs b/game_server/src/gameserver.rs
index e69de29..6bc3e07 100644
--- a/game_server/src/gameserver.rs
+++ b/game_server/src/gameserver.rs
@@ -0,0 +1,44 @@
+use websocket::{OwnedMessage, sync::Server, server::NoTlsAcceptor};
+use std::net::{SocketAddr, ToSocketAddrs};
+use std::sync::mpsc;
+use std::sync::mpsc::{Sender, Receiver};
+
+#[derive(Debug)]
+pub enum GameServerError {
+    BindError(std::io::Error),
+}
+
+type ClientConnection = Result<(), GameServerError>;
+
+pub struct GameServer {
+    addr: SocketAddr,
+    rec: Receiver<ClientConnection>,
+}
+
+impl GameServer {
+    pub fn new<T: ToSocketAddrs>(addr: T) -> Self {
+        let (s, r): (Sender<ClientConnection>, Receiver<ClientConnection>)
+                     = mpsc::channel();
+        let addr = addr.to_socket_addrs().unwrap().next().unwrap();
+        debug!("ws address: {}", addr);
+        std::thread::spawn(move || {
+            let server = match Server::<NoTlsAcceptor>::bind(addr) {
+                Ok(v) => v,
+                Err(e) => {
+                    s.send(Err(GameServerError::BindError(e))).unwrap();
+                    return;
+                },
+            };
+            info!("webserver is being launched");
+            for req in server {
+                //println!("{:?}", req);
+                println!("gotcha");
+            }
+            info!("webserver is being shut down");
+        });
+        GameServer {
+            addr,
+            rec: r,
+        }
+    }
+}
diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index f7a1085..2d261d8 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -1,27 +1,33 @@
 mod group;
 mod test_group;
 mod lobby;
+mod gameserver;
 mod backend_connection;
 
 #[macro_use] extern crate log;
 use pretty_env_logger;
 
-use test_group::TestGroup;
 use lobby::Lobby;
 use backend_connection::BackendConnection;
 
 fn main() {
     pretty_env_logger::init();
 
+    info!("create lobby");
     let mut lobby = Lobby::new();
+    let addr = ("127.0.0.1", 5001);
+    info!("create game server on {:?}", addr);
+    let gameserver = gameserver::GameServer::new(addr);
 
     for group in lobby.iter() {
         group.run()
     }
 
-    let mut backend = BackendConnection::new("http://129.13.215.68:5000");
+    let mut backend = BackendConnection::new("https://kobert.dev");
     loop {
-        backend.request("/scribble").unwrap();
-        println!("{:?}", backend.get_response());
+        std::thread::sleep(std::time::Duration::from_millis(1000));
+
+        //backend.request("/api/lobby/tokens/1230").unwrap();
+        //println!("{:?}", backend.get_response());
     }
 }
diff --git a/game_server/src/ws_test.html b/game_server/src/ws_test.html
new file mode 100644
index 0000000..29d4d50
--- /dev/null
+++ b/game_server/src/ws_test.html
@@ -0,0 +1,65 @@
+<!doctype html>
+<html>
+    <head>
+        <title>WS Test</title>
+        <style>
+.b {
+    border-bottom: 1px solid black;
+}
+        </style>
+    </head>
+    <body style='background: black; color: white'>
+        <div id='cons'>connected</div><br>
+        <button onclick='test_connection()'>Launch</button><br>
+        <span>Server address: </span><input id='addr'></input>
+        <div id='chat' style='background: rgb(20, 20, 20); padding-left: 20px; margin: 40px' />
+    </body>
+    <script>
+function get_addr() {
+    return document.getElementById('addr').value;
+}
+
+function test_connection() {
+    let a = 'ws://' + get_addr();
+    add_text('create a new connection at "' + a + '"');
+    const ws = new WebSocket(a);
+    ws.addEventListener('open', function (event) {
+        add_text('connection established');
+        toggle_connected(true);
+    });
+    ws.addEventListener('error', function (event) {
+        add_text('ws error occured: "' + event + '"');
+        toggle_connected(false);
+    });
+    ws.addEventListener('close', function (event) {
+        add_text('ws is closed now');
+        toggle_connected(false);
+    });
+    ws.addEventListener('message', function (event) {
+        add_text('got ws message: ' + event);
+    });
+}
+
+function add_text(text, color='white') {
+    let c = document.getElementById('chat');
+    let n = document.createElement('span');
+    n.setAttribute('class', 'b');
+    n.style = 'color: ' + color;
+    n.textContent = (new Date()).toTimeString().substring(0, 8) + '|> '+ text;
+    c.appendChild(n);
+    c.appendChild(document.createElement('br'));
+}
+function toggle_connected(con) {
+    let c = document.getElementById('cons');
+    if (con) {
+        c.style = 'background: green'
+        c.textContent = 'connected';
+    } else {
+        c.style = 'background: red'
+        c.textContent = 'not connected';
+    }
+}
+toggle_connected(false);
+add_text("JS loaded");
+    </script>
+</html>
-- 
cgit v1.2.3-54-g00ecf


From 70f46161fe0c9819d463cf612d60d4c03faabe7e Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Sat, 18 May 2019 05:27:06 +0200
Subject: Add threading and possibility to connect to socket

---
 game_server/Cargo.toml        |   1 +
 game_server/src/gameserver.rs | 148 +++++++++++++++++++++++++++++++++++-------
 game_server/src/main.rs       |  17 +----
 game_server/src/ws_test.html  |   5 +-
 4 files changed, 131 insertions(+), 40 deletions(-)

(limited to 'game_server/src/gameserver.rs')

diff --git a/game_server/Cargo.toml b/game_server/Cargo.toml
index baf27fa..97c0e77 100644
--- a/game_server/Cargo.toml
+++ b/game_server/Cargo.toml
@@ -10,3 +10,4 @@ log = "0.4"
 pretty_env_logger = "0.3"
 reqwest = "0.9"
 websocket = "0.22"
+hyper = "0.10"
diff --git a/game_server/src/gameserver.rs b/game_server/src/gameserver.rs
index 6bc3e07..377654e 100644
--- a/game_server/src/gameserver.rs
+++ b/game_server/src/gameserver.rs
@@ -1,44 +1,146 @@
-use websocket::{OwnedMessage, sync::Server, server::NoTlsAcceptor};
-use std::net::{SocketAddr, ToSocketAddrs};
+use websocket::{OwnedMessage,
+    sync::Server,
+    client::sync::Client,
+    server::{NoTlsAcceptor, InvalidConnection,
+        sync::AcceptResult}};
+use std::net::{SocketAddr, ToSocketAddrs, TcpStream};
 use std::sync::mpsc;
 use std::sync::mpsc::{Sender, Receiver};
+use super::lobby::Lobby;
+use super::backend_connection::BackendConnection;
+
+const PROTOCOL: &str = "tuesday";
+
+type Token = u32;
 
 #[derive(Debug)]
 pub enum GameServerError {
     BindError(std::io::Error),
+    HandshakeRequestError,
+    InvalidProtocolError,
+    AcceptError(std::io::Error)
 }
 
-type ClientConnection = Result<(), GameServerError>;
-
 pub struct GameServer {
     addr: SocketAddr,
-    rec: Receiver<ClientConnection>,
+    lobby: Lobby,
+    backend: BackendConnection,
+}
+
+pub struct GameClient {
+    addr: SocketAddr,
+    client: Client<TcpStream>,
+}
+
+impl GameClient {
+    fn from_raw(client: Client<TcpStream>) -> Result<Self, ()> {
+        let addr = client.peer_addr().map_err(|_| ())?;
+        info!("got a client connection from: {}", addr);
+        Ok(GameClient {
+            addr,
+            client,
+        })
+    }
+
+    fn require_token(&mut self) -> Option<Token> {
+        let message = self.client
+                 .recv_message()
+                 .ok()?;
+        if let OwnedMessage::Text(text) = message {
+            text.parse::<Token>().ok()
+        } else {
+            None
+        }
+    }
 }
 
+type ClientConnection = Result<GameClient, GameServerError>;
+
 impl GameServer {
     pub fn new<T: ToSocketAddrs>(addr: T) -> Self {
-        let (s, r): (Sender<ClientConnection>, Receiver<ClientConnection>)
-                     = mpsc::channel();
         let addr = addr.to_socket_addrs().unwrap().next().unwrap();
         debug!("ws address: {}", addr);
-        std::thread::spawn(move || {
-            let server = match Server::<NoTlsAcceptor>::bind(addr) {
-                Ok(v) => v,
-                Err(e) => {
-                    s.send(Err(GameServerError::BindError(e))).unwrap();
-                    return;
-                },
-            };
-            info!("webserver is being launched");
-            for req in server {
-                //println!("{:?}", req);
-                println!("gotcha");
-            }
-            info!("webserver is being shut down");
-        });
+        info!("create lobby");
+        let lobby = Lobby::new();
+        let backend = BackendConnection::new("https://kobert.dev");
+        info!("got a C# backend connection");
         GameServer {
             addr,
-            rec: r,
+            lobby,
+            backend,
+        }
+    }
+
+    pub fn run(&self) -> Result<(), GameServerError> {
+        let reader = self.read_clients();
+        loop {
+            let mut connection = reader.recv().unwrap()?;
+            self.add_client(connection);
+        }
+        Ok(())
+    }
+
+    fn add_client(&self, mut client: GameClient) {
+        std::thread::spawn(move || {
+            println!("Token: {:?}", client.require_token());
+        });
+    }
+
+    fn read_clients(&self) -> Receiver<ClientConnection> {
+        let (s, r): (Sender<ClientConnection>, Receiver<ClientConnection>)
+                     = mpsc::channel();
+        let addr = self.addr;
+        std::thread::spawn(move || {
+            let result = Self::handle_requests(addr, &s).or_else(|e| s.send(Err(e)));
+        });
+        r
+    }
+
+    fn handle_requests(addr: SocketAddr, s: &Sender<ClientConnection>) -> Result<(), GameServerError> {
+        let server = match Server::<NoTlsAcceptor>::bind(addr) {
+            Ok(v) => v,
+            Err(e) => {
+                error!("websocket binding error");
+                Err(GameServerError::BindError(e))?
+            },
+        };
+        info!("webserver is being launched");
+        for req in server {
+            s.send(Ok(Self::handle_request(req)?)).unwrap();
+        }
+        info!("webserver is being shut down");
+        Ok(())
+    }
+
+    fn handle_request(req: AcceptResult<TcpStream>) -> ClientConnection {
+        match req {
+            Ok(req) => {
+                if !req.protocols().contains(&PROTOCOL.to_string()) {
+                    warn!("a client tried to connect without {} protocol", PROTOCOL);
+                    req.reject().unwrap();
+                    Err(GameServerError::InvalidProtocolError)
+                } else {
+                    match req.use_protocol(PROTOCOL).accept() {
+                        Ok(client) => {
+                            match GameClient::from_raw(client) {
+                                Ok(client) => Ok(client),
+                                Err(_) => {
+                                    error!("could not create a client");
+                                    Err(GameServerError::HandshakeRequestError)
+                                }
+                            }
+                        },
+                        Err((_, e)) => {
+                            warn!("client handshake failed");
+                            Err(GameServerError::AcceptError(e))
+                        }
+                    }
+                }
+            },
+            Err(e) => {
+                warn!("invalid client request");
+                Err(GameServerError::HandshakeRequestError)
+            }
         }
     }
 }
diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index 2d261d8..d8a7b53 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -7,27 +7,14 @@ mod backend_connection;
 #[macro_use] extern crate log;
 use pretty_env_logger;
 
-use lobby::Lobby;
 use backend_connection::BackendConnection;
 
 fn main() {
     pretty_env_logger::init();
 
-    info!("create lobby");
-    let mut lobby = Lobby::new();
-    let addr = ("127.0.0.1", 5001);
+    let addr = ("0.0.0.0", 5001);
     info!("create game server on {:?}", addr);
     let gameserver = gameserver::GameServer::new(addr);
+    gameserver.run().unwrap();
 
-    for group in lobby.iter() {
-        group.run()
-    }
-
-    let mut backend = BackendConnection::new("https://kobert.dev");
-    loop {
-        std::thread::sleep(std::time::Duration::from_millis(1000));
-
-        //backend.request("/api/lobby/tokens/1230").unwrap();
-        //println!("{:?}", backend.get_response());
-    }
 }
diff --git a/game_server/src/ws_test.html b/game_server/src/ws_test.html
index 29d4d50..ea259b7 100644
--- a/game_server/src/ws_test.html
+++ b/game_server/src/ws_test.html
@@ -22,10 +22,11 @@ function get_addr() {
 function test_connection() {
     let a = 'ws://' + get_addr();
     add_text('create a new connection at "' + a + '"');
-    const ws = new WebSocket(a);
+    const ws = new WebSocket(a, 'tuesday');
     ws.addEventListener('open', function (event) {
         add_text('connection established');
         toggle_connected(true);
+        ws.send('1230123');
     });
     ws.addEventListener('error', function (event) {
         add_text('ws error occured: "' + event + '"');
@@ -36,7 +37,7 @@ function test_connection() {
         toggle_connected(false);
     });
     ws.addEventListener('message', function (event) {
-        add_text('got ws message: ' + event);
+        add_text('got ws message: ' + event.data);
     });
 }
 
-- 
cgit v1.2.3-54-g00ecf


From f3983341be939235c1a6cd522b3bb5cc318a6d1a Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Sat, 18 May 2019 05:52:08 +0200
Subject: Keep client connections open

and start the server on localhost
---
 game_server/src/gameserver.rs | 1 +
 game_server/src/main.rs       | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'game_server/src/gameserver.rs')

diff --git a/game_server/src/gameserver.rs b/game_server/src/gameserver.rs
index 377654e..9334a27 100644
--- a/game_server/src/gameserver.rs
+++ b/game_server/src/gameserver.rs
@@ -83,6 +83,7 @@ impl GameServer {
     fn add_client(&self, mut client: GameClient) {
         std::thread::spawn(move || {
             println!("Token: {:?}", client.require_token());
+            loop { std::thread::sleep(std::time::Duration::from_millis(100)); }
         });
     }
 
diff --git a/game_server/src/main.rs b/game_server/src/main.rs
index d8a7b53..e129283 100644
--- a/game_server/src/main.rs
+++ b/game_server/src/main.rs
@@ -12,7 +12,7 @@ use backend_connection::BackendConnection;
 fn main() {
     pretty_env_logger::init();
 
-    let addr = ("0.0.0.0", 5001);
+    let addr = ("127.0.0.1", 5001);
     info!("create game server on {:?}", addr);
     let gameserver = gameserver::GameServer::new(addr);
     gameserver.run().unwrap();
-- 
cgit v1.2.3-54-g00ecf