import json import os.path import threading import time import psutil import traceback from datetime import datetime from typing import List, Dict, Optional, Tuple, MutableMapping, Union import simple_websocket from mod.base import json_response, list_args from mod.project.node.nodeutil import ServerNode, LocalNode, LPanelNode, SSHApi from mod.project.node.dbutil import Script, CommandLog, TaskFlowsDB, CommandTask, ServerNodeDB, TransferTask, \ ServerMonitorRepo, Flow, FlowTemplates from mod.project.node.task_flow import self_file_running_log, flow_running_log, flow_useful_version, file_task_run_sync, \ command_task_run_sync import public class main: next_flow_tip_name = "user_next_flow_tip" @staticmethod def create_script(get): e_db = TaskFlowsDB() err = Script.check(get) if err: return public.return_message(-1, 0,=err) s = Script.from_dict(get) # 查重 if e_db.Script.find("name = ?", (s.name,)): return public.return_message(-1, 0,"Script name already exists") err = e_db.Script.create(s) if isinstance(err, str): return public.return_message(-1, 0,err) # return json_response(status=True, msg="Created successfully", data=s.to_dict()) return public.return_message(0, 0,s.to_dict()) @staticmethod def modify_script(get): e_db = TaskFlowsDB() err = Script.check(get) if err: return public.return_message(-1, 0,err) s = Script.from_dict(get) if not s.id: return public.return_message(-1, 0,"Script ID cannot be empty") if not e_db.Script.find("id = ?", (s.id,)): return public.return_message(-1, 0,"Script does not exist") err = e_db.Script.update(s) if err: return public.return_message(-1, 0,err) # return json_response(status=True, msg="Modified successfully", data=s.to_dict()) return public.return_message(0, 0,s.to_dict()) @staticmethod def delete_script(get): e_db = TaskFlowsDB() if not get.id: return public.return_message(-1, 0,"Script ID cannot be empty") try: del_id = int(get.id) except: return public.return_message(-1, 0,"Script ID format error") e_db.Script.delete(del_id) return public.return_message(0, 0,"Deleted successfully") @staticmethod def get_script_list(get): page_num = max(int(get.get('p/d', 1)), 1) limit = max(int(get.get('limit/d', 16)), 1) search = get.get('search', "").strip() script_type = get.get('script_type/s', "all") if not script_type in ["all", "python", "shell"]: script_type = "all" where_list, params = [], [] if search: where_list.append("(name like ? or content like ? or description like ?)") params.append("%{}%".format(search)) params.append("%{}%".format(search)) params.append("%{}%".format(search)) if script_type != "all": where_list.append("script_type = ?") params.append(script_type) where = " and ".join(where_list) e_db = TaskFlowsDB() data_list = e_db.Script.query_page(where, (*params,), page_num=page_num, limit=limit) count = e_db.Script.count(where, params) page = public.get_page(count, page_num, limit) page["data"] = [i.to_dict() for i in data_list] return page @staticmethod def bath_delete_script(get): script_ids = list_args(get, 'script_ids') try: script_ids = [int(i) for i in script_ids] except: return public.return_message(-1, 0,"Script ID format error") if not script_ids: return public.return_message(-1, 0,"Script ID cannot be empty") e_db = TaskFlowsDB() err = e_db.Script.delete(script_ids) if err: return public.return_message(-1, 0,err) return public.return_message(0, 0,"Deleted successfully") @staticmethod def create_task(get): node_ids = list_args(get, 'node_ids') if not node_ids: return public.return_message(-1, 0,"Node ID cannot be empty") try: node_ids = [int(i) for i in node_ids] except: return public.return_message(-1, 0,"Node ID format error") e_db = TaskFlowsDB() script_id = get.get('script_id/d', 0) if script_id: s = e_db.Script.find("id = ?", (script_id,)) if not s: return public.return_message(-1, 0,"Script does not exist") elif get.get("script_content/s", "").strip(): if not (get.get("script_type", "").strip() in ("python", "shell")): return public.return_message(-1, 0,"Script type error") s = Script("", get.get("script_type", "").strip(), content=get.get("script_content", "").strip()) s.id = 0 else: return public.return_message(-1, 0,"Please select a script") nodes_db = ServerNodeDB() nodes = [] timestamp = int(datetime.now().timestamp()) for i in node_ids: n = nodes_db.get_node_by_id(i) if not n: return public.return_message(-1, 0,"The node with node ID [{}] does not exist".format(i)) n["ssh_conf"] = json.loads(n["ssh_conf"]) if not n["ssh_conf"]: return public.return_message(-1, 0,"The node with node ID [{}] has not configured SSH information and cannot distribute instructions".format(i)) n["log_name"] = "{}_{}_{}.log".format(public.md5(s.content)[::2], timestamp, n['remarks']) nodes.append(n) e_task = CommandTask( script_id=s.id, script_content=s.content, script_type=s.script_type, flow_id=0, step_index=0, ) command_task_id = e_db.CommandTask.create(e_task) e_task.id = command_task_id if not isinstance(command_task_id, int) or command_task_id <= 0: return public.return_message(-1, 0,"Task creation failed:" + command_task_id) log_list = [] for i in nodes: elog = CommandLog( command_task_id=command_task_id, server_id=i["id"], ssh_host=i["ssh_conf"]["host"], status=0, log_name=i["log_name"], ) elog.create_log() log_list.append(elog) last_id = e_db.CommandLog.create(log_list) if not isinstance(last_id, int) or last_id <= 0: for i in log_list: i.remove_log() return public.return_message(-1, 0,"Failed to create log:" + last_id) script_py = "{}/script/node_command_executor.py command".format(public.get_panel_path()) res = public.ExecShell("nohup {} {} {} > /dev/null 2>&1 &".format( public.get_python_bin(), script_py, command_task_id) ) data_dict = e_task.to_dict() data_dict["log_list"] = [i.to_dict() for i in log_list] data_dict["task_id"] = command_task_id # return json_response(status=True, msg="Created successfully", data=data_dict) return public.return_message(0, 0, data_dict) @staticmethod def get_server_info(server_id: int, server_cache) -> dict: server_info = server_cache.get(server_id) if not server_info: server = ServerNodeDB().get_node_by_id(server_id) if not server: server_cache[server_id] = {} else: server_cache[server_id] = server return server_cache[server_id] else: return server_info @classmethod def get_task_list(cls, get): page_num = max(int(get.get('p/d', 1)), 1) limit = max(int(get.get('limit/d', 16)), 1) script_type = get.get('script_type/s', "all") if not script_type in ["all", "python", "shell"]: script_type = "all" search = get.get('search', "").strip() e_db = TaskFlowsDB() count, tasks = e_db.CommandTask.query_tasks( page=page_num, size=limit, script_type=script_type, search=search ) res = [] server_cache: Dict[int, Dict] = {} for i in tasks: task_dict = i.to_dict() log_list = e_db.CommandLog.query("command_task_id = ?", (i.id,)) task_dict["log_list"] = [] if i.script_id > 0: s = e_db.Script.find("id = ?", (i.script_id,)) if s: task_dict["script_name"] = s.name else: task_dict["script_name"] = "-" for j in log_list: tmp = j.to_dict() tmp["server_name"] = cls.get_server_info(j.server_id, server_cache).get("remarks") task_dict["log_list"].append(tmp) res.append(task_dict) page = public.get_page(count, page_num, limit) page["data"] = res return public.return_message(0, 0,page) @classmethod def get_task_info(cls, get): task_id = get.get('task_id/d', 0) if not task_id: return public.return_message(-1, 0,"Task ID cannot be empty") e_db = TaskFlowsDB() task = e_db.CommandTask.find("id = ?", (task_id,)) if not task: return public.return_message(-1, 0,"Task does not exist") task_dict = task.to_dict() task_dict["log_list"] = [] server_cache = {} log_list = e_db.CommandLog.query("command_task_id = ?", (task_id,)) for i in log_list: tmp = i.to_dict() if i.status != 0: tmp["log"] = i.get_log() tmp["server_name"] = cls.get_server_info(i.server_id, server_cache).get("remarks", "") task_dict["log_list"].append(tmp) return public.return_message(0, 0,task_dict) @staticmethod def delete_task(get): e_db = TaskFlowsDB() task_id = get.get('task_id/d', 0) if not task_id: return public.return_message(-1, 0,"Task ID cannot be empty") task = e_db.CommandTask.find("id = ?", (task_id,)) if not task: return public.return_message(-1, 0,"Task does not exist") pid_file = "{}/logs/executor_log/{}.pid".format(public.get_panel_path(), task_id) if os.path.exists(pid_file): pid: str = public.readFile(pid_file) if pid and pid.isdigit(): public.ExecShell("kill -9 {}".format(pid)) os.remove(pid_file) log_list = e_db.CommandLog.query("command_task_id = ?", (task_id,)) for i in log_list: i.remove_log() e_db.CommandLog.delete(i.id) e_db.CommandTask.delete(task_id) return public.return_message(0, 0,"Deleted successfully") @staticmethod def batch_delete_task(get): task_ids: List[int] = list_args(get, "task_ids") if not task_ids: return public.return_message(-1, 0,"Please select the task to delete") task_ids = [int(i) for i in task_ids] e_db = TaskFlowsDB() task_list = e_db.CommandTask.query("id IN ({})".format(",".join(["?"] * len(task_ids))), (*task_ids,)) if not task_list: return public.return_message(-1, 0,"Task does not exist") for i in task_list: pid_file = "{}/logs/executor_log/{}.pid".format(public.get_panel_path(), i.id) if os.path.exists(pid_file): pid: str = public.readFile(pid_file) if pid and pid.isdigit(): public.ExecShell("kill -9 {}".format(pid)) os.remove(pid_file) log_list = e_db.CommandLog.query("command_task_id = ?", (i.id,)) for j in log_list: j.remove_log() e_db.CommandLog.delete(j.id) e_db.CommandTask.delete(i.id) return public.return_message(0, 0,"Deleted successfully") @staticmethod def retry_task(get): task_id = get.get('task_id/d', 0) if not task_id: return public.return_message(-1, 0,"Task ID cannot be empty") log_id = get.get('log_id/d', 0) if not log_id: return public.return_message(-1, 0,"The log ID cannot be empty") e_db = TaskFlowsDB() log = e_db.CommandLog.find("id = ? AND command_task_id = ?", (log_id, task_id)) if not log: return public.return_message(-1, 0,"log does not exist") log.create_log() log.status = 0 e_db.CommandLog.update(log) script_py = "{}/script/node_command_executor.py command".format(public.get_panel_path()) public.ExecShell("nohup {} {} {} {} > /dev/null 2>&1 &".format( public.get_python_bin(), script_py, task_id, log_id) ) return public.return_message(0, 0,"Retry started") @staticmethod def node_create_transfer_task(get): try: transfer_task_data = json.loads(get.get('transfer_task_data', "{}")) if not transfer_task_data: return public.return_message(-1, 0,"Parameter error") except Exception as e: return public.return_message(-1, 0,"Parameter error") transfer_task_data["flow_id"] = 0 transfer_task_data["step_index"] = 0 transfer_task_data["src_node"] = {"name": "local"} transfer_task_data["src_node_task_id"] = 0 if not isinstance(transfer_task_data["dst_nodes"], dict): return public.return_message(-1, 0,"Please upgrade the version of the main node panel you are currently using") fdb = TaskFlowsDB() tt = TransferTask.from_dict(transfer_task_data) task_id = fdb.TransferTask.create(tt) if not task_id: return public.return_message(-1, 0,"Task creation failed") # return json_response(status=True, msg="Created successfully", data={"task_id": task_id}) return public.return_message(0, 0, {"task_id": task_id}) @classmethod def node_transferfile_status_history(cls, get): task_id = get.get('task_id/d', 0) only_error = get.get('only_error/d', 1) if not task_id: return public.return_message(-1, 0,"Task ID cannot be empty") fdb = TaskFlowsDB() ret = fdb.history_transferfile_task(task_id, only_error=only_error==1) fdb.close() # return json_response(status=True, msg="Successfully obtained", data=ret) return public.return_message(0, 0, ret) @classmethod def node_proxy_transferfile_status(cls, get): ws: simple_websocket.Server = getattr(get, '_ws', None) if not ws: return public.return_message(-1, 0, "Please use WebSocket connection") task_id = get.get('task_id/d', 0) exclude_nodes = list_args(get, "exclude_nodes") the_log_id = get.get('the_log_id/d', 0) if not task_id: ws.send(json.dumps({"type": "end", "msg": "Task ID cannot be empty"})) ws.send("{}") return try: exclude_nodes = [int(i) for i in exclude_nodes] except: exclude_nodes = [] fdb = TaskFlowsDB() task = fdb.TransferTask.get_byid(task_id) if not task: ws.send(json.dumps({"type": "end", "msg": "Task does not exist"})) ws.send("{}") return if the_log_id: # 单任务重试 res_data = file_task_run_sync(task_id, the_log_id) if isinstance(res_data, str): ws.send(json.dumps({"type": "error", "msg": res_data})) ws.send("{}") else: ws.send(json.dumps({"type": "end", "data": res_data})) ws.send("{}") fdb.close() return if task.status in (0, 3): # 初次执行 或 出错后再次尝试 pid = cls._start_task("file", task_id, exclude_nodes=exclude_nodes) elif task.status == 2: # 运行成功了， 获取历史数据并返回 ret = fdb.history_transferfile_task(task_id) ws.send(json.dumps({"type": "end", "data": ret})) ws.send("{}") fdb.close() return else: # 还在运行中 pid_file = "{}/logs/executor_log/file_{}_0.pid".format(public.get_panel_path(), task_id) if os.path.exists(pid_file): pid = int(public.readFile(pid_file)) else: pid = None if not pid: # 运行失败， 返回数据库信息 ret = fdb.history_transferfile_task(task_id) ws.send(json.dumps({"type": "end", "data": ret})) fdb.close() ws.send("{}") return def send_status(soc_data: dict): ws.send(json.dumps({"type": "status", "data": soc_data})) err = self_file_running_log(task_id, send_status) if err: ws.send(json.dumps({"type": "error", "msg": err})) ret = fdb.history_transferfile_task(task_id) ws.send(json.dumps({"type": "end", "data": ret})) fdb.close() ws.send("{}") # 告诉接收端，数据传输已经结束 return def run_flow_task(self, get): ws: simple_websocket.Server = getattr(get, '_ws', None) if not ws: return public.return_message(-1, 0,"Please use WebSocket connection") public.set_module_logs("nodes_flow_task", "run_flow_task") node_ids = list_args(get, 'node_ids') if not node_ids: ws.send(json.dumps({"type": "error", "msg": "Node ID cannot be empty"})) return try: node_ids = [int(i) for i in node_ids] except: ws.send(json.dumps({"type": "error", "msg": "Node ID format error"})) return try: flow_data = get.get('flow_data', '[]') if isinstance(flow_data, str): flow_data = json.loads(flow_data) elif isinstance(flow_data, (list, tuple)): pass else: raise except: ws.send(json.dumps({"type": "error", "msg": "Process data format error"})) return strategy = {"run_when_error": True} if "exclude_when_error" in get and get.exclude_when_error not in ("1", "true", 1, True): strategy["exclude_when_error"] = False has_cmd_task = False data_src_node = [] for i in flow_data: if i["task_type"] == "command": has_cmd_task = True elif i["task_type"] == "file": data_src_node.append(i["src_node_id"]) nodes_db = ServerNodeDB() used_nodes, target_nodes = [], [] srv_cache = ServerMonitorRepo() for i in set(node_ids + data_src_node): n = nodes_db.get_node_by_id(i) if not n: ws.send(json.dumps({"type": "error", "msg": "The node with node ID [{}] does not exist".format(i)})) return n["ssh_conf"] = json.loads(n["ssh_conf"]) if has_cmd_task and n["id"] in node_ids and not n["ssh_conf"]: ws.send(json.dumps({"type": "error", "msg": "The node of node [{}] has not enabled SSH".format(n["remarks"])})) return if n["id"] in data_src_node: is_local = n["app_key"] == n["api_key"] == "local" if (not n["app_key"] and not n["api_key"]) or n["lpver"]: # 1panel面板或者 仅有ssh配置的节点无法作为数据源 ws.send(json.dumps( {"type": "error", "msg": "Node [{}] is not a pagoda node and cannot be used as a data source".format(n["remarks"])})) return if not is_local: # 检查节点版本号 tmp = srv_cache.get_server_status(n["id"]) if not tmp or not flow_useful_version(tmp["version"]): ws.send( json.dumps({"type": "error", "msg": "Node [{}] version is too low, please upgrade the node".format(n["remarks"])})) return used_nodes.append(n) if n["id"] in node_ids: target_nodes.append(n) fdb = TaskFlowsDB() flow, err = fdb.create_flow(used_nodes, target_nodes, strategy, flow_data) if not flow: ws.send(json.dumps({"type": "error", "msg": err})) return fdb.close() pid = self._start_task("flow", flow.id) if not pid: ws.send(json.dumps({"type": "error", "msg": "Task startup failed"})) return def update_status(data: dict): ws.send(json.dumps({"type": "status", "data": data})) err = flow_running_log(flow.id, update_status) if err: ws.send(json.dumps({"type": "error", "msg": err})) # flow_data = fdb.history_flow_task(flow.id) # ws.send(json.dumps({"type": "data", "data": flow_data})) ws.send(json.dumps({"type": "end", "msg": "Mission complete"})) return @classmethod def _start_task(cls, task_type: str, task_id: int, exclude_nodes: List[int]=None) -> Optional[int]: pid_file = "{}/logs/executor_log/{}_{}_0.pid".format(public.get_panel_path(), task_type, task_id) if os.path.exists(pid_file): pid = int(public.readFile(pid_file)) if psutil.pid_exists(pid): return pid script_py = "{}/script/node_command_executor.py".format(public.get_panel_path()) cmd = [ public.get_python_bin(), script_py, "--task_type={}".format(task_type), "--task_id={}".format(task_id), ] exclude_nodes = exclude_nodes or [] if exclude_nodes: exclude_nodes = [str(i) for i in exclude_nodes if i] exclude_nodes_str = "'{}'".format(",".join(exclude_nodes)) cmd.append("--exclude_nodes={}".format(exclude_nodes_str)) cmd_str = "nohup {} > /dev/null 2>&1 &".format(" ".join(cmd)) public.ExecShell(cmd_str) for i in range(60): if os.path.exists(pid_file): pid = int(public.readFile(pid_file)) if psutil.pid_exists(pid): return pid time.sleep(0.05) return None @classmethod def flow_task_status(cls, get): ws: simple_websocket.Server = getattr(get, '_ws', None) if not ws: return public.return_message(-1, 0, "Please use WebSocket connection") fdb = TaskFlowsDB() flow = fdb.Flow.last(order_by="id DESC") if flow and flow.status == "running": flow_data = fdb.history_flow_task(flow) ws.send(json.dumps({"type": "status", "data": flow_data})) for t in flow.steps: t: Union[CommandTask, TransferTask] src_node = getattr(t, "src_node", {}) is_local_src = src_node.get("address", None) is None if not src_node: task_data = fdb.history_command_task(t.id) elif is_local_src: task_data = fdb.history_transferfile_task(t.id) else: srv = ServerNode(src_node["address"], src_node["api_key"], src_node["app_key"], src_node["remarks"]) srv_data = srv.node_transferfile_status_history(t.src_node_task_id) if srv_data["status"]: task_data = srv_data["data"] else: task_data = { "task_id": t.id, "task_type": "file", "count": 0, "complete": 0, "error": 0, "data": [] } ws.send(json.dumps({"type": "status", "data": task_data})) err = flow_running_log(flow.id, lambda x: ws.send(json.dumps({"type": "status", "data": x}))) if err: ws.send(json.dumps({"type": "error", "msg": err})) ws.send(json.dumps({"type": "end", "msg": "Mission complete"})) return else: if not flow: ws.send(json.dumps({"type": "no_flow", "msg": "No tasks"})) # 没有任务 return flow_data = fdb.history_flow_task(flow.id) ws.send(json.dumps({"type": "end", "last_flow": flow_data})) return @classmethod def next_flow_tip(cls, get): return public.return_message(0, 0,"Setup successful") @staticmethod def get_flow_info(get): flow_id = get.get("flow_id/d", 0) fdb = TaskFlowsDB() flow = fdb.Flow.get_byid(flow_id) if not flow: return public.return_message(-1, 0,"Task does not exist") flow_data = fdb.history_flow_task(flow.id) return public.return_message(0, 0,flow_data) @staticmethod def get_command_task_info(get): task_id = get.get("task_id/d", 0) fdb = TaskFlowsDB() task = fdb.CommandTask.get_byid(task_id) if not task: return public.return_message(-1, 0,"Task does not exist") return public.return_message(0, 0,fdb.history_command_task(task.id, only_error=False)) @staticmethod def get_transferfile_task_info(get): task_id = get.get("task_id/d", 0) fdb = TaskFlowsDB() task = fdb.TransferTask.get_byid(task_id) if not task: return public.return_message(-1, 0,"Task does not exist") src_node = task.src_node is_local_src = task.src_node.get("address", None) is None if is_local_src: return public.return_message(0, 0,fdb.history_transferfile_task(task.id, only_error=False)) else: srv = ServerNode(src_node["address"], src_node["api_key"], src_node["app_key"], src_node["name"]) srv_data = srv.node_transferfile_status_history(task.src_node_task_id, only_error=False) if srv_data["status"]: task_data = srv_data["data"] else: task_data = { "task_id": task.id, "task_type": "file", "count": 0, "complete": 0, "error": 0, "data": [] } return public.return_message(0, 0,task_data) def flow_task_list(self, get): page_num = max(int(get.get('p/d', 1)), 1) limit = max(int(get.get('limit/d', 16)), 1) fdb = TaskFlowsDB() flow_list = fdb.Flow.query_page(page_num=page_num, limit=limit) count = fdb.Flow.count() res = [] server_cache: Dict[int, Dict] = {} for flow in flow_list: tmp_data = fdb.history_flow_task(flow.id) tmp_data["server_list"] = [{ "id": int(i), "name": self.get_server_info(int(i), server_cache).get("remarks", ""), "server_ip": self.get_server_info(int(i), server_cache).get("server_ip", ""), } for i in tmp_data["server_ids"].strip("|").split("|")] res.append(tmp_data) page = public.get_page(count, page_num, limit) page["data"] = res return public.return_message(0, 0,page) @staticmethod def remove_flow(get): flow_ids = list_args(get,"flow_ids") if not flow_ids: return public.return_message(-1, 0,"Please select the task to delete") fdb = TaskFlowsDB() flows = fdb.Flow.query( "id IN (%s) AND status NOT IN (?, ?)" % (",".join(["?"]*len(flow_ids))), (*flow_ids, "waiting", "running") ) command_tasks = fdb.CommandTask.query( "flow_id IN (%s)" % (",".join(["?"]*len(flow_ids))), (*flow_ids,) ) command_logs = fdb.CommandLog.query( "command_task_id IN (%s)" % (",".join(["?"]*len(flow_ids))), (*flow_ids,) ) for log in command_logs: try: if os.path.exists(log.log_file): os.remove(log.log_file) except: pass fdb.CommandLog.delete([log.id for log in command_logs]) fdb.CommandTask.delete([task.id for task in command_tasks]) fdb.Flow.delete([flow.id for flow in flows]) w, p = "flow_id IN (%s)" % (",".join(["?"]*len(flow_ids))), (*flow_ids,) fdb.TransferTask.delete_where(w, p) fdb.TransferLog.delete_where(w, p) fdb.TransferFile.delete_where(w, p) return public.return_message(0, 0,"Deleted successfully") def retry_flow(self, get): ws: simple_websocket.Server = getattr(get, '_ws', None) if not ws: return public.return_message(-1, 0,"Please use WebSocket connection") flow_id = get.get("flow_id/d", 0) flow = TaskFlowsDB().Flow.get_byid(flow_id) if not flow: ws.send(json.dumps({"type": "error", "msg": "Task does not exist"})) return if flow.status == "complete": ws.send(json.dumps({"type": "error", "msg": "Task completed, cannot retry"})) return def call_status(data): ws.send(json.dumps({"type": "status", "data": data})) pid = self._start_task("flow", flow.id) if not pid: ws.send(json.dumps({"type": "error", "msg": "Task startup failed"})) return err = flow_running_log(flow.id, call_status) if err: ws.send(json.dumps({"type": "error", "msg": err})) ws.send(json.dumps({"type": "end", "msg": "Mission complete"})) return # 重试某个单一任务, 如：单机器文件上传或单机器命令执行 @staticmethod def retry_flow_task(get): task_type = get.get("task_type/s", "") task_id = get.get("task_id/d", 0) log_id = get.get("log_id/d", 0) if not task_type or not task_id or not log_id: return public.return_message(-1, 0,"Parameter error") if task_type not in ("file", "command"): return public.return_message(-1, 0,"Parameter error") if task_type == "file": ret = file_task_run_sync(task_id, log_id) else: ret = command_task_run_sync(task_id, log_id) if isinstance(ret, str): return public.return_message(-1, 0,ret) # return json_response(status=True, msg="Task has been retried", data=ret) return public.return_message(0, 0, ret) @staticmethod def stop_flow(get): flow_id = get.get("flow_id/d", 0) if not flow_id: return public.return_message(-1, 0,"Please select the task to stop") pid_file = "{}/logs/executor_log/flow_{}_0.pid".format(public.get_panel_path(), flow_id) if os.path.exists(pid_file): pid = int(public.readFile(pid_file)) if psutil.pid_exists(pid): psutil.Process(pid).kill() if os.path.exists(pid_file): os.remove(pid_file) sock_file = "/tmp/flow_task/flow_task_{}".format(flow_id) if os.path.exists(sock_file): os.remove(sock_file) return public.return_message(0, 0,"Task stopped") @staticmethod def file_dstpath_check(get): path = get.get("path/s", "") node_ids = list_args(get, "node_ids") if not path or not node_ids: return public.return_message(-1, 0,"Parameter error") if path == "/": return public.return_message(-1, 0,"Cannot upload to root directory") nodes_db = ServerNodeDB() ret = [] def check_node(n_data:dict, t_srv: Union[ServerNode, LPanelNode, SSHApi]): res = {"id": n_data["id"], "err": "", "remarks": n_data["remarks"]} err = t_srv.upload_dir_check(path) if err: res["err"] = err ret.append(res) th_list = [] for i in node_ids: n = nodes_db.get_node_by_id(i) if not n: ret.append({"id": i, "err": "Node does not exist"}) n["ssh_conf"] = json.loads(n["ssh_conf"]) if n["app_key"] or n["api_key"]: srv = ServerNode.new_by_data(n) elif n["ssh_conf"]: srv = SSHApi(**n["ssh_conf"]) else: ret.append({"id": i, "err": "Node configuration error"}) continue th = threading.Thread(target=check_node, args=(n, srv)) th.start() th_list.append(th) for th in th_list: th.join() # return json_response(status=True, data=ret) return public.return_message(0, 0,ret) @staticmethod def create_flow_template(get): err = FlowTemplates.check(get) if err: return public.return_message(-1, 0,err) s = FlowTemplates.from_dict(get) # 查重 e_db = TaskFlowsDB() if e_db.FlowTemplate.find("name = ?", (s.name,)): return public.return_message(-1, 0,"Script name already exists") err = e_db.FlowTemplate.create(s) if isinstance(err, str): return public.return_message(-1, 0,err) e_db.close() # return json_response(status=True, msg="Created successfully", data=s.to_dict()) return public.return_message(0, 0,s.to_dict()) @staticmethod def modify_flow_template(get): err = FlowTemplates.check(get) if err: return public.return_message(-1, 0,err) e_db = TaskFlowsDB() ft = FlowTemplates.from_dict(get) if not ft.id: return public.return_message(-1, 0,"Please select the template to modify") if not e_db.FlowTemplate.get_byid(ft.id): return public.return_message(-1, 0,"Template does not exist") err = e_db.FlowTemplate.update(ft) if isinstance(err, str) and err: return public.return_message(-1, 0,err) e_db.close() # return json_response(status=True, msg="Modified successfully", data=ft.to_dict()) return public.return_message(0, 0,ft.to_dict()) @staticmethod def delete_flow_template(get): e_db = TaskFlowsDB() if not get.get("id/d", 0): return public.return_message(-1, 0,"Script ID cannot be empty") try: del_id = int(get.id) except: return public.return_message(-1, 0,"Script ID format error") e_db.FlowTemplate.delete(del_id) return public.return_message(0, 0,"Deleted successfully") @staticmethod def get_flow_template_list(get): page_num = max(int(get.get('p/d', 1)), 1) limit = max(int(get.get('limit/d', 16)), 1) search = get.get('search', "").strip() where_list, params = [], [] if search: where_list.append("(name like ? or key_words like ? or description like ?)") params.append("%{}%".format(search)) params.append("%{}%".format(search)) params.append("%{}%".format(search)) where = " and ".join(where_list) e_db = TaskFlowsDB() data_list = e_db.FlowTemplate.query_page(where, (*params,), page_num=page_num, limit=limit) count = e_db.FlowTemplate.count(where, params) page = public.get_page(count, page_num, limit) page["data"] = [i.to_dict() for i in data_list] return public.return_message(0, 0,page)