def put(self, request, *args, **kwargs):
try:
_data = request.data
user_id = _data.get("user_id")
user = self.get_object(user_id)
if not user:
logger.error("admin user not exist: %s" % user_id)
ret = get_error_result("AdminUserNotExist")
return ret
# username = _data.get("username") or None
real_name = _data.get("real_name") or None
password = _data.get("password") or None
role_id = _data.get("role") or None
desc = _data.get("desc", "") or None
email = _data.get("email", "") or None
# if username: user.username = username
if real_name is not None: user.real_name = real_name
if password: user.password = create_md5(password)
if role_id: user.role_id = role_id
if desc is not None: user.desc = desc
if email is not None: user.email = email
user.save()
ret = get_error_result()
msg = "修改管理员用户信息: %s" % user_id
insert_operation_log(msg, ret)
return JSONResponse(ret)
except Exception as e:
logger.error("", exc_info=True)
return JSONResponse(get_error_result("OtherError"))
def post(self, request, *args, **kwargs):
# upgrade_package_uuid = request.data.get("upgrade_package_uuid", None)
upgrade_file_obj = request.FILES.get("file", None)
if not upgrade_file_obj:
logger.error("VOI terminal upgrade file upload error")
return JSONResponse(get_error_result("TerminalUpgradeFileError"))
return JSONResponse(voi_terminal_mgr.upload_upgrade(upgrade_file_obj))
def get_desktop_info(self, request, uuid):
logger.debug("start get instance info")
resp = get_error_result("Success")
try:
node = YzyNodes.objects.filter(deleted=False, uuid=uuid).first()
if not node:
logger.error("get desktop info error: ParameterError")
ret = get_error_result("ParameterError")
return JSONResponse(ret)
resp['data'] = {}
instances = YzyInstances.objects.filter(deleted=False,
host=node).all()
power_instance = instances.filter(
status=constants.STATUS_ACTIVE).count()
error_instance = instances.exclude(message='').count()
resp['data']['node_name'] = node.name
resp['data']['power_instance'] = power_instance
resp['data']['error_instance'] = error_instance
resp['data']['total_instance'] = len(instances)
resp['data']['shutdown_instance'] = len(instances) - power_instance
page = YzyWebPagination()
desktops = page.paginate_queryset(queryset=instances,
request=request,
view=self)
ser = YzyWarningInfoDesktopSerializer(instance=desktops,
many=True,
context={'request': request})
resp['data']['instances'] = ser.data
logger.info("get instance info success: %s", desktops)
return JSONResponse(resp)
except Exception as e:
logger.error("get instance info error:%s", e, exc_info=True)
ret = get_error_result("OtherError")
return JSONResponse(ret)
def put(self, request, *args, **kwargs):
role_id = kwargs.get("role")
user = request.user
options = request.data.get("options")
if not (role_id and options):
logger.error("update permission fail: parameter error")
ret = get_error_result("ParameterError")
return JSONResponse(ret, status=status.HTTP_200_OK)
role = YzyRole.objects.filter(deleted=False, id=role_id).first()
if not role:
logger.error("update permission fail: role not exist")
ret = get_error_result("RoleNotExistError")
return JSONResponse(ret, status=status.HTTP_200_OK)
if not user.is_superuser:
ret = get_error_result("SuperAdminOnlySetError")
return JSONResponse(ret, status=status.HTTP_200_OK)
menu_ids = []
self.get_ids(options, menu_ids)
_menus = self.get_menus(menu_ids)
try:
role.menus.clear()
except Exception as e:
logger.error("update permission fail: %s" % e, exc_info=True)
ret = get_error_result("OtherError")
return JSONResponse(ret, status=status.HTTP_200_OK)
for menu in _menus:
p = YzyRolePermission(role=role, menu=menu)
p.save()
ret = {"code": 0, "msg": "成功"}
return JSONResponse(ret, status=status.HTTP_200_OK)
def post(self, request):
try:
logger.info("post request: {}".format(request))
data = request.data
statis_hours = data.get('statis_hours', 0)
step_minutes = data.get('step_minutes', 0)
node_uuid = data.get('node_uuid', "")
if not (statis_hours and step_minutes and node_uuid):
pass
request_data = {
"statis_hours": statis_hours,
"step_minutes": step_minutes,
"node_uuid": node_uuid
}
ret = server_post('/api/v1/monitor/node/get_history_perf',
request_data)
_data = ret.get("data", {}).copy()
if _data:
ret['data'].clear()
ret['data'] = self.update_nic_order(_data)
return JSONResponse(ret)
except Exception as e:
logger.error("get node history performance data error:%s",
e,
exc_info=True)
ret = get_error_result("OtherError")
return JSONResponse(ret)
def publish(self, data, request):
tmp_path = data['path']
# base_path = self._get_template_storage_path()
#
# try:
# os.makedirs(base_path)
# except:
# pass
# data['path'] = os.path.join(base_path, data['uuid'])
ser = YzyBaseImagesSerializer(data=data, context={'request': request})
if ser.is_valid() and os.path.exists(tmp_path):
logger.info("save image info to db")
ser.save()
post_data = {
"pool_uuid": data['resource_pool'],
"image_id": data['uuid'],
"image_path": tmp_path,
"md5_sum": data['md5_sum']
}
# move(tmp_path, data['path'])
# os.remove(tmp_path)
logger.info("begin upload images to other node in resource pool")
ret = server_post('/resource_pool/images/upload', post_data)
if ret.get("code", -1) != 0:
logger.error("upload base image error, server return: %s", ret)
return JSONResponse(ret)
else:
if os.path.exists(tmp_path):
os.remove(tmp_path)
return JSONResponse(get_error_result("OtherError"))
return JSONResponse(ser.data)
def get(self, request, *args, **kwargs):
try:
upgrades = YzyTerminalUpgrade.objects.filter(deleted=False).exclude(platform="VOI").all()
ser = YzyTerminalUpgradeSerializer(instance=upgrades, many=True, context={'request': request})
return JSONResponse(get_error_result("Success", ser.data))
except Exception as e:
return JSONResponse(get_error_result("OtherError"))
def post(self, request, *args, **kwargs):
username = request.data.get("username", "")
option = request.data.get("option", "")
ret = get_error_result()
user = self.get_object_by_name(username, option)
if user:
ret = get_error_result("AdminUsernameExist")
return JSONResponse(ret)
return JSONResponse(ret)
def get(self, request, *args, **kwargs):
try:
upgrades = YzyTerminalUpgrade.objects.filter(
deleted=False, platform='VOI').order_by("-upload_at")[:10]
ser = YzyTerminalUpgradeSerializer(instance=upgrades,
many=True,
context={'request': request})
return JSONResponse(get_error_result("Success", ser.data))
except Exception as e:
return JSONResponse(get_error_result("OtherError"))
def post(self, request, *args, **kwargs):
pwd = request.data.get("password", "")
obj = YzyAdminUser.objects.filter(username="******").first()
if not obj or not obj.validate_password(pwd):
logger.error(
"user password check error: %s password check fail!!!" %
"admin")
ret = get_error_result("PasswordCheckError")
return JSONResponse(ret)
return JSONResponse(get_error_result("Success"))
def get(self, request, *args, **kwargs):
role_id = kwargs.get("role")
role = YzyRole.objects.filter(deleted=False, id=role_id).first()
if not role:
logger.error("get permissions fail role not exits:%s", role_id)
return JSONResponse(get_error_result("ParameterError"))
user = YzyAdminUser.objects.filter(deleted=False, role=role.id).first()
ids = self.get_menu_ids(role_id)
menu_list = self.parse_data(ids, user)
return JSONResponse({"options": menu_list}, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs):
try:
logger.info("system monitor post request")
req_data = {}
ret = server_post("/api/v1/index/get_voi_data", req_data)
return JSONResponse(ret)
except Exception as e:
logger.error("Get system monitor top data error: %s", e)
logger.error(''.join(traceback.format_exc()))
ret = get_error_result("OtherError")
return JSONResponse(ret)
def post(self, request, *args, **kwargs):
try:
logger.debug("system monitor post request")
statis_period = request.data.get("statis_period")
req_data = {"statis_period": int(statis_period)}
ret = server_post("/api/v1/index/get_top_data", req_data)
return JSONResponse(ret)
except Exception as err:
logger.error("Get system monitor top data error: %s", err)
logger.error(''.join(traceback.format_exc()))
ret = get_error_result("OtherError")
return JSONResponse(ret)
def get_edu_groups(self, request, *args, **kwargs):
"""
获取指定学期的教学分组列表
"""
term_uuid = kwargs.get("term_uuid", "")
if not term_uuid or not education_model.YzyTerm.objects.filter(deleted=False, uuid=term_uuid).first():
return JSONResponse(get_error_result("TermNotExist"))
edu_groups = education_model.YzyGroup.objects.filter(deleted=False, group_type=constants.EDUCATION_GROUP)
ser = TermEduGroupSerializer(instance=edu_groups, many=True, context={'request': request})
return JSONResponse(ser.data)
def post(self, request):
terminal_uuid = request.data.get("uuid")
option = request.data.get("option")
if not (terminal_uuid and option):
logger.error("post request error: param error")
return JSONResponse(get_error_result("ParameterError"))
if option == "terminal_hardware":
return self.get_hardware(terminal_uuid)
elif option == "export_resources":
return self.get_terminal_resources(terminal_uuid)
else:
logger.error("option error:%s", option)
return JSONResponse(get_error_result("ParameterError"))
def get(self, request, *args, **kwargs):
try:
logger.debug("get_resource_statistic request")
ret = get_error_result("Success")
ret["data"] = {}
node_query_set = YzyNodes.objects.filter(deleted=0).all()
online_node_cnt = len(
[x for x in node_query_set if x.status == "active"])
resource_pool_cnt = YzyResourcePools.objects.filter(
deleted=0).count()
instance_query_set = YzyInstances.objects.filter(deleted=0).all()
online_instance_cnt = len(
[x for x in instance_query_set if x.status == "active"])
terminal_query_set = YzyTerminal.objects.filter(deleted=0).all()
online_terminal_cnt = len(
[x for x in terminal_query_set if x.status == "1"])
ha_info = YzyHaInfo.objects.filter(deleted=False).first()
ret['data']['ha_enable_status'] = 0
if ha_info:
request_data = {"ha_info_uuid": ha_info.uuid}
resp = server_post("/controller/ha_status", request_data)
ret['data']['ha_enable_status'] = resp['data'][
'ha_enable_status']
_time = time.localtime()
ret['data']['current_time'] = time.strftime(
"%Y-%m-%d %H:%M", _time)
ret["data"]["online_node_cnt"] = online_node_cnt
ret["data"]["sum_node_cnt"] = len(node_query_set)
ret["data"]["online_instance_cnt"] = online_instance_cnt
ret["data"]["sum_instance_cnt"] = len(instance_query_set)
ret["data"]["online_terminal_cnt"] = online_terminal_cnt
ret["data"]["sum_terminal_cnt"] = len(terminal_query_set)
ret["data"]["resource_pool_cnt"] = resource_pool_cnt
ret["data"]["alarm_node_cnt"] = 0
ret["data"]["alarm_records_cnt"] = 0
lic_info = LicenseManager().info()
ret["data"]["license_status"] = lic_info['auth_type']
ret["data"]["trail_days"] = lic_info['expire_time']
ret["data"]["vdi_size"] = lic_info['vdi_size']
ret["data"]["voi_size"] = lic_info['voi_size']
ret['data']['current_version'] = 'V' + lic_info['version'].split(
'_')[-2] if lic_info['version'] else '0'
logger.debug("ret: {}".format(ret))
return JSONResponse(ret)
except Exception as err:
logger.error("get_resource_statistic error: %s", err)
logger.error(''.join(traceback.format_exc()))
ret = get_error_result("OtherError")
return JSONResponse(ret)
def get(self, request, *args, **kwargs):
group_uuid = request.GET.get("group_uuid", "")
query_set = YzyTerminal.objects.values("id", "terminal_id", "mac", "ip", "name", "status")
if group_uuid:
group_info = terminal_mgr.get_group_info(group_uuid)
if not group_info:
raise Http404()
group_name = group_info.name
query_set = query_set.filter(group_uuid=group_uuid)
else:
query_set = query_set.filter(Q(group_uuid__isnull=True) | Q(group_uuid = ''))
group_name = "未分组"
group_dict = {"name": group_name, "uuid": group_uuid, "open_num": 0, "close_num": 0}
terminals = query_set.order_by("terminal_id")
results = list()
for terminal in terminals:
results.append(terminal)
if str(terminal["status"]) == "0":
group_dict["close_num"] += 1
else:
group_dict["open_num"] += 1
# import pdb; pdb.set_trace()
# for i in ser.data:
# if i["status"] == "0":
# group_dict["close_num"] += 1
# else:
# group_dict["open_num"] += 1
# ret = terminal_mgr.get_all_terminal(request, group_type, group_uuid, _filter, page)
# return JSONResponse(ret)
ret = get_error_result("Success")
ret["data"] = {"results": results, "group_info": group_dict}
return JSONResponse(ret)
def post(self, request, *args, **kwargs):
ret = get_error_result("Success")
_data = request.data
password = _data.get("password")
if not password:
# ex = Exception("not input password!")
logger.error("create admin user error: not password input")
ret = get_error_result("NotPasswordInputError")
# return JSONResponse(ret)
else:
_data.update({"password": create_md5(password)})
ser = YzyAdminUserSerializer(data=_data,
context={'request': request})
if ser.is_valid():
ser.save()
# return Response(ser.data, status=status.HTTP_201_CREATED)
# return JSONResponse()
else:
msg = ser.errors
ret = get_error_result("ParamError")
ret["msg"] = msg
logger.info("create admin user: %s" % ret)
msg = "创建管理员用户: %s" % _data.get("username")
insert_operation_log(msg, ret)
return JSONResponse(ret)
def get(self, request, *args, **kwargs):
terminal_uuid = request.GET.get("terminal_uuid")
terminal = YzyVoiTerminalPerformance.objects.filter(
deleted=False, terminal_uuid=terminal_uuid).first()
terminal_obj = YzyVoiTerminal.objects.filter(
deleted=False, uuid=terminal_uuid).first()
if not terminal:
logger.error("get terminal monitor error: param error")
return JSONResponse(get_error_result("ParameterError"))
if not terminal_obj:
logger.error("get terminal monitor error: terminal not exist")
return JSONResponse(get_error_result("TerminalNotExistError"))
if not terminal_obj.status:
logger.error(
"get terminal monitor error: terminal status inactive")
return JSONResponse(get_error_result("TerminalOfflineError"))
ser = TerminalMonitorSerializer(instance=terminal,
context={"request": request})
return JSONResponse(ser.data)
def put(self, request):
_id = request.data.get("id")
desc = request.data.get("desc", '')
name = request.data.get("role", '')
role = YzyRole.objects.filter(deleted=False, id=_id).first()
if not role:
logger.error("update role fail: role not exits")
return JSONResponse(get_error_result("RoleNotExistError"))
if role.role != name and YzyRole.objects.filter(deleted=False,
role=name).all():
logger.error("update role fail: name exits")
return JSONResponse(get_error_result("NameAlreadyUseError"))
role.role = name
role.desc = desc
role.save()
ret = get_error_result("Success")
msg = "更新角色信息：%s" % role.role
insert_operation_log(msg, ret)
return JSONResponse(ret)
def delete(self, request):
_id = request.data.get("id", "")
role = YzyRole.objects.filter(deleted=False, id=_id).first()
user = YzyAdminUser.objects.filter(deleted=False, role=_id).first()
if not role:
logger.error("role not exist: %s", _id)
return JSONResponse(get_error_result("UserNotExistError"))
if user:
logger.error("the role is already referenced")
return JSONResponse(get_error_result("RoleAlreadyReferencedError"))
if user and user.is_superuser:
logger.error("Super administrator does not allow deletion:%s",
role.role)
return JSONResponse(get_error_result("SuperAdminNotDeleteError"))
role.delete()
ret = get_error_result("Success")
msg = "删除角色信息：%s" % role.role
insert_operation_log(msg, ret)
return JSONResponse(ret)
def delete(self, request, *args, **kwargs):
user_id = request.data.get("id", "")
user = YzyAdminUser.objects.filter(deleted=False, id=user_id).first()
if not user:
logger.error("user not exist: %s", user_id)
return JSONResponse(get_error_result("UserNotExistError"))
if user.is_superuser:
logger.error("Super administrator does not allow deletion:%s",
user.username)
return JSONResponse(get_error_result("SuperAdminNotDeleteError"))
template = YzyInstanceTemplate.objects.filter(
deleted=False, owner_id=user.id).first()
if template:
logger.error("delete admin error template under the account")
return JSONResponse(
get_error_result("TemplateUnderTheAccountError"))
user.delete()
ret = get_error_result("Success")
msg = "删除管理员用户信息：%s" % user.username
insert_operation_log(msg, ret)
return JSONResponse(ret)
def get(self, request, *args, **kwargs):
# ret = terminal_mgr.terminal_log_download(request)
_file = request.GET.get("file", "")
log_dir = constants.TERMINAL_LOG_PATH
file_path = os.path.join(log_dir, _file)
if not os.path.exists(file_path):
return JSONResponse(get_error_result("OtherError"))
response = FileResponse(open(file_path, 'rb'))
response['content_type'] = "application/octet-stream"
response['Content-Disposition'] = "attachment; filename*=utf-8''{}".format(escape_uri_path(_file))
return response
def post(self, request):
enable = request.data.get("enable", 1)
_id = request.data.get("id", "")
option = request.data.get("option", "")
if option == "role":
yzy_role = YzyRole.objects.filter(deleted=False, id=_id).first()
if yzy_role:
yzy_role.enable = enable
yzy_role.save()
logger.info("update role enable success")
return JSONResponse(get_error_result("Success"))
elif option == "admin_user":
user = YzyAdminUser.objects.filter(deleted=False, id=_id).first()
if user:
user.is_active = enable
user.save()
logger.info("update admin user enable success")
return JSONResponse(get_error_result("Success"))
else:
logger.error("update fail param error:%s", option)
return JSONResponse(get_error_result("ParameterError"))
return JSONResponse(get_error_result("ParameterError"))
def get(self, request, *args, **kwargs):
user = request.user
_role = user.role
permissions = user.role.yzyrolepermission_set.all()
menu_ids = []
for permission in permissions:
menu_ids.append(permission.menu_id)
menus = self.get_menus(menu_ids)
if user.is_superuser:
menus = YzyMenuPermission.objects.filter(deleted=False).all()
router_list = self.parse_data(menus, user)
return JSONResponse({"routers": router_list},
status=status.HTTP_200_OK)
def get_node_info(self, request):
logger.debug("start get node info")
resp = get_error_result("Success")
try:
nodes = YzyNodes.objects.filter(deleted=False).all()
power_nodes = nodes.exclude(
status=constants.STATUS_SHUTDOWN).count()
resp['data'] = {}
resp['data']['curr_time'] = time.strftime('%Y/%m/%d %H:%M',
time.localtime())
resp['data']['node_total'] = len(nodes)
resp['data']['power_node'] = power_nodes
resp['data']['shutdown_node'] = len(nodes) - power_nodes
instances = YzyInstances.objects.filter(deleted=False).all()
# voi_instances = YzyVoiTerminal.objects.filter(deleted=False).all()
power_desktop = instances.filter(
status=constants.STATUS_ACTIVE).count()
error_desktop = instances.exclude(message='').count()
resp['data']['desktop_total'] = len(instances)
resp['data']['power_desktop'] = power_desktop
resp['data']['shutdown_desktop'] = len(instances) - power_desktop
resp['data']['error_desktop'] = error_desktop
page = YzyWebPagination()
controller_nodes = page.paginate_queryset(queryset=nodes,
request=request,
view=self)
ser = YzyWarningInfoSerializer(instance=controller_nodes,
many=True,
context={'request': request})
resp['data']['nodes'] = ser.data
logger.info("get node info success: %s", nodes)
return JSONResponse(resp)
except Exception as e:
logger.error("get node info error:%s", e, exc_info=True)
ret = get_error_result("OtherError")
return JSONResponse(ret)
def get_hardware(self, terminal_uuid):
req_data = {"terminal_uuid": terminal_uuid}
ret = server_post("/api/v1/monitor/terminal/terminal_hardware",
req_data)
if ret.get("code", -1) == 0:
_file = constants.TERMINAL_HARDWARE_PATH.split("/")[-1]
response = FileResponse(
open(constants.TERMINAL_HARDWARE_PATH, 'rb'))
response['content_type'] = "application/octet-stream"
response[
'Content-Disposition'] = "attachment; filename*=utf-8''{}".format(
escape_uri_path(_file))
return response
return JSONResponse(ret)
def get_weeks_num_map(self, request, *args, **kwargs):
"""
获取可批量应用的周列表
"""
term_uuid = kwargs.get("term_uuid", "")
term_obj = education_model.YzyTerm.objects.filter(deleted=False, uuid=term_uuid).first()
if not term_obj:
return JSONResponse(get_error_result("TermNotExist"))
group_uuid = request.GET.get("group_uuid", "")
if not education_model.YzyGroup.objects.filter(deleted=False, uuid=group_uuid).first():
return JSONResponse(get_error_result("EduGroupNotExist"))
# 找到该学期、该教学分组下，所有已有课表的周
cs_week_num_list = education_model.YzyCourseSchedule.objects.filter(
deleted=False,
term=term_uuid,
group=group_uuid
).values("week_num").distinct().all()
cs_week_num_list = [_d["week_num"] for _d in cs_week_num_list]
ret = list()
weeks_num_map = json.loads(term_obj.weeks_num_map)
for k, v in weeks_num_map.items():
_d = dict()
_d["week_num"] = int(k)
ntc = NumberToChinese().number_to_str(_d["week_num"])
if ntc.startswith("一十"):
ntc = ntc[1:]
_d["value"] = "第%s周 %s--%s" % (ntc, v[0][5:], v[1][5:])
if _d["week_num"] in cs_week_num_list:
_d["occupied"] = constants.WEEK_OCCUPIED
else:
_d["occupied"] = constants.WEEK_NOT_OCCUPIED
ret.append(_d)
return JSONResponse(ret)
def post(self, request):
ret = get_error_result()
_data = request.data
_data.update({"enable": 1})
ser = YzyRoleSerializer(data=_data, context={'request': request})
if ser.is_valid():
ser.save()
else:
msg = ser.errors
ret = get_error_result("ParameterError")
ret["msg"] = msg
logger.info("create admin user: %s" % ret)
msg = "创建角色信息: %s" % _data.get("role")
insert_operation_log(msg, ret)
return JSONResponse(ret)
def terminal_operate(self, request):
"""
节点服务的相关操作
:param request:
:return:
"""
_data = request.data
cmd = _data.get("cmd")
data = _data.get("data")
try:
func = getattr(self, cmd + '_terminal')
except:
ret = get_error_result("ParamError")
return JSONResponse(ret,
status=400,
json_dumps_params={'ensure_ascii': False})
return func(data)
