ryry-cli 1.0__py3-none-any.whl

ryry/constant.py

@@ -0,0 +1,5 @@
+#!!!!! do not change this file !!!!!
+app_version="1.0"
+app_bulld_number=10
+app_bulld_anchor="Noh_2024-05-21 19:10:52.776464"
+app_name="ryry-cli"

ryry/main.py

@@ -0,0 +1,300 @@
+import sys, os, urllib3, time, platform, json
+
+from ryry import utils
+from ryry import ryry_service
+from ryry import ryry_widget
+from ryry import store
+from ryry import utils
+from ryry import taskUtils
+
+ll = 25
+def scr_str(s):
+    return "| " + s + " |"
+def scr_str1(s):
+    return "| " + s
+def scr_line(s):
+    return "|" + s + "|"
+
+def service_status(stdscr, idx):
+    def real_stdsrc(*args):
+        if platform.system() == 'Windows':
+            print(args[2])
+        else:
+            stdscr.addstr(*args)
+    if platform.system() != 'Windows':
+        real_stdsrc(idx, 0, scr_str("test".ljust(ll)))
+        real_stdsrc(idx, ll*1-1, scr_str("us".ljust(ll)))
+        real_stdsrc(idx, ll*2-2, scr_str("sg".ljust(ll)))
+        idx+=1
+    def running_task_uuids():
+        lst = []
+        if os.path.exists(taskUtils.task_config_file):
+            with open(taskUtils.task_config_file, 'r') as f:
+                data = json.load(f)
+            infos = ""
+            for it in data:
+                if it not in ["last_task_pts"]:
+                    lst.append(it)
+        return lst
+    lst = running_task_uuids()
+    for d in range(0, max([len(lst)])):
+        def widget_stdscr(this_d, this_lst, row_idx, col_idx, append_str):
+            if this_d < len(this_lst):
+                real_s = this_lst[this_d]
+                if len(append_str) > 0:
+                    real_s += f" [{append_str}]"
+                real_stdsrc(row_idx, col_idx, scr_str(" " + real_s.ljust(ll-1)))
+            else:
+                real_stdsrc(row_idx, col_idx, scr_str(" " + " ".ljust(ll-1)))
+        widget_stdscr(d, lst, idx, 0, "task" if platform.system() == 'Windows' else "")
+        idx+=1
+    return idx
+
+def device_status(stdscr, idx):
+    def real_stdsrc(*args):
+        if platform.system() == 'Windows':
+            print(args[2])
+        else:
+            stdscr.addstr(*args)
+    import psutil
+    import GPUtil
+    cpu_load = psutil.cpu_percent(interval=1)
+    mem = psutil.virtual_memory()
+    mem_load = mem.percent
+    gpu_list = GPUtil.getGPUs()
+    if len(gpu_list) > 0:
+        gpu_load = gpu_list[0].load * 100  # 只考虑第一块显卡
+    else:
+        gpu_load = 0
+    real_stdsrc(idx, 0, scr_str(f"Device Usage   |   CPU : {cpu_load}%   |   Memory : {mem_load}%   |   GPU : {gpu_load}%".ljust(ll*3-2)))
+    idx+=1
+    return idx
+
+def widget_status(stdscr, idx):
+    def real_stdsrc(*args):
+        if platform.system() == 'Windows':
+            print(args[2])
+        else:
+            stdscr.addstr(*args)
+    real_stdsrc(idx, 0, scr_str("Widget List".ljust(ll*3-2)))
+    idx+=1
+    widget_map = store.widgetMap()
+    if len(widget_map) == 0:
+        real_stdsrc(idx, 0, scr_str("empty".ljust(ll*3-2)))
+        idx+=1
+        return idx
+    maxJust = 10
+    for it in widget_map:
+        if len(it) > maxJust:
+            maxJust = len(it)
+    maxJust += 5
+    for it in widget_map:
+        path = ""
+        is_block = False
+        if isinstance(widget_map[it], (dict)):
+            path = widget_map[it]["path"]
+            is_block = widget_map[it]["isBlock"]
+        else:
+            path = map[it]
+        end_args = ""
+        if is_block:
+            end_args = " [X]"
+        real_stdsrc(idx, 0, scr_str(f'{f"{it}{end_args}".ljust(maxJust)} {path}'.ljust(ll*3-2)))
+        idx+=1
+    return idx
+
+def status():
+    from pkg_resources import parse_version, get_distribution
+    ver = get_distribution("ryry-cli").version
+    deviceid = utils.generate_unique_id()
+    import socket
+    machine_name = socket.gethostname()
+    service = ryry_service.ryryService()
+    thread_num = store.get_multithread()
+
+    if platform.system() == 'Windows':
+        service_is_running = service.is_running()
+        print(scr_line("-" * ll*3))
+        print(scr_str(f"ryry".ljust(ll*3-2)))
+        print(scr_str(f"版本: {ver}".ljust(ll*3-4)))
+        print(scr_str(f"设备号: {deviceid}".ljust(ll*3-5)))
+        print(scr_str(f"容器HostName: {machine_name}".ljust(ll*3-4)))
+        print(scr_line("-" * ll*3))
+        if service_is_running:
+            print(scr_str1(f"运行中 ({thread_num} 线程)".ljust(ll*3-2)))
+        else:
+            print(scr_str1("未运行".ljust(ll*3-2)))
+        print(scr_line("-" * ll*3))
+        service_status(None, 0)
+        print(scr_line("-" * ll*3))
+        device_status(None, 0)
+        print(scr_line("-" * ll*3))
+        widget_status(None, 0)
+        print(scr_line("-" * ll*3))
+    else:
+        import curses
+        stdscr = curses.initscr()
+        curses.noecho()
+        curses.cbreak()
+        curses.start_color()
+        curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_BLACK)
+        curses.init_pair(2, curses.COLOR_RED, curses.COLOR_BLACK)
+        stdscr.keypad(True)
+        try:
+            tiktak = 0
+            while True:
+                stdscr.clear()
+                height, width = stdscr.getmaxyx()
+                service_is_running = service.is_running()
+                idx=0
+                stdscr.addstr(idx, 0, scr_line("-" * ll*3))
+                idx+=1
+                stdscr.addstr(idx, 0, scr_str(f"ryry".ljust(ll*3-2)))
+                idx+=1
+                stdscr.addstr(idx, 0, scr_str(f"版本: {ver}".ljust(ll*3-4)))
+                idx+=1
+                stdscr.addstr(idx, 0, scr_str(f"设备号: {deviceid}".ljust(ll*3-5)))
+                idx+=1
+                stdscr.addstr(idx, 0, scr_str(f"容器HostName: {machine_name}".ljust(ll*3-4)))
+                idx+=1
+                stdscr.addstr(idx, 0, scr_line("-" * ll*3))
+                idx+=1
+                if service_is_running:
+                    if tiktak > 3:
+                        tiktak = 0
+                    stdscr.addstr(idx, 0, scr_str1("运行中"+"."*tiktak+f" ({thread_num} 线程)".ljust(ll*3-2)), curses.color_pair(1))
+                    tiktak+=1
+                else:
+                    stdscr.addstr(idx, 0, scr_str1("未运行".ljust(ll*3-2)), curses.color_pair(2))
+                idx+=1
+                stdscr.addstr(idx, 0, scr_line("-" * ll*3))
+                idx+=1
+                idx = service_status(stdscr, idx)
+                stdscr.addstr(idx, 0, scr_line("-" * ll*3))
+                idx+=1
+                idx = device_status(stdscr, idx)
+                stdscr.addstr(idx, 0, scr_line("-" * ll*3))
+                idx+=1
+                idx = widget_status(stdscr, idx)
+                stdscr.addstr(idx, 0, scr_line("-" * ll*3))
+                stdscr.refresh()
+                time.sleep(1)
+        except:
+            pass
+        curses.nocbreak()
+        stdscr.keypad(False)
+        curses.echo()
+        curses.endwin()
+
+def service():
+    if len(sys.argv) <= 2:
+        print('please set command!')
+        return
+
+    command = sys.argv[2]
+    service = ryry_service.ryryService()
+    if command == 'start':
+        if service.is_running():
+            print('Service is already running.')
+        else:
+            print(f'Starting service...[args = {" ".join(sys.argv)}]')
+            threadNum = 1
+            idx = 2
+            while idx < len(sys.argv):
+                if sys.argv[idx] == "-thread":
+                    threadNum = int(sys.argv[idx+1])
+                    if threadNum < 1 or threadNum > 500:
+                        print('multi thread number must be 1~500')
+                        return
+                idx+=1
+            service.start(threadNum)
+    elif command == 'stop':
+        if not service.is_running():
+            print('Service is not running.')
+        else:
+            print('Stopping service...')
+            service.stop()
+    elif command == 'status': 
+        status()
+    else:
+        print("Unknown command:", command)
+
+def widget():
+    if len(sys.argv) <= 2:
+        print('please set command! Usage: ryry widget [init|publish]')
+        return
+
+    command = sys.argv[2]
+    work_path = os.getcwd()
+    if len(sys.argv) > 3:
+        work_path = sys.argv[3]
+    if command == 'init':
+        ryry_widget.createWidget(work_path)
+    elif command == 'publish':
+        ryry_widget.publishWidget(work_path)
+    elif command == 'list':
+        map = store.widgetMap()
+        if len(map) == 0:
+            print("local widget is empty")
+        maxJust = 20
+        for it in map:
+            if len(it) > maxJust:
+                maxJust = len(it)
+        maxJust += 10
+        showStatus = ""
+        if len(sys.argv) > 3:
+            showStatus = sys.argv[3]
+        for it in map:
+            path = ""
+            is_block = False
+            if isinstance(map[it], (dict)):
+                path = map[it]["path"]
+                is_block = map[it]["isBlock"]
+            else:
+                path = map[it]
+            end_args = ""
+            if is_block:
+                end_args = " [X]"
+            ss = f"{it}{end_args}"
+            if showStatus in ["disable", "enable"]:
+                if is_block and showStatus == "disable":
+                    print(f'{ss.ljust(maxJust + 4)} {path}')
+                elif is_block == False and showStatus == "enable":
+                    print(f'{ss.ljust(maxJust + 4)} {path}')
+            else:
+                print(f'{ss.ljust(maxJust + 4)} {path}')
+    elif command == 'add':
+        ryry_widget.addWidgetToEnv(work_path)
+    elif command == 'remove':
+        ryry_widget.remove(work_path)
+    elif command == 'enable':
+        ryry_widget.enable(work_path)
+    elif command == 'disable':
+        ryry_widget.disable(work_path)
+    elif command == 'pending_task':
+        ryry_widget.getTaskCount(work_path)
+    else:
+        print("Unknown command:", command)
+
+def main():
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+    if len(sys.argv) >= 2:
+        module = sys.argv[1]
+        if module == "widget":
+            widget()
+        elif module == "service":
+            service()
+        elif module == "status":
+            status()
+        elif module == "report":
+            utils.reportLog()
+            print(f"report success")
+        else:
+            print(f"Unknown command:{module}")
+            sys.exit(0)
+    else:
+        status()
+
+if __name__ == '__main__':
+    main()

ryry/ryry_server_socket.py

@@ -0,0 +1,180 @@
+import os, time, json
+from urllib.parse import *
+import threading
+from datetime import datetime, timedelta
+import calendar
+from threading import Thread, current_thread, Lock
+import websocket
+import uuid
+import queue
+import subprocess, platform
+
+from ryry import store
+from ryry import ryry_webapi
+from ryry import task 
+from ryry import constant 
+from ryry import utils
+from ryry import taskUtils
+
+thisFileDir = os.path.dirname(os.path.abspath(__file__))
+
+class ryryTaskExecutorThread(Thread):
+    THEADING_LIST = []
+    max_counter = 1
+    cur_counter = 0
+    is_running = False
+    task_queue = None
+    ttt = 0
+    
+    def appendTask(self, data, timeout, callback):
+        self.cur_counter+=1
+        self.task_queue.put([data, timeout, callback])
+        try:
+            taskUUID = data["taskUUID"]
+            taskUtils.taskPrint(taskUUID, f"{current_thread().name} === addQueue task : {taskUUID}")
+        except:
+            pass
+            
+    def idlePower(self):
+        return self.max_counter - self.cur_counter
+    
+    def isWorking(self):
+        return self.cur_counter > 0
+    
+    def __init__(self):
+        threading.Thread.__init__(self)
+        self.name = f"ryryTaskExecutorThread"
+        self.task_queue = queue.Queue()
+        self.max_counter = store.get_multithread()
+        self.is_running = True
+        self.THEADING_LIST = []
+        self.start()
+
+    def taskRunning(self):
+        while self.is_running:
+            try:
+                data, timeout, callback = self.task_queue.get()
+                if data is None: 
+                    break
+                try:
+                    taskUUID = data["taskUUID"]
+                    taskUtils.taskPrint(taskUUID, f"{current_thread().name} === receive task : {taskUUID}")
+                    _appendTask(taskUUID)
+                    is_ok, msg, result = task.runTask(data, timeout)
+                    if is_ok == False:
+                        taskUtils.notifyTaskFail(taskUUID, msg)
+                    self.cur_counter-=1
+                    callback(taskUUID, is_ok, msg, result)
+                    _removeTask(taskUUID)
+                except Exception as e:
+                    taskUtils.taskPrint(taskUUID, f"{current_thread().name} === task exception : {e}")
+                    taskUtils.notifyScriptError(taskUUID)
+                finally:
+                    taskUtils.taskPrint(taskUUID, None)
+                self.task_queue.task_done()
+            except Exception as ex:
+                taskUtils.taskPrint(None, f"{current_thread().name} === exception : {ex}")
+                pass
+        print(f"   {current_thread().name} taskRunning stop")
+
+    def run(self):
+        idx = 1
+        for _ in range(0, self.max_counter):
+            self.THEADING_LIST.append(Thread(name=f"exector-{idx}",target=self.taskRunning))
+            idx+=1
+        for t in self.THEADING_LIST:
+            t.start()
+        while self.is_running:
+            time.sleep(5)
+        for t in self.THEADING_LIST:
+            t.join()
+        print(f"   {self.name} stop!")
+
+    def markStop(self):
+        self.is_running = False
+        print(f"   {self.name} waiting stop")
+        for _ in range(self.max_counter*2):
+            self.task_queue.put([None, -1, None])
+        print(f"   {self.name} stop")
+
+lock = Lock()
+task_config_file = os.path.join(thisFileDir, f"task_config.txt")
+def _readTaskConfig():
+    if os.path.exists(task_config_file) == False:
+        with open(task_config_file, 'w') as f:
+            json.dump({
+                "last_task_pts": 0
+            }, f)
+    with open(task_config_file, 'r') as f:
+        data = json.load(f)
+    return data
+def _saveTaskConfig(data):
+    with open(task_config_file, 'w') as f:
+        json.dump(data, f)
+def _appendTask(taskUUID):
+    lock.acquire()
+    task_config = _readTaskConfig()
+    task_config[taskUUID] = {
+        "pts": calendar.timegm(time.gmtime())
+    }
+    task_config["last_task_pts"] = task_config[taskUUID]["pts"]
+    _saveTaskConfig(task_config)
+    lock.release() 
+def _clearTask():
+    lock.acquire()
+    task_config = {
+        "last_task_pts": 0
+    }
+    _saveTaskConfig(task_config)
+    lock.release() 
+def _removeTask(taskUUID):
+    lock.acquire()
+    task_config = _readTaskConfig()
+    if taskUUID in task_config:
+        del task_config[taskUUID]
+    _saveTaskConfig(task_config)
+    lock.release() 
+def _taskCreateTime(taskUUID):
+    pts = 0
+    lock.acquire()
+    task_config = _readTaskConfig()
+    if taskUUID in task_config:
+        pts = task_config[taskUUID]["pts"]
+    lock.release()
+    return pts 
+def _getTaskConfig():
+    lock.acquire()
+    task_config = _readTaskConfig()
+    lock.release() 
+    return task_config
+
+class ryryShortConnectThread(Thread):
+    is_running = False
+    executor: ryryTaskExecutorThread = None
+
+    def __init__(self, executor):
+        super().__init__()
+        self.name = f"ryryShortConnectThread"
+        self.is_running = True
+        self.executor = executor
+        self.start()
+    
+    def taskCallback(self, taskUUID, is_ok, msg, result):
+        ryry_webapi.TaskNotify(taskUUID, is_ok, msg, result)
+
+    def run(self):
+        print(f"   {self.name} start")
+        what_time = 10
+        while (self.is_running):
+            try:
+                datas, timeout = ryry_webapi.GetTask()
+                for it in datas:
+                    self.executor.appendTask(it, timeout, self.taskCallback)
+            except Exception as ex:
+                taskUtils.taskPrint(None, f"{self.name} === exception : {ex}")
+            time.sleep(what_time)
+        print(f"   {self.name} stop")
+
+    def markStop(self):
+        print(f"   {self.name} waiting stop")
+        self.is_running = False