Miguel Grinberg
9 years ago
10 changed files with 284 additions and 43 deletions
@ -1,4 +1,9 @@ |
|||
from .middleware import Middleware |
|||
from .base_manager import BaseManager |
|||
from .pubsub_manager import PubSubManager |
|||
from .kombu_manager import KombuManager |
|||
from .redis_manager import RedisManager |
|||
from .server import Server |
|||
|
|||
__all__ = [Middleware, Server] |
|||
__all__ = [Middleware, Server, BaseManager, PubSubManager, KombuManager, |
|||
RedisManager] |
|||
|
|||
@ -0,0 +1,64 @@ |
|||
import json |
|||
import pickle |
|||
|
|||
import six |
|||
try: |
|||
import kombu |
|||
except ImportError: |
|||
kombu = None |
|||
|
|||
from .pubsub_manager import PubSubManager |
|||
|
|||
|
|||
class KombuManager(PubSubManager): |
|||
"""Client manager that uses kombu for inter-process messaging. |
|||
|
|||
This class implements a client manager backend for event sharing across |
|||
multiple processes, using RabbitMQ, Redis or any other messaging mechanism |
|||
supported by `kombu <http://kombu.readthedocs.org/en/latest/>`_. |
|||
|
|||
To use a kombu backend, initialize the :class:`Server` instance as |
|||
follows:: |
|||
|
|||
url = 'amqp://user:password@hostname:port//' |
|||
server = socketio.Server(client_manager=socketio.KombuManager(url)) |
|||
|
|||
:param url: The connection URL for the backend messaging queue. Example |
|||
connection URLs are ``'amqp://guest:guest@localhost:5672//'`` |
|||
and ``'redis://localhost:6379/'`` for RabbitMQ and Redis |
|||
respectively. Consult the `kombu documentation |
|||
<http://kombu.readthedocs.org/en/latest/userguide\ |
|||
/connections.html#urls>`_ for more on how to construct |
|||
connection URLs. |
|||
:param channel: The channel name on which the server sends and receives |
|||
notifications. Must be the same in all the servers. |
|||
""" |
|||
name = 'kombu' |
|||
|
|||
def __init__(self, url='amqp://guest:guest@localhost:5672//', |
|||
channel='socketio'): |
|||
if kombu is None: |
|||
raise RuntimeError('Kombu package is not installed ' |
|||
'(Run "pip install kombu" in your ' |
|||
'virtualenv).') |
|||
self.kombu = kombu.Connection(url) |
|||
self.queue = self.kombu.SimpleQueue(channel) |
|||
super(KombuManager, self).__init__(channel=channel) |
|||
|
|||
def _publish(self, data): |
|||
return self.queue.put(pickle.dumps(data)) |
|||
|
|||
def _listen(self): |
|||
listen_queue = self.kombu.SimpleQueue(self.channel) |
|||
while True: |
|||
message = listen_queue.get(block=True) |
|||
message.ack() |
|||
data = None |
|||
if isinstance(message.payload, six.binary_type): |
|||
try: |
|||
data = pickle.loads(message.payload) |
|||
except pickle.PickleError: |
|||
pass |
|||
if data is None: |
|||
data = json.loads(message.payload) |
|||
yield data |
|||
@ -0,0 +1,77 @@ |
|||
from .base_manager import BaseManager |
|||
|
|||
|
|||
class PubSubManager(BaseManager): |
|||
"""Manage a client list attached to a pub/sub backend. |
|||
|
|||
This is a base class that enables multiple servers to share the list of |
|||
clients, with the servers communicating events through a pub/sub backend. |
|||
The use of a pub/sub backend also allows any client connected to the |
|||
backend to emit events addressed to Socket.IO clients. |
|||
|
|||
The actual backends must be implemented by subclasses, this class only |
|||
provides a pub/sub generic framework. |
|||
|
|||
:param channel: The channel name on which the server sends and receives |
|||
notifications. |
|||
""" |
|||
def __init__(self, channel='socketio'): |
|||
super(PubSubManager, self).__init__() |
|||
self.channel = channel |
|||
|
|||
def initialize(self, server): |
|||
super(PubSubManager, self).initialize(server) |
|||
self.thread = self.server.start_background_task(self._thread) |
|||
self.server.logger.info(self.name + ' backend initialized.') |
|||
|
|||
def emit(self, event, data, namespace=None, room=None, skip_sid=None, |
|||
callback=None): |
|||
"""Emit a message to a single client, a room, or all the clients |
|||
connected to the namespace. |
|||
|
|||
This method takes care or propagating the message to all the servers |
|||
that are connected through the message queue. |
|||
|
|||
The parameters are the same as in :meth:`.Server.emit`. |
|||
""" |
|||
self._publish({'method': 'emit', 'event': event, 'data': data, |
|||
'namespace': namespace or '/', 'room': room, |
|||
'skip_sid': skip_sid, 'callback': callback}) |
|||
|
|||
def close_room(self, room, namespace=None): |
|||
self._publish({'method': 'close_room', 'room': room, |
|||
'namespace': namespace or '/'}) |
|||
|
|||
def _publish(self, data): |
|||
"""Publish a message on the Socket.IO channel. |
|||
|
|||
This method needs to be implemented by the different subclasses that |
|||
support pub/sub backends. |
|||
""" |
|||
raise NotImplementedError('This method must be implemented in a ' |
|||
'subclass.') |
|||
|
|||
def _listen(self): |
|||
"""Return the next message published on the Socket.IO channel, |
|||
blocking until a message is available. |
|||
|
|||
This method needs to be implemented by the different subclasses that |
|||
support pub/sub backends. |
|||
""" |
|||
raise NotImplementedError('This method must be implemented in a ' |
|||
'subclass.') |
|||
|
|||
def _thread(self): |
|||
for message in self._listen(): |
|||
if 'method' in message: |
|||
if message['method'] == 'emit': |
|||
super(PubSubManager, self).emit( |
|||
message['event'], message['data'], |
|||
namespace=message.get('namespace'), |
|||
room=message.get('room'), |
|||
skip_sid=message.get('skip_sid'), |
|||
callback=message.get('callback')) |
|||
elif message['method'] == 'close_room': |
|||
super(PubSubManager, self).close_room( |
|||
room=message.get('room'), |
|||
namespace=message.get('namespace')) |
|||
@ -0,0 +1,60 @@ |
|||
import json |
|||
import pickle |
|||
|
|||
import six |
|||
try: |
|||
import redis |
|||
except ImportError: |
|||
redis = None |
|||
|
|||
from .pubsub_manager import PubSubManager |
|||
|
|||
|
|||
class RedisManager(PubSubManager): |
|||
"""Redis based client manager. |
|||
|
|||
This class implements a Redis backend for event sharing across multiple |
|||
processes. Only kept here as one more example of how to build a custom |
|||
backend, since the kombu backend is perfectly adequate to support a Redis |
|||
message queue. |
|||
|
|||
To use a Redis backend, initialize the :class:`Server` instance as |
|||
follows:: |
|||
|
|||
url = 'redis://hostname:port/0' |
|||
server = socketio.Server(client_manager=socketio.RedisManager(url)) |
|||
|
|||
:param url: The connection URL for the Redis server. |
|||
:param channel: The channel name on which the server sends and receives |
|||
notifications. Must be the same in all the servers. |
|||
""" |
|||
name = 'redis' |
|||
|
|||
def __init__(self, url='redis://localhost:6379/0', channel='socketio'): |
|||
if redis is None: |
|||
raise RuntimeError('Redis package is not installed ' |
|||
'(Run "pip install redis" in your ' |
|||
'virtualenv).') |
|||
self.redis = redis.Redis.from_url(url) |
|||
self.pubsub = self.redis.pubsub() |
|||
super(RedisManager, self).__init__(channel=channel) |
|||
|
|||
def _publish(self, data): |
|||
return self.redis.publish(self.channel, pickle.dumps(data)) |
|||
|
|||
def _listen(self): |
|||
channel = self.channel.encode('utf-8') |
|||
self.pubsub.subscribe(self.channel) |
|||
for message in self.pubsub.listen(): |
|||
if message['channel'] == channel and \ |
|||
message['type'] == 'message' and 'data' in message: |
|||
data = None |
|||
if isinstance(message['data'], six.binary_type): |
|||
try: |
|||
data = pickle.loads(message['data']) |
|||
except pickle.PickleError: |
|||
pass |
|||
if data is None: |
|||
data = json.loads(message['data']) |
|||
yield data |
|||
self.pubsub.unsubscribe(self.channel) |
|||
Loading…
Reference in new issue