def delete_conn(request, id):
"""
删除
:param request:
:param id:
:return:
"""
try:
res = Conn.objects.filter(id=id).delete()
info = make_log_info(u'删除数据库连接配置', u'业务日志', u'Conn',
sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
add_log(info)
status_dic = {}
# 删除完后重新计算页数
items_count = Conn.objects.count()
pages = items_count / 5
if 0 != items_count % 5:
pages = pages + 1
status_dic['message'] = 'ok'
status_dic['page_count'] = pages
return tools.success_result(status_dic)
except Exception as e:
res1 = tools.error_result(e)
info = make_log_info(u'删除数据库连接配置', u'业务日志', u'Conn',
sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
add_log(info)
return tools.error_result(res1)
def delete_muenu(request, id):
"""
删除菜单
:param request:
:param id:
:return:
"""
# 先删除菜单，再删除该菜单下的所有角色，两表无外键Id
try:
Muenu.objects.get(id=id).delete()
rm.objects.filter(muenuid=id).all().delete()
info = make_log_info(u'删除菜单', u'业务日志', u'Muenu',
sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
add_log(info)
info = make_log_info(u'删除菜单', u'业务日志', u'rm',
sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
add_log(info)
return tools.success_result(None)
except Exception as e:
info = make_log_info(u'删除菜单', u'业务日志', u'Muenu',
sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
add_log(info)
info = make_log_info(u'删除菜单', u'业务日志', u'rm',
sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
add_log(info)
res3 = tools.error_result(e)
return tools.error_result(res3)
def get_api_type(cls, api_address):
"""
:return:
"""
# 请求地址,测试数据
# api_address = LOG_API_ADDRESS
# 返回列表
return_list = []
# 请求结果
try:
api_result = json.loads(requests.get(api_address).content)
if api_result['code'] == '000000':
for i in api_result['data']:
map = {}
# 度量值列表
metric_list = api_result['data'][i].split('|')[1].split(',')
dimension_list = api_result['data'][i].split('|')[0].split(',')
map[i] = dict()
map[i]['metric_list'] = metric_list
map[i]['dimension_list'] = dimension_list
return_list.append(map)
return success_result(return_list)
else:
return error_result([])
except Exception as e:
return error_result(str(e))
def editconn(request):
"""
修改
:param request:
:return:
"""
try:
# 拿到当前用户，保存为修改人
res = json.loads(request.body)
res['editname'] = request.user.username
res['edittime'] = datetime.datetime.now()
# 点修改密码进行解密
password = encryption_str(res['password'])
res['password'] = password
re1 = Conn.objects.filter(id=res['id']).update(**res)
info = make_log_info(u'修改数据库连接配置', u'业务日志', u'Conn',
sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
add_log(info)
return tools.success_result(re1)
except Exception as e:
res1 = tools.error_result(e)
info = make_log_info(u'修改数据库连接配置', u'业务日志', u'Conn',
sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
add_log(info)
return res1
def addmuenus(request):
"""
增加菜单
:param request:
:return:
"""
try:
status_dic = {}
res = json.loads(request.body)
re = Muenu(**res).save()
items_count = Muenu.objects.count()
# 增加菜单后重新查看总页数
pages = items_count / 5
if 0 != items_count % 5:
pages = pages + 1
status_dic['message'] = 'ok'
status_dic['page_count'] = pages
info = make_log_info(u'增加菜单', u'业务日志', u'Muenu',
sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
add_log(info)
return tools.success_result(status_dic)
except Exception as e:
res1 = tools.error_result(e)
info = make_log_info(u'增加菜单', u'业务日志', u'Muenu',
sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
add_log(info)
return res1
def add_person(request):
"""
添加岗位人员
:param request:
:return:
"""
# 外键关联，user_pos不能为空，把岗位id=1 的设为无岗位人员
try:
res = json.loads(request.body)
id = res['id']
# 穿梭框左边的值
person_no_positions = dict_get(res['data2'], u'pinyin', None)
# 穿梭框右边的值
person_positions = res['value2']
# 获取无岗位id
noposition_id = get_noposition_id()
# 一个用来循环，一个用来存数据
person_no_positions2 = person_no_positions
# 增加岗位人员
for pos_username in person_positions:
user_info.objects.filter(user_name=pos_username).update(user_pos=id)
# 把已经赋予岗位的人员从左边移出
for no_pos_username in person_no_positions:
if pos_username == no_pos_username:
person_no_positions2.remove(pos_username)
# 移出岗位人员
for no_pos_username2 in person_no_positions2:
user_info.objects.filter(user_name=no_pos_username2).update(user_pos=noposition_id)
info = make_log_info(u'岗位人员增加或移除', u'业务日志', u'pos_info', sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
except Exception, e:
res = tools.error_result(e)
info = make_log_info(u'岗位人员增加或移除', u'业务日志', u'pos_info', sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
def model_tree_host(request):
"""
树状主机信息显示
:param request:
:return:
"""
try:
param = {"bk_biz_id": 2}
client = tools.interface_param(request)
res = client.cc.search_biz_inst_topo(param)
if res.get('result'):
# 判断调用search_biz_inst_topo接口是否成功，成功则取数据，失败则返回错误信息
bk_tree_list = res.get('data')
else:
bk_tree_list = []
logger.error(u"请求主机拓扑列表失败：%s" % res.get('message'))
test_list = bk_tree_list[0]['child'] # 取出集群数据
display_list = []
for i in test_list: # 循环遍历取出集群名称
dic = {
'bk_inst_name': i['bk_inst_name'],
'bk_inst_id': i['bk_inst_id'],
}
child_list = []
for child in i['child']:
dic1 = {
'child_bk_inst_name': child['bk_inst_name'],
'child_bk_inst_id': child['bk_inst_id'],
}
child_list.append(dic1)
dic['child'] = child_list
display_list.append(dic)
result = tools.success_result(display_list)
except Exception, e:
result = tools.error_result(e)
def get_scenes_all():
"""
获取所有场景信息
:return:
"""
try:
result = Scene.objects.get_scenes_all().get("result")
except Exception, e:
result = tools.error_result(e)
def get_positions_all():
"""
获取所有岗位信息
:return: json--results--StaffPosition对象
"""
try:
res = StaffPosition.objects.get_positions_all().get("result")
result = tools.success_result(res)
except Exception, e:
result = tools.error_result(e)
def get_user(request):
"""
获取当前用户
:param request:
:return:
"""
try:
client = tools.interface_param(request)
result = client.bk_login.get_user({}) # 获取当前用户信息
except Exception, e:
result = tools.error_result(e)
def get_staff_info(request):
"""
获取职员信息-完成
:param request:
:return:
"""
try:
user_info = get_user(request)
bk_username = user_info.get('data').get('bk_username') # 当前用户用户名
result = StaffInfo.objects.get_staff_info(bk_username)
except Exception, e:
result = tools.error_result(e)
def get_scene_by_id(id):
"""
根据场景ID获取场景对象
:param id:
:return:
"""
res = Scene.objects.get_scenes_by_id(id)
if res.get("code"):
result_temp = res.get("result")
result = tools.success_result(result_temp)
else:
result_temp = res.get("result")
result = tools.error_result(result_temp)
return result
def get_staff_position_by_username(request):
"""
获取岗位信息--完成
:param request:
:return:
"""
try:
user_info = get_staff_info(request)
staff_position_id = user_info.get("result").get("staff_position_id")
temp_result = StaffPosition.objects.get_staff_position_by_username(
staff_position_id)
result = temp_result
except Exception, e:
result = tools.error_result(e)
def get_conname(request):
"""
根据id获取数据库连接配置并返回
:param request:
:return:
"""
try:
res = request.body
res_obj = Conn.objects.get(id=res)
conn = model_to_dict(res_obj)
reslut = tools.success_result(conn)
except Exception as e:
reslut = tools.error_result(e)
return reslut
def synchronize(request):
"""
用户同步
:param request:
:return:
"""
try:
res = get_user(request)
reslist = res['data']
# 获取无岗位id
# noposition_id = get_noposition_id()
# 所有用户
users = user_info.objects.all()
# 判断本地用户与蓝鲸用户，以蓝鲸的为准，多了删除，少了增加，变了更新
# 先蓝鲸用户匹配本地用户,少了增加，变了更新
for data in reslist:
flag1 = 0
for user in users:
if data['bk_username'] == user.user_name:
user_info.objects.filter(user_name=user.user_name).update(mobile_no=data['phone'], email=data['email'],user_type_id=data['bk_role'])
flag1 = 1
break
if flag1 == 0:
if data['bk_role'] == 1:
user_pos = 1
else:
user_pos = 2
user_info.objects.create(user_name=data['bk_username'], user_type_id=data['bk_role'],
mobile_no=data['phone'], email=data['email'],
user_pos_id=user_pos)
# 后本地用户匹配蓝鲸用户,多了删除
#for user in users:
#flag2 = 0
#for data in reslist:
# 相同表示存在，就不管
# if user.user_name == data['bk_username']:
# flag2 = 1
# break
# 表示此用户表中的用户，已经在蓝鲸上删除，在用户表中也删除
#if flag2 == 0:
# user_info.objects.filter(user_name=user.user_name).delete()
info = make_log_info(u'同步蓝鲸用户', u'业务日志', u'user_info', sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
mess = "同步成功"
except Exception, e:
r1 = tools.error_result(e)
info = make_log_info(u'同步蓝鲸用户', u'业务日志', u'user_info', sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
mess = "同步失败"
def testConn(request):
"""
测试
:param request:
:return:
"""
res = json.loads(request.body)
ip = str(res['ip'])
port = res['port']
username = res['username']
password = res['password']
databasename = res['databasename']
# 测试连接密码不需要解密，传的明码
# password = base64.b64decode(password)
try:
if res['type'] == 'MySQL':
db = MySQLdb.connect(host=ip,
user=username,
passwd=password,
db=databasename,
port=int(port))
elif res['type'] == 'Oracle':
sql = r'%s/%s@%s/%s' % (username, password, ip, databasename)
# db = cx_Oracle.connect(sql)
db = None
else:
# SqlServer数据库链接包暂时有部署问题，暂时取消该功能
# db = pymssql.connect(host=ip + r':' + port, user=username, password=password, database=databasename)
return tools.error_result("暂不支持SqlServer类型数据库！")
cursor = db.cursor()
if cursor != '':
cursor.close()
db.close()
return tools.success_result('0')
except Exception as e:
return tools.error_result(e)
def get_all_db_connection(request):
"""
获取所有的数据库名称
:param request:
:return:
"""
try:
conn = Conn.objects.all()
result = []
for con in conn:
obj = model_to_dict(con)
result.append(obj)
return tools.success_result(result)
except Exception as e:
return tools.error_result(str(e))
def get_scene_by_staff_position_id_time_order_by_scene_order_id(request):
"""
根据用户ID和当前时间获取场景信息----暂时保留---待废弃
:param request:json
:return:
"""
try:
staff_position = get_staff_position_by_username(request) # 获取场景信息
staff_position_id = staff_position.get("result").get(
"staff_position_id") # 场景ID
now_time = datetime.datetime.now().strftime("%H:%M:%S") # 当前时间
temp_result = Scene.objects.get_scene_by_staff_position_id_time_order_by_scene_order_id(
staff_position_id, now_time).get("result")
result = tools.success_result(temp_result)
except Exception, e:
result = tools.error_result(e)
def savemnus(request):
"""
更新角色菜单权限
:param request:
:return:
"""
ids = json.loads(request.body)
# 保留角色菜单中间表
rm_all = rm.objects.all()
r_all = rm_all
x = 0
z = 0
parent_id = []
son_id = []
# 获取拿到数据第一个值，如果为数字型数组，则权限未发生变动
if isinstance(ids[0], int):
return 1
# 如果获取的是对象数组，则变动了
else:
# 保存角色菜单前先删除中间表，中间表不为空则删除
if rm_all is not None:
try:
with transaction.atomic():
de = rm.objects.all().delete()
for id in ids:
if ('children' not in id) and ('label' in id):
# 逐个树id还原成菜单id(之前经过处理 树id = (角色id+1)*100+菜单Id)
x = id['id'] // 1000
z = id['id'] % 1000
x = int(x)
res1 = rm.objects.create(roleid=x - 1, muenuid=z)
else:
pass
info = make_log_info(u'逐条增加菜单与角色中间表', u'业务日志', u'rm',
sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
add_log(info)
except Exception as e:
# for i in r_all:
# rm.objects.create(roleid=model_to_dict(i)['roleid'], muenuid=model_to_dict(i)['muenuid'])
info = make_log_info(u'逐条增加菜单与角色中间表', u'业务日志', u'rm',
sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
add_log(info)
return tools.error_result(e)
def delete_pos(request):
"""
删除岗位
:param request:
:return:
"""
try:
res = json.loads(request.body)
id = res['id']
res1 = pos_info.objects.get(id=id).delete()
info = make_log_info(u'删除岗位', u'业务日志', u'pos_info', sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
except Exception as e:
res1 = tools.error_result(e)
info = make_log_info(u'删除岗位', u'业务日志', u'pos_info', sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
add_log(info)
return res1
def add_pos(request):
"""
增加岗位
:param request:
:return:
"""
try:
re = ''
res = json.loads(request.body)
# 获取当前用户
nowPerson = request.user.username
res['creator'] = nowPerson
pos_info.objects.create(**res)
info = make_log_info(u'增加岗位', u'业务日志', u'pos_info', sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
except Exception, e:
re = tools.error_result(e)
info = make_log_info(u'增加岗位', u'业务日志', u'pos_info', sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
def get_scene_by_staff_position_id(request):
"""
根据用户ID获取场景信息----未添加时间
:param request:
:return:
"""
try:
staff_position = get_staff_position_by_username(request) # 获取场景信息
staff_position_id = staff_position.get("result").get(
"staff_position_id") # 场景ID
str_now_time = time.strftime("%H:%M:%S", time.localtime(time.time()))
now_time = time.localtime(time.time())
temp_result = Scene.objects.get_scene_by_staff_position_id(
staff_position_id).get("result") # 场景信息结果
result = tools.success_result(temp_result)
return result
except Exception, e:
result = tools.error_result(e)
return result
def edit_pos(request):
"""
编辑岗位
:param request:
:return:
"""
try:
res = json.loads(request.body)
id = res['id']
posname = res['pos_name']
# 获取系统时间
nowTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
# 获取当前用户
nowPerson = request.user.username
r1 = pos_info.objects.filter(id=id).update(pos_name=posname, edit_time=nowTime, editor=nowPerson)
info = make_log_info(u'编辑岗位', u'业务日志', u'pos_info', sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
except Exception, e:
r1 = tools.error_result(e)
info = make_log_info(u'编辑岗位', u'业务日志', u'pos_info', sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
def edit_muenu(request):
"""
修改菜单
:param request:
:return:
"""
try:
res = json.loads(request.body)
re1 = Muenu.objects.filter(id=res['id']).update(**res)
info = make_log_info(u'修改菜单', u'业务日志', u'Muenu',
sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
add_log(info)
return tools.success_result(re1)
except Exception as e:
res1 = tools.error_result(e)
info = make_log_info(u'修改菜单', u'业务日志', u'Muenu',
sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
add_log(info)
return res1
def saveconn_all(request):
"""
保存
:param request:
:return:
"""
try:
res = json.loads(request.body)
cilent = tools.interface_param(request)
user = cilent.bk_login.get_user({})
# 获取用户名
res['createname'] = request.user.username
res['editname'] = request.user.username
# 密码加密后保存
password = encryption_str(res['password'])
res['password'] = password
re = Conn(**res).save()
status_dic = {}
# 计算总页数，取5有余就+1页
items_count = Conn.objects.count()
pages = items_count / 5
if 0 != items_count % 5:
pages = pages + 1
status_dic['message'] = 'ok'
status_dic['page_count'] = pages
info = make_log_info(u'增加数据库连接配置', u'业务日志', u'Conn',
sys._getframe().f_code.co_name,
request.user.username, '成功', '无')
add_log(info)
return tools.success_result(status_dic)
except Exception as e:
info = make_log_info(u'增加数据库连接配置', u'业务日志', u'Conn',
sys._getframe().f_code.co_name,
request.user.username, '失败', repr(e))
add_log(info)
res1 = tools.error_result(e)
return res1
def save_staff_info(request):
"""
保存员工信息--待完善
:param request:
:return:
"""
try:
user_info = get_user(request)
bk_username = user_info.get('data').get('bk_username') # 当前用户用户名
staff_position_id = 1 # 假定岗位ID为1,待完善
temp_result = StaffInfo.objects.get_staff_info(bk_username)
temp_code = temp_result.get("code")
if temp_code is True: # 判断是否存在该员工信息表
result = temp_result
else:
data = {
"bk_username": bk_username,
"staff_position_id": staff_position_id,
}
result = StaffInfo.objects.save_staff_info(data)
except Exception, e:
result = tools.error_result(e)
def show_host(request):
"""
取出所有主机信息
:param request:
:return:
"""
limit = 7 # 暂时为7
bk_biz_id = 2
start_page = tools.page_paging(request, limit) # 起始页码
try:
display_list = [] # 定义一个空列表
param = { # 以下定义search_host--查询主机接口参数
"ip": {
"data": [],
"exact": 1,
"flag": "bk_host_innerip|bk_host_outerip"
},
"condition": [
{
"bk_obj_id": "biz",
"fields": [],
"condition": [
{
"field": "bk_biz_id",
"operator": "$eq",
"value": bk_biz_id
}
]
},
],
"page": {
"start": start_page,
"limit": limit,
"sort": "bk_host_id"
},
}
param2 = { # 定义get_agent_status--agent状态接口参数
"bk_supplier_id": 0,
"hosts": [{
"ip": 0,
"bk_cloud_id": "0"
}]
}
client = tools.interface_param(request)
res = client.cc.search_host(param) # 调用search_host接口
# 判断调用search_host接口是否成功，成功则取数据，失败则返回错误信息
if res.get('result'):
bk_host_list = res.get('data').get('info')
else:
bk_host_list = []
logger.error(u"请求主机列表失败：%s" % res.get('message'))
for i in bk_host_list: # 循环遍历接口返回的参数，取出数据保存
dic = {
'bk_os_name': i['host']['bk_os_name'],
'bk_host_name': i['host']['bk_host_name'],
'bk_host_innerip': i['host']['bk_host_innerip'],
'bk_inst_name': i['host']['bk_cloud_id'][0]['bk_inst_name'],
}
param2['hosts'][0]['ip'] = dic['bk_host_innerip']
res2 = client.gse.get_agent_status(param2) # 调用get_agent_status接口
bk_agent_info = res2['data']
if bk_agent_info['0:' +
dic['bk_host_innerip']]['bk_agent_alive'] == 1:
dic['bk_agent_alive'] = u"Agent已安装"
else:
dic['bk_agent_alive'] = u"Agent未安装"
display_list.append(dic) # 把取出来的数据保存到display_list里面
print display_list
result = tools.success_result(display_list)
except Exception, e:
result = tools.error_result(e)
def get_staff_scene(request):
"""
获取场景 ---- 完成-----多个岗位对应多个场景
:param request:
:return:
"""
try:
staff_info = get_staff_info(request)
now_time = datetime.datetime.now().strftime("%H:%M:%S") # 当前时间字符串型
bk_username = staff_info.get('result').get('bk_username') # 当前用户用户名
res = PositionScene.objects.get_position_scene(
staff_info.get("result").get("staff_position_id"))
temp_list = [] # 存储scene_id
for i in res.get("result"):
temp_list.append(i['scene_id'])
pass
print(u'通过岗位获取的所有岗位有的场景ID')
print temp_list
# 根据岗位获取对应场景信息
scene_res = Scene.objects.filter(
scene_id__in=temp_list,
scene_start_time__lt=now_time,
scene_stop_time__gt=now_time).order_by('scene_order_id').values()
scene_list = [] # 所有符合要求的场景id
for i in scene_res: # 遍历结果集
scene_id = i['scene_id']
scene_list.append(scene_id)
print(u"符合要求的场景ID")
print scene_list
# 根据用户和场景ID遍历个人设置场景信息(根据用户设置排序)
staff_scene_res = StaffScene.objects.filter(
bk_username=bk_username, staff_scene_id__in=scene_list).order_by(
'staff_scene_order_id').values()
staff_scene_list = [] # 用户设置了的并符合要求的场景ID
staff_scene_default_time_list = []
for i in staff_scene_res:
staff_scene_id = i['staff_scene_id']
staff_scene_list.append(staff_scene_id)
staff_scene_default_time = i['staff_scene_default_time']
staff_scene_default_time_list.append(staff_scene_default_time)
print(u'用户设置了的场景ID')
print staff_scene_list
print(u'用户自定义设置的时间')
print staff_scene_default_time_list
difference_list = list(
set(scene_list).difference(
set(staff_scene_list))) # 用户没有设置的场景ID,将默认排在最后
print(u'用户没有设置的场景ID')
print difference_list
temp = StaffScene.objects.filter(
bk_username=bk_username, staff_scene_id__in=scene_list).values()
temp_list = []
for i in temp:
temp_list.append(i)
result_list = [] # 存储最后结果集
staff_scene_default_time_list_length = 0
for j in staff_scene_list:
# 将符合要求的并且用户设置了顺序的依次添加搞结果集
result = Scene.objects.filter(
scene_id=j,
scene_start_time__lt=now_time,
scene_stop_time__gt=now_time).values()
for i in result:
i['scene_start_time'] = i['scene_start_time'].strftime(
"%H:%M:%S")
i['scene_stop_time'] = i['scene_stop_time'].strftime(
"%H:%M:%S")
i['scene_default_time'] = staff_scene_default_time_list[
staff_scene_default_time_list_length]
staff_scene_default_time_list_length = staff_scene_default_time_list_length + 1
result_list.append(i)
# 取出符合要求的并且用户没有自主设置的场景添
temp_staff_scene = Scene.objects.filter(
scene_start_time__lt=now_time,
scene_stop_time__gt=now_time,
scene_id__in=difference_list).order_by('scene_order_id').values()
# 将符合要求的并且用户没有自主设置的场景添加到结果集
for i in temp_staff_scene:
i['scene_start_time'] = i['scene_start_time'].strftime("%H:%M:%S")
i['scene_stop_time'] = i['scene_stop_time'].strftime("%H:%M:%S")
result_list.append(i)
result = tools.success_result(result_list)
except Exception, e:
result = tools.error_result(e)
def gather_base_test(cls, interface_type, measures, measures_name,
gather_rule, show_rule_type, interface_param):
"""
基本单元采集测试
:param interface_type: 接口类型 log为日志,measures为指标类型
:param measures: 指标集
:param measures_name: 指标名称
:param gather_rule: 解析规则
:param show_rule_type: 显示类型 0/百分比, 1/颜色, 2/不变化 增加显示类型时请增加注释
:param interface_param: url参数
:return:
"""
# 日志数据模拟
if interface_type == 'log':
api_address = MEASURES_QUERY_API
# 模拟数据
temp_list = [{"zy-shangpin-initial_system-init": "1"}]
# 加入颜色展示规则
for temp in temp_list:
temp[measures + '_' + measures_name] = Gather.color_manage(
temp[measures + '_' + measures_name], gather_rule)
# 返回统一出来的结果
return success_result(temp_list)
else:
api_address = MEASURES_QUERY_API
# 获取当前系统时间前10秒（具体时长数据库配置，默认为1000秒）的时间戳
result = get_previous_second_ts()
curr_ts = str(list(result[0])[0])
query_form = api_address + '?' + 'start=' + curr_ts + '&m=sum:sum:' + measures + '_' + measures_name + interface_param
timeout_result = get_icube_timeout()
icube_timeout = int(list(timeout_result[0])[0])
# 设置调用服务的超时时长在数据库中配置，超过配置的时长就抛异常
request_result = requests.get(url=query_form, timeout=icube_timeout)
request_code = request_result.status_code
print request_result
if request_code == 200:
temp_list = Gather.change_json(measures, request_result,
measures_name)
# 百分比
if show_rule_type == '0':
# # API请求结果
# result_json = json.loads(request_result.content)
# # 此处解析结果
# result_list = []
# for i in result_json:
# time_list = []
# for key, value in i['dps'].items():
# time_list.append(key)
# max_time = max(time_list)
# metric = i['dps'][max_time]
# max_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(int(max_time)))
# map = {}
# map[measures + '_' + measures_name] = metric
# map['time'] = max_time
# appsystem = i['tags']['appsystem']
# ip = i['tags']['ip']
# map['system_name'] = appsystem
# map['ip'] = ip
# result_list.append(map)
# 此处规则转换
for i in temp_list:
i[measures + '_' + measures_name] = Gather.percent_manage(
gather_rule, i[measures + '_' + measures_name])
# i['metric_max'] = Gather.percent_manage(gather_rule, i['metric_max'])
# i['metric_avg'] = Gather.percent_manage(gather_rule, i['metric_avg'])
# print result_list
return success_result(temp_list)
# 显示颜色
elif show_rule_type == '1':
# 转换颜色规则
# color_code_map = {}
# rule_list = gather_rule.split('@')
# for i in rule_list:
# if i is not None:
# color_rgb = i.split('==')[0]
# try:
# color_code = i.split('==')[1]
# except Exception as e:
# # 不存在默认将
# color_code = 'error'
# color_code_map[color_code] = color_rgb
# 模拟数据
# temp_list = [{"system_name": "jzjy", "ip": "192.168.1.153", "cpu_cpu_used_pct": 2, "time": "2019-03-22 19:42:12"}, {"system_name": "jzjy", "ip": "192.168.1.157", "cpu_cpu_used_pct": 0, "time": "2019-03-22 19:37:23"}, {"system_name": "jzjy", "ip": "192.168.1.165", "cpu_cpu_used_pct": 0, "time": "2019-03-22 19:41:56"}]
# result_list = Gather.color_manage(color_code_map, temp_list, measures, measures_name)
try:
for i in temp_list:
i[measures + '_' +
measures_name] = Gather.color_manage(
i[measures + '_' + measures_name], gather_rule)
# i['metric_max'] = Gather.color_manage(i['metric_max'], gather_rule)
# i['metric_avg'] = Gather.color_manage(i['metric_avg'], gather_rule)
return success_result(temp_list)
except Exception as e:
print e
return error_result(u'异常' + str(e))
# 其它展示
elif show_rule_type == '2':
try:
for i in temp_list:
i[measures + '_' +
measures_name] = Gather.other_manage(
i[measures + '_' + measures_name], gather_rule)
# i['metric_max'] = Gather.other_manage(i['metric_max'], gather_rule)
# i['metric_avg'] = Gather.other_manage(i['metric_avg'], gather_rule)
print temp_list
return success_result(temp_list)
except Exception as e:
print e
return error_result(u'异常' + str(e))
elif request_code == '500':
return error_result(u'接口请求错误')
elif request_code == '404':
return error_result(u'接口找不到了')
else:
return error_result(request_code.__str__() + u'系统错误')
