def post(self, request, team_name, *args, **kwargs): name = parse_item(request, "name", required=True) rtype = parse_item(request, "type", required=True) region_name = parse_item(request, "region_name", required=True) components = team_services.check_resource_name(team_name, region_name, rtype, name) return Response( general_message(200, "success", "查询成功", list=components))
def post(self, request, app_id, record_id, *args, **kwargs): version = parse_item(request, "version", required=True) # It is not yet possible to upgrade based on services, which is user-specified attribute changes components = parse_item(request, "services", default=[]) component_keys = [cpt["service"]["service_key"] for cpt in components] record, _ = upgrade_service.upgrade( self.tenant, self.region, self.user, version, self.app_upgrade_record, component_keys, ) return MessageResponse(msg="success", msg_show="升级成功", bean=record)
def post(self, request, group_id, record_id, *args, **kwargs): """提交回滚任务""" service_ids = parse_item(request, 'service_ids', required=True, error='service_ids is a required parameter') # 判断是不是最后一条升级记录 app_record = AppUpgradeRecord.objects.filter( tenant_id=self.tenant.tenant_id, group_id=int(group_id), status__in=(UpgradeStatus.UPGRADED.value, UpgradeStatus.ROLLBACK.value, UpgradeStatus.PARTIAL_UPGRADED.value, UpgradeStatus.PARTIAL_ROLLBACK.value, UpgradeStatus.UPGRADE_FAILED.value, UpgradeStatus.ROLLBACK_FAILED.value)).order_by('-create_time').first() if not app_record or app_record.ID != int(record_id): raise AbortRequest(msg="This upgrade cannot be rolled back", msg_show=u"本次升级无法回滚") service_records = app_record.service_upgrade_records.filter( status__in=(UpgradeStatus.UPGRADED.value, UpgradeStatus.ROLLBACK.value, UpgradeStatus.UPGRADE_FAILED.value, UpgradeStatus.ROLLBACK_FAILED.value), upgrade_type=ServiceUpgradeRecord.UpgradeType.UPGRADE.value, service_id__in=service_ids) services = service_repo.get_services_by_service_ids_and_group_key( app_record.group_key, service_records.values_list('service_id', flat=True) or []) market_services = [ upgrade_service.market_service_and_restore_backup(self.tenant, service, app_record.version) for service in services ] upgrade_service.send_rolling_request(market_services, self.tenant, self.user, app_record, service_records) upgrade_repo.change_app_record_status(app_record, UpgradeStatus.ROLLING.value) return MessageResponse(msg="success", bean=upgrade_service.serialized_upgrade_record(app_record))
def put(self, request, app_id, *args, **kwargs): governance_mode = parse_item(request, "governance_mode", required=True) if governance_mode not in GovernanceModeEnum.names(): raise AbortRequest("governance_mode not in ({})".format(GovernanceModeEnum.names())) group_service.update_governance_mode(self.tenant, self.region_name, app_id, governance_mode) result = general_message(200, "success", "更新成功", bean={"governance_mode": governance_mode}) return Response(result)
def put(self, request, enterprise_id, *args, **kwargs): title = parse_item(request, "title") logo = parse_item(request, "logo") favicon = parse_item(request, "favicon") enterprise_alias = parse_item(request, "enterprise_alias") config_service = ConfigService() if title: config_service.update_config_value(ConfigKeyEnum.TITLE.name, title) if logo: config_service.update_config_value(ConfigKeyEnum.LOGO.name, logo) if enterprise_alias: enterprise_services.update_alias(enterprise_id, enterprise_alias) if favicon: config_service.update_config_value(ConfigKeyEnum.FAVICON.name, favicon) return Response(status=status.HTTP_200_OK)
def patch(self, request, env_id, *args, **kwargs): """变更环境变量范围""" scope = parse_item(request, 'scope', required=True, error="scope is is a required parameter") env = env_var_service.patch_env_scope(self.tenant, self.service, env_id, scope, self.user.nick_name) if env: return MessageResponse(msg="success", msg_show="更新成功", bean=env.to_dict()) else: return MessageResponse(msg="success", msg_show="更新成功", bean={})
def post(self, request, app_id, *args, **kwargs): upgrade_group_id = parse_item(request, 'upgrade_group_id', required=True) record = upgrade_service.create_upgrade_record(self.user.enterprise_id, self.tenant, self.app, upgrade_group_id) return MessageResponse(msg="success", bean=record)
def put(self, request, *args, **kwargs): """ 修改组件的某个端口(打开|关闭|修改协议|修改环境变量) --- parameters: - name: tenantName description: 租户名 required: true type: string paramType: path - name: serviceAlias description: 组件别名 required: true type: string paramType: path - name: port description: 端口号 required: true type: string paramType: path - name: action description: 操作类型(open_outer|close_outer|open_inner|close_inner|change_protocol|change_port_alias) required: true type: string paramType: form - name: port_alias description: 端口别名(修改端口别名时必须) required: false type: string paramType: - name: protocol description: 端口协议(修改端口协议时必须) required: false type: string paramType: path """ container_port = kwargs.get("port", None) action = request.data.get("action", None) port_alias = request.data.get("port_alias", None) protocol = request.data.get("protocol", None) k8s_service_name = parse_item(request, "k8s_service_name", default="") if not container_port: raise AbortRequest("container_port not specify", u"端口变量名未指定") if self.service.service_source == "third_party" and ("outer" in action): msg, msg_show, code = port_service.check_domain_thirdpart(self.tenant, self.service) if code != 200: logger.exception(msg, msg_show) return Response(general_message(code, msg, msg_show), status=code) code, msg, data = port_service.manage_port(self.tenant, self.service, self.response_region, int(container_port), action, protocol, port_alias, k8s_service_name) if code != 200: return Response(general_message(code, "change port fail", msg), status=code) result = general_message(200, "success", "操作成功", bean=model_to_dict(data)) return Response(result, status=result["code"])
def put(self, request, enterprise_id, *args, **kwargs): enable = bool_argument(parse_item(request, "enable", required=True)) hub_url = parse_item(request, "hub_url", required=True) namespace = parse_item(request, "namespace") hub_user = parse_item(request, "hub_user") hub_password = parse_item(request, "hub_password") ent_cfg_svc = EnterpriseConfigService(enterprise_id) ent_cfg_svc.update_config_enable_status(key="APPSTORE_IMAGE_HUB", enable=enable) ent_cfg_svc.update_config_value( key="APPSTORE_IMAGE_HUB", value={ "hub_url": hub_url, "namespace": namespace, "hub_user": hub_user, "hub_password": hub_password, }) return Response(status=status.HTTP_200_OK)
def put(self, request, enterprise_id, user_id, *args, **kwargs): roles = parse_item(request, "roles", required=True, error="at least one role needs to be specified") if not set(roles).issubset(EnterpriseRolesEnum.names()): raise AbortRequest("invalid roles", msg_show="角色不正确") if str(request.user.user_id) == user_id: raise AbortRequest("changing your role is not allowed", "不可修改自己的角色") user_services.update_roles(enterprise_id, user_id, roles) result = general_message(200, "success", None) return Response(result, 200)
def validate_parameter(data): xpa_type = parse_item(data, key="xpa_type", required=True) if xpa_type not in ["hpa"]: raise AbortRequest(msg="unsupported xpa_type: " + xpa_type) parse_item(data, key="enable", required=True) min_replicas = parse_item(data, key="min_replicas", required=True) if min_replicas <= 0 or min_replicas > 65535: raise AbortRequest(msg="the range of min_replicas is (0, 65535]") max_replicas = parse_item(data, key="max_replicas", required=True) if max_replicas <= 0 or max_replicas > 65535: raise AbortRequest(msg="the range of max_replicas is (0, 65535]") if max_replicas < min_replicas: raise AbortRequest( msg="max_replicas must be greater than min_replicas") metrics = parse_item(data, key="metrics", required=True) if len(metrics) < 1: raise AbortRequest(msg="need at least one metric") for metric in metrics: metric_type = parse_item(metric, key="metric_type", required=True) if metric_type not in ["resource_metrics"]: raise AbortRequest( msg="unsupported metric type: {}".format(metric_type)) metric_name = parse_item(metric, key="metric_name", required=True) # The metric_name of resource_metrics can only be cpu or memory if metric_name not in ["cpu", "memory"]: raise AbortRequest( msg="resource_metrics does not support metric name: {}".format( metric_name)) metric_target_type = parse_item(metric, key="metric_target_type", required=True) if metric_target_type not in ["utilization", "average_value"]: raise AbortRequest(msg="unsupported metric target type: {}".format( metric_target_type)) metric_target_value = parse_item(metric, key="metric_target_value", required=True) if metric_target_value < 0 or metric_target_value > 65535: raise AbortRequest( msg="the range of metric_target_value is [0, 65535]")
def post(self, request, *args, **kwargs): version = parse_item(request, "group_version", required=True) # get app app = group_repo.get_by_service_id(self.tenant.tenant_id, self.service.service_id) upgrade_service.upgrade_component(self.tenant, self.region, self.user, app, self.service, version) return Response(status=200, data=general_message(200, "success", "升级成功"))
def get(self, request, *args, **kwargs): k8s_service_name = parse_item(request, "k8s_service_name", required=True) is_valid = True try: port_service.check_k8s_service_name(self.tenant.tenant_id, k8s_service_name) except ErrK8sServiceNameExists: is_valid = False result = general_message( 200, "success", "检测成功", bean={ "is_valid": is_valid, }) return Response(result)
def patch(self, request, attr_name, *args, **kwargs): """变更环境变量范围""" scope = parse_item(request, 'scope', required=True, error="scope is is a required parameter") env = env_var_repo.get_service_env_or_404_by_attr_name( self.tenant.tenant_id, self.service.service_id, attr_name ) env_var_repo.change_service_env_scope(env, scope) return MessageResponse( msg="success", msg_show=u"更新成功", bean=env.to_dict() )
def get(self, request, *args, **kwargs): k8s_service_name = parse_item(request, "k8s_service_name", required=True) if len(k8s_service_name) > 63: raise AbortRequest( "k8s_service_name must be no more than 63 characters") if not re.match("[a-z]([-a-z0-9]*[a-z0-9])?", k8s_service_name): raise AbortRequest( "regex used for validation is '[a-z]([-a-z0-9]*[a-z0-9])?'") res = port_service.check_k8s_service_name(self.tenant.tenant_id, k8s_service_name) result = general_message(200, "success", "检测成功", bean=res) return Response(result)
def post(self, request, *args, **kwargs): client_id = parse_item(request, "client_id", required=True) client_secret = parse_item(request, "client_secret", required=True) user_id = parse_item(request, "user_id", required=True) oauth_service = oauth_repo.get_by_client_id(client_id) if oauth_service.oauth_type != "dbox": raise AbortRequest( "unsupported oauth type {} for oauth user logout".format( oauth_service.oauth_type)) if oauth_service.client_secret != client_secret: raise AbortRequest("the requested client key does not match") oauth_user = oauth_user_repo.get_by_oauth_user_id( oauth_service.ID, user_id) # Go to Oauth2 Server to check if the user has logged out api = get_oauth_instance(oauth_service.oauth_type, oauth_service, oauth_user) api.is_logout() # logout JwtManager().delete_user_id(oauth_user.user_id) return Response(status=status.HTTP_200_OK)
def post(self, request, group_id, *args, **kwargs): """新增升级订单""" group_key = parse_item(request, 'group_key', required=True, error='group_key is a required parameter') is_from_cloud = request.data.get("is_from_cloud", False) market_name = request.data.get("market_name", None) recode_kwargs = { "tenant_id": self.tenant.tenant_id, "group_id": int(group_id), "group_key": group_key, "is_from_cloud": is_from_cloud, "market_name": market_name, } # 查询或创建一条升级记录 app_record = upgrade_service.get_or_create_upgrade_record(**recode_kwargs) return MessageResponse(msg="success", bean=app_record.to_dict())
def post(self, request, group_id, *args, **kwargs): """新增升级订单""" group_key = parse_item(request, 'group_key', required=True, error='group_key is a required parameter') recode_kwargs = { "tenant_id": self.tenant.tenant_id, "group_id": int(group_id), "group_key": group_key, } # 查询或创建一条升级记录 app_record = upgrade_service.get_or_create_upgrade_record( **recode_kwargs) return MessageResponse(msg="success", bean=app_record.to_dict())
def post(self, request, enterprise_id, *args, **kwargs): roles = parse_item(request, "roles", required=True, error="at least one role needs to be specified") if not set(roles).issubset(EnterpriseRolesEnum.names()): raise AbortRequest("invalid roles", msg_show="角色不正确") user_id = request.data.get("user_id") if user_id == self.user.user_id: raise AbortRequest("cannot edit your own role", msg_show="不可操作自己的角色") try: user = user_services.get_user_by_user_id(user_id) except UserNotExistError: raise ErrUserNotFound ent = enterprise_services.get_enterprise_by_enterprise_id(enterprise_id) if ent is None: raise ErrEnterpriseNotFound user_services.create_admin_user(user, ent, roles) return Response(general_message(201, "success", None), status=201)
def put(self, request, enterprise_id, *args, **kwargs): enable = bool_argument(parse_item(request, "enable", required=True)) provider = parse_item(request, "provider", required=True) endpoint = parse_item(request, "endpoint", required=True) bucket_name = parse_item(request, "bucket_name", required=True) access_key = parse_item(request, "access_key", required=True) secret_key = parse_item(request, "secret_key", required=True) if provider not in ("alioss", "s3"): raise AbortRequest("provider {} not in (\"alioss\", \"s3\")".format(provider)) ent_cfg_svc = EnterpriseConfigService(enterprise_id) ent_cfg_svc.update_config_enable_status(key="OBJECT_STORAGE", enable=enable) ent_cfg_svc.update_config_value( key="OBJECT_STORAGE", value={ "provider": provider, "endpoint": endpoint, "bucket_name": bucket_name, "access_key": access_key, "secret_key": secret_key, }) return Response(status=status.HTTP_200_OK)
def test_parse_item(self): """测试 解析一个参数""" value = parse_item(self.request, 'a') self.assertEqual(value, 1)
def post(self, request, app_id, *args, **kwargs): values = parse_item(request, "values", required=True) services = application_service.parse_services(self.region_name, self.tenant, app_id, values) return Response(general_message(200, "success", "查询成功", list=services))
def test_parse_dict_data(self): data = {"foo": "bar"} value = parse_item(data, key="foo", required=True) self.assertEqual(value, "bar")
def test_not_parse_item_must(self): """测试解析不到必填参数""" try: parse_item(self.request, 'c', required=True) except AbortRequest as e: self.assertEqual(isinstance(e, AbortRequest), True)
def test_parse_item_must(self): """测试 解析必填参数""" value = parse_item(self.request, 'a', required=True) self.assertEqual(value, 1)