micrOSDevToolKit 2.9.1__py3-none-any.whl → 2.9.6__py3-none-any.whl

micrOS/source/LM_telegram.py

@@ -1,5 +1,4 @@
 from sys import modules
-import uasyncio as asyncio
 import urequests
 from Notify import Notify
 from Config import cfgget
@@ -15,6 +14,10 @@ class Telegram(Notify):
     _API_PARAMS = "?offset=-1&limit=1&timeout=2"  # Generic API params - optimization
     _IN_MSG_ID = None
 
+    def __init__(self):
+        # Subscribe to the notification system - provide send_msg method (over self)
+        super().add_subscriber(self)
+
     @staticmethod
     def __id_cache(mode):
         """
@@ -97,36 +100,60 @@ class Telegram(Notify):
             verdict = f'Sent{chat_id}' if resp_json['ok'] else str(resp_json)
         return verdict
 
+    @staticmethod
+    def __update_chat_ids(resp_json):
+        """
+        Update known chat_id-s and cache them
+        - return active chat_id frm resp_json
+        """
+        console_write("[NTFY GET] update chatIDs")
+        _cid = None
+        if resp_json.get("ok", None) and len(resp_json["result"]) > 0:
+            _cid = resp_json["result"][-1]["message"]["chat"]["id"]
+            # LIMIT Telegram._CHAT_IDS NOTIFICATION CACHE TO 3 IDs
+            if len(Telegram._CHAT_IDS) < 4:
+                _ids = len(Telegram._CHAT_IDS)
+                Telegram._CHAT_IDS.add(_cid)
+                if len(Telegram._CHAT_IDS) - _ids > 0:  # optimized save (slow storage access)
+                    Telegram.__id_cache('s')
+        else:
+            Telegram.__id_cache('r')
+            if len(Telegram._CHAT_IDS) == 0:
+                error_message = resp_json.get("description", "Unknown error")
+                raise Exception(f"Error retrieving chat ID: {error_message}")
+        return _cid
+
     @staticmethod
     def get_msg():
         """
         Get the last message from the Telegram chat.
         RETURN None when telegram bot token is missing
         """
+        console_write("[NTFY] GET MESSAGE")
+        bot_token = Telegram.__bot_token()
+        if bot_token is None:
+            return None
+        response = {'sender': None, 'text': None, 'm_id': -1, 'c_id': None}
+        url = f"https://api.telegram.org/bot{bot_token}/getUpdates{Telegram._API_PARAMS}"
+        console_write(f"\t1/2[GET] request: {url}")
 
-        def _update_chat_ids():
-            """
-            Update known chat_id-s and cache them
-            - return active chat_id frm resp_json
-            """
-            console_write("[NTFY GET] update chatIDs")
-            _cid = None
-            if resp_json.get("ok", None) and len(resp_json["result"]) > 0:
-                _cid = resp_json["result"][-1]["message"]["chat"]["id"]
-                # LIMIT Telegram._CHAT_IDS NOTIFICATION CACHE TO 3 IDs
-                if len(Telegram._CHAT_IDS) < 4:
-                    _ids = len(Telegram._CHAT_IDS)
-                    Telegram._CHAT_IDS.add(_cid)
-                    if len(Telegram._CHAT_IDS) - _ids > 0:  # optimized save (slow storage access)
-                        Telegram.__id_cache('s')
-            else:
-                Telegram.__id_cache('r')
-                if len(Telegram._CHAT_IDS) == 0:
-                    error_message = resp_json.get("description", "Unknown error")
-                    raise Exception(f"Error retrieving chat ID: {error_message}")
-            return _cid
+        _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
 
-        # --------------------- FUNCTION MAIN ------------------------ #
+        if len(resp_json["result"]) > 0:
+            response['c_id'] = Telegram.__update_chat_ids(resp_json)
+            resp = resp_json["result"][-1]["message"]
+            response['sender'] = f"{resp['chat']['first_name']}{resp['chat']['last_name']}" if resp['chat'].get(
+                'username', None) is None else resp['chat']['username']
+            response['text'], response['m_id'] = resp['text'], resp['message_id']
+        console_write(f"\t2/2[GET] response: {response}")
+        return response
+
+    @staticmethod
+    async def aget_msg():
+        """
+        Async: Get the last message from the Telegram chat.
+        RETURN None when telegram bot token is missing
+        """
         console_write("[NTFY] GET MESSAGE")
         bot_token = Telegram.__bot_token()
         if bot_token is None:
@@ -134,9 +161,11 @@ class Telegram(Notify):
         response = {'sender': None, 'text': None, 'm_id': -1, 'c_id': None}
         url = f"https://api.telegram.org/bot{bot_token}/getUpdates{Telegram._API_PARAMS}"
         console_write(f"\t1/2[GET] request: {url}")
-        _, resp_json = urequests.get(url, jsonify=True, sock_size=128)
+
+        _, resp_json = await urequests.aget(url, jsonify=True, sock_size=128)
+
         if len(resp_json["result"]) > 0:
-            response['c_id'] = _update_chat_ids()
+            response['c_id'] = Telegram.__update_chat_ids(resp_json)
             resp = resp_json["result"][-1]["message"]
             response['sender'] = f"{resp['chat']['first_name']}{resp['chat']['last_name']}" if resp['chat'].get(
                 'username', None) is None else resp['chat']['username']
@@ -145,16 +174,13 @@ class Telegram(Notify):
         return response
 
     @staticmethod
-    def receive_eval():
+    async def receive_eval():
         """
         READ - VALIDATE - EXECUTE - REPLY LOOP
         - can be used in async loop
         RETURN None when telegram bot token is missing
         """
-
-        console_write("[NTFY] REC&EVAL sequence")
-
-        # Return data structure template
+        console_write("[NTFY] EVAL sequence")
         verdict = None
 
         def lm_execute(cmd_args):
@@ -168,8 +194,8 @@ class Telegram(Notify):
                 Telegram._IN_MSG_ID = m_id
 
         # -------------------------- FUNCTION MAIN -------------------------- #
-        # Poll telegram chat
-        data = Telegram.get_msg()
+        # Async Poll telegram chat
+        data = await Telegram.aget_msg()
         if data is None:
             return data
         # Get msg, msg_id, chat_id as main input data source
@@ -197,12 +223,42 @@ class Telegram(Notify):
                     verdict = Telegram.notifications(not param[0].strip().lower() in ("disable", "off", 'false'))
                 else:
                     verdict = Telegram.notifications()
+                # Send is still synchronous (OK)
                 Telegram.send_msg(verdict, reply_to=m_id)
         else:
             verdict = "[UP] NoExec"
-        console_write(f"\tREC&EVAL: {verdict}")
+        console_write(f"\tBOT: {verdict}")
         return verdict
 
+    @staticmethod
+    async def bot_repl(tag, period=3):
+        """
+        BOT - ReceiveEvalPrintLoop
+        :param tag: task tag (access)
+        :param period: polling period in sec, default: 3
+        """
+        cancel_cnt = 0
+        period = period if period > 0 else 1
+        period_ms = period * 1000
+        with micro_task(tag=tag) as my_task:
+            my_task.out = "[UP] Running"
+            while True:
+                # Normal task period
+                await my_task.feed(sleep_ms=period_ms)
+                try:
+                    v = await Telegram.receive_eval()
+                    my_task.out = "Missing bot token" if v is None else f"{v} ({period}s)"
+                    cancel_cnt = 0
+                except Exception as e:
+                    my_task.out = str(e)
+                    # Auto scale - blocking nature - in case of serial failures (5) - hibernate task (increase async sleep)
+                    cancel_cnt += 1
+                    if cancel_cnt > 5:
+                        my_task.out = f"[DOWN] {e} (wait 1min)"
+                        cancel_cnt = 5
+                        # SLOW DOWN - hibernate task
+                        await my_task.feed(sleep_ms=60_000)
+
     @staticmethod
     def set_commands():
         """
@@ -237,7 +293,6 @@ def __init():
         _sta_available = True if ifconfig()[0] == "STA" else False
         if _sta_available:
             TELEGRAM_OBJ = Telegram()
-            Notify.add_subscriber(TELEGRAM_OBJ)
         else:
             syslog("No STA: cannot init telegram")
 
@@ -292,37 +347,16 @@ def receive():
     return "Missing telegram bot token" if verdict is None else verdict
 
 
-async def __task():
-    cancel_cnt = 0
-    with micro_task(tag='telegram._loop') as my_task:
-        my_task.out = "[UP] Running"
-        while True:
-            # Normal task period
-            await asyncio.sleep(5)
-            try:
-                v = TELEGRAM_OBJ.receive_eval()
-                my_task.out = "Missing bot token" if v is None else v
-                cancel_cnt = 0
-            except Exception as e:
-                my_task.out = str(e)
-                # Auto scale - blocking nature - in case of serial failures (5) - hibernate task (increase async sleep)
-                cancel_cnt += 1
-                if cancel_cnt > 5:
-                    my_task.out = f"[DOWN] {e}"
-                    cancel_cnt = 5
-                    # SLOW DOWN - hibernate task
-                    asyncio.sleep(115)
-
-
-def receiver_loop():
+def receiver_loop(period=3):
     """
-    Telegram msg receiver loop - automatic LM execution
+    Telegram BOT (repl) - ReadEvalPrintLoop for Load Modules
     - Only executes module (function) if the module is already loaded
-    on the endpoint / micrOS node
+    :param period: polling period in sec, default: 3
     """
     if TELEGRAM_OBJ is None:
         return "Network unavailable."
-    state = micro_task(tag='telegram._loop', task=__task())
+    tag = 'telegram.bot_repl'
+    state = micro_task(tag=tag, task=TELEGRAM_OBJ.bot_repl(tag=tag, period=period))
     return "Starting" if state else "Already running"
 
 
@@ -335,6 +369,6 @@ def help(widgets=False):
     """
     return ('send "text"',
             'receive',
-            'receiver_loop',
+            'receiver_loop period=3',
             'notify "message"',
             'load', 'INFO: Send & Receive messages with Telegram bot')

micrOS/source/Logger.py

@@ -5,11 +5,34 @@ Module is responsible for System and User logging
 Designed by Marcell Ban aka BxNxM
 """
 from time import localtime
-from os import listdir, remove
+from re import match
+from uos import listdir, remove, stat, mkdir, getcwd
 
 #############################################
 #        LOGGING WITH DATA ROTATION         #
 #############################################
+LOG_FOLDER = None
+
+def _init_logger():
+    """ Init /logs folder """
+    global LOG_FOLDER
+    if LOG_FOLDER is None:
+        LOG_FOLDER = f"{getcwd()}logs"
+        do_create = True
+        try:
+            if stat(LOG_FOLDER)[0] & 0x4000:
+                # Dir exists - skip create
+                do_create = False
+        except:
+            pass
+        if do_create:
+            try:
+                mkdir(LOG_FOLDER)
+                syslog(f"[BOOT] log dir {LOG_FOLDER} init")
+            except Exception as e:
+                LOG_FOLDER = getcwd()
+                syslog(f"[BOOT] log dir {LOG_FOLDER} fallback: {e}")
+    return LOG_FOLDER
 
 
 def logger(data, f_name, limit):
@@ -23,14 +46,15 @@ def logger(data, f_name, limit):
     return write verdict - true / false
     INFO: hardcoded max data number = 30
     """
-    def _logger(_data, _f_name, _limit, f_mode='r+'):
-        _limit = 30 if _limit > 30 else _limit
+    def _logger(f_mode='r+'):
+        nonlocal data, f_name, limit
+        limit = min(limit, 30)  # Hardcoded max data line = 30
         # [1] GET TIME STUMP
         ts_buff = [str(k) for k in localtime()]
         ts = ".".join(ts_buff[0:3]) + "-" + ":".join(ts_buff[3:6])
         # [2] OPEN FILE - WRITE DATA WITH TS
-        with open(_f_name, f_mode) as f:
-            _data = f"{ts} {_data}\n"
+        with open(f_name, f_mode) as f:
+            _data = f"{ts} {data}\n"
             # read file lines and filter by time stump chunks (hack for replace truncate)
             lines = [_l for _l in f.readlines() if '-' in _l and '.' in _l]
             # get file params
@@ -38,22 +62,20 @@ def logger(data, f_name, limit):
             lines.append(_data)
             f.seek(0)
             # line data rotate
-            if lines_len >= _limit:
-                lines = lines[-_limit:]
-                lines_str = ''.join(lines)
-            else:
-                lines_str = ''.join(lines)
+            if lines_len >= limit:
+                lines = lines[-limit:]
             # write file
-            f.write(lines_str)
+            f.write(''.join(lines))
 
+    f_name = f"{LOG_FOLDER}/{f_name}"
     # Run logger
     try:
         # There is file - append 'r+'
-        _logger(data, f_name, limit)
+        _logger()
     except:
         try:
             # There is no file - create 'a+'
-            _logger(data, f_name, limit, 'a+')
+            _logger('a+')
         except:
             return False
     return True
@@ -64,8 +86,11 @@ def log_get(f_name, msgobj=None):
     Get and stream (ver osocket/stdout) .log file's content and count "critical" errors
     - critical error tag in log line: [ERR]
     """
+    f_name = f"{LOG_FOLDER}/{f_name}"
     err_cnt = 0
     try:
+        if msgobj is not None:
+            msgobj(f_name)
         with open(f_name, 'r') as f:
             eline = f.readline().strip()
             while eline:
@@ -73,7 +98,7 @@ def log_get(f_name, msgobj=None):
                 err_cnt += 1 if "[ERR]" in eline else 0
                 # GIVE BACK .log file contents
                 if msgobj is not None:
-                    msgobj(eline)
+                    msgobj(f"\t{eline}")
                 eline = f.readline().strip()
     except:
         pass
@@ -82,13 +107,22 @@ def log_get(f_name, msgobj=None):
 
 def syslog(data=None, msgobj=None):
     if data is None:
-        return log_get('err.log', msgobj)
-    return logger(data, 'err.log', limit=6)
+        err_cnt = sum([log_get(f, msgobj) for f in listdir(LOG_FOLDER) if f.endswith(".sys.log")])
+        return err_cnt
+
+    _match = match(r"^\[([^\[\]]+)\]", data)
+    log_lvl = _match.group(1).lower() if _match else 'user'
+    f_name = f"{log_lvl}.sys.log" if log_lvl in ("err", "warn", "boot") else 'user.sys.log'
+    return logger(data, f_name, limit=4)
 
 
 def log_clean(msgobj=None):
-    to_del = [file for file in listdir() if file.endswith('.log')]
+    to_del = [file for file in listdir(LOG_FOLDER) if file.endswith('.log')]
     for _del in to_del:
+        _del = f"{LOG_FOLDER}/{_del}"
         if msgobj is not None:
             msgobj(f" Delete: {_del}")
         remove(_del)
+
+# Init log folder at module load
+_init_logger()

micrOS/source/Notify.py

@@ -35,16 +35,17 @@ class Notify:
     @staticmethod
     def message(text, reply_to=None, chat_id=None):
         """
-        Send message to all subscribers
+        Send message to all subscribers - Notify agents
         """
         exit_code = 0
         for s in Notify._SUBSCRIBERS:
             try:
+                # !!! SUBSCRIBER HAS TO DEFINE send_msg(text, reply_to, chat_id) method !!!
                 s.send_msg(text, reply_to, chat_id)
             except Exception as e:
                 errlog_add(f"[ERR] Notify: {e}")
                 exit_code+=1
-        return f"Sent N{len(Notify._SUBSCRIBERS)} ({exit_code})"
+        return f"Sent for {len(Notify._SUBSCRIBERS)} client(s), errors: ({exit_code})"
 
     @staticmethod
     def notifications(state=None):
@@ -66,7 +67,7 @@ class Notify:
 
     @staticmethod
     def lm_execute(cmd_args):
-        """Executor with basic access handling"""
+        """Load Module Executor with basic access handling"""
         if lm_is_loaded(cmd_args[0]):
             try:
                 _, out = lm_exec(cmd_args)

micrOS/source/Server.py

@@ -114,7 +114,7 @@ class Client:
             console_write("[Client] NoCon: response>dev/nul")
 
     def send(self, response):
-        # Implement in child class - synchronous send method
+        # Implement in child class - synchronous send (all) method
         pass
 
     async def close(self):
@@ -182,7 +182,7 @@ class WebCli(Client, WebEngine):
             if cfgput('webui', True):  # SET webui to True
                 from machine import reset
                 reset()  # HARD RESET (REBOOT)
-        WebEngine.REST_ENDPOINTS[endpoint] = callback
+        WebEngine.ENDPOINTS[endpoint] = callback
 
 
 class ShellCli(Client, Shell):
@@ -196,7 +196,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:
@@ -219,8 +221,7 @@ class ShellCli(Client, Shell):
 
     async def __wait_for_drain(self):
         """
-        Handle drain serialization
-        - solve output data duplicate
+        Handle drain serialization - for synchronous send function
         """
         try:
             # send write buffer
@@ -233,55 +234,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)))
         # 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()
-                    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}")
+                errlog_add(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")
+                    errlog_add("[ERR] Socket critical error - reboot")
+                    await self.reboot()
+            if _exit:
+                collect()
                 break
         # Close connection
+        await self.a_send("Bye!")
         await self.close()
 
 
@@ -418,8 +409,11 @@ class Server:
         """
         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()