def get(self, *args, **kwargs):
temp_id = self.get_argument('temp_id', default=None, strip=True)
temp_list = []
temp_user = []
if not temp_id:
return self.write(dict(code=-1, msg='模板ID不能为空'))
with DBContext('r') as session:
temp_info = session.query(TempDetails).filter(
TempDetails.temp_id == temp_id).order_by(
TempDetails.group, TempDetails.level).all()
user_info = session.query(TempToUser).filter(
TempToUser.temp_id == temp_id).all()
for msg in temp_info:
data_dict = model_to_dict(msg)
data_dict.pop('update_time')
temp_list.append(data_dict)
for u in user_info:
data_dict = model_to_dict(u)
temp_user.append("{},,,{}".format(data_dict.get("user_id"),
data_dict.get("nickname")))
data_info = dict(temp_list=temp_list, temp_user=temp_user)
return self.write(
dict(code=0, msg='获取模板详情成功', data=data_info, temp_user=temp_user))
def get(self, *args, **kwargs):
page_size = self.get_argument('page', default=1, strip=True)
limit = self.get_argument('limit', default=500, strip=True)
limit_start = (int(page_size) - 1) * int(limit)
task_list = []
this_list = []
username = self.get_current_user()
nickname = self.get_current_nickname()
with DBContext('r') as session:
count = session.query(TaskList).filter(TaskList.schedule == 'OK').count()
task_info = session.query(TaskList).filter(TaskList.schedule == 'OK').order_by(
-TaskList.list_id).offset(limit_start).limit(int(limit))
for msg in task_info:
data_dict = model_to_dict(msg)
user_list = []
for i in list(literal_eval(data_dict.get("associated_user")).values()):
user_list.extend(i)
if username in user_list or nickname in user_list or self.is_superuser:
data_dict['create_time'] = str(data_dict['create_time'])
data_dict['start_time'] = str(data_dict['start_time'])
this_list.append(data_dict.get("list_id"))
task_list.append(data_dict)
return self.write(dict(code=0, msg="获取成功", data=task_list, count=count, history=True))
def put(self, *args, **kwargs):
### 处理全部需要手动干预的任务
data = json.loads(self.request.body.decode("utf-8"))
list_id = data.get('list_id', None)
hand_task = data.get('hand_task', None)
if not list_id:
return self.write(dict(code=-1, msg='订单ID 不能为空'))
if not hand_task:
return self.write(dict(code=-2, msg='任务名称不正确'))
with DBContext('w', None, True) as session:
session.query(TaskSched).filter(TaskSched.list_id == list_id, TaskSched.task_name == hand_task).update(
{TaskSched.task_status: '1'})
data_info = session.query(TaskSched).filter(TaskSched.list_id == list_id,
TaskSched.task_name == hand_task).all()
redis_conn = cache_conn()
redis_pipe = redis_conn.pipeline()
for msg in data_info:
data_dict = model_to_dict(msg)
hash_key = "task_{}_{}_{}".format(list_id, data_dict["task_group"], data_dict["exec_ip"])
redis_pipe.hset(hash_key, data_dict["task_level"], '1')
redis_pipe.expire(hash_key, 2592000)
redis_pipe.execute()
return self.write(dict(code=0, msg='审核干预成功'))
def get(self, *args, **kwargs):
temp_id = self.get_argument('temp_id', default=None, strip=True)
args_list = []
if not temp_id:
return self.write(dict(code=-1, msg='模板ID不能为空'))
with DBContext('r') as session:
temp_args = session.query(
TempDetails.args).filter(TempDetails.temp_id == temp_id).all()
args_info = session.query(ArgsList).all()
for msg in temp_args:
if msg[0]:
for m in msg[0].split():
args_list.append(m)
args_list = list(set(args_list))
if 'FLOW_ID' in args_list:
args_list.remove('FLOW_ID')
args_dict = {}
for msg in args_info:
data_dict = model_to_dict(msg)
if data_dict['args_self']:
args_dict[data_dict['args_self']] = data_dict['args_name']
return self.write(
dict(code=0, msg="获取成功", data=args_list, args_dict=args_dict))
def get(self, *args, **kwargs):
search_value = self.get_argument('search_value',
default=None,
strip=True)
page_size = self.get_argument('page', default=1, strip=True)
limit = self.get_argument('limit', default=201, strip=True)
limit_start = (int(page_size) - 1) * int(limit)
args_list = []
with DBContext('r') as session:
if search_value:
count = session.query(ArgsList).filter(
or_(ArgsList.args_id.like('{}%'.format(search_value)),
ArgsList.args_name.like('{}%'.format(search_value)),
ArgsList.args_self.like('{}%'.format(search_value)),
ArgsList.creator.like(
'{}%'.format(search_value)))).count()
args_info = session.query(ArgsList).filter(
or_(ArgsList.args_id.like('{}%'.format(search_value)),
ArgsList.args_name.like('{}%'.format(search_value)),
ArgsList.args_self.like('{}%'.format(search_value)),
ArgsList.creator.like('{}%'.format(
search_value)))).offset(limit_start).limit(
int(limit))
if limit > 200:
args_info = session.query(ArgsList).filter(
or_(
ArgsList.args_id.like('{}%'.format(search_value)),
ArgsList.args_name.like(
'{}%'.format(search_value)),
ArgsList.args_self.like(
'{}%'.format(search_value)),
ArgsList.creator.like(
'{}%'.format(search_value)))).all()
elif limit > 200: ### 获取全部
count = session.query(ArgsList).count()
args_info = session.query(ArgsList).order_by(
ArgsList.args_id).all()
else: ## 默认分页查询
count = session.query(ArgsList).count()
args_info = session.query(ArgsList).order_by(
ArgsList.args_id).offset(limit_start).limit(int(limit))
for msg in args_info:
data_dict = model_to_dict(msg)
data_dict['update_time'] = str(data_dict['update_time'])
args_list.append(data_dict)
return self.write(dict(code=0, msg='获取成功', data=args_list,
count=count))
def get(self, *args, **kwargs):
user_list = []
with DBContext('r') as session:
args_info = session.query(ExecuteUser).order_by(
ExecuteUser.id).all()
for msg in args_info:
data_dict = model_to_dict(msg)
data_dict['update_time'] = str(data_dict['update_time'])
user_list.append(data_dict)
return self.write(dict(code=0, msg='获取成功', data=user_list))
def tail_data():
log_list = []
with DBContext('r') as session:
for key in LISTENERS:
ele_list = LISTENERS[key]['ele']
if ele_list:
log_info = session.query(TaskLog).filter(TaskLog.log_key == key).order_by(
TaskLog.log_time).all()
for msg in log_info:
data_dict = model_to_dict(msg)
log_list.append("{}： {}".format(str(data_dict.get('log_time')), data_dict.get('log_info')))
for el in ele_list:
el.write_message('----'.join(log_list))
else:
LISTENERS.pop(key)
def get_log_data():
log_list1 = []
with DBContext('r') as session:
for key in LISTENERS_v1:
ele_list = LISTENERS_v1[key]['ele']
if ele_list:
log_info = session.query(TaskLog).filter(
TaskLog.log_key == key).order_by(TaskLog.exec_time).all()
for msg in log_info:
data_dict = model_to_dict(msg)
log_list1.append(data_dict.get('log_info'))
if log_list1:
del log_list1[0]
for el in ele_list:
el.write_message('----'.join(log_list1))
else:
LISTENERS_v1.pop(key)
def get(self, *args, **kwargs):
key = self.get_argument('key', default=None, strip=True)
value = self.get_argument('value', default=None, strip=True)
args_list = []
with DBContext('r') as session:
if key and value:
args_info = session.query(ArgsList).filter_by(**{
key: value
}).order_by(ArgsList.args_id).all()
else:
args_info = session.query(ArgsList).order_by(
ArgsList.args_id).all()
for msg in args_info:
data_dict = model_to_dict(msg)
data_dict['update_time'] = str(data_dict['update_time'])
args_list.append(data_dict)
return self.write(dict(code=0, msg='获取成功', data=args_list))
def get_task_info(list_id, task_group, exec_ip, this_host_list):
scheduler_list = []
hosts_status = {}
with DBContext('r') as session:
for h in this_host_list:
scheduler_info = session.query(TaskSched).filter(TaskSched.list_id == list_id,
TaskSched.task_group == task_group,
TaskSched.exec_ip == h).order_by(
TaskSched.task_level).all()
status_list = []
for msg in scheduler_info:
data_dict = model_to_dict(msg)
status_list.append(data_dict.get("task_status"))
if exec_ip == data_dict.get("exec_ip"):
scheduler_list.append(data_dict)
status = '4'
if '0' in status_list:
status = '0'
if '1' in status_list:
status = '1'
if '2' in status_list:
status = '2'
if '5' in status_list and '1' not in status_list and '2' not in status_list:
status = '5'
if '6' in status_list:
status = '6'
if '7' in status_list:
status = '7'
if '4' in status_list:
status = '4'
if '3' in status_list and len(list(set(status_list))) == 1:
status = '3'
hosts_status[str(h)] = status
return scheduler_list, hosts_status
def get(self, *args, **kwargs):
page_size = self.get_argument('page', default=1, strip=True)
limit = self.get_argument('limit', default=500, strip=True)
limit_start = (int(page_size) - 1) * int(limit)
task_list = []
this_list = []
with DBContext('r') as session:
count = session.query(TaskList).filter(
TaskList.schedule == 'OK').count()
task_info = session.query(TaskList).filter(
TaskList.schedule == 'OK').order_by(-TaskList.list_id).offset(
limit_start).limit(int(limit))
for msg in task_info:
data_dict = model_to_dict(msg)
data_dict['create_time'] = str(data_dict['create_time'])
data_dict['start_time'] = str(data_dict['start_time'])
this_list.append(data_dict.get("list_id"))
task_list.append(data_dict)
return self.write(
dict(code=0, msg="获取成功", data=task_list, count=count,
history=True))
def exec_list_thread(self, lid, *all_gid):
### 如果任务没有审批，则进入休眠,初始休眠时间为0秒
int_sleep, end_sleep = 1, 1
while True:
### 挂起的任务设置休眠时间
ins_log.read_log(
'info',
'The task-{0} is not ready, retry after {1} s of sleep'.format(
lid, int_sleep))
time.sleep(int_sleep)
int_sleep += 2
end_sleep += int_sleep
if int_sleep > 15:
int_sleep = 15
with DBContext('r') as session:
job_code = session.query(TaskList).filter(
TaskList.list_id == lid,
TaskList.schedule == 'new').first()
if not job_code:
break
if end_sleep > 150:
raise SystemExit('message timeout')
### 标记为任务开始，判断任务是否审批(schedule等于ready)
with DBContext('w') as session:
session.query(TaskList.list_id).filter(
TaskList.list_id == lid, TaskList.schedule == 'ready').update(
{TaskList.schedule: 'start'})
session.commit()
exec_user_dict = dict()
with DBContext('r') as session:
exec_user_info = session.query(ExecuteUser).all()
task_info = session.query(TaskList).filter(
TaskList.list_id == lid).first()
sched_task_info = session.query(TaskSched).filter(
TaskSched.list_id == lid).all()
### 参数信息 主机信息
all_args_info = literal_eval(task_info.args)
all_host_info = literal_eval(task_info.hosts)
self.redis_conn.set('task_id_{}_start_time'.format(lid),
time.mktime(task_info.start_time.timetuple()))
self.redis_conn.expire('task_id_{}_start_time'.format(lid),
2592000)
### 管理用户信息
for msg in exec_user_info:
data_dict = model_to_dict(msg)
exec_user_dict[data_dict.get("exec_user") +
"port"] = data_dict.get("ssh_port", "22")
exec_user_dict[data_dict.get("exec_user") +
"password"] = data_dict.get("password", "")
key_file = "/home/.ssh_key/{}_key".format(
data_dict.get("exec_user"))
if not os.path.exists('/home/.ssh_key/'):
os.makedirs('/home/.ssh_key/')
with open(key_file, 'w') as k_file:
k_file.write(data_dict.get("user_key"))
os.system("chmod 600 {}".format(key_file))
### 取出必要信息写入缓存
level_list_info = dict()
for i in all_gid:
level_list_info[i[0]] = []
with self.redis_conn.pipeline() as redis_pipe:
for msg in sched_task_info:
data_dict = model_to_dict(msg)
log_key = "{}_{}_{}_{}".format(lid,
data_dict["task_group"],
data_dict["task_level"],
data_dict["exec_ip"])
task_info_key = "task_info_{}".format(log_key)
level_status_key = "level_status_{}".format(log_key)
data_dict["log_key"] = log_key
redis_pipe.hmset(task_info_key, data_dict)
redis_pipe.set(level_status_key, data_dict["task_status"])
redis_pipe.expire(task_info_key, 2592000)
redis_pipe.expire(level_status_key, 2592000)
for i in all_gid:
if i[0] == data_dict["task_group"]:
level_list_info[i[0]].append(
data_dict["task_level"])
redis_pipe.execute()
threads = []
#####取所有主机###
for i in all_gid:
i = i[0]
if i:
all_exec_ip = all_host_info.get(i)
level_list = list(set(level_list_info[i]))
print('level_list', level_list)
threads.append(
multiprocessing.Process(target=self.run,
args=(lid, i, all_exec_ip,
all_args_info,
exec_user_dict, level_list)))
ins_log.read_log(
'info', "current has %d threads group execution " % len(threads))
###开始多进程
for start_t in threads:
try:
start_t.start()
except UnboundLocalError:
ins_log.read_log('error', "UnboundLocalError")
###阻塞
for join_t in threads:
join_t.join()
