From 5a350c70fdc475b2d1f6b2c9e4d63e1c52c57b19 Mon Sep 17 00:00:00 2001
From: Miguel Grinberg <miguelgrinberg50@gmail.com>
Date: Sat, 8 Aug 2015 20:15:15 -0700
Subject: [PATCH] Added gevent and threading support, added disconnect function

---
 docs/index.rst                | 243 ++++++++++++++++++++++++++--------
 example/app.py                |   4 +-
 flask_socketio/__init__.py    | 110 ++++++++-------
 flask_socketio/test_client.py |  75 ++++++-----
 setup.py                      |   2 +-
 test_socketio.py              | 113 ++++++++--------
 6 files changed, 348 insertions(+), 199 deletions(-)

diff --git a/docs/index.rst b/docs/index.rst
index 0b9b3ad7..998936f3 100755
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -6,26 +6,49 @@
 Welcome to Flask-SocketIO's documentation!
 ==========================================
 
-**Flask-SocketIO** gives Flask applications access to low latency bi-directional communications between the clients and the server. The client-side application can use the `SocketIO <http://socket.io>`_ Javascript library or any compatible client to establish a permanent connection to the server.
+**Flask-SocketIO** gives Flask applications access to low latency
+bi-directional communications between the clients and the server. The
+client-side application can use the `SocketIO <http://socket.io>`_ Javascript
+library or any compatible client to establish a permanent connection to the
+server.
 
 Requirements
 ------------
 
-Flask-SocketIO is based on `gevent-socketio <https://gevent-socketio.readthedocs.org/en/latest/>`_ which in turn depends on `gevent <http://www.gevent.org/>`_ and `gevent-websocket <https://bitbucket.org/Jeffrey/gevent-websocket>`_.
+Since version 1.0, this extension is fully compatible with Python 2.7 and
+Python 3.3+, and a few different asynchronous frameworks can be used. At this
+time, the most complete implementation uses
+`eventlet <http://eventlet.net/>`_ as a dependency. As an alternative,
+`gevent <http://www.gevent.org/>`_ can be used instead of eventlet. The Flask
+development server based on Werkzeug can be used as well, with the caveat that
+it lacks the performance of the other two options, so it should only be used
+to simplify the development workflow.
+
+On the client-side, the Socket.IO Javascript library is used to establish a
+connection to the server. Versions 1.3.5 or newer of the Socket.IO client are
+recommended. Versions of the Socket.IO client prior to 1.0 are not supported
+anymore.
+
+Note that older versions of Flask-SocketIO had a completely different set of
+requirements. These versions had a dependency on
+`gevent-socketio <https://gevent-socketio.readthedocs.org/en/latest/>`_ and
+`gevent-websocket <https://bitbucket.org/Jeffrey/gevent-websocket>`_, which are
+not used anymore.
 
 Current Limitations
 ~~~~~~~~~~~~~~~~~~~
 
-- Projects gevent and gevent-socketio only support Python 2.x at this time. There has been some activity in the gevent project towards Python 3 compliance, so support for Python 3 is likely to come in the near future.
-- The 1.x releases of the Socket.IO client-side Javascript libraries are not compatible with project gevent-socketio. At this time the Socket.IO client release 0.9.16 has been found to be the most stable.
+- Flask-SocketIO can only run in a single worker process at this time. Work is
+currently in progress to eliminate this limitation.
 
 Initialization
 --------------
 
-The following code example shows how to add Flask-SocketIO to a Flask application::
+The following code example shows how to add Flask-SocketIO to a Flask
+application::
 
     from flask import Flask, render_template
-    from flask.ext.socketio import SocketIO
+    from flask_socketio import SocketIO
 
     app = Flask(__name__)
     app.config['SECRET_KEY'] = 'secret!'
@@ -34,11 +57,19 @@ The following code example shows how to add Flask-SocketIO to a Flask applicatio
     if __name__ == '__main__':
         socketio.run(app)
 
-The ``init_app()`` style of initialization is also supported. Note the way the web server is started. The ``socketio.run()`` function encapsulates the start up of the gevent web server and replaces the standard Werkzeug development web server, which cannot be used with this extension. However, the Werkzeug debugger and reloader modules are still used when the application is in debug mode.
+The ``init_app()`` style of initialization is also supported. Note the way the
+web server is started. The ``socketio.run()`` function encapsulates the start
+up of the web server and replaces the standard ``app.run()`` standard Flask
+development server start up. When the application is in debug mode the
+Werkzeug development server is still used and configured properly inside
+``socketio.run()``. In production mode the eventlet web server is used if
+available, else the gevent web server is used. If eventlet and gevent are not
+installed, the Werkzeug development web server is used.
 
-The application must serve a page to the client that loads the Socket.IO library and establishes a connection::
+The application must serve a page to the client that loads the Socket.IO
+library and establishes a connection::
 
-    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/socket.io/0.9.16/socket.io.min.js"></script>
+    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/socket.io/1.3.6/socket.io.min.js"></script>
     <script type="text/javascript" charset="utf-8">
         var socket = io.connect('http://' + document.domain + ':' + location.port);
         socket.on('connect', function() {
@@ -49,15 +80,20 @@ The application must serve a page to the client that loads the Socket.IO library
 Receiving Messages
 ------------------
 
-When using SocketIO messages are received by both parties as events. On the client side Javascript callbacks are used. With Flask-SocketIO the server needs to register handlers for these events, similarly to how routes are handled by view functions.
+When using SocketIO, messages are received by both parties as events. On the
+client side Javascript callbacks are used. With Flask-SocketIO the server
+needs to register handlers for these events, similarly to how routes are
+handled by view functions.
 
-The following example creates an event handler for an unnamed event::
+The following example creates a server-side event handler for an unnamed
+event::
 
     @socketio.on('message')
     def handle_message(message):
         print('received message: ' + message)
 
-The above example uses string messages. Another type of unnamed events use JSON data::
+The above example uses string messages. Another type of unnamed events use
+JSON data::
 
     @socketio.on('json')
     def handle_json(json):
@@ -69,24 +105,30 @@ The most flexible type of event uses custom event names::
     def handle_my_custom_event(json):
         print('received json: ' + str(json))
 
-Named events are the most flexible, as they eliminate the need to include additional metadata to describe the message type.
+Named events are the most flexible, as they eliminate the need to include
+additional metadata to describe the message type.
 
-Flask-SocketIO also supports SocketIO namespaces, which allow the client to multiplex several independent connections on the same physical socket::
+Flask-SocketIO also supports SocketIO namespaces, which allow the client to
+multiplex several independent connections on the same physical socket::
 
     @socketio.on('my event', namespace='/test')
     def handle_my_custom_namespace_event(json):
         print('received json: ' + str(json))
 
-When a namespace is not specified a default global namespace is used.
+When a namespace is not specified a default global namespace with the name
+``'/'`` is used.
 
 Sending Messages
 ----------------
 
-SocketIO event handlers defined as shown in the previous section can send reply messages to the connected client using the ``send()`` and ``emit()`` functions.
+SocketIO event handlers defined as shown in the previous section can send
+reply messages to the connected client using the ``send()`` and ``emit()``
+functions.
 
-The following examples bounce received events back to the client that sent them::
+The following examples bounce received events back to the client that sent
+them::
 
-    from flask.ext.socketio import send, emit
+    from flask_socketio import send, emit
 
     @socketio.on('message')
     def handle_message(message):
@@ -100,9 +142,12 @@ The following examples bounce received events back to the client that sent them:
     def handle_my_custom_event(json):
         emit('my response', json)
 
-Note how ``send()`` and ``emit()`` are used for unnamed and named events respectively.
+Note how ``send()`` and ``emit()`` are used for unnamed and named events
+respectively.
 
-When working with namespaces, ``send()`` and ``emit()`` use the namespace of the incoming message by default. A different namespace can be specified with the optional ``namespace`` argument::
+When working with namespaces, ``send()`` and ``emit()`` use the namespace of
+the incoming message by default. A different namespace can be specified with
+the optional ``namespace`` argument::
 
     @socketio.on('message')
     def handle_message(message):
@@ -112,7 +157,8 @@ When working with namespaces, ``send()`` and ``emit()`` use the namespace of the
     def handle_my_custom_event(json):
         emit('my response', json, namespace='/chat')
 
-SocketIO supports acknowledgement callbacks that confirm that a message was received by the client::
+SocketIO supports acknowledgement callbacks that confirm that a message was
+received by the client::
 
     def ack():
         print 'message was received!'
@@ -121,32 +167,53 @@ SocketIO supports acknowledgement callbacks that confirm that a message was rece
     def handle_my_custom_event(json):
         emit('my response', json, callback=ack)
 
-When using callbacks the Javascript client receives a callback function to invoke upon receipt of the message. When the client calls the callback function the server invokes the corresponding server-side callback. The client can pass arguments in the callback function, which are transferred to the server and given to the server-side callback.
+When using callbacks the Javascript client receives a callback function to
+invoke upon receipt of the message. When the client calls the callback
+function the server invokes the corresponding server-side callback. The client
+can pass arguments in the callback function, which are transferred to the
+server and given to the server-side callback as function arguments.
 
 Broadcasting
 ------------
 
-Another very useful feature of SocketIO is the broadcasting of messages. Flask-SocketIO supports this feature with the ``broadcast=True`` optional argument to ``send()`` and ``emit()``::
+Another very useful feature of SocketIO is the broadcasting of messages.
+Flask-SocketIO supports this feature with the ``broadcast=True`` optional
+argument to ``send()`` and ``emit()``::
 
     @socketio.on('my event')
     def handle_my_custom_event(data):
         emit('my response', data, broadcast=True)
 
-When a message is sent with the broadcast option enabled, all clients connected to the namespace receive it, including the sender. When namespaces are not used, the clients connected to the global namespace receive the message. Note that callbacks are not invoked for broadcast messages.
+When a message is sent with the broadcast option enabled, all clients
+connected to the namespace receive it, including the sender. When namespaces
+are not used, the clients connected to the global namespace receive the
+message. Note that callbacks are not invoked for broadcast messages.
 
-In all the examples shown until this point the server responds to an event sent by the client. But for some applications, the server needs to be the originator of a message. This can be useful to send notifications to clients of events that originated in the server, for example in a background thread. The ``socketio.send()`` and ``socketio.emit()`` methods can be used to broadcast to all connected clients::
+In all the examples shown until this point the server responds to an event
+sent by the client. But for some applications, the server needs to be the
+originator of a message. This can be useful to send notifications to clients
+of events that originated in the server, for example in a background thread.
+The ``socketio.send()`` and ``socketio.emit()`` methods can be used to
+broadcast to all connected clients::
 
     def some_function():
         socketio.emit('some event', {'data': 42})
 
-Note that in this usage there is no client context, so ``broadcast=True`` is assumed and does not need to be specified.
+Note that ``socketio.send()`` and ``socketio.emit()`` are not the same
+functions as the context-aware ``send()`` and ``emit()``. Also note that in the
+above usage there is no client context, so ``broadcast=True`` is assumed and
+does not need to be specified.
 
 Rooms
 -----
 
-For many applications it is necessary to group users into subsets that can be addressed together. The best example is a chat application with multiple rooms, where users receive messages from the room or rooms they are in, but not from other rooms where other users are. Flask-SocketIO supports this concept of rooms through the ``join_room()`` and ``leave_room()`` functions::
+For many applications it is necessary to group users into subsets that can be
+addressed together. The best example is a chat application with multiple rooms,
+where users receive messages from the room or rooms they are in, but not from
+other rooms where other users are. Flask-SocketIO supports this concept of
+rooms through the ``join_room()`` and ``leave_room()`` functions::
 
-    from flask.ext.socketio import join_room, leave_room
+    from flask_socketio import join_room, leave_room
 
     @socketio.on('join')
     def on_join(data):
@@ -162,12 +229,25 @@ For many applications it is necessary to group users into subsets that can be ad
         leave_room(room)
         send(username + ' has left the room.', room=room)
 
-The ``send()`` and ``emit()`` functions accept an optional ``room`` argument that cause the message to be sent to all the clients that are in the given room. A given client can join multiple rooms if desired. When a client disconnects it is removed from any room it was in. The context-free ``socketio.send()`` and ``socketio.emit()`` functions also accept a ``room`` argument.
+The ``send()`` and ``emit()`` functions accept an optional ``room`` argument
+that cause the message to be sent to all the clients that are in the given
+room.
+
+All clients are assigned a room when they connect, named with the session ID
+of the connection, which can be obtained from ``request.sid``. A given client
+can join any rooms, which can be given any names. When a client disconnects it
+is removed from all the rooms it was in. The context-free ``socketio.send()``
+and ``socketio.emit()`` functions also accept a ``room`` argument to broadcast
+to all clients in a room.
+
+Since all clients are assigned a personal room, to address a message to a
+single client, the session ID of the client can be used as the room argument.
 
 Connection Events
 -----------------
 
-Flask-SocketIO also dispatches connection and disconnection events. The following example shows how to register handlers for them::
+Flask-SocketIO also dispatches connection and disconnection events. The
+following example shows how to register handlers for them::
 
     @socketio.on('connect', namespace='/chat')
     def test_connect():
@@ -177,7 +257,11 @@ Flask-SocketIO also dispatches connection and disconnection events. The followin
     def test_disconnect():
         print('Client disconnected')
 
-Note that these events are sent individually on each namespace used. When the global namespace is used only disconnection events are sent due to a limitation in gevent-socketio.
+The connection event handler can optionally return ``False`` to reject the
+connection. This is so that the client can be authenticated at this point.
+
+Note that connection and disconnection events are sent individually on each
+namespace used.
 
 Error Handling
 --------------
@@ -198,7 +282,9 @@ Flask-SocketIO can also deal with exceptions::
 
 Error handler functions take the exception object as an argument.
 
-The message and data arguments of the current request can also be inspected with the ``request.event`` variable, which is useful for error logging and debugging outside the event handler::
+The message and data arguments of the current request can also be inspected
+with the ``request.event`` variable, which is useful for error logging and
+debugging outside the event handler::
 
     from flask import request
 
@@ -214,28 +300,69 @@ The message and data arguments of the current request can also be inspected with
 Access to Flask's Context Globals
 ---------------------------------
 
-Handlers for SocketIO events are different than handlers for routes and that introduces a lot of confusion around what can and cannot be done in a SocketIO handler. The main difference is that all the SocketIO events generated for a client occur in the context of a single long running request.
-
-In spite of the differences, Flask-SocketIO attempts to make working with SocketIO event handlers easier by making the environment similar to that of a regular HTTP request. The following list describes what works and what doesn't:
-
-- An application context is pushed before invoking an event handler making ``current_app`` and ``g`` available to the handler.
-- A request context is also pushed before invoking a handler, also making ``request`` and ``session`` available. Note that WebSocket events do not have individual requests associated with them, so the request context that started the WebSocket connection is pushed for all the events that are dispatched.
-- The ``request`` context global is enhanced with a ``namespace`` member. This is the gevent-socketio namespace object, which offers direct access to the low level socket.
-- The ``session`` context global behaves in a different way than in regular requests. A copy of the user session at the time the SocketIO connection is established is made available to handlers invoked in the context of that connection. Any changes made to the session inside a SocketIO handler are preserved, but only in the SocketIO context, these changes will not be seen by regular HTTP handlers. The technical reason for this limitation is that to save the user session a cookie needs to be sent to the client, and that requires HTTP request and response, which do not exist in a socket connection. When using server-side session storage SocketIO handlers can update user sessions even for HTTP routes (see the `Flask-KVsession <http://pythonhosted.org/Flask-KVSession/>`_ extension).
-- The ``before_request`` and ``after_request`` hooks are not invoked for SocketIO event handlers.
-- SocketIO handlers can take custom decorators, but most Flask decorators will not be appropriate to use for a SocketIO handler, given that there is no concept of a ``Response`` object during a SocketIO connection.
+Handlers for SocketIO events are different than handlers for routes and that
+introduces a lot of confusion around what can and cannot be done in a SocketIO
+handler. The main difference is that all the SocketIO events generated for a
+client occur in the context of a single long running request.
+
+In spite of the differences, Flask-SocketIO attempts to make working with
+SocketIO event handlers easier by making the environment similar to that of a
+regular HTTP request. The following list describes what works and what doesn't:
+
+- An application context is pushed before invoking an event handler making
+  ``current_app`` and ``g`` available to the handler.
+- A request context is also pushed before invoking a handler, also making
+  ``request`` and ``session`` available. Note that WebSocket events do not
+  have individual requests associated with them, so the request context that
+  started the connection is pushed for all the events that are dispatched
+  during the life of the connection.
+- The ``request`` context global is enhanced with a ``sid`` member that is set
+  to a unique session ID for the connection. This value is used as an initial
+  room where the client is added.
+- The ``request`` context global is enhanced with ``namespace`` and ``event``
+  members that contain the currently handled namespace and event arguments.
+  The ``event`` member is a dictionary with ``message`` and ``args`` keys.
+- The ``session`` context global behaves in a different way than in regular
+  requests. A copy of the user session at the time the SocketIO connection is
+  established is made available to handlers invoked in the context of that
+  connection. Any changes made to the session inside a SocketIO handler are
+  preserved, but only in the SocketIO context, these changes will not be seen
+  by regular HTTP handlers. The technical reason for this limitation is that to
+  save the user session a cookie needs to be sent to the client, and that
+  requires HTTP request and response, which do not exist in a socket
+  connection. When using server-side session storage SocketIO handlers can
+  update user sessions even for HTTP routes (see the
+  `Flask-KVsession <http://pythonhosted.org/Flask-KVSession/>`_ extension).
+- The ``before_request`` and ``after_request`` hooks are not invoked for
+  SocketIO event handlers.
+- SocketIO handlers can take custom decorators, but most Flask decorators will
+  not be appropriate to use for a SocketIO handler, given that there is no
+  concept of a ``Response`` object during a SocketIO connection.
 
 Authentication
 --------------
 
-A common need of applications is to validate the identify of their users. The traditional mechanisms based on web forms and HTTP requests cannot be used in a SocketIO connection, since there is no place to send HTTP requests and responses. If necessary, an application can implement a customized login form that sends credentials to the server as a SocketIO message when the submit button is pressed by the user.
+A common need of applications is to validate the identify of their users. The
+traditional mechanisms based on web forms and HTTP requests cannot be used in
+a SocketIO connection, since there is no place to send HTTP requests and
+responses. If necessary, an application can implement a customized login form
+that sends credentials to the server as a SocketIO message when the submit
+button is pressed by the user.
 
-However, in most cases it is more convenient to perform the traditional authentication process before the SocketIO connection is established. The user's identify can then be recorded in the user session or in a cookie, and later when the SocketIO connection is established that information will be accessible to SocketIO event handlers.
+However, in most cases it is more convenient to perform the traditional
+authentication process before the SocketIO connection is established. The
+user's identify can then be recorded in the user session or in a cookie, and
+later when the SocketIO connection is established that information will be
+accessible to SocketIO event handlers.
 
 Using Flask-Login with Flask-SocketIO
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Flask-SocketIO can access login information maintained by `Flask-Login <https://flask-login.readthedocs.org/en/latest/>`_. After a regular Flask-Login authentication is performed and the ``login_user()`` function is called to record the user in the user session, any SocketIO connections will have access to the ``current_user`` context variable::
+Flask-SocketIO can access login information maintained by
+`Flask-Login <https://flask-login.readthedocs.org/en/latest/>`_. After a
+regular Flask-Login authentication is performed and the ``login_user()``
+function is called to record the user in the user session, any SocketIO
+connections will have access to the ``current_user`` context variable::
 
     @socketio.on('my event')
     def handle_my_custom_event(data):
@@ -246,7 +373,9 @@ Flask-SocketIO can access login information maintained by `Flask-Login <https://
         else:
             request.namespace.disconnect()  # not allowed here
 
-Note that the ``login_required`` decorator cannot be used with SocketIO event handlers, but a custom decorator that disconnects non-authenticated users can be created as follows::
+Note that the ``login_required`` decorator cannot be used with SocketIO event
+handlers, but a custom decorator that disconnects non-authenticated users can
+be created as follows::
 
     import functools
     from flask import request
@@ -270,20 +399,28 @@ Note that the ``login_required`` decorator cannot be used with SocketIO event ha
 Deployment
 ----------
 
-The simplest deployment strategy is to start the web server by calling ``socketio.run(app)`` as shown above, but with debug mode turned off in the configuration. This will run the application on the gevent-socketio web server, which is based on gevent.
-
-An alternative is to use `gunicorn <http://gunicorn.org/>`_ as web server, using the worker class provided by gevent-socketio. The command line that starts the server in this way is shown below::
+The simplest deployment strategy is to have eventlet or gevent installed, and
+start the web server by calling ``socketio.run(app)`` as shown above, but with
+debug mode turned off in the configuration. This will run the application on
+the eventlet or gevent web servers, in that order of preference.
 
-    gunicorn --worker-class socketio.sgunicorn.GeventSocketIOWorker module:app
+An alternative is to use `gunicorn <http://gunicorn.org/>`_ as web server,
+using the eventlet or gevent workers. The command line that starts the server
+in this way is shown below::
 
-In this command ``module`` is the Python module or package that defines the application instance, and ``app`` is the application instance itself.
+    gunicorn --worker-class eventlet module:app
+    gunicorn --worker-class gevent module:app
 
-Note regarding `uWSGI <http://uwsgi-docs.readthedocs.org/en/latest/>`_: While this server has support for gevent and WebSocket, there is no way to use the custom event loop needed by gevent-socketio, so there is no directly available method for hosting Flask-SocketIO applications on it. If you figure out how to do this please let me know!
+In this command ``module`` is the Python module or package that defines the
+application instance, and ``app`` is the application instance itself.
 
 Using nginx as a WebSocket Reverse Proxy
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-It is possible to use nginx as a front-end reverse proxy that passes requests to the application. However, it is important to note that only releases of nginx 1.4 and newer support proxying of the WebSocket protocol. Below is an example nginx configuration that proxies regular and WebSocket requests::
+It is possible to use nginx as a front-end reverse proxy that passes requests
+to the application. However, it is important to note that only releases of
+nginx 1.4 and newer support proxying of the WebSocket protocol. Below is an
+example nginx configuration that proxies regular and WebSocket requests::
 
     server {
         listen 80;
diff --git a/example/app.py b/example/app.py
index 225278e4..b1543b24 100755
--- a/example/app.py
+++ b/example/app.py
@@ -3,14 +3,14 @@
 
 import time
 from threading import Thread
-from flask import Flask, render_template, session, request
+from flask import Flask, render_template, session
 from flask_socketio import SocketIO, emit, join_room, leave_room, \
     close_room, rooms, disconnect
 
 app = Flask(__name__)
 app.debug = True
 app.config['SECRET_KEY'] = 'secret!'
-socketio = SocketIO(app, logger=True)
+socketio = SocketIO(app)
 thread = None
 
 
diff --git a/flask_socketio/__init__.py b/flask_socketio/__init__.py
index 424d021b..43e5c333 100755
--- a/flask_socketio/__init__.py
+++ b/flask_socketio/__init__.py
@@ -1,12 +1,7 @@
-import os
 import sys
 
-import eventlet
 import socketio
 import flask
-from werkzeug.debug import DebuggedApplication
-from werkzeug.serving import run_with_reloader
-from werkzeug._internal import _log
 
 from .test_client import SocketIOTestClient
 
@@ -23,6 +18,8 @@ class SocketIO(object):
     def __init__(self, app=None, **kwargs):
         self.app = None
         self.server = None
+        self.server_options = None
+        self.handlers = {}
         self.exception_handlers = {}
         self.default_exception_handler = None
         if app is not None:
@@ -35,12 +32,9 @@ def init_app(self, app, **kwargs):
         if not hasattr(app, 'extensions'):
             app.extensions = {}
         app.extensions['socketio'] = self
-        self.server = socketio.Server(**kwargs)
+        self.server_options = kwargs
         self.app = app
 
-    def _on_message(self, message, handler, namespace='/'):
-        self.server.on(message, handler, namespace=namespace)
-
     def on(self, message, namespace=None):
         """Decorator to register a SocketIO event handler.
 
@@ -70,6 +64,7 @@ def _handler(sid, *args):
                             flask.session)
                     flask.request.sid = sid
                     flask.request.namespace = namespace
+                    flask.request.event = {'message': message, 'args': args}
                     try:
                         if message == 'connect':
                             ret = handler()
@@ -87,7 +82,9 @@ def _handler(sid, *args):
                         flask.session,
                         self.server.environ[sid]['saved_session'])
                     return ret
-            self.server.on(message, _handler, namespace=namespace)
+            if namespace not in self.handlers:
+                self.handlers[namespace] = {}
+            self.handlers[namespace][message] = _handler
         return decorator
 
     def on_error(self, namespace=None):
@@ -188,7 +185,7 @@ def send(self, data, json=False, namespace=None, room=None, callback=None):
             self.emit('message', data, namespace=namespace, room=room,
                       callback=callback)
 
-    def close_room(self, room, namespace='/'):
+    def close_room(self, room, namespace=None):
         """Close a room.
 
         This function removes any users that are in the given room and then
@@ -201,7 +198,7 @@ def close_room(self, room, namespace='/'):
         """
         self.server.close_room(room, namespace)
 
-    def run(self, app, host=None, port=None, **kwargs):
+    def run(self, app=None, host=None, port=None, **kwargs):
         """Run the SocketIO web server.
 
         :param app: The Flask application instance.
@@ -211,33 +208,14 @@ def run(self, app, host=None, port=None, **kwargs):
                      5000.
         :param use_reloader: ``True`` to enable the Flask reloader, ``False``
                              to disable it.
+        :param log_output: If ``True``, the server logs all incomming
+                           connections. If ``False`` logging is disabled.
+                           Defaults to ``True`` in debug mode, ``False``
+                           otherwise.
         :param resource: The SocketIO resource name. Defaults to
                          ``'socket.io'``. Leave this as is unless you know what
                          you are doing.
-        :param transports: Optional list of transports to allow. List of
-                           strings, each string should be one of
-                           handler.SocketIOHandler.handler_types.
-        :param policy_server: Boolean describing whether or not to use the
-                              Flash policy server.  Defaults to ``True``.
-        :param policy_listener: A tuple containing (host, port) for the
-                                policy server. This is optional and used only
-                                if policy server is set to true.  Defaults to
-                                0.0.0.0:843.
-        :param heartbeat_interval: The timeout for the server, we should
-                                   receive a heartbeat from the client within
-                                   this interval. This should be less than the
-                                   ``heartbeat_timeout``.
-        :param heartbeat_timeout: The timeout for the client when it should
-                                  send a new heartbeat to the server. This
-                                  value is sent to the client after a
-                                  successful handshake.
-        :param close_timeout: The timeout for the client, when it closes the
-                              connection it still X amounts of seconds to do
-                              re-open of the connection. This value is sent to
-                              the client after a successful handshake.
-        :param log_file: The file in which you want the PyWSGI server to write
-                         its access log.  If not specified, it is sent to
-                         ``stderr`` (with gevent 0.13).
+        :param kwargs: additional options passed to the eventlet WSGI server.
         """
         if host is None:
             host = '127.0.0.1'
@@ -248,23 +226,41 @@ def run(self, app, host=None, port=None, **kwargs):
             else:
                 port = 5000
 
-        resource = kwargs.pop('resource', 'socket.io')
-        # use_reloader = kwargs.pop('use_reloader', app.debug)
-        # if use_reloader:
-        #     # monkey patching is required by the reloader
-        #     from gevent import monkey
-        #     monkey.patch_all()
-        #
-        #     def run_server():
-        #         self.server.serve_forever()
-        #     if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
-        #         _log('info', ' * Running on http://%s:%d/' % (host, port))
-        #     run_with_reloader(run_server)
-        # else:
-        #     _log('info', ' * Running on http://%s:%d/' % (host, port))
-        #     self.server.serve_forever()
-        app = socketio.Middleware(self.server, app, socketio_path=resource)
-        eventlet.wsgi.server(eventlet.listen((host, port)), app)
+        if app is None:
+            app = self.app
+        else:
+            self.app = app
+
+        self.server_options.update(kwargs)
+        log_output = self.server_options.pop('log_output', app.debug)
+        use_reloader = self.server_options.pop('use_reloader', app.debug)
+        resource = self.server_options.pop('resource', 'socket.io')
+        if resource.startswith('/'):
+            resource = resource[1:]
+        if app.debug:
+            self.server_options['async_mode'] = 'threading'
+
+        self.server = socketio.Server(**self.server_options)
+        for namespace in self.handlers.keys():
+            for message, handler in self.handlers[namespace].items():
+                self.server.on(message, handler, namespace=namespace)
+
+        app.wsgi_app = socketio.Middleware(self.server, app.wsgi_app,
+                                           socketio_path=resource)
+
+        if self.server.eio.async_mode == 'threading':
+            app.run(host=host, port=port, threaded=True,
+                    use_reloader=use_reloader)
+        elif self.server.eio.async_mode == 'eventlet':
+            import eventlet
+            eventlet.wsgi.server(eventlet.listen((host, port)), app,
+                                 log_output=log_output, **kwargs)
+        elif self.server.eio.async_mode == 'gevent':
+            from gevent import pywsgi
+            log = 'default'
+            if not log_output:
+                log = None
+            pywsgi.WSGIServer((host, port), app, log=log).serve_forever()
 
     def test_client(self, app, namespace=None):
         """Return a simple SocketIO client that can be used for unit tests."""
@@ -420,8 +416,8 @@ def receive_message(msg):
                 disconnect()
             # ...
 
-    :param silent: close the connection, but do not actually send a disconnect
-                   packet to the client.
+    :param silent: this option is deprecated.
     """
-    #return flask.request.namespace.disconnect(silent)
-    raise NotImplementedError()
+    socketio = flask.current_app.extensions['socketio']
+    return socketio.server.disconnect(flask.request.sid,
+                                      namespace=flask.request.namespace)
diff --git a/flask_socketio/test_client.py b/flask_socketio/test_client.py
index a71dd09d..2dcd92df 100755
--- a/flask_socketio/test_client.py
+++ b/flask_socketio/test_client.py
@@ -1,40 +1,42 @@
-"""
-This module contains a collection of auxiliary mock objects used by
-unit tests.
-"""
-
 import uuid
 
 from socketio import packet
 from werkzeug.test import EnvironBuilder
 
 
-_queue = {}
-
-
-def _mock_send_packet(sid, pkt):
-    global _queue
-    if sid not in _queue:
-        _queue[sid] = []
-    if pkt.packet_type == packet.EVENT or \
-            pkt.packet_type == packet.BINARY_EVENT:
-        if pkt.data[0] == 'message' or pkt.data[0] == 'json':
-            _queue[sid].append({'name': pkt.data[0], 'args': pkt.data[1],
-                                'namespace': pkt.namespace or '/'})
-        else:
-            _queue[sid].append({'name': pkt.data[0], 'args': pkt.data[1:],
-                                'namespace': pkt.namespace or '/'})
-
-
 class SocketIOTestClient(object):
+    """Fake client useful for testing of a Flask-SocketIO server."""
+    queue = {}
+    ack = None
+
     def __init__(self, app, socketio, namespace=None):
+        def _mock_send_packet(sid, pkt):
+            if pkt.packet_type == packet.EVENT or \
+                    pkt.packet_type == packet.BINARY_EVENT:
+                if sid not in self.queue:
+                    self.queue[sid] = []
+                if pkt.data[0] == 'message' or pkt.data[0] == 'json':
+                    self.queue[sid].append({'name': pkt.data[0],
+                                            'args': pkt.data[1],
+                                            'namespace': pkt.namespace or '/'})
+                else:
+                    self.queue[sid].append({'name': pkt.data[0],
+                                            'args': pkt.data[1:],
+                                            'namespace': pkt.namespace or '/'})
+            elif pkt.packet_type == packet.ACK or \
+                    pkt.packet_type == packet.BINARY_ACK:
+                self.ack = {'args': pkt.data,
+                            'namespace': pkt.namespace or '/'}
+
         self.sid = uuid.uuid4().hex
+        self.callback_counter = 0
         self.socketio = socketio
         socketio.server._send_packet = _mock_send_packet
         socketio.server.environ[self.sid] = {}
         self.connect(namespace)
 
     def connect(self, namespace=None):
+        """Connect the client."""
         environ = EnvironBuilder('/socket.io').get_environ()
         self.socketio.server._handle_eio_connect(self.sid, environ)
         if namespace is not None and namespace != '/':
@@ -42,26 +44,39 @@ def connect(self, namespace=None):
             self.socketio.server._handle_eio_message(self.sid, pkt.encode())
 
     def disconnect(self, namespace=None):
+        """Disconnect the client."""
         pkt = packet.Packet(packet.DISCONNECT, namespace=namespace)
         self.socketio.server._handle_eio_message(self.sid, pkt.encode())
 
     def emit(self, event, *args, **kwargs):
+        """Emit an event to the server."""
         namespace = kwargs.pop('namespace', None)
+        callback = kwargs.pop('callback', False)
+        id = None
+        if callback:
+            self.callback_counter += 1
+            id = self.callback_counter
         pkt = packet.Packet(packet.EVENT, data=[event] + list(args),
-                            namespace=namespace, binary=False)
+                            namespace=namespace, id=id, binary=False)
+        self.ack = None
         self.socketio.server._handle_eio_message(self.sid, pkt.encode())
+        if self.ack is not None:
+            return self.ack['args'][0] if len(self.ack['args']) == 1 \
+                else self.ack['args']
 
-    def send(self, data, json=False, namespace=None):
+    def send(self, data, json=False, callback=False, namespace=None):
+        """Send a message to the server."""
         if json:
             msg = 'json'
         else:
             msg = 'message'
-        return self.emit(msg, data, namespace=namespace)
+        return self.emit(msg, data, callback=callback, namespace=namespace)
 
     def get_received(self, namespace=None):
-        if self.sid not in _queue:
-            return []
+        """Return the list of messages received from the server."""
         namespace = namespace or '/'
-        r = [pkt for pkt in _queue[self.sid] if pkt['namespace'] == namespace]
-        _queue[self.sid] = [pkt for pkt in _queue[self.sid] if pkt not in r]
-        return r
\ No newline at end of file
+        r = [pkt for pkt in self.queue[self.sid]
+             if pkt['namespace'] == namespace]
+        self.queue[self.sid] = [pkt for pkt in self.queue[self.sid]
+                                if pkt not in r]
+        return r
diff --git a/setup.py b/setup.py
index 7eedb26a..4ea82934 100755
--- a/setup.py
+++ b/setup.py
@@ -22,7 +22,7 @@
     platforms='any',
     install_requires=[
         'Flask>=0.9',
-        'python-socketio>=0.2.0'
+        'python-socketio>=0.4.0'
     ],
     tests_require=[
         'coverage'
diff --git a/test_socketio.py b/test_socketio.py
index f7c3d745..ca68efe5 100755
--- a/test_socketio.py
+++ b/test_socketio.py
@@ -213,7 +213,7 @@ def test_disconnect_namespace(self):
 
     def test_send(self):
         client = socketio.test_client(app)
-        client.get_received()  # clean received
+        client.get_received()
         client.send('echo this message back')
         received = client.get_received()
         self.assertTrue(len(received) == 1)
@@ -222,8 +222,8 @@ def test_send(self):
     def test_send_json(self):
         client1 = socketio.test_client(app)
         client2 = socketio.test_client(app)
-        client1.get_received()  # clean received
-        client2.get_received()  # clean received
+        client1.get_received()
+        client2.get_received()
         client1.send({'a': 'b'}, json=True)
         received = client1.get_received()
         self.assertTrue(len(received) == 1)
@@ -234,7 +234,7 @@ def test_send_json(self):
 
     def test_send_namespace(self):
         client = socketio.test_client(app, namespace='/test')
-        client.get_received('/test')  # clean received
+        client.get_received('/test')
         client.send('echo this message back', namespace='/test')
         received = client.get_received('/test')
         self.assertTrue(len(received) == 1)
@@ -242,7 +242,7 @@ def test_send_namespace(self):
 
     def test_send_json_namespace(self):
         client = socketio.test_client(app, namespace='/test')
-        client.get_received('/test')  # clean received
+        client.get_received('/test')
         client.send({'a': 'b'}, json=True, namespace='/test')
         received = client.get_received('/test')
         self.assertTrue(len(received) == 1)
@@ -250,10 +250,9 @@ def test_send_json_namespace(self):
 
     def test_emit(self):
         client = socketio.test_client(app)
-        client.get_received()  # clean received
+        client.get_received()
         client.emit('my custom event', {'a': 'b'})
         received = client.get_received()
-        print(received)
         self.assertTrue(len(received) == 1)
         self.assertTrue(len(received[0]['args']) == 1)
         self.assertTrue(received[0]['name'] == 'my custom response')
@@ -261,7 +260,7 @@ def test_emit(self):
 
     def test_request_event_data(self):
         client = socketio.test_client(app)
-        client.get_received()  # clean received
+        client.get_received()
         global request_event_data
         request_event_data = None
         client.emit('other custom event', 'foo')
@@ -270,7 +269,7 @@ def test_request_event_data(self):
 
     def test_emit_namespace(self):
         client = socketio.test_client(app, namespace='/test')
-        client.get_received('/test')  # clean received
+        client.get_received('/test')
         client.emit('my custom namespace event', {'a': 'b'}, namespace='/test')
         received = client.get_received('/test')
         self.assertTrue(len(received) == 1)
@@ -282,8 +281,8 @@ def test_broadcast(self):
         client1 = socketio.test_client(app)
         client2 = socketio.test_client(app)
         client3 = socketio.test_client(app, namespace='/test')
-        client2.get_received()  # clean
-        client3.get_received('/test')  # clean
+        client2.get_received()
+        client3.get_received('/test')
         client1.emit('my custom broadcast event', {'a': 'b'}, broadcast=True)
         received = client2.get_received()
         self.assertTrue(len(received) == 1)
@@ -296,8 +295,8 @@ def test_broadcast_namespace(self):
         client1 = socketio.test_client(app, namespace='/test')
         client2 = socketio.test_client(app, namespace='/test')
         client3 = socketio.test_client(app)
-        client2.get_received('/test')  # clean
-        client3.get_received()  # clean
+        client2.get_received('/test')
+        client3.get_received()
         client1.emit('my custom broadcast namespace event', {'a': 'b'},
                      namespace='/test')
         received = client2.get_received('/test')
@@ -309,7 +308,7 @@ def test_broadcast_namespace(self):
 
     def test_session(self):
         client = socketio.test_client(app)
-        client.get_received()  # clean received
+        client.get_received()
         client.send('echo this message back')
         session = socketio.server.environ[client.sid]['saved_session']
         self.assertTrue(session['a'] == 'b')
@@ -318,9 +317,9 @@ def test_room(self):
         client1 = socketio.test_client(app)
         client2 = socketio.test_client(app)
         client3 = socketio.test_client(app, namespace='/test')
-        client1.get_received()  # clean
-        client2.get_received()  # clean
-        client3.get_received('/test')  # clean
+        client1.get_received()
+        client2.get_received()
+        client3.get_received('/test')
         client1.emit('join room', {'room': 'one'})
         client2.emit('join room', {'room': 'one'})
         client3.emit('join room', {'room': 'one'}, namespace='/test')
@@ -348,19 +347,21 @@ def test_room(self):
         self.assertTrue(len(received) == 0)
         received = client3.get_received('/test')
         self.assertTrue(len(received) == 0)
-        client3.emit('my room namespace event', {'room': 'one'}, namespace='/test')
+        client3.emit('my room namespace event', {'room': 'one'},
+                     namespace='/test')
         received = client3.get_received('/test')
         self.assertTrue(len(received) == 1)
         self.assertTrue(received[0]['name'] == 'message')
         self.assertTrue(received[0]['args'] == 'room message')
         socketio.close_room('one', namespace='/test')
-        client3.emit('my room namespace event', {'room': 'one'}, namespace='/test')
+        client3.emit('my room namespace event', {'room': 'one'},
+                     namespace='/test')
         received = client3.get_received('/test')
         self.assertTrue(len(received) == 0)
 
     def test_error_handling(self):
         client = socketio.test_client(app)
-        client.get_received()       # clean client
+        client.get_received()
         global error_testing
         error_testing = False
         client.emit("error testing", "")
@@ -382,42 +383,42 @@ def test_error_handling_default(self):
         client.emit("error testing", "", namespace='/unused_namespace')
         self.assertTrue(error_testing_default)
 
-    # def test_ack(self):
-    # 	client1 = socketio.test_client(app)
-    # 	ack = client1.send('echo this message back')
-    # 	self.assertIsNot(ack, None)
-    # 	self.assertIs(ack, 'echo this message back')
-    # 	client2 = socketio.test_client(app)
-    # 	ack2 = client2.send({'a': 'b'}, json=True)
-    # 	self.assertIsNot(ack2, None)
-    # 	self.assertEqual(ack2, {'a': 'b'})
-    # 	client3 = socketio.test_client(app)
-    # 	ack3 = client3.emit('my custom event', {'a': 'b'})
-    # 	self.assertIsNot(ack3, None)
-    # 	self.assertEqual(ack3, {'a': 'b'})
-    #
-    # def test_noack(self):
-    # 	client1 = socketio.test_client(app)
-    # 	no_ack_dict = {'noack': True}
-    # 	noack = client1.send("test noack")
-    # 	self.assertIs(noack, None)
-    # 	client2 = socketio.test_client(app)
-    # 	noack2 = client2.send(no_ack_dict, json=True)
-    # 	client3 = socketio.test_client(app)
-    # 	self.assertIs(noack2, None)
-    # 	noack3 = client3.emit('my custom event', no_ack_dict)
-    # 	self.assertIs(noack3, None)
-    #
-    # def test_error_handling_ack(self):
-    # 	client1 = socketio.test_client(app)
-    # 	errorack = client1.emit("error testing", "")
-    # 	self.assertIsNotNone(errorack)
-    # 	client2 = socketio.test_client(app, namespace='/test')
-    # 	errorack_namespace = client2.emit("error testing", "", namespace='/test')
-    # 	self.assertIsNotNone(errorack_namespace)
-    # 	client3 = socketio.test_client(app, namespace='/unused_namespace')
-    # 	errorack_default = client3.emit("error testing", "", namespace='/unused_namespace')
-    # 	self.assertIsNotNone(errorack_default)
+    def test_ack(self):
+        client1 = socketio.test_client(app)
+        ack = client1.send('echo this message back', callback=True)
+        self.assertEqual(ack, 'echo this message back')
+        client2 = socketio.test_client(app)
+        ack2 = client2.send({'a': 'b'}, json=True, callback=True)
+        self.assertEqual(ack2, {'a': 'b'})
+        client3 = socketio.test_client(app)
+        ack3 = client3.emit('my custom event', {'a': 'b'}, callback=True)
+        self.assertEqual(ack3, {'a': 'b'})
+
+    def test_noack(self):
+        client1 = socketio.test_client(app)
+        no_ack_dict = {'noack': True}
+        noack = client1.send("test noack", callback=True)
+        self.assertIsNone(noack)
+        client2 = socketio.test_client(app)
+        noack2 = client2.send(no_ack_dict, json=True, callback=True)
+        client3 = socketio.test_client(app)
+        self.assertIsNone(noack2)
+        noack3 = client3.emit('my custom event', no_ack_dict)
+        self.assertIsNone(noack3)
+
+    def test_error_handling_ack(self):
+        client1 = socketio.test_client(app)
+        errorack = client1.emit("error testing", "", callback=True)
+        self.assertIsNotNone(errorack)
+        client2 = socketio.test_client(app, namespace='/test')
+        errorack_namespace = client2.emit("error testing", "",
+                                          namespace='/test', callback=True)
+        self.assertIsNotNone(errorack_namespace)
+        client3 = socketio.test_client(app, namespace='/unused_namespace')
+        errorack_default = client3.emit("error testing", "",
+                                        namespace='/unused_namespace',
+                                        callback=True)
+        self.assertIsNotNone(errorack_default)
 
 if __name__ == '__main__':
     unittest.main()