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_user_rules(user_id, is_superuser=False):
page_data = {}
component_data = {}
with DBContext('r') as session:
if is_superuser:
components_info = session.query(Components.component_name).filter(Components.status == '0').all()
page_data['all'] = True
component_data['all'] = True
for msg in components_info:
component_data[msg[0]] = True
else:
this_menus = session.query(Menus.menu_name).outerjoin(RoleMenus,
Menus.menu_id == RoleMenus.menu_id).outerjoin(
UserRoles, RoleMenus.role_id == UserRoles.role_id).filter(UserRoles.user_id == user_id,
UserRoles.status == '0',
Menus.status == '0').all()
this_components = session.query(Components.component_name).outerjoin(RolesComponents,
Components.comp_id == RolesComponents.comp_id
).outerjoin(
UserRoles, RolesComponents.role_id == UserRoles.role_id).filter(UserRoles.user_id == user_id,
UserRoles.status == '0',
Components.status == '0').all()
## 如果不是超级用户 插入一个没有权限的
page_data['all'] = False
component_data['all'] = False
for p in this_menus:
page_data[p[0]] = True
for c in this_components:
component_data[c[0]] = True
redis_conn = cache_conn()
redis_conn.hmset("{}_rules".format(user_id), dict(page=page_data, component=component_data))
def get(self, *args, **kwargs):
page_size = self.get_argument('page', default=1, strip=True)
limit = self.get_argument('limit', default=100, 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.start_time,
-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)
list_id = "" if len(this_list) < 1 else this_list[0]
return self.write(
dict(code=0,
msg="获取成功",
data=task_list,
count=count,
list_id=list_id))
def put(self, *args, **kwargs):
if not self.is_superuser:
return self.write(dict(code=-1, msg='不是超级管理员，没有权限'))
data = json.loads(self.request.body.decode("utf-8"))
user_list = data.get('user_list', None)
if len(user_list) < 1:
return self.write(dict(code=-2, msg='用户不能为空'))
redis_conn = cache_conn()
configs_init('all')
config_info = redis_conn.hgetall(const.APP_SETTINGS)
config_info = convert(config_info)
obj = SendMail(
mail_host=config_info.get(const.EMAIL_HOST),
mail_port=config_info.get(const.EMAIL_PORT),
mail_user=config_info.get(const.EMAIL_HOST_USER),
mail_password=config_info.get(const.EMAIL_HOST_PASSWORD),
mail_ssl=True
if config_info.get(const.EMAIL_USE_SSL) == '1' else False,
mail_tls=True
if config_info.get(const.EMAIL_USE_TLS) == '1' else False)
with DBContext('w', None, True) as session:
for user_id in user_list:
md5_password = shortuuid.uuid()
new_password = gen_md5(md5_password)
session.query(Users).filter(Users.user_id == user_id).update(
{Users.password: new_password})
mail_to = session.query(
Users.email).filter(Users.user_id == user_id).first()
obj.send_mail(mail_to[0],
'修改密码',
md5_password,
subtype='plain')
return self.write(dict(code=0, msg='重置密码成功，新密码已经发送到邮箱'))
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
paid_id = data.get('id')
paid_name = data.get('paid_name', None)
paid_start_time = data.get('paid_start_time', None)
paid_end_time = data.get('paid_end_time', None)
reminder_day = data.get('reminder_day', None)
nicknames = data.get('nicknames', None)
if not paid_name or not paid_start_time or not paid_end_time or not reminder_day or not nicknames:
return self.write(dict(code=-2, msg='关键参数不能为空'))
if nicknames:
nicknames = ','.join(nicknames)
update_info = {
"paid_start_time": paid_start_time,
"paid_end_time": paid_end_time,
"reminder_day": reminder_day,
"nicknames": nicknames
}
if re.search('000Z', paid_start_time):
paid_start_time = datetime.datetime.strptime(
paid_start_time,
"%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8)
update_info['paid_start_time'] = paid_start_time
if re.search('000Z', paid_end_time):
paid_end_time = datetime.datetime.strptime(
paid_end_time,
"%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8)
update_info['paid_end_time'] = paid_end_time
with DBContext('w', None, True) as session:
session.query(PaidMG).filter(
PaidMG.paid_name == paid_name).update(update_info)
self.write(dict(code=0, msg='更新成功'))
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
id = data.get('id', None)
name = data.get('name', None) # 名称，也是唯一
system_user = data.get('system_user', None) # 系统用户
platform_users = data.get('platform_users', []) # 平台用户
priority = data.get('priority', None) # 优先级
sudo_list = data.get('sudo_list', None) # sudo权限
bash_shell = data.get('bash_shell', None) # sudo权限
remarks = data.get('remarks', None) # 备注
if not name or not system_user or not priority or not sudo_list or not bash_shell:
return self.write(dict(code=-2, msg='关键参数不能为空'))
if not platform_users:
return self.write(dict(code=-2, msg='请至少选择一个关联用户'))
if not is_number(priority):
return self.write(dict(code=-2, msg='优先级必须是数字'))
with DBContext('w', None, True) as session:
exist_sudo_list = session.query(
SystemUser.sudo_list).filter(SystemUser.id == id).first()
if exist_sudo_list[0] != sudo_list:
# 存在修改sudo_list，更新新的sudo_list到主机上
obj = PushSystemUser()
obj.update_user_sudo(system_user, sudo_list)
session.query(SystemUser).filter(SystemUser.id == id).update({
SystemUser.platform_users:
','.join(platform_users),
SystemUser.priority:
priority,
SystemUser.sudo_list:
sudo_list,
SystemUser.remarks:
remarks
})
return self.write(dict(code=0, msg='编辑成功'))
def get_user_rules(user_id):
page_data = {}
component_data = {}
with DBContext('r') as session:
this_menus = session.query(Menus.menu_name
).outerjoin(RoleMenus, Menus.menu_id == RoleMenus.menu_id).outerjoin(
UserRoles, RoleMenus.role_id == UserRoles.role_id).filter(UserRoles.user_id == user_id).all()
this_components = session.query(Components.component_name
).outerjoin(RolesComponents,
Components.comp_id == RolesComponents.comp_id).outerjoin(
UserRoles, RolesComponents.role_id == UserRoles.role_id).filter(UserRoles.user_id == user_id).all()
for p in this_menus:
page_data[p[0]] = True
for c in this_components:
component_data[c[0]] = True
## 插入一个没有权限的
page_data['all'] = False
component_data['all'] = False
redis_conn = cache_conn()
redis_conn.hmset("{}_rules".format(user_id), dict(page=page_data, component=component_data))
def get(self, *args, **kwargs):
role_id = self.get_argument('role_id', default=None, strip=True)
data_list = []
if not role_id: return self.write(dict(code=-1, msg='角色不能为空'))
with DBContext('r') as session:
role_func = session.query(Functions).outerjoin(
RoleFunctions,
Functions.func_id == RoleFunctions.func_id).filter(
RoleFunctions.role_id == role_id,
RoleFunctions.status == '0').all()
for msg in role_func:
menu_dict = {}
data_dict = model_to_dict(msg)
menu_dict["func_id"] = data_dict["func_id"]
menu_dict["func_name"] = data_dict["func_name"]
menu_dict["method_type"] = data_dict["method_type"]
menu_dict["uri"] = data_dict["uri"]
data_list.append(menu_dict)
return self.write(dict(code=0, msg='获取成功', data=data_list))
def post(self, *args, **kwargs):
with DBContext('w', None, True) as session:
zabbix_generator_list = get_zabbix_hosts()
if zabbix_generator_list:
for zabbix_gen in zabbix_generator_list:
for host_info in zabbix_gen:
host_name = host_info.get('host_name')
exist_hostname = session.query(ZabbixHosts).filter(
ZabbixHosts.host_name == host_name).first()
if not exist_hostname:
session.add(
ZabbixHosts(zabbix_url=host_info.get('zabbix_url'),
group_id=host_info.get('group_id'),
group_name=host_info.get('group_name'),
host_id=host_info.get('host_id'),
host_name=host_name))
else:
session.query(ZabbixHosts).filter(
ZabbixHosts.host_name == host_name).update(
host_info)
session.commit()
self.write(dict(code=0, msg='刷新成功'))
def get(self, *args, **kwargs):
key = self.get_argument('key', default=None, strip=True)
value = self.get_argument('value', default=None, strip=True)
page_size = self.get_argument('page', default=1, strip=True)
limit = self.get_argument('limit', default=10, strip=True)
limit_start = (int(page_size) - 1) * int(limit)
role_list = []
with DBContext('r') as session:
if key and value:
count = session.query(Roles).filter(Roles.status != '10').filter_by(**{key: value}).count()
role_info = session.query(Roles).filter(Roles.status != '10').filter_by(**{key: value}).order_by(
Roles.role_id).offset( limit_start).limit(int(limit))
else:
count = session.query(Roles).filter(Roles.status != '10').count()
role_info = session.query(Roles).filter(Roles.status != '10').order_by(Roles.role_id).offset(
limit_start).limit(int(limit))
for msg in role_info:
data_dict = model_to_dict(msg)
data_dict['ctime'] = str(data_dict['ctime'])
role_list.append(data_dict)
return self.write(dict(code=0, msg='获取角色成功', count=count, data=role_list))
def update_resource(data: dict):
try:
valid_data = ResourceUpdateModel(**data)
except ValidationError as e:
return dict(code=-1, msg=str(e))
try:
with DBContext('w', None, True) as db:
db.query(ResourceOrm).filter(
ResourceOrm.id == valid_data.id).update({
'name':
valid_data.name,
'code':
valid_data.code,
'expand':
valid_data.expand,
'entity':
valid_data.entity
})
except Exception as err:
return dict(code=-2, msg='修改失败, {}'.format(str(err)))
return dict(code=0, msg="修改成功")
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
admin_user_id = data.get('id')
admin_user = data.get('admin_user', None)
system_user = data.get('system_user', None)
# password = data.get('password', None)
user_key = data.get('user_key', None)
remarks = data.get('remarks', None)
if not admin_user or not system_user or not user_key:
return self.write(dict(code=-2, msg='关键参数不能为空'))
update_info = {
"admin_user": admin_user,
"system_user": system_user,
"user_key": user_key,
"remarks": remarks,
}
with DBContext('w', None, True) as session:
session.query(AdminUser).filter(
AdminUser.id == admin_user_id).update(update_info)
self.write(dict(code=0, msg='更新成功'))
def get(self, *args, **kwargs):
key = self.get_argument('key', default=None, strip=True)
idc_list = []
with DBContext('w') as session:
if key:
idc_data = session.query(AssetIDC).filter(
or_(AssetIDC.name.like('%{}%'.format(key)),
AssetIDC.contact.like('%{}%'.format(key)),
AssetIDC.email.like('%{}%'.format(key)),
AssetIDC.phone.like('%{}%'.format(key)),
AssetIDC.address.like('%{}%'.format(key)),
AssetIDC.network.like('%{}%'.format(key)),
AssetIDC.bandwidth.like('%{}%'.format(key)),
AssetIDC.ip_range.like('%{}%'.format(key)),
AssetIDC.remarks.like('%{}%'.format(key)))).order_by(
AssetIDC.id)
else:
idc_data = session.query(AssetIDC).order_by(AssetIDC.id).all()
for data in idc_data:
data_dict = model_to_dict(data)
idc_list.append(data_dict)
return self.write(dict(code=0, msg='获取成功', data=idc_list))
def get(self, *args, **kwargs):
role_id = self.get_argument('role_id', default=None, strip=True)
data_list = []
if not role_id:
return self.write(dict(code=-1, msg='角色不能为空'))
with DBContext('r') as session:
comp_info = session.query(Components).outerjoin(
RolesComponents,
Components.comp_id == RolesComponents.comp_id).filter(
RolesComponents.role_id == role_id,
RolesComponents.status == '0',
Components.status == '0').all()
for msg in comp_info:
comp_dict = {}
data_dict = model_to_dict(msg)
comp_dict["comp_id"] = data_dict["comp_id"]
comp_dict["component_name"] = data_dict["component_name"]
data_list.append(comp_dict)
return self.write(dict(code=0, msg='获取成功', data=data_list))
def write_verify(self):
if self.is_superuser:
user_method = self.user_id + 'ALL'
self.redis_conn.sadd(user_method, '/')
self.redis_conn.expire(user_method, time=3 * 86400)
return '权限已经写入缓存'
for method in self.method_list:
user_method = self.user_id + method
self.redis_conn.delete(user_method)
with DBContext('r') as session:
func_list = session.query(Functions.method_type, Functions.uri
).outerjoin(RoleFunctions, Functions.func_id == RoleFunctions.func_id).outerjoin(
UserRoles, RoleFunctions.role_id == UserRoles.role_id).filter(UserRoles.user_id == self.user_id,
Functions.status == '0',
RoleFunctions.status == '0',
UserRoles.status == '0').all()
for func in func_list:
### 把权限写入redis
self.redis_conn.sadd(self.user_id + func[0], func[1])
self.redis_conn.expire(self.user_id + func[0], time=3 * 86400)
return '权限已经写入缓存'
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
hook_tag = data.get('hook_tag').strip()
temp_id = data.get('temp_id')
schedule = data.get('schedule', 'new')
hook_args = data.get('hook_args')
the_id = data.get('the_id')
if not hook_tag or not temp_id or not the_id:
return self.write(dict(code=1, msg='关键参数不能为空'))
if hook_args:
try:
hook_args_dict = json.loads(hook_args)
except Exception as e:
return self.write(dict(code=2, msg='参数字典格式不正确'))
else:
hook_args_dict = dict()
with DBContext('w', None, True) as session:
git_hooks_info = session.query(GitRepo.git_hooks).filter(GitRepo.id == the_id).first()
hook_dict = git_hooks_info[0] if git_hooks_info else {}
if hook_dict:
try:
hook_dict = json.loads(hook_dict)
except Exception as e:
return self.write(dict(code=2, msg='钩子参数转化为字典的时候出错，请仔细检查相关内容' + str(e)))
if not hook_dict:
hook_dict = {hook_tag: dict(temp_id=temp_id, schedule=schedule, hook_args=hook_args_dict)}
else:
hook_dict[hook_tag] = dict(temp_id=temp_id, schedule=schedule, hook_args=hook_args_dict)
hook_dict = json.dumps(hook_dict)
session.query(GitRepo.git_hooks).filter(GitRepo.id == the_id).update({GitRepo.git_hooks: hook_dict})
self.write(dict(code=0, msg='更新钩子成功'))
def get(self, *args, **kwargs):
key = self.get_argument('key', default=None, strip=True)
pageNum = int(self.get_argument('page', default='1', strip=True))
pageSize = int(self.get_argument('limit', default='10', strip=True))
with DBContext('r') as session:
if key:
elasticache_data = session.query(ElastiCache).filter(
or_(
ElastiCache.idc.like('%{}%'.format(key)),
ElastiCache.db_code.like('%{}%'.format(key)),
ElastiCache.db_class.like('%{}%'.format(key)),
ElastiCache.db_host.like('%{}%'.format(key)),
ElastiCache.db_port.like('%{}%'.format(key)),
ElastiCache.db_user.like('%{}%'.format(key)),
ElastiCache.db_region.like('%{}%'.format(key)),
ElastiCache.db_type.like('%{}%'.format(key)),
ElastiCache.db_version.like('%{}%'.format(key)),
ElastiCache.state.like('%{}%'.format(key)),
ElastiCache.db_detail.like('%{}%'.format(key)),
ElastiCache.tag_list.like('%{}%'.format(key)),
ElastiCache.db_node_num.like('%{}%'.format(key)),
)).all()
else:
elasticache_data = session.query(ElastiCache).all()
data_dict = list()
for msg in elasticache_data:
msg = model_to_dict(msg)
msg.pop("create_time")
msg.pop("update_time")
data_dict.append(msg)
elasticache_list_re = data_dict[(pageNum - 1) * pageSize:pageNum *
pageSize]
self.write(
dict(code=0,
msg='获取成功',
count=len(data_dict),
data=elasticache_list_re))
def get(self, *args, **kwargs):
data_list = []
key = self.get_argument('key', default=None, strip=True)
value = self.get_argument('value', default=None, strip=True)
page_size = self.get_argument('page', default=1, strip=True)
limit = self.get_argument('limit', default=30, strip=True)
limit_start = (int(page_size) - 1) * int(limit)
user_list = []
with DBContext('r') as session:
conditions = []
if key == "typename":
conditions.append(TypeList.typename.like('%{}%'.format(value)))
if key == "remarks":
conditions.append(TypeList.remarks.like('%{}%'.format(value)))
if key == "chart":
conditions.append(TypeList.chart.like('%{}%'.format(value)))
todata = session.query(TypeList).filter(*conditions).order_by(
TypeList.ctime.desc()).offset(limit_start).limit(
int(limit)).all()
tocount = session.query(TypeList).filter(*conditions).count()
for msg in todata:
case_dict = {}
data_dict = model_to_dict(msg)
case_dict["id"] = data_dict["id"]
case_dict["typename"] = data_dict["typename"]
case_dict["remarks"] = data_dict["remarks"]
case_dict["chart"] = data_dict["chart"]
case_dict["ctime"] = str(data_dict["ctime"])
data_list.append(case_dict)
if len(data_list) > 0:
return self.write(
dict(code=0, msg='获取成功', count=tocount, data=data_list))
else:
return self.write(dict(code=-1, msg='没有相关数据', count=0, data=[]))
def get(self, *args, **kwargs):
project_code = self.get_argument('project_code', default=None, strip=True)
with DBContext('r') as session:
config_info = session.query(BusinessModel).filter(BusinessModel.project_code == project_code).all()
config_list = [model_to_dict(msg) for msg in config_info]
_tree = [{"expand": True, "title": project_code, "children": [], "data_type": 'project'}]
if config_list:
tmp_tree = {"environ": {}, "service": {}}
for t in config_list:
service, environ = t['service'], t["environment"]
# 因为是第一层所以没有parent
tmp_tree["environ"][environ] = {
"expand": False, "title": environ, "parent": "root", "children": [], "data_type": 'env'
}
# 父节点是对应的environ
tmp_tree["service"][environ + "|" + service] = {
"expand": False, "title": service, "parent": environ,
"children": [], "data_type": 'service'
}
# service的数据插入到environ的children中
for tmpService in tmp_tree["service"].values():
tmp_tree["environ"][tmpService["parent"]]["children"].append(tmpService)
for tmpEnviron in tmp_tree["environ"].values():
if tmpEnviron not in ["all", "all_env"]:
_tree[0]["children"].append(tmpEnviron)
return self.write(dict(code=0, msg='获取项目Tree成功', data=_tree))
else:
return self.write(dict(code=0, msg='获取项目Tree失败', data=_tree))
def get(self, *args, **kwargs):
"""查询出用户登录记录接口"""
search_key = self.get_argument('search_key', default=None, strip=True)
login_list = []
with DBContext('r') as session:
if search_key:
# 模糊查所有
login_info = session.query(LoginRecord).filter(
or_(LoginRecord.ID.like('%{}%'.format(search_key)),
LoginRecord.name.like('%{}%'.format(search_key)),
LoginRecord.ip_address.like('%{}%'.format(search_key)),
LoginRecord.login_date.like('%{}%'.format(search_key)))
).order_by(
LoginRecord.ID
).all()
else:
login_info = session.query(LoginRecord).order_by(
LoginRecord.ID
).all()
if login_info:
for data in login_info:
data_dict = model_to_dict(data)
login_list.append(data_dict)
return login_list
def get(self, *args, **kwargs):
value = self.get_argument('value', default=None, strip=True)
db_list = []
with DBContext('r') as session:
db_info = session.query(DB).outerjoin(
DBTag, DB.id == DBTag.db_id).outerjoin(
Tag, Tag.id == DBTag.tag_id).filter(
Tag.tag_name == str(value),
DB.db_type == 'mysql').all()
proxy_host = session.query(
Tag.proxy_host).filter(Tag.tag_name == value).first()[0]
if not proxy_host:
return self.write(dict(code=-1, msg='请给选择标签添加代理主机'))
for msg in db_info:
data_dict = model_to_dict(msg)
db_list.append(data_dict['db_code'])
### 这里需要获取库 未完成
if len(db_list) == 0:
return self.write(dict(code=-2, msg='当前标签下没有MySQL库'))
self.write(dict(code=0, msg='获取成功', data=db_list))
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
event_name = data.get('event_name', None)
event_status = data.get('event_status', None)
event_level = data.get('event_level', None)
event_processing = data.get('event_processing', None)
event_start_time = data.get('event_start_time', None)
event_end_time = data.get('event_end_time', None)
if not event_name or not event_status or not event_level or not event_processing or not event_start_time or not event_end_time:
return self.write(dict(code=-2, msg='关键参数不能为空'))
update_info = {
"event_status": event_status,
"event_level": event_level,
"event_processing": event_processing,
"event_start_time": event_start_time,
"event_end_time": event_end_time,
}
if re.search('000Z', event_start_time):
event_start_time = datetime.datetime.strptime(
event_start_time,
"%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8)
update_info['event_start_time'] = event_start_time
if re.search('000Z', event_end_time):
event_end_time = datetime.datetime.strptime(
event_end_time,
"%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8)
update_info['event_end_time'] = event_end_time
with DBContext('w', None, True) as session:
session.query(EventRecord).filter(
EventRecord.event_name == event_name).update(update_info)
self.write(dict(code=0, msg='更新成功'))
def patch(self, *args, **kwargs):
# 启用 暂停
data = json.loads(self.request.body.decode("utf-8"))
domain_id = data.get('domain_id')
domain_state = data.get('domain_state')
if not domain_id or not domain_state:
return self.write(dict(code=1, msg='关键参数不能为空'))
with DBContext('w', None, True) as session:
session.query(DNSDomainName).filter(
DNSDomainName.domain_id == domain_id).update(
{DNSDomainName.domain_state: domain_state})
### log
domain_info = session.query(DNSDomainName).filter(
DNSDomainName.domain_id == domain_id).first()
log_msg = '{}：{} 用户：{}'.format(domain_state,
domain_info.domain_name,
self.get_current_nickname())
session.add(
DNSDomainLog(domain_name=domain_info.domain_name,
log_data=log_msg))
self.write(dict(code=0, msg='{}成功'.format(domain_state)))
def sync_host_usage_from_zabbix():
uz = UserZbx()
usage_info = uz.get_ec2_usage_info()
d = (datetime.now() - timedelta(days=1)).replace(hour=0,
minute=0,
second=0,
microsecond=0)
with DBContext('w', const.DEFAULT_DB_KEY, need_commit=True) as session:
for k, v in usage_info.items():
exist_usage = session \
.query(ResourceUsage) \
.filter(ResourceUsage.ec2_id == v["ec2_id"],
ResourceUsage.date == d,
).first()
if exist_usage:
session \
.query(ResourceUsage) \
.filter(ResourceUsage.ec2_id == v["ec2_id"],
ResourceUsage.date == d,
).update(
{
ResourceUsage.ec2_id: v["ec2_id"],
ResourceUsage.cpu_usage: v["cpu"],
ResourceUsage.mem_usage: v["mem"],
ResourceUsage.disk_usage: v["disk"],
ResourceUsage.date: d,
}
)
else:
new_record = ResourceUsage(ec2_id=v["ec2_id"],
cpu_usage=v["cpu"],
mem_usage=v["mem"],
disk_usage=v["disk"],
date=d)
session.add(new_record)
session.commit()
def delete(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
the_id = data.get('the_id')
tag_index = data.get('tag_index')
with DBContext('w', None, True) as session:
hook_info = session.query(GitRepo.git_hooks).filter(GitRepo.id == the_id).first()
if not hook_info:
return self.write(dict(code=-1, msg='No related items were found'))
if not hook_info[0]:
return self.write(dict(code=-2, msg='No hooks, ignore'))
else:
try:
hook_dict = json.loads(hook_info[0])
except Exception as e:
session.query(GitRepo).filter(GitRepo.id == the_id).update({GitRepo.git_hooks: ""})
return self.write(dict(code=2, msg='钩子出错'))
hook_dict.pop(tag_index)
hook_dict = json.dumps(hook_dict)
session.query(GitRepo).filter(GitRepo.id == the_id).update({GitRepo.git_hooks: hook_dict})
self.write(dict(code=0, msg='删除成功'))
def get(self, *args, **kwargs):
key = self.get_argument('key', default=None, strip=True)
value = self.get_argument('value', default=None, strip=True)
asset_configs_list = []
with DBContext('r') as session:
if key and value:
asset_configs_data = session.query(AssetConfigs).filter_by(
**{
key: value
}).all()
else:
asset_configs_data = session.query(AssetConfigs).all()
for data in asset_configs_data:
data_dict = model_to_dict(data)
data_dict['create_time'] = str(data_dict['create_time'])
data_dict['update_time'] = str(data_dict['update_time'])
# 解密AccessKey
if data_dict.get('access_key'):
data_dict['access_key'] = mc.my_decrypt(
data_dict.get('access_key'))
asset_configs_list.append(data_dict)
return self.write(dict(code=0, msg='获取成功', data=asset_configs_list))
def put(self, *args, **kwargs):
"""管理员修改标签value数据接口"""
tag_key = self.get_argument('tag_key', default=None, strip=True)
services_name = self.get_argument('services_name',
default=None,
strip=True)
resource_id = self.get_argument('resource_id',
default=None,
strip=True)
tag_value = self.get_argument('tag_value', default=None, strip=True)
with DBContext('w') as session:
tag_info = session.query(ResultList).filter_by(
services_name=services_name,
services_resource_id=resource_id,
key=tag_key).first()
tag_info.value = tag_value
session.commit()
# 把修改的数据记录到修改数据库
new_order_tag = ChangeResultList(key=tag_key,
services_name=services_name,
services_resource_id=resource_id,
value=tag_value)
session.add(new_order_tag)
session.commit()
def post(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
alias_name = data.get('alias_name')
cloud_name = data.get('cloud_name')
cloud_code = data.get('cloud_code')
access_id = data.get('access_id')
access_key = data.get('access_key')
if not alias_name or not cloud_name or not access_id or not access_key:
return self.write(dict(code=-1, msg='关键参数不能为空'))
with DBContext('w', None, True) as session:
is_exist = session.query(DomainCloudConf.id).filter(
DomainCloudConf.alias_name == alias_name).first()
if is_exist:
return self.write(dict(code=-2, msg='当前账号已经存在，别名不能重复'))
session.add(
DomainCloudConf(alias_name=alias_name,
cloud_name=cloud_name,
cloud_code=cloud_code,
access_id=access_id,
access_key=access_key))
self.write(dict(code=0, msg='添加成功'))
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
project_name = data.get('project_name', None)
project_status = data.get('project_status', None)
project_requester = data.get('project_requester', None)
project_processing = data.get('project_processing', None)
project_start_time = data.get('project_start_time', None)
project_end_time = data.get('project_end_time', None)
if not project_name or not project_status or not project_requester or not project_processing or not project_start_time or not project_end_time:
return self.write(dict(code=-2, msg='关键参数不能为空'))
update_info = {
"project_status": project_status,
"project_requester": project_requester,
"project_processing": project_processing,
"project_start_time": project_start_time,
"project_end_time": project_end_time,
}
if re.search('000Z', project_start_time):
project_start_time = datetime.datetime.strptime(
project_start_time,
"%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8)
update_info['project_start_time'] = project_start_time
if re.search('000Z', project_end_time):
project_end_time = datetime.datetime.strptime(
project_end_time,
"%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(hours=8)
update_info['project_end_time'] = project_end_time
with DBContext('w', None, True) as session:
session.query(ProjectMG).filter(
ProjectMG.project_name == project_name).update(update_info)
self.write(dict(code=0, msg='更新成功'))
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))
