totalsync-webinterface 0.1.1__py3-none-any.whl

totalsync_webinterface/web_interface.py

@@ -0,0 +1,268 @@
+import functools
+import http.server
+import json
+import logging
+import os
+import re
+import socketserver
+import threading
+from importlib import resources
+from pathlib import Path
+
+import numpy as np
+
+from .websocket_server import WebsocketServer as ReconnectingWebsocketServer
+
+WS_PORT = 5678
+HTTP_PORT = 8000
+
+# web/ lives inside this package rather than beside it, so the build backend ships it
+# without any package-data declaration to keep in step -- get that wrong and the wheel
+# installs an interface with no JS. importlib.resources then finds it wherever the
+# package ends up, with no '..' arithmetic that a move would silently invalidate.
+#
+# os.fspath() because SimpleHTTPRequestHandler(directory=) and read_text() both want a
+# real filesystem path. For a normally installed wheel the traversable *is* one; if the
+# package were ever zipimported this raises instead of quietly serving nothing.
+WEB_DIRECTORY = os.fspath(resources.files(__package__) / 'web')
+
+# The pin sheet labels are baked into index.html as window.CHANNEL_LABELS. This route
+# serves the same mapping as JSON, for checking what the server thinks the labels are
+# ("curl http://localhost:8000/channel_labels.json"); the page does not depend on it.
+LABELS_ROUTE = '/channel_labels.json'
+INDEX_ROUTES = ('/', '/index.html')
+
+# Everything in web/ is served under a /v<token>/ prefix, and a request for the index
+# without one is redirected to the current token.
+#
+# A browser told nothing about how long a file stays fresh guesses, and it guesses from
+# the file's date: index.html is dated 2024, which buys months of reuse without ever
+# asking the server again. So an interface.js edited today keeps being served from
+# cache, and that is what makes changes to the interface appear in one tab and not the
+# next -- the Reload and Reset buttons open a new tab, which reads the cache, rather
+# than reloading, which revalidates. Under the prefix, the relative URLs in index.html
+# *and* the module imports inside interface.js all resolve to a URL the cache has never
+# seen as soon as any one file changes, so there is nothing for it to reuse.
+VERSION_PREFIX = re.compile(r'^/v[0-9a-f]+(?=/)')
+
+
+def asset_version():
+    """Cache-busting token for web/: the newest modification time in it.
+
+    Not a random value per run: as long as nothing changes, the URLs stay the same and
+    the browser can go on caching. It is only an edit that invalidates them.
+    """
+    try:
+        newest = max(p.stat().st_mtime_ns
+                     for p in Path(WEB_DIRECTORY).rglob('*') if p.is_file())
+    except (OSError, ValueError):
+        # A web directory that cannot be read, or holds nothing, is a problem that the
+        # request for index.html will report; here just fall back to busting nothing.
+        newest = 0
+    return f'v{newest:x}'
+
+
+def num_to_bits(num, nbits=16, reverse=True):
+    """Integer to list of bits"""
+    # TODO: pad zeros with string formatter
+    bl = list(map(int, bin(num)[2:]))
+    # pad with leading zeros
+    bl = [0] * (nbits - len(bl)) + bl
+    return list(reversed(bl)) if reverse else bl
+
+
+class NumpyEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return json.JSONEncoder.default(self, obj)
+
+
+class HttpRequestHandler(http.server.SimpleHTTPRequestHandler):
+    # Set per request by parse_request(); a default keeps a request that never got
+    # that far from tripping over the attribute.
+    versioned = False
+
+    def __init__(self, *args, channel_labels=None, **kwargs):
+        # BaseRequestHandler.__init__() serves the request there and then, so
+        # everything do_GET needs has to be in place before delegating to it.
+        self.channel_labels = channel_labels or {}
+        super().__init__(*args, directory=WEB_DIRECTORY, **kwargs)
+
+    def parse_request(self):
+        """Take the cache-busting prefix off the path, so nothing below sees it.
+
+        Done here rather than in do_GET because it is the one place every method
+        passes through, and translate_path resolves self.path against web/ where a
+        /v<token>/ prefix would just look like a directory that does not exist.
+        """
+        if not super().parse_request():
+            return False
+        self.versioned = VERSION_PREFIX.match(self.path) is not None
+        self.path = VERSION_PREFIX.sub('', self.path, count=1)
+        return True
+
+    def do_GET(self):
+        if not self.serve_route():
+            super().do_GET()
+
+    def do_HEAD(self):
+        # Routed like GET, so that a HEAD cannot describe a different resource than
+        # the one a GET returns -- which is exactly what a cache would go on to store.
+        if not self.serve_route():
+            super().do_HEAD()
+
+    def serve_route(self):
+        """Serve the index with labels baked in, or the labels route from memory.
+
+        False when the path is neither, meaning it is a file to be read from disk.
+        """
+        path = self.path.partition('?')[0]
+        if path in INDEX_ROUTES:
+            if self.versioned:
+                self.send_index()
+            else:
+                # A bookmark, or the URL totalsync opens. Send the browser to the
+                # prefixed index, so that page's assets are fetched from under the
+                # prefix too.
+                self.redirect_to_current_version()
+        elif path == LABELS_ROUTE:
+            self.send_body(json.dumps(self.channel_labels).encode(), 'application/json')
+        else:
+            return False
+        return True
+
+    def redirect_to_current_version(self):
+        self.send_response(302)
+        self.send_header('Location', f'/{asset_version()}/index.html')
+        self.send_header('Content-Length', '0')
+        self.end_headers()
+
+    def send_index(self):
+        """Serve index.html with the channel labels baked into the document.
+
+        The labels belong in the page that builds the interface. Fetching them
+        separately means the interface can be built before, or entirely without,
+        them, and a request that quietly fails leaves every trace showing its
+        default name with nothing to say why.
+        """
+        index = Path(WEB_DIRECTORY) / 'index.html'
+        try:
+            html = index.read_text()
+        except OSError as e:
+            logging.error(f'Cannot read {index}: {e}')
+            self.send_error(404, 'index.html not found')
+            return
+
+        # A literal "</script>" in the JSON would close the block early; escaping the
+        # three characters that can start markup keeps whatever a pin sheet contains
+        # inert. json.dumps has already dealt with quotes and backslashes.
+        payload = (json.dumps(self.channel_labels)
+                   .replace('<', '\\u003c').replace('>', '\\u003e').replace('&', '\\u0026'))
+        # A classic script in the head runs before the deferred module that reads it.
+        tag = f'<script>window.CHANNEL_LABELS = {payload};</script>\n'
+        if '</head>' in html:
+            html = html.replace('</head>', tag + '</head>', 1)
+        else:
+            logging.warning(f'{index} has no </head>: serving it without channel labels.')
+
+        self.send_body(html.encode(), 'text/html; charset=utf-8')
+
+    def send_body(self, body, content_type):
+        self.send_response(200)
+        self.send_header('Content-Type', content_type)
+        self.send_header('Content-Length', str(len(body)))
+        self.end_headers()
+        if self.command != 'HEAD':
+            self.wfile.write(body)
+
+    def end_headers(self):
+        # Says what SimpleHTTPRequestHandler leaves the browser to guess (see
+        # VERSION_PREFIX). Belt and braces next to the versioned URLs, and what keeps
+        # a tab left open for a week honest. It still allows a cheap 304; it only
+        # forbids reusing a copy without checking first.
+        self.send_header('Cache-Control', 'no-cache')
+        super().end_headers()
+
+
+class HTTPServer(threading.Thread):
+    def __init__(self, http_port, channel_labels=None):
+        super(HTTPServer, self).__init__(daemon=True)
+
+        logging.info(f"Launching HTTP server for directory {WEB_DIRECTORY} on port {http_port}")
+
+        # allow reuse of previously bound endpoints
+        socketserver.TCPServer.allow_reuse_address = True
+        # The handler class is instantiated per request, so bind the labels to it
+        # rather than reaching for a module global.
+        handler = functools.partial(HttpRequestHandler, channel_labels=channel_labels)
+        self.server = socketserver.TCPServer(("", http_port), handler)
+
+    def run(self):
+        self.server.serve_forever()
+
+
+class WSServer(threading.Thread):
+    def __init__(self, ws_port):
+        super(WSServer, self).__init__(daemon=True)
+        logging.info(f"Starting Websocket Server on port {ws_port}")
+        self.server = ReconnectingWebsocketServer(host="0.0.0.0", port=ws_port)
+        self.server.set_fn_new_client(self.ws_client_connect)
+        self.server.set_fn_client_left(self.ws_client_left)
+        self.server.set_fn_message_received(self.ws_msg_rcv)
+        self.msg_callback = None
+
+    def run(self):
+        self.server.run_forever()
+
+    @staticmethod
+    def ws_client_connect(client, server):
+        client_id = "Unknown" if client is None else client["id"]
+        logging.debug(f'Client {client_id} connected to WebSocket server.')
+
+    @staticmethod
+    def ws_client_left(client, server):
+        client_id = "Unknown" if client is None else client["id"]
+        logging.debug(f'Client {client_id} disconnected from WebSocket server.')
+
+    def ws_msg_rcv(self, client, server, message):
+        # TODO: Match pinout, which pins are input, which output
+        logging.debug(f"WS_msg {message} from {client}")
+        if self.msg_callback is None:
+            return
+
+        try:
+            if message.startswith('digital'):
+                pin_type, pin_direction, instruction, pin = message.split('_')
+                instr = {'instruction': instruction, 'data': [(int(pin), 1)]}
+                logging.debug(instr)
+                self.msg_callback(instr)
+            else:
+                logging.debug('Unknown WS Message:' + message)
+        except BaseException as e:
+            logging.error(e)
+
+    def handle_packet(self, packet):
+        if packet.type == 0:
+            js = json.dumps({'us_start': packet.us_start, 'us_end': packet.us_end,
+                             'analog': packet.analog, 'states': packet.states,
+                             'digitalIn': num_to_bits(packet.digitalIn, nbits=16),
+                             'digitalOut': num_to_bits(packet.digitalOut, nbits=16)},
+                            cls=NumpyEncoder)
+            self.server.send_message_to_all(js)
+
+
+class WebInterface:
+    def __init__(self, http_port, ws_port, teensy_commander, channel_labels=None):
+        self.http_port = http_port
+        self.ws_port = ws_port
+        self.http_server = HTTPServer(http_port=self.http_port, channel_labels=channel_labels)
+        self.tc = teensy_commander
+        self.ws_server = WSServer(ws_port=self.ws_port)
+        self.ws_server.msg_callback = self.tc.send
+
+        self.http_server.start()
+        self.ws_server.start()
+
+    def handle_packet(self, packet):
+        self.ws_server.handle_packet(packet)

totalsync_webinterface/websocket_server/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Johan Hanssen Seferidis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

totalsync_webinterface/websocket_server/__init__.py

@@ -0,0 +1 @@
+from .websocket_server import *

totalsync_webinterface/websocket_server/websocket_server.py

@@ -0,0 +1,377 @@
+# Author: Johan Hanssen Seferidis
+# License: MIT
+
+import sys
+import struct
+from base64 import b64encode
+from hashlib import sha1
+import logging
+from socket import error as SocketError
+import errno
+
+if sys.version_info[0] < 3:
+    from SocketServer import ThreadingMixIn, TCPServer, StreamRequestHandler
+else:
+    from socketserver import ThreadingMixIn, TCPServer, StreamRequestHandler
+
+logger = logging.getLogger(__name__)
+logging.basicConfig()
+
+'''
++-+-+-+-+-------+-+-------------+-------------------------------+
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
++-+-+-+-+-------+-+-------------+-------------------------------+
+|F|R|R|R| opcode|M| Payload len |    Extended payload length    |
+|I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
+|N|V|V|V|       |S|             |   (if payload len==126/127)   |
+| |1|2|3|       |K|             |                               |
++-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
+|     Extended payload length continued, if payload len == 127  |
++ - - - - - - - - - - - - - - - +-------------------------------+
+|                     Payload Data continued ...                |
++---------------------------------------------------------------+
+'''
+
+FIN    = 0x80
+OPCODE = 0x0f
+MASKED = 0x80
+PAYLOAD_LEN = 0x7f
+PAYLOAD_LEN_EXT16 = 0x7e
+PAYLOAD_LEN_EXT64 = 0x7f
+
+OPCODE_CONTINUATION = 0x0
+OPCODE_TEXT         = 0x1
+OPCODE_BINARY       = 0x2
+OPCODE_CLOSE_CONN   = 0x8
+OPCODE_PING         = 0x9
+OPCODE_PONG         = 0xA
+
+
+# -------------------------------- API ---------------------------------
+
+class API():
+
+    def run_forever(self):
+        try:
+            logger.info("Listening on port %d for clients.." % self.port)
+            self.serve_forever()
+        except KeyboardInterrupt:
+            self.server_close()
+            logger.info("Server terminated.")
+        except Exception as e:
+            logger.error(str(e), exc_info=True)
+            exit(1)
+
+    def new_client(self, client, server):
+        pass
+
+    def client_left(self, client, server):
+        pass
+
+    def message_received(self, client, server, message):
+        pass
+
+    def set_fn_new_client(self, fn):
+        self.new_client = fn
+
+    def set_fn_client_left(self, fn):
+        self.client_left = fn
+
+    def set_fn_message_received(self, fn):
+        self.message_received = fn
+
+    def send_message(self, client, msg):
+        self._unicast_(client, msg)
+
+    def send_message_to_all(self, msg):
+        self._multicast_(msg)
+
+
+# ------------------------- Implementation -----------------------------
+
+class WebsocketServer(ThreadingMixIn, TCPServer, API):
+    """
+	A websocket server waiting for clients to connect.
+
+    Args:
+        port(int): Port to bind to
+        host(str): Hostname or IP to listen for connections. By default 127.0.0.1
+            is being used. To accept connections from any client, you should use
+            0.0.0.0.
+        loglevel: Logging level from logging module to use for logging. By default
+            warnings and errors are being logged.
+
+    Properties:
+        clients(list): A list of connected clients. A client is a dictionary
+            like below.
+                {
+                 'id'      : id,
+                 'handler' : handler,
+                 'address' : (addr, port)
+                }
+    """
+
+    allow_reuse_address = True
+    daemon_threads = True  # comment to keep threads alive until finished
+
+    clients = []
+    id_counter = 0
+
+    def __init__(self, port, host='127.0.0.1', loglevel=logging.WARNING):
+        logger.setLevel(loglevel)
+        TCPServer.__init__(self, (host, port), WebSocketHandler)
+        self.port = self.socket.getsockname()[1]
+
+    def _message_received_(self, handler, msg):
+        self.message_received(self.handler_to_client(handler), self, msg)
+
+    def _ping_received_(self, handler, msg):
+        handler.send_pong(msg)
+
+    def _pong_received_(self, handler, msg):
+        pass
+
+    def _new_client_(self, handler):
+        self.id_counter += 1
+        client = {
+            'id': self.id_counter,
+            'handler': handler,
+            'address': handler.client_address
+        }
+        self.clients.append(client)
+        self.new_client(client, self)
+
+    def _client_left_(self, handler):
+        client = self.handler_to_client(handler)
+        self.client_left(client, self)
+        if client in self.clients:
+            self.clients.remove(client)
+
+    def _unicast_(self, to_client, msg):
+        to_client['handler'].send_message(msg)
+
+    def _multicast_(self, msg):
+        for client in self.clients:
+            self._unicast_(client, msg)
+
+    def handler_to_client(self, handler):
+        for client in self.clients:
+            if client['handler'] == handler:
+                return client
+
+
+class WebSocketHandler(StreamRequestHandler):
+
+    def __init__(self, socket, addr, server):
+        self.server = server
+        StreamRequestHandler.__init__(self, socket, addr, server)
+
+    def setup(self):
+        StreamRequestHandler.setup(self)
+        self.keep_alive = True
+        self.handshake_done = False
+        self.valid_client = False
+
+    def handle(self):
+        while self.keep_alive:
+            if not self.handshake_done:
+                try:
+                    self.handshake()
+                except AssertionError:
+                    logging.debug(f"Websocket handshake failed for client {self.client_address}. Most likely a stale connection.")
+                    self.keep_alive = False
+            elif self.valid_client:
+                self.read_next_message()
+
+    def read_bytes(self, num):
+        # python3 gives ordinal of byte directly
+        bytes = self.rfile.read(num)
+        if sys.version_info[0] < 3:
+            return map(ord, bytes)
+        else:
+            return bytes
+
+    def read_next_message(self):
+        try:
+            b1, b2 = self.read_bytes(2)
+        except SocketError as e:  # to be replaced with ConnectionResetError for py3
+            if e.errno == errno.ECONNRESET:
+                logger.info("Client closed connection.")
+                self.keep_alive = 0
+                return
+            b1, b2 = 0, 0
+        except ValueError as e:
+            b1, b2 = 0, 0
+
+        fin    = b1 & FIN
+        opcode = b1 & OPCODE
+        masked = b2 & MASKED
+        payload_length = b2 & PAYLOAD_LEN
+
+        if opcode == OPCODE_CLOSE_CONN:
+            logger.info("Client asked to close connection.")
+            self.keep_alive = 0
+            return
+        if not masked:
+            logger.debug("Client must always be masked.")
+            self.keep_alive = 0
+            return
+        if opcode == OPCODE_CONTINUATION:
+            logger.warn("Continuation frames are not supported.")
+            return
+        elif opcode == OPCODE_BINARY:
+            logger.warn("Binary frames are not supported.")
+            return
+        elif opcode == OPCODE_TEXT:
+            opcode_handler = self.server._message_received_
+        elif opcode == OPCODE_PING:
+            opcode_handler = self.server._ping_received_
+        elif opcode == OPCODE_PONG:
+            opcode_handler = self.server._pong_received_
+        else:
+            logger.warn("Unknown opcode %#x." % opcode)
+            self.keep_alive = 0
+            return
+
+        if payload_length == 126:
+            payload_length = struct.unpack(">H", self.rfile.read(2))[0]
+        elif payload_length == 127:
+            payload_length = struct.unpack(">Q", self.rfile.read(8))[0]
+
+        masks = self.read_bytes(4)
+        message_bytes = bytearray()
+        for message_byte in self.read_bytes(payload_length):
+            message_byte ^= masks[len(message_bytes) % 4]
+            message_bytes.append(message_byte)
+        opcode_handler(self, message_bytes.decode('utf8'))
+
+    def send_message(self, message):
+        self.send_text(message)
+
+    def send_pong(self, message):
+        self.send_text(message, OPCODE_PONG)
+
+    def send_text(self, message, opcode=OPCODE_TEXT):
+        """
+        Important: Fragmented(=continuation) messages are not supported since
+        their usage cases are limited - when we don't know the payload length.
+        """
+
+        # Validate message
+        if isinstance(message, bytes):
+            message = try_decode_UTF8(message)  # this is slower but ensures we have UTF-8
+            if not message:
+                logger.warning("Can\'t send message, message is not valid UTF-8")
+                return False
+        elif sys.version_info < (3,0) and (isinstance(message, str) or isinstance(message, unicode)):
+            pass
+        elif isinstance(message, str):
+            pass
+        else:
+            logger.warning('Can\'t send message, message has to be a string or bytes. Given type is %s' % type(message))
+            return False
+
+        header  = bytearray()
+        payload = encode_to_UTF8(message)
+        payload_length = len(payload)
+
+        # Normal payload
+        if payload_length <= 125:
+            header.append(FIN | opcode)
+            header.append(payload_length)
+
+        # Extended payload
+        elif payload_length >= 126 and payload_length <= 65535:
+            header.append(FIN | opcode)
+            header.append(PAYLOAD_LEN_EXT16)
+            header.extend(struct.pack(">H", payload_length))
+
+        # Huge extended payload
+        elif payload_length < 18446744073709551616:
+            header.append(FIN | opcode)
+            header.append(PAYLOAD_LEN_EXT64)
+            header.extend(struct.pack(">Q", payload_length))
+
+        else:
+            raise Exception("Message is too big. Consider breaking it into chunks.")
+            return
+
+        self.request.send(header + payload)
+
+    def read_http_headers(self):
+        headers = {}
+        # first line should be HTTP GET
+        http_get = self.rfile.readline().decode().strip()
+        if not http_get.upper().startswith('GET'):
+            if http_get:
+                logging.error('faulty get "{}"'.format(http_get))
+        assert http_get.upper().startswith('GET')
+        # remaining should be headers
+        while True:
+            header = self.rfile.readline().decode().strip()
+            if not header:
+                break
+            head, value = header.split(':', 1)
+            headers[head.lower().strip()] = value.strip()
+        return headers
+
+    def handshake(self):
+        headers = self.read_http_headers()
+
+        try:
+            assert headers['upgrade'].lower() == 'websocket'
+        except AssertionError:
+            self.keep_alive = False
+            return
+
+        try:
+            key = headers['sec-websocket-key']
+        except KeyError:
+            logger.warning("Client tried to connect but was missing a key")
+            self.keep_alive = False
+            return
+
+        response = self.make_handshake_response(key)
+        self.handshake_done = self.request.send(response.encode())
+        self.valid_client = True
+        self.server._new_client_(self)
+
+    @classmethod
+    def make_handshake_response(cls, key):
+        return \
+          'HTTP/1.1 101 Switching Protocols\r\n'\
+          'Upgrade: websocket\r\n'              \
+          'Connection: Upgrade\r\n'             \
+          'Sec-WebSocket-Accept: %s\r\n'        \
+          '\r\n' % cls.calculate_response_key(key)
+
+    @classmethod
+    def calculate_response_key(cls, key):
+        GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+        hash = sha1(key.encode() + GUID.encode())
+        response_key = b64encode(hash.digest()).strip()
+        return response_key.decode('ASCII')
+
+    def finish(self):
+        self.server._client_left_(self)
+
+
+def encode_to_UTF8(data):
+    try:
+        return data.encode('UTF-8')
+    except UnicodeEncodeError as e:
+        logger.error("Could not encode data to UTF-8 -- %s" % e)
+        return False
+    except Exception as e:
+        raise(e)
+        return False
+
+
+def try_decode_UTF8(data):
+    try:
+        return data.decode('utf-8')
+    except UnicodeDecodeError:
+        return False
+    except Exception as e:
+        raise(e)