def get(self, request):
if request.user.id is not None:
menu_data = self.get_all_menus(request)
# print('UserBuildMenuView: ',menu_data)
return XopsResponse(menu_data, status=OK)
else:
return XopsResponse('请登录后访问!', status=FORBIDDEN)
def get(self, request, *args, **kwargs):
if request.user.id is not None:
# 获取当前用户所拥有的所有菜单数据
menu_data = self.get_all_menus(request)
return XopsResponse(menu_data, status=OK)
else:
return XopsResponse('请登录后访问!', status=FORBIDDEN)
def post(self, request, *args, **kwargs):
try:
# 原始文件名
raw_file_name = request.FILES['file'].name
# 文件的后缀
suffix = os.path.splitext(raw_file_name)[-1][1:]
# 时间戳作为头像的名称
name = str(time.time()).split('.')[0].strip()
# 图片名称
avatar_name = 'avatar/{}/{}.{}'.format(request.user.username, name,
suffix)
# pillow 打开图片，保存副本
avatar = Image.open(request.data['file'])
# 生成缩略图
thumb = self.make_thumb(avatar)
# 判断文件的父文件是否存在，不存在则创建
if not os.path.exists('media/avatar/' + request.user.username):
os.makedirs('media/avatar/' + request.user.username)
# 文件保存的具体路径（只保存缩略图）
avatar_file_path = os.path.join(settings.MEDIA_ROOT,
avatar_name).replace('\\', '/')
thumb.save(avatar_file_path)
# 将保存的路径更新到数据库
request.user.image = avatar_name.replace('\\', '/')
request.user.save()
# 返回结果
return XopsResponse(status=OK, data={'avatar': avatar_name})
except Exception as e:
return XopsResponse(status=BAD)
def get(self, request, *args, **kwargs):
if request.user.id is not None:
# 根据当前用户所拥有的角色，返回相应的权限列表
perms = self.get_permission_from_role(request)
skills = self.get_skills(request)
data = {
'id':
request.user.id,
'username':
request.user.username,
'avatar':
request._request._current_scheme_host + '/media/' +
str(request.user.image),
'email':
request.user.email,
'is_active':
request.user.is_active,
'createTime':
request.user.date_joined,
'roles':
perms,
'skills':
skills,
}
# 如果存在用户 id 则返回当前用户的相关数据给前端（用户 id，用户名，头像，邮箱，...）
return XopsResponse(data, status=OK)
else:
return XopsResponse('请登录后访问!', status=FORBIDDEN)
def set_password(self, request, pk=None):
perms = UserInfoView.get_permission_from_role(request)
user = UserProfile.objects.get(id=pk)
if 'admin' in perms or 'user_all' in perms or request.user.is_superuser:
new_password1 = request.data['new_password1']
new_password2 = request.data['new_password2']
if new_password1 == new_password2:
user.set_password(new_password2)
user.save()
return XopsResponse('密码修改成功!')
else:
return XopsResponse('新密码两次输入不一致!',
status=status.HTTP_400_BAD_REQUEST)
else:
old_password = request.data['old_password']
if check_password(old_password, user.password):
new_password1 = request.data['new_password1']
new_password2 = request.data['new_password2']
if new_password1 == new_password2:
user.set_password(new_password2)
user.save()
return XopsResponse('密码修改成功!')
else:
return XopsResponse('新密码两次输入不一致!',
status=status.HTTP_400_BAD_REQUEST)
else:
return XopsResponse('旧密码错误!',
status=status.HTTP_400_BAD_REQUEST)
def post(self,request):
# print(request.user)
# print(request)
if request.data['exec'] == 'mod_run':
try:
# pass
run_model.delay(group_name=str(request.user),group_ids=None,custom_model_name=None,host_ids=request.data['hostIds'],
selected_module_name=request.data['module'],module_args=request.data['args'])
# self.run_model(group_name=str(request.user),group_ids=None,custom_model_name=None,host_ids=request.data['hostIds'],selected_module_name=request.data['module'],module_args=request.data['args'])
# gen_resource = GenResource()
#
# # if group_ids == ['custom'] or group_ids == ['all']:
# # resource = gen_resource.gen_host_list(host_ids)
# # else:
# # resource = gen_resource.gen_group_dict(group_ids)
# resource = gen_resource.gen_host_list(request.data['hostIds'])
# print(resource)
# host_list = [DeviceInfo.objects.get(id=host_id).hostname for host_id in request.data['hostIds']]
# print(host_list)
# sources=','.join(host_list)
# print(sources)
# module_name = request.data['module'] if request.data['module'] != 'custom' else request.data['module']
#
# unique_key = '{}.{}.{}'.format(request.data['hostIds'], module_name, request.data['args'])
#
#
# ans = ANSRunner(resource=resource,sources=sources, sock=get_channel_layer(),group_name=str(request.user))
# ans.run_module(host_list=host_list, module_name=module_name, module_args=request.data['args'])
msg='已经发送到后端执行,请耐心等待！'
return XopsResponse(msg,status=200)
except Exception as e:
print(e)
else:
return XopsResponse('没有任何实质参数', status=200)
def create(self, request, *args, **kwargs):
rd = ''.join(random.sample(string.digits, 2))
request.data['voucher_number'] = datetime.now().strftime(
"%Y%m%d%H%M") + rd
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.validated_data['net_weight'] = request.data['gross_weight'] - \
request.data['vehicle_weight'] - request.data['sub_weight']
serializer.validated_data[
'net_weight'] = serializer.validated_data['net_weight'] * 2
if serializer.validated_data['net_weight'] < 0:
return XopsResponse('净重结果是负数,输入异常')
if serializer.validated_data['naure'] == 1: #代存
serializer.validated_data['amount_pay'] = 0
serializer.validated_data['unit_price'] = 0
elif serializer.validated_data['naure'] == 0:
serializer.validated_data['amount_pay'] = Decimal(
serializer.validated_data['net_weight']) * Decimal(
request.data['unit_price'])
else:
return XopsResponse('naure error')
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return XopsResponse(serializer.data, status=CREATED, headers=headers)
def post(self, request, *args, **kwargs):
username = request.data.get('username')
password = request.data.get('password')
user = authenticate(username=username, password=password)
if user:
payload = jwt_payload_handler(user)
return XopsResponse({'token': jwt.encode(payload, SECRET_KEY)},status=OK)
else:
return XopsResponse('用户名或密码错误!', status=BAD)
def update(self, request, *args, **kwargs):
msg = '修改成功'
print(request.data)
print(kwargs)
put_obj = WarehousEntry.objects.get(voucher_number=kwargs['pk'])
serializer = self.get_serializer(data=request.data,
instance=put_obj,
many=False)
serializer.is_valid(raise_exception=True)
serializer.validated_data['net_weight'] = request.data['gross_weight'] - \
request.data['vehicle_weight'] - request.data['sub_weight']
serializer.validated_data[
'net_weight'] = serializer.validated_data['net_weight'] * 2
if serializer.validated_data['net_weight'] < 0:
return XopsResponse('净重结果是负数,输入异常')
if serializer.validated_data['net_weight'] < 0:
return XopsResponse('净重结果是负数,输入异常')
if serializer.validated_data['naure'] == 1: #代存
serializer.validated_data['amount_pay'] = 0
serializer.validated_data['amount_pay'] = 0
serializer.validated_data['actual_pay'] = 0
elif serializer.validated_data['naure'] == 0: #收购
serializer.validated_data['amount_pay'] = Decimal(
serializer.validated_data['net_weight']) * Decimal(
request.data['unit_price'])
else:
msg = 'naure error'
return XopsResponse(msg=msg)
if 1 == serializer.validated_data[
'pay'] and 0 == serializer.validated_data['naure']:
if serializer.validated_data['unit_price'] == 0:
msg = "代存订单需要设定收购单价,才能付款"
serializer.validated_data['actual_pay'] = 0
serializer.validated_data['pay'] = 0
else:
serializer.validated_data[
'actual_pay'] = serializer.validated_data['amount_pay']
msg = "付款成功"
elif 1 == serializer.validated_data[
'pay'] and 1 == serializer.validated_data['naure']:
serializer.validated_data['pay'] = 0
msg = "代存订单不能结账付款,修改为收购,设定单价在付款"
else:
serializer.validated_data['actual_pay'] = 0
msg = "设定欠账,已付款清零"
self.perform_update(serializer)
print(serializer.data)
return XopsResponse(serializer.data, msg=msg)
def post(self, request, format=None):
if request.data['excu'] == 'list':
try:
# request-data-injection.command-injection.001.source
app_log_path = request.data['app_log_path']
host = request.data['host']
connect = connect_init(host)
# request-data-injection.command-injection.001.sink
commands = "find %s -name '*.log'" % (app_log_path)
result = connect.run(commands).stdout
res = []
for i in result.split():
res.append(i)
res = filter(None, res)
connect.close()
http_status = OK
except Exception as e:
http_status = BAD
res = '执行错误:' + str(e)
return XopsResponse(res, status=http_status)
elif request.data['excu'] == 'filedown':
# request-data-injection.path-traversal.001.source
# request-data-injection.command-injection.002.source
file_path = request.data['file_path']
host = request.data['host']
file_name = os.path.basename(file_path)
dir_name = os.path.dirname(file_path)
old_file_name = os.path.splitext(file_name)
if old_file_name[1] == '.log':
new_file_name = old_file_name[0] + '.tar.gz'
connect = connect_init(host)
# request-data-injection.command-injection.002.sink
commands = 'mkdir -p /tmp/remote/ && tar czf /tmp/remote/%s -C %s %s' % (
new_file_name, dir_name, file_name)
connect.run(commands)
connect.get('/tmp/remote/' + new_file_name,
'/tmp/' + new_file_name)
# request-data-injection.path-traversal.001.sink
response = FileResponse(open('/tmp/' + new_file_name, 'rb'))
response['Content-Type'] = 'application/octet-stream'
response[
'Content-Disposition'] = 'attachment;filename="%s"' % old_file_name[
0]
# request-data-injection.command-injection.002.sink
commands = 'rm -f /tmp/remote/%s' % (new_file_name)
connect.run(commands)
connect.close()
# request-data-injection.path-traversal.001.sink
os.remove('/tmp/' + new_file_name)
return response
else:
return XopsResponse('请求文件格式不对!', status=BAD)
def post(self, request, *args, **kwargs):
username = request.data.get('username')
password = request.data.get('password')
user = authenticate(username=username, password=password)
if user:
payload = jwt_payload_handler(user)
# 用户登录成功后，返回生成好的 token 给前端（token 是动态生成的，每次用户登录成功后，值都是不同的）
return XopsResponse(
{'token': jwt.encode(payload, settings.SECRET_KEY)}, status=OK)
else:
return XopsResponse('用户名或密码错误!', status=BAD)
def get(self, request):
if request.user.id is not None:
perms = self.get_permission_from_role(request)
data = {
'id': request.user.id,
'username': request.user.username,
'avatar': request._request._current_scheme_host + '/media/' + str(request.user.image),
'email': request.user.email,
'is_active': request.user.is_active,
'createTime':request.user.date_joined,
'roles': perms
}
return XopsResponse(data, status=OK)
else:
return XopsResponse('请登录后访问!', status=FORBIDDEN)
def post(self, request, format=None):
if request.data['excu'] == 'list':
try:
app_log_path = request.data['app_log_path']
host = request.data['host']
auth_info, auth_key = auth_init(host)
connect = Shell(auth_info,
connect_timeout=5,
connect_kwargs=auth_key)
commands = "find %s -name '*.log'" % (app_log_path)
result = connect.run(commands).stdout
res = []
for i in result.split('\r\n'):
res.append(i)
res = filter(None, res)
connect.close()
http_status = OK
except Exception as e:
http_status = BAD
res = '执行错误:' + str(e)
return XopsResponse(res, status=http_status)
elif request.data['excu'] == 'filedown':
file_path = request.data['file_path']
host = request.data['host']
file_name = os.path.basename(file_path)
old_file_name = os.path.splitext(file_name)
if old_file_name[1] == '.log':
new_file_name = old_file_name[0] + '.tar.gz'
auth_info, auth_key = auth_init(host)
connect = Shell(auth_info,
connect_timeout=5,
connect_kwargs=auth_key)
commands = 'mkdir -p /tmp/remote/ && tar czf /tmp/remote/%s %s' % (
new_file_name, file_path)
connect.run(commands)
connect.get('/tmp/remote/' + new_file_name,
'/tmp/' + new_file_name)
response = FileResponse(open('/tmp/' + new_file_name, 'rb'))
response['Content-Type'] = 'application/octet-stream'
response[
'Content-Disposition'] = 'attachment;filename="%s"' % new_file_name
commands = 'rm -f /tmp/remote/%s' % (new_file_name)
connect.run(commands)
connect.close()
os.remove('/tmp/' + new_file_name)
return response
else:
return XopsResponse('请求文件格式不对!', status=BAD)
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
self.before_destroy(request, kwargs)
self.perform_destroy(instance)
return XopsResponse(status=NO_CONTENT)
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
page = self.paginate_queryset(queryset)
serializer = self.get_serializer(queryset, many=True)
tree_dict = {}
tree_data = []
group_dict = copy.deepcopy(self.group_sc.data)
for item in group_dict:
item['pid'] = None
tree_dict[item['id']] = item
tree_dict[9999] = {'id': 9999, 'name': '未分组', 'pid': None}
for i in serializer.data:
groups = i['groups']
print(groups)
if groups:
for g in groups:
temp_dict = {'id': i['id'], 'name': i['ip'], 'pid': g}
tree_dict[g].setdefault('children', []).append(temp_dict)
else:
# print('已执行')
temp_dict = {'id': i['id'], 'name': i['ip'], 'pid': 0}
tree_dict[9999].setdefault('children', []).append(temp_dict)
for k, v in tree_dict.items():
tree_data.append(v)
results = tree_data
if page is not None:
return self.get_paginated_response(results)
return XopsResponse(results)
def create(self, request, *args, **kwargs):
# 创建密码时自动绑定uid
request.data['uid'] = request.user.id
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return XopsResponse(serializer.data, status=CREATED, headers=headers)
def create(self, request, *args, **kwargs):
# 创建用户默认添加密码
request.data['password'] = '******'
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return XopsResponse(serializer.data, status=CREATED, headers=headers)
def get_paginated_response(self, data):
return XopsResponse({
'count': self.page.paginator.count,
'size':len(data),
'current':self.page.number,
# 'totalPage':int(self.page.paginator.count/self.page_size),
'results': data
})
def create(self, request, *args, **kwargs):
self.before_create(request)
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
# 自定义返回响应数据
return XopsResponse(serializer.data, status=CREATED, headers=headers)
def update(self, request, *args, **kwargs):
print(request.data)
id = kwargs['pk']
obj_role_file = AnsibleFileList.objects.get(id=id)
self.get_parent_path(obj_role_file.pid)
file = os.path.join(self.parent_path, obj_role_file.file_name)
result = {'file_name': file, 'file_content': request.data['file_content']}
with open(file,'w') as f:
f.write(request.data['file_content'])
return XopsResponse(data=result)
def get(self, request, format=None):
result = None
id = request.query_params['id']
repo = Project.objects.filter(id=int(id)).values('alias', 'repo_url', 'repo_mode')
path = self._path.rstrip('/') + '/' + str(id) + '_' + str(repo[0]['alias']) + '/' + repo[0]['alias']
if repo[0]['repo_mode'] == 'tag':
result = self.get_tag(path)
result = result.stdout.split('\n')
elif repo[0]['repo_mode'] == 'branch':
result = self.get_branch(path)
branches = result.stdout.split('\n')
result = [branch.strip().lstrip('origin/') for branch in branches if
not branch.strip().startswith('origin/HEAD')]
return XopsResponse(filter(None, result))
def retrieve(self, request, *args, **kwargs):
print(args)
print(kwargs)
id=kwargs['pk']
obj_role_file=AnsibleFileList.objects.get(id=id)
self.get_parent_path(obj_role_file.pid)
file=os.path.join(self.parent_path,obj_role_file.file_name)
content = ''
if os.path.exists(file):
with open(file, 'r') as f:
for line in f.readlines():
content = content + line
result={'file_name':file,'file_content':content}
return XopsResponse(data=result)
def post(self, request, format=None):
if request.data['id']:
old_project = Project.objects.get(id=request.data['id'])
new_project = copy.deepcopy(old_project)
new_project.pk = None
new_project.name = '复制___' + new_project.name
new_project.status = 'Failed'
new_project.save()
http_status = OK
msg = '复制成功!'
else:
http_status = BAD
msg = '复制失败!项目ID为空!'
return XopsResponse(msg, status=http_status)
def update(self, request, *args, **kwargs):
put_obj = OutStock.objects.get(voucher_number=kwargs['pk'])
serializer = self.get_serializer(data=request.data,
instance=put_obj,
many=False)
serializer.is_valid(raise_exception=True)
serializer.validated_data['net_weight'] = request.data['gross_weight'] - \
request.data['vehicle_weight']
serializer.validated_data[
'net_weight'] = serializer.validated_data['net_weight'] * 2
if serializer.validated_data['net_weight'] < 0:
return XopsResponse('净重结果是负数,输入异常')
serializer.validated_data['amount_pay'] = Decimal(
serializer.validated_data['net_weight']) * Decimal(
request.data['unit_price'])
if 1 == serializer.validated_data['pay']:
serializer.validated_data[
'actual_pay'] = serializer.validated_data['amount_pay']
elif 0 == serializer.validated_data['pay']:
serializer.validated_data['actual_pay'] = 0
self.perform_update(serializer)
return XopsResponse('ppp')
def destroy(self, request, *args, **kwargs):
# 删除用户时删除其他表关联的用户
instance = self.get_object()
id = str(kwargs['pk'])
projects = Project.objects.filter(
Q(user_id__icontains=id + ',') | Q(user_id__in=id) | Q(user_id__endswith=',' + id)).values()
if projects:
for project in projects:
user_id = project['user_id'].split(',')
user_id.remove(id)
user_id = ','.join(user_id)
Project.objects.filter(
id=project['id']).update(user_id=user_id)
ConnectionInfo.objects.filter(uid_id=id).delete()
self.perform_destroy(instance)
return XopsResponse(status=NO_CONTENT)
def model_detail(self, request, pk=None):
content_type = ContentType.objects.get(pk=pk)
app_name = content_type.app_label
model_name = content_type.model
model_obj = apps.get_model(app_name, model_name)
print(model_obj)
fields = []
print(model_obj._meta.fields)
for field in model_obj._meta.fields:
field_dic = {}
field_dic['name'] = field.name
field_dic['verbose_name'] = field.verbose_name
field_dic['type'] = field.get_internal_type()
field_dic['blank'] = field.blank
field_dic['editable'] = field.editable
fields.append(field_dic)
return XopsResponse(fields)
def destroy(self, request, *args, **kwargs):
# 删除其他关联资产的数据
instance = self.get_object()
id = str(kwargs['pk'])
projects = Project.objects.filter(
Q(server_ids__icontains=id + ',') | Q(server_ids__in=id)
| Q(server_ids__endswith=',' + id)).values()
if projects:
for project in projects:
server_ids = project['server_ids'].split(',')
server_ids.remove(id)
server_ids = ','.join(server_ids)
Project.objects.filter(id=project['id']).update(
server_ids=server_ids)
self.perform_destroy(instance)
return XopsResponse(status=NO_CONTENT)
def get(self, request, format=None):
organizations = Organization.objects.all()
serializer = OrganizationUserTreeSerializer(organizations, many=True)
tree_dict = {}
tree_data = []
for item in serializer.data:
new_item = {
'id': 'o' + str(item['id']),
'label': item['label'],
'pid': item['pid'],
'children': item['children']
}
tree_dict[item['id']] = new_item
for i in tree_dict:
if tree_dict[i]['pid']:
pid = tree_dict[i]['pid']
parent = tree_dict[pid]
parent['children'].append(tree_dict[i])
else:
tree_data.append(tree_dict[i])
return XopsResponse(tree_data)
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
page = self.paginate_queryset(queryset)
serializer = self.get_serializer(queryset, many=True)
tree_dict = {}
tree_data = []
try:
for item in serializer.data:
tree_dict[item['id']] = item
for i in tree_dict:
if tree_dict[i]['pid']:
pid = tree_dict[i]['pid']
parent = tree_dict[pid]
parent.setdefault('children', []).append(tree_dict[i])
else:
tree_data.append(tree_dict[i])
results = tree_data
except KeyError:
results = serializer.data
if page is not None:
return self.get_paginated_response(results)
return XopsResponse(results)
def post(self, request, format=None):
if request.data['excu'] == 'init':
# 项目初始化
id = request.data['id']
result = self.repo_init(id)
if result.exited == 0:
Project.objects.filter(id=id).update(status='Succeed')
info_logger.info('初始化项目:' + str(id) + ',执行成功!')
http_status = OK
msg = '初始化成功!'
else:
error_logger.error('初始化项目:%s 执行失败! 错误信息:%s' %
(str(id), result.stderr))
http_status = BAD
msg = '初始化项目:%s 执行失败! 错误信息:%s' % (str(id), result.stderr)
return XopsResponse(msg, status=http_status)
elif request.data['excu'] == 'deploy':
# 部署操作
id = request.data['id']
webuser = request.user.username
alias = request.data['alias']
self.start_time = time.strftime("%Y%m%d%H%M%S", time.localtime())
record_id = str(alias) + '_' + str(self.start_time)
name = '部署_' + record_id
DeployRecord.objects.create(name=name,
alias=alias,
status='Failed',
project_id=int(id))
Project.objects.filter(id=id).update(last_task_status='Failed')
local_log_path = self._path.rstrip('/') + '/' + str(
id) + '_' + str(request.data['alias']) + '/logs'
log = local_log_path + '/' + record_id + '.log'
version = request.data['version'].strip()
serverid = request.data['server_ids']
# 调用celery异步任务
deploy.delay(id, log, version, serverid, record_id, webuser,
self.start_time)
return XopsResponse(record_id)
elif request.data['excu'] == 'rollback':
# 回滚
id = request.data['id']
project_id = request.data['project_id']
alias = request.data['alias']
self.start_time = time.strftime("%Y%m%d%H%M%S", time.localtime())
record_id = str(alias) + '_' + str(self.start_time)
log = self._path.rstrip('/') + '/' + str(project_id) + '_' + str(
alias) + '/logs/' + record_id + '.log'
self.do_rollback(id, log, record_id)
return XopsResponse(record_id)
elif request.data['excu'] == 'deploymsg':
# 部署控制台消息读取
try:
id = request.data['id']
alias = request.data['alias']
record = request.data['record']
scenario = int(request.data['scenario'])
logfile = self._path.rstrip('/') + '/' + str(id) + '_' + str(
alias) + '/logs/' + record + '.log'
webuser = request.user.username
if scenario == 0:
local_tailf.delay(logfile, webuser, id)
http_status = OK
request_status = '执行成功!'
except Exception as e:
http_status = BAD
request_status = str(e)
return XopsResponse(request_status, status=http_status)
elif request.data['excu'] == 'readlog' and request.data[
'scenario'] == 1:
# 读取部署日志
try:
id = request.data['id']
alias = request.data['alias']
record = request.data['record']
logfile = self._path.rstrip('/') + '/' + str(id) + '_' + str(
alias) + '/logs/' + record + '.log'
response = FileResponse(open(logfile, 'rb'))
response['Content-Type'] = 'text/plain'
return response
except Exception:
http_status = BAD
request_status = '执行错误:文件不存在!'
return XopsResponse(request_status, status=http_status)
elif request.data['excu'] == 'app_start':
# 项目启动
try:
app_start = request.data['app_start']
host = request.data['host']
webuser = request.user.username
auth_info, auth_key = auth_init(host)
connect = Shell(auth_info,
connect_timeout=5,
connect_kwargs=auth_key)
app_start = app_start.strip().replace('&&',
'').replace('||', '')
connect.run(app_start, ws=True, webuser=webuser)
connect.close()
http_status = OK
request_status = '执行成功!'
except Exception as e:
http_status = BAD
request_status = '执行错误:' + str(e)
return XopsResponse(request_status, status=http_status)
elif request.data['excu'] == 'app_stop':
# 项目停止
try:
app_stop = request.data['app_stop']
host = request.data['host']
webuser = request.user.username
auth_info, auth_key = auth_init(host)
connect = Shell(auth_info,
connect_timeout=5,
connect_kwargs=auth_key)
app_stop = app_stop.strip().replace('&&', '').replace('||', '')
connect.run(app_stop, ws=True, webuser=webuser)
connect.close()
http_status = OK
request_status = '执行成功!'
except Exception as e:
http_status = BAD
request_status = '执行错误:' + str(e)
return XopsResponse(request_status, status=http_status)
elif request.data['excu'] == 'tail_start':
# 日志监控
try:
filter_text = str(request.data['filter'])
app_log_file = request.data['app_log_file']
host = request.data['host']
webuser = request.user.username
device_info = DeviceInfo.objects.filter(id=int(host)).values()
host = device_info[0]['hostname']
auth_type = device_info[0]['auth_type']
connect_info = ConnectionInfo.objects.filter(
hostname=host, auth_type=auth_type).values()
user = connect_info[0]['username']
passwd = connect_info[0]['password']
port = connect_info[0]['port']
tail = Tailf()
tail.remote_tail(host,
port,
user,
passwd,
app_log_file,
webuser,
filter_text=filter_text)
http_status = OK
request_status = '执行成功!'
except Exception as e:
http_status = BAD
request_status = str(e)
return XopsResponse(request_status, status=http_status)
elif request.data['excu'] == 'tail_stop':
# 日志监控停止
try:
webuser = request.user.username
redis = RedisObj()
redis.set('remote_tail_' + str(webuser), '1')
http_status = OK
request_status = '执行成功!'
except Exception as e:
http_status = BAD
request_status = str(e)
return XopsResponse(request_status, status=http_status)