removed the threadedhandler model in favor of pure gevent coroutines all the way. Works rather well but as a drawback with CherryPy as we need to monkey_patch all with gevent first. Need to change this behavior

Lawouach · Lawouach · commit 8739f89f5ccf · 2012-02-12T16:14:44.000+01:00
diff --git a/example/echo_cherrypy_server.py b/example/echo_cherrypy_server.py
@@ -1,14 +1,17 @@
 # -*- coding: utf-8 -*-
+# for now I can't avoid this
+from gevent import monkey; monkey.patch_all()
+    
 import argparse
 import random
 import os
 
 import cherrypy
 
 from ws4py.server.cherrypyserver import WebSocketPlugin, WebSocketTool
-from ws4py.server.handler.threadedhandler import WebSocketHandler, EchoWebSocketHandler
+from ws4py.websocket import WebSocket
 
-class ChatWebSocketHandler(WebSocketHandler):
+class ChatWebSocketHandler(WebSocket):
     def received_message(self, m):
         cherrypy.engine.publish('websocket-broadcast', m)
 
diff --git a/setup.py b/setup.py
@@ -5,14 +5,13 @@
     from distutils.core import setup
 
 setup(name = "ws4py",
-      version = '0.1.6',
+      version = '0.2.0',
       description = "WebSocket library for Python",
       maintainer = "Sylvain Hellegouarch",
       maintainer_email = "sh@defuze.org",
       url = "https://github.com/Lawouach/WebSocket-for-Python",
       download_url = "http://www.defuze.org/oss/ws4py/",
-      packages = ["ws4py", "ws4py.client", "ws4py.server",
-                  "ws4py.server.handler", "ws4py.server.wsgi"],
+      packages = ["ws4py", "ws4py.client", "ws4py.server", "ws4py.server.wsgi"],
       platforms = ["any"],
       license = 'BSD',
       long_description = "WebSocket library for Python",
diff --git a/ws4py/__init__.py b/ws4py/__init__.py
@@ -28,7 +28,7 @@
 #
 
 __author__ = "Sylvain Hellegouarch"
-__version__ = "0.1.6"
+__version__ = "0.2.0"
 __all__ = ['WS_KEY']
 
 WS_KEY = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
diff --git a/ws4py/client/__init__.py b/ws4py/client/__init__.py
@@ -14,7 +14,7 @@
 
 class WebSocketBaseClient(object):
     def __init__(self, url, protocols=None, version='13'):
-        self.stream = Stream()
+        self.stream = Stream(always_mask=True, expect_masking=False)
         self.url = url
         self.protocols = protocols
         self.version = version
diff --git a/ws4py/client/threadedclient.py b/ws4py/client/threadedclient.py
@@ -114,11 +114,13 @@ def _receive(self):
                         
                     for ping in s.pings:
                         self.write_to_connection(s.pong(str(ping.data)))
-                    s.pings = []
+                    else:
+                        s.pings = []
 
                     for pong in s.pongs:
                         self.ponged(pong)
-                    s.pongs = []
+                    else:
+                        s.pongs = []
                     
         except:
             print "".join(traceback.format_exception(*exc_info()))
diff --git a/ws4py/framing.py b/ws4py/framing.py
@@ -132,16 +132,16 @@ def _parser(self):
         if self.rsv1 or self.rsv2 or self.rsv3:
             raise ProtocolException()
 
+        # control frames between 3 and 7 as well as above 0xA are currently reserved
+        if 2 < self.opcode < 8 or self.opcode > 0xA:
+            raise ProtocolException()
+
         # control frames cannot be fragmented
         if self.opcode > 0x7 and self.fin == 0:
             raise ProtocolException()
 
         # do we already have enough bytes to continue?
-        if bytes and len(bytes) > 1:
-            buf = bytes[1:]
-            bytes = buf
-        else:
-            bytes = ''
+        bytes = bytes[1:] if bytes and len(bytes) > 1 else ''
 
         # Yield until we get the second header's byte
         while not bytes or len(bytes) < 1:
@@ -162,17 +162,14 @@ def _parser(self):
             buf = ''
             bytes = ''
 
-        # The spec doesn't disallow putting a value in 0x0-0xFFFF into the
-        # 8-octet extended payload length field (or 0x0-0xFD in 2-octet field).
-        # So, we don't check the range of extended_payload_length.
         if self.payload_length == 127:
             if len(buf) < 8:
                 nxt_buf_size = 8 - len(buf)
                 bytes = (yield nxt_buf_size)
                 bytes = buf + (bytes or '')
                 while len(bytes) < 8:
                     b = (yield 8 - len(bytes))
-                    if isinstance(b, basestring):
+                    if b is not None:
                         bytes = bytes + b
                 if len(bytes) > 8:
                     buf = bytes[8:]
@@ -191,7 +188,7 @@ def _parser(self):
                 bytes = buf + (bytes or '')
                 while len(bytes) < 2:
                     b = (yield 2 - len(bytes))
-                    if isinstance(b, basestring):
+                    if b is not None:
                         bytes = bytes + b
                 if len(bytes) > 2:
                     buf = bytes[2:]
@@ -209,7 +206,7 @@ def _parser(self):
                 bytes = buf + (bytes or '')
                 while not bytes or len(bytes) < 4:
                     b = (yield 4 - len(bytes))
-                    if isinstance(b, basestring):
+                    if b is not None:
                         bytes = bytes + b
                 if len(bytes) > 4:
                     buf = bytes[4:]
@@ -225,13 +222,17 @@ def _parser(self):
             while len(bytes) < self.payload_length:
                 l = self.payload_length - len(bytes)
                 b = (yield l)
-                if isinstance(b, basestring):
+                if b is not None:
                     bytes = bytes + b
         else:
-            bytes = buf[:self.payload_length]
-
+            if self.payload_length == len(buf):
+                bytes = buf
+            else:
+                bytes = buf[:self.payload_length]
+                
         self.body = bytes
-        yield
+
+        #yield 
         
     def mask(self, data):
         """
diff --git a/ws4py/messaging.py b/ws4py/messaging.py
@@ -9,7 +9,7 @@
            'PingControlMessage', 'PongControlMessage']
 
 class Message(object):
-    def __init__(self, opcode, data='', encoding='utf-8'):
+    def __init__(self, opcode, data='', encoding='utf-8', size=None):
         """
         A WebSocket message is made of an opcode defining its type
         and some bytes.
@@ -20,7 +20,7 @@ def __init__(self, opcode, data='', encoding='utf-8'):
         """
         self.opcode = opcode
         self._completed = False
-        
+
         if isinstance(data, basestring):
             if isinstance(data, unicode):
                 data = data.encode(encoding)
diff --git a/ws4py/server/cherrypyserver.py b/ws4py/server/cherrypyserver.py
@@ -73,9 +73,12 @@ def ws(self):
 from cherrypy.process import plugins
 from cherrypy.wsgiserver import HTTPConnection, HTTPRequest
 
+import gevent
+from gevent.pool import Pool
+
 from ws4py import WS_KEY
 from ws4py.exc import HandshakeError
-from ws4py.server.handler.threadedhandler import WebSocketHandler
+from ws4py.websocket import WebSocket
 
 __all__ = ['WebSocketTool', 'WebSocketPlugin']
 
@@ -96,7 +99,7 @@ def _setup(self):
         hooks.attach('on_end_request', self.start_handler,
                      priority=70)
 
-    def upgrade(self, protocols=None, extensions=None, version=13, handler_cls=WebSocketHandler):
+    def upgrade(self, protocols=None, extensions=None, version=13, handler_cls=WebSocket):
         """
         Performs the upgrade of the connection to the WebSocket
         protocol.
@@ -194,8 +197,6 @@ def upgrade(self, protocols=None, extensions=None, version=13, handler_cls=WebSo
 	addr = (request.remote.ip, request.remote.port)
         ws_conn = request.rfile.rfile._sock
         request.ws_handler = handler_cls(ws_conn, ws_protocols, ws_extensions)
-	# Start tracking the handler 
-        cherrypy.engine.publish('handle-websocket', request.ws_handler, addr)
         
     def complete(self):
         """
@@ -227,13 +228,17 @@ def start_handler(self):
         request = cherrypy.request
         if not hasattr(request, 'ws_handler'):
             return
-        
-        request.ws_handler.opened()
+
+	addr = (request.remote.ip, request.remote.port)
+        ws_handler = request.ws_handler
         request.ws_handler = None
+        delattr(request, 'ws_handler')
 	# By doing this we detach the socket from
 	# the CherryPy stack avoiding memory leaks
 	request.rfile.rfile._sock = None
         
+        cherrypy.engine.publish('handle-websocket', ws_handler, addr)
+        
     def _set_internal_flags(self):
         """
         CherryPy has two internal flags that we are interested in
@@ -269,20 +274,19 @@ def _set_internal_flags(self):
 class WebSocketPlugin(plugins.SimplePlugin):
     def __init__(self, bus):
         plugins.SimplePlugin.__init__(self, bus)
-        self.handlers = []
+        self.pool = Pool()
 
     def start(self):
         cherrypy.log("Starting WebSocket processing")
         self.bus.subscribe('handle-websocket', self.handle)
         self.bus.subscribe('websocket-broadcast', self.broadcast)
-        self.bus.subscribe('main', self.cleanup)
         
     def stop(self):
         cherrypy.log("Terminating WebSocket processing")
-        self.bus.unsubscribe('main', self.cleanup)
+        self.pool.kill()
+        self.pool.join()
         self.bus.unsubscribe('handle-websocket', self.handle)
         self.bus.unsubscribe('websocket-broadcast', self.broadcast)
-	self.cleanup()
 
     def handle(self, ws_handler, peer_addr):
         """
@@ -292,28 +296,13 @@ def handle(self, ws_handler, peer_addr):
 	@param peer_addr: remote peer address for tracing purpose
 	"""
         cherrypy.log("Managing WebSocket connection from %s:%d" % (peer_addr[0], peer_addr[1]))
-        self.handlers.append((ws_handler, peer_addr))
-
-    def cleanup(self):
-        """
-	Performs a bit of cleanup on tracked handlers
-	by closing connection of terminated streams then
-	removing them from the tracked list.
-	"""
-        handlers = self.handlers[:]
-        for peer in handlers:
-	    handler, addr = peer
-            if handler.terminated:
-		cherrypy.log("Removing WebSocket connection from peer: %s:%d" % (addr[0], addr[1]))
-                try:
-                    handler.close_connection()
-                except:
-                    cherrypy.log(traceback=True)
-                finally:
-                    if handler._th.is_alive():
-                        handler._th.join()
-                    self.handlers.remove(peer)
+        ws_handler.link(self.unhandle)
+        self.pool.start(ws_handler)
 
+    def unhandle(self, ws_handler):
+        cherrypy.log("Removing WebSocket connection")
+        self.pool.discard(ws_handler)
+        
     def broadcast(self, message, binary=False):
         """
         Broadcasts a message to all connected clients known to
@@ -323,13 +312,8 @@ def broadcast(self, message, binary=False):
           of the connected handler.
         @param binary: whether or not the message is a binary one
         """
-        handlers = self.handlers[:]
-        for peer in handlers:
-            try:
-                handler, addr = peer
-                handler.send(message, binary)
-            except:
-                cherrypy.log(traceback=True)
+        for ws_handler in self.pool:
+            ws_handler.send(message, message.is_binary)
             
 if __name__ == '__main__':
     import random
diff --git a/ws4py/server/geventserver.py b/ws4py/server/geventserver.py
@@ -1,9 +1,13 @@
+
+from gevent import monkey; monkey.patch_all()
+
 import gevent.pywsgi
 from gevent import version_info
 IS_GEVENT_V10 = version_info[0] == 1
 del version_info
 
 from ws4py.server.wsgi.middleware import WebSocketUpgradeMiddleware
+from ws4py.websocket import WebSocket
 
 class UpgradableWSGIHandler(gevent.pywsgi.WSGIHandler):
     """Upgradable version of gevent.pywsgi.WSGIHandler class
@@ -85,25 +89,31 @@ def start_response_for_upgrade(status, headers, exc_info=None):
 class WebSocketServer(gevent.pywsgi.WSGIServer):
     handler_class = UpgradableWSGIHandler
     
-    def __init__(self, *args, **kwargs):
-        gevent.pywsgi.WSGIServer.__init__(self, *args, **kwargs)
+    def __init__(self, address, *args, **kwargs):
+
         protocols = kwargs.pop('websocket_protocols', [])
         extensions = kwargs.pop('websocket_extensions', [])
-        self.application = WebSocketUpgradeMiddleware(self.application, 
-                                                      protocols=protocols,
-                                                      extensions=extensions)    
+        websocket = kwargs.pop('websocket_class', WebSocket)
+        
+        gevent.pywsgi.WSGIServer.__init__(self, address, *args, **kwargs)
+        self.application = WebSocketUpgradeMiddleware(protocols=protocols,
+                                                      extensions=extensions,
+                                                      websocket_class=websocket)    
 
 if __name__ == '__main__':
-    def echo_handler(websocket, environ):
-        try:
-            while True:
-                msg = websocket.receive(msg_obj=True)
-                if msg is not None:
-                    websocket.send(msg.data, msg.is_binary)
-                else:
-                    break
-        finally:
-            websocket.close()
-    
-    server = WebSocketServer(('127.0.0.1', 9001), echo_handler)
+    import logging
+    import sys
+    logging.basicConfig(format='%(asctime)s %(message)s')
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+    h = logging.StreamHandler()
+    h.setLevel(logging.DEBUG)
+    logger.addHandler(h)
+
+    class EchoWebSocket(WebSocket):
+        def received_message(self, message):
+            self.send(message, message.is_binary)
+        
+    server = WebSocketServer(('127.0.0.1', 9001), websocket_class=EchoWebSocket)
     server.serve_forever()
+        
diff --git a/ws4py/server/wsgi/middleware.py b/ws4py/server/wsgi/middleware.py
diff --git a/ws4py/streaming.py b/ws4py/streaming.py

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@`
`28`	`28`	`#`
`29`	`29`
`30`	`30`	`__author__ = "Sylvain Hellegouarch"`
`31`		`-__version__ = "0.1.6"`
	`31`	`+__version__ = "0.2.0"`
`32`	`32`	`__all__ = ['WS_KEY']`
`33`	`33`
`34`	`34`	`WS_KEY = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"`