micrOSDevToolKit 2.9.8__py3-none-any.whl → 2.9.11__py3-none-any.whl

toolkit/dashboard_apps/SystemTest.py

@@ -5,34 +5,79 @@ import sys
 import time
 import socket
 import ast
+from pprint import pprint
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
+
 MYPATH = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
+REPORT_OUTPUT_PATH = os.path.join(MYPATH, '../../micrOS/release_info/micrOS_ReleaseInfo/devices_system_metrics.json')
 sys.path.append(os.path.join(MYPATH, '../lib/'))
 from TerminalColors import Colors
 import requests
 
-# FILL OUT
-DEVICE = '__simulator__'
-PASSWD = None
+CLIENT = None
 TIMEOUT_SEC = 5
 
-
-def base_cmd():
-    if PASSWD is None:
-        return ['--dev', DEVICE]
-    return ['--dev', DEVICE, '--password', PASSWD]
-
-
-def get_device():
-    return DEVICE
-
+# COLLECT AND SAVE SYSTEM TEST METRICS
+ENABLE_DATA_COLLECTION = os.environ.get("ENABLE_DATA_COLLECTION", False)
+REPORT_DICT = {}
+METRICS = {}
+
+#####################################
+#               METRICS             #
+#####################################
+def load_reports():
+    global REPORT_DICT
+    previous_reports = {}
+    try:
+        with open(REPORT_OUTPUT_PATH, 'r') as f:
+            previous_reports = json.loads(f.read())
+    except FileNotFoundError:
+        pass
+    finally:
+        REPORT_DICT = previous_reports
+
+def create_report(device_name:str, metrics:dict) -> None:
+    global REPORT_DICT
+
+    if not ENABLE_DATA_COLLECTION:
+        print(f"[SKIP] system test metrics export, ENABLE_DATA_COLLECTION={ENABLE_DATA_COLLECTION}")
+        pprint(metrics)
+        return
+    load_reports()
+    version = metrics.get('version')
+    device_type = metrics.get('board_type')
+    device_type = '???' if device_type is None else device_type.split()[-1]
+    if REPORT_DICT.get(version) is None:
+        REPORT_DICT[version] = {}
+    if REPORT_DICT.get(version).get(device_type) is None:
+        REPORT_DICT[version][device_type] = {}
+    REPORT_DICT[version][device_type][device_name] = metrics
+    # Cleanup - remove redundant elements
+    REPORT_DICT[version][device_type][device_name].pop("board_type", None)
+    REPORT_DICT[version][device_type][device_name].pop("version", None)
+    # Dump report
+    print(f"Save system test report: {REPORT_OUTPUT_PATH}")
+    pprint(metrics)
+    with open(REPORT_OUTPUT_PATH, 'w') as f:
+        f.write(json.dumps(REPORT_DICT, indent=4))
+
+
+def _add_metrics(key:str, value):
+    global METRICS
+    METRICS[key] = value
+
+#####################################
+#               TESTS               #
+#####################################
 
 def single_cmd_exec_check():
     info = "[ST] Run single command execution check [hello]"
     print(info)
     cmd_list = ['hello']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if output[1].startswith("hello:"):
             return True, info
@@ -42,17 +87,18 @@ def shell_cmds_check():
     info = "[ST] Run built-in shell commands [modules|version|help]"
     print(info)
     cmd_list = ['modules']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
+        _add_metrics("modules", ast.literal_eval(output[1]))
         if not (output[1].startswith("[") and output[1].endswith("]")):
             return False, f"{info}modules: {output[1]}"
     cmd_list = ['version']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if not ('.' in output[1] and '-' in output[1]):
             return False, f"{info}version: {output[1]}"
     cmd_list = ['help']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if not ('[MICROS]' in output[1] and '[CONF]' in output[1] and '[TASK]' in output[1] and '[EXEC]' in output[1]):
             return False, f"{info}help: {output[1]}"
@@ -63,7 +109,7 @@ def lm_cmd_exec_check():
     info = "[ST] Run Load Module command execution check [system heartbeat]"
     print(info)
     cmd_list = ['system heartbeat']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if output[1].strip() == '<3 heartbeat <3':
             return True, info
@@ -74,7 +120,7 @@ def micrOS_config_get():
     info = "[ST] Run micrOS config get [conf -> socport]"
     print(info)
     cmd_list = ['config <a> socport']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if output[1].strip() == '9008':
             return True, info
@@ -88,7 +134,7 @@ def micrOS_config_set():
 
     # [1] Get actual utc value
     cmd_list = ['config <a> utc']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         try:
             utc_bak = int(output[1].strip())
@@ -98,21 +144,21 @@ def micrOS_config_set():
     # [2] Set x+1 value as expected
     utc_expected = utc_bak+1
     cmd_list = ['config <a> utc {}'.format(utc_expected)]
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if output[1].strip() != 'Saved':
             return False, f"{info} + utc overwrite issue: {output[1]}"
 
     # [3] Get modified utc value - veridy [2] step
     cmd_list = ['config <a> utc']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if int(output[1].strip()) != utc_expected:
             return False, f"{info} + utc modified value error: {output[1]} != {utc_expected}"
 
     # Restore original value
     cmd_list = ['config <a> utc {}'.format(utc_bak)]
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if output[1].strip() != 'Saved':
             return False, f"{info} + utc overwrite issue: {output[1]}"
@@ -126,11 +172,11 @@ def micrOS_bgjob_one_shot_check():
     print(info)
 
     # Initial task cleanup...
-    execute(['task kill system.clock'])
+    CLIENT.execute(['task kill system.clock'])
 
     for _ in range(0, 2):
         cmd_list = ['system clock &']
-        output = execute(cmd_list)
+        output = CLIENT.execute(cmd_list)
         time.sleep(1)
         if output[0]:
             if 'Start system.clock' not in output[1].strip():
@@ -144,14 +190,14 @@ def micrOS_bgjob_loop_check():
 
     # Start background task loop
     cmd_list = ['system clock &&']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if 'Start system.clock' not in output[1].strip():
             return False, f'[Start Task error] {info} + not expected return: {output[1]}'
 
     # Attempt to overload background thread
     cmd_list = ['system clock &&']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if 'system.clock is Busy' not in output[1].strip():
             return False, f'[Overload task - run same] {info} + not expected return: {output[1]}'
@@ -159,14 +205,14 @@ def micrOS_bgjob_loop_check():
     # Show task output by task tag
     time.sleep(0.1)                           # Give time for the task to start and update buffer... (sim)
     cmd_list = ['task show system.clock']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if "No task found" in output[1].strip() or len(output[1].strip()) == 0:
             return False, f'[No task output] {info} + not expected return: {output[1]}'
 
     # Stop BgJob
     cmd_list = ['task kill system.clock']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if 'Kill:' in output[1].strip() or 'system.clock' in output[1].strip():
             return True, f'[Stop task] {info}'
@@ -179,7 +225,7 @@ def micrOS_task_list_check():
     print(info)
 
     async_available_cmd_list = ['task list']
-    output = execute(async_available_cmd_list)
+    output = CLIENT.execute(async_available_cmd_list)
     if output[0]:
         if "---- micrOS  top ----" not in output[1]:
             return False, f"{info} - ERROR: missing response prefix {output[1]}"
@@ -187,7 +233,7 @@ def micrOS_task_list_check():
         return False, f"{info} - task list error: {output[1]}"
 
     async_available_cmd_list = ['task list >json']
-    output = execute(async_available_cmd_list)
+    output = CLIENT.execute(async_available_cmd_list)
     if output[0]:
         starts = '{'
         ends = '}'
@@ -201,10 +247,11 @@ def micrOS_get_version():
     info = "[ST] Run micrOS get version [version]"
     print(info)
     cmd_list = ['version']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if '.' in output[1].strip() and '-' in output[1].strip():
             return True, f"{info} v:{output[1].strip()}"
+    _add_metrics('version', output[1])
     return False, f"{info} out: {output[1]}"
 
 
@@ -212,7 +259,7 @@ def json_format_check():
     info = "[ST] Run micrOS raw output check aka >json [system rssi >json]"
     print(info)
     cmd_list = ['system rssi >json']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0] and output[1].startswith("{") and output[1].endswith("}"):
         return True, info + f" out: {output[1]}"
     return False, info + f" out: {output[1]}"
@@ -223,25 +270,25 @@ def negative_interface_check():
     print(info)
 
     cmd_list = ['Apple']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if 'Shell: for hints type help.' not in output[1].strip():
             return False, f'[Wrong single command] {info} + not expected return: {output[1]}'
 
     cmd_list = ['Apple test']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if 'no module named' not in output[1].strip().lower():
             return False, f'[Missing module] {info} + not expected return: {output[1]}'
 
     cmd_list = ['conf', 'gmttimaaaa']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if output[1].strip() != 'None':
             return False, f'[Config invalid key] {info} + not expected return: {output[1]}'
 
     cmd_list = ['conf', 'utc "type"']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0]:
         if output[1].strip() != 'Failed to save':
             return False, f'[Config invalid key type] {info} + not expected return: {output[1]}'
@@ -265,11 +312,12 @@ def measure_package_response_time():
     # Start time
     start = time.time()
     # Command exec
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     # Stop time
     end = time.time() - start
     # Get average response time
     delta_cmd_rep_time = round(end/10, 4)
+    _add_metrics('shell_heartbeatX10_response_ms', int(delta_cmd_rep_time*1000))
     # Create verdict
     print(output)
     if output[0] and "<3 heartbeat <3" in output[1]:
@@ -281,7 +329,7 @@ def micros_alarm_check():
     info = "[ST] Test alarm state - system alarms should be null"
     print(info)
     cmd_list = ['system alarms']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     alarm_cnt = 0
     if output[0]:
         try:
@@ -292,7 +340,7 @@ def micros_alarm_check():
             print(e)
         # Clean alarms
         cmd_list = ['system alarms True']
-        execute(cmd_list)
+        CLIENT.execute(cmd_list)
         # Evaluation
         if alarm_cnt > 0:
             return True, info + f" -1 !!!WARN!!! [{alarm_cnt}] out: {output[1]}"
@@ -301,10 +349,10 @@ def micros_alarm_check():
 
 def oled_msg_end_result(result):
     cmd_list = ['pacman moduls >json']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0] and 'LM_oled_ui' in output[1]:
         cmd_list = [f'oled_ui msgbox "{result} %"']
-        print(execute(cmd_list))
+        print(CLIENT.execute(cmd_list))
 
 
 def check_device_by_hostname(dev):
@@ -325,7 +373,7 @@ def check_robustness_exception():
     info_msg = '[ST] Check robustness - exception [robustness raise_error]'
     print(info_msg)
     cmd_list = ['robustness raise_error']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0] and "Core error: LM_robustness->raise_error: Test exception" in output[1]:
         return True, f'{info_msg}: Valid error msg: exec_lm_core *->raise_error: *'
     else:
@@ -336,7 +384,7 @@ def check_robustness_memory():
     info_msg = '[ST] Check robustness - memory_leak [robustness memory_leak 12]'
     print(info_msg)
     cmd_list = ['robustness memory_leak 12']
-    output = execute(cmd_list)
+    output = CLIENT.execute(cmd_list)
     if output[0] and "[12] RAM Alloc" in output[1]:
         end_result = output[1].split("\n")[-1]
         return True, f'{info_msg}: Mem alloc: {end_result}'
@@ -348,7 +396,7 @@ def check_robustness_recursion():
     info_msg = '[ST] Check robustness - recursion [robustness recursion_limit 8]'
     print(info_msg)
     cmd_list = ['robustness recursion_limit 8']
-    output = execute(cmd_list, tout=10)
+    output = CLIENT.execute(cmd_list, tout=10)
     if output[0]:
         last_line = output[1].split("\n")[-1]
         if "Recursion limit:" in last_line:
@@ -372,7 +420,7 @@ def check_intercon(host=None):
         _output = None
         for _ in range(0, 2):
             time.sleep(1)
-            _output = execute(_cmd_list, tout=8)
+            _output = CLIENT.execute(_cmd_list, tout=8)
             if _output[0] and 'No task found:' not in _output[1]:
                 _state = True
                 break
@@ -382,7 +430,7 @@ def check_intercon(host=None):
     print(info_msg)
     host = 'test.local' if host is None else host
     cmd_list = ['intercon sendcmd "{}" "hello" >json'.format(host)]
-    output = execute(cmd_list, tout=8)
+    output = CLIENT.execute(cmd_list, tout=8)
     output = _convert_return_to_dict(output)
     device_was_found = False
     if output[0] is False or output[1] is None:
@@ -404,7 +452,7 @@ def check_intercon(host=None):
     if device_was_found:
         # DO Negative testing as well
         cmd_list = ['intercon sendcmd "notavailable.local" "hello" >json']
-        output_neg = execute(cmd_list, tout=15)
+        output_neg = CLIENT.execute(cmd_list, tout=15)
         output_neg = _convert_return_to_dict(output_neg)
         state_neg = False, output_neg
         if len(output_neg[1]) > 1 and "hello" in output_neg[1]['verdict']:
@@ -417,9 +465,11 @@ def check_intercon(host=None):
 
 def measure_conn_metrics():
     try:
-        verdict = socketClient.connection_metrics(f"{get_device().strip()}.local")
+        verdict, delta_t_single, delta_t_multi = CLIENT.connection_metrics()
+        _add_metrics("shell_single_session_dt_ms", int(delta_t_single*1000))
+        _add_metrics("shell_multi_session_dt_ms", int(delta_t_multi*1000))
         for k in verdict:
-            print("\t\t{}".format(k))
+            print(f"\t\t{k}")
         state = True if len(verdict) > 0 else False
     except Exception as e:
         state = False
@@ -429,7 +479,7 @@ def measure_conn_metrics():
 
 def memory_usage():
     cmd = ['system memory_usage >json']
-    out = execute(cmd, tout=TIMEOUT_SEC)
+    out = CLIENT.execute(cmd, tout=TIMEOUT_SEC)
     state, raw_output = out[0], out[1]
     try:
         json_out = json.loads(raw_output)
@@ -437,6 +487,8 @@ def memory_usage():
         return False, '[ST] {}ERR{}: {}: {}'.format(Colors.ERR, Colors.NC, raw_output, e)
 
     # {"percent": 93.11, "mem_used": 103504}
+    _add_metrics('mem_percent', json_out.get('percent'))
+    _add_metrics('mem_used_byte', json_out.get('mem_used'))
     if json_out.get('percent') > 70:        # MEM USAGE WARNING INDICATOR: 80%
         return state, '[ST] {}WARNING{}: memory usage {}% ({} bytes)'.format(Colors.WARN, Colors.NC,
                                                                              json_out.get('percent'),
@@ -450,7 +502,7 @@ def disk_usage():
     Check disk usage - manually defined 16% (336_000 byte) - check degradations...
     """
     cmd = ['system disk_usage >json']
-    out = execute(cmd, tout=TIMEOUT_SEC)
+    out = CLIENT.execute(cmd, tout=TIMEOUT_SEC)
     state, raw_output = out[0], out[1]
     try:
         json_out = json.loads(raw_output)
@@ -458,6 +510,8 @@ def disk_usage():
         return False, '[ST] {}ERR{}: {}: {}'.format(Colors.ERR, Colors.NC, raw_output, e)
 
     # {"percent": 15.4, "fs_used": 323_584}
+    _add_metrics('fs_percent', json_out.get('percent'))
+    _add_metrics('fs_used_byte', json_out.get('fs_used'))
     if json_out.get('fs_used') > 700_000:        # MEM USAGE WARNING INDICATOR: 700_000 bytes (700kb)
         return state, '[ST] {}WARNING{}: disk usage {}% ({} bytes)'.format(Colors.WARN, Colors.NC,
                                                                              json_out.get('percent'),
@@ -468,7 +522,7 @@ def disk_usage():
 
 def task_list():
     cmd = ['task list']
-    out = execute(cmd, tout=TIMEOUT_SEC)
+    out = CLIENT.execute(cmd, tout=TIMEOUT_SEC)
     state, output = out[0], out[1]
     if state:
         return state, output.replace('\n', f'\n{" "*51}')        # TODO format output
@@ -478,12 +532,12 @@ def task_list():
 def webcli_test():
     endpoints = []
     cmd = ['conf', 'webui']
-    out = execute(cmd, tout=TIMEOUT_SEC)
+    out = CLIENT.execute(cmd, tout=TIMEOUT_SEC)
     state, output = out[0], out[1]
     if state:
         verdict = f"[ST] WEBUI IS ENABLED ({output})" if output.strip() == 'True' else f"[ST] WEBUI IS DISABLED ({output})"
         if output.strip() == 'True':
-            out = execute(['conf', 'devip'], tout=TIMEOUT_SEC)
+            out = CLIENT.execute(['conf', 'devip'], tout=TIMEOUT_SEC)
             if out[0] and out[1] is not None:
                 devip = out[1]
                 endpoints.append(f'http://{devip}')
@@ -491,27 +545,35 @@ def webcli_test():
 
             for endpoint in endpoints:
                 _start_t = time.time()
+                delta_t = -1
                 try:
                     response = requests.get(endpoint, timeout=5)
+                    delta_t = round(time.time() - _start_t, 2)
                     # Check if the request was successful
                     if not (response.status_code == 200 and ('<!DOCTYPE html>' in str(response.content) or '"micrOS"' in str(response.content))):
-                        verdict += f" Endpoint: {endpoint} [{Colors.ERR}NOK{Colors.NC}]({round(time.time()-_start_t, 2)}s)"
+                        verdict += f" Endpoint: {endpoint} [{Colors.ERR}NOK{Colors.NC}]({delta_t}s)"
                         print(response.content)
                         state = False
                     else:
-                        verdict += f" Endpoint: {endpoint} [{Colors.OK}OK{Colors.NC}]({round(time.time()-_start_t, 2)}s)"
+                        verdict += f" Endpoint: {endpoint} [{Colors.OK}OK{Colors.NC}]({delta_t}s)"
+
+                        metrics_name = 'landingpage' if "." in endpoint.split('/')[-1] else endpoint.split('/')[-1]
+                        _add_metrics(f"web_{metrics_name}_response_ms", int(delta_t*1000))
                 except Exception as e:
-                    verdict += f" Endpoint: {endpoint} [{Colors.ERR}NOK{Colors.NC}]({round(time.time()-_start_t, 2)}s)"
+                    verdict += f" Endpoint: {endpoint} [{Colors.ERR}NOK{Colors.NC}]({delta_t}s)"
                     print(f"webcli_test error: {e}")
                     state  = False
         return state, verdict
     return state, output
 
+#####################################
+#               HELPERS             #
+#####################################
 
 def after_st_reboot():
     verdict = False, 'reboot -h failed'
     cmd = ['reboot -h']
-    out = execute(cmd, tout=TIMEOUT_SEC)
+    out = CLIENT.execute(cmd, tout=TIMEOUT_SEC)
     state, output = out[0], out[1]
     if state:
         verdict = state, f'[reboot-h] commad out: {output}'
@@ -519,7 +581,7 @@ def after_st_reboot():
             print(f"[reboot-h] Wait for node up again ({retry}/{retry*2}sec)")
             time.sleep(2)
             try:
-                up, o = execute(['hello'], tout=TIMEOUT_SEC)
+                up, o = CLIENT.execute(['hello'], tout=TIMEOUT_SEC)
                 if up:
                     verdict = True, f"[reboot-h][OK] successfully rebooted: {o} (boot time: ~{retry * 2}sec)"
                     print(verdict[1])
@@ -532,19 +594,37 @@ def after_st_reboot():
 
 def get_dev_version():
     cmd = ['version']
-    out = execute(cmd, tout=TIMEOUT_SEC)
+    out = CLIENT.execute(cmd, tout=TIMEOUT_SEC)
     state, output = out[0], out[1]
+    _add_metrics("version", output)
     if state:
         return output
     return '0.0.0-0'
 
+def get_dev_board_type():
+    cmd = ['system info >json']
+    out = CLIENT.execute(cmd, tout=TIMEOUT_SEC)
+    state, output = out[0], out[1]
+    output = ast.literal_eval(output)
+    board = output.get("board")
+    upython = output.get("upython")
+    _add_metrics("board_type", board)
+    _add_metrics("micropython_version", str(upython))
+    if state:
+        return board, upython
+    return None, None
+
+#####################################
+#              MAIN APP             #
+#####################################
+
 def app(devfid=None, pwd=None):
-    global DEVICE, PASSWD
-    if devfid is not None:
-        DEVICE = devfid
-    if pwd is not None:
-        PASSWD = pwd
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
+    # Get device info
+    version = get_dev_version()
+    get_dev_board_type()        # update metrics
     # Get test verdict
     verdict = {'single_cmds': single_cmd_exec_check(),
                'shell_cmds': shell_cmds_check(),
@@ -558,7 +638,7 @@ def app(devfid=None, pwd=None):
                'json_check': json_format_check(),
                'response_time': measure_package_response_time(),
                'negative_api': negative_interface_check(),
-               'dhcp_hostname': check_device_by_hostname(DEVICE),
+               'dhcp_hostname': check_device_by_hostname(CLIENT.get_device()),
                'lm_exception': check_robustness_exception(),
                'mem_usage': memory_usage(),
                'disk_usage': disk_usage(),
@@ -575,8 +655,8 @@ def app(devfid=None, pwd=None):
     # Test Evaluation
     final_state = True
     ok_cnt = 0
-    version = get_dev_version()
-    print(f"\n----------------------------------- micrOS System Test results on {DEVICE}:{version} device -----------------------------------")
+    create_report(CLIENT.get_device(), METRICS)
+    print(f"\n----------------------------------- micrOS System Test results on {CLIENT.get_device()}:{version} device -----------------------------------")
     print("\tTEST NAME\t\tSTATE\t\tDescription\n")
     for test, state_data in verdict.items():
         state = Colors.ERR + 'NOK' + Colors.NC
@@ -596,11 +676,5 @@ def app(devfid=None, pwd=None):
     oled_msg_end_result(f"System[{state}] {pass_rate}")
 
 
-def execute(cmd_list, tout=5):
-    cmd_args = base_cmd() + cmd_list
-    print("[ST] test cmd: {}".format(cmd_args))
-    return socketClient.run(cmd_args, timeout=tout)
-
-
 if __name__ == "__main__":
     app()

toolkit/dashboard_apps/Template_app.py

@@ -2,28 +2,16 @@
 
 import os
 import sys
-import time
 MYPATH = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
 sys.path.append(os.path.join(MYPATH, '../lib/'))
 from TerminalColors import Colors
 
-# FILL OUT
-DEVICE = 'node01'
-PASSWD = None
-
-def base_cmd():
-    if PASSWD is None:
-        return ['--dev', DEVICE]
-    return ['--dev', DEVICE, '--password', PASSWD]
-
-def run_command(cmd):
-    # EDIT YOUR COMMAND
-    args = base_cmd() + cmd
-    status, answer = socketClient.run(args)
-    return status, answer
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
 
+CLIENT = None
 
 def app(devfid=None, pwd=None):
     """
@@ -31,13 +19,13 @@ def app(devfid=None, pwd=None):
         send command(s) over socket connection [socketClient.run(args)]
         list load module commands and send in single connection
     """
-    global DEVICE, PASSWD
-    if devfid is not None:
-        DEVICE = devfid
-    if pwd is not None:
-        PASSWD = pwd
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
-    status, answer = run_command(['help', 'version'])
+    output = CLIENT.execute(['help', 'version'])
+    status = output[0]
+    result = output[1]
+    print(f"{Colors.WARN}[{status}]{Colors.NC} {result}")
 
 
 if __name__ == "__main__":

toolkit/dashboard_apps/_app_base.py

@@ -0,0 +1,34 @@
+#####################################
+#            APP CONFIG             #
+#####################################
+import os, sys
+MYPATH = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.dirname(MYPATH))
+import socketClient
+
+class AppBase:
+
+    def __init__(self, device:str, password:str):
+        self.device = device
+        self.password = password
+
+    def base_cmd(self) -> list:
+        if self.password is None:
+            return ['--dev', self.device]
+        return ['--dev', self.device, '--password', self.password]
+
+    def get_device(self):
+        return self.device
+
+    def execute(self, cmd_list, tout=5):
+        cmd_args = self.base_cmd() + cmd_list
+        print(f"Execute: {cmd_args}")
+        return socketClient.run(cmd_args, timeout=tout)
+
+    def run(self, cmd_list):
+        """Legacy"""
+        out = self.execute(cmd_list)
+        return out[0], out[1]
+
+    def connection_metrics(self):
+        return socketClient.connection_metrics(f"{self.device}.local")