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

toolkit/lib/macroScript.py

@@ -0,0 +1,371 @@
+import os
+import sys
+import time
+from datetime import datetime
+import subprocess
+import platform
+import threading
+try:
+    from .micrOSClient import micrOSClient, color
+except:
+    from micrOSClient import micrOSClient, color
+try:
+    import curses
+except Exception as e:
+    print(f"Missing dependency for curses: {e}")
+    curses = None
+
+DRY_RUN = False
+
+#####################################
+#         FILE SELECTION TUI        #
+#####################################
+
+def select_menu(directory):
+    if not os.path.isdir(directory):
+        print("Not a directory.")
+        return None
+    files = [f for f in os.listdir(directory) if os.path.isfile(os.path.join(directory, f)) and f.endswith(".macro")]
+    if not files:
+        print("No macro found in the directory.")
+        return None
+
+    def macro_preview(path):
+        with open(path, 'r') as file:
+            # Read the first line
+            first_line = file.readline().strip()
+        preview = ' '.join(first_line.split()[1:])
+        macro_name_len = len(os.path.basename(path))
+        column_idx = 30
+        spacer = " " * (column_idx - macro_name_len)
+        return f"{spacer}{preview}"
+
+    def display_menu(stdscr):
+        if curses is None:
+            return None
+        curses.curs_set(0)  # Hide the cursor
+        current_row = 0
+        while True:
+            stdscr.clear()
+            stdscr.addstr(0, 0, "Please select a macro:")
+            # Display files with navigation
+            for idx, file in enumerate(files):
+                if idx == current_row:
+                    stdscr.addstr(idx + 1, 2, f"> {file} {macro_preview(os.path.join(directory, file))}", curses.A_REVERSE)  # Highlight the current selection
+                else:
+                    stdscr.addstr(idx + 1, 2, f"  {file}")
+            key = stdscr.getch()
+            if key == curses.KEY_UP and current_row > 0:
+                current_row -= 1
+            elif key == curses.KEY_DOWN and current_row < len(files) - 1:
+                current_row += 1
+            elif key == curses.KEY_ENTER or key in [10, 13]:
+                stdscr.clear()
+                #stdscr.addstr(0, 0, f"Macro selected: {files[current_row]}")
+                #stdscr.refresh()
+                #stdscr.getch()  # Wait for another key press before exiting
+                return os.path.join(directory, files[current_row])
+    return curses.wrapper(display_menu)
+
+
+#####################################
+#           HELPER FUNCTIONS        #
+#####################################
+
+def _elapsed_time(start, stop):
+    # Calculate the difference (delta) between the end and start times
+    delta = stop - start
+
+    # Total seconds in the delta
+    total_seconds = int(delta.total_seconds())
+
+    # Calculate days, hours, minutes, and seconds
+    days = total_seconds // 86400
+    hours = (total_seconds % 86400) // 3600
+    minutes = (total_seconds % 3600) // 60
+    seconds = total_seconds % 60
+
+    # Formatting the delta time
+    formatted_delta = f"{days}d {hours}h {minutes}m {seconds}s"
+    return formatted_delta
+
+
+def action_console(action, msg):
+    if action == "SKIP":
+        action = f"{color.BOLD}--- {action}{color.NC}"
+    if action == "SEND":
+        action = f"{color.WARN}==> {action}{color.NC}"
+    if action == "SHELL":
+        action = f"{color.HEADER}*** {action}{color.NC}"
+    if action == "WAIT":
+        action = f"{color.OKBLUE}=== {action}{color.NC}"
+    if action == "MACRO":
+        action = f"{color.OKGREEN}=== {action}{color.NC}"
+    if action == "ERR":
+        action = f"{color.ERR}=== {action}{color.NC}"
+    if action == "RECURSION":
+        action = f"{color.WARN}{color.BOLD}    &&& {action}{color.NC}"
+    if action == "INIT":
+        print(msg)
+        return
+    dr = "DRYRUN" if DRY_RUN else ""
+    message = f"{dr}|  {action} {msg}"
+    print(message)
+
+
+#####################################
+#           MACRO EXECUTOR          #
+#####################################
+
+class Executor:
+    RECURSION_COUNTER = {}
+
+    def __init__(self, host=None, pwd=None, verbose=None, safe=None, parallel=None, max_recursion=5):
+        self.com = None
+        self.host = host
+        self.pwd = pwd
+        self.verbose = verbose
+        self.safe_mode = safe
+        self.safe_modules = None
+        self.workdir = None
+        self.macro_name = None
+        self.max_recursion = max_recursion
+        self.parallel = parallel
+
+    def init_com(self):
+        try:
+            self.com = micrOSClient(host=self.host, port=9008, pwd=self.pwd, dbg=self.verbose)
+            if self.safe_mode:
+                self.safe_modules = self.com.send_cmd_retry("modules")[0]
+        except Exception as e:
+            print(f"Connection error, cannot get dhcp(?): {e}")
+            if DRY_RUN:
+                self.com.close = lambda: print("DRY_RUN close")
+                self.safe_modules = []
+                return
+            raise e
+
+    def run(self, cmd, force_close=True):
+        if self.com is None:
+            self.init_com()
+        if self.safe_mode and cmd.split()[0] not in self.safe_modules:
+            action_console("SKIP", f"{cmd.split()[0]} execution (not loaded) - safe mode: {self.safe_modules}")
+            return True, "Skipped..."
+        # [2] Test functions for command send function
+        action_console("SEND", cmd)
+        if DRY_RUN:
+            out = f"dryrun"
+        else:
+            out = self.com.send_cmd_retry(cmd)
+        action_console(" "*8, f"{cmd}: {out}")
+        if force_close: self.com.close()
+        return True if len(out) > 0 else False, out
+
+    @staticmethod
+    def _run_embedded_macro(macro_name, workdir, verbose=None, safe=None, background=None):
+        def run():
+            nonlocal  macro_name, workdir, verbose, safe, background
+            macro_name = f"{macro_name}.macro"
+            macro_path = os.path.join(workdir, macro_name)
+            print(f"|      - {macro_path}{' - background' if background else ''}")
+            macro_exec = Executor(verbose=verbose, safe=safe)
+            macro_exec.run_micro_script(macro_path)
+
+        if background:
+            thread = threading.Thread(target=run)
+            thread.start()
+        else:
+            run()
+
+    def run_embedded_macro(self, macro_name):
+        run_macro = True
+        if self.macro_name == macro_name:
+            if Executor.RECURSION_COUNTER.get(self.macro_name, None) is None:
+                Executor.RECURSION_COUNTER[self.macro_name] = 1
+            counter = Executor.RECURSION_COUNTER[self.macro_name]
+            if counter >= self.max_recursion:
+                action_console("RECURSION", f"{self.macro_name} macro limit exceeded: {self.max_recursion}")
+                Executor.RECURSION_COUNTER[self.macro_name] = 1
+                run_macro = False
+            else:
+                action_console("RECURSION", f"{self.macro_name} macro: {counter}/{self.max_recursion}")
+                Executor.RECURSION_COUNTER[self.macro_name] += 1
+        if run_macro:
+            self._run_embedded_macro(macro_name, self.workdir, verbose=self.verbose, safe=self.safe_mode, background=self.parallel)
+
+    @staticmethod
+    def _run_shell_command(command):
+        """Run a command in the detected shell."""
+
+        def detect_shell():
+            """Detect the current shell type."""
+            if platform.system() == "Windows":
+                return os.getenv('ComSpec')  # Typically cmd.exe on Windows
+            else:
+                return os.getenv('SHELL')  # Typically /bin/bash, /bin/zsh, etc. on Unix-like systems
+
+        shell = detect_shell()
+        if not shell:
+            raise EnvironmentError("Could not detect the shell type.")
+        # Execute the command in the detected shell
+        result = subprocess.run(command, shell=True, executable=shell, capture_output=True, text=True)
+        return shell, result
+
+    def filter_commands(self, cmd):
+        cmd = cmd.strip()
+        # HANDLE wait COMMAND
+        if cmd.startswith("WAIT"):
+            wait_cmd = cmd.split()
+            wait = int(wait_cmd[1]) if len(wait_cmd) > 1 else 1
+            action_console("WAIT", cmd)
+            if DRY_RUN:
+                return None
+            time.sleep(wait)
+            return None
+        # HANDLE wait COMMAND
+        if cmd.startswith("MACRO"):
+            action_console("MACRO", cmd)
+            macro_name = cmd.split()[1].strip()
+            self.run_embedded_macro(macro_name)
+            return None
+        if cmd.startswith("SHELL"):
+            action_console("SHELL", cmd)
+            cmd = ' '.join(cmd.split()[1:])
+            try:
+                shell, result = self._run_shell_command(cmd)
+                stdout = result.stdout.strip()
+                stderr = "\n" + result.stderr.strip()
+                action_console(" " * 8, f"[{result.returncode}] {shell} {cmd}\n{stdout}{stderr}")
+            except Exception as e:
+                action_console("ERR", f"NoShell: {e}")
+            return None
+        return cmd
+
+    @staticmethod
+    def validate_conf(conf):
+        is_valid = False
+        parsed_config = {'dbg': False, 'device': None, 'pwd': "ADmin123", 'safe': False, 'parallel': False}
+        conf_list = conf.strip().split()
+        if len(conf_list) < 2:
+            print(f"Not enough parameters:\n#macroscript devName.local/IPaddress\n\t{conf}")
+            sys.exit(3)
+        if conf_list[0] == "#macroscript":
+            is_valid = True
+            # FLAG: safe
+            parsed_config['safe'] = "safe" in conf_list
+            if parsed_config['safe']:
+                conf_list.remove("safe")
+            # FLAG: debug
+            parsed_config['dbg'] = "debug" in conf_list
+            if parsed_config['dbg']:
+                conf_list.remove("debug")
+            # FLAG: parallel
+            parsed_config['parallel'] = "parallel" in conf_list
+            if parsed_config['parallel']:
+                conf_list.remove("parallel")
+            # PARAM: device
+            parsed_config['device'] = conf_list[1]
+            # PARAM: pwd
+            if len(conf_list) > 2:
+                parsed_config['pwd'] = conf_list[2]
+        return is_valid, parsed_config
+
+    @staticmethod
+    def create_template(path):
+        default_conf = """#macroscript 127.0.0.1 safe
+#
+# HINTS:
+#   SHEBANG LINE: #macroscript <device> <password> <opts>
+#       <device>    :   host name or IP address
+#       <password>  :   optional parameter, defualt: ADmin123
+#       <opts>      :   additional optional params:
+#           debug   :   show verbose output
+#           safe    :   only run loaded modules
+#           parallel:   enable parallel macro execution
+#
+# You can list any load module function call to be remotely executed
+#
+# Additional script commands:
+#   WAIT <s>        - seconds to wait before execute next command
+#   MACRO <name>    - run a macro by name (from same dir as parent macro)
+#   SHELL <command> - run shell oneliners
+#   #               - line comment
+
+system top
+system clock
+WAIT 1
+system clock
+
+"""
+
+        print(f"{color.OKGREEN}Create template for{color.NC} {path}")
+        with open(path, 'w') as f:
+            f.write(default_conf)
+
+    def run_micro_script(self, path):
+        try:
+            self._run_micro_script(path)
+        except KeyboardInterrupt:
+            print("Exiting...")
+
+    def _run_micro_script(self, path):
+        if os.path.isdir(path):
+            path = select_menu(path)
+            if path is None:
+                action_console("ERR", "Cannot find macro for selection menu")
+                sys.exit(5)
+        if not (os.path.isfile(path) and path.endswith(".macro")):
+            print(f"No file was found: {path} or extension is not .macro")
+            self.create_template(path)
+            return
+        with open(path, 'r') as f:
+            lines = [ l for l in f.read().strip().splitlines() if len(l.strip()) > 0 ]
+            conf = lines.pop(0)
+        lines  = [ l for l in lines if not l.strip().startswith("#") ]
+        conf_is_valid, conf = self.validate_conf(conf)
+        if not conf_is_valid:
+            print("Invalid initial line, must starts with #macroscript")
+            sys.exit(2)
+
+        if self.com is None:
+            # Inject params from macro if was not set by constructor
+            self.safe_mode = conf['safe'] if self.safe_mode is None else self.safe_mode
+            self.verbose = conf['dbg'] if self.verbose is None else self.verbose
+            self.parallel = conf['parallel'] if self.parallel is None else self.parallel
+            self.host = conf['device'] if self.host is None else self.host
+            self.pwd = conf['pwd'] if self.pwd is None else self.pwd
+            self.workdir = os.path.dirname(path)
+            self.macro_name = os.path.basename(path).split(".")[0].strip()
+        action_console("INIT", f"{color.BOLD}{color.OK}\nmacroSCRIPT{color.NC}: {self.macro_name} {color.BOLD}{self.host}{color.NC}")
+        if DRY_RUN:
+            print(f"conf:{conf}\ncommands:{lines}")
+        start_time = datetime.now()
+        cmd_cnt = 0
+        try:
+            for cmd in lines:
+                cmd = self.filter_commands(cmd)
+                if cmd is None:
+                    continue
+                cmd_cnt += 1
+                state, out = self.run(cmd, force_close=False)
+                if not state:
+                    print("Communication was broken...")
+                    break
+        except Exception as e:
+            print(f"Connection error {self.macro_name}: {e}")
+        finally:
+            if self.com is not None:
+                self.com.close()
+        end_time = datetime.now()
+        elapsed = _elapsed_time(start_time, end_time)
+        print(f"[{color.BOLD}{color.OK}{self.macro_name}{color.NC}] Elapsed time: {elapsed} / {cmd_cnt} command(s).")
+
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("Missing file input")
+        sys.exit(1)
+    MICROSCRIPT_PATH = sys.argv[1]
+    executor = Executor()
+    executor.run_micro_script(MICROSCRIPT_PATH)

toolkit/lib/micrOSClient.py

@@ -1,6 +1,4 @@
 import socket
-import sys
-
 import select
 import re
 import time
@@ -10,6 +8,25 @@ except:
     from TerminalColors import Colors as color
 
 
+ANSI_ESCAPE_RE = re.compile(r"\x1B\[[0-?]*[ -/]*[@-~]")
+
+def load_command_history(prompt_getter):
+    """Optional command history feature"""
+    try:
+        try:
+            from .micrOSClientHistory import CommandInterface
+        except:
+            from micrOSClientHistory import CommandInterface
+    except Exception as e:
+        print(f"Command history - disabled (readline module error): {e}")
+        return None
+    try:
+        return CommandInterface(prompt=prompt_getter)
+    except Exception as e:
+        print(f"Command history error: {e}")
+    return None
+
+
 class micrOSClient:
     CONN_MAP = {}
 
@@ -35,6 +52,10 @@ class micrOSClient:
         # Validate and resolve host (IP/Hostname)
         self.__address_manager()
 
+    @property
+    def telnet_prompt(self):
+        return f"{color.BOLD}{self.preprompt}{self.prompt}{color.NC} "
+
     def __address_manager(self):
         self.dbg_print("[INIT] micrOSClient")
         # Host is valid IP address - self.host is ip address OK
@@ -50,7 +71,7 @@ class micrOSClient:
             if "__simulator__" in self.host:
                 # Simulator hack - due to no dhcp available
                 self.host = '127.0.0.1'
-                self.hostname = 'node01'
+                self.hostname = 'simulator'     # HARDCODE MATCHING HOSTNAME FOR __simulator__
             else:
                 # * Set self.host to ip address OK
                 self.host = socket.getaddrinfo(self.host, self.port)[-1][4][0]
@@ -67,10 +88,22 @@ class micrOSClient:
 
     @staticmethod
     def validate_ipv4(str_in):
-        pattern = "^([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$"
-        if bool(re.match(pattern, str_in)):
-            return True
-        return False
+        parts = str_in.split(".")
+        # An IPv4 address must have exactly 4 parts
+        if len(parts) != 4:
+            return False
+        for part in parts:
+            # Each part must be a number and not empty
+            if not part.isdigit():
+                return False
+            num = int(part)
+            # Each number must be in the valid range (0-255)
+            if num < 0 or num > 255:
+                return False
+            # Prevents leading zeros (e.g., "01" is invalid)
+            if part != str(num):
+                return False
+        return True
 
     def __connect(self, timeout):
         # Server connection - create socket
@@ -143,24 +176,35 @@ class micrOSClient:
 
     def __filter_preprompt(self, _data):
         if len(_data) == 0:
-            return
-        last_line = _data.strip().split('\n')[-1]
-        # get pre-prompt: >[configure]< prompt $
+            return _data
+
+        has_trailing_newline = _data.endswith('\n')
+        working = _data.rstrip('\n')
+        lines = working.split('\n') if working else ['']
+        last_line = lines[-1]
+
         if self.prompt is not None:
-            # Check prompt is in last line
-            if self.prompt in last_line:
-                # Check pre-prompt - remove prompt
-                x = last_line.replace(self.prompt, '')
-                # SET preprompt if preprompt exists
-                self.preprompt = x if len(x) > 0 else self.preprompt
-            # Pre-prompt remove and cancel preprompt modes
-            if self.preprompt in last_line:
-                _data = _data.replace(self.preprompt, "")
-            else:
-                self.preprompt = ""
-        return _data
+            prompt_index = last_line.find(self.prompt)
+            if prompt_index != -1:
+                raw_prefix = last_line[:prompt_index]
+                plain_prefix = ANSI_ESCAPE_RE.sub('', raw_prefix)
+
+                plain_prefix = plain_prefix.rstrip()
+                if plain_prefix:
+                    if not plain_prefix.endswith(' '):
+                        plain_prefix += ' '
+                    self.preprompt = plain_prefix
+                else:
+                    self.preprompt = ""
+
+                lines[-1] = last_line[prompt_index:]
 
-    def __receive_data(self, read_timeout=20):
+        rebuilt = '\n'.join(lines)
+        if has_trailing_newline:
+            rebuilt += '\n'
+        return rebuilt
+
+    def __receive_data(self, read_timeout=20, stream=False):
         """
         Client Receiver Loop
         - read_timeout - wait for server to reply (should be <15, avoid msg queue-ing)
@@ -173,7 +217,11 @@ class micrOSClient:
         # Collect answer data
         if select.select([self.conn], [], [], read_timeout)[0]:
             while True:
-                data_buffer += self.conn.recv(4096).decode('utf-8')
+                incoming_data = self.conn.recv(4096).decode('utf-8')
+                if stream:
+                    incoming_data = incoming_data.replace(self.prompt, f"{color.NC}{color.BOLD}{self.prompt}{color.NC}")
+                    print(f"\r{color.LIGHT_GRAY}{incoming_data}{color.NC}", end="")
+                data_buffer += incoming_data
                 # Last line from data_buffer (handle fragmented messages - prompt detection)
                 last_line = data_buffer.strip().split("\n")[-1]
                 # Wait for prompt or special cases (exit/prompt)
@@ -200,7 +248,7 @@ class micrOSClient:
         self.isconn = False
         self.spacer = 0
 
-    def __run_command(self, cmd):
+    def __run_command(self, cmd, stream=False):
         """
         Run command on server tcp/ip connection
         - prompt check - validate device ("hostname $" = "prompt")
@@ -218,14 +266,14 @@ class micrOSClient:
             # Workaround for reboot command - micrOS async server cannot send Bye! msg before reboot.
             if reboot_request:
                 return 'Bye!'
-            data = self.__receive_data()
+            data = self.__receive_data(stream=stream)
             return data
         # Skip command run: prompt and host not the same!
         print(f"[micrOSClient] {color.ERR}prompt mismatch{color.NC}, hostname: {check_hostname} prompt: {check_prompt} ")
         # Check UID?
         return None
 
-    def send_cmd(self, cmd, timeout=3, retry=5):
+    def send_cmd(self, cmd, timeout=3, retry=5, stream=False):
         """
         Send command function - main usage for non interactive mode
         """
@@ -244,7 +292,7 @@ class micrOSClient:
 
         # @ Run command
         try:
-            out = self.__run_command(cmd)
+            out = self.__run_command(cmd, stream=stream)
         except Exception as e:
             self.dbg_print("{}[ERR]{} send_cmd error: {}".format(color.ERR, color.NC, e))
             self.dbg_print("Auto deinit connection")
@@ -258,14 +306,14 @@ class micrOSClient:
         f_delta_t = "{}[{:.2f}]{}".format(color.OKGREEN, delta_time, color.NC)
         self.dbg_print("{}[⏰] {} {}reply: {}{}".format(f_delta_t, cmd, color.BOLD, out, color.NC))
 
-        # return output list
+        # return output list or None
         return out
 
-    def send_cmd_retry(self, cmd, timeout=6, retry=5):
+    def send_cmd_retry(self, cmd, timeout=6, retry=5, stream=False):
         out = None
         for cnt in range(0, retry):
             try:
-                out = self.send_cmd(cmd, timeout)
+                out = self.send_cmd(cmd, timeout, stream=stream)
                 if out is None or isinstance(out, list):
                     break
             except OSError as e:
@@ -277,7 +325,7 @@ class micrOSClient:
             time.sleep(0.2)
         return out
 
-    def telnet(self, timeout=4):
+    def telnet(self, timeout=5):
         """
         Implements interactive mode for socket communication.
         """
@@ -287,18 +335,41 @@ class micrOSClient:
             print("Telnet connect: {}".format(e))
             if "busy" in str(e) or "timed out" in str(e) or "No route to host" in str(e) or "Host is down" in str(e):
                 return
+
+        history = load_command_history(self.telnet_prompt)              # History: Beta feature
+        if history is not None:
+            history.prompt = self.telnet_prompt
+        print(self.telnet_prompt, end="")
+        is_empty = False                                                # Empty input support
         while True:
-            cmd = input("{}{} ".format(self.preprompt, self.prompt))
-            # send command
-            output = self.send_cmd(cmd)
-            # Format output to human readable
-            output = '\n'.join(output) if isinstance(output, list) else output
-            # output to STDOUT
-            if not (cmd.strip() == '' and output is None):
-                print(output)
-            # Close session
-            if 'Bye!' in str(output):
+            try:
+                # INPUT HANDLING
+                if history is not None:
+                    history.prompt = self.telnet_prompt
+                cmd = input(self.telnet_prompt if is_empty else '')     # CANNOT contain prompt - it is coming back from response data
+                if len(cmd.strip()) == 0:
+                    is_empty = True
+                    if history is not None:
+                        history.prompt = self.telnet_prompt
+                    continue
+                is_empty = False
+                # SEND COMMAND
+                output = self.send_cmd(cmd, timeout=timeout, stream=True)
+                if history is not None:
+                    history.prompt = self.telnet_prompt
+                if not (history is None or output is None) and "Shell: for hints type help." not in output:   # History: Beta feature
+                    history.add_history(cmd)
+                # OUTPUT HANDLING
+                if 'Bye!' in str(output):
+                    break
+                if output is None:
+                    print("Exiting... client disconnected")
+                    break
+            except KeyboardInterrupt:
+                print("Exiting...")
                 break
+        if history is not None:                                         # History: Beta feature
+            history.save_history()
         self.close()
 
     def dbg_print(self, msg, end='\n'):
@@ -325,8 +396,9 @@ class micrOSClient:
             verdict.append(console_msg)
             print(f"===>\t\t{console_msg}")
         self.close()
-        verdict.append(f"SINGLE CONNECTION LOAD TEST X{cnt}, AVERAGE REPLY TIME: {round(delta_t_all/cnt, 3)} sec\n")
-        return verdict
+        delta_t_result = round(delta_t_all / cnt, 3)
+        verdict.append(f"SINGLE CONNECTION LOAD TEST X{cnt}, AVERAGE REPLY TIME: {delta_t_result} sec\n")
+        return verdict, delta_t_result
 
     def __del__(self):
         if self.dbg and self.avg_reply[1] > 0:
@@ -355,9 +427,10 @@ def micros_connection_metrics(address):
             print(f"\t\t{_console_msg}")
             all_reply.append(_console_msg)
         success_rate = int(round(_success / cnt, 2) * 100)
-        all_reply.append(f"MULTI CONNECTION LOAD TEST X{cnt}, AVERAGE REPLY TIME: {round(_all_delta_t/cnt, 3)}s, "
-                         f"SERVER AVAILABILITY: {success_rate}% ({round(_all_delta_t/_success, 3)}s)")
-        return all_reply
+        delta_t_result = round(_all_delta_t/cnt, 3)
+        all_reply.append(f"MULTI CONNECTION LOAD TEST X{cnt}, AVERAGE REPLY TIME: {delta_t_result}s, "
+                         f"SERVER AVAILABILITY: {success_rate}% ({int((_all_delta_t/_success)*1000)} ms)")
+        return all_reply, delta_t_result
 
     # ---------------------------------------------------- #
     high_level_verdict = []
@@ -365,12 +438,12 @@ def micros_connection_metrics(address):
     # [1] Create micrOSClient object + Run LOAD tests
     com_obj = micrOSClient(host=address, port=9008, pwd="ADmin123", dbg=True)
     # [1.1] Run load test in one connection
-    verdict_list = com_obj.load_test()
+    verdict_list, delta_t_single_session = com_obj.load_test()
     com_obj.close()
     high_level_verdict.append(verdict_list[-1])
 
     # [2] Run multi connection load test - reconnect - raw connection (without retry)
-    verdict_multi = multi_conn_load(address)
+    verdict_multi, delta_t_multi_session = multi_conn_load(address)
     high_level_verdict.append((verdict_multi[-1]))
 
     ############################################################################
@@ -382,7 +455,7 @@ def micros_connection_metrics(address):
     for k in verdict_multi:
         print(f"\t{k}")
 
-    return high_level_verdict
+    return high_level_verdict, delta_t_single_session, delta_t_multi_session
 
 
 if __name__ == "__main__":
@@ -416,7 +489,7 @@ if __name__ == "__main__":
     print(f"noconf out: {noconf_mode}")
     if force_close: com_obj.close()
 
-    verdict = micros_connection_metrics(address=address)
+    verdict, delta_t_single, delta_t_multi = micros_connection_metrics(address=address)
     for k in verdict:
         print(f"+\t\t{k}")