Merge branch 'master' into master

yguarata · web-flow · commit 8ca54ff281e0 · 2017-07-13T15:34:36.000-03:00
diff --git a/docs/changelog.rst b/docs/changelog.rst
@@ -4,19 +4,32 @@
 Release History
 ===============
 
-0.4.7 develop
--------------
+0.5.0
+-----
+* Support for Django-1.11.
+
+0.4.8
+-----
+* Support Redis connections over Unix Domain Sockets.
 
+0.4.7
+-----
 Instalation settings:
 
 * Adding support to run websockets in cross domains (setting WEBSOCKET_HOST).
 
 Improvements to the javascript API:
 
 * Performing reconnection attempts when the first connection (on instantiation) fails.
-* Adding the 'close()' method to enable closing the connection explicitly. When the connection is closed calling this method, there will be no reconnection attempts. In order to connect again, the client must be re-instantiated.
-* Adding 'connecting' and 'disconnected' callback options. The first is fired right before the Websocket is being instantiated, while tha last is fired after connection is closed.
-* Adding the following methods to check websocket status: is_connecting(), is_connected(), is_closing(), is_closed().
+* Adding the 'close()' method to enable closing the connection explicitly. When the connection is
+  closed calling this method, there will be no reconnection attempts. In order to connect again,
+  the client must be re-instantiated.
+* Adding 'connecting' and 'disconnected' callback options. The first is fired right before the
+  Websocket is being instantiated, while tha last is fired after connection is closed.
+* Adding the following methods to check websocket status: ``is_connecting()``, ``is_connected()``,
+  ``is_closing()``, ``is_closed()``.
+* Replaced ``STATIC_URL`` against ``{% static %}`` in all templates.
+* Keep track on opened websockets.
 
 0.4.6
 -----
diff --git a/docs/installation.rst b/docs/installation.rst
@@ -82,6 +82,15 @@ override these values
 
 .. note:: Specify only the values, which deviate from the default.
 
+If your Redis instance is accessed via a Unix Domain Socket, you can configure that as well:
+
+.. code-block:: python
+
+	WS4REDIS_CONNECTION = {
+	    'unix_socket_path': '/tmp/redis.sock',
+	    'db': 5
+	}
+
 **Websocket for Redis** can be configured with ``WS4REDIS_EXPIRE``, to additionally persist messages
 published on the message queue. This is advantageous in situations, where clients shall be able
 to access the published information after reconnecting the websocket, for instance after a page
diff --git a/examples/chatserver/settings.py b/examples/chatserver/settings.py
@@ -98,7 +98,7 @@
 # URL that distinguishes websocket connections from normal requests
 WEBSOCKET_URL = '/ws/'
 
-# Set the number of seconds each message shall persited
+# Set the number of seconds each message shall be persisted
 WS4REDIS_EXPIRE = 3600
 
 WS4REDIS_HEARTBEAT = '--heartbeat--'
diff --git a/examples/chatserver/templates/chat_base.html b/examples/chatserver/templates/chat_base.html
@@ -1,3 +1,4 @@
+{% load static from staticfiles %}
 {% load tutorial_tags %}
 <!DOCTYPE html>
 <html lang="en">
@@ -94,11 +95,11 @@ <h1>Simple chat {% block "title" %}{% endblock %}</h1>
 	</div>
 	<script src="//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js" type="text/javascript"></script>
 	<script src="//maxcdn.bootstrapcdn.com/bootstrap/3.3.1/js/bootstrap.min.js" type="text/javascript"></script>
-	<script src="{{ STATIC_URL }}js/ws4redis.js" type="text/javascript"></script>
+	<script src="{% static "js/ws4redis.js" %}" type="text/javascript"></script>
 	{% block script_panel %}{% endblock %}
 	<a href="https://github.com/jrief/django-websocket-redis" class="hidden-xs">
 		<img style="position: absolute; top: 0; right: 0; border: 0; z-index: 1001;" src="https://camo.githubusercontent.com/365986a132ccd6a44c23a9169022c0b5c890c387/68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f6769746875622f726962626f6e732f666f726b6d655f72696768745f7265645f6161303030302e706e67" alt="Fork me on GitHub" data-canonical-src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png">
 	</a>
 </body>
 
-</html>
+</html>
diff --git a/ws4redis/__init__.py b/ws4redis/__init__.py
@@ -1,2 +1,2 @@
 # -*- coding: utf-8 -*-
-__version__ = '0.4.6'
+__version__ = '0.5.0'
diff --git a/ws4redis/_compat.py b/ws4redis/_compat.py
@@ -0,0 +1,13 @@
+def is_authenticated(request):
+    """Wrapper for checking when a request is authenticated. This checks first
+    for a valid request and user, then checks to see if `is_authenticated` is
+    a callable in order to be compatible with Django 1.10, wherein using a
+    callable for `is_authenticated` is deprecated in favor of a property.
+    """
+    if not request:
+        return False
+    if not request.user:
+        return False
+    if callable(request.user.is_authenticated):
+        return request.user.is_authenticated()
+    return request.user.is_authenticated
diff --git a/ws4redis/django_runserver.py b/ws4redis/django_runserver.py
@@ -2,11 +2,11 @@
 import six
 import base64
 import select
+import logging
 from hashlib import sha1
 from wsgiref import util
 from django.core.wsgi import get_wsgi_application
 from django.core.servers.basehttp import WSGIServer, WSGIRequestHandler
-from django.core.handlers.wsgi import logger
 from django.conf import settings
 from django.core.management.commands import runserver
 from django.utils.six.moves import socketserver
@@ -15,6 +15,7 @@
 from ws4redis.wsgi_server import WebsocketWSGIServer, HandshakeError, UpgradeRequiredError
 
 util._hoppish = {}.__contains__
+logger = logging.getLogger('django.request')
 
 
 class WebsocketRunServer(WebsocketWSGIServer):
@@ -63,7 +64,7 @@ def select(self, rlist, wlist, xlist, timeout=None):
         return select.select(rlist, wlist, xlist, timeout)
 
 
-def run(addr, port, wsgi_handler, ipv6=False, threading=False):
+def run(addr, port, wsgi_handler, ipv6=False, threading=False, **kwargs):
     """
     Function to monkey patch the internal Django command: manage.py runserver
     """
diff --git a/ws4redis/publisher.py b/ws4redis/publisher.py
@@ -2,9 +2,17 @@
 from redis import ConnectionPool, StrictRedis
 from ws4redis import settings
 from ws4redis.redis_store import RedisStore
+from ws4redis._compat import is_authenticated
+from redis.connection import UnixDomainSocketConnection
 
-redis_connection_pool = ConnectionPool(**settings.WS4REDIS_CONNECTION)
-
+if 'unix_socket_path' in settings.WS4REDIS_CONNECTION:
+    # rename 'unix_socket_path' to 'path' and pass as args
+    conn_args = dict(settings.WS4REDIS_CONNECTION,
+            path=settings.WS4REDIS_CONNECTION['unix_socket_path'])
+    del conn_args['unix_socket_path']
+    pool = ConnectionPool(connection_class=UnixDomainSocketConnection, **conn_args)
+else:
+    redis_connection_pool = ConnectionPool(**settings.WS4REDIS_CONNECTION)
 
 class RedisPublisher(RedisStore):
     def __init__(self, **kwargs):
@@ -32,11 +40,11 @@ def fetch_message(self, request, facility, audience='any'):
             if request and request.session:
                 channels.append('{prefix}session:{0}:{facility}'.format(request.session.session_key, prefix=prefix, facility=facility))
         if audience in ('user', 'any',):
-            if request and request.user and request.user.is_authenticated():
+            if is_authenticated(request):
                 channels.append('{prefix}user:{0}:{facility}'.format(request.user.get_username(), prefix=prefix, facility=facility))
         if audience in ('group', 'any',):
             try:
-                if request.user.is_authenticated():
+                if is_authenticated(request):
                     groups = request.session['ws4redis:memberof']
                     channels.extend('{prefix}group:{0}:{facility}'.format(g, prefix=prefix, facility=facility)
                                 for g in groups)
diff --git a/ws4redis/redis_store.py b/ws4redis/redis_store.py
@@ -2,6 +2,7 @@
 import six
 import warnings
 from ws4redis import settings
+from ws4redis._compat import is_authenticated
 
 
 """
@@ -18,7 +19,7 @@ def _wrap_users(users, request):
     """
     result = set()
     for u in users:
-        if u is SELF and request and request.user and request.user.is_authenticated():
+        if u is SELF and is_authenticated(request):
             result.add(request.user.get_username())
         else:
             result.add(u)
@@ -36,7 +37,7 @@ def _wrap_groups(groups, request):
     """
     result = set()
     for g in groups:
-        if g is SELF and request and request.user and request.user.is_authenticated():
+        if g is SELF and is_authenticated(request):
             result.update(request.session.get('ws4redis:memberof', []))
         else:
             result.add(g)
@@ -70,7 +71,7 @@ def __new__(cls, value):
                     value = value.encode()
                     return super(RedisMessage, cls).__new__(cls, value)
             elif isinstance(value, bytes):
-                if value != settings.WS4REDIS_HEARTBEAT.encode():
+                if settings.WS4REDIS_HEARTBEAT is None or value != settings.WS4REDIS_HEARTBEAT.encode():
                     return super(RedisMessage, cls).__new__(cls, value)
             elif isinstance(value, list):
                 if len(value) >= 2 and value[0] == b'message':
@@ -129,7 +130,7 @@ def _get_message_channels(self, request=None, facility='{facility}', broadcast=F
             # message is delivered to all listed groups
             channels.extend('{prefix}group:{0}:{facility}'.format(g, prefix=prefix, facility=facility)
                             for g in _wrap_groups(groups, request))
-        elif groups is True and request and request.user and request.user.is_authenticated():
+        elif groups is True and is_authenticated(request):
             # message is delivered to all groups the currently logged in user belongs to
             warnings.warn('Wrap groups=True into a list or tuple using SELF', DeprecationWarning)
             channels.extend('{prefix}group:{0}:{facility}'.format(g, prefix=prefix, facility=facility)
@@ -146,7 +147,7 @@ def _get_message_channels(self, request=None, facility='{facility}', broadcast=F
             # message is delivered to all listed users
             channels.extend('{prefix}user:{0}:{facility}'.format(u, prefix=prefix, facility=facility)
                             for u in _wrap_users(users, request))
-        elif users is True and request and request.user and request.user.is_authenticated():
+        elif users is True and is_authenticated(request):
             # message is delivered to browser instances of the currently logged in user
             warnings.warn('Wrap users=True into a list or tuple using SELF', DeprecationWarning)
             channels.append('{prefix}user:{0}:{facility}'.format(request.user.get_username(), prefix=prefix, facility=facility))
diff --git a/ws4redis/subscriber.py b/ws4redis/subscriber.py
@@ -48,7 +48,7 @@ def set_pubsub_channels(self, request, channels):
         for key in self._get_message_channels(request=request, facility=facility, **audience):
             self._subscription.subscribe(key)
 
-    def send_persited_messages(self, websocket):
+    def send_persisted_messages(self, websocket):
         """
         This method is called immediately after a websocket is openend by the client, so that
         persisted messages can be sent back to the client upon connection.
@@ -58,6 +58,9 @@ def send_persited_messages(self, websocket):
             if message:
                 websocket.send(message)
 
+    # for backwards compatibility: remove on major version upgrade (v1)
+    send_persited_messages = send_persisted_messages
+
     def get_file_descriptor(self):
         """
         Returns the file descriptor used for passing to the select call when listening
diff --git a/ws4redis/websocket.py b/ws4redis/websocket.py
@@ -1,13 +1,14 @@
 # -*- coding: utf-8 -*-
 # This code was generously pilfered from https://bitbucket.org/Jeffrey/gevent-websocket
 # written by Jeffrey Gelens (http://noppo.pro/) and licensed under the Apache License, Version 2.0
+import logging
 import six
 import struct
 from socket import error as socket_error
-from django.core.handlers.wsgi import logger
 from ws4redis.utf8validator import Utf8Validator
 from ws4redis.exceptions import WebSocketError, FrameTooLargeException
 
+logger = logging.getLogger('django.request')
 
 if six.PY3:
     xrange = range
diff --git a/ws4redis/wsgi_server.py b/ws4redis/wsgi_server.py
@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 import sys
+
+import logging
 import six
 from six.moves import http_client
 from redis import StrictRedis
@@ -8,7 +10,7 @@
     django.setup()
 from django.conf import settings
 from django.contrib.auth import get_user
-from django.core.handlers.wsgi import WSGIRequest, logger
+from django.core.handlers.wsgi import WSGIRequest
 from django.core.exceptions import PermissionDenied
 from django import http
 from django.utils.encoding import force_str
@@ -17,6 +19,8 @@
 from ws4redis.redis_store import RedisMessage
 from ws4redis.exceptions import WebSocketError, HandshakeError, UpgradeRequiredError
 
+logger = logging.getLogger('django.request')
+
 try:
     # django >= 1.8 && python >= 2.7
     # https://docs.djangoproject.com/en/1.8/releases/1.7/#django-utils-dictconfig-django-utils-importlib
@@ -25,6 +29,12 @@
     # RemovedInDjango19Warning: django.utils.importlib will be removed in Django 1.9.
     from django.utils.importlib import import_module
 
+try:
+    # django >= 1.7
+    from django.utils.module_loading import import_string
+except ImportError:
+    # django >= 1.5
+    from django.utils.module_loading import import_by_path as import_string
 
 class WebsocketWSGIServer(object):
     def __init__(self, redis_connection=None):
@@ -37,6 +47,7 @@ def __init__(self, redis_connection=None):
         self.possible_channels = Subscriber.subscription_channels + Subscriber.publish_channels
         self._redis_connection = redis_connection and redis_connection or StrictRedis(**private_settings.WS4REDIS_CONNECTION)
         self.Subscriber = Subscriber
+        self._websockets = set()  # a list of currently active websockets
 
     def assure_protocol_requirements(self, environ):
         if environ.get('REQUEST_METHOD') != 'GET':
@@ -57,7 +68,6 @@ def process_request(self, request):
             request.session = engine.SessionStore(session_key)
             request.user = SimpleLazyObject(lambda: get_user(request))
 
-
     def process_subscriptions(self, request):
         agreed_channels = []
         echo_message = False
@@ -69,6 +79,10 @@ def process_subscriptions(self, request):
                 echo_message = True
         return agreed_channels, echo_message
 
+    @property
+    def websockets(self):
+        return self._websockets
+
     def __call__(self, environ, start_response):
         """
         Hijack the main loop from the original thread and listen on events on the Redis
@@ -79,7 +93,9 @@ def __call__(self, environ, start_response):
         try:
             self.assure_protocol_requirements(environ)
             request = WSGIRequest(environ)
-            if callable(private_settings.WS4REDIS_PROCESS_REQUEST):
+            if isinstance(private_settings.WS4REDIS_PROCESS_REQUEST, six.string_types):
+                import_string(private_settings.WS4REDIS_PROCESS_REQUEST)(request)
+            elif callable(private_settings.WS4REDIS_PROCESS_REQUEST):
                 private_settings.WS4REDIS_PROCESS_REQUEST(request)
             else:
                 self.process_request(request)
@@ -95,14 +111,15 @@ def __call__(self, environ, start_response):
                 except AttributeError:
                     pass
             websocket = self.upgrade_websocket(environ, start_response)
+            self._websockets.add(websocket)
             logger.debug('Subscribed to channels: {0}'.format(', '.join(channels)))
             subscriber.set_pubsub_channels(request, channels)
             websocket_fd = websocket.get_file_descriptor()
             listening_fds = [websocket_fd]
             redis_fd = subscriber.get_file_descriptor()
             if redis_fd:
                 listening_fds.append(redis_fd)
-            subscriber.send_persited_messages(websocket)
+            subscriber.send_persisted_messages(websocket)
             recvmsg = None
             while websocket and not websocket.closed:
                 ready = self.select(listening_fds, [], [], 4.0)[0]
@@ -124,6 +141,9 @@ def __call__(self, environ, start_response):
                 # because the websocket can closed previously in the loop.
                 if private_settings.WS4REDIS_HEARTBEAT and not websocket.closed:
                     websocket.send(private_settings.WS4REDIS_HEARTBEAT)
+                # Remove websocket from _websockets if closed
+                if websocket.closed:
+                    self._websockets.remove(websocket)
         except WebSocketError as excpt:
             logger.warning('WebSocketError: {}'.format(excpt), exc_info=sys.exc_info())
             response = http.HttpResponse(status=1001, content='Websocket Closed')

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`# -- coding: utf-8 --`
`2`		`-__version__ = '0.4.6'`
	`2`	`+__version__ = '0.5.0'`