django-nativemojo 0.1.10__py3-none-any.whl → 0.1.15__py3-none-any.whl

mojo/ws4redis/connection.py

@@ -1,327 +0,0 @@
-import time
-from objict import objict
-from django.core.handlers.wsgi import WSGIRequest
-from django.apps import apps
-
-from mojo.ws4redis import settings as private_settings
-from mojo.ws4redis.redis import RedisStore, RedisMessage
-
-from mojo.apps.account.utils.jwtoken import JWToken
-from mojo.helpers import request as rhelper
-from mojo.helpers.logit import get_logger
-logger = get_logger("async", filename="async.log")
-
-MODEL_CACHE = dict()  # caching of app.Model for faster access
-
-ALLOW_ANY_FACILITY = not private_settings.WS4REDIS_FACILITIES
-DISCONNECT_AFTER_NO_CREDS = 30
-
-
-
-class WebsocketConnection():
-    def __init__(self, server, environ, start_response):
-        self.server = server
-        self.request = WSGIRequest(environ)
-        self.ip = rhelper.get_remote_ip(self.request)
-        self.ua = rhelper.get_user_agent(self.request)
-        self.facility = self.request.path_info.replace(private_settings.WEBSOCKET_URL, '', 1)
-        self.credentials = objict()
-        self.listening_fds = None
-        self.redis = RedisStore(server._redis_connection)
-        self.websocket = server.upgrade_websocket(environ, start_response)
-        self.last_beat = time.time()
-        self.conneted_time = time.time()
-        self.last_msg = None
-        self._heart_beat = private_settings.WS4REDIS_HEARTBEAT
-        self.debug = private_settings.WS4REDIS_LOG_DEBUG
-
-    @property
-    def elapsed_time(self):
-        return time.time() - self.conneted_time
-
-    def refreshFDs(self):
-        if len(self.listening_fds) == 1:
-            sub_sd = self.redis.get_file_descriptor()
-            if sub_sd:
-                self.listening_fds.append(sub_sd)
-
-    def on_auth(self, msg):
-        if msg.kind == "jwt":
-            self.on_auth_jwt(msg)
-            return
-        # check our other auth mechanisms
-        auther = self.getAuthenticator(msg.kind)
-        if auther is None or not hasattr(auther, "authWS4RedisConnection"):
-            logger.error(f"{self.ip} invalid auth", msg)
-            self.sendToWS(msg.channel, dict(error="invalid auth kind", code=500))
-            return
-
-        # logger.info(f"{self.ip} authenticating")
-        self.credentials = auther.authWS4RedisConnection(msg)
-        if self.credentials is None or self.credentials.pk is None:
-            logger.error(f"{self.ip} invalid credentials for", msg, self.credentials)
-            self.sendToWS(msg.channel, dict(error="invalid credentials", code=401))
-            return
-        self.on_authenticated()
-
-    def on_auth_jwt(self, msg):
-        token = JWToken()
-        if token.payload is None:
-            raise Exception("invalid auth token")
-        User = apps.get_model("account", "User")
-        user, error = User.validate_jwt(token)
-        if error is not None:
-            raise Exception(error)
-        self.credentials = objict(kind="user", instance=user, pk=user.pk, uuid=user.username)
-        self.on_authenticated()
-
-    def on_authenticated(self):
-        if self.debug:
-            logger.info(F"authenticated {self.credentials.kind}: {self.credentials.uuid}")
-        if self.credentials.kind == "user":
-            channel_key = self.redis.subscribe("user", self.facility, self.credentials.uuid)
-            self.forwardPending(channel_key)
-        else:
-            channel_key = self.redis.subscribe(self.credentials.kind, self.facility, self.credentials.uuid)
-            self.forwardPending(channel_key)
-
-        self.redis.publishModelOnline(self.credentials.kind, self.credentials.pk, only_one=self.credentials.only_one)
-        self.refreshFDs()
-        if self.credentials and self.credentials.instance:
-            if hasattr(self.credentials.instance, "on_ws_online"):
-                self.credentials.instance.on_ws_online()
-
-    def forwardPending(self, channel_key):
-        msg = self.redis.getPendingMessage(channel_key)
-        if msg:
-            if self.debug:
-                logger.info("pending messages", repr(msg))
-            channel, pk = self.parseChannel(channel_key)
-            self.sendToWS(channel, msg, pk)
-
-    def on_resubscribe(self, msg):
-        for ch in msg.channels:
-            self.redis.subscribe(ch.channel, self.facility, ch.pk)
-
-    def getAppModel(self, app_model):
-        if app_model not in MODEL_CACHE:
-            app_label, model_name = app_model.split('.')
-            MODEL_CACHE[app_model] = apps.get_model(app_label, model_name)
-        return MODEL_CACHE[app_model]
-
-    def getAuthenticator(self, channel):
-        auther_path = private_settings.WS4REDIS_AUTHENTICATORS.get(channel, None)
-        if auther_path is not None:
-            return self.getAppModel(auther_path)
-        return None
-
-    def on_subscribe(self, msg):
-        pks = self.canSubscribeTo(msg)
-        if bool(pks):
-            for pk in pks:
-                channel_key = self.redis.subscribe(msg.channel, self.facility, pk)
-        else:
-            logger.warning("subscribe permission denied", msg)
-            self.sendToWS(msg.channel, dict(error="subscribe permission denied"))
-
-    def canSubscribeTo(self, msg):
-        ch_model = private_settings.WS4REDIS_CHANNELS.get(msg.channel, None)
-        if not ch_model:
-            return None
-        if ch_model == "any":
-            # this allows anything to be sent
-            return [msg.pk]
-        Model = self.getAppModel(ch_model)
-        if not hasattr(Model, "can_ws_subscribe_to"):
-            return None
-        return Model.can_ws_subscribe_to(self.credentials, msg)
-
-    def on_unsubscribe(self, msg):
-        self.redis.unsubscribe(msg.channel, self.facility, msg.pk)
-
-    def on_publish(self, msg):
-        if self.canPublishTo(msg):
-            self.redis.publish(msg.message, channel=msg.channel, pk=msg.pk)
-        else:
-            logger.warning("publish permission denied", msg)
-            self.sendToWS(msg.channel, dict(error="publish permission denied"))
-
-    def canPublishTo(self, msg):
-        ch_model = private_settings.WS4REDIS_CHANNELS.get(msg.channel, None)
-        if not ch_model:
-            # you can publish to any channels you may create
-            return True
-        Model = self.getAppModel(ch_model)
-        if not hasattr(Model, "canPublishTo"):
-            logger.warning("canPublishTo", "no canPublishTo")
-            return False
-        return Model.can_ws_publish_to(self.credentials, msg)
-
-    def on_ws_msg(self, raw_data):
-        if isinstance(raw_data, bytes):
-            raw_data = raw_data.decode()
-        if raw_data == self._heart_beat:
-            # echo the heartbeat
-            self.websocket.send(self._heart_beat)
-            return
-        if self.debug:
-            logger.info("on_ws_msg", repr(raw_data))
-        dmsg = objict.from_json(raw_data, ignore_errors=True)
-        if dmsg.action:
-            # this is a special message that we want to handle directly
-            try:
-                if dmsg.action == "auth":
-                    self.on_auth(dmsg)
-                elif dmsg.action == "subscribe":
-                    self.on_subscribe(dmsg)
-                elif dmsg.action == "unsubscribe":
-                    self.on_unsubscribe(dmsg)
-                elif dmsg.action == "resubscribe":
-                    self.on_resubscribe(dmsg)
-                elif dmsg.action == "publish":
-                    self.on_publish(dmsg)
-                elif dmsg.action == "save":
-                    self.on_save(dmsg)
-                elif dmsg.channel:
-                    self.on_channel_msg(dmsg)
-            except Exception as err:
-                self.sendToWS(dmsg.get("channel", "system"), dict(error=str(err)))
-                logger.exception(self.ip)
-
-    def on_save(self, msg):
-        if self.credentials and self.credentials.instance:
-            if hasattr(self.credentials.instance, "on_ws_save"):
-                resp = objict(id=msg.id, name="save")
-                if msg.echo:
-                    resp.data = msg.data
-                resp.status = self.credentials.instance.on_ws_save(msg)
-                self.sendToWS(self.credentials.kind, resp)
-
-    def on_channel_msg(self, msg):
-        if not self.canPublishTo(msg):
-            logger.warning("on_channel_msg permission denied", msg, private_settings.WS4REDIS_CHANNELS)
-            self.sendToWS(msg.channel, dict(error="cannot publish to channel"))
-            return None
-        ch_model = private_settings.WS4REDIS_CHANNELS.get(msg.channel, None)
-        if ch_model is None:
-            return None
-        Model = self.getAppModel(ch_model)
-        if not hasattr(Model, "on_ws_message"):
-            logger.warning(f"{msg.channel} does not support on_ws_message")
-            self.sendToWS(msg.channel, dict(error="channel does not support on_ws_message"))
-            return None
-        Model.on_ws_message(self.credentials, msg, self)
-
-    def on_redis_pending(self):
-        sub_resp = self.redis.getSubMessage()
-        if sub_resp:
-            if self.debug:
-                logger.info("incoming redis msg", sub_resp)
-            self.on_redis_msg(sub_resp)
-
-    def sendToWS(self, channel, message, pk=None):
-        msg = objict(channel=channel)
-        if pk is not None:
-            msg.pk = pk
-        if isinstance(message, (str, bytes)):
-            msg.message = objict.from_json(message, ignore_errors=True)
-        if not msg.message:
-            msg.message = message
-        elif msg.message.name == "logout" and msg.message.pk == self.credentials.pk:
-            raise Exception("websocket is being logged out")
-        self.websocket.send(msg.toJSON(as_string=True))
-
-    def on_redis_msg(self, sub_resp):
-        if isinstance(sub_resp, list):
-            if sub_resp[0] == b'subscribe':
-                # this is succesfull subscriptions
-                # notify ws
-                channel, pk = self.parseChannel(sub_resp[1].decode())
-                msg = objict(name="subscribed", channel=channel, status=sub_resp[2])
-                if pk is not None:
-                    msg.pk = pk
-                self.websocket.send(msg.toJSON(as_string=True))
-                return
-            elif sub_resp[0] == b'unsubscribe':
-                # this is succesfull subscriptions
-                # notify ws
-                channel, pk = self.parseChannel(sub_resp[1].decode())
-                msg = objict(name="unsubscribed", channel=channel, status=sub_resp[2])
-                if pk is not None:
-                    msg.pk = pk
-                self.websocket.send(msg.toJSON(as_string=True))
-                return
-            elif sub_resp[0] == b'message':
-                channel, pk = self.parseChannel(sub_resp[1].decode())
-                self.sendToWS(channel, sub_resp[2].decode(), pk)
-                return
-        sendmsg = RedisMessage(sub_resp)
-        if self.debug:
-            logger.info(sub_resp)
-        if sendmsg:
-            if self.debug:
-                logger.info("pushing to websocket", sendmsg)
-            self.websocket.send(sendmsg)
-
-    def parseChannel(self, channel):
-        fields = channel.split(":")
-        fields.pop(0)
-        fields.pop()
-        if len(fields) == 1:
-            return fields[0], None
-        return fields[0], fields[1]
-
-    def on_ws_pending(self):
-        try:
-            self.last_msg = self.websocket.receive()
-            if bool(self.last_msg):
-                self.on_ws_msg(self.last_msg)
-        except Exception:
-            # logger.exception()
-            logger.error(f"{self.ip}: unable to recv on ws... flushing")
-            self.websocket.flush()
-
-    def checkHeartbeat(self):
-        beat_delta = time.time() - self.last_beat
-        if beat_delta > 30.0:
-            self.last_beat = time.time()
-            if private_settings.WS4REDIS_HEARTBEAT and not self.websocket.closed:
-                # logger.info("send heartbeat")
-                self.websocket.send(private_settings.WS4REDIS_HEARTBEAT)
-
-    def release(self):
-        self.redis.release()
-        self.listening_fds = None
-        if self.websocket:
-            self.websocket.close(code=1001, message='Websocket Closed')
-        if self.credentials and self.credentials.instance:
-            if hasattr(self.credentials.instance, "on_ws_offline"):
-                self.credentials.instance.on_ws_offline()
-
-    def handleComs(self):
-        # check if token is in url
-        if not ALLOW_ANY_FACILITY and self.facility not in private_settings.WS4REDIS_FACILITIES:
-            self.sendToWS("facility", dict(error=f"facility name not allowed: '{self.facility}'.  Please check your connection URL."))
-            return
-
-        websocket_fd = self.websocket.get_file_descriptor()
-        self.listening_fds = [websocket_fd]
-        if callable(private_settings.URL_AUTHENTICATOR):
-            private_settings.URL_AUTHENTICATOR(self)
-
-        while self.websocket and not self.websocket.closed:
-            ready = self.server.select(self.listening_fds, [], [], 4.0)[0]
-            if not ready:
-                self.websocket.flush()
-            if not self.credentials:
-                if self.elapsed_time > 8 and self.elapsed_time < 30:
-                    logger.error(f"{self.ip} has sent no credentials", self.ua)
-                    self.sendToWS("user", dict(error="no credentials received"))
-                elif private_settings.WS4REDIS_NOAUTH_CLOSE and self.elapsed_time > 30:
-                    self.release()
-
-            for fd in ready:
-                if fd == websocket_fd:
-                    self.on_ws_pending()
-                else:
-                    self.on_redis_pending()

mojo/ws4redis/exceptions.py

@@ -1,32 +0,0 @@
-#-*- coding: utf-8 -*-
-from socket import error as socket_error
-from django.http import BadHeaderError
-
-
-class WebSocketError(socket_error):
-    """
-    Raised when an active websocket encounters a problem.
-    """
-
-
-class FrameTooLargeException(WebSocketError):
-    """
-    Raised if a received frame is too large.
-    """
-
-
-class HandshakeError(BadHeaderError):
-    """
-    Raised if an error occurs during protocol handshake.
-    """
-
-
-class UpgradeRequiredError(HandshakeError):
-    """
-    Raised if protocol must be upgraded.
-    """
-
-class SSLRequiredError(socket_error):
-    """
-    Raised if protocol must be upgraded.
-    """

mojo/ws4redis/redis.py

@@ -1,183 +0,0 @@
-from redis import ConnectionPool, StrictRedis
-
-from mojo.ws4redis import settings
-import time
-from objict import objict
-
-from mojo.helpers.logit import get_logger
-logger = get_logger("async", filename="async.log")
-
-
-REDIS_CON_POOL = None
-
-
-def getRedisClient():
-    global REDIS_CON_POOL
-    if REDIS_CON_POOL is None:
-        REDIS_CON_POOL = ConnectionPool(**settings.WS4REDIS_CONNECTION)
-    return StrictRedis(connection_pool=REDIS_CON_POOL)
-
-
-# Function to check the number of connections in use and available
-def getPoolStatus():
-    status = objict()
-    if REDIS_CON_POOL is None:
-        return status
-    status.max_size = REDIS_CON_POOL.max_connections
-    status.size = REDIS_CON_POOL._created_connections
-    status.in_use = len(REDIS_CON_POOL._in_use_connections)
-    status.available = len(REDIS_CON_POOL._available_connections)
-    return status
-
-
-class RedisMessage(bytes):
-    def __new__(cls, value):
-        if isinstance(value, str):
-            if value != settings.WS4REDIS_HEARTBEAT:
-                return bytes(value, 'utf-8')
-        elif isinstance(value, list):
-            if len(value) >= 2 and value[0] == b'message':
-                return value[2]
-        elif isinstance(value, dict):
-            if not hasattr(value, "toJSON"):
-                value = objict(value)
-            return bytes(value.toJSON(as_string=True), 'utf-8')
-        elif isinstance(value, bytes):
-            return value
-        return None
-
-
-class RedisStore():
-    def __init__(self, connection=None):
-        self.connection = connection
-        if self.connection is None:
-            self.connection = getRedisClient()
-        self.subscriptions = []
-        self.pubsub = None
-        self.online_pk = None
-        self.online_channel = None
-        self.only_one = False  # don't count connections, only allows one instance
-        self.expire = settings.WS4REDIS_EXPIRE
-
-    def publish(self, message, channel, facility="events", pk=None, expire=None, prefix=settings.WS4REDIS_PREFIX):
-        if expire is None:
-            expire = self.expire
-        if not isinstance(message, RedisMessage):
-            message = RedisMessage(message)
-
-        if not isinstance(message, bytes):
-            raise ValueError('message is {} but should be bytes'.format(type(message)))
-
-        if isinstance(pk, list):
-            count = 0
-            for spk in pk:
-                count += self.publish(message, channel, facility, pk=spk, expire=expire, prefix=prefix)
-            return count
-
-        channel_key = self.channelToKey(channel, facility, pk, prefix)
-        if settings.WS4REDIS_LOG_DEBUG:
-            logger.info("publishing msg to: {0}".format(channel_key), message)
-        count = self.connection.publish(channel_key, message)
-        return count
-
-    def getSubMessage(self):
-        # get a message pending from subscription
-        if self.pubsub:
-            return self.pubsub.parse_response()
-        return None
-
-    def getPendingMessage(self, channel, facility="events", pk=None, prefix=settings.WS4REDIS_PREFIX):
-        # get a message from the connection channel
-        channel_key = self.channelToKey(channel, facility, pk, prefix)
-        return self.connection.get(channel_key)
-
-    def channelToKey(self, channel, facility="events", pk=None, prefix=settings.WS4REDIS_PREFIX):
-        if not pk:
-            key = F'{prefix}:{channel}:{facility}'
-        else:
-            key = F'{prefix}:{channel}:{pk}:{facility}'
-        return key
-
-    def subscribe(self, channel, facility="events", pk=None, prefix=settings.WS4REDIS_PREFIX):
-        if self.pubsub is None:
-            self.pubsub = self.connection.pubsub()
-        key = self.channelToKey(channel, facility, pk, prefix)
-        if key not in self.subscriptions:
-            if settings.WS4REDIS_LOG_DEBUG:
-                logger.info(F"subscribing to: {key}")
-            self.subscriptions.append(key)
-            self.pubsub.subscribe(key)
-        return key
-
-    def unsubscribe(self, channel, facility, pk=None, prefix=settings.WS4REDIS_PREFIX):
-        key = self.channelToKey(channel, facility, pk, prefix)
-        if key in self.subscriptions:
-            if settings.WS4REDIS_LOG_DEBUG:
-                logger.info(F"unsubscribing to: {key}")
-            self.subscriptions.remove(key)
-            self.pubsub.unsubscribe(key)
-
-    def publishModelOnline(self, name, pk, only_one=False):
-        if self.online_pk is None:
-            self.online_pk = pk
-            self.online_channel = name
-            self.only_one = only_one
-            if self.only_one:
-                self.connection.sadd(F"{name}:online", pk)
-            else:
-                count = self.connection.hincrby(F"{name}:online:connections", pk, 1)
-                if count == 1:
-                    self.connection.sadd(F"{name}:online", pk)
-
-    def unpublishModelOnline(self):
-        if self.online_pk:
-            name = self.online_channel
-            pk = self.online_pk
-            self.online_channel = None
-            self.online_pk = None
-            if self.only_one:
-                self.connection.srem(F"{name}:online", pk)
-            else:
-                count = self.connection.hincrby(F"{name}:online:connections", pk, -1)
-                if count == 0:
-                    self.connection.srem(F"{name}:online", pk)
-
-    def waitForMessage(self, muid=None, timeout=55):
-        timeout_at = time.time() + timeout
-        while time.time() < timeout_at:
-            message = self.pubsub.get_message()
-            if message is not None and message.get("type") == "message":
-                imsg = objict.from_json(message.get("data"))
-                if muid is not None and imsg.muid == muid:
-                    return imsg
-                elif muid is None:
-                    return imsg
-            time.sleep(1.0)
-        return None
-
-    def get_file_descriptor(self):
-        """
-        Returns the file descriptor used for passing to the select call when listening
-        on the message queue.
-        """
-        if self.pubsub.connection:
-            return self.pubsub.connection._sock.fileno()
-        return None
-
-    def release(self):
-        """
-        New implementation to free up Redis subscriptions when websockets close. This prevents
-        memory sap when Redis Output Buffer and Output Lists build when websockets are abandoned.
-        """
-        self.unpublishModelOnline()
-        if self.pubsub and self.pubsub.subscribed:
-            self.pubsub.unsubscribe()
-            self.pubsub.reset()
-        self.connection = None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.release()
-        return False

mojo/ws4redis/servers/base.py

@@ -1,86 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-from redis import StrictRedis
-from http import client as http_client
-from mojo.ws4redis import settings as private_settings
-from mojo.ws4redis.exceptions import WebSocketError, HandshakeError, UpgradeRequiredError, SSLRequiredError
-from mojo.ws4redis.connection import WebsocketConnection
-
-from django.core.exceptions import PermissionDenied
-from django.utils.encoding import force_str
-from django import http
-
-from mojo.helpers.logit import get_logger
-logger = get_logger("async", filename="async.log")
-
-
-class WebsocketServerBase(object):
-    def __init__(self, redis_connection=None):
-        """
-        redis_connection can be overriden by a mock object.
-        """
-        self._websockets = set()  # a list of currently active websockets
-        self._redis_connection = redis_connection
-        if redis_connection is None:
-            self._redis_connection = StrictRedis(**private_settings.WS4REDIS_CONNECTION)
-
-        # clear out all online user connections from redis
-        self._redis_connection.delete("users:online:connections")
-        self._redis_connection.delete("users:online")
-
-    def assure_protocol_requirements(self, environ):
-        if environ.get('REQUEST_METHOD') != 'GET':
-            raise HandshakeError('HTTP method must be a GET')
-
-        if environ.get('SERVER_PROTOCOL') != 'HTTP/1.1':
-            raise HandshakeError('HTTP server protocol must be 1.1')
-
-        if environ.get('HTTP_UPGRADE', '').lower() != 'websocket':
-            raise HandshakeError('Client does not wish to upgrade to a websocket')
-
-    @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 Redis and Websockets"""
-        connection = None
-        try:
-            self.assure_protocol_requirements(environ)
-            connection = WebsocketConnection(self, environ, start_response)
-            connection.handleComs()
-        except WebSocketError:
-            logger.exception()
-            response = http.HttpResponse(status=1001, content='Websocket Closed')
-        except UpgradeRequiredError as excpt:
-            logger.exception()
-            response = http.HttpResponseBadRequest(status=426, content=excpt)
-        except HandshakeError as excpt:
-            logger.exception()
-            response = http.HttpResponseBadRequest(content=excpt)
-        except PermissionDenied as excpt:
-            logger.exception("PermissionDenied")
-            logger.warning('PermissionDenied: {}'.format(excpt), exc_info=sys.exc_info())
-            response = http.HttpResponseForbidden(content=excpt)
-        except SSLRequiredError as excpt:
-            logger.exception("SSLRequiredError")
-            response = http.HttpResponseServerError(content=excpt)
-        except Exception as excpt:
-            logger.exception()
-            response = http.HttpResponseServerError(content=excpt)
-        else:
-            response = http.HttpResponse()
-        finally:
-            logger.info("closing websocket")
-            if connection:
-                connection.release()
-            else:
-                logger.warning('Starting late response on websocket')
-                status_text = http_client.responses.get(response.status_code, 'UNKNOWN STATUS CODE')
-                status = '{0} {1}'.format(response.status_code, status_text)
-                # headers = list(response._headers.values())
-                # if six.PY3:
-                #     headers = list(headers)
-                start_response(force_str(status), [])
-                logger.info('Finish non-websocket response with status code: {}'.format(response.status_code))
-        return response