def IdQuery(request):
if request.method == 'POST':
clientip = request.META['REMOTE_ADDR']
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
minionsup, minionsdown = sapi.MinionStatus()
minion_list = []
logger.info('%s is requesting. %s' %
(clientip, request.get_full_path()))
for minion_id in minionsup:
minion_dict = {}
minion_dict['minion_id'] = minion_id
minion_dict['minion_status'] = 'up'
minion_list.append(minion_dict)
for minion_id in minionsdown:
minion_dict = {}
minion_dict['minion_id'] = minion_id
minion_dict['minion_status'] = 'down'
minion_list.append(minion_dict)
return HttpResponse(json.dumps(minion_list))
elif request.method == 'GET':
return HttpResponse('You get nothing!')
else:
return HttpResponse('nothing!')
def minionKeysReject(request):
'''
展示已经被拒绝的Minino keys；
:param request:
:return:
'''
user = request.user.username
dccn_list = []
dc_hosts = {}
dc_hosts_keys = {}
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
minions, minions_pre, minions_rej = sapi.allMinionKeys()
minions_rej_set = set(minions_rej)
dcs = DataCenter.objects.all()
for dc in dcs:
minion_info_dict = {}
hosts = HostList.objects.filter(dccn=dc.dccn)
dccn_list.append(dc.dccn)
for host in hosts:
minion_id = host.minionid
if minion_id in minions_rej_set:
minion_info_dict[minion_id] = host.ip
dc_hosts[dc.dccn] = minion_info_dict
dccn_list.sort()
return render(request, 'manage_keys_reject.html', {
'all_dc_list': dccn_list,
'all_minions_rej': dc_hosts
})
def manageMinionKeysAPI(request):
'''
前端选择不同状态、机房、维护人员下的Minion id相关信息，通过ajax后台请求并刷新页面；
:param request:
:return: [
{'192.168.220.201': 'CNET_HQ_SH_BETA_192_168_220_201'},
{'192.168.220.202': 'CNET_HQ_SH_BETA_192_168_220_202'},
...
]
'''
user = request.user.username
ip_list = []
serv_list = []
serv_dict = {}
if request.method == 'GET':
column = request.GET.get('col', '')
dcen = request.GET.get('dcen', '')
engi = request.GET.get('engi', '')
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password']
)
minions, minions_pre, minions_rej = sapi.allMinionKeys()
if column == 'acp':
result = clearUpMinionKyes(minions, dcen, engi)
elif column == 'pre':
result = clearUpMinionKyes(minions_pre, dcen, engi)
elif column == 'rej':
result = clearUpMinionKyes(minions_rej, dcen, engi)
else:
log.error("Unexpected execution here.")
for id in result:
id_list = id.split('_')
ip = '.'.join(id_list[4:])
ip_list.append(ip)
serv_dict[ip] = id
ip_list.sort()
for i in ip_list:
ipid_dict = {}
id = serv_dict.get(i)
ipid_dict[i] = id
serv_list.append(ipid_dict)
del ipid_dict
else:
log.error("Request the wrong way, need to GET method.")
keys_json = json.dumps(serv_list)
return HttpResponse(keys_json, content_type="application/json")
def manageMinionKeysAPI(request):
'''
前端选择不同状态、机房、维护人员下的Minion id相关信息，通过ajax后台请求并刷新页面；
:param request:
:return: [
{'192.168.220.201': 'CNET_HQ_SH_BETA_192_168_220_201'},
{'192.168.220.202': 'CNET_HQ_SH_BETA_192_168_220_202'},
...
]
'''
user = request.user.username
ip_list = []
serv_list = []
serv_dict = {}
if request.method == 'GET':
column = request.GET.get('col', '')
dcen = request.GET.get('dcen', '')
engi = request.GET.get('engi', '')
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
minions, minions_pre, minions_rej = sapi.allMinionKeys()
if column == 'acp':
result = clearUpMinionKyes(minions, dcen, engi)
elif column == 'pre':
result = clearUpMinionKyes(minions_pre, dcen, engi)
elif column == 'rej':
result = clearUpMinionKyes(minions_rej, dcen, engi)
else:
log.error("Unexpected execution here.")
for id in result:
id_list = id.split('_')
ip = '.'.join(id_list[4:])
ip_list.append(ip)
serv_dict[ip] = id
ip_list.sort()
for i in ip_list:
ipid_dict = {}
id = serv_dict.get(i)
ipid_dict[i] = id
serv_list.append(ipid_dict)
del ipid_dict
else:
log.error("Request the wrong way, need to GET method.")
keys_json = json.dumps(serv_list)
return HttpResponse(keys_json, content_type="application/json")
def acceptMinionKeys(request):
'''
Master将待接受的minion keys接受；
:param request:
:return:
'''
minion_id = request.GET.get('minion_id')
minion_id_strings = ','.join(minion_id_list)
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
ret = sapi.acceptKeys(minion_id_strings)
return HttpResponseRedirect(reverse('keys_unaccept'))
def manageMinionKeys(request):
'''
进入页面，首次展示已经接受的所有Minion ID，从这里获取并返回；
:param request:
:return:
'''
user = request.user.username
serv_list = []
ip_list = []
serv_dict = {}
dc_dict = {}
engi_dict ={}
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password']
)
minions, minions_pre, minions_rej = sapi.allMinionKeys()
# log.debug(str(minions))
dcs = DataCenter.objects.all()
for dc in dcs:
dc_dict[dc.dcen] = dc.dccn
egs = Dzhuser.objects.all()
for eg in egs:
engi_dict[eg.username] = eg.engineer
for id in minions:
id_list = id.split('_')
ip = '.'.join(id_list[4:])
ip_list.append(ip)
serv_dict[ip] = id
ip_list.sort()
for i in ip_list:
ipid_dict = {}
id = serv_dict.get(i)
ipid_dict[i] = id
serv_list.append(ipid_dict)
del ipid_dict
return render(
request,
'manage_keys.html',
{
'dc_dict': dc_dict,
'engi_dict': engi_dict,
'serv_list': serv_list
}
)
def server_collects(tgt='*', server_id=0):
server_list = SaltServer.objects.all()
contexts = {'server_list': server_list, 'server_id': server_id}
try:
try:
salt_server = SaltServer.objects.get(id=server_id)
except Exception as e: # id不存在时返回第一个
salt_server = SaltServer.objects.all()[0]
except Exception as e:
contexts.update({'error': e})
try:
sapi = SaltAPI(url=salt_server.url,
username=salt_server.username,
password=salt_server.password)
print salt_server.url
grains = sapi.SaltCmd(tgt=tgt, fun='grains.items',
client='local')['return'][0]
minions = sapi.key_list('manage.status', client='runner')['return'][0]
if salt_server and grains:
for i in grains.keys():
try:
server = Servers.objects.get(local_ip=i)
except:
server = Servers()
# if sapi.SaltCmd(tgt=i,fun='test.ping',client='local')['return'][0]:
if i in minions['up']:
minions_status = '0'
else:
minions_status = '1'
server.hostname = grains[i]['host']
server.local_ip = grains[i]['id']
server.OS = "%s %s" % (grains[i]['os'], grains[i]['osrelease'])
server.Mem = grains[i]['mem_total']
server.Cpus = grains[i]['num_cpus']
server.Cpu_type = grains[i]['cpu_model']
server.minion_id = grains[i]['id']
server.app = grains[i]['virtual']
server.server_status = minions_status
server.save()
contexts.update({
'success': u'%s 收集成功' % tgt,
'server_id': salt_server.id
})
if not grains:
contexts.update({'error': u'%s 主机不存在或者离线' % tgt})
except Exception as e:
contexts.update({'error': '%s %s' % (tgt, e)})
return contexts
def acceptMinionKeys(request):
'''
Master将待接受的minion keys接受；
:param request:
:return:
'''
minion_id = request.GET.get('minion_id')
minion_id_strings = ','.join(minion_id_list)
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
ret = sapi.acceptKeys(minion_id_strings)
return HttpResponseRedirect(reverse('keys_unaccept'))
def deleteRejectKeys(request):
'''
Master删除已经拒绝的minion keys;
:param request:
:return:
'''
minion_id_list = request.GET.getlist('rejectkeys')
minion_id_strings = ','.join(minion_id_list)
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
ret = sapi.deleteKeys(minion_id_strings)
return HttpResponseRedirect(reverse('keys_reject'))
def deleteMinionKeys(request):
'''
删除已经接受的minion keys；
:param request:
:return:
'''
minion_id = request.GET.get('minion_id')
minion_id_strings = minion_id.strip(',')
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
ret = sapi.deleteKeys(minion_id_strings)
return HttpResponseRedirect(reverse('keys_show'))
def deleteRejectKeys(request):
'''
Master删除已经拒绝的minion keys;
:param request:
:return:
'''
minion_id_list = request.GET.getlist('rejectkeys')
minion_id_strings = ','.join(minion_id_list)
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
ret = sapi.deleteKeys(minion_id_strings)
return HttpResponseRedirect(reverse('keys_reject'))
def deleteMinionKeys(request):
'''
删除已经接受的minion keys；
:param request:
:return:
'''
minion_id = request.GET.get('minion_id')
minion_id_strings = minion_id.strip(',')
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
ret = sapi.deleteKeys(minion_id_strings)
return HttpResponseRedirect(reverse('keys_show'))
def QueryMinion(request):
if request.method == 'POST':
clientip = request.META['REMOTE_ADDR']
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
data = json.loads(request.body)
logger.info('%s is requesting %s. minion: %s' %
(clientip, request.get_full_path(), data))
minion_id = data[0]['minion_id']
info = sapi.GetGrains(minion_id)
#logger.info(info['return'][0])
return HttpResponse(json.dumps(info['return'][0]))
elif request.method == 'GET':
return HttpResponse('You get nothing!')
else:
return HttpResponse('nothing!')
def manageMinionKeys(request):
'''
进入页面，首次展示已经接受的所有Minion ID，从这里获取并返回；
:param request:
:return:
'''
user = request.user.username
serv_list = []
ip_list = []
serv_dict = {}
dc_dict = {}
engi_dict = {}
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
minions, minions_pre, minions_rej = sapi.allMinionKeys()
# log.debug(str(minions))
dcs = DataCenter.objects.all()
for dc in dcs:
dc_dict[dc.dcen] = dc.dccn
egs = Dzhuser.objects.all()
for eg in egs:
engi_dict[eg.username] = eg.engineer
for id in minions:
id_list = id.split('_')
ip = '.'.join(id_list[4:])
ip_list.append(ip)
serv_dict[ip] = id
ip_list.sort()
for i in ip_list:
ipid_dict = {}
id = serv_dict.get(i)
ipid_dict[i] = id
serv_list.append(ipid_dict)
del ipid_dict
return render(request, 'manage_keys.html', {
'dc_dict': dc_dict,
'engi_dict': engi_dict,
'serv_list': serv_list
})
def actionMinionKeys(request, action):
'''
管理minion keys，根据url捕获操作，如接受、拒绝、删除；
:param request: 'zhaogb-201,zhaogb-202,...,'（注意：有逗号结尾的字符串）
:param action: 通过url捕获的accept/reject/delect;
:return:
'''
action = action
minion_id = request.GET.get('minion_id')
minion_id_strings = minion_id.strip(',')
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
ret = sapi.actionKyes(minion_id_strings, action)
result_json = json.dumps(ret)
return HttpResponse(result_json, content_type='application/json')
def actionMinionKeys(request, action):
'''
管理minion keys，根据url捕获操作，如接受、拒绝、删除；
:param request: 'zhaogb-201,zhaogb-202,...,'（注意：有逗号结尾的字符串）
:param action: 通过url捕获的accept/reject/delect;
:return:
'''
action = action
minion_id = request.GET.get('minion_id')
minion_id_strings = minion_id.strip(',')
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
ret = sapi.actionKyes(minion_id_strings, action)
result_json = json.dumps(ret)
return HttpResponse(result_json, content_type='application/json')
def findJob(minionids_set, jid):
'''
:return:
'''
target_list_to_str = ','.join(list(minionids_set))
log.debug('target_list: %s' % str(target_list_to_str))
fun = 'saltutil.find_job'
diff_send_receive = []
loop = True
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
while loop:
counter = 0
# log.debug('The loop variable')
log.debug('into loop start [common.views.findJob]')
time.sleep(10)
find_job_result = sapi.masterToMinionContent(target_list_to_str, fun,
jid)
log.debug('find_job_result: %s' % str(find_job_result))
find_job_result_set = set(find_job_result.keys())
diff_send_receive.extend(
list(minionids_set.difference(find_job_result_set)))
find_job_result_value = find_job_result.values()
for eachDict in find_job_result_value:
if eachDict:
log.debug(
'The find job result is Dict, It is values list is Not null.'
)
break
else:
counter += 1
if counter == len(find_job_result_set):
loop = False
diff_send_receive_set = set(diff_send_receive)
return diff_send_receive_set
def service_fun(request, server_id):
url = SaltServer.objects.values('url').filter(id=server_id)[0]['url']
username = SaltServer.objects.values('username').filter(
id=server_id)[0]['username']
password = SaltServer.objects.values('password').filter(
id=server_id)[0]['password']
if request.method == 'GET':
active = request.GET.get('active')
project_id = request.GET.get('project_id')
script = SvnProject.objects.values('script').filter(
id=project_id)[0]['script']
tgt = SvnProject.objects.values('host').filter(
id=project_id)[0]['host']
arg = ''
if active == 'stop':
arg = script + ' stop'
elif active == 'start':
arg = script + ' start'
elif active == 'status':
arg = script + ' status'
elif active == 'restart':
arg = script + ' restart'
try:
sapi = SaltAPI(url=url, username=username, password=password)
info = sapi.SaltCmd(tgt=tgt,
fun='cmd.run',
client='local',
arg=arg)['return'][0][tgt]
result = {'ret': True, 'msg': u'%s' % info}
except Exception as e:
result = {'error': str(e)}
fh = files_history()
fh.username = request.session.get('username')
fh.active = '应用操作'
fh.active_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
fh.remote_server = SvnProject.objects.filter(id=project_id)[0].host
fh.path = result['msg']
fh.save()
return JsonResponse(result, safe=False)
def check_salt_minion_fun():
check_salt_minion = check_status.objects.filter(program='check_salt_minion').first()
if check_salt_minion.status == 1:
sapi = SaltAPI(
url = settings.SALT_API['url'],
username = settings.SALT_API['user'],
password = settings.SALT_API['password']
)
sapi_glb = SaltAPI(
url = settings.SALT_API['url_glb'],
username = settings.SALT_API['user'],
password = settings.SALT_API['password']
)
minionsup, minionsdown= sapi.MinionStatus()
minionsup_glb, minionsdown_glb= sapi_glb.MinionStatus()
minionsdown_glb = [id for id in minionsdown_glb if 'SC' in id]
else:
minionsdown = []
minionsdown_glb = []
if len(minionsdown) != 0:
send_mail(get_mail_list('check_salt_minion'),'Attention: salt_minion','Minion Down:'+ '\n\t' +'\n\t'.join(minionsdown))
if len(minionsdown_glb) != 0:
send_mail(admin_mail_addr,'Attention: 市场部服务器故障','Minion Down:'+ '\n\t' +'\n\t'.join(minionsdown_glb))
end_time['check_salt_minion'] = time()
def minionKeysAccept(request):
'''
展示Master已经接受的所有Minion keys；
:param request:
:return:
'''
user = request.user.username
dccn_list = []
dc_hosts = {}
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password']
)
minions, minions_pre, minions_rej = sapi.allMinionKeys()
minions_set = set(minions)
dcs = DataCenter.objects.all()
for dc in dcs:
minion_info_dict = {}
hosts = HostList.objects.filter(dccn=dc.dccn)
dccn_list.append(dc.dccn)
for host in hosts:
minion_id = host.minionid
if minion_id in minions_set:
minion_info_dict[minion_id] = host.ip
dc_hosts[dc.dccn] = minion_info_dict
dccn_list.sort()
return render(
request,
'manage_keys_accept.html',
{
'all_dc_list': dccn_list,
'all_dc_hosts': dc_hosts
}
)
def __init__(self, tgt, fun, arg='', expr_form='glob', timeout=1800):
self.__tgt = tgt
self.__fun = fun
self.__arg = arg
self.__expr_form = expr_form
self.__timeout = timeout
self.tgt_list = []
self.info = {}
#get saltapi url
global sapi
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
def findJob(minionids_set, jid):
'''
:return:
'''
target_list_to_str = ','.join(list(minionids_set))
log.debug('target_list: %s' % str(target_list_to_str))
fun = 'saltutil.find_job'
diff_send_receive = []
loop = True
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
while loop:
counter = 0
# log.debug('The loop variable')
log.debug('into loop start [common.views.findJob]')
time.sleep(10)
find_job_result = sapi.masterToMinionContent(target_list_to_str, fun, jid)
log.debug('find_job_result: %s' % str(find_job_result))
find_job_result_set = set(find_job_result.keys())
diff_send_receive.extend(list(minionids_set.difference(find_job_result_set)))
find_job_result_value = find_job_result.values()
for eachDict in find_job_result_value:
if eachDict:
log.debug('The find job result is Dict, It is values list is Not null.')
break
else:
counter += 1
if counter == len(find_job_result_set):
loop = False
diff_send_receive_set = set(diff_send_receive)
return diff_send_receive_set
def state_fun(request, server_id):
try:
salt_server = SaltServer.objects.get(id=server_id)
except: # id不存在时返回第一个
salt_server = SaltServer.objects.all()
if salt_server:
salt_server = salt_server[0]
else:
return render(request, 'saltstack/state.html',
{'apiinfo': u'请先添加SaltServer API'})
sapi = SaltAPI(url=salt_server.url,
username=salt_server.username,
password=salt_server.password)
try:
env = request.GET.get('env')
roots = sapi.SaltRun(
client='wheel',
fun='file_roots.list_roots')['return'][0]['data']['return']
dirs = roots[env][0]
states = []
for root, dirs in dirs.items(
): # root="/srv/salt/prod/" dirs={"init":{"epel.sls":"f",}}
for dir, files in dirs.items(
): # dir='init' or 'top.sls' files={"epel.sls":"f",}
if dir == '.svn':
dir = '.svn'
elif files == "f" and dir.endswith('.sls'):
states.append(dir[0:-4])
elif isinstance(files, dict):
for sls, f in files.items():
if f == 'f' and sls.endswith('.sls'):
states.append('%s.%s' % (dir, sls[0:-4]))
result = sorted(states)
except Exception as e:
result = e
return HttpResponse(json.dumps(result))
def key_list(request, server_id):
server_list = SaltServer.objects.all()
try:
salt_server = SaltServer.objects.get(id=server_id)
except: # id不存在时返回第一个
salt_server = SaltServer.objects.all()
if salt_server:
salt_server = salt_server[0]
else:
return render(request, 'saltstack/command.html',
{'apiinfo': u'请先添加SaltServer API'})
sapi = SaltAPI(url=salt_server.url,
username=salt_server.username,
password=salt_server.password)
context = {
'salt_server': salt_server,
'server_list': server_list,
'url': 'key_list'
}
if request.method == 'POST':
if request.POST.get('accept'):
accept_minion = request.POST.get('accept')
sapi.key_list(fun='key.accept', match=accept_minion)
else:
delete_minion = request.POST.get('delete')
sapi.key_list(fun='key.delete', match=delete_minion)
key_status = sapi.key_list('key.list_all')['return']
minions_accept = key_status[0]['data']['return']['minions']
minions_denied = key_status[0]['data']['return']['minions_denied']
minions_rejected = key_status[0]['data']['return']['minions_rejected']
minions_pre = key_status[0]['data']['return']['minions_pre']
# minion_down = sapi.key_list('manage.status', client='runner')['return']
minions = minions_accept + minions_denied + minions_rejected + minions_pre
insert = []
for minion in minions_accept:
try:
m = Minions.objects.get(minion=minion)
m.status = "Accepted"
m.save()
except:
insert.append(
Minions(minion=minion,
saltserver=salt_server,
status="Accepted"))
for minion in minions_rejected:
try:
m = Minions.objects.get(minion=minion)
m.status = "Rejected"
m.save()
except:
insert.append(
Minions(minion=minion,
saltserver=salt_server,
status="Rejected"))
for minion in minions_pre:
try:
m = Minions.objects.get(minion=minion)
m.status = "Unaccepted"
m.save()
except:
insert.append(
Minions(minion=minion,
saltserver=salt_server,
status="Unaccepted"))
Minions.objects.bulk_create(insert)
# if len(minion_down[0]['down']) > 0:
# minion_down = minion_down[0]['down']
# else:
# minion_down = []
context.update({
'minions': minions,
'minion_down': "",
'minions_pre': minions_pre
})
return render(request, 'saltstack/key_list.html', context)
def deployProgramApi(request):
'''
模块部署功能，前端页面提交的数据由该函数处理，执行完毕后返回json格式数据到api；
:param request:
:return:
'''
user = request.user.username
salt_module = 'state.sls'
get_errors = []
errors = []
result_dict = {}
if request.method == 'GET':
check_tgt = request.GET.get('tgt', '')
check_dc_list = request.GET.get('datacenter', '')
check_arg = request.GET.get('sls', '')
module_detection = moduleDetection(salt_module, user)
if module_detection:
get_errors.append(module_detection)
log.debug('{0}'.format(str(module_detection)))
if not (check_tgt or check_dc_list):
get_errors.append(u'需要输入服务器IP或选择机房！')
log.error('Did not enter servers ip or choose data center.')
if not check_arg:
get_errors.append(u'请选择将要进行的操作！')
log.error('Not select the file of salt state.')
if get_errors:
for error in get_errors:
errors.append(error.encode('utf-8'))
result_dict['errors'] = errors
else:
tgt = request.GET.get('tgt', '')
dc = request.GET.get('datacenter', '')
arg = request.GET.get('sls', '')
dc_clean = dc.strip(',')
log.debug(str(dc_clean))
dc_list = dc_clean.split(',')
target_list = tgt.split(',')
tgt_mixture_list = copy.deepcopy(dc_list)
tgt_mixture_list.extend(target_list)
if tgt:
minion_id_from_tgt_set = targetToMinionID(tgt)
else:
minion_id_from_tgt_set = set([])
if dc:
log.debug(str(dc_list))
minion_id_from_dc_set = datacenterToMinionID(dc_list)
else:
minion_id_from_dc_set = set([])
all_minion_id_set = minion_id_from_tgt_set.union(minion_id_from_dc_set)
# log.debug('The all target minion id set: {0}'.format(str(all_minion_id_set)))
if all_minion_id_set:
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
module_lock = moduleLock(salt_module, user)
if '*' in tgt_mixture_list:
jid = sapi.asyncMasterToMinion('*', salt_module, arg)
else:
tgt_list_to_str = ','.join(list(all_minion_id_set))
jid = sapi.asyncMasterToMinion(tgt_list_to_str, salt_module, arg)
if dc_list:
operate_tgt = dc_list[0]
elif tgt:
operate_tgt = target_list[0]
else:
operate_tgt = 'unknown'
op_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
op_user = arg
op_tgt = '%s...' % operate_tgt
p1 = OperateRecord.objects.create(
nowtime=op_time,
username=user,
user_operate=op_user,
simple_tgt=op_tgt,
jid=jid)
find_job = findJob(all_minion_id_set, jid)
result = mysqlReturns(jid)
module_unlock = moduleUnlock(salt_module, user)
ret, hostfa, hosttr = outFormat(result)
# log.debug(str(ret))
recv_ips_list = ret.keys()
send_recv_info = manageResult(all_minion_id_set, recv_ips_list)
send_recv_info['succeed'] = hosttr
send_recv_info['failed'] = hostfa
saveRecord = ReturnRecord.objects.create(
jid=jid,
tgt_total=send_recv_info['send_count'],
tgt_ret=send_recv_info['recv_count'],
tgt_succ=send_recv_info['succeed'],
tgt_fail=send_recv_info['failed'],
tgt_unret=send_recv_info['unrecv_count'],
tgt_unret_list=send_recv_info['unrecv_strings']
)
result_dict['result'] = ret
result_dict['info'] = send_recv_info
else:
log.info('The all target minion id set is Null.')
set_null = u'数据库中没有找到输入的主机，请确认输入是否正确！'
result_dict['errors'] = set_null.encode('utf-8')
ret_json = json.dumps(result_dict)
return HttpResponse(ret_json, content_type='application/json')
def deployProgramApi(request):
'''
模块部署功能，前端页面提交的数据由该函数处理，执行完毕后返回json格式数据到api；
:param request:
:return:
'''
user = request.user.username
salt_module = 'state.sls'
get_errors = []
errors = []
result_dict = {}
if request.method == 'GET':
check_tgt = request.GET.get('tgt', '')
check_dc_list = request.GET.get('datacenter', '')
check_arg = request.GET.get('sls', '')
module_detection = moduleDetection(salt_module, user)
if module_detection:
get_errors.append(module_detection)
log.debug('{0}'.format(str(module_detection)))
if not (check_tgt or check_dc_list):
get_errors.append(u'需要输入服务器IP或选择机房！')
log.error('Did not enter servers ip or choose data center.')
if not check_arg:
get_errors.append(u'请选择将要进行的操作！')
log.error('Not select the file of salt state.')
if get_errors:
for error in get_errors:
errors.append(error.encode('utf-8'))
result_dict['errors'] = errors
else:
tgt = request.GET.get('tgt', '')
dc = request.GET.get('datacenter', '')
arg = request.GET.get('sls', '')
dc_clean = dc.strip(',')
log.debug(str(dc_clean))
dc_list = dc_clean.split(',')
target_list = tgt.split(',')
tgt_mixture_list = copy.deepcopy(dc_list)
tgt_mixture_list.extend(target_list)
if tgt:
minion_id_from_tgt_set = targetToMinionID(tgt)
else:
minion_id_from_tgt_set = set([])
if dc:
log.debug(str(dc_list))
minion_id_from_dc_set = datacenterToMinionID(dc_list)
else:
minion_id_from_dc_set = set([])
all_minion_id_set = minion_id_from_tgt_set.union(
minion_id_from_dc_set)
# log.debug('The all target minion id set: {0}'.format(str(all_minion_id_set)))
if all_minion_id_set:
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
module_lock = moduleLock(salt_module, user)
if '*' in tgt_mixture_list:
jid = sapi.asyncMasterToMinion('*', salt_module, arg)
else:
tgt_list_to_str = ','.join(list(all_minion_id_set))
jid = sapi.asyncMasterToMinion(tgt_list_to_str,
salt_module, arg)
if dc_list:
operate_tgt = dc_list[0]
elif tgt:
operate_tgt = target_list[0]
else:
operate_tgt = 'unknown'
op_time = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime(time.time()))
op_user = arg
op_tgt = '%s...' % operate_tgt
p1 = OperateRecord.objects.create(nowtime=op_time,
username=user,
user_operate=op_user,
simple_tgt=op_tgt,
jid=jid)
find_job = findJob(all_minion_id_set, jid)
result = mysqlReturns(jid)
module_unlock = moduleUnlock(salt_module, user)
ret, hostfa, hosttr = outFormat(result)
# log.debug(str(ret))
recv_ips_list = ret.keys()
send_recv_info = manageResult(all_minion_id_set, recv_ips_list)
send_recv_info['succeed'] = hosttr
send_recv_info['failed'] = hostfa
saveRecord = ReturnRecord.objects.create(
jid=jid,
tgt_total=send_recv_info['send_count'],
tgt_ret=send_recv_info['recv_count'],
tgt_succ=send_recv_info['succeed'],
tgt_fail=send_recv_info['failed'],
tgt_unret=send_recv_info['unrecv_count'],
tgt_unret_list=send_recv_info['unrecv_strings'])
result_dict['result'] = ret
result_dict['info'] = send_recv_info
else:
log.info('The all target minion id set is Null.')
set_null = u'数据库中没有找到输入的主机，请确认输入是否正确！'
result_dict['errors'] = set_null.encode('utf-8')
ret_json = json.dumps(result_dict)
return HttpResponse(ret_json, content_type='application/json')
minion_id_from_tgt_set = targetToMinionID(tgt)
else:
minion_id_from_tgt_set = set([])
if dc:
log.debug(str(dc_list))
minion_id_from_dc_set = datacenterToMinionID(dc_list)
else:
minion_id_from_dc_set = set([])
all_minion_id_set = minion_id_from_tgt_set.union(
minion_id_from_dc_set)
log.debug('The all target minion id set: {0}'.format(
str(all_minion_id_set)))
if all_minion_id_set:
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
module_lock = moduleLock('cmd.run', user)
if '*' in tgt_mixture_list:
jid = sapi.asyncMasterToMinion('*', 'cmd.run', arg)
else:
tgt_list_to_str = ','.join(list(all_minion_id_set))
jid = sapi.asyncMasterToMinion(tgt_list_to_str, 'cmd.run',
arg)
if dc_list:
operate_tgt = dc_list[0]
elif tgt:
operate_tgt = target_list[0]
#set django env settings
os.environ['DJANGO_SETTINGS_MODULE'] = 'phxweb.settings'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "phxweb.settings")
from monitor.models import project_t, minion_t
from phxweb import settings
from saltstack.saltapi import SaltAPI
from requests.packages.urllib3.exceptions import InsecureRequestWarning
# 禁用安全请求警告
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
#获取salt接口，接入rest接口，获取salt信息
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
#minion_id_list = ['CP_NG_HK_83_36', 'CP_NG_HK_85_10', 'CP_NG_HK_34_106', 'CP_NG_HK_153_1', 'CP_NG_HK_179_204']
#minion_id_list = ['CP_NG_HK_50_4', 'CP_NG_HK_224_181', 'CP_NG_HK_224_152', 'CP_NG_HK_224_249']
#
#for minion_id in minion_id_list:
# insert = project_t(
# product = 'UC',
# project = 'CAIPIAO',
# minion_id = minion_id,
# domain = 'uc22.com',
# uri = '/',
# info = 'high defense',
# )
# insert.save()
#!/usr/bin/env python
#-_- coding:utf-8 -_-
import os,sys,datetime,logging,json
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)))
reload(sys)
sys.setdefaultencoding('utf8')
from monitor import settings
from saltstack.saltapi import SaltAPI
#from saltstack.saltapi_bak import SaltAPI
from scripts.tomcat import get_mail_list
basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
#获取salt接口，接入rest接口，获取salt信息
sapi = SaltAPI(
url = settings.SALT_API['url'],
username = settings.SALT_API['user'],
password = settings.SALT_API['password']
)
#data = sapi.ClientLocal(["GLB_10_153", "GLB_10_154"], 'cmd.run', '#uptime')
##data = sapi.masterToMinionContent("GLB_10_153, GLB_10_154", #'cmd.run', 'uptime')
#print data
#sys.exit()
#data = sapi.checkMinion(['GLB_10_153','GLB_10_154'])
data = sapi.ClientLocal(["GLB_10_153", "GLB_10_154"], 'cmd.run', 'uptime')
print type(data)
print data[0]['GLB_10_153']
#up, down = sapi.MinionStatus()
#print up+down
if tgt:
minion_id_from_tgt_set = targetToMinionID(tgt)
else:
minion_id_from_tgt_set = set([])
if dc:
log.debug(str(dc_list))
minion_id_from_dc_set = datacenterToMinionID(dc_list)
else:
minion_id_from_dc_set = set([])
all_minion_id_set = minion_id_from_tgt_set.union(minion_id_from_dc_set)
log.debug('The all target minion id set: {0}'.format(str(all_minion_id_set)))
if all_minion_id_set:
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
module_lock = moduleLock('cmd.run', user)
if '*' in tgt_mixture_list:
jid = sapi.asyncMasterToMinion('*', 'cmd.run', arg)
else:
tgt_list_to_str = ','.join(list(all_minion_id_set))
jid = sapi.asyncMasterToMinion(tgt_list_to_str, 'cmd.run', arg)
if dc_list:
operate_tgt = dc_list[0]
elif tgt:
operate_tgt = target_list[0]
else:
def cmd_exec(request, server_id):
server_list = SaltServer.objects.all()
try:
salt_server = SaltServer.objects.get(id=server_id)
except: # id不存在时返回第一个
salt_server = SaltServer.objects.all()
if salt_server:
salt_server = salt_server[0]
else:
return render(request, 'saltstack/command.html',
{'apiinfo': u'请先添加SaltServer API'})
sapi = SaltAPI(url=salt_server.url,
username=salt_server.username,
password=salt_server.password)
minion_group = MinionGroup.objects.all()
minions = sapi.key_list(
'key.list_all')['return'][0]['data']['return']['minions']
# minions = MinionGroup.objects.minions.all()
tgt = info = cmd_exec_result = minion_list = ''
context = {
'salt_server': salt_server,
'server_list': server_list,
'minions': minions,
'url': 'cmd_exec'
}
exec_module = "cmd.run"
if request.method == 'POST':
try:
ip_list = request.POST.get('minion')
cmd_args = request.POST.get('arg')
group = request.POST.get('group')
if group:
minions = MinionGroup.objects.get(
groupname=group).minions.all()
else:
minions = MinionGroup.objects.get(
groupname="All").minions.all()
if not cmd_args:
info = '请输入执行命令！'
elif ip_list:
tgt = ip_list
cmd_exec_result = sapi.SaltCmd(tgt,
exec_module,
client='local',
arg=cmd_args,
expr_form='list')['return'][0]
else:
for i in minions.values('minion'):
minion_list += i['minion'] + ','
tgt = minion_list.strip(',')
cmd_exec_result = sapi.SaltCmd(tgt,
exec_module,
client='local',
arg=cmd_args,
expr_form='list')['return'][0]
context.update({
'cmd_exec_result': cmd_exec_result,
'info': info,
'arg': cmd_args,
'tgt': tgt,
'group': group,
'minions': minions
})
except Exception as e:
if request.POST.get('minion'):
tgt = request.POST.get('minion')
if request.POST.get('minions'):
tgt = request.POST.get('minions')
cmd_exec_result = e
context.update({'error': e})
##添加审计记录
fh.username = request.session.get('username')
fh.active = 'exec command'
fh.active_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
fh.remote_server = tgt
fh.path = cmd_exec_result
fh.save()
context.update({'minion_group': minion_group})
return render(request, 'saltstack/command.html', context)
def saltinfo(tgt):
sapi = SaltAPI(url, username, password)
grains = sapi.SaltCmd(tgt=tgt, fun='grains.items',
client='local')['return'][0]
disk = sapi.SaltCmd(tgt=tgt, fun='disk.usage', client='local')['return'][0]
info = sapi.SaltCmd(tgt=tgt, fun='cmd.run', client='local',
arg='uptime')['return'][0]
hostname = grains[tgt]['host']
ip = grains[tgt]['ip4_interfaces'][device0][0]
OS = grains[tgt]['os'] + ' ' + grains[tgt]['osrelease'] + '.' + grains[
tgt]['osarch']
disk_all = float(disk[tgt]['/']['1K-blocks']) / 1000 / 1000
disk_free = float(disk[tgt]['/']['available']) / 1000 / 1000
disk_used = float(disk[tgt]['/']['used']) / 1000 / 1000
disk_used_p = disk[tgt]['/']['capacity']
Manufacturer = grains[tgt]['manufacturer']
saltstack_version = grains[tgt]['saltversion']
mem_total = grains[tgt]['mem_total']
cpu_logical_cores = grains[tgt]['num_cpus']
cpu_model = grains[tgt]['cpu_model']
uptime = info[tgt].split(',')[0]
loadavg = info[tgt].split(',')[-3:]
loadavg_1 = loadavg[0].strip(' load average:')
loadavg_5 = loadavg[1]
loadavg_15 = loadavg[2]
login_user_num = sapi.SaltCmd(tgt=tgt,
fun='cmd.run',
client='local',
arg='who |wc -l')['return'][0][tgt]
processs = sapi.SaltCmd(tgt=tgt,
fun='cmd.run',
client='local',
arg="ps -A -ostat")['return'][0][tgt]
S = R = Z = 0
for process in processs:
if 'S' in process:
S += 1
elif 'R' in process:
R += 1
elif 'Z' in process:
Z += 1
LocalData = {
'uptime': uptime,
'ip': ip,
'hostname': hostname,
'os': OS,
'disk_all': disk_all,
'disk_free': disk_free,
'disk_used': disk_used,
'disk_used_p': disk_used_p,
'loadavg_1': loadavg_1,
'loadavg_5': loadavg_5,
'loadavg_15': loadavg_15,
'salt_version': saltstack_version,
'mem_total': mem_total,
'cpu_physical_num': cpu_model,
'cpu_logical_cores': cpu_logical_cores,
'process_num': S + R + Z,
'process_S': S,
'process_R': R,
'process_Z': Z,
'login_user_num': login_user_num,
'Manufacturer': Manufacturer,
}
return LocalData
#!/usr/bin/env python
#-_- coding:utf-8 -_-
import os, sys, datetime, logging
sys.path.append(
os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)))
reload(sys)
sys.setdefaultencoding('utf8')
from monitor import settings
from saltstack.saltapi import SaltAPI
from scripts.tomcat import get_mail_list
basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
#获取salt接口，接入rest接口，获取salt信息
sapi = SaltAPI(url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
minionsup, minionsdown = sapi.MinionStatus()
def deploy_fun(request, server_id):
#SVN功能按钮
if request.is_ajax() and request.method == 'GET':
tgt = request.GET.get('tgt', '')
path = request.GET.get('path', '').encode("utf-8")
active = request.GET.get('active', '')
project_id = request.GET.get('project_id', '')
try:
salt_server = SaltServer.objects.get(id=server_id)
sapi = SaltAPI(url=salt_server.url,
username=salt_server.username,
password=salt_server.password)
if project_id:
project = SvnProject.objects.get(id=project_id) #指定项目
path = project.path + '/' + project.target
tgt = project.host
else:
project = None #项目不存在
projects = SvnProject.objects.filter(host=tgt)
for p in projects:
if path.startswith(p.path + '/' + p.target): #项目子目录
project = p
#SvnProject里没有记录时自动创建，但密码需要在后台设置
if not project:
svn_info = sapi.SaltCmd(client='local',
tgt=tgt,
fun='svn.info',
arg=path,
arg1='fmt=dict')['return'][0][tgt][0]
if isinstance(svn_info, dict):
result = {
'ret': False,
'msg': u'SVN项目不存在，请在后台页面添加！',
'add': True
}
else:
result = {'ret': False, 'msg': u'错误：%s' % svn_info}
#提交
elif active == 'commit' or active == 'update':
status = sapi.SaltCmd(client='local',
tgt=tgt,
fun='svn.status',
arg=path)['return'][0][tgt]
for s in status.split('\n'):
l = s.split(' ')
if l[0] == '?':
sapi.SaltCmd(client='local',
tgt=tgt,
fun='svn.add',
arg=path,
arg0=path + '/' + l[-1],
arg2='username=%s' % project.username,
arg3='password=%s' % project.password)
elif l[0] == '!':
sapi.SaltCmd(client='local',
tgt=tgt,
fun='svn.remove',
arg=path,
arg0=path + '/' + l[-1],
arg2='username=%s' % project.username,
arg3='password=%s' % project.password)
ci = sapi.SaltCmd(client='local',
tgt=tgt,
fun='svn.commit',
arg=path,
arg1='msg=commit from %s' % tgt,
arg2='username=%s' % project.username,
arg3='password=%s' %
project.password)['return'][0][tgt]
result = {'ret': True, 'msg': u"提交成功！\n%s" % ci}
#更新（先提交否则会冲突）
if active == 'update':
up = sapi.SaltCmd(client='local',
tgt=tgt,
fun='svn.update',
arg=path,
arg2='username=%s' % project.username,
arg3='password=%s' %
project.password)['return'][0][tgt]
result = {
'ret': True,
'msg': u"提交成功！\n%s\n更新成功！\n%s" % (ci, up)
}
##更新完成后更新项目状态
svn_info = sapi.SaltCmd(
client='local',
tgt=project.host,
fun='svn.info',
arg=path,
arg1='fmt=dict')['return'][0][project.host][0]
if isinstance(svn_info, dict):
if project.url == svn_info['URL']:
project.status = u"已发布"
project.info = u"最近修改时间：%s\n最近修改版本：%s\n最新版本：%s" % (
svn_info["Last Changed Date"][0:20],
svn_info["Last Changed Rev"], svn_info["Revision"])
else:
project.status = u"冲突"
project.info = u"SVN路径不匹配：\n本地SVN为'%s'\n项目SVN为'%s'" % (
svn_info['URL'], project.url)
project.save()
except Exception as e:
result = {'ret': False, 'msg': u'错误：%s' % e}
fh = files_history()
fh.username = request.session.get('username')
fh.active = 'svn update'
fh.active_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
fh.remote_server = SvnProject.objects.filter(id=project_id)[0].host
fh.path = result['msg']
fh.save()
return JsonResponse(result, safe=False)
def state_exec(request, server_id):
ret = state = ''
server_list = SaltServer.objects.all()
try:
salt_server = SaltServer.objects.get(id=server_id)
except: # id不存在时返回第一个
salt_server = SaltServer.objects.all()
if salt_server:
salt_server = salt_server[0]
else:
return render(request, 'saltstack/state.html',
{'apiinfo': u'请先添加SaltServer API'})
sapi = SaltAPI(url=salt_server.url,
username=salt_server.username,
password=salt_server.password)
# envs = sapi.SaltRun(client='runner', fun='fileserver.envs')['return'][0]
envs = glob_config("salt_api", "envs").split(',')
minions = sapi.key_list(
'key.list_all')['return'][0]['data']['return']['minions']
env = envs[0]
minion_group = MinionGroup.objects.all()
context = {
'minions': minions,
"minion_group": minion_group,
'ret': ret,
'envs': envs,
'env': env,
'state': state,
'salt_server': salt_server,
'server_list': server_list,
'url': 'state_exec'
}
if request.method == 'POST':
try:
if request.POST.get('tgt'):
minion = request.POST.get('tgt')
else:
minion = minions[0]
if request.POST.get('env'):
env = request.POST.get('env')
state = request.POST.get('state')
if minion and state:
ret = sapi.SaltCmd(tgt=minion,
fun='state.sls',
client='local',
arg=state,
arg1='saltenv=%s' % env)['return'][0]
roots = sapi.SaltRun(
client='wheel',
fun='file_roots.list_roots')['return'][0]['data']['return']
dirs = roots[env][0]
states = []
for root, dirs in dirs.items(
): # root="/srv/salt/prod/" dirs={"init":{"epel.sls":"f",}}
for dir, files in dirs.items(
): # dir='init' or 'top.sls' files={"epel.sls":"f",}
if dir == '.svn':
dir = '.svn'
elif files == "f" and dir.endswith('.sls'):
states.append(dir[0:-4])
elif isinstance(files, dict):
for sls, f in files.items():
if f == 'f' and sls.endswith('.sls'):
states.append('%s.%s' % (dir, sls[0:-4]))
result = sorted(states)
if result and not state:
state = result[0]
context.update({
'minion': minion,
'ret': ret,
'states': result,
'env': env,
'state': state
})
except Exception as e:
context.update({'error': e})
fh.username = request.session.get('username')
fh.active = u'state 编排'
fh.active_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
fh.remote_server = ''
fh.path = state
fh.save()
return render(request, 'saltstack/state.html', context)
def checkout(request, server_id):
server_list = SaltServer.objects.all()
try:
salt_server = SaltServer.objects.get(id=server_id)
except: # id不存在时返回第一个
salt_server = SaltServer.objects.all()[0]
try:
project_id = request.GET.get('project_id')
except:
project_id = ''
project_list = SvnProject.objects.filter(
salt_server=salt_server).order_by('host')
contexts = {
'server_list': server_list,
'salt_server': salt_server,
'project_list': project_list
}
if project_list and project_id:
try:
sapi = SaltAPI(url=salt_server.url,
username=salt_server.username,
password=salt_server.password)
result = sapi.SaltRun(client='runner', fun='manage.status')
contexts['minions_up'] = result['return'][0]['up']
#刷新页面检测并更新项目状态
project = SvnProject.objects.filter(id=project_id)[0]
path = project.path + '/' + project.target
svn_info = sapi.SaltCmd(
client='local',
tgt=project.host,
fun='svn.info',
arg=path,
arg1='fmt=dict')['return'][0][project.host][0]
if isinstance(svn_info, dict):
if project.url == svn_info['URL']:
project.status = u"已发布"
project.info = u"最近修改时间：%s\n最近修改版本：%s\n最新版本：%s" % (
svn_info["Last Changed Date"][0:20],
svn_info["Last Changed Rev"], svn_info["Revision"])
else:
project.status = u"冲突"
project.info = u"SVN路径不匹配：\n本地SVN为'%s'\n项目SVN为'%s'" % (
svn_info['URL'], project.url)
else:
#根路径不存在时创建
if not sapi.SaltCmd(
client='local',
tgt=project.host,
fun='file.directory_exists',
arg=project.path)['return'][0][project.host]:
sapi.SaltCmd(client='local',
tgt=project.host,
fun='file.mkdir',
arg=project.path)
#目录未被版本控制，可能SVN未安装
if not sapi.SaltCmd(
client='local',
tgt=project.host,
fun='pkg.version',
arg='subversion')['return'][0][project.host]:
sapi.SaltCmd(client='local',
tgt=project.host,
fun='pkg.install',
arg='subversion')
#签出项目、获取信息并存入库
sapi.SaltCmd(client='local',
tgt=project.host,
fun='svn.checkout',
arg=project.path,
arg0='target=%s' % project.target,
arg1='remote=%s' % project.url,
arg2='username=%s' % project.username,
arg3='password=%s' % project.password)
#签出项目后更新项目状态
svn_info = sapi.SaltCmd(
client='local',
tgt=project.host,
fun='svn.info',
arg=path,
arg1='fmt=dict')['return'][0][project.host][0]
project.status = u"已发布"
project.info = u"最近修改时间：%s\n最近修改版本：%s\n最新版本：%s" % (
svn_info["Last Changed Date"][0:20],
svn_info["Last Changed Rev"], svn_info["Revision"])
project.save()
result = {'ret': True, 'msg': u'检出成功'}
except Exception as error:
result = {'ret': False, 'msg': u'错误：项目目录冲突'}
fh = files_history()
fh.username = request.session.get('username')
fh.active = 'svn checkout'
fh.active_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
fh.remote_server = SvnProject.objects.filter(id=project_id)[0].host
fh.path = result['msg']
fh.save()
return JsonResponse(result, safe=False)
def repairHistoryDataAPI(request):
'''
:param request:
:return:
'''
user = request.user.username
data_path = '/srv/salt/dzh_store/mobileserver/DATA/'
state_module = 'state.sls'
get_errors = []
errors = []
result_dict = {}
if request.method == 'GET':
module_detection = moduleDetection(state_module, user)
if module_detection:
get_errors.append(module_detection)
if not request.GET.get('datacenter', ''):
get_errors.append(u'需要指定目标机房，才能允许后续操作！')
if not request.GET.get('stockexchange', ''):
get_errors.append(u'亲，需要指定本次将要补数据的市场！')
if not request.GET.get('sls', ''):
get_errors.append(u'行情程序需要重启吗？请选择之一！')
if not os.path.exists(data_path):
get_errors.append(u'目录：{0} 不存在！'.format(data_path))
log.error("The data path:{0} not exist.".format(data_path))
if get_errors:
for error in get_errors:
errors.append(error.encode('utf8'))
result_dict['errors'] = errors
else:
get_dc_str = request.GET.get('datacenter')
get_exch_str = request.GET.get('stockexchange')
get_sls = request.GET.get('sls')
dc_clean = get_dc_str.strip(',')
getdclist = dc_clean.split(',')
exch_clean = get_exch_str.strip(',')
getexchlist = exch_clean.split(',')
getstatesls = get_sls
if get_dc_str:
result_host_set = datacenterToMinionID(getdclist)
else:
result_host_set = set([])
stkexch_set = set(os.listdir(data_path))
clear_dir = stkexch_set.difference(set(getexchlist))
for exchcode in clear_dir:
day_path = os.path.join(data_path, exchcode, 'history/day')
day_files = os.listdir(day_path)
if day_files:
for dyfile in day_files:
dyfile_path = os.path.join(day_path,dyfile)
os.remove(dyfile_path)
log.info('Delete Other Market Success')
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
module_lock = moduleLock(state_module, user)
if '*' in getdclist:
jid = sapi.asyncMasterToMinion(getstatesls)
else:
tgt_list_to_str = ','.join(list(result_host_set))
jid = sapi.asyncMasterToMinion(tgt_list_to_str,getstatesls)
module_unlock = moduleUnlock(state_module, user)
if getexchlist:
operate_tgt = getexchlist[0]
else:
operate_tgt = 'unknown'
op_time = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time()))
op_user = getstatesls
op_tgt = '%s...' % operate_tgt
p1 = OperateRecord.objects.create(
nowtime=op_time,
username=user,
user_operate=op_user,
simple_tgt=op_tgt,
jid=jid)
find_job = findJob(result_host_set,jid)
result = mysqlReturns(jid)
ret, hostfa, hosttr = outFormat(result)
recv_ips_list = ret.keys()
send_recv_info = manageResult(result_host_set, recv_ips_list)
send_recv_info['succeed'] = hosttr
send_recv_info['failed'] = hostfa
saveRecord = ReturnRecord.objects.create(
jid=jid,
tgt_total=send_recv_info['send_count'],
tgt_ret=send_recv_info['recv_count'],
tgt_succ=send_recv_info['succeed'],
tgt_fail=send_recv_info['failed'],
tgt_unret=send_recv_info['unrecv_count'],
tgt_unret_list=send_recv_info['unrecv_strings']
)
result_dict['result'] = ret
result_dict['info'] = send_recv_info
ret_json = json.dumps(result_dict)
return HttpResponse(ret_json, content_type='application/json')
def remoteExecuteApi(request):
'''
远程执行的命令通过JQuery(ajax)提交到这里，处理后返回结果json;
:param request:
:return:
'''
user = request.user.username
get_errors = []
errors = []
result_dict = {}
danger_cmd = ('rm', 'reboot', 'init', 'shutdown', 'poweroff')
if request.method == 'GET':
check_tgt = request.GET.get('tgt', '')
check_dc_list = request.GET.get('datacenter', '')
check_arg = request.GET.get('arg', '')
module_detection = moduleDetection('cmd.run', user)
if module_detection:
get_errors.append(module_detection)
if not (check_tgt or check_dc_list):
get_errors.append(u'需要指定目标主机或目标机房！')
if not check_arg:
get_errors.append(u'请输入将要执行的命令！')
else:
arg_list = check_arg.split(';')
for i in arg_list:
command = i.split()[0]
if command in danger_cmd:
get_errors.append(u'%s 命令危险，不允许使用！' % command)
if get_errors:
for error in get_errors:
errors.append(error.encode('utf-8'))
result_dict['errors'] = errors
else:
tgt = request.GET.get('tgt', '')
dc = request.GET.get('datacenter', '')
arg = request.GET.get('arg', '')
dc_clean = dc.strip(',')
log.debug(str(dc_clean))
dc_list = dc_clean.split(',')
target_list = tgt.split(',')
tgt_mixture_list = copy.deepcopy(dc_list)
tgt_mixture_list.extend(target_list)
if tgt:
minion_id_from_tgt_set = targetToMinionID(tgt)
else:
minion_id_from_tgt_set = set([])
if dc:
log.debug(str(dc_list))
minion_id_from_dc_set = datacenterToMinionID(dc_list)
else:
minion_id_from_dc_set = set([])
all_minion_id_set = minion_id_from_tgt_set.union(minion_id_from_dc_set)
log.debug('The all target minion id set: {0}'.format(str(all_minion_id_set)))
if all_minion_id_set:
sapi = SaltAPI(
url=settings.SALT_API['url'],
username=settings.SALT_API['user'],
password=settings.SALT_API['password'])
# module_lock = moduleLock('cmd.run', user)
if '*' in tgt_mixture_list:
jid = sapi.asyncMasterToMinion('*', 'cmd.run', arg)
else:
tgt_list_to_str = ','.join(list(all_minion_id_set))
jid = sapi.asyncMasterToMinion(tgt_list_to_str, 'cmd.run', arg)
if dc_list:
operate_tgt = dc_list[0]
elif tgt:
operate_tgt = tgt_list[0]
else:
operate_tgt = 'unknown'
op_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
op_user = arg
op_tgt = '%s...' % operate_tgt
p1 = OperateRecord.objects.create(
nowtime=op_time,
username=user,
user_operate=op_user,
simple_tgt=op_tgt,
jid=jid)
find_job = findJob(all_minion_id_set, jid)
result = mysqlReturns(jid)
# module_unlock = moduleUnlock('cmd.run', user)
ret, hostfa, hosttr = outFormat(result)
# log.debug(str(ret))
recv_ips_list = ret.keys()
send_recv_info = manageResult(all_minion_id_set, recv_ips_list)
saveRecord = ReturnRecord.objects.create(
jid=jid,
tgt_total=send_recv_info['send_count'],
tgt_ret=send_recv_info['recv_conut'],
tgt_unret=send_recv_info['unrecv_conut'],
tgt_unret_list=send_recv_info['unrecv_strings']
)
result_dict['result'] = ret
result_dict['info'] = send_recv_info
else:
log.info('The all target minion id set is Null.')
set_null = u'数据库中没有找到输入的主机，请确认输入是否正确！'
result_dict['errors'] = set_null.encode('utf-8')
ret_json = json.dumps(result_dict)
return HttpResponse(ret_json, content_type='application/json')
