def execute_script(request):
"""
执行脚本
"""
# 接收并处理数据
post = request.POST
files = request.FILES
ip_data = post["ipList"].split(',')
ip_list = list()
for item_ip in ip_data:
ip_list.append(dict(ip=item_ip, bk_cloud_id=0))
script_param = post["scriptWord"]
bk_biz_id = post["businessId"]
re_list = list()
temp_dict = dict()
for key in files:
_file = files.get(key)
temp_dict["filename"] = _file.name
temp_dict['file_content'] = _file.file.read()
re_list.append(dict(filename=temp_dict["filename"]))
# 执行数据
client = get_client_by_request(request)
encode_param = base64.b64encode(script_param)
encode_content = base64.b64encode(temp_dict['file_content'])
kwargs = {
"bk_biz_id": bk_biz_id,
"script_param": encode_param,
"script_content": encode_content,
"account": "root",
"ip_list": ip_list
}
result = client.job.fast_execute_script(kwargs)
result_data = result["data"]
job_instance_name = result_data["job_instance_name"]
job_instance_id = result_data["job_instance_id"]
# 保存数据
task_val = dict()
task_val["job_instance_name"] = job_instance_name
task_val["job_instance_id"] = job_instance_id
task_val["script_name"] = temp_dict["filename"]
task_val["bk_biz_id"] = bk_biz_id
task_val["ip"] = ip_list
task_val["script_param"] = encode_param
task_val["script_content"] = encode_content
TaskDetail(**task_val).save()
return render_json({"result": u"已启动作业：%s (%s)" % (job_instance_name, job_instance_id)})
def get_monitor_host(request):
param = json.loads(request.body)
monitor_list = MonitorItem.objects.filter(bk_biz_id=param['bk_biz_id'])
if param['ip_list']:
monitor_list = monitor_list.filter(ip__in=param['ip_list'])
monitor_list = monitor_list.order_by('id')
return render_json({
'data': [model_to_dict(obj) for obj in monitor_list],
'result': True,
})
def get_mem_info(request):
try:
info = json.loads(request.body)
app_id = info["id"]
ip = info["ip"]
task_id = execute_script(app_id,ip)
# print task_id
memory_info = get_task_result(str(task_id))
# print memory_info
# print memory_info["data"]
mem_list = memory_info["data"].split()
total_memory = float(mem_list[7])
used_memory = float(mem_list[8])
data = {"total_memory": total_memory,"used_memory": used_memory}
memory_used_rate = "%.2f%%" %(used_memory/total_memory*100)
except Exception as e:
return render_json({"result": False, "memory_info": e})
return render_json({"result": True, "memory_info": memory_used_rate})
def verify_name_only(request):
'''
验证名字的唯一性
:param request:
:return:
'''
body = json.loads(request.body)
name = body['name']
id = body['id']
res = function.verify_name_only(name, id)
return render_json(res)
def search_sys_info(request):
try:
username = request.user.username
request_data = json.loads(request.body)
return_data = []
data = {
"id": "1",
"sys_name": "test",
"sys_code": "te",
"owners": "dd",
"is_control": "否",
"department": "dd",
"comment": "dja",
"first_owner": "cyz"
}
return_data.append(data)
return render_json({"result": True, "data": return_data})
except Exception as e:
logger.error(e)
return render_json({"result": False, "msg": [u"查询系统信息失败!!"]})
def test_exam(request):
'''
测试
:param request:
:return:
'''
return render_json({
'name': request.user.username,
'test': 'demo-eaxm',
'message': 'success'
})
def get_sys_tree(request):
try:
client = get_client_by_request(request)
kwargs = {}
result = client.cc.get_app_by_user(kwargs)
if result["result"]:
datas = result["data"]
app_list = [{
"name": data["ApplicationName"],
"id": data["ApplicationID"],
"checked": False,
"isParent": False,
"type": "first",
"children_add": False,
"is_open": False
} for data in datas if data["ApplicationID"] != "1"]
return render_json({"result": True, "data": app_list})
except Exception, e:
return render_json({"result": False, "error": e})
def job_list(request):
"""
get jobs
"""
# 默认从django settings中获取APP认证信息：应用ID和应用TOKEN
# 默认从django request中获取用户登录态bk_token
client = get_client_by_request(request)
# 组件参数
kwargs = {"bk_biz_id": 2}
result = client.job.get_job_list(kwargs)
return render_json(result)
def update_organization(request):
"""更新组织"""
result = json.loads(request.body)
organization_id = int(result['id'])
try:
organization = Organization.objects.filter(id=organization_id)[0]
except ObjectDoesNotExist:
raise Http404("organization does not exist")
Organization.objects.update_organization(organization, result,
request.user)
return render_json({'result': True, 'data': "update success"})
def search_all_host(request):
try:
requst_data = json.loads(request.body)
client = get_client_by_user(request.user.username)
kwargs = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": '******',
"ip" : {"flag": "bk_host_innerip|bk_host_outerip","exact": 1,"data": []},
"condition": [
{
"bk_obj_id": "biz",
"fields": [
"default",
"bk_biz_id",
"bk_biz_name",
],
# 根据业务ID查询主机
"condition": [
{
"field": "bk_biz_id",
"operator": "$eq",
"value": int(requst_data['biz'])
}
]
},
{
"bk_obj_id": "module",
"fields": [],
"condition": []
},
{
"bk_obj_id": "set",
"fields": [],
"condition": []
},
]
}
result = client.cc.search_host(kwargs)
host_list = []
if result["result"]:
for i in result['data']['info']:
host_list.append({
'id':i['host']['bk_host_id'],
'bk_host_innerip':i['host']['bk_host_innerip'],
'area': i['host']['bk_cloud_id'][0]['bk_inst_name'],
'module': [j['bk_module_name'] for j in i['module']][0] if [j['bk_module_name'] for j in i['module']] else '',
#'agent_status': u'正常' if get_host_agent(request.user.username, i['host']['bk_host_innerip'], i['host']['bk_cloud_id'][0]['bk_inst_id']) else u'异常',
})
return render_json({"result": True, "data": host_list})
except Exception as e:
logger.error(e)
def app_list(request):
"""
获取业务
"""
# 默认从django settings中获取APP认证信息：应用ID和应用TOKEN
# 默认从django request中获取用户登录态bk_token
client = get_client_by_request(request)
# 组件参数
kwargs = {}
result = client.cc.get_app_list(kwargs)
return render_json(result)
def api_holiday_list(request):
holiday_list = []
q_query = Q()
year = request.POST.get("year")
if year:
q_query = q_query & Q(year=year)
result_list = Holiday.objects.filter(q_query).values()
if result_list:
holiday_list = list(result_list)
return render_json({"success": True, "data": holiday_list})
def search_topu(request):
id = request.GET['id']
client = get_client_by_user(request.user.username)
kwarg = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": request.user.username,
"bk_biz_id": id,
}
data = client.cc.search_biz_inst_topo(kwarg)
return render_json({'result': True, 'data': data})
def test_la(request):
client = get_client_by_user(request.user.username)
kwarg = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": request.user.username,
"target_app_code": APP_ID,
"fields": "bk_app_code;bk_app_name;introduction;creator;developer"
}
data = client.bk_paas.get_app_info(kwarg)
return render_json({'result': True, 'data': data})
def delete_task(request):
try:
task_obj = json.loads(request.body)
CheckTask.objects.filter(id=task_obj['id']).update(is_deleted=True)
CeleryTimeSet.objects.filter(checktask__id=task_obj['id']).update(
is_deleted=True)
check_task = CheckTask.objects.get(id=task_obj['id'])
log = OperationLog()
log.create_log(check_task, None, 'delete', request.user.username)
return render_json({'result': True})
except Exception as e:
logger.exception(e)
return render_json({
'result':
False,
'data':
u'\u7cfb\u7edf\u5f02\u5e38\uff0c\u8bf7\u8054\u7cfb\u7ba1\u7406\u5458\uff01'
})
return
def list_host(request):
bk_biz_id = request.GET.get('bk_biz_id')
client = get_client_by_request(request)
res = search_host_esb(client, request.user.username, bk_biz_id)
result = []
for item in res['data']:
params = {
'bk_host_innerip': item['host']['bk_host_innerip']
}
result.append(params)
return render_json({'data': result})
def get_vulnscan_report_chartdata(request):
soc_task_resultid = request.GET.get('soc_task_resultid')
print soc_task_resultid
sum = VulnScanReport.objects.filter(
soc_task_resultid=soc_task_resultid).count()
info = VulnScanReport.objects.filter(
soc_task_resultid=soc_task_resultid).filter(risk_level=u'信息').count()
warning = VulnScanReport.objects.filter(
soc_task_resultid=soc_task_resultid).filter(risk_level=u'警告').count()
danger = VulnScanReport.objects.filter(
soc_task_resultid=soc_task_resultid).filter(risk_level=u'危险').count()
emergence = VulnScanReport.objects.filter(
soc_task_resultid=soc_task_resultid).filter(risk_level=u'紧急').count()
res = {
'code': 0,
'result': True,
'messge': 'success',
'data': {
"title":
"漏洞报告",
"series": [
{
'name': u'紧急',
'value': emergence,
'itemStyle': {
'color': 'green'
},
},
{
'name': u'警告',
'value': warning,
'itemStyle': {
'color': 'blue'
},
},
{
'name': u'危险',
'value': danger,
'itemStyle': {
'color': 'yellow'
},
},
{
'name': u'信息',
'value': info,
'itemStyle': {
'color': 'red'
},
},
]
}
}
return render_json(res)
def search_student(request):
name=request.POST.get('name_info')
students=StudentInfo.objects.filter(name__icontains=name).values()
result_list=[]
for stu in students:
result_list.append(stu)
return render_json({'result':True, 'student':result_list})
def do_del_user(req):
op_ids = req.POST.getlist("userIds")
if op_ids == None or op_ids == "":
return render_json({'code': False, 'msg': u"必须传递参数op_id且值不为空"})
try:
for op_id in op_ids:
user = BkingOperator.objects.get(op_id=op_id)
#删除账号
BkingOperator.objects.filter(op_id=op_id).delete()
#删除账号关联的角色信息
BkingOpRoleGrant.objects.filter(
login_code=user.login_code).delete()
return render_json({'code': True, 'msg': u"数据删除成功"})
except Exception, e:
logger.error('delete object for BkingOperator is error:{}'.format(
repr(e)))
return render_json({
'code': False,
'msg': u"数据删除失败:{}".format(repr(e))
})
def application_type_create(request):
form = ApplicationTypeForm(request.POST)
if not form.is_valid():
return render_json({'result': False, "msg": u'参数错误！'})
cc_name = form.cleaned_data['cc_name']
template_type = form.cleaned_data['template_type']
try:
app = Application.objects.get(cc_name=cc_name)
except ObjectDoesNotExist:
return render_json({'result': False, "msg": u'业务名称错误！'})
n = BusinessType.objects.filter(app=app, types=template_type).count()
if n > 0:
return render_json({'result': False, "msg": u'模版类型已存在！'})
else:
try:
BusinessType.objects.create(types=template_type, app=app)
return render_json({'result': True, "msg": u'增加模版类型成功！'})
except Exception, e:
logger.error(u'增加模版类型错误， %s！' % e)
return render_json({'result': False, "msg": u'增加模版类型错误！'})
def switch_func(request):
"""
开启、关闭示例功能
"""
try:
status = int(request.POST.get('status', '0'))
# 更改功能开关的状态
Function_controller.objects.filter(func_code='func_test').update(enabled=status)
except Exception, e:
msg = u"更改功能状态出错，异常信息：%s" % e
return render_json({'res': False, 'msg': msg})
def add_sys(request):
try:
req_data = json.loads(request.body)
start_time = to_datetime(req_data['start_time'])
# 存入数据库
data = {
"id": 2,
"sys_name": "新增系统",
"sys_code": "www",
"owners": "wwwww",
"is_control": "是",
"department": "www",
"comment": "wwwww",
}
return render_json({"result": True, "data": data})
except Exception as e:
return render_json({"result": False, "msg": [u"新增系统信息失败!!"]})
def esb_test2(request):
'''
@note: 蓝鲸体系组件调用 执行任务 用到的前端文件esb_test.html
'''
client = get_client_by_request(request)
kwargs = {
"app_code": settings.APP_ID,
"app_secret": settings.APP_TOKEN,
# 通过cookie获取到bk_token
"bk_token": request.COOKIES['bk_token'],
"app_id": 2, # 业务ID
}
result = client.my_app.get_flask_content(kwargs)
content = result['content']
message = result['message']
import time
time.sleep(10)
if result['result']:
return render_json({'result': True,'content': content,'message': message or u'调取第三方接口Flask_Api成功'})
return render_json({'result': False, 'content': content,'message': message or u'调取第三方接口Flask_Api失败'})
def get_report_server_detail_by_id(request):
try:
server_obj = json.loads(request.body)
menu_list = _get_report_server_detail_by_id(server_obj)
error_list, summary = get_error_server_list(server_obj['id'])
return render_json({
'result': True,
'menu_list': menu_list,
'error_list': error_list,
'summary': summary
})
except Exception as e:
logger.exception(e)
return render_json({
'result':
False,
'data': [
u'\u7cfb\u7edf\u5f02\u5e38\uff0c\u8bf7\u8054\u7cfb\u7ba1\u7406\u5458\uff01'
]
})
def get_history_data(request):
"""
获取磁盘容量历史数据 API
"""
ip = request.GET.get('ip', '')
filesystem = request.GET.get('filesystem', '')
mounted = request.GET.get('mounted', '')
token = request.GET.get('token', '')
if token != TOKEN:
return render_json({
'result': False,
'data': [],
'message': u"token不合法"
})
capacitydatas = CapacityData.objects.all()
if ip:
capacitydatas = capacitydatas.filter(ip=ip)
if filesystem:
capacitydatas = capacitydatas.filter(filesystem=filesystem)
if mounted:
capacitydatas = capacitydatas.filter(mounted=mounted)
datalist = []
for _data in capacitydatas:
datalist.append({
'ip':
_data.ip,
'filesystem':
_data.filesystem,
'mounted':
_data.mounted,
'size':
_data.size,
'use':
_data.use,
'createtime':
_data.createtime.strftime('%Y-%m-%d %H:%M:%S')
})
return render_json({'result': True, 'data': datalist, 'message': 'ok'})
def vcenter(request, vm_id):
if request.method == 'GET':
response = requests.get("https://api.starbucks.net/auth",
auth=('S-Cmdbcn', 'K{RTOLtTP^*Muc#'),
verify=False)
token = response.headers['x-api-key']
return render_json({"result": "ok", "token": token})
if request.method == "DELETE":
logger.info(vm_id)
if not vm_id:
return render_json({
"data": "",
"bk_status": False,
"Message": "vm id is required"
})
try:
response = requests.get("https://api.starbucks.net/auth",
auth=('S-Cmdbcn', 'K{RTOLtTP^*Muc#'),
verify=False)
token = response.headers['x-api-key']
headers = {'Authorization': token, 'accept': 'application/json'}
data = request.POST['data']
logger.info(data)
logger.info(token)
res = requests.delete(
"https://api.starbucks.net/bean-api/api/v1/server/verde/" +
vm_id,
headers=headers,
verify=False)
return render_json({
"data": res.json(),
"bk_status": True,
"Message": u"成功"
})
except Exception as e:
return render_json({
"data": "",
"bk_status": False,
"Message": e.message
})
def get_agent_status(request, cc_biz_id):
"""获取agent安装状态
:param request:
:param cc_biz_id:
:return:
"""
hosts_list = CCBiz.hosts(cc_biz_id).get('data') or []
hostid_list = [host_key(h) for h in hosts_list]
agent_status_info = CCBiz.agent_status(cc_biz_id, hostid_list)
if hosts_list and not len(agent_status_info):
return render_json({
'result': False,
'message': u"查询agent状态接口失败",
'data': []
})
agent_fail_cnt = agent_ok_cnt = 0
ok_ip_list = list()
fail_ip_list = list()
for hostid, status in agent_status_info.iteritems():
ip, plat_id = parse_host_id(hostid)
if status == AGENT_STATUS.ON:
agent_ok_cnt += 1
ok_ip_list.append({'ip': ip, 'cc_plat_id': plat_id})
else:
agent_fail_cnt += 1
fail_ip_list.append({'ip': ip, 'cc_plat_id': plat_id})
details = {
'agent_ok_cnt': agent_ok_cnt,
'agent_fail_cnt': agent_fail_cnt,
'ok_ip_list': ok_ip_list,
'fail_ip_list': fail_ip_list,
}
res = {
'result': True,
'message': "",
'data': agent_ok_cnt,
'details': details
}
return render_json(res)
def get_task_option(request):
try:
filter_obj = eval(request.body)
if not filter_obj['type_id']:
return render_json({
'result':
False,
'data':
[u'\u8bf7\u5148\u9009\u62e9\u7cfb\u7edf\u7c7b\u578b\uff01']
})
mail_data = MailReceiver.objects.all()
module_list = CheckModule.objects.filter(is_deleted=False,
os_type=str(
filter_obj['type_id']))
if not request.user.is_superuser:
mail_data = MailReceiver.objects.filter(
created_by=request.user.username)
module_list = module_list.filter(
Q(created_by=request.user.username) | Q(created_by='system'))
mails = [{
'text': o['mailbox'],
'id': o['mailbox']
} for o in mail_data.values('mailbox').distinct()]
module_list_return = [{
'id': i.id,
'text': i.name + '(' + i.created_by + ')'
} for i in module_list]
return render_json({
'result': True,
'mail_list': mails,
'module_list': module_list_return
})
except Exception as e:
logger.exception(e)
return render_json({
'result':
False,
'data': [
u'\u7cfb\u7edf\u5f02\u5e38\uff0c\u8bf7\u8054\u7cfb\u7ba1\u7406\u5458\uff01'
]
})
def do_add_user(req):
user_name = req.user.username
if user_name == None or user_name == "":
return render_json({'code': False, 'msg': u"获取用户信息失败"})
login_code = req.POST.get("login_code")
op_name = req.POST.get("op_name")
op_password = req.POST.get("op_password")
bill_class = req.POST.get("bill_class")
region_id = req.POST.get("region_id")
county_id = req.POST.get("county_id")
org_id = req.POST.get("org_id")
email = req.POST.get("email")
phone_id = req.POST.get("phone_id")
status = req.POST.get("status")
mark = req.POST.get("mark")
try:
users = BkingOperator.objects.filter(login_code=login_code)
if users.exists():
return render_json({'code': False, 'msg': u"登录名已存在"})
BkingOperator.objects.create(login_code=login_code,
op_name=op_name,
op_password=hash_code(
op_password, login_code),
bill_class=bill_class,
region_id=region_id,
county_id=county_id,
org_id=org_id,
email=email,
phone_id=phone_id,
status=status,
mark=mark,
create_op=user_name)
logger.error('insert object to BkingOperator is success')
return render_json({'code': False, 'msg': u"账号数据新增成功"})
except Exception, e:
logger.error('insert object to BkingOperator is error:{}'.format(
repr(e)))
return render_json({
'code': False,
'msg': u"账号数据新增失败:{}".format(repr(e))
})
def search_hosts(request):
'''获取业务下的集群下的主机'''
try:
bk_set_id = json.loads(request.body)['bk_set_id']
url = host_url + '/api/c/compapi/v2/cc/search_host/'
params = {
"bk_app_code":
bk_app_code,
"bk_app_secret":
bk_app_secret,
"bk_username":
'******',
"condition": [{
"bk_obj_id":
"set",
"fields": [],
"condition": [{
"field": "bk_set_id",
"operator": "$eq",
"value": bk_set_id
}]
}]
}
res = requests.post(url, json.dumps(params)).json()
res_list = []
for host_item in res['data']['info']:
res_dict = {
'bk_host_innerip': host_item['host']['bk_host_innerip'],
'bk_os_name': host_item['host']['bk_os_name'],
'bk_cpu': host_item['host']['bk_cpu'],
'bk_host_name': host_item['host']['bk_host_name'],
'bk_inst_name':
host_item['host']['bk_cloud_id'][0]['bk_inst_name']
}
res_list.append(res_dict)
return render_json({'result': True, 'data': res_list})
except Exception as e:
return render_json({
'result': False,
'message': u'获取业务下集群下主机失败，{}'.format(e)
})
def add_to_celery_list(request):
server_obj = json.loads(request.body)
Servers.objects.update_or_create(ip_address=server_obj["ip_address"],
cloud_id=server_obj["cloud_id"],
app_id=server_obj["app_id"],
os_name=server_obj["os_name"],
cloud_name=server_obj["cloud_name"],
defaults={
"is_deleted": False,
"created_by": request.user.username
})
return render_json({"result": True})
)
# 获取功能开启状态
is_enabled = func_info.enabled
except Exception, e:
logger.error(u"加载功能推荐页面失败，异常信息：%s" % e)
is_enabled = False
return render_mako_context(request, '/home_application/func_check.part',
{'is_enabled': is_enabled})
def switch_func(request):
"""
开启、关闭示例功能
"""
try:
status = int(request.POST.get('status', '0'))
# 更改功能开关的状态
Function_controller.objects.filter(func_code='func_test').update(enabled=status)
except Exception, e:
msg = u"更改功能状态出错，异常信息：%s" % e
return render_json({'res': False, 'msg': msg})
return render_json({'res': True, 'msg': u"操作成功"})
@function_check('func_test')
def excute_func(request):
"""
开启、关闭示例功能
"""
return render_json({'res': True, 'msg': u"这是一个功能开关示例"})
def excute_func(request):
"""
开启、关闭示例功能
"""
return render_json({'res': True, 'msg': u"这是一个功能开关示例"})
