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)