micrOSDevToolKit 2.1.5__py3-none-any.whl → 2.26.1__py3-none-any.whl

micrOS/source/Server.py

@@ -13,21 +13,34 @@ Designed by Marcell Ban aka BxNxM GitHub
 import uasyncio as asyncio
 from utime import ticks_ms, ticks_diff
 from Config import cfgget
-from Debug import console_write, errlog_add
+from Debug import console_write, syslog
 from Network import ifconfig
 from Tasks import Manager
 from Shell import Shell
 try:
-    from gc import collect, mem_free
+    from gc import collect
 except:
     console_write("[SIMULATOR MODE GC IMPORT]")
-    from simgc import collect, mem_free
+    from simgc import collect
 
 # Module load optimization, needed only for webui
 if cfgget('webui'):
-    from json import dumps, loads
-    from Tasks import lm_exec, NativeTask, lm_is_loaded
-
+    from Web import WebEngine
+else:
+    # Create dummy web engine - Lazy loading
+    class WebEngine:
+        __slots__ = []
+        def __init__(self, *args, **kwargs):
+            pass
+        @staticmethod
+        def register(*args, **kwargs) -> None:
+            """Child class can implement"""
+            syslog(f"[WARN] webui disabled, skip register: {kwargs.get('endpoint')}")
+        @staticmethod
+        def web_mounts(*args, **kwargs) -> dict:
+            """Child class can implement"""
+            syslog(f"[WARN] webui disabled, skip web_mounts: {kwargs.get('endpoint')}")
+            return {}
 
 #########################################################
 #         SOCKET SERVER-CLIENT HANDLER CLASSES          #
@@ -59,19 +72,25 @@ class Client:
         console_write("|" + "-" * Client.INDENT + msg)
         Client.INDENT += 1 if Client.INDENT < 50 else 0       # Auto indent
 
-    async def read(self):
+    async def read(self, decoding='utf8', timeout_seconds=0):
         """
         [Base] Implements client read function, reader size: 2048
-        - set timeout counter
-        - read input from client (run: return False)
-        - connection error handling (stop: return True)
-        - exit command handling (stop: return True)
+        :return tuple: read_error, data
+        - read_error is set to true upon timeout or other exception
+        - data holds bytes or decoded string read from the socket
         """
         Client.console(f"[Client] read {self.client_id}")
         self.last_msg_t = ticks_ms()
         try:
-            request = await self.reader.read(self.read_bytes)
-            request = request.decode('utf8').strip()
+            if timeout_seconds:
+                request = await asyncio.wait_for(self.reader.read(self.read_bytes), timeout_seconds)
+            else:
+                request = await self.reader.read(self.read_bytes)
+            if decoding:
+                request = request.decode(decoding)
+        except asyncio.TimeoutError:
+            Client.console(f"[Client] Stream read timeout ({self.client_id}), timeout={timeout_seconds}s")
+            return True, ''
         except Exception as e:
             Client.console(f"[Client] Stream read error ({self.client_id}): {e}")
             collect()           # gc collection: "fix" for memory allocation failed, allocating 2049 bytes
@@ -79,8 +98,6 @@ class Client:
 
         # Input handling
         Client.console(f"[Client] raw request ({self.client_id}): |{request}|")
-        if request in ('exit', ''):
-            return True, request
         return False, request
 
     async def a_send(self, response, encode='utf8'):
@@ -95,7 +112,7 @@ class Client:
             except Exception as e:
                 # Maintain ACTIVE_CLIS - remove closed connection by peer.
                 await self.close()
-                errlog_add(f"[WARN] Client.a_send (auto-drop) {self.client_id}: {e}")
+                syslog(f"[WARN] Client.a_send (auto-drop) {self.client_id}: {e}")
                 return          # Abort async send (no drain)
             # Send buffered data with async task - hacky
             try:
@@ -107,10 +124,10 @@ class Client:
                 Client.console(f"[Client] Drain error -> close conn: {e}")
                 await self.close()
         else:
-            console_write(f"[Client] NoCon: response>dev/nul")
+            console_write("[Client] NoCon: response>dev/nul")
 
     def send(self, response):
-        # Implement in child class - synchronous send method
+        # Optional - Implement in child class - synchronous send (all) method
         pass
 
     async def close(self):
@@ -138,7 +155,7 @@ class Client:
         if Client.ACTIVE_CLIS.get(client_id, None) is not None:
             Client.ACTIVE_CLIS.pop(client_id)
         # Update server task output (? test ?)
-        Manager().server_task_msg(','.join(list(Client.ACTIVE_CLIS)))
+        Manager().task_msg('server', ','.join(list(Client.ACTIVE_CLIS)))
 
     def __del__(self):
         """Client GC collect"""
@@ -146,176 +163,31 @@ class Client:
         Client.console(f"[Client] del: {self.client_id}")
 
 
-class WebCli(Client):
-    REST_ENDPOINTS = {}
-    AUTH = cfgget('auth')
-    REQ200 = "HTTP/1.1 200 OK\r\nContent-Type: {dtype}\r\nContent-Length:{len}\r\n\r\n{data}"
-    REQ400 = "HTTP/1.1 400 Bad Request\r\nContent-Type: text/plain\r\nContent-Length: {len}\r\n\r\n{data}"
-    REQ404 = "HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\nContent-Length: {len}\r\n\r\n{data}"
+class WebCli(Client, WebEngine):
 
     def __init__(self, reader, writer):
         Client.__init__(self, reader, writer, r_size=512)
-
-    @staticmethod
-    def rest_setter(endpoint, callback):
-        # AUTO ENABLE webui when rest_setter called and webui is False
-        if not cfgget('webui'):
-            from Config import cfgput
-            if cfgput('webui', True):        # SET webui to True
-                from machine import reset
-                reset()                                 # HARD RESET (REBOOT)
-        WebCli.REST_ENDPOINTS[endpoint] = callback
+        WebEngine.__init__(self, client=self, version=Shell.MICROS_VERSION)
 
     async def run_web(self):
         # Update server task output
-        Manager().server_task_msg(','.join(list(Client.ACTIVE_CLIS)))
+        Manager().task_msg('server', ','.join(list(Client.ACTIVE_CLIS)))
 
         # Run async connection handling
         while self.connected:
             try:
                 # Read request msg from client
-                state, request = await self.read()
-                if state:
+                state, request = await self.read(decoding=None)
+                if state or not request:
+                    break
+                if not await self.response(request):
                     break
-                await self.response(request)
             except Exception as e:
-                errlog_add(f"[ERR] Client.run_web: {e}")
+                syslog(f"[ERR] Client.run_web: {e}")
                 break
         # Close connection
         await self.close()
 
-    @staticmethod
-    def file_type(path):
-        """File dynamic Content-Type handling"""
-        if path.endswith(".html"):
-            return "text/html"
-        elif path.endswith(".css"):
-            return "text/css"
-        elif path.endswith(".js"):
-            return "application/javascript"
-        else:
-            return "text/plain"
-
-    async def response(self, request):
-        """HTTP GET REQUEST - WEB INTERFACE"""
-        # Parse request line (first line)
-        _method, url, _version = request.split('\n')[0].split()
-        # Protocol validation
-        if _method != "GET" and _version.startswith('HTTP'):
-            _err = f"Bad Request: not GET HTTP/1.1"
-            await self.a_send(self.REQ400.format(len=len(_err), data=_err))
-            return
-
-        # [1] REST API GET ENDPOINT [/rest]
-        if url.startswith('/rest'):
-            Client.console("[WebCli] --- /rest ACCEPT")
-            try:
-                await self.a_send(WebCli.rest(url))
-            except Exception as e:
-                await self.a_send(self.REQ404.format(len=len(str(e)), data=e))
-            return
-        # [2] DYNAMIC/USER ENDPOINTS (from Load Modules)
-        if await self.endpoints(url):
-            return
-        # [3] HOME/PAGE ENDPOINT(s) [default: / -> /index.html]
-        if url.startswith('/'):
-            resource = 'index.html' if url == '/' else url.replace('/', '')
-            Client.console(f"[WebCli] --- {url} ACCEPT")
-            if resource.split('.')[-1] not in ('html', 'js', 'css'):
-                await self.a_send(self.REQ404.format(len=27, data='404 Not supported file type'))
-                return
-            try:
-                # SEND RESOURCE CONTENT: HTML, JS, CSS
-                with open(resource, 'r') as file:
-                    html = file.read()
-                await self.a_send(self.REQ200.format(dtype=WebCli.file_type(resource), len=len(html), data=html))
-            except OSError:
-                await self.a_send(self.REQ404.format(len=13, data='404 Not Found'))
-            return
-        # INVALID/BAD REQUEST
-        await self.a_send(self.REQ400.format(len=15, data='400 Bad Request'))
-
-    async def endpoints(self, url):
-        url = url[1:]       # Cut first / char
-        if url in WebCli.REST_ENDPOINTS:
-            console_write(f"[WebCli] endpoint: {url}")
-            # Registered endpoint was found - exec callback
-            try:
-                # RESOLVE ENDPOINT CALLBACK
-                # dtype:
-                #   one-shot: image/jpeg | text/html | text/plain              - data: raw
-                #       task: multipart/x-mixed-replace | multipart/form-data  - data: dict=callback,content-type
-                #                   content-type: image/jpeg | audio/l16;*
-                dtype, data = WebCli.REST_ENDPOINTS[url]()
-                if dtype == 'image/jpeg':
-                    resp = f"HTTP/1.1 200 OK\r\nContent-Type: {dtype}\r\nContent-Length:{len(data)}\r\n\r\n".encode('utf8') + data
-                    await self.a_send(resp, encode=None)
-                elif dtype in ('multipart/x-mixed-replace', 'multipart/form-data'):
-                    headers = (f"HTTP/1.1 200 OK\r\nContent-Type: {dtype}; boundary=\"micrOS_boundary\"\r\n\r\n").encode('utf-8')
-                    await self.a_send(headers, encode=None)
-                    # Start Native stream async task
-                    task = NativeTask()
-                    task.create(callback=self.stream(data['callback'], task, data['content-type']),
-                                tag=f"web.stream_{self.client_id.replace('W', '')}")
-                else:  # dtype: text/html or text/plain
-                    await self.a_send(f"HTTP/1.1 200 OK\r\nContent-Type: {dtype}\r\nContent-Length:{len(data)}\r\n\r\n{data}")
-            except Exception as e:
-                await self.a_send(self.REQ404.format(len=len(str(e)), data=e))
-                errlog_add(f"[ERR] WebCli endpoints {url}: {e}")
-            return True         # Registered endpoint was found and executed
-        return False            # Not registered endpoint
-
-    async def stream(self, callback, task, content_type):
-        """
-        Async stream method
-        :param callback: sync or async function callback (auto-detect) WARNING: works for functions only (not methods!)
-        """
-        is_coroutine = 'generator' in str(type(callback))   # async function callback auto-detect
-        with task:
-            task.out = 'Stream started'
-            data_to_send = b''
-
-            while self.connected and data_to_send is not None:
-                data_to_send = await callback() if is_coroutine else callback()
-                part = (f"\r\n--micrOS_boundary\r\nContent-Type: {content_type}\r\n\r\n").encode('utf-8') + data_to_send
-                task.out = 'Data sent'
-                await self.a_send(part, encode=None)
-                await asyncio.sleep_ms(10)
-
-            # Gracefully terminate the stream
-            if self.connected:
-                closing_boundary = '\r\n--micrOS_boundary--\r\n'
-                await self.a_send(closing_boundary, encode=None)
-                await self.close()
-            task.out = 'Finished stream'
-
-    @staticmethod
-    def rest(url):
-        resp_schema = {'result': None, 'state': False}
-        cmd = url.replace('/rest', '')
-        if len(cmd) > 1:
-            # REST sub-parameter handling (rest commands)
-            cmd = (cmd.replace('/', ' ').replace('%22', '"').replace('%E2%80%9C', '"')
-                   .replace('%E2%80%9D', '"').replace('-', ' ').strip().split())
-            # request json format instead of default string output (+ handle & tasks syntax)
-            cmd.insert(-1, '>json') if cmd[-1].startswith('&') else cmd.append('>json')
-            # EXECUTE COMMAND - LoadModule
-            if WebCli.AUTH:
-                state, out = lm_exec(cmd) if lm_is_loaded(cmd[0]) else (True, 'Auth:Protected')
-            else:
-                state, out = lm_exec(cmd)
-            try:
-                resp_schema['result'] = loads(out)       # Load again ... hack for embedded shell json converter...
-            except:
-                resp_schema['result'] = out
-            resp_schema['state'] = state
-        else:
-            resp_schema['result'] = {"micrOS": Shell.MICROS_VERSION, 'node': cfgget('devfid'), 'auth': WebCli.AUTH}
-            if len(tuple(WebCli.REST_ENDPOINTS.keys())) > 0:
-                resp_schema['result']['usr_endpoints'] = tuple(WebCli.REST_ENDPOINTS)
-            resp_schema['state'] = True
-        response = dumps(resp_schema)
-        return WebCli.REQ200.format(dtype='text/html', len=len(response), data=response)
 
 class ShellCli(Client, Shell):
 
@@ -328,7 +200,9 @@ class ShellCli(Client, Shell):
 
     def send(self, response):
         """
-        Send response to client with non-async function
+        Synchronous send function (with drain task)
+        - not used in Shell or ShellCli
+        - Note: it is a support function for synchronous scenarios: Server.reply_all
         """
         if self.connected:
             if self.prompt() != response:
@@ -338,21 +212,20 @@ class ShellCli(Client, Shell):
             # Store data in stream buffer
             try:
                 self.writer.write(response.encode('utf8'))
-            except Exception as e:
+            except:
                 # Maintain ACTIVE_CLIS - remove closed connection by peer.
                 Client.drop_client(self.client_id)
-                errlog_add(f"[WARN] ShellCli.send (auto-drop) {self.client_id}: {e}")
+                syslog(f"[WARN] ShellCli.send (auto-drop) {self.client_id}")
             # Send buffered data with async task - hacky
             if self.drain_event.is_set():
                 self.drain_event.clear()        # set drain busy (False)
                 asyncio.get_event_loop().create_task(self.__wait_for_drain())
         else:
-            console_write(f"[ShellCli] NoCon: response>/dev/nul")
+            console_write("[ShellCli] NoCon: response>/dev/nul")
 
     async def __wait_for_drain(self):
         """
-        Handle drain serialization
-        - solve output data duplicate
+        Handle drain serialization - for synchronous send function
         """
         try:
             # send write buffer
@@ -365,55 +238,45 @@ class ShellCli(Client, Shell):
         # set drain free
         self.drain_event.set()                  # set drain free (True)
 
-    async def close(self):
-        Client.console(f"[ShellCli] Close connection {self.client_id}")
-        self.send("Bye!\n")
-        # Reset shell state machine
-        self.reset()
-        await asyncio.sleep_ms(50)
-        # Used from Client parent class
-        await super().close()
-
-    async def __shell_cmd(self, request):
+    async def a_send(self, response, encode='utf8'):
         """
-        Handle micrOS shell commands
+        Async send for Shell (new line + prompt$)
         """
-        # Run micrOS shell with request string
-        try:
-            # Handle micrOS shell
-            Client.console("[ShellCli] --- #Run shell")
-            state = self.shell(request)
-            if state:
-                return False      # exit_loop
-            return True           # exit_loop : Close session when shell returns False (auth Failed, etc.)
-        except Exception as e:
-            Client.console(f"[ShellCli] Shell exception: {e}")
-            if "ECONNRESET" in str(e):
-                return True       # exit_loop
-        self.send("[HA] Critical error - disconnect & hard reset")
-        errlog_add("[ERR] Socket critical error - reboot")
-        self.reboot()
+        if self.prompt() != response:
+            # [format] Add new line if not prompt
+            response = f"{response}\n"
+        await super().a_send(response, encode)
 
     async def run_shell(self):
         # Update server task output
-        Manager().server_task_msg(','.join(list(Client.ACTIVE_CLIS)))
+        Manager().task_msg('server', ','.join(list(Client.ACTIVE_CLIS)))
         # Init prompt
-        self.send(self.prompt())
+        await self.a_send(self.prompt())
         # Run async connection handling
+        _exit = False
         while self.connected:
             try:
                 # Read request msg from client
                 state, request = await self.read()
-                if state:
-                    break
-                _exit = await self.__shell_cmd(request)
-                if _exit:
-                    collect()
+                if state or request in ('exit', ''):
                     break
+                # Run micrOS shell with request string
+                Client.console("[ShellCli] --- #Run shell")
+                # Shell -> True (OK) or False (NOK) -> NOK->Close session (auth Failed, etc.)
+                _exit = not await self.shell(request)
             except Exception as e:
-                errlog_add(f"[ERR] handle_client: {e}")
+                syslog(f"[ERR] Shell client: {e}")
+                if "ECONNRESET" in str(e):
+                    _exit = True  # exit_loop
+                else:
+                    await self.a_send("[HA] Critical error - disconnect & hard reset")
+                    syslog("[ERR] Socket critical error - reboot")
+                    await self.reboot()
+            if _exit:
+                collect()
                 break
         # Close connection
+        await self.a_send("Bye!")
         await self.close()
 
 
@@ -421,13 +284,14 @@ class ShellCli(Client, Shell):
 #                    SOCKET SERVER CLASS                #
 #########################################################
 
-class SocketServer:
+class Server:
     """
     Socket message data packet layer - send and receive
     Embedded command interpretation:
     - exit
     Handle user requests/commands with Shell (bash like experience)
     """
+    __slots__ = ['server', 'web', '_host', '_socqueue', '_port', '_timeout', '_initialized']
     __instance = None
 
     def __new__(cls):
@@ -437,8 +301,8 @@ class SocketServer:
         cls     - class
         """
         if not cls.__instance:
-            # SocketServer singleton properties
-            cls.__instance = super(SocketServer, cls).__new__(cls)
+            # Server singleton properties
+            cls.__instance = super(Server, cls).__new__(cls)
             cls.__instance._initialized = False
         return cls.__instance
 
@@ -549,8 +413,11 @@ class SocketServer:
         """
         for _, cli in Client.ACTIVE_CLIS.items():
             if cli.connected:
-                cli.send(msg)
+                cli.send(f"~~~ {msg}")
 
     def __del__(self):
         Client.console("[ socket server ] <<destructor>>")
-        self.server.close()
+        if self.server:
+            self.server.close()
+        if self.web:
+            self.web.close()