django-nativemojo 0.1.10__py3-none-any.whl

mojo/ws4redis/websocket.py

@@ -0,0 +1,403 @@
+# -*- 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 struct
+from socket import error as socket_error
+from mojo.ws4redis.utf8validator import Utf8Validator
+from mojo.ws4redis.exceptions import WebSocketError, FrameTooLargeException
+
+from mojo.helpers.logit import get_logger
+logger = get_logger("async", filename="async.log")
+
+
+class WebSocket(object):
+    __slots__ = ('_closed', 'stream', 'utf8validator', 'utf8validate_last')
+
+    OPCODE_CONTINUATION = 0x00
+    OPCODE_TEXT = 0x01
+    OPCODE_BINARY = 0x02
+    OPCODE_CLOSE = 0x08
+    OPCODE_PING = 0x09
+    OPCODE_PONG = 0x0a
+
+    def __init__(self, wsgi_input):
+        self._closed = False
+        self.stream = Stream(wsgi_input)
+        self.utf8validator = Utf8Validator()
+        self.utf8validate_last = None
+
+    def __del__(self):
+        try:
+            self.close()
+        except:
+            # close() may fail if __init__ didn't complete
+            pass
+
+    def _decode_bytes(self, bytestring):
+        """
+        Internal method used to convert the utf-8 encoded bytestring into unicode.
+        If the conversion fails, the socket will be closed.
+        """
+        if not bytestring:
+            return u''
+        try:
+            return bytestring.decode('utf-8')
+        except UnicodeDecodeError:
+            self.close(1007)
+            raise
+
+    def _encode_bytes(self, text):
+        """
+        :returns: The utf-8 byte string equivalent of `text`.
+        """
+        if isinstance(text, bytes):
+            return text
+        if not isinstance(text, bytes):
+            text = str(text or '')
+        return text.encode('utf-8')
+
+    def _is_valid_close_code(self, code):
+        """
+        :returns: Whether the returned close code is a valid hybi return code.
+        """
+        if code < 1000:
+            return False
+        if 1004 <= code <= 1006:
+            return False
+        if 1012 <= code <= 1016:
+            return False
+        if code == 1100:
+            # not sure about this one but the autobahn fuzzer requires it.
+            return False
+        if 2000 <= code <= 2999:
+            return False
+        return True
+
+    def get_file_descriptor(self):
+        """Return the file descriptor for the given websocket"""
+        return self.stream.fileno
+
+    @property
+    def closed(self):
+        return self._closed
+
+    def handle_close(self, header, payload):
+        """
+        Called when a close frame has been decoded from the stream.
+
+        :param header: The decoded `Header`.
+        :param payload: The bytestring payload associated with the close frame.
+        """
+        if not payload:
+            self.close(1000, None)
+            return
+        if len(payload) < 2:
+            raise WebSocketError('Invalid close frame: {0} {1}'.format(header, payload))
+        rv = payload[:2]
+        code = struct.unpack('!H', bytes(rv))[0]
+        payload = payload[2:]
+        if payload:
+            validator = Utf8Validator()
+            val = validator.validate(payload)
+            if not val[0]:
+                raise UnicodeError
+        if not self._is_valid_close_code(code):
+            raise WebSocketError('Invalid close code {0}'.format(code))
+        self.close(code, payload)
+
+    def handle_ping(self, header, payload):
+        self.send_frame(payload, self.OPCODE_PONG)
+
+    def handle_pong(self, header, payload):
+        pass
+
+    def read_frame(self):
+        """
+        Block until a full frame has been read from the socket.
+
+        This is an internal method as calling this will not cleanup correctly
+        if an exception is called. Use `receive` instead.
+
+        :return: The header and payload as a tuple.
+        """
+        header = Header.decode_header(self.stream)
+        if header.flags:
+            raise WebSocketError
+        if not header.length:
+            return header, ''
+        try:
+            payload = self.stream.read(header.length)
+        except socket_error:
+            payload = ''
+        except Exception as e:
+            logger.debug("{}: {}".format(type(e), str(e)))
+            payload = ''
+        if len(payload) != header.length:
+            raise WebSocketError('Unexpected EOF reading frame payload')
+        if header.mask:
+            payload = header.unmask_payload(payload)
+        return header, payload
+
+    def validate_utf8(self, payload):
+        # Make sure the frames are decodable independently
+        self.utf8validate_last = self.utf8validator.validate(payload)
+
+        if not self.utf8validate_last[0]:
+            raise UnicodeError("Encountered invalid UTF-8 while processing "
+                               "text message at payload octet index "
+                               "{0:d}".format(self.utf8validate_last[3]))
+
+    def read_message(self):
+        """
+        Return the next text or binary message from the socket.
+
+        This is an internal method as calling this will not cleanup correctly
+        if an exception is called. Use `receive` instead.
+        """
+        opcode = None
+        message = None
+        while True:
+            header, payload = self.read_frame()
+            f_opcode = header.opcode
+            if f_opcode in (self.OPCODE_TEXT, self.OPCODE_BINARY):
+                # a new frame
+                if opcode:
+                    raise WebSocketError("The opcode in non-fin frame is expected to be zero, got {0!r}".format(f_opcode))
+                # Start reading a new message, reset the validator
+                self.utf8validator.reset()
+                self.utf8validate_last = (True, True, 0, 0)
+                opcode = f_opcode
+            elif f_opcode == self.OPCODE_CONTINUATION:
+                if not opcode:
+                    raise WebSocketError("Unexpected frame with opcode=0")
+            elif f_opcode == self.OPCODE_PING:
+                self.handle_ping(header, payload)
+                continue
+            elif f_opcode == self.OPCODE_PONG:
+                self.handle_pong(header, payload)
+                continue
+            elif f_opcode == self.OPCODE_CLOSE:
+                self.handle_close(header, payload)
+                return
+            else:
+                raise WebSocketError("Unexpected opcode={0!r}".format(f_opcode))
+            if opcode == self.OPCODE_TEXT:
+                self.validate_utf8(payload)
+                payload = payload.decode()
+            if message is None:
+                message = str() if opcode == self.OPCODE_TEXT else bytes()
+            message += payload
+            if header.fin:
+                break
+        if opcode == self.OPCODE_TEXT:
+            self.validate_utf8(message.encode())
+            return message
+        else:
+            return bytearray(message)
+
+    def receive(self):
+        """
+        Read and return a message from the stream. If `None` is returned, then
+        the socket is considered closed/errored.
+        """
+        if self._closed:
+            raise WebSocketError("Connection is already closed")
+        try:
+            return self.read_message()
+        except UnicodeError as e:
+            logger.info('websocket.receive: UnicodeError {}'.format(e))
+            self.close(1007)
+        except WebSocketError as e:
+            logger.info('websocket.receive: WebSocketError {}'.format(e))
+            self.close(1002)
+        except Exception as e:
+            logger.info('websocket.receive: Unknown error {}'.format(e))
+            raise e
+
+    def flush(self):
+        """
+        Flush a websocket. In this implementation intentionally it does nothing.
+        """
+        pass
+
+    def send_frame(self, message, opcode):
+        """
+        Send a frame over the websocket with message as its payload
+        """
+        if self._closed:
+            raise WebSocketError("Connection is already closed")
+        if opcode == self.OPCODE_TEXT:
+            message = self._encode_bytes(message)
+        elif opcode == self.OPCODE_BINARY:
+            message = bytes(message)
+        header = Header.encode_header(True, opcode, '', len(message), 0)
+        try:
+            self.stream.write(header + message)
+        except socket_error:
+            raise WebSocketError("Socket is dead")
+
+    def send(self, message, binary=False):
+        """
+        Send a frame over the websocket with message as its payload
+        """
+        if binary is None:
+            binary = not isinstance(message, str)
+        opcode = self.OPCODE_BINARY if binary else self.OPCODE_TEXT
+        try:
+            self.send_frame(message, opcode)
+        except WebSocketError:
+            raise WebSocketError("Socket is dead")
+
+    def close(self, code=1000, message=''):
+        """
+        Close the websocket and connection, sending the specified code and
+        message.  The underlying socket object is _not_ closed, that is the
+        responsibility of the initiator.
+        """
+        try:
+            message = self._encode_bytes(message)
+            self.send_frame(
+                struct.pack('!H%ds' % len(message), code, message),
+                opcode=self.OPCODE_CLOSE)
+        except WebSocketError:
+            # Failed to write the closing frame but it's ok because we're
+            # closing the socket anyway.
+            logger.debug("Failed to write closing frame -> closing socket")
+        finally:
+            logger.debug("Closed WebSocket")
+            self._closed = True
+            self.stream = None
+
+
+class Stream(object):
+    """
+    Wraps the handler's socket/rfile attributes and makes it in to a file like
+    object that can be read from/written to by the lower level websocket api.
+    """
+
+    __slots__ = ('read', 'write', 'fileno')
+
+    def __init__(self, wsgi_input):
+        self.read = wsgi_input.raw._sock.recv
+        self.write = wsgi_input.raw._sock.sendall
+        self.fileno = wsgi_input.fileno()
+
+
+class Header(object):
+    __slots__ = ('fin', 'mask', 'opcode', 'flags', 'length')
+
+    FIN_MASK = 0x80
+    OPCODE_MASK = 0x0f
+    MASK_MASK = 0x80
+    LENGTH_MASK = 0x7f
+    RSV0_MASK = 0x40
+    RSV1_MASK = 0x20
+    RSV2_MASK = 0x10
+
+    # bitwise mask that will determine the reserved bits for a frame header
+    HEADER_FLAG_MASK = RSV0_MASK | RSV1_MASK | RSV2_MASK
+
+    def __init__(self, fin=0, opcode=0, flags=0, length=0):
+        self.mask = ''
+        self.fin = fin
+        self.opcode = opcode
+        self.flags = flags
+        self.length = length
+
+    def mask_payload(self, payload):
+        payload = bytearray(payload)
+        mask = bytearray(self.mask)
+        for i in range(self.length):
+            payload[i] ^= mask[i % 4]
+        return bytes(payload)
+
+    # it's the same operation
+    unmask_payload = mask_payload
+
+    def __repr__(self):
+        return ("<Header fin={0} opcode={1} length={2} flags={3} at "
+                "0x{4:x}>").format(self.fin, self.opcode, self.length,
+                                   self.flags, id(self))
+
+    @classmethod
+    def decode_header(cls, stream):
+        """
+        Decode a WebSocket header.
+
+        :param stream: A file like object that can be 'read' from.
+        :returns: A `Header` instance.
+        """
+        read = stream.read
+        data = read(2)
+        if len(data) != 2:
+            raise WebSocketError("Unexpected EOF while decoding header")
+        first_byte, second_byte = struct.unpack('!BB', data)
+        header = cls(
+            fin=first_byte & cls.FIN_MASK == cls.FIN_MASK,
+            opcode=first_byte & cls.OPCODE_MASK,
+            flags=first_byte & cls.HEADER_FLAG_MASK,
+            length=second_byte & cls.LENGTH_MASK)
+        has_mask = second_byte & cls.MASK_MASK == cls.MASK_MASK
+        if header.opcode > 0x07:
+            if not header.fin:
+                raise WebSocketError('Received fragmented control frame: {0!r}'.format(data))
+            # Control frames MUST have a payload length of 125 bytes or less
+            if header.length > 125:
+                raise FrameTooLargeException('Control frame cannot be larger than 125 bytes: {0!r}'.format(data))
+        if header.length == 126:
+            # 16 bit length
+            data = read(2)
+            if len(data) != 2:
+                raise WebSocketError('Unexpected EOF while decoding header')
+            header.length = struct.unpack('!H', data)[0]
+        elif header.length == 127:
+            # 64 bit length
+            data = read(8)
+            if len(data) != 8:
+                raise WebSocketError('Unexpected EOF while decoding header')
+            header.length = struct.unpack('!Q', data)[0]
+        if has_mask:
+            mask = read(4)
+            if len(mask) != 4:
+                raise WebSocketError('Unexpected EOF while decoding header')
+            header.mask = mask
+        return header
+
+    @classmethod
+    def encode_header(cls, fin, opcode, mask, length, flags):
+        """
+        Encodes a WebSocket header.
+
+        :param fin: Whether this is the final frame for this opcode.
+        :param opcode: The opcode of the payload, see `OPCODE_*`
+        :param mask: Whether the payload is masked.
+        :param length: The length of the frame.
+        :param flags: The RSV* flags.
+        :return: A bytestring encoded header.
+        """
+        first_byte = opcode
+        second_byte = 0
+        extra = b''
+        if fin:
+            first_byte |= cls.FIN_MASK
+        if flags & cls.RSV0_MASK:
+            first_byte |= cls.RSV0_MASK
+        if flags & cls.RSV1_MASK:
+            first_byte |= cls.RSV1_MASK
+        if flags & cls.RSV2_MASK:
+            first_byte |= cls.RSV2_MASK
+        # now deal with length complexities
+        if length < 126:
+            second_byte += length
+        elif length <= 0xffff:
+            second_byte += 126
+            extra = struct.pack('!H', length)
+        elif length <= 0xffffffffffffffff:
+            second_byte += 127
+            extra = struct.pack('!Q', length)
+        else:
+            raise FrameTooLargeException
+        if mask:
+            second_byte |= cls.MASK_MASK
+            extra += mask
+        return bytes([first_byte, second_byte]) + extra

testit/client.py

@@ -0,0 +1,147 @@
+import requests
+import base64
+from objict import objict
+
+
+class RestClient:
+    """
+    A simple REST client for making HTTP requests to a specified host.
+    """
+
+    def __init__(self, host, logger=None):
+        """
+        Initializes the SimpleRestClient with a host URL.
+
+        Args:
+            host (str): The base URL of the host for making requests.
+        """
+        self.host = host if host[-1] == "/" else f"{host}/"
+        self.logger = logger
+        self.access_token = None
+        self.is_authenticated = False
+        self.bearer = "bearer"
+        self.access_token = None
+
+    def login(self, username, password):
+        self.logout()
+        resp = self.post("/api/login", dict(username=username, password=password))
+        if resp.response.data and resp.response.data.access_token:
+            self.is_authenticated = True
+            self.access_token = resp.response.data.access_token
+            junk, self.jwt_data = decode_jwt(self.access_token)
+        return self.is_authenticated
+
+    def logout(self):
+        self.is_authenticated = False
+        self.bearer = "bearer"
+        self.access_token = None
+
+    def get_headers(self):
+        if self.is_authenticated:
+            return dict(Authorization=f"{self.bearer} {self.access_token}")
+        return {}
+
+    def _make_request(self, method, path, **kwargs):
+        """
+        Makes an HTTP request using the specified method and path.
+
+        Args:
+            method (str): The HTTP method to use for the request (e.g., 'GET', 'POST').
+            path (str): The endpoint path to append to the base host URL.
+            **kwargs: Additional arguments to pass to the request (e.g., headers, params).
+
+        Returns:
+            dict: A dictionary containing the response data and status code. If an error occurs,
+                  returns a dictionary with an error message instead.
+        """
+        if path[0] == "/":
+            path = path[1:]
+        url = f"{self.host}{path}"
+        headers = self.get_headers()
+        response = requests.request(method, url, headers=headers, **kwargs)
+        if self.logger:
+            self.logger.info("REQUEST", f"{method}:{url}", headers)
+            self.logger.info(kwargs.get("json", ""))
+        try:
+            data = objict.fromdict(response.json()) if response.content else None
+            response_data = objict(response=data, status_code=response.status_code)
+            if not response.ok:
+                response_data['error_reason'] = response.reason
+            if self.logger:
+                self.logger.info("RESPONSE", f"{method}:{url}")
+                self.logger.info(response_data)
+            return response_data
+        except Exception as e:
+            if self.logger:
+                self.logger.error("RESPONSE", f"{method}:{url}")
+                self.logger.exception(str(e), response.text)
+            return objict(error=str(e), text=response.text)
+
+    def get(self, path, **kwargs):
+        """
+        Sends a GET request to the specified path.
+
+        Args:
+            path (str): The endpoint path to append to the base host URL.
+            **kwargs: Additional arguments to pass to the request (e.g., headers, params).
+
+        Returns:
+            dict: A dictionary containing the response data and status code.
+        """
+        return self._make_request('GET', path, **kwargs)
+
+    def post(self, path, json=None, **kwargs):
+        """
+        Sends a POST request to the specified path.
+
+        Args:
+            path (str): The endpoint path to append to the base host URL.
+            json (dict, optional): The JSON data to include in the request body.
+            **kwargs: Additional arguments to pass to the request (e.g., headers).
+
+        Returns:
+            dict: A dictionary containing the response data and status code.
+        """
+        return self._make_request('POST', path, json=json, **kwargs)
+
+    def put(self, path, json=None, **kwargs):
+        """
+        Sends a PUT request to the specified path.
+
+        Args:
+            path (str): The endpoint path to append to the base host URL.
+            json (dict, optional): The JSON data to include in the request body.
+            **kwargs: Additional arguments to pass to the request (e.g., headers).
+
+        Returns:
+            dict: A dictionary containing the response data and status code.
+        """
+        return self._make_request('PUT', path, json=json, **kwargs)
+
+    def delete(self, path, **kwargs):
+        """
+        Sends a DELETE request to the specified path.
+
+        Args:
+            path (str): The endpoint path to append to the base host URL.
+            **kwargs: Additional arguments to pass to the request (e.g., headers).
+
+        Returns:
+            dict: A dictionary containing the response data and status code.
+        """
+        return self._make_request('DELETE', path, **kwargs)
+
+
+
+def base64_decode(data):
+    """Decode base64-encoded data."""
+    padding = '=' * (-len(data) % 4)
+    return base64.urlsafe_b64decode(data + padding)
+
+
+def decode_jwt(token):
+    """Decode a JWT token using base64 decoding."""
+    headers, payload, signature = token.split('.')
+    decoded_headers = objict.fromJSON(base64_decode(headers))
+    decoded_payload = objict.fromJSON(base64_decode(payload))
+    return decoded_headers, decoded_payload

testit/faker.py

@@ -0,0 +1,20 @@
+from faker import Faker
+
+fake = Faker()
+
+def generate_person():
+    return {
+        'first_name': fake.first_name(),
+        'last_name': fake.last_name(),
+        'dob': fake.date_of_birth(),
+        'city': fake.city(),
+        'state': fake.state(),
+        'zipcode': fake.zipcode()
+    }
+
+def generate_name():
+    return fake.catch_phrase()
+
+
+def generate_text():
+    return fake.text()