def get(self):
mysql_conn = getConn()
groupObj = []
try:
sql = '''
select id,groupName from custom_group where grouptype = 2
'''
resp = mysql_conn.query(sql)
for id, name in resp:
groupObj.append({'id': id, 'name': name})
except Exception as e:
groupObj = []
ins_log.read_log('error', e)
db_list = []
try:
sql = '''
select id,db_code from codo_cmdb.asset_db
'''
resp = mysql_conn.query(sql)
for id, name in resp:
db_list.append({'id': id, 'name': name})
except Exception as e:
db_list = []
ins_log.read_log('error', e)
return self.write(dict(code=0, groupObj=groupObj, db_list=db_list))
def get(self, *args, **kwargs):
report_na = self.get_argument('report_na', default=None, strip=True)
report_val = self.get_argument('report_val', default=None, strip=True)
dict_list = []
Base_DIR = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
dir_path = '{}/static/report/{}/'.format(Base_DIR, report_val)
try:
root, dirs, files = os.walk(dir_path).__next__()
for f in files:
filename = dir_path + f
df = pd.read_excel(filename)
columns = []
num = 1
for k in list(df.columns.values[1:]):
columns_temp = {"title": '', "key": '', "align": 'center'}
columns_temp["title"] = str(k)
columns_temp["key"] = "number" + str(num)
columns.append(columns_temp)
num = num + 1
ins_log.read_log('info',
"11111111111111111111111111111111111111")
ins_log.read_log('info', columns)
all_list = []
for d in df.values:
temp_dict = {}
num = 1
for k in list(d[1:]):
tokey = "number" + str(num)
temp_dict[tokey] = str(k)
num = num + 1
all_list.append(temp_dict)
obj = {
'file_na':
f,
'file_size':
'{}{}'.format(get_FileSize(os.path.join(root, f)), 'KB'),
'ctime':
get_FileCreateTime(os.path.join(root, f)),
'url':
'http://{}/static/report/{}/{}'.format(
self.request.host, report_val, f),
'columns':
str(columns),
'file_data':
str(all_list),
}
# ins_log.read_log('info', "22222222222222222222222222222222222")
# ins_log.read_log('info', obj)
dict_list.append(obj)
dict_list.sort(key=lambda x: x['ctime'], reverse=True)
except:
traceback.print_exc()
return self.write(dict(code=-1, msg='获取失败', data=dict_list))
if len(dict_list) == 0:
return self.write(dict(code=-2, msg='没有文件', data=dict_list))
return self.write(dict(code=0, msg='获取成功', data=dict_list))
def delete(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_nickname()
db_id = data.get('db_id', None)
id_list = data.get('id_list', None)
# 记录操作,不成功直接Pass
try:
with DBContext('w', None, True) as session:
if db_id:
data_info = session.query(DB).filter(
DB.id == int(db_id)).all()
for data in data_info:
origion_data = model_to_dict(data)
origion_data['create_time'] = str(
origion_data['create_time'])
origion_data['update_time'] = str(
origion_data['update_time'])
new_record = AssetOperationalAudit(
username=nickname,
request_object='数据库',
request_host=origion_data.get('db_host'),
request_method='删除',
original_data=origion_data)
session.add(new_record)
elif id_list:
for i in id_list:
data_info = session.query(DB).filter(DB.id == i).all()
for data in data_info:
origion_data = model_to_dict(data)
origion_data['create_time'] = str(
origion_data['create_time'])
origion_data['update_time'] = str(
origion_data['update_time'])
new_record = AssetOperationalAudit(
username=nickname,
request_object='数据库',
request_host=origion_data.get('db_host'),
request_method='删除',
original_data=origion_data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error',
'operational_audit error:{err}'.format(err=err))
with DBContext('w', None, True) as session:
if db_id:
session.query(DB).filter(DB.id == int(db_id)).delete(
synchronize_session=False)
session.query(DBTag).filter(DBTag.db_id == int(db_id)).delete(
synchronize_session=False)
elif id_list:
for i in id_list:
session.query(DB).filter(DB.id == i).delete(
synchronize_session=False)
session.query(DBTag).filter(DBTag.db_id == i).delete(
synchronize_session=False)
else:
return self.write(dict(code=1, msg='关键参数不能为空'))
return self.write(dict(code=0, msg='删除成功'))
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_nickname()
server_id = data.get('id', None)
hostname = data.get('hostname', None)
ip = data.get('ip', None)
public_ip = data.get('public_ip', None)
port = data.get('port', None)
idc = data.get('idc', None)
admin_user = data.get('admin_user', None)
region = data.get('region', None)
tag_list = data.get('tag_list', [])
detail = data.get('detail', None)
if not hostname or not ip or not port:
return self.write(dict(code=-1, msg='关键参数不能为空'))
if not admin_user:
return self.write(dict(code=-1, msg='管理用户不能为空'))
if not check_ip(ip):
return self.write(dict(code=-1, msg="IP格式不正确"))
if not type(port) is int and int(port) >= 65535:
return self.write(dict(code=-1, msg="端口格式不正确"))
with DBContext('w', None, True) as session:
exist_hostname = session.query(Server.hostname).filter(Server.id == server_id).first()
if exist_hostname[0] != hostname:
return self.write(dict(code=-2, msg='主机名不能修改'))
session.query(ServerTag).filter(ServerTag.server_id == server_id).delete(synchronize_session=False)
all_tags = session.query(Tag.id).filter(Tag.tag_name.in_(tag_list)).order_by(Tag.id).all()
if all_tags:
for tag_id in all_tags:
session.add(ServerTag(server_id=server_id, tag_id=tag_id[0]))
session.query(Server).filter(Server.id == server_id).update({Server.hostname: hostname, Server.ip: ip,
Server.port: int(port),
Server.public_ip: public_ip,
Server.idc: idc,
Server.admin_user: admin_user,
Server.region: region, Server.detail: detail
}) # Server.state: 'new'
# 记录操作,不成功直接Pass
try:
modify_data = data
with DBContext('w', None, True) as session:
data_info = session.query(Server).filter(Server.id == int(server_id)).all()
for data in data_info:
origion_data = model_to_dict(data)
origion_data['create_time'] = str(origion_data['create_time'])
origion_data['update_time'] = str(origion_data['update_time'])
new_record = AssetOperationalAudit(username=nickname, request_object='主机', request_host=ip,
request_method='更新', original_data=origion_data,
modify_data=modify_data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error', 'operational_audit error:{err}'.format(err=err))
return self.write(dict(code=0, msg='编辑成功'))
def asset_update(self, id_list):
# time.sleep(20) #测试下阻塞
server_list = []
# 检查下状态，是true的话直接推送资产
with DBContext('r', None, True) as session:
for i in id_list:
server_info = session.query(
Server.ip, Server.port, AdminUser.system_user,
AdminUser.user_key, Server.state).outerjoin(
AdminUser,
AdminUser.admin_user == Server.admin_user).filter(
Server.id == i).all()
server_list.append(server_info)
# server_info = [('47.100.231.147', 22, 'root', '-----BEGIN RSA PRIVATE KEYxxxxxEND RSA PRIVATE KEY-----', 'false')]
server_state = server_info[0][4]
if server_state == 'true':
ins_log.read_log('info', 'update asset info')
# 选中的是true，直接更新资产
asset_data = get_server_sysinfo(server_list)
update_asset(asset_data)
else:
# 选中的是其余的状态，那就先推送key, 拿到推送成功的key，更新资产
ins_log.read_log('info',
'rsync public key , update asset info')
rsync_sucess_list = rsync_public_key(server_list)
if rsync_sucess_list:
asset_data = get_server_sysinfo(server_list)
update_asset(asset_data)
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_nickname()
db_id = data.get('id', None)
db_code = data.get('db_code', None)
db_host = data.get('db_host', None)
db_port = data.get('db_port', 3306)
db_user = data.get('db_user', None)
db_pwd = data.get('db_pwd', None)
db_env = data.get('db_env', None)
proxy_host = data.get('proxy_host', None)
db_type = data.get('db_type', 'mysql')
db_version = data.get('db_version', None)
db_mark = data.get('db_mark', '写')
idc = data.get('idc', None)
tag_list = data.get('tag_list', [])
db_detail = data.get('db_detail', None)
db_instance = data.get('db_instance', '')
if not db_id or not db_code or not db_host or not db_port or not db_user:
return self.write(dict(code=-1, msg='关键参数不能为空'))
with DBContext('r') as session:
old_password = session.query(DB.db_pwd).filter(DB.id == int(db_id)).first()[0]
if old_password != db_pwd:
# 加密密码
db_pwd = encrypt(db_pwd)
with DBContext('w', None, True) as session:
all_tags = session.query(Tag.id).filter(Tag.tag_name.in_(tag_list)).order_by(Tag.id).all()
session.query(DBTag).filter(DBTag.db_id == db_id).delete(synchronize_session=False)
if all_tags:
for tag_id in all_tags:
session.add(DBTag(db_id=int(db_id), tag_id=tag_id[0]))
session.query(DB).filter(DB.id == int(db_id)).update({DB.db_code: db_code, DB.db_host: db_host,
DB.db_port: db_port, DB.db_user: db_user,
DB.db_pwd: db_pwd, DB.db_env: db_env,
DB.proxy_host: proxy_host, DB.db_type: db_type,
DB.db_version: db_version, DB.idc: idc,
DB.db_mark: db_mark, DB.db_detail: db_detail,
DB.db_instance: db_instance
})
# 记录操作,不成功直接Pass
try:
modify_data = data
with DBContext('w', None, True) as session:
data_info = session.query(DB).filter(DB.id == int(db_id)).all()
for data in data_info:
origion_data = model_to_dict(data)
origion_data['create_time'] = str(origion_data['create_time'])
origion_data['update_time'] = str(origion_data['update_time'])
new_record = AssetOperationalAudit(username=nickname, request_object='数据库', request_host=db_host,
request_method='更新', original_data=origion_data,
modify_data=modify_data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error', 'operational_audit error:{err}'.format(err=err))
return self.write(dict(code=0, msg='编辑成功'))
async def post(self, *args, **kwargs):
# data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_user() # 这里使用useame 不用中文
#if not self.is_superuser: return self.write(dict(code=-1, msg='你不是超级超级管理员,不能使用WebTerminal'))
connect_server_info = dict()
connect_server_info['nickname'] = nickname
# 数据加密给Jimmy
mc = MyCryptV2()
# 加密数据
# encrypt_data = mc.my_encrypt(str(connect_server_info))
encrypt_data = mc.my_encrypt(str(connect_server_info))
print(encrypt_data)
ins_log.read_log('info', '加密后的数据是：{}'.format(encrypt_data))
try:
web_terminal_initialssh = '{0}/webterminal/initiallogin/'.format(WEB_TERMINAL)
the_body = json.dumps(encrypt_data)
http_client = httpclient.AsyncHTTPClient()
response = await http_client.fetch(web_terminal_initialssh, method="POST", body=the_body,
raise_error=False)
response_data = json.loads(response.body.decode('utf-8'))
if not response_data.get('status'):
return self.write(dict(code=1, msg=response_data.get('message')))
# 返回信息
web_terminal_key = response_data['key']
web_terminal_url = '{0}/logslist/'.format(WEB_TERMINAL)
res_data = {
"web_terminal_url": web_terminal_url,
"web_terminal_key": web_terminal_key
}
except Exception as e:
ins_log.read_log('error', '请求webterminal接口出错:{err}'.format(err=e))
return self.write(dict(code=1, msg='请求webterminal接口出错:{err}'.format(err=e)))
return self.write(dict(code=0, msg='Sucessfully', data=res_data))
def delete(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
id = data.get('id')
nickname = self.get_current_nickname()
if not id:
return self.write(dict(code=-2, msg='关键参数不能为空'))
# 记录操作,不成功直接Pass
try:
with DBContext('w', None, True) as session:
data_info = session.query(AssetIDC).filter(
AssetIDC.id == id).all()
for data in data_info:
origion_data = model_to_dict(data)
new_record = AssetOperationalAudit(
username=nickname,
request_object='IDC',
request_host=origion_data.get('name'),
request_method='删除',
original_data=origion_data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error',
'operational_audit error:{err}'.format(err=err))
with DBContext('w', None, True) as session:
session.query(AssetIDC).filter(AssetIDC.id == id).delete(
synchronize_session=False)
self.write(dict(code=0, msg='删除成功'))
def post(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_nickname()
# 列表包str格式，str空格切割
if not data:
return self.write(dict(code=-1, msg='不能为空'))
# 记录下操作，即使报错也不影响程序
try:
with DBContext('w', None, True) as session:
new_record = AssetOperationalAudit(username=nickname,
request_object='主机',
request_method='批量添加',
modify_data=data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error',
'operational_audit error:{err}'.format(err=err))
# 判断下格式长度
with DBContext('w', None, True) as session:
for i in data:
if i:
server_info = i.split(' ')
ins_log.read_log(
'info', 'MultiServer:{server_info}'.format(
server_info=server_info))
if len(server_info) != 4:
return self.write(dict(code=-2, msg='格式错误'))
hostname = server_info[0]
ip = server_info[1]
port = server_info[2]
admin_user = server_info[3]
if not check_ip(ip):
return self.write(dict(code=-1, msg="IP格式不正确"))
if not type(port) is int and int(port) >= 65535:
return self.write(dict(code=-1, msg="端口格式不正确"))
exist_id = session.query(
Server.id).filter(Server.hostname == hostname).first()
exist_ip = session.query(
Server.id).filter(Server.ip == ip).first()
if exist_id or exist_ip:
return self.write(
dict(code=-2,
msg='IP:{ip}/Hostname:{hostname}已经存在,不要重复记录'.
format(ip=ip, hostname=hostname)))
new_server = Server(hostname=hostname,
ip=ip,
port=int(port),
admin_user=admin_user)
session.add(new_server)
session.commit()
return self.write(dict(code=0, msg='批量添加成功'))
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_nickname()
id = data.get('id', None)
name = data.get('name', None)
contact = data.get('contact', None)
email = data.get('email', None)
phone = data.get('phone', None)
address = data.get('address', None)
network = data.get('network', None)
bandwidth = data.get('bandwidth', None)
ip_range = data.get('ip_range', None)
remarks = data.get('remarks', None)
if not id or not name:
return self.write(dict(code=-2, msg='关键参数不能为空'))
if email and not is_mail(email):
return self.write(dict(code=-2, msg='Email格式不正确'))
if phone and not is_tel(phone):
return self.write(dict(code=-2, msg='Phone格式不正确'))
with DBContext('r') as session:
exist_name = session.query(AssetIDC.name).filter(AssetIDC.id == id).first()
if name != exist_name[0]:
return self.write(dict(code=-2, msg='名称不能修改'))
# 记录操作,不成功直接Pass
try:
modify_data = data
with DBContext('w', None, True) as session:
data_info = session.query(AssetIDC).filter(AssetIDC.id == id).all()
for data in data_info:
origion_data = model_to_dict(data)
new_record = AssetOperationalAudit(username=nickname, request_object='IDC', request_host=name,
request_method='更新', original_data=origion_data,
modify_data=modify_data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error', 'operational_audit error:{err}'.format(err=err))
update_info = {
"contact": contact,
"email": email,
"phone": phone,
"address": address,
"network": network,
"bandwidth": bandwidth,
"ip_range": ip_range,
"remarks": remarks,
}
with DBContext('w', None, True) as session:
session.query(AssetIDC).filter(AssetIDC.name == name).update(update_info)
self.write(dict(code=0, msg='更新成功'))
def server_api(self, account, region, access_id, access_key, project_id,
huawei_cloud, huawei_instance_id):
"""
测试各厂商server API的权限
:return:
"""
# 收集测试错误日志
err_msg = ''
# 测试接口的时候默认管理用户不需要
default_admin_user = ''
if account == 'AWS':
ins_log.read_log('info', 'AWS EC2 API TEST')
obj = Ec2Api(access_id, access_key, region, default_admin_user)
try:
obj.test_auth()
except Exception as e:
err_msg = 'Error：{}'.format(e)
elif account == '阿里云':
ins_log.read_log('info', 'Aliyun ECS API TEST')
obj = EcsAPi(access_id, access_key, region, default_admin_user)
try:
obj.test_auth()
except Exception as e:
err_msg = 'Error：{}'.format(e)
elif account == '腾讯云':
ins_log.read_log('info', 'Qcloud CVM API TEST')
obj = CVMApi(access_id, access_key, region, default_admin_user)
try:
result_data = obj.test_auth()
if result_data['Response'].get('Error'):
err_msg = 'Error：{}'.format(result_data['Response'])
except Exception as e:
ins_log.read_log('error', e)
elif account == '华为云':
ins_log.read_log('info', 'HuaweiCloud ECS API TEST')
obj = HuaweiEcsApi(access_id=access_id,
access_key=access_key,
region=region,
cloud=huawei_cloud,
project_id=project_id,
default_admin_user=default_admin_user)
try:
obj.test_auth(huawei_instance_id)
except keystoneauth1.exceptions.http.Unauthorized:
err_msg = '请检查AccessID和AccessKey权限是否正确'
except openstack.exceptions.HttpException as err:
err_msg = 'openstack error {}'.format(err)
except Exception as e:
print(e)
err_msg = 'error: {}'.format(e)
else:
err_msg = 'In Development.'
return err_msg
def get(self, *args, **kwargs):
# nickname = self.get_current_nickname()
id = self.get_argument('id', default=None, strip=True)
if not id:
return self.write(dict(code=-1, msg='关键参数不能为空'))
server_list = []
admin_user_list = []
connect_server_info_list = []
with DBContext('r') as session:
server_info = session.query(Server).filter(
Server.id == id).filter()
for msg in server_info:
data_dict = model_to_dict(msg)
server_list.append(data_dict)
data_dict['create_time'] = str(data_dict['create_time'])
data_dict['update_time'] = str(data_dict['update_time'])
if not server_list:
return self.write(dict(code=-1, msg='没有发现IP'))
admin_user = server_list[0]['admin_user']
if not admin_user:
return self.write(dict(code=-1, msg='此机器没有配置管理用户，请先配置管理用户'))
admin_user_info = session.query(AdminUser).filter(
AdminUser.admin_user == admin_user).filter()
for admin_user_msg in admin_user_info:
data_dict = model_to_dict(admin_user_msg)
data_dict['update_time'] = str(data_dict['update_time'])
admin_user_list.append(data_dict)
try:
connect_server_info = dict()
connect_server_info['ip'] = server_list[0].get('ip')
connect_server_info['public_ip'] = server_list[0].get(
'public_ip')
connect_server_info['private_ip'] = server_list[0].get(
'private_ip')
connect_server_info['port'] = server_list[0].get('port')
connect_server_info['admin_user'] = server_list[0].get(
'admin_user')
connect_server_info['system_user'] = admin_user_list[0].get(
'system_user')
connect_server_info['user_key'] = admin_user_list[0].get(
'user_key')
connect_server_info_list.append(connect_server_info)
except (IndexError, KeyError) as err:
ins_log.read_log('error', '解析的时候出错:{err}'.format(err=err))
return False
return self.write(
dict(code=0, msg='获取成功', data=connect_server_info_list))
def post(self):
red_data = {}
try:
data = json.loads(self.request.body.decode("utf-8"))
mysql_conn = getConn()
if not data['qid']:
try:
sql = '''
select max(id) from custom_query
'''
resp = mysql_conn.query(sql)
mid = resp[0][0]
new_id = int(mid) + 1
data['qid'] = new_id
except:
data['qid'] = 1
colnames = json.dumps(data['colnames'])
colalarms = json.dumps(data['colalarms'])
sql = '''
replace into `custom_query`(`id`, `title`, `dblinkId`, `database`, `user`,
`password`, `sql`, `colnames`, `timesTy`, `timesTyVal`, `colalarms`, `status`,
`create_time`, `update_time`, `description`, `seq`, `groupID`)
values ({id},'{title}',{dblinkId},'{database}','{user}','{password}',"{sql}",
'{colnames}','{timesTy}','{timesTyVal}','{colalarms}','{status}','{create_time}','{update_time}',
'{description}',{seq},'{groupID}')
'''.format(id=data['qid'], title=data['title'], dblinkId=data['dblinkId'], database=data['database'],
user=data['user'], password=data['password'], sql=data['sql'],
colnames=colnames.replace("\\", "\\\\"), timesTy=data['timesTy'],
timesTyVal=data['timesTyVal'], colalarms=colalarms.replace("\\", "\\\\"), status=data['status'],
create_time=data['create_time'], update_time=str(datetime.datetime.now()),
description=data['description'], seq=data['seq'], groupID=data['groupID'])
res = mysql_conn.change(sql)
if res > 0:
# 返回qid，并更新qid
red_data[data['id']] = data['qid']
# 更新组排序
try:
groupSeq = data['group2ndSeq']
groupName = data['groupName']
sql = '''
UPDATE custom_group set groupSeq = {} where groupName = '{}'
'''.format(groupSeq, groupName)
mysql_conn.change(sql)
except Exception as e:
ins_log.read_log('error', e)
except Exception as e:
ins_log.read_log('error', e)
return self.write(dict(code=-1, msg='failed', data=red_data, err='%s' % e))
return self.write(dict(code=0, msg='success', data=red_data))
def post(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_nickname()
hostname = data.get('hostname', None)
ip = data.get('ip', None)
port = data.get('port', 22)
public_ip = data.get('public_ip', None)
idc = data.get('idc', None)
admin_user = data.get('admin_user', None)
region = data.get('region', None)
state = data.get('state', 'new')
tag_list = data.get('tag_list', [])
detail = data.get('detail', None)
if not hostname or not ip or not port:
return self.write(dict(code=-1, msg='关键参数不能为空'))
if not admin_user:
return self.write(dict(code=-1, msg='管理用户不能为空'))
if not check_ip(ip):
return self.write(dict(code=-1, msg="IP格式不正确"))
if not type(port) is int and int(port) >= 65535:
return self.write(dict(code=-1, msg="端口格式不正确"))
with DBContext('r') as session:
exist_id = session.query(Server.id).filter(Server.hostname == hostname).first()
exist_ip = session.query(Server.id).filter(Server.ip == ip).first()
if exist_id or exist_ip:
return self.write(dict(code=-2, msg='不要重复记录'))
with DBContext('w', None, True) as session:
new_server = Server(hostname=hostname, ip=ip, public_ip=public_ip, port=int(port), idc=idc,
admin_user=admin_user, region=region, state=state, detail=detail)
session.add(new_server)
all_tags = session.query(Tag.id).filter(Tag.tag_name.in_(tag_list)).order_by(Tag.id).all()
# print('all_tags', all_tags)
if all_tags:
for tag_id in all_tags:
session.add(ServerTag(server_id=new_server.id, tag_id=tag_id[0]))
# 记录,记录错误也不要影响用户正常添加
try:
with DBContext('w', None, True) as session:
new_record = AssetOperationalAudit(username=nickname, request_object='主机', request_host=ip,
request_method='新增', modify_data=data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error', 'operational_audit error:{err}'.format(err=err))
return self.write(dict(code=0, msg='添加成功'))
def post(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_nickname()
db_code = data.get('db_code', None)
db_host = data.get('db_host', None)
db_port = data.get('db_port', 3306)
db_user = data.get('db_user', None)
db_pwd = data.get('db_pwd', None)
db_env = data.get('db_env', None)
proxy_host = data.get('proxy_host', None)
db_type = data.get('db_type', 'mysql')
db_version = data.get('db_version', None)
db_mark = data.get('db_mark', '写')
tag_list = data.get('tag_list', [])
db_detail = data.get('db_detail', None)
db_instance = data.get('db_instance', '')
if not db_code or not db_host or not db_port or not db_user:
return self.write(dict(code=-1, msg='关键参数不能为空'))
with DBContext('r') as session:
exist_id = session.query(DB.id).filter(DB.db_code == db_code, DB.db_host == db_host, DB.db_port == db_port,
DB.db_user == db_user, DB.db_env == db_env,
DB.proxy_host == proxy_host, DB.db_type == db_type,
db_version == db_version,
DB.db_mark == db_mark).first()
if exist_id:
return self.write(dict(code=-2, msg='不要重复记录'))
# 加密密码
db_pwd = encrypt(db_pwd)
with DBContext('w', None, True) as session:
new_db = DB(db_code=db_code, db_host=db_host, db_port=db_port, db_user=db_user, db_pwd=db_pwd,
db_env=db_env, proxy_host=proxy_host, db_type=db_type, db_version=db_version, db_mark=db_mark,
db_detail=db_detail, db_instance=db_instance)
session.add(new_db)
all_tags = session.query(Tag.id).filter(Tag.tag_name.in_(tag_list)).order_by(Tag.id).all()
if all_tags:
for tag_id in all_tags:
session.add(DBTag(db_id=new_db.id, tag_id=tag_id[0]))
# 记录,记录错误也不要影响用户正常添加
try:
with DBContext('w', None, True) as session:
new_record = AssetOperationalAudit(username=nickname, request_object='数据库', request_host=db_host,
request_method='新增', modify_data=data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error', 'operational_audit error:{err}'.format(err=err))
return self.write(dict(code=0, msg='添加成功'))
def post(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_nickname()
# 列表包str格式，str空格切割
if not data:
return self.write(dict(code=-1, msg='不能为空'))
# 记录下操作，即使报错也不影响程序
try:
with DBContext('w', None, True) as session:
new_record = AssetOperationalAudit(username=nickname, request_object='数据库',
request_method='批量添加', modify_data=data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error', 'operational_audit error:{err}'.format(err=err))
# 判断下格式长度
with DBContext('w', None, True) as session:
for i in data:
if i:
db_info = i.split(' ')
ins_log.read_log('info', 'MultiDB:{db_info}'.format(db_info=db_info))
if len(db_info) != 6:
return self.write(dict(code=-2, msg='格式错误'))
db_type = db_info[0]
db_name = db_info[1]
db_host = db_info[2]
db_port = db_info[3]
db_user = db_info[4]
db_passwd = db_info[5]
if not type(db_port) is int and int(db_port) >= 65535:
return self.write(dict(code=-1, msg="端口格式不正确"))
exist_id = session.query(DB.id).filter(DB.db_code == db_name).first()
exist_ip = session.query(DB.id).filter(DB.db_host == db_host).first()
if exist_id or exist_ip:
return self.write(
dict(code=-2,
msg='IP:{address}/Hostname:{hostname}已经存在,不要重复记录'.format(address=db_host,
hostname=db_name)))
new_db = DB(db_code=db_name, db_host=db_host, db_port=db_port, db_user=db_user, db_type=db_type,
db_pwd=db_passwd, state='Handle')
session.add(new_db)
session.commit()
return self.write(dict(code=0, msg='批量添加成功'))
def get(self, *args, **kwargs):
ipstr = self.get_argument('key', default=None)
cardstr = self.get_argument('value', default=None)
cardtype = str(cardstr)
ip_list = [ipstr]
serverObjList = get_serverObjList(ip_list)
asb = AnsiableAPI(connection='smart', hostsresource=serverObjList)
# 获取卡片数据
cardlist = []
if cardtype == '0':
carddict = getcard0(ipstr, asb) # 主机基本信息
cardlist.append(carddict)
if cardtype == '1':
carddict = getcard1(ipstr, asb) # 文件分区使用情况
cardlist.append(carddict)
if cardtype == '2':
carddict = getcard2(ipstr, asb) # 文件分区使用情况
cardlist.append(carddict)
# asb.run(hosts=ipstr, module="shell", args='uptime')
# stdout_dict = json.loads(asb.get_result())
ins_log.read_log('info', "1222222222222222222222000000000000000000000")
ins_log.read_log('info', cardlist)
ins_log.read_log('info',
"11111111111111111100000000000000000000000000")
if len(cardlist) > 0:
ins_log.read_log('info', "13333333333333333333333333")
self.write(dict(code=0, msg='获取報告成功', count=1, data=cardlist))
else:
self.write(dict(code=-1, msg='没有相关数据', count=0, data=[]))
def post(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
nickname = self.get_current_nickname()
name = data.get('name', None)
contact = data.get('contact', None)
email = data.get('email', None)
phone = data.get('phone', None)
address = data.get('address', None)
network = data.get('network', None)
bandwidth = data.get('bandwidth', None)
ip_range = data.get('ip_range', None)
remarks = data.get('remarks', None)
if not name:
return self.write(dict(code=-2, msg='关键参数不能为空'))
if email and not is_mail(email):
return self.write(dict(code=-2, msg='Email格式不正确'))
if phone and not is_tel(phone):
return self.write(dict(code=-2, msg='Phone格式不正确'))
with DBContext('r') as session:
exist_name = session.query(AssetIDC.id).filter(AssetIDC.name == name).first()
count = session.query(AssetIDC).count()
if exist_name:
return self.write(dict(code=-2, msg='不要重复记录'))
if count > 50:
return self.write(dict(code=-2, msg='IDC最大只允许50个'))
with DBContext('w', None, True) as session:
new_idc = AssetIDC(name=name, contact=contact, email=email, phone=phone, address=address, network=network,
bandwidth=bandwidth, ip_range=ip_range, remarks=remarks)
session.add(new_idc)
# 记录,记录错误也不要影响用户正常添加
try:
with DBContext('w', None, True) as session:
new_record = AssetOperationalAudit(username=nickname, request_object='IDC', request_host=name,
request_method='新增', modify_data=data)
session.add(new_record)
except Exception as err:
ins_log.read_log('error', 'operational_audit error:{err}'.format(err=err))
return self.write(dict(code=0, msg='添加成功'))
def getGroupInfo(self, gid):
groupName = ''
group2ndSeq = 0
try:
mysql_conn = getConn()
sql = '''
select groupName,groupSeq from custom_group where id = %s
''' % gid
resp = mysql_conn.query(sql)
for name, seq in resp:
groupName = name
group2ndSeq = seq
except Exception as e:
ins_log.read_log('error', e)
return [groupName, group2ndSeq]
def asset_update(self, id_list):
# 检查下状态，是true的话直接推送资产
with DBContext('r', None, True) as session:
for i in id_list:
server_list = session.query(Server.ip, Server.port, AdminUser.system_user,
AdminUser.user_key, Server.state).outerjoin(AdminUser,
AdminUser.admin_user == Server.admin_user).filter(
Server.id == i).all()
# server_list = [('47.100.231.147', 22, 'root', '-----BEGIN RSA PRIVATE KEYxxxxxEND RSA PRIVATE KEY-----', 'false')]
ins_log.read_log('info', '手动触发更新资产')
rsync_sucess_list = rsync_public_key(server_list)
if rsync_sucess_list:
asset_data = get_server_sysinfo(server_list)
ins_log.read_log('info', '资产信息：{}'.format(asset_data))
update_asset(asset_data)
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
status = data.get('status')
s3_name = data.get('name')
remark = data.get('remark')
if not remark:
return self.write(dict(code=-1, msg='mark内容不能为空'))
ins_log.read_log("info", s3_name)
with DBContext('w', None) as session:
session.query(S3).filter(S3.bucket_name == s3_name).update({
S3.bucket_remark: remark, S3.bucket_mark:int(status)})
session.commit()
self.write(dict(code=0, msg='修改成功'))
def login_auth(self, zabbix_url, zabbix_username, zabbix_password):
"""
测试ZABBIX验证是否可以通过
:return:
"""
# 错误信息
err_msg = ''
ins_log.read_log('info', 'ZABBIX Login Auth')
try:
zabbix_login(zabbix_url, zabbix_username, zabbix_password)
except Exception as e:
err_msg = '测试失败，错误信息：{}'.format(e)
return err_msg
def send_work_wechat(self, webhook_addr, content):
"""
发送企业微信机器人
:return:
"""
try:
messages_data = {
"msgtype": "text",
"text": {
"content": content,
# "mentioned_list": ["hongfei.yang"],
}
}
res = requests.post(webhook_addr, json.dumps(messages_data))
print(res.text)
return True, res
except Exception as err:
ins_log.read_log('error', 'send work_wechat error: {err}'.format(err=err))
return False, err
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)
limit = self.get_argument('limit', default="999", strip=True)
limit_start = (int(page_size) - 1) * int(limit)
hostIp_list = []
try:
with DBContext('r') as session:
serObj = session.query(Server).all()
for msg in serObj:
data_dict = {}
data_dict['host'] = msg.hostname
data_dict['ip'] = msg.ip
hostIp_list.append(data_dict)
except Exception as e:
ins_log.read_log('error:', '{err}'.format(err=e))
self.write(dict(code=0, msg='获取成功', data=hostIp_list))
def get(self, *args, **kwargs):
data_list = []
data_list2 = []
with DBContext('r') as session:
todata = session.query(Storage).filter().order_by(
Storage.create_time.desc()).all()
for msg in todata:
temp_dict = {}
data_dict = model_to_dict(msg)
temp_dict["id"] = data_dict["id"]
temp_dict["name"] = data_dict["name"]
temp_dict["mode"] = data_dict["mode"]
temp_dict["consume"] = data_dict["consume"]
temp_dict["dictvalue"] = str(data_dict["dictvalue"])
# temp_dict["authorized"] = str(data_dict["authorized"])
ins_log.read_log('info', "800000000000000000000000000000000000")
ins_log.read_log('info', data_dict["mode"])
ins_log.read_log('info', "800000000000000000000000000000000000")
if data_dict["mode"] == "定时":
data_list.append(temp_dict)
if data_dict["mode"] == "触发":
data_list2.append(temp_dict)
if len(data_list) > 0 or len(data_list2) > 0:
self.write(
dict(code=0, msg='获取成功', data=data_list, data2=data_list2))
else:
self.write(dict(code=-1, msg='没有相关数据', count=0, data=[]))
def get(self):
red_data = []
try:
mysql_conn = getConn()
sql = '''
select * from custom_query
'''
resp = mysql_conn.query(sql)
for id, title, dblinkId, database, user, password, sql, colnames, timesTy, timesTyVal, colalarms, status, \
create_time, update_time, description, seq, groupID in resp:
_d = {}
_d['qid'] = id
_d['title'] = title
_d['dblinkId'] = dblinkId
_d['database'] = database
_d['user'] = user
_d['password'] = password
_d['sql'] = sql
_d['colnames'] = colnames
_d['timesTy'] = timesTy
_d['timesTyVal'] = timesTyVal
_d['colalarms'] = colalarms
_d['status'] = status
_d['create_time'] = str(create_time)
_d['update_time'] = str(update_time)
_d['description'] = description
_d['seq'] = seq
_d['groupID'] = groupID
groupIds = json.loads(groupID)
groupInfo = self.getGroupInfo(groupIds[-1])
_d['groupName'] = groupInfo[0]
_d['group2ndSeq'] = groupInfo[-1]
red_data.append(_d)
except Exception as e:
ins_log.read_log('error', e)
return self.write(dict(code=-1, msg='failed', data=red_data, err='%s' % e))
return self.write(dict(code=0, msg='success', data=red_data))
def toexcel(all_customized_list, asset_date, AssetSql_date):
for j in all_customized_list: # 执行时间表
for q_id, q_header, q_dbname_id, q_totype, q_sqlstr in AssetSql_date: # sql语句表
if q_id == int(j[1]): # 脚本id相等
for s_id, s_db_host, s_db_port, s_db_user, s_db_pwd, s_db_type, s_db_instance in asset_date: # 数据库源
if str(s_id) == q_dbname_id: # 数据源id相等
CUSTOM_DB_INFO = dict(
host=s_db_host,
port=s_db_port,
user=s_db_user,
passwd=decrypt(s_db_pwd),
db=s_db_instance # 库名
)
try:
if s_db_type == "mysql":
mysql_conn = MysqlBase(**CUSTOM_DB_INFO)
db_data = mysql_conn.query(q_sqlstr)
if s_db_type == "oracle":
oracle_conn = OracleBase(**CUSTOM_DB_INFO)
db_data = oracle_conn.query(q_sqlstr)
except:
traceback.print_exc()
db_data_list = []
for g in db_data:
db_data_list.append(list(g))
# 解析excel表头
# q_header.split('|')
temp_copy = copy.deepcopy(q_header)
temp_copy2 = temp_copy.split('|')
ins_log.read_log(
'info', "11111111111111111111111111111111111111")
ins_log.read_log('info', temp_copy2)
ins_log.read_log(
'info', "11111111111111111111111111111111111111")
# 保存文件
Base_DIR = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)))
upload_path = '{}/static/report/'.format(Base_DIR)
upload_path = upload_path + j[3]
# 创建的目录
if not os.path.exists(upload_path):
os.mkdir(upload_path)
file_path = upload_path + '/' + j[0] + str(
datetime.datetime.now().strftime(
'%Y%m%d-%H:%M:%S')) + ".xls"
writer = pd.ExcelWriter(file_path, engine='xlsxwriter')
df = pd.DataFrame(db_data_list,
index=range(1,
len(db_data_list) + 1),
columns=temp_copy2)
df.to_excel(writer,
encoding='utf-8',
sheet_name='Sheet')
writer.save()
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
id = data.get('id', None)
totitle = str(data.get('title', None))
dbid = str(data.get('dbid', None))
times = data.get('times', None)
cycle = str(data.get('cycle', None))
flag = str(data.get('flag', None))
todate = str(data.get('todate', None))
start_end = str(data.get('start_end', None))
download_dir = str(data.get('download_dir', None))
ins_log.read_log('info', flag)
ins_log.read_log('info', todate)
try:
with DBContext('w', None, True) as session:
session.query(Customized).filter(Customized.id == id).update({
Customized.totitle:
totitle,
Customized.dbid:
dbid,
Customized.times:
times,
Customized.cycle:
cycle,
Customized.flag:
flag,
Customized.todate:
todate,
Customized.start_end:
start_end,
Customized.download_dir:
download_dir,
})
session.commit()
except Exception as e:
return self.write(dict(code=-2, msg='修改失败，请检查数据是否合法或者重复'))
self.write(dict(code=0, msg='编辑成功'))
def put(self, *args, **kwargs):
data = json.loads(self.request.body.decode("utf-8"))
remark = data.get('mark')
instance_id = data.get('id')
state = data.get('state')
ins_log.read_log("info",
remark + "||||" + state + "||||" + instance_id)
if not remark or not state:
return self.write(dict(code=-1, msg='mark内容和状态内容都不能为空'))
with DBContext('w', None) as session:
session.query(Security_Host).filter(
Security_Host.server_instance_id == instance_id).update({
Security_Host.server_mark:
remark,
Security_Host.security_state:
state
})
session.commit()
self.write(dict(code=0, msg='修改成功'))
def get(self, *args, **kwargs):
nickname = self.get_current_nickname()
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="999", strip=True)
limit_start = (int(page_size) - 1) * int(limit)
sys_list = []
count = 0
try:
with DBContext('r') as session:
if key == 'sys_id':
count = session.query(SysUpgrade).filter(
SysUpgrade.sys_id == value).count()
all_upgrade = session.query(SysUpgrade).filter(
SysUpgrade.sys_id == value).order_by(
SysUpgrade.id.desc())
sys_name = session.query(
Sys.sys_name).filter(Sys.id == value).first()
_sn = ''
if sys_name:
_sn = sys_name[0]
for msg in all_upgrade:
data_dict = model_to_dict(msg)
data_dict['up_stime'] = str(data_dict['up_stime'])
data_dict['up_etime'] = str(data_dict['up_etime'])
data_dict['issued_time'] = str(
data_dict['issued_time'])
data_dict['up_real_time'] = str(
data_dict['up_real_time'])
data_dict['sys_name'] = _sn
sys_list.append(data_dict)
except Exception as e:
ins_log.read_log('error:', '{err}'.format(err=e))
self.write(dict(code=0, msg='获取成功', count=count, data=sys_list))
