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)
