From a9ea6578432aef503e6720af1cc6ce2761631a27 Mon Sep 17 00:00:00 2001
From: chao-master <ripppony@gmail.com>
Date: Thu, 7 Apr 2016 01:56:03 +0100
Subject: [PATCH] migrated project to websockets and python3, added logging and
 a few other bobs

---
 client/chat.js      |   7 ++-
 client/demo.html    |   2 +-
 server/rooms.py     |  30 ++++++-----
 server/server.py    | 121 ++++++++++++++++++++++++++------------------
 server/smartJson.py |  21 +++++++-
 5 files changed, 114 insertions(+), 67 deletions(-)
 mode change 100644 => 100755 server/server.py

diff --git a/client/chat.js b/client/chat.js
index 3982d36..957476b 100644
--- a/client/chat.js
+++ b/client/chat.js
@@ -1,4 +1,4 @@
-var chatSocket = new WebSocket("ws://localhost:8000");
+var chatSocket = new WebSocket("ws://"+window.location.hostname+":8000");
 
 $(document).ready(function(){
     $("#chatInput").keyup(function (e) {
@@ -36,7 +36,9 @@ var messageHandlers = {
     join:function(msg){
         addToChat(msg.client.nick+" has joined "+msg.room.name);
         $("*[data-show-for]").hide();
-        $("*[data-show-for='"+msg.room.type+"']").show();
+        for(var i=0;i<msg.room.types.length;i++){
+            $("*[data-show-for='"+msg.room.types[i]+"']").show();
+        }
         if (msg.room.owner){
           $("*[data-owner-only]").prop('disabled',msg.room.owner.cid != OWN_CLIENT_ID);
         }
@@ -86,6 +88,7 @@ chatSocket.onmessage = function(event){
 
 chatSocket.onopen = function(){
     $("*[data-show-for='Limbo']").show();
+    console.debug("Socket Opened");
 };
 
 chatSocket.onclose = function(){
diff --git a/client/demo.html b/client/demo.html
index 50a5941..c76f440 100644
--- a/client/demo.html
+++ b/client/demo.html
@@ -73,7 +73,7 @@
 			</form>
 		</div>
 	</main>
-	<aside>
+	<aside data-show-for="ChatRoom">
 		<div id="chat"></div>
 		<div>
 			<form data-event="chat">
diff --git a/server/rooms.py b/server/rooms.py
index f733227..a4aa81d 100644
--- a/server/rooms.py
+++ b/server/rooms.py
@@ -1,6 +1,10 @@
-from __future__ import print_function
-
 import smartJson as json
+import logging
+import os
+
+_log = logging.getLogger(__name__)
+#_log.addHandler(logging.StreamHandler())
+#_log.setLevel(int(os.getenv("DBLEVEL",logging.INFO)))
 
 def Singleton(cls):
     cls.IS_SINGLETON = True
@@ -9,11 +13,11 @@ def Singleton(cls):
 
 class Room(json.BasicJsonEncodable):
     IS_SINGLETON = False
-    _jsonProperties = set(("type","name"))
+    _jsonProperties = set(("types","name"))
 
     @property
-    def type(self):
-        return self.__class__.__name__
+    def types(self):
+        return [p.__name__ for p in self.__class__.__mro__ if issubclass(p,Room)]
 
     def __init__(self):
         self.clients = set()
@@ -55,19 +59,19 @@ class Room(json.BasicJsonEncodable):
 
 class ChatRoom(Room):
     def on_chat(self,client,msg):
-        print (self," - ",client.nick," : ",msg)
+        _log.info("%s - %s : %s",self,client.nick,msg)
         self.broadcast(type="chat",msg=msg,client=client)
 
     def handleAdd(self,client):
-        print (self,"-",client.nick," : has joined")
+        _log.info("%s - %s : has joined",self,client.nick)
         self.broadcast(type="join",client=client,room=self)
 
     def handleLeave(self,client):
-        print (self,"-",client.nick," : has left")
+        _log.info("%s - %s : has left",self,client.nick)
         self.broadcast(type="leave",client=client,room=self)
 
     def handleClose(self,client):
-        print (self,"-",client.nick," : has disconnected")
+        _log.info("%s - %s : has disconnected",self,client.nick)
         self.broadcast(type="disconnect",client=client,room=self)
 
 
@@ -76,7 +80,7 @@ class Limbo(Room):
     def handleAdd(self,client):
         client.hasAuthed = False
         client.nick = None
-        print ("{} has entered Limbo".format(client.address[1]))
+        _log.info("{} has entered Limbo".format(client.address[1]))
         client.send(type="connected",client=client)
 
     def on_auth(self,client,authType,key=None,nick=None):
@@ -111,7 +115,7 @@ class Lobby(ChatRoom):
         self.games[room].addClient(client)
 
 class GameRoom(ChatRoom):
-    _jsonProperties = set(("type","name","owner","id"))
+    _jsonProperties = set(("types","name","owner","id"))
 
     def __init__(self,owner,name,password):
         ChatRoom.__init__(self)
@@ -137,14 +141,14 @@ class GameRoom(ChatRoom):
             del Lobby.games[id(self)]
 
     def on_options(self,client,**options):
-        print(options)
+        _log.info(options)
         if not self.assertOwner(client,"You are not allowed to adjust the options"):
             return
         for k,v in options.items():
             if k in self.options:
                 if type(v) is type(self.options[k]):
                     self.options[k] = v
-        print(self.options)
+        _log.info(self.options)
         self.broadcast(type="options",client=client,options=self.options)
 
     def assertOwner(self,client,msg=None):
diff --git a/server/server.py b/server/server.py
old mode 100644
new mode 100755
index 7043dc4..2526ec7
--- a/server/server.py
+++ b/server/server.py
@@ -1,93 +1,116 @@
-from __future__ import print_function
+#!/usr/bin/python3
 
 from rooms import *
 
-from SimpleWebSocketServer import WebSocket, SimpleWebSocketServer, SimpleSSLWebSocketServer
+import websockets
 import smartJson as json
-
 import traceback
+import logging
+import asyncio
+import os
 
-def nabExceptions(f):
-    def ff(*args,**kwargs):
-        try:
-            f(*args,**kwargs)
-        except Exception as e:
-            print("\033[1;31m!")
-            traceback.print_exc()
-            print("\033[0m!")
-            raise e
-    return ff
+HANDLERS = set()
+_log = logging.getLogger(__name__)
+
+
+@asyncio.coroutine
+def handler(websocket,uri):
+    c = Client(websocket)
+    c.handleConnected()
+    HANDLERS.add(c)
+    while 1:
+        r = yield from websocket.recv()
+        c.handleMessage(r)
+        for h in HANDLERS:
+            try:
+                yield from h.sendAll()
+            except websockets.exceptions.ConnectionClosed as e:
+                _log.debug("Client disconnected whilst trying to send message %s")
+    HANDLERS.remove(c)
+    c.handleClose()
 
-class Client(json.BasicJsonEncodable,WebSocket):
+class Client(json.BasicJsonEncodable):
     _jsonProperties = set(("nick","cid"))
+    
+    def __init__(self,websocket):
+        self.websocket = websocket
+        self.toSend = []
+    
     def __str__(self):
         return "Client-{}".format(self.address)
+    
+    def sendAll(self):
+        while self.toSend:
+            yield from self.websocket.send(self.toSend.pop(0))
+    
+    @property
+    def address(self):
+        return self.websocket.remote_address
 
-    @nabExceptions
     def handleConnected(self):
         self.room = None
         self.cid = self.address[1]
-        print("connected", self)
-        try:
-            Limbo.addClient(self)
-        except Exception as e:
-            print("\033[1;31m!")
-            traceback.print_exc()
-            print("\033[0m!")
+        _log.info("client connected %s",self)
+        Limbo.addClient(self)
 
-    @nabExceptions
     def handleClose(self):
         if self.room is not None:
             self.room.disconnectClient(self)
-        print("closed", self)
+        _log.info("client closed %s",self)
 
-    @nabExceptions
-    def handleMessage(self):
+    def handleMessage(self,data):
         handler = None
         try:
-            msg = json.loads(self.data)
+            msg = json.loads(data)
         except ValueError as e:
-            print("Cannot decode data - bad json",self.data)
+            _log.warn("Cannot decode data - bad json %s",data)
             return
 
         try:
             handler = getattr(self.room,"on_"+msg["type"])
         except KeyError:
-            print ("No type in json")
+            _log.warn("No type in json")
             return
         except AttributeError as e:
-            print (e)
-            print ("Unknown message type: {}".format(msg["type"]))
+            _log.warn("Unknown message type: %s",msg["type"])
             return
         except TypeError as e:
-            print("Bad paramaters for method ",msg["type"],msg)
+            _log.warn("Bad paramaters for method %s %s",msg["type"],msg)
             return
 
         del msg["type"]
         msg["client"] = self
 
-        try:
-            handler(**msg)
-        except TypeError as e:
-            print ("Bad paramaters to handler",e)
-            print("\033[1;31m!")
-            traceback.print_exc()
-            print("\033[0m!")
-        except Exception as e:
-            print("\033[1;31m!")
-            traceback.print_exc()
-            print("\033[0m!")
+        handler(**msg)
 
     def sendRaw(self,message):
-        message = unicode(message)
-        WebSocket.sendMessage(self,message)
+        #message = message.encode("utf-8")
+        self.toSend.append(message)
 
     def send(self,**payload):
         jMsg = json.dumps(payload)
         self.sendRaw(jMsg)
 
 if __name__ == "__main__":
-    import SimpleHTTPServer
-    print("Running on port 8000")
-    server = SimpleWebSocketServer('', 8000, Client)
-    server.serveforever()
+    import sys
+    
+    logging.basicConfig(level=int(os.getenv("DBLEVEL",logging.INFO)))
+    def addColourToEmitter(fn):
+        def format(self,record):
+            cols = ["\x1b[0m","\x1b[35m","\x1b[32m","\x1b[33m","\x1b[31m"]
+            rLevel = record.levelno//10
+            if rLevel < 0: rLevel = 0
+            elif rLevel >= len(cols): rLevel = len(cols)
+            record.msg = cols[rLevel] + record.msg + "\x1b[0m"
+            return fn(self,record)
+        return format
+    logging.StreamHandler.emit = addColourToEmitter(logging.StreamHandler.emit)        
+        
+    port = 8000 if len(sys.argv)<3 else sys.argv[2]
+    host = "0.0.0.0" if len(sys.argv)<2 else sys.argv[1]
+        
+    print("Running on {}:{}".format(host,port))
+    
+    socketServer = websockets.serve(handler,host,port)
+    asyncio.get_event_loop().run_until_complete(socketServer)
+    asyncio.get_event_loop().run_forever()
diff --git a/server/smartJson.py b/server/smartJson.py
index b9ff6bc..b766b9c 100644
--- a/server/smartJson.py
+++ b/server/smartJson.py
@@ -1,4 +1,10 @@
 import json,traceback
+import logging
+import os
+
+_log = logging.getLogger(__name__)
+#_log.addHandler(logging.StreamHandler())
+#_log.setLevel(int(os.getenv("DBLEVEL",logging.INFO)))
 
 class JsonEncodable(object):
     def _toJsonDict(self):
@@ -15,7 +21,7 @@ class BasicJsonEncodable(JsonEncodable):
         return id(self)
 
     def _toJsonDict(self):
-        return {k:getattr(self,k) for k in self._jsonProperties}
+        return dict({k:getattr(self,k) for k in self._jsonProperties})
 
     @classmethod
     def _fromJsonDict(cls,data):
@@ -43,10 +49,21 @@ class Decoder(json.JSONDecoder):
 
 class Encoder(json.JSONEncoder):
     def default(self,o):
+        causedBy = []
         try:
             return o._toJsonDict()
-        except Exception:
+        except Exception as e:
+            causedBy.append(e)
+            _log.debug("%s raised whilst trying _toJsonDict on %s, trying default",e,o)
+        try:
             return json.JSONEncoder.default(self,o)
+        except TypeError as e:
+            causedBy.append(e)
+            _log.debug("%s raised whilst trying default on %s, testing for iterator",e,o)
+        try:
+            return [self.default(p) for p in o]
+        except Exception as e:
+            _log.error("%s raised whilst trying to convert %s to json, possibly caused by:\n\t %s",e,o,"\n\t".join(causedBy))
 
 def dumps(*args,**kwargs):
     return json.dumps(*args,cls=Encoder,**kwargs)
-- 
GitLab