Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: 1f7a785744
Fetching contributors…

Cannot retrieve contributors at this time

89 lines (66 sloc) 3.518 kb
__version__ = (0, 3, 5)
import logging
import gevent
log = logging.getLogger(__name__)
def socketio_manage(environ, namespaces, request=None, error_handler=None,
json_loads=None, json_dumps=None):
"""Main SocketIO management function, call from within your Framework of
choice's view.
The ``environ`` variable is the WSGI ``environ``. It is used to extract
Socket object from the underlying server (as the 'socketio' key), and will
be attached to both the ``Socket`` and ``Namespace`` objects.
The ``namespaces`` parameter is a dictionary of the namespace string
representation as key, and the BaseNamespace namespace class descendant as
a value. The empty string ('') namespace is the global namespace. You can
use Socket.GLOBAL_NS to be more explicit. So it would look like:
.. code-block:: python
namespaces={'': GlobalNamespace,
'/chat': ChatNamespace}
The ``request`` object is not required, but will probably be useful to pass
framework-specific things into your Socket and Namespace functions. It will
simply be attached to the Socket and Namespace object (accessible through
``self.request`` in both cases), and it is not accessed in any case by the
``gevent-socketio`` library.
Pass in an ``error_handler`` if you want to override the default
error_handler (which is :func:`socketio.virtsocket.default_error_handler`.
The callable you pass in should have the same signature as the default
error handler.
The ``json_loads`` and ``json_dumps`` are overrides for the default
``json.loads`` and ``json.dumps`` function calls. Override these at
the top-most level here. This will affect all sockets created by this
socketio manager, and all namespaces inside.
This function will block the current "view" or "controller" in your
framework to do the recv/send on the socket, and dispatch incoming messages
to your namespaces.
This is a simple example using Pyramid:
.. code-block:: python
def my_view(request):
socketio_manage(request.environ, {'': GlobalNamespace}, request)
NOTE: You must understand that this function is going to be called
*only once* per socket opening, *even though* you are using a long
polling mechanism. The subsequent calls (for long polling) will
be hooked directly at the server-level, to interact with the
active ``Socket`` instance. This means you will *not* get access
to the future ``request`` or ``environ`` objects. This is of
particular importance regarding sessions (like Beaker). The
session will be opened once at the opening of the Socket, and not
closed until the socket is closed. You are responsible for
opening and closing the cookie-based session yourself if you want
to keep its data in sync with the rest of your GET/POST calls.
"""
socket = environ['socketio']
socket._set_environ(environ)
socket._set_namespaces(namespaces)
if request:
socket._set_request(request)
if error_handler:
socket._set_error_handler(error_handler)
if json_loads:
socket._set_json_loads(json_loads)
if json_dumps:
socket._set_json_dumps(json_dumps)
receiver_loop = socket._spawn_receiver_loop()
watcher = socket._spawn_watcher()
gevent.joinall([receiver_loop, watcher])
# TODO: double check, what happens to the WSGI request here ? it vanishes ?
return
Jump to Line
Something went wrong with that request. Please try again.