def get_servers_info():
logger.info(1)
res = Servers.objects.all()
for m in res:
if not m.men_info or not m.disk_info:
get_other_info.delay(m.id)
app_list = Servers.objects.all().values("app_id", "created_by").distinct()
run_apps = []
for i in app_list:
servers = Servers.objects.filter(app_id=i["app_id"], is_deleted=False)
one_app = {
"app_id": i["app_id"],
"ip_list": [{"ip": u.ip_address, "bk_cloud_id": u.cloud_id} for u in servers],
}
client = get_client_by_user(i["created_by"])
result = get_server_perform(client, one_app, i["created_by"])
if result["result"]:
run_apps.append({"app_id": i["app_id"], "job_instance_id": result["data"], "username": i["created_by"]})
performance_list = []
for i in run_apps:
client = get_client_by_user(i["username"])
one_app_result = get_task_ip_log(client, i["app_id"], i["job_instance_id"], i["username"])
performance_list += create_server_perform(one_app_result, i["app_id"])
ServerPerformance.objects.bulk_create(
performance_list, batch_size=500
)
def test_get_client_by_user(self):
user = self.user_model(username=TS['bk_user']['bk_username'])
client = get_client_by_user(user)
result = client.bk_login.get_user()
self.assertTrue(result['result'], json.dumps(result))
self.assertEqual(result['data']['bk_username'], TS['bk_user']['bk_username'])
client = get_client_by_user(TS['bk_user']['bk_username'])
result = client.bk_login.get_user()
self.assertTrue(result['result'], json.dumps(result))
self.assertEqual(result['data']['bk_username'], TS['bk_user']['bk_username'])
def setup_bk_client(cls, request=None, user=None, **kwargs):
"""
获取蓝鲸的client对象
request和user对象二选一，同时传入，使用request参数
"""
if request:
_client = get_client_by_request(request, **kwargs)
elif user:
_client = get_client_by_user(user, **kwargs)
else:
_client = get_client_by_user(settings.ADMIN_USERNAME, **kwargs)
cls.client = _client
def save_history(request, result1):
content = result1['data'][0]['stepAnalyseResult'][0]['ipLogContent']
end_time = content['endTime']
start_time = content['startTime']
ip = content['ip']
log_content = content['logContent']
name = content['resultTypeText']
try:
Taskhistory.objects.create(end_time=end_time, start_time=start_time, ip=ip, result=log_content,
name=name, username=get_current_username(request))
except Exception as ex:
print str(ex)
print get_client_by_user(request)
data = {'result': True}
return JsonResponse(data)
def excute_by_script(username,
biz_id,
ip_list,
script_content,
script_type=1,
script_timeout=600):
client = get_client_by_user(username)
# app_list=[{'ip':'192.168.165.51','bk_cloud_id':'2'}]
kwargs = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_biz_id": int(biz_id),
"bk_username": username,
"script_content": base64.b64encode(script_content),
"ip_list": ip_list,
"script_type": script_type,
"account": 'root',
"script_timeout": script_timeout
}
result = client.job.fast_execute_script(kwargs)
if result["result"]:
task_id = result["data"]["job_instance_id"]
time.sleep(2)
return get_ip_log_content(client, username, task_id, biz_id)
else:
return {"result": False, "data": result["message"]}
def app_detail(request):
try:
client = get_client_by_user(request.user.username)
kwargs = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": '******',
"target_app_code": APP_ID,
"fields": 'introduction;creator;developer',
}
result = client.bk_paas.get_app_info(kwargs)
my_dict = {}
if result["result"]:
my_dict['message'] = result['message']
my_dict['code'] = result['code']
my_dict['data'] = [{'bk_app_code':result['data'][0]['bk_app_code'], "introduction": result['data'][0]['introduction'], "creator": result['data'][0]['creator'],"bk_app_name": result['data'][0]['bk_app_name'],"developer": result['data'][0]['developer']}]
my_dict['result'] = result['result']
my_dict['request_id'] = result['request_id']
return render_json(my_dict)
except Exception as e:
print e
def install_mysql_by_script(username,
app_id,
app_list,
script_content,
script_type=1,
script_timeout=600):
client = get_client_by_user(username)
kwargs = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_biz_id": app_id,
"bk_username": username,
"script_content": base64.b64encode(script_content),
"ip_list": app_list,
"script_type": script_type,
"account": 'root',
"script_timeout": script_timeout
}
result = client.job.fast_execute_script(kwargs)
if result["result"]:
task_id = result["data"]["job_instance_id"]
time.sleep(2)
return get_ip_log_content(client, username, task_id, app_id)
else:
return {"result": False, "data": result["message"]}
def search_topo(request):
try:
request_data = json.loads(request.body)
client = get_client_by_user(request.user.username)
topo = []
for k in request_data['biz_list']:
kwargs = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": '******',
"bk_biz_id": int(k['id'])
}
result = client.cc.search_biz_inst_topo(kwargs)
if result["result"]:
global topo_list
topo_list = []
# need_data = []
# for child in result['data']:
# if
get_inst_of_same_level(result['data'])
topo.append({"id": int(k['id']), "name": k['text'], "bk_obj_id": "biz","isParent": 'true', 'children': copy.deepcopy(topo_list)})
return render_json({"result": True, "data": topo})
except Exception as e:
logger.error(e)
def get_all_users(username):
client = get_client_by_user(username)
res = client.bk_login.get_all_users()
if res["result"]:
return {"result": True, "data": res["data"]}
else:
return {"result": False, "data": res["message"]}
def install_mysql_by_script(username,
instance_info,
script_content,
script_type=1,
script_timeout=600):
client = get_client_by_user(username)
kwargs = {
"app_code": APP_ID,
"app_secret": APP_TOKEN,
"app_id": instance_info['app_id'],
"username": username,
"content": base64.b64encode(script_content),
"ip_list": [{
"ip": instance_info['ip'],
"source": instance_info['source']
}],
"type": script_type,
"account": username,
"script_timeout": script_timeout
}
result = client.job.fast_execute_script(kwargs)
if result["result"]:
task_id = result["data"]["taskInstanceId"]
time.sleep(2)
return get_ip_log_content(client, username, task_id)
else:
return {"result": False, "data": result["message"]}
def sync_user(self, request, *args, **kwargs):
"""
同步蓝鲸用户
{}
"""
# bk用户和app用户字段映射
user_maps = [
{'from': 'bk_username', 'to': 'username'},
{'from': 'chname', 'to': 'chname'},
{'from': 'phone', 'to': 'phone'},
{'from': 'email', 'to': 'email'},
]
user_model = get_user_model()
client = get_client_by_user(request.user.username)
result = client.bk_login.get_all_users()
username_list = []
if result['result']:
user_list = result['data']
for user in user_list:
to_user = get_mapping(user, user_maps)
username_list.append(to_user['username'])
user_model.objects.update_or_create(defaults=to_user, username=to_user['username'])
user_model.objects.exclude(username__in=username_list).delete()
return Response()
else:
raise ValueError(result['message'])
def __init__(self):
self.client = get_client_by_user("admin")
self.send_type = {
"mail": self.send_mail,
"sms": self.send_sms,
"weixin": self.send_weixin
}
def search_all_host(request):
try:
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":"$nin","value":6}]
}
]
}
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'],
'text':i['host']['bk_host_innerip']
})
return render_json({"result": True, "data": host_list})
except Exception as e:
logger.error(e)
def send_Email(user, content):
# receiver_address = MailInfo.objects.filter(name=user).values("email_address")
# if len(receiver_address) < 1:
# # 当操作用户不在邮件接收列表中时，则向默认邮件接收人发送邮件
# logger.info("当前执行用户不在邮件发送用户中，发送邮件给默认邮件接收用户")
receiver_address_list = []
receiver_address=[]
for address in receiver_address:
receiver_address_list.append(address['email_address'])
receiver = ",".join(receiver_address_list)
client = get_client_by_user(user)
kwargs = {
'bk_app_code': settings.APP_ID,
'bk_app_secret': settings.APP_TOKEN,
'bk_username': user,
'receiver': receiver,
'title': u'有孚云常用查询脚本执行结果通知',
'content': content,
'body_format': "Html"
}
result = client.cmsi.send_mail(kwargs)
if result['result']:
logger.info(u"邮件已发送至%s" % receiver)
#MailRecords.objects.create(receiver=receiver, content=content, sent_state="success")
else:
logger.info(u"邮件发送失败:%s" % result['message'])
def get_user_detail(username):
"""
param:username 用户名
return：{"email","*****@*****.**","telephone":""}
"""
client = get_client_by_user("admin")
kwargs = {
"id": f"{username}",
}
res = client.usermanage.retrieve_user(kwargs)
result = {"result": res['result'], "message": res['message']}
if res.get("result", False):
result.update({
'username': res['data']['username'],
'email': res['data']['email'],
'telephone': res['data']['telephone'],
'qq': res['data']['qq'],
'wx_openid': res['data']['wx_openid'],
'wx_userid': res['data']['wx_userid']
})
else:
logger.warning(f"获取用户信息失败 接口名称(retrieve_user) 请求参数({kwargs})")
return result
def execute_script_log(script_content, script_param, ip):
"""
执行脚本命令，并获取执行log
"""
user = User.objects.get(username='******')
client = get_client_by_user(user.username)
# base64 快速执行脚本需要的参数，并执行client
fast_execute_script_result = fast_execute_script(client, script_content,
script_param, ip)
logger.info(fast_execute_script_result)
# 如果快速脚本调用成功，执行log日志查询，获取执行内容
if fast_execute_script_result['message'] == 'success':
job_instance_id = fast_execute_script_result['data']['job_instance_id']
get_job_instance_log_result = get_job_instance_log(
client, job_instance_id)
# 如果日志查询成功，提取内容
if get_job_instance_log_result['message'] == 'success':
# 匹配log_content规则
regex = r"(?<='log_content': ').*?(?=')"
return re.findall(regex, str(get_job_instance_log_result),
re.MULTILINE)
else:
return None
def search_host_by_business(request):
client = get_client_by_user(request)
dict_data = json.loads(request.body)
params = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": request.user.username,
"bk_biz_id": dict_data['bk_biz_id'],
"condition": [],
"page": {
"start": 0,
"limit": 100,
}
}
res = client.cc.search_host(params)
infos = res['data']['info']
info_list = []
for info in infos[0:7]:
host = info['host']
dict = {
'business_id': dict_data['bk_biz_id'],
'ip': host['bk_host_innerip'],
'sys_name': host['bk_os_name'],
'host_name': host['bk_host_name'],
'cloud_region': 'default area',
'bk_cloud_id': host['bk_cloud_id'][0]['bk_obj_id'],
'men': host['bk_mem'],
'disk': host['bk_disk'],
'cpu': host['bk_cpu'],
}
info_list.append(dict)
return success_result(info_list)
def save_capacity_data(username='******'):
"""
执行 celery 异步任务
调用celery任务方法:
task.delay(arg1, arg2, kwarg1='x', kwarg2='y')
task.apply_async(args=[arg1, arg2], kwargs={'kwarg1': 'x', 'kwarg2': 'y'})
delay(): 简便方法，类似调用普通函数
apply_async(): 设置celery的额外执行选项时必须使用该方法，如定时（eta）等
详见 ：http://celery.readthedocs.org/en/latest/userguide/calling.html
"""
biz_id = 3 # 请修改为你需要执行的业务ID(可在蓝鲸配置平台里查询)
ip = '10.0.1.192' # 请修改为你需要执行的业务IP(可在蓝鲸配置平台里查询)
# 作业ID和脚本ID二选一
job_id = 12 # 请修改为你需要执行的作业ID(可在蓝鲸作业平台里查询)
script_id = 0 # 请修改为你需要执行的脚本ID(可在蓝鲸作业平台里查询)
# 使用该方式调用云API时，请先将您的SaaS APPID 加入白名单 http://xx.xx.xx.xx/admin/bkcore/functioncontroller/
client = get_client_by_user(username)
result, job_instance_id = get_job_instance_id(client, biz_id, ip, job_id,
script_id)
if result:
count = 0
while True:
is_finish, capacity_data = get_host_capaticy(
client, biz_id, job_instance_id, ip)
if is_finish or count > 20:
break
count += 1
time.sleep(3)
def get_all_user(request):
client = get_client_by_user(request.user.username)
param = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": "******"
}
result = client.bk_login.get_all_user(param)
return_data = []
if result['result']:
for user in result['data']:
if user['bk_username'] == request.user.username:
continue
return_data.append({
'id': user['bk_username'],
'text': user['bk_username']
})
data = {'result': True, 'data': return_data}
else:
data = {'result': False, 'msg': [u"查询用户信息失败!!"]}
return render_json(data)
def search_set(request):
try:
request_data = json.loads(request.body)
app_id = request_data['app_id']
client = get_client_by_user(request.user.username)
param = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": '******',
"bk_biz_id": app_id,
"page": {
"start": 0,
"limit": 0,
"sort": "bk_set_id"
},
"fields": ['bk_set_name', 'bk_set_id'],
"condition": {}
}
result = client.cc.search_set(param)
data_list = []
if result['result']:
data_list = [{
'id': i['bk_set_id'],
'text': i['bk_set_name']
} for i in result['data']['info']]
return render_json({'result': True, 'data': data_list})
except Exception as e:
logger.error(e)
def check_service():
client = get_client_by_user('bk_four')
execute_check_service.apply_async(args=[client, 6])
now = datetime.datetime.now()
Operations.objects.create(celery_opra_time=now,
celery_opra_content='检查服务状态')
logger.error(u'开始调用check_service周期任务，当前时间：{}'.format(now))
def search_host_by_ip(request):
try:
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": ['192.168.165.51']
},
"condition": [{
"bk_obj_id": "biz",
"fields": [
"default",
"bk_biz_id",
"bk_biz_name",
],
"condition": []
}]
}
result = client.cc.search_host(kwargs)
d = {}
if result["result"]:
d = {}
return render_json({"result": True, "data": d})
except Exception as e:
logger.error(e)
def fast_script(username,
server,
script_content,
script_type=1,
script_timeout=3600):
'''
:param username: 用户名
:param server: {'app_id': 业务id,
'ip_list': [{'ip': 主机ip, 'source': 主机source}],
'account': 执行账号（root,administrator）}
:param script_content:脚本内容
:param script_type:脚本类型 1(shell脚本)、2(bat脚本)、3(perl脚本)、4(python脚本)、5(Powershell脚本)
:param script_timeout:超时时间
:return:
'''
client = get_client_by_user(username)
kwargs = {
"app_code": APP_ID,
"app_secret": APP_TOKEN,
"app_id": server["app_id"],
"username": username,
"content": base64.b64encode(script_content),
"ip_list": server["ip_list"],
"type": script_type,
"account": server["account"],
"script_timeout": script_timeout
}
result = client.job.fast_execute_script(kwargs)
if result["result"]:
task_id = result["data"]["taskInstanceId"]
time.sleep(2)
return get_ip_log_content(client, username, task_id)
else:
return {"result": False, "data": result["message"]}
def check_cpu_util():
task_id = '2'
app_id = '3'
target_ip = '1:10.0.1.109'
steps = [{"ipList": target_ip, "stepId": 2}]
client = get_client_by_user('admin')
result = client.job.execute_task({
"app_id": app_id,
"task_id": task_id,
"steps": steps
})
execute_status = 'Waiting'
while (execute_status != 'Finished'):
time.sleep(5)
execute_status = check_tasks_status(result['data']['taskInstanceId'])
result_new = get_instance_detail(result['data']['taskInstanceId'])
log_content = result_new['data'][0]['stepAnalyseResult'][0][
'ipLogContent'][0]['logContent']
# ip = result_new['data'][0]['stepAnalyseResult'][0]['ipLogContent'][0]['ip']
# print log_content
CpuUtil.objects.create(log=log_content,
time=datetime.now(),
ip=result_new['data'][0]['stepAnalyseResult'][0]
['ipLogContent'][0]['ip'],
userspace=float(log_content.split()[26]),
systemspace=float(log_content.split()[28]),
idle=float(log_content.split()[35]))
return result_new
def get_access_token_from_esb(self):
"""
从ESB获取access_token
"""
client = get_client_by_user('admin')
esb_result = client.esb.get_weixin_access_token({})
return esb_result
def get_monitor_detail():
logger.error('开始')
hosts = Host.objects.filter(is_deleted=False)
host_list = [i.toDic() for i in hosts]
ip_dic = {}
for host in host_list:
if host["app_id"] in ip_dic.keys():
ip_dic[host["app_id"]].append({"ip": host['ip_address'], "bk_cloud_id": host["cloud_id"]})
else:
ip_dic[host["app_id"]] = []
ip_dic[host["app_id"]].append({"ip": host['ip_address'], "bk_cloud_id": host["cloud_id"]})
client = get_client_by_user("admin")
script = """
#!/bin/bash
MEMORY=$(free -m | awk 'NR==2{printf "%.2f%%", $3*100/$2 }')
DISK=$(df -h)
CPU=$(top -bn1 | grep load | awk '{printf "%.2f%%", $(NF-2)}')
echo -e "$MEMORY|$CPU|$DISK"
"""
for biz_id in ip_dic.keys():
check_obj = {'app_id': biz_id, 'ip_list': ip_dic[biz_id]}
result = fast_execute_script(check_obj, client, "admin", 'root', script)
if result["result"]:
time.sleep(5)
detail = get_info_by_jobid(biz_id, result["data"])
logger.error(detail)
if detail["result"]:
sync_detail(detail["data"])
def search_hosts(request):
try:
request_data = json.loads(request.body)
set_id = request_data['set_id']
app_id = request_data['app_id']
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":
"set",
"fields": [
"default",
"bk_set_id",
"bk_set_name",
],
# 根据业务ID查询主机
"condition": [{
"field": "bk_set_id",
"operator": "$eq",
"value": int(set_id)
}]
}]
}
result = client.cc.search_host(kwargs)
host_list = []
if result["result"]:
for i in result['data']['info']:
host_list.append({
'host_ip':
i['host']['bk_host_innerip'],
'host_name':
i['host']['bk_host_name'],
'server_name':
i['host']['bk_host_name'],
'app_id':
app_id,
'bk_cloud_name':
i['host']['bk_cloud_id'][0]['bk_inst_name'],
'bk_cloud_id':
i['host']['bk_cloud_id'][0]['bk_inst_id'],
'os_type':
os_type[i['host']['bk_os_type']]
if i['host']['bk_os_type'] else '',
'bk_os_name':
i['host']['bk_os_name']
})
return render_json({"result": True, "data": host_list})
except Exception as e:
logger.error(e)
def async_task(bk_biz_id):
"""
定义一个 celery 异步任务
"""
# 创建操作记录
client = get_client_by_user('dingyu')
client.set_bk_api_ver('v2')
kwargs = {"bk_biz_id": bk_biz_id, "bk_job_id": 1019}
res = client.job.execute_job(kwargs)
task_id = res.get('data').get('job_instance_id')
while not client.job.get_job_instance_status({
'bk_biz_id': bk_biz_id,
'job_instance_id': task_id,
}).get('data').get('is_finished'):
print 'waiting job finished...'
time.sleep(1.2)
res = client.job.get_job_instance_log({
'bk_biz_id': bk_biz_id,
'job_instance_id': task_id
})
log_content = res['data'][0]['step_results'][0]['ip_logs'][0][
'log_content']
check_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
OptLog.objects.create(
operator='dingyu',
bk_biz_id=bk_biz_id,
bk_job_id=task_id,
opt_at=check_time,
host_list=res['data'][0]['step_results'][0]['ip_logs'][0]['ip'],
job_status=res['data'][0]['status'],
job_content=log_content)
def search_inst_detail(request):
try:
client = get_client_by_user(request.user.username)
param = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": '******',
"bk_obj_id": "mssql",
"page": {
"start": 0,
"limit": 0,
"sort": "-bk_inst_id"
},
"fields": {},
"condition": {
'bk_inst_name': 'mssql-192.168.169.22'
}
}
result = client.cc.search_inst_by_object(param)
inst_data = {}
if result['result']:
inst_data = {'inst_id': result['data']['info'][0]['bk_inst_id']}
return render_json({'result': True, 'data': inst_data})
except Exception as e:
logger.error(e)
def execute_platform_task(self, bk_token, kwargs):
'''
启动平台作业
'''
task_inst_id = task_inst_name = ''
try:
logger.info(u'job.execute_platform_task->kwargs: %s' % kwargs)
# client = get_client_by_bk_token(bk_token)
##########将执行job作业的用户改为
client = get_client_by_user('admin')
res = client.job.execute_platform_task(**kwargs)
logger.info(u'job.execute_platform_task->res: %s' % res)
if res.get('result', False):
code, result = 0, True # ijobs接口调用成功
data = res.get('data', {})
task_inst_id = data.get('taskInstanceId')
task_inst_name = data.get('taskInstanceName')
message = u'作业启动成功.'
else:
code, result = -1, False # ijobs接口调用失败
message = u'作业启动失败: %s' % res.get('message')
logger.error(message)
except Exception, e:
code, result = -10000, False # 接口调用异常
message = u'作业启动异常: %s' % e
logger.error(message)
