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))
