def put(self, period_id):
product_id = request.args.get("product_id")
user = g.user_info["username"]
db = DB()
status, result = db.select_by_id("period_task", period_id)
if status is True:
result["action"] = "scheduler_resume"
result["status"] = {"id": 9, "name": period_status.get(9)}
audit = {
"timestamp": int(time.time()),
"user": user,
"option": period_audit.get(10)
}
insert_period_audit(period_id, audit)
update_status, update_result = db.update_by_id(
"period_task", json.dumps(result, ensure_ascii=False),
period_id)
if update_status is not True:
logger.error("Pause period_task error: %s" % update_result)
db.close_mysql()
return {"status": False, "message": update_result}, 500
scheduler_result = scheduler_resume(period_id)
if scheduler_result.get("status") is not True:
return {
"status": False,
"message": scheduler_result.get("message")
}, 500
audit_log(user, period_id, product_id, "period_task",
"scheduler resume")
return {"status": True, "message": ""}, 200
else:
db.close_mysql()
return {"status": False, "message": result}, 500
def no_concurrent(period_result, period_id, minion_list, salt_api, user, product_id):
db = DB()
period_result["status"] = {
"id": 2,
"name": period_status.get(2)
}
db.update_by_id("period_task", json.dumps(period_result, ensure_ascii=False), period_id)
if period_result.get("execute") == "shell":
result = salt_api.shell_remote_execution(minion_list, period_result.get("shell"))
elif period_result.get("execute") == "sls":
# 去掉后缀
sls = period_result.get("sls").replace(".sls", "")
result = salt_api.target_deploy(minion_list, sls)
results = {
"time": int(time.time()),
"result": result,
"option": period_audit.get(9)
}
insert_period_result(period_id, results)
# 不同调度方式使用不同的状态显示
if period_result["scheduler"] == "period":
period_result["status"] = {
"id": 9,
"name": period_status.get(9)
}
elif period_result["scheduler"] == "crontab":
period_result["status"] = {
"id": 10,
"name": period_status.get(10)
}
else:
period_result["status"] = {
"id": 3,
"name": period_status.get(3)
}
# 执行审计写入到period_audit表
audits = {
"timestamp": int(time.time()),
"user": "******",
"option": period_audit.get(3)
}
insert_period_audit(period_id, audits)
db.update_by_id("period_task", json.dumps(period_result, ensure_ascii=False), period_id)
db.close_mysql()
audit_log(user, minion_list, product_id, "minion", "shell")
def get_period(period_id, product_id):
db = DB()
status, period_result = db.select_by_id("period_task", period_id)
if status is True and period_result:
minions = []
for group in period_result.get("target"):
status, result = db.select_by_id("groups", group)
if status is True and result:
minions.extend(result.get("minion"))
minion_list = list(set(minions))
salt_api = salt_api_for_product(product_id)
if isinstance(salt_api, dict):
period_result["status"] = {"id": 4, "name": period_status.get(4)}
db.update_by_id("period_task",
json.dumps(period_result, ensure_ascii=False),
period_id)
return salt_api, 500
return period_result, minion_list, salt_api
else:
logger.error("Get period and minion error: %s" % period_result)
def post(self):
args = parser.parse_args()
args["id"] = uuid_prefix("t")
user = g.user_info["username"]
period_task = args
period_task["timestamp"] = int(time.time())
period_task["result"] = []
period_task["audit"] = []
period_task["status"] = {"id": 1, "name": period_status.get(1)}
period_task["count"] = 0
period_task["step"] = 0
audit = {
"timestamp": int(time.time()),
"user": user,
"option": period_audit.get(0)
}
insert_period_audit(args["id"], audit)
if args["once"]["date"]:
args["once"]["date"] = utc_to_local(args["once"]["date"])
db = DB()
status, result = db.select(
"period_task",
"where data -> '$.name'='%s' and data -> '$.product_id'='%s'" %
(args["name"], args["product_id"]))
if status is True:
if len(result) == 0:
audit_log(user, args["id"], "", "period_task", "add")
# 一次立即执行的直接扔给celery
if args["scheduler"] == "once" and args["once"][
"type"] == "now":
period_task["action"] = "concurrent_play"
job.delay(args["id"], args["product_id"], user)
# 一次定时执行的扔给APScheduler,进行定时处理
if args["scheduler"] == "once" and args["once"][
"type"] == "timing":
period_task["action"] = "scheduler_resume"
run_date = args["once"]["date"].split(
" ")[0] + " " + args["once"]["time"]
scheduler_result = scheduler_timing_add(
args["id"], args["product_id"], user, run_date)
if scheduler_result.get("status") is not True:
return {
"status": False,
"message": scheduler_result.get("message")
}, 500
# 周期性的扔给APScheduler,进行定时处理
if args["scheduler"] == "period":
period_task["action"] = "scheduler_resume"
scheduler_result = scheduler_interval_add(
args["id"], args["product_id"], user,
args["period"]["interval"], args["period"]["type"])
if scheduler_result.get("status") is not True:
return {
"status": False,
"message": scheduler_result.get("message")
}, 500
insert_status, insert_result = db.insert(
"period_task", json.dumps(period_task, ensure_ascii=False))
db.close_mysql()
if insert_status is not True:
logger.error("Add period_task error: %s" % insert_result)
return {"status": False, "message": insert_result}, 500
return {"status": True, "message": ""}, 201
else:
db.close_mysql()
return {
"status": False,
"message": "The period_task name already exists"
}, 200
else:
db.close_mysql()
logger.error("Select period_task name error: %s" % result)
return {"status": False, "message": result}, 500
def grouping(concurrent, period_result, period_id, minion_list, salt_api, user,
product_id):
# 假如并行数大于minion的总数,range步长为minion长度，即一次全部运行
# for m in period_result["executed_minion"]:
# minion_list.remove(m)
if concurrent > len(minion_list):
concurrent = len(minion_list)
count = period_result["count"] if period_result["count"] != 0 else 1
step = period_result["step"] if period_result["step"] != 0 else 0
for i in range(step, len(minion_list), concurrent):
db = DB()
p_status, p_result = db.select_by_id("period_task", period_id)
if p_status is True and p_result:
if p_result.get("action") == "concurrent_play" or p_result.get(
"action") == "scheduler_resume":
# 记录状态为第N组运行中
p_result["status"] = {
"id": 7,
"name": period_status.get(7) % count
}
audits = {
"timestamp": int(time.time()),
"user": "******",
"option": period_audit.get(7) % count
}
insert_period_audit(period_id, audits)
db.update_by_id("period_task",
json.dumps(p_result, ensure_ascii=False),
period_id)
# 根据并行数，对minion进行切分
minion = minion_list[i:i + concurrent]
if period_result.get("execute") == "shell":
result = salt_api.shell_remote_execution(
minion, period_result.get("shell"))
elif period_result.get("execute") == "sls":
result = salt_api.target_deploy(
minion,
period_result.get("sls").replace(".sls", ""))
# 执行结果写入到period_result表
results = {
"time": int(time.time()),
"result": result,
"option": period_audit.get(7) % count
}
insert_period_result(period_id, results)
# 执行完命令更新状态
p_result["status"] = {
"id": 8,
"name": period_status.get(8) % count
}
# 执行审计写入到period_audit表
audits = {
"timestamp": int(time.time()),
"user": "******",
"option": period_audit.get(8) % count
}
insert_period_audit(period_id, audits)
p_result["count"] = count + 1
p_result["step"] = step + concurrent
# 并行间隔时间，最后一次不等待
if concurrent < len(minion_list):
if i != list(range(0, len(minion_list), concurrent))[-1]:
time.sleep(int(p_result["interval"]))
count += 1
elif i == list(range(0, len(minion_list), concurrent))[-1]:
# 正常循环最后一次对计数几步长初始化
p_result["count"] = 0
p_result["step"] = 0
db.update_by_id("period_task",
json.dumps(p_result, ensure_ascii=False),
period_id)
db.close_mysql()
# audit_log(user, minion, product_id, "minion", "shell")
# 不同调度方式使用不同的状态显示
if p_result["scheduler"] == "period":
p_result["status"] = {"id": 9, "name": period_status.get(9)}
elif p_result["scheduler"] == "crontab":
p_result["status"] = {"id": 10, "name": period_status.get(10)}
elif p_result.get("action") != "concurrent_pause":
p_result["status"] = {"id": 3, "name": period_status.get(3)}
if p_result.get("action") != "concurrent_pause":
audits = {
"timestamp": int(time.time()),
"user": "******",
"option": period_audit.get(3)
}
insert_period_audit(period_id, audits)
db = DB()
db.update_by_id("period_task", json.dumps(p_result, ensure_ascii=False),
period_id)
db.close_mysql()
