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 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 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 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 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 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 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 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 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 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))
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 process_action():
try:
request_data = common_service.check_request_dat_not_null(
["process_instance_id", "action"])
cur_user_id = session.get("user_id")
process_instance_id = request_data["process_instance_id"]
action = request_data["action"] # 动作
is_need_destroy_child_process = False
# 查询流程
db_res_data = json.loads(
dumps(
project_manage__work_order_process__run_manage_co.find_one(
filter={'_id': ObjectId(process_instance_id)})))
if action == "FINISH": # 跳转到下一个步骤
# 流程的当前节点必须要是当前登录人
del db_res_data["_id"]
next_step = db_res_data["next_step"]
next_steps = db_res_data["next_steps"]
if next_step != "*" and next_step != cur_user_id:
raise MyServiceException("当前登录人(%s)没有权限操作流程(%s)" %
(cur_user_id, process_instance_id))
process_action_finish(process_instance_id, next_steps, db_res_data)
elif action == "REJECT": # 驳回流程
reject_reason = request_data["reject_reason"] # 驳回理由
print("reject_reason: ", reject_reason)
next_steps = db_res_data["next_steps"]
do_next(next_steps)
process_action_reject(process_instance_id, reject_reason)
is_need_destroy_child_process = True
elif action == "DESTROY": # 销毁流程
next_steps = db_res_data["next_steps"]
if next_steps != "":
do_next(next_steps)
else:
is_cur_user_process(get_last_step(db_res_data["steps"]))
process_action_destroy(process_instance_id)
is_need_destroy_child_process = True
elif action == "ROLLBACK": # 回滚流程
last_step = get_last_step(db_res_data["steps"])
if last_step != "*" and last_step != cur_user_id:
raise MyServiceException("当前登录人(%s)没有权限操作流程(%s)" %
(cur_user_id, process_instance_id))
process_action_rollback(process_instance_id, db_res_data)
is_need_destroy_child_process = True
elif action == "SPECIAL_INVOKE_DATETIME_DURATION": # 指定执行时间段
# 流程的当前节点必须要是当前登录人
next_steps = db_res_data["next_steps"]
if next_steps == "":
is_cur_user_process(get_last_step(db_res_data["steps"]))
else:
next_step = db_res_data["next_step"]
if next_step != "*" and next_step != cur_user_id:
raise MyServiceException(
"当前登录人(%s)没有权限操作流程(%s)" %
(cur_user_id, process_instance_id))
special_invoke_datetime_duration = request_data[
"special_invoke_datetime_duration"]
special_invoke_datetime_duration_str = "-".join(
special_invoke_datetime_duration)
do_special_invoke_datetime_duration(
process_instance_id, special_invoke_datetime_duration_str)
elif action == "EXCEPTION_INTERRUPT_RESUME": # 异常中断恢复
is_cur_user_process(get_last_step(db_res_data["steps"]))
exception_interrupt_resume(process_instance_id, db_res_data)
#
#
#
# 处理以当前工单为前置流程的工单
if is_need_destroy_child_process:
db_res_data_child_process = json.loads(
dumps(
project_manage__work_order_process__run_manage_co.find(
filter={
'prepare_work_order_list': {
"$regex": process_instance_id
}
})))
for item in db_res_data_child_process:
project_manage__work_order_process__run_manage_co.delete_one(
filter={'_id': ObjectId(item["_id"]["$oid"])})
return {}
except MyServiceException as e:
print(e)
return ResResult.return500(str(e))
