def get_process_template_role(): try: request_data = common_service.check_request_dat_not_null( ["process_template_id"]) env = request_data["env"] process_template_id = request_data["process_template_id"] # 获取该模板对应的值 process_template_level_top = json.loads(get()) process_template_level_second = process_template_level_top[0] process_template_level_data = process_template_level_second[ "process_template"] if not process_template_level_data.__contains__(env): raise common_service.MyServiceException("该流程模板环境(%s)不存在" % env) process_template_level_env = process_template_level_data[env] if not process_template_level_env.__contains__(process_template_id): raise common_service.MyServiceException("该流程模板id(%s)不存在" % process_template_id) process_template = process_template_level_env[process_template_id] process_template = process_template.strip() if not process_template or process_template.strip() == "": raise common_service.MyServiceException("该流程模板值为空") return process_template except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def finish_process(): try: request_data = common_service.check_request_dat_not_null(["process_instance_id"]) process_instance_id = request_data["process_instance_id"] try: # 查询对应流程id的执行内容 db_res_data = json.loads( dumps(project_manage__work_order_process__run_manage_process__schedule_work_order_co.find_one( filter={'process_id': process_instance_id}))) env = db_res_data["env"] host = db_res_data["host"] modify_schedule_line = db_res_data["modify_schedule_line"] do_process(host, modify_schedule_line, process_instance_id) run_manage.upgrade_process_service_invoke_status(process_instance_id, True) return {} except Exception as e: project_manage__work_order_process__run_manage_result_log_co.insert_one({ "process_id": process_instance_id, "log": "异常:" + str(e), "is_exe_success": True, }) run_manage.upgrade_process_service_invoke_status(process_instance_id, False) raise e except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def insert(): """ 插入 """ try: request_data = common_service.check_request_dat_not_null( ["pid", "slice_len"]) pid = request_data["pid"] slice_len = request_data["slice_len"] slice_len = str(int(slice_len) + 1) print("插入数据: ", "pid=", pid, "slice_len=", slice_len) if "root" == pid: pid = "" _id = str(slice_len) else: _id = str(pid) + "_" + slice_len general_asset_manage_system__metadata_co.insert_one({ "pid": str(pid), "id": str(_id), "name": "", "env": "dev", "env_name": "开发环境" }) return {"id": _id} except MyServiceException as e: print(e) return ResResult.return500(str(e))
def get_crontab_file_content_list(): try: request_data = common_service.check_request_dat_not_null(["env", "host"]) env = request_data["env"] host = request_data["host"] host = host.replace(".", "_") # 判断来访数据合理性 schedule_server_config_datas = json.loads(schedule_server_config.get()) schedule_server_config_data = schedule_server_config_datas[0] schedule_server_config_data_data = schedule_server_config_data["schedule_server_config"] level_env = schedule_server_config_data_data[env] level_host = level_env[host] if not level_host: raise common_service.MyServiceException("非法入侵, 该服务器不存在调度服务器配置数据中") # 获取服务器连接信息 server_manage_datas = json.loads(server_manage.get_decrypt()) server_manage_data = server_manage_datas[0] server_manage_data_data = server_manage_data["server_manage"] server_manage_level_host = server_manage_data_data[host] conn_host = host.replace("_", ".") for key in server_manage_level_host: username = key password = server_manage_level_host[username] my_server = MyServer(conn_host, username, password) filepath = "/etc/crontab" file_content = my_server.get_file_content(filepath) result = {} for index, item in enumerate(file_content): result[index] = item return result break except common_service.MyServiceException as e: return common_service.ResResult.return500(str(e))
def rollback_sql_invoke(): try: is_exe_success = True log = "开始回滚:" try: request_data = common_service.check_request_dat_not_null( ["process_instance_id"]) if request_data.__contains__("is_rollback"): if request_data["is_rollback"]: return process_instance_id = request_data["process_instance_id"] # 查询对应流程id的执行内容 db_res_data = json.loads( dumps( project_manage__work_order_process__run_manage_process_sql_content_rb_co .find_one(filter={'process_id': process_instance_id}))) inception_rollback_data = db_res_data["inception_rollback_data"] action_type = db_res_data["action_type"] for inception_rollback_data_item in inception_rollback_data: username = inception_rollback_data_item["username"] password = inception_rollback_data_item["password"] host = inception_rollback_data_item["host"] port = inception_rollback_data_item["port"] database = inception_rollback_data_item["database"] if SQL_INVOKE_STR == action_type: sql = inception_rollback_data_item["sql"] db_execute_result_rollback = my_inception.execute_sql( username, password, host, port, database, sql, is_use_inception=False) log += json.dumps(db_execute_result_rollback) elif DANGER_SQL_STR == action_type: dumper_dir_path = inception_rollback_data_item[ "dumper_dir_path"] loader_log_list = mydumper_loader.do_loader_in_remote( host, port, username, password, dumper_dir_path) for loader_log_item in loader_log_list: log += loader_log_item log += "导入完成" except Exception as e: print(e) log += str(e) is_exe_success = False project_manage__work_order_process__run_manage_result_log_co.insert_one( { "process_id": process_instance_id, "log": log, "is_exe_success": is_exe_success, }) return {} except MyServiceException as e: print(e) return ResResult.return500(str(e))
def get_alarm_config_file(): request_data = common_service.check_request_dat_not_null(["name"]) name = request_data["name"] if not name or name.strip() == "": raise common_service.MyServiceException("name不能为空") return dumps( monitoring__alarm_config_file_co.find(filter={"name": name}, limit=1, sort=[("_id", -1)]))
def do_sql_invoke(): try: request_data = common_service.check_request_dat_not_null([ "title", "env", "host_port", "database", "sql_content", "apply_process", "process_template_id", "action_type" ]) title = request_data["title"] env = request_data["env"] host_port = request_data["host_port"] database = request_data["database"] sql_content = request_data["sql_content"] apply_process = request_data["apply_process"] process_template_id = request_data["process_template_id"] action_type = request_data["action_type"] if "TRUNCATE" in sql_content: raise MyServiceException("禁止执行TRUNCATE语法") if action_type != DANGER_SQL_STR: # 检测是否为危险SQL sql_content_list = split_sql_content(sql_content) for sql_content_item in sql_content_list: for forbid_sql_type_item in forbid_sql_type_list: if sql_content_item.upper().startswith( forbid_sql_type_item): raise MyServiceException("不支持的SQL类型: %s" % forbid_sql_type_item) # 检测SQL是否能够执行 check_sql_executable(env, host_port, database, sql_content) # 流程 finish_result = { "method": "POST", "url": "http://localhost:8080/project_manage/associate_db/sql_work_order/finish_sql_invoke", "rb_url": "http://localhost:8080/project_manage/associate_db/sql_work_order/rollback_sql_invoke", } display_content = "执行环境为: %s \n MySQL实例为: %s \n 数据库为: %s \n 动作类型为: %s \n SQL内容为: \n %s \n\n\n " % ( env, host_port, database, action_type, sql_content) process_id, next_step = run_manage.process_start( apply_process, process_type, finish_result, title, display_content, env, process_template_id) # 存储内容等待流程完成时去执行 sql_content = sql_content.replace("`", "") project_manage__work_order_process__run_manage_process_sql_content_co.insert_one( { "process_id": process_id, "env": env, "host_port": host_port, "database": database, "action_type": action_type, "sql_content": sql_content, }) run_manage.process_after_trigger(process_id, next_step) return {} except MyServiceException as e: return ResResult.return500(str(e))
def delete_access_control_label_manage(): try: request_data = common_service.check_request_dat_not_null(["id"]) data_id = request_data["id"] access_control_label_manage_co.delete_one( filter={'_id': ObjectId(data_id)}) return {} except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def list_log(): try: request_data = common_service.check_request_dat_not_null( ["process_instance_id"]) my_filter = {"process_id": request_data["process_instance_id"]} return dumps( project_manage__work_order_process__run_manage_result_log_co.find( filter=my_filter)) except MyServiceException as e: return ResResult.return500(str(e))
def add_access_control_label_manage(): try: request_data = common_service.check_request_dat_not_null( ["name", "code"]) name = request_data["name"] code = request_data["code"] access_control_label_manage_co.insert_one({"name": name, "code": code}) return {} except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def opt_data(): """ 操作数据 """ try: request_data = common_service.check_request_dat_not_null(["opt_name", "asset_type"]) asset_type = request_data["asset_type"] opt_name = request_data["opt_name"] del request_data["opt_name"] if "insert" == opt_name: # 存在性检测 old_data = json.loads(dumps(general_asset_manage_system__data_struct_co.find(filter=request_data))) # 校验key唯一性 if old_data: raise MyServiceException("添加失败, 数据已经存在,不能重复添加") general_asset_manage_system__data_co.insert_one(request_data) elif "delete" == opt_name: del request_data["_id"] query_old_data = json.loads(dumps(general_asset_manage_system__data_co.find_one(filter=request_data))) if not query_old_data: raise MyServiceException("删除失败, 该数据不存在,不能存在的数据") general_asset_manage_system__data_co.delete_one(filter=request_data) elif "update" == opt_name: request_data = common_service.check_request_dat_not_null(["old_data", "new_data"]) old_data = request_data["old_data"] new_data = request_data["new_data"] del old_data["_id"] del new_data["_id"] # 校验key存在性 query_old_data = json.loads(dumps(general_asset_manage_system__data_co.find_one(filter=old_data))) if not query_old_data: raise MyServiceException("修改失败, 数据不存在,不能修改空的数据") general_asset_manage_system__data_co.update_one(filter=old_data, update={'$set': new_data}) return {} except MyServiceException as e: print(e) return ResResult.return500(str(e))
def get_group_struct_has_auth_term(): try: request_data = common_service.check_request_dat_not_null( ["group_struct"]) group_struct = request_data["group_struct"] with open(os.path.join(config.project_root_path, "init_data", "access_control", "group_struct_has_auth_term", group_struct + ".json"), encoding="utf-8") as f: file_content = f.read() return file_content except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def finish_sql_invoke(): try: request_data = common_service.check_request_dat_not_null( ["process_instance_id"]) process_instance_id = request_data["process_instance_id"] # 查询对应流程id的执行内容 db_res_data = json.loads( dumps( project_manage__work_order_process__run_manage_process_sql_content_co .find_one(filter={'process_id': process_instance_id}))) env = db_res_data["env"] host_port = db_res_data["host_port"] database = db_res_data["database"] action_type = db_res_data["action_type"] sql_content = db_res_data["sql_content"] # 得到连接MySQL的信息 query_result = json.loads(mysql.get_decrypt()) query_result = query_result[0] level_mysql = query_result["mysql"] level_mysql_instance = level_mysql[env][host_port.replace(".", "_")] host = host_port.split(":")[0] port = host_port.split(":")[1] username = level_mysql_instance["username"] password = level_mysql_instance["password"] exe_sql_basic_info = { "env": env, "host": host, "port": port, "username": username, "password": password, "database": database, "action_type": action_type, "sql_content": sql_content, "process_id": process_instance_id, } # # 执行SQL project_manage__work_order_process__run_manage_result_log_co.insert_one( { "process_id": process_instance_id, "log": "开始执行", "is_exe_success": True, }) threading.Thread(target=exe_sql, args=[exe_sql_basic_info]).start() return {} except MyServiceException as e: print(e) return ResResult.return500(str(e))
def select_data_struct(): """ 查询数据结构 """ try: # 搜索 # 分页 request_data = common_service.check_request_dat_not_null(["asset_type"]) asset_type = request_data["asset_type"] return dumps(general_asset_manage_system__data_struct_co.find(filter={ "asset_type": asset_type })) except MyServiceException as e: print(e) return ResResult.return500(str(e))
def get_process_template(): """ 约束: 返回的流程必须包含当前用户, 且流程运行时的第一个人必须为当前登录人, 流程至少包含一个角色, 如果当前在整组流程中有更高级别的角色则会导致流程长度缩减(不会显示低级别的角色) :return: """ try: request_data = common_service.check_request_dat_not_null( ["process_template_id", "env"]) env = request_data["env"] process_template_id = request_data["process_template_id"] return dumps(do_get_process_template(env, process_template_id)) except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def modify_access_control_label_manage(): try: request_data = common_service.check_request_dat_not_null( ["id", "name", "code"]) data_id = request_data["id"] name = request_data["name"] code = request_data["code"] access_control_label_manage_co.update_one( filter={'_id': ObjectId(data_id)}, update={'$set': { "name": name, "code": code }}) return {} except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def rollback_process(): try: request_data = common_service.check_request_dat_not_null(["process_instance_id"]) process_instance_id = request_data["process_instance_id"] # 查询对应流程id的执行内容 db_res_data = json.loads( dumps(project_manage__work_order_process__run_manage_process__schedule_work_order_rb_co.find_one( filter={'process_id': process_instance_id}))) env = db_res_data["env"] host = db_res_data["host"] modify_schedule_line = db_res_data["modify_schedule_line"] do_process(host, modify_schedule_line, process_instance_id) return {} except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def update(): """ 修改 """ try: request_data = common_service.check_request_dat_not_null( ["id", "name"]) _id = request_data["id"] name = request_data["name"] if not _id or _id == "": raise MyServiceException("不能修改空id节点") process_instance = {"name": name} general_asset_manage_system__metadata_co.update_one( filter={'id': _id}, update={'$set': process_instance}) except MyServiceException as e: print(e) return ResResult.return500(str(e)) return {}
def delete_group_struct_has_user(): try: request_data = common_service.check_request_dat_not_null( ["group_struct", "user_open_id"]) group_struct = request_data["group_struct"] user_open_id = request_data["user_open_id"] # user_id = session["user_id"] # if user_id == user_open_id: # raise common_service.MyServiceException("用户不能删除自己的权限") access_control_group_struct_has_user_co.delete_one( filter={ "group_struct": group_struct, "user_open_id": user_open_id }) return {} except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e)) pass
def opt_data_struct(): """ 操作数据结构 """ try: request_data = common_service.check_request_dat_not_null(["opt_name", "code", "meaning", "asset_type"]) asset_type = request_data["asset_type"] opt_name = request_data["opt_name"] code = request_data["code"] meaning = request_data["meaning"] old_data_struct = json.loads(dumps(general_asset_manage_system__data_struct_co.find(filter={ "asset_type": asset_type, "code": code, }))) if "insert" == opt_name: # 校验key唯一性 if old_data_struct: raise MyServiceException("添加失败, 该代码值已经存在,不能重复添加") general_asset_manage_system__data_struct_co.insert_one({ "asset_type": asset_type, "code": code, "meaning": meaning, }) elif "delete" == opt_name: if not old_data_struct: raise MyServiceException("删除失败, 该代码值不存在,不能删除空的代码值") general_asset_manage_system__data_struct_co.delete_one(filter={ "asset_type": asset_type, "code": code, }) elif "update" == opt_name: # 校验key存在性 if not old_data_struct: raise MyServiceException("修改失败, 该代码值不存在,不能修改空的代码值的含义") general_asset_manage_system__data_struct_co.update_one(filter={"asset_type": asset_type, "code": code}, update={'$set': { "meaning": meaning }}) return {} except MyServiceException as e: print(e) return ResResult.return500(str(e))
def finish_project_deploy(): try: request_data = common_service.check_request_dat_not_null( ["process_instance_id"]) process_instance_id = request_data["process_instance_id"] # 查询对应流程id的执行内容 db_res_data = json.loads( dumps( project_manage__work_order_process__run_manage_process_project_deploy_co .find_one(filter={'process_id': process_instance_id}))) project_type = db_res_data["project_type"] if "java" == project_type: deploy_java(db_res_data) else: threading.Thread(target=deploy_php, args=[db_res_data]).start() return {} except MyServiceException as e: print(e) return ResResult.return500(str(e))
def delete(): """ 删除 """ try: request_data = common_service.check_request_dat_not_null(["id"]) _id = request_data["id"] if not _id or _id == "": raise MyServiceException("不能删除空id节点") # 删除指定id节点 general_asset_manage_system__metadata_co.delete_one(filter={"id": _id}) # 删除子节点 general_asset_manage_system__metadata_co.delete_many( filter={"id": { '$regex': "^" + _id + ".*" }}) return {} except MyServiceException as e: print(e) return ResResult.return500(str(e))
def modify_group_struct_has_user(): try: request_data = common_service.check_request_dat_not_null( ["group_struct", "user", "label", "action"]) group_struct = request_data["group_struct"] user = request_data["user"] label = request_data["label"] # action = request_data["action"] access_control_group_struct_has_user_db_res = access_control_group_struct_has_user_co.find_one( { "group_struct": group_struct, "user_open_id": user, }) if not access_control_group_struct_has_user_db_res: # 查询该用户的nick user_info_data = json.loads( dumps(dingding_user_info_co.find_one({"openid": user}))) nick = user_info_data["nick"] access_control_group_struct_has_user_co.insert_one({ "group_struct": group_struct, "user_open_id": user, "nick": nick }) access_control_user_manage_has_label_db_res = access_control_user_manage_has_label_co.find_one( {"user_open_id": user}) if not access_control_user_manage_has_label_db_res: access_control_user_manage_has_label_co.insert_one({ "user_open_id": user, "label": label }) else: access_control_user_manage_has_label_co.update_one( filter={"user_open_id": user}, update={'$set': { "label": label }}) return {} except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def get_group_struct_has_user(group_struct=None): try: if not group_struct: request_data = common_service.check_request_dat_not_null( ["group_struct"]) group_struct = request_data["group_struct"] access_control_group_struct_has_user_db_res = json.loads( dumps( access_control_group_struct_has_user_co.find( {"group_struct": group_struct}))) for item in access_control_group_struct_has_user_db_res: user_open_id = item["user_open_id"] item["label"] = json.loads( dumps( access_control_user_manage_has_label_co.find_one( {"user_open_id": user_open_id})))["label"] return json.dumps(access_control_group_struct_has_user_db_res) except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def select_data(): """ 查询数据 分页,搜索 """ try: page_size = 9999999 page_no = 1 # 处理资产类型 request_data = common_service.check_request_dat_not_null([]) if request_data.__contains__("asset_type"): asset_type = request_data["asset_type"] elif request_data.__contains__("asset_type_str"): asset_type_str = request_data["asset_type_str"] asset_type = metadata_manage.get_asset_type_by_asset_type_str(asset_type_str) if not asset_type: raise MyServiceException("查询数据没有指定资产类型") my_filter = {"asset_type": asset_type} if request_data.__contains__("search"): search = request_data["search"] search["asset_type"] = asset_type my_filter = search # 分页 if request_data.__contains__("page"): page = request_data["page"] if page["current"]: page_no = page["current"] if page["page_size"]: page_size = page["page_size"] skip = page_size * (page_no - 1) return dumps({ "data": general_asset_manage_system__data_co.find(filter=my_filter, sort=[("_id", -1)]).limit( page_size).skip(skip), "total": general_asset_manage_system__data_co.find(filter=my_filter, sort=[("_id", -1)]).limit( page_size).skip(skip).count(), }) except MyServiceException as e: print(e) return ResResult.return500(str(e))
def put_alarm_config_file(): try: # 入参 request_data = common_service.check_request_dat_not_null( ["config_file", "name"]) file_content = request_data["config_file"] if not file_content or file_content.strip() == "": raise common_service.MyServiceException("文件内容不能为空") name = request_data["name"] # 查询alarm文件位置 alarm_config_data = json.loads(alarm_config.get()) alarm_config_data_obj = alarm_config_data[0] level_data_alarm__config = alarm_config_data_obj["alarm__config"] level_data_component = level_data_alarm__config["component"] level_data_name = level_data_component[name] config_path = level_data_name["config_path"] # 文件位置 # 得到prometheus server 服务器的连接信息 prometheus_server_config = json.loads( get())[0]["monitoring__config"]["prometheus_server"] server_ip_tag = prometheus_server_config["server"] config_dirpath = prometheus_server_config["config_dirpath"] load_config_file_command = prometheus_server_config[ "load_config_file_command"] # 修改prometheus server 服务器中的文件 local_dirs = ["rule_files"] local_file_path = config_path target_file_path = config_dirpath + "/" + config_path service_type = "monitoring" modify_server_file(service_type, local_dirs, local_file_path, target_file_path, server_ip_tag, file_content, load_config_file_command) # 更新数据库数据 monitoring__alarm_config_file_co.insert(request_data) return {} except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def do_project_deploy(): try: request_data = common_service.check_request_dat_not_null([ "title", "project_type", "deploy_env", "deploy_target", "project", "process_template_id" ]) title = request_data["title"] project_type = request_data["project_type"] deploy_env = request_data["deploy_env"] process_template_id = request_data["process_template_id"] deploy_target = request_data["deploy_target"] project = request_data["project"] apply_process = request_data["apply_process"] display_content = "项目类型为: %s \n 部署环境为: %s \n 部署目标为: %s \n 项目为: %s \n " % ( project_type, deploy_env, deploy_target, project) last_process_template_arr_index = 0 if request_data.__contains__("code_inner_sql"): code_inner_sql = request_data["code_inner_sql"] else: code_inner_sql = None if code_inner_sql and code_inner_sql.strip() != "": last_process_template_arr_index = 1 store_data = { "project_type": project_type, "deploy_env": deploy_env, "deploy_target": deploy_target, "project": project, "code_inner_sql": code_inner_sql, } prepare_work_order_list = None if "prepare_work_order_list" in request_data: prepare_work_order_list = request_data[ "prepare_work_order_list"] # 前置工单 display_content += "前置工单: %s \n " % prepare_work_order_list if "java" == project_type: common_service.check_request_dat_not_null( ["namespace", "image_id"]) namespace = request_data["namespace"] image_id = request_data["image_id"] store_data["namespace"] = namespace store_data["image_id"] = image_id # 部署名称 deploy_name = json.loads(template.get())[0]["template"][ project_type][deploy_env]["projects"][project]["deploy_name"] store_data["deploy_name"] = deploy_name display_content += "命名空间为: %s \n 镜像ID为: %s \n 部署名称为: %s \n \n\n\n " % ( namespace, image_id, deploy_name) else: common_service.check_request_dat_not_null(["svn_tag_package"]) svn_tag_package = request_data["svn_tag_package"] # display_content += "取包地址为: %s \n \n\n\n " % svn_tag_package store_data["svn_tag_package"] = svn_tag_package # 检查包是否合理 display_content_area = check_deploy_php(request_data) display_content += display_content_area # 流程 finish_result = { "method": "POST", "url": "http://localhost:8080/project_manage/deploy_server/apply/finish_project_deploy", "rb_url": "http://localhost:8080/project_manage/deploy_server/apply/rollback_project_deploy", } process_id, next_step = run_manage.process_start( apply_process, process_template_arr[last_process_template_arr_index], finish_result, title, display_content, deploy_env, process_template_id, prepare_work_order_list, system_tag=project_type + ":" + project) store_data["process_id"] = process_id # 存储内容等待流程完成时去执行 project_manage__work_order_process__run_manage_process_project_deploy_co.insert_one( store_data) project_manage__work_order_process__run_manage_result_log_co.insert_one( { "process_id": process_id, "log": "创建流程", "is_exe_success": True, }) run_manage.process_after_trigger(process_id, next_step) return {} except MyServiceException as e: print(e) return ResResult.return500(str(e))
def encrypt(): request_data = common_service.check_request_dat_not_null(["encrypt_value"]) encrypt_value = request_data["encrypt_value"] return config.get_encrypt_value(encrypt_value)
def put_config_file(request_data=None): # 校验入参 try: if not request_data: request_data = common_service.check_request_dat_not_null( ["config_file"]) config_file = request_data["config_file"] if not config_file or config_file.strip() == "": raise common_service.MyServiceException("config_file不能为空") # 加载prometheus server服务器 prometheus_server_config = json.loads( get())[0]["monitoring__config"]["prometheus_server"] server = prometheus_server_config["server"] config_filepath = prometheus_server_config["config_filepath"] load_config_file_command = prometheus_server_config[ "load_config_file_command"] # 推断数据 config_dir_path = config_filepath[0:config_filepath.rfind("/")] # 生成本地文件 local_monitoring_path = project_root_path + "/" + "temp" + "/" + "monitoring" if not os.path.exists(local_monitoring_path): os.mkdir(local_monitoring_path) local_monitoring_config_file_path = project_root_path + "/" + "temp" + "/" + "monitoring" + "/" + "config_file" if not os.path.exists(local_monitoring_config_file_path): os.mkdir(local_monitoring_config_file_path) cur_file_name = "prometheus-%s.yml" % datetime.datetime.strftime( datetime.datetime.now(), '%Y%m%d_%H%M_%S') local_prometheus_yml = local_monitoring_config_file_path + "/" + cur_file_name local_file = open(local_prometheus_yml, "w", encoding="utf-8") local_file.write(config_file) local_file.flush() local_file.close() # 修改远程服务器的文件内容 filepath_new_backup = config_dir_path + "/" + cur_file_name filepath_old_backup = config_dir_path + "/" + "prometheus-old-backup.yml" filepath = config_filepath # 获取服务器连接信息 server_conn_info = json.loads( server_manage.get_decrypt())[0]["server_manage"][server] server_ip = server.replace("_", ".") server_username = list(server_conn_info.keys())[0] server_password = server_conn_info[server_username] my_server = MyServer(server_ip, server_username, server_password) # # 备份文件 my_server.backup_file(filepath, filepath_old_backup) # # 上传文件 my_server.upload_local_file(local_prometheus_yml, filepath_new_backup) # # 移动文件 my_server.move_file(filepath_new_backup, filepath) # 运行加载配置文件的指令 my_server.exe_command(load_config_file_command) request_data = common_service.clear_id(request_data) monitoring__config_file_co.insert(request_data) return {} except common_service.MyServiceException as e: print(e) return common_service.ResResult.return500(str(e))
def rollback_project_deploy(): try: request_data = common_service.check_request_dat_not_null( ["process_instance_id"]) process_instance_id = request_data["process_instance_id"] # 查询对应流程id的执行内容 db_res_data = json.loads( dumps( project_manage__work_order_process__run_manage_process_process_project_rb_co .find_one(filter={'process_id': process_instance_id}))) project_type = db_res_data["project_type"] deploy_env = db_res_data["deploy_env"] if "java" == project_type: data_namespace = db_res_data["data_namespace"] data_image_id = db_res_data["data_image_id"] deploy_name = db_res_data["deploy_name"] asset_manage__deploy_server__k8s_co_one = \ json.loads(common_service.query(asset_manage__deploy_server__k8s_co))[ 0] data_k8s = asset_manage__deploy_server__k8s_co_one["k8s"] data_k8s_env = data_k8s[deploy_env] data_k8s_host = data_k8s_env["host"] data_k8s_token = data_k8s_env["token"] my_k8s = MyK8s(data_k8s_host, data_k8s_token) project_manage__work_order_process__run_manage_result_log_co.insert_one( { "process_id": process_instance_id, "log": "开始回滚部署<br/>" + data_image_id + "<br/>", "is_exe_success": True, }) my_k8s.update_image(data_namespace, deploy_name, data_image_id) else: project = db_res_data["project"] revision = db_res_data["revision"] jenkins_data = json.loads(jenkins.get_decrypt())[0]["jenkins"] projects = json.loads(template.get( ))[0]["template"][project_type][deploy_env]["projects"] project_template_data = projects[project] build_info = project_template_data["build_env"] build_info_host = build_info["host"] build_info_job_name = build_info["job_name"] cur_jenkins = jenkins_data[build_info_host] cur_jenkins_url = cur_jenkins["url"] cur_jenkins_username = cur_jenkins["username"] cur_jenkins_password = cur_jenkins["password"] my_jenkins = MyJenkins(cur_jenkins_url, cur_jenkins_username, cur_jenkins_password) project_manage__work_order_process__run_manage_result_log_co.insert_one( { "process_id": process_instance_id, "log": "开始回滚部署<br/>" + str(revision) + "<br/>", "is_exe_success": True, }) my_jenkins.build_job(build_info_job_name, {"ROLLBACK": revision}, False) project_manage__work_order_process__run_manage_result_log_co.insert_one( { "process_id": process_instance_id, "log": "回滚成功", "is_exe_success": True, }) return {} except MyServiceException as e: print(e) project_manage__work_order_process__run_manage_result_log_co.insert_one( { "process_id": process_instance_id, "log": "回滚失败,原因:%s" % str(e), "is_exe_success": False, }) return ResResult.return500(str(e))