def post(self, request, team_name, share_id, *args, **kwargs):
"""
生成分享应用实体，向数据中心发送分享任务
---
parameter:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: share_id
description: 分享流程ID
required: true
type: string
paramType: path
"""
try:
share_record = share_service.get_service_share_record_by_ID(
ID=share_id, team_name=team_name)
if not share_record:
result = general_message(404, "share record not found",
"分享流程不存在，请退出重试")
return Response(result, status=404)
if share_record.is_success or share_record.step >= 3:
result = general_message(400, "share record is complete",
"分享流程已经完成，请重新进行分享")
return Response(result, status=400)
if not request.data:
result = general_message(400, "share info can not be empty",
"分享信息不能为空")
return Response(result, status=400)
share_group_info = request.data.get("share_group_info", None)
if share_group_info["scope"] == "goodrain":
enterprise = enterprise_services.get_enterprise_by_enterprise_id(
self.team.enterprise_id)
if not enterprise.is_active:
return Response(general_message(
10407, "enterprise is not active", "企业未激活"),
status=403)
share_app_info = request.data.get("share_service_list", None)
if not share_group_info or not share_app_info:
result = general_message(400, "share info can not be empty",
"分享应用基本信息或应用信息不能为空")
return Response(result, status=400)
if not share_group_info.get("group_key", None):
result = general_message(400,
"share group key can not be empty",
"分享应用信息不全")
return Response(result, status=400)
# 继续给app_template_incomplete赋值
code, msg, bean = share_service.create_share_info(
share_record=share_record,
share_team=self.team,
share_user=request.user,
share_info=request.data)
result = general_message(code, "create share info", msg, bean=bean)
return Response(result, status=code)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def get(self, request, *args, **kwargs):
"""
一个组的备份导出
---
parameters:
- name: tenantName
description: 团队名称
required: true
type: string
paramType: path
- name: group_id
description: 组ID
required: true
type: string
paramType: path
- name: backup_id
description: 备份id
required: true
type: string
paramType: query
"""
try:
group_id = int(kwargs.get("group_id", None))
if not group_id:
return Response(general_message(400, "group id is null",
"请选择需要导出备份的组"),
status=400)
team_name = kwargs.get("tenantName", None)
if not team_name:
return Response(general_message(400, "group id is null",
"请选择需要导出备份的组"),
status=400)
team = team_services.get_tenant_by_tenant_name(team_name)
if not team:
return Response(general_message(404, "team not found",
"团队{0}不存在".format(team_name)),
status=404)
group = group_repo.get_group_by_id(group_id)
if not group:
return Response(general_message(404, "group not found",
"组{0}不存在".format(group_id)),
status=404)
backup_id = request.GET.get("backup_id", None)
if not backup_id:
return Response(general_message(400, "backup id is null",
"请指明当前组的具体备份项"),
status=400)
code, msg, data_str = groupapp_backup_service.export_group_backup(
team, backup_id)
if code != 200:
return Response(general_message(code, "export backup failed",
msg),
status=code)
file_name = group.group_name + ".bak"
output = StringIO.StringIO()
output.write(data_str)
res = StreamingHttpResponse(output.getvalue())
res['Content-Type'] = 'application/octet-stream'
res['Content-Disposition'] = 'attachment;filename="{0}"'.format(
file_name)
return res
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def post(self, request, *args, **kwargs):
"""
插件创建
---
parameters:
- name: tenantName
description: 团队名
required: true
type: string
paramType: path
- name: plugin_alias
description: 插件名称
required: true
type: string
paramType: form
- name: build_source
description: 构建来源 dockerfile | image
required: true
type: string
paramType: form
- name: min_memory
description: 最小内存
required: true
type: integer
paramType: form
- name: category
description: 插件类别 net-plugin:down|net-plugin:up|analyst-plugin:perf|init-plugin|general-plugin
required: false
type: string
paramType: form
- name: build_cmd
description: 构建命令
required: false
type: string
paramType: form
- name: code_repo
description: dockerfile构建代码仓库地址,选择dockerfile时必须
required: false
type: string
paramType: form
- name: code_version
description: 代码版本，默认master
required: false
type: string
paramType: form
- name: image
description: 镜像构建时镜像名称
required: false
type: string
paramType: form
- name: desc
description: 镜像说明
required: true
type: string
paramType: form
"""
# 必要参数
plugin_alias = request.data.get("plugin_alias", None)
build_source = request.data.get("build_source", None)
min_memory = request.data.get("min_memory", None)
category = request.data.get("category", None)
desc = request.data.get("desc", None)
# 非必要参数
build_cmd = request.data.get("build_cmd", None)
code_repo = request.data.get("code_repo", None)
code_version = request.data.get("code_version", None)
image = request.data.get("image", None)
tenant_plugin = None
plugin_build_version = None
try:
if not plugin_alias:
return Response(general_message(400, "plugin alias is null",
"插件名称未指明"),
status=400)
if not build_source:
return Response(general_message(400, "build source is null",
"构建来源未指明"),
status=400)
if not min_memory:
return Response(general_message(400,
"plugin min_memroy is null",
"插件内存大小未指明"),
status=400)
if not category:
return Response(general_message(400, "plugin category is null",
"插件类别未指明"),
status=400)
else:
if category not in (
PluginCategoryConstants.OUTPUT_NET,
PluginCategoryConstants.INPUT_NET,
PluginCategoryConstants.PERFORMANCE_ANALYSIS,
PluginCategoryConstants.INIT_TYPE,
PluginCategoryConstants.COMMON_TYPE):
return Response(general_message(
400, "plugin category is wrong",
"插件类别参数错误，详情请参数API说明"),
status=400)
if not desc:
return Response(general_message(400, "plugin desc is null",
"请填写插件描述"),
status=400)
image_tag = ""
if image:
image_and_tag = image.rsplit(":", 1)
if len(image_and_tag) > 1:
image = image_and_tag[0]
image_tag = image_and_tag[1]
else:
image = image_and_tag[0]
image_tag = "latest"
# 创建基本信息
code, msg, tenant_plugin = plugin_service.create_tenant_plugin(
self.tenant, self.user.user_id, self.response_region, desc,
plugin_alias, category, build_source, image, code_repo)
if code != 200:
return Response(general_message(code, "create plugin error",
msg),
status=code)
# 创建插件版本信息
plugin_build_version = plugin_version_service.create_build_version(
self.response_region, tenant_plugin.plugin_id,
self.tenant.tenant_id, self.user.user_id, "", "unbuild",
min_memory, build_cmd, image_tag, code_version)
# 数据中心创建插件
code, msg = plugin_service.create_region_plugin(
self.response_region, self.tenant, tenant_plugin, image_tag)
if code != 200:
plugin_service.delete_console_tenant_plugin(
tenant_plugin.plugin_id)
plugin_version_service.delete_build_version_by_id_and_version(
tenant_plugin.plugin_id,
plugin_build_version.build_version, True)
return Response(general_message(code, "create plugin error",
msg),
status=code)
bean = tenant_plugin.to_dict()
bean["build_version"] = plugin_build_version.build_version
bean["code_version"] = plugin_build_version.code_version
bean["build_status"] = plugin_build_version.build_status
bean["update_info"] = plugin_build_version.update_info
bean["image_tag"] = plugin_build_version.image_tag
result = general_message(200, "success", "创建成功", bean=bean)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
if tenant_plugin:
plugin_service.delete_console_tenant_plugin(
tenant_plugin.plugin_id)
if plugin_build_version:
plugin_version_service.delete_build_version_by_id_and_version(
tenant_plugin.plugin_id,
plugin_build_version.build_version, True)
return Response(result, status=result["code"])
def get(self, request, *args, **kwargs):
"""
总览 团队应用信息 + 分页 + 排序 + 模糊查询
---
parameters:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: page
description: 页数(默认第一页)
required: false
type: string
paramType: query
- name: page_size
description: 每页展示个数(默认10个)
required: false
type: string
paramType: query
- name: order
description: 排序规则 desc(从大到小)或者asc(从小到大) 默认desc
required: false
type: string
paramType: query
- name: fields
description: 排序字段 默认 update_time 可用(update_time, min_memory)
required: false
type: string
paramType: query
- name: query_key
description: 模糊组件名 默认为空，查到所有组件
required: false
type: string
paramType: query
- name: service_status
description: 组件状态 默认all 可用(running, closed, all)
required: true
type: string
paramType: query
"""
try:
code = 200
page = request.GET.get("page", 1)
page_size = request.GET.get("page_size", 10)
order = request.GET.get('order_type', 'desc')
fields = request.GET.get('fields', 'update_time')
query_key = request.GET.get("query_key", '')
service_status = request.GET.get("service_status", 'all')
if not self.team:
result = general_message(400, "failed", "该团队不存在")
return Response(result, status=400)
services_list = base_service.get_fuzzy_services_list(
team_id=self.team.tenant_id,
region_name=self.response_region,
query_key=query_key,
fields=fields,
order=order)
if services_list:
try:
service_ids = [
service["service_id"] for service in services_list
]
status_list = base_service.status_multi_service(
region=self.response_region,
tenant_name=self.team_name,
service_ids=service_ids,
enterprise_id=self.team.enterprise_id)
status_cache = {}
statuscn_cache = {}
for status in status_list:
status_cache[status["service_id"]] = status["status"]
statuscn_cache[
status["service_id"]] = status["status_cn"]
result = []
for service in services_list:
if service["group_id"] is None:
service["group_name"] = "未分组"
service["group_id"] = "-1"
if service_status == "all":
service["status_cn"] = statuscn_cache.get(
service["service_id"], "未知")
status = status_cache.get(service["service_id"],
"unknow")
if status == "unknow" and service[
"create_status"] != "complete":
service["status"] = "creating"
service["status_cn"] = "创建中"
else:
service["status"] = status_cache.get(
service["service_id"], "unknow")
service["status_cn"] = get_status_info_map(
service["status"]).get("status_cn")
if service["status"] == "closed" or service[
"status"] == "undeploy":
service["min_memory"] = 0
result.append(service)
else:
if status_cache.get(
service.service_id) == service_status:
service["status"] = status_cache.get(
service.service_id, "unknow")
service["status_cn"] = get_status_info_map(
service["status"]).get("status_cn")
if service["status"] == "closed" or service[
"status"] == "undeploy":
service["min_memory"] = 0
result.append(service)
paginator = Paginator(result, page_size)
try:
result = paginator.page(page).object_list
except PageNotAnInteger:
result = paginator.page(1).object_list
except EmptyPage:
result = paginator.page(
paginator.num_pages).object_list
result = general_message(200,
"query user success",
"查询用户成功",
list=result,
total=paginator.count)
except Exception as e:
logger.exception(e)
return Response(services_list, status=200)
return Response(result, status=code)
else:
result = general_message(200, "success", "当前团队没有创建应用")
return Response(result, status=200)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def get(self, request, *args, **kwargs):
"""
获取服务的构建版本
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: serviceAlias
description: 服务别名
required: true
type: string
paramType: path
"""
try:
page = request.GET.get("page_num", 1)
page_size = request.GET.get("page_size", 10)
body = region_api.get_service_build_versions(
self.response_region, self.tenant.tenant_name,
self.service.service_alias)
build_version_sort = body["list"]
build_version_sort.sort(key=operator.itemgetter('BuildVersion'),
reverse=True)
paginator = Paginator(build_version_sort, page_size)
build_version_list = paginator.page(int(page)).object_list
events = event_repo.get_events_before_specify_time(
self.tenant.tenant_id, self.service.service_id,
current_time_str(fmt="%Y-%m-%d %H:%M:%S")).filter(
type="deploy")
version_user_map = {
event.deploy_version: event.user_name
for event in events
}
versions_info = build_version_list
version_list = []
for info in versions_info:
version_list.append({
"build_version":
info["BuildVersion"],
"kind":
BUILD_KIND_MAP.get(info["Kind"]),
"service_type":
info["DeliveredType"],
"image_url":
info["ImageName"],
"repo_url":
info["RepoURL"],
"commit_msg":
info["CommitMsg"],
"author":
info["Author"],
"create_time":
info["CreatedAt"],
"status":
info["FinalStatus"],
"build_user":
version_user_map.get(info["BuildVersion"], "未知")
})
res_versions = sorted(version_list,
key=lambda version: version["build_version"],
reverse=True)
# try:
# result = paginator.page(page).object_list
# except PageNotAnInteger:
# result = paginator.page(1).object_list
# except EmptyPage:
# result = paginator.page(paginator.num_pages).object_list
result = general_message(200,
"success",
"查询成功",
list=res_versions,
total=paginator.count)
return Response(result, status=result["code"])
except Exception as e:
result = error_message(e.message)
return Response(result, status=500)
def put(self, request, *args, **kwargs):
"""
修改插件配置信息
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: plugin_id
description: 插件ID
required: true
type: string
paramType: path
- name: build_version
description: 版本
required: true
type: string
paramType: path
- name: body
description: 配置组内容
required: true
type: string
paramType: body
"""
try:
config = request.data
injection = config.get("injection")
service_meta_type = config.get("service_meta_type")
config_name = config.get("config_name")
config_group_pk = config.get("ID")
config_groups = plugin_config_service.get_config_group(
self.plugin_version.plugin_id,
self.plugin_version.build_version).exclude(pk=config_group_pk)
is_pass, msg = plugin_config_service.check_group_config(
service_meta_type, injection, config_groups)
if not is_pass:
return Response(general_message(400, "param error", msg),
status=400)
config_group = plugin_config_service.get_config_group_by_pk(
config_group_pk)
old_meta_type = config_group.service_meta_type
plugin_config_service.update_config_group_by_pk(
config_group_pk, config_name, service_meta_type, injection)
# 删除原有配置项
plugin_config_service.delet_config_items(
self.plugin_version.plugin_id,
self.plugin_version.build_version, old_meta_type)
options = config.get("options")
plugin_config_service.create_config_items(
self.plugin_version.plugin_id,
self.plugin_version.build_version, service_meta_type, *options)
result = general_message(200, "success", "修改成功")
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def get(self, request, *args, **kwargs):
"""
应用组件列表、状态展示
---
parameters:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: page
description: 页数(默认第一页)
required: false
type: string
paramType: query
- name: page_size
description: 每页展示个数(默认10个)
required: false
type: string
paramType: query
- name: group_id
description: 应用id
required: true
type: string
paramType: query
"""
try:
code = 200
page = request.GET.get("page", 1)
page_size = request.GET.get("page_size", 10)
group_id = request.GET.get("group_id", None)
if group_id is None or not group_id.isdigit():
code = 400
result = general_message(code,
"group_id is missing or not digit!",
"group_id缺失或非数字")
return Response(result, status=code)
query = request.GET.get("query", "")
tenant_actions = list(self.user.actions.tenant_actions)
service_actions = list(self.user.actions.service_actions)
if group_id == "-1":
# query service which not belong to any app
no_group_service_list = service_repo.get_no_group_service_status_by_group_id(
team_name=self.team_name,
team_id=self.team.tenant_id,
region_name=self.response_region,
enterprise_id=self.team.enterprise_id)
paginator = Paginator(no_group_service_list, page_size)
try:
no_group_service_list = paginator.page(page).object_list
except PageNotAnInteger:
no_group_service_list = paginator.page(1).object_list
except EmptyPage:
no_group_service_list = paginator.page(
paginator.num_pages).object_list
result = general_message(code,
"query success",
"应用查询成功",
list=no_group_service_list,
total=paginator.count)
result["data"]["bean"] = {
"tenant_actions": tenant_actions,
"service_actions": service_actions
}
return Response(result, status=code)
team_id = self.team.tenant_id
group_count = group_repo.get_group_count_by_team_id_and_group_id(
team_id=team_id, group_id=group_id)
if group_count == 0:
result = general_message(202,
"group is not yours!",
"当前组已删除或您无权限查看！",
bean={})
return Response(result, status=200)
group_service_list = service_repo.get_group_service_by_group_id(
group_id=group_id,
region_name=self.response_region,
team_id=self.team.tenant_id,
team_name=self.team_name,
enterprise_id=self.team.enterprise_id,
query=query)
paginator = Paginator(group_service_list, page_size)
try:
group_service_list = paginator.page(page).object_list
except PageNotAnInteger:
group_service_list = paginator.page(1).object_list
except EmptyPage:
group_service_list = paginator.page(
paginator.num_pages).object_list
result = general_message(code,
"query success",
"应用查询成功",
list=group_service_list,
total=paginator.count)
result["data"]["bean"] = {
"tenant_actions": tenant_actions,
"service_actions": service_actions
}
return Response(result, status=code)
except GroupNotExistError as e:
logger.exception(e)
result = general_message(400, "query success", "该应用不存在")
return Response(result, status=400)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def get(self, request, *args, **kwargs):
"""
判断该应用是否有webhooks自动部署功能，有则返回URL
"""
try:
deployment_way = request.GET.get("deployment_way", None)
if not deployment_way:
result = general_message(400, "Parameter cannot be empty",
"缺少参数")
return Response(result, status=400)
tenant_id = self.tenant.tenant_id
service_alias = self.service.service_alias
service_obj = TenantServiceInfo.objects.filter(
tenant_id=tenant_id, service_alias=service_alias)[0]
if service_obj.service_source == AppConstants.MARKET:
result = general_message(200,
"failed",
"该应用不符合要求",
bean={"display": False})
return Response(result, status=200)
if service_obj.service_source == AppConstants.SOURCE_CODE:
support_type = 1
else:
support_type = 2
service_id = service_obj.service_id
# 从环境变量中获取域名，没有在从请求中获取
host = os.environ.get('DEFAULT_DOMAIN', request.get_host())
service_webhook = service_webhooks_repo.get_service_webhooks_by_service_id_and_type(
self.service.service_id, deployment_way)
if not service_webhook:
service_webhook = service_webhooks_repo.create_service_webhooks(
self.service.service_id, deployment_way)
# api处发自动部署
if deployment_way == "api_webhooks":
# 生成秘钥
deploy = deploy_repo.get_deploy_relation_by_service_id(
service_id=service_id)
secret_key = pickle.loads(
base64.b64decode(deploy)).get("secret_key")
url = "http://" + host + "/console/" + "custom/deploy/" + service_obj.service_id
status = service_webhook.state
result = general_message(200,
"success",
"获取URl及开启状态成功",
bean={
"url": url,
"secret_key": secret_key,
"status": status,
"display": True,
"support_type": support_type
})
# 镜像处发自动部署
elif deployment_way == "image_webhooks":
url = "http://" + host + "/console/" + "image/webhooks/" + service_obj.service_id
status = service_webhook.state
result = general_message(200,
"success",
"获取URl及开启状态成功",
bean={
"url": url,
"status": status,
"display": True,
"support_type": support_type
})
# 源码处发自动部署
else:
url = "http://" + host + "/console/" + "webhooks/" + service_obj.service_id
status = service_webhook.state
deploy_keyword = service_webhook.deploy_keyword
result = general_message(200,
"success",
"获取URl及开启状态成功",
bean={
"url": url,
"status": status,
"display": True,
"support_type": support_type,
"deploy_keyword": deploy_keyword
})
return Response(result, status=200)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def delete(self, request, *args, **kwargs):
"""
应用组数据删除
---
parameters:
- name: tenantName
description: 团队名称
required: true
type: string
paramType: path
- name: group_id
description: 组ID
required: true
type: string
paramType: path
- name: new_group_id
description: 组ID
required: true
type: string
paramType: query
"""
try:
group_id = int(kwargs.get("group_id", None))
if not group_id:
return Response(general_message(400, "group id is null",
"请确认需要删除的组"),
status=400)
new_group_id = request.data.get("new_group_id", None)
if not new_group_id:
return Response(general_message(400, "new group id is null",
"请确认新恢复的组"),
status=400)
if group_id == new_group_id:
return Response(general_message(200, "success", "恢复到当前组无需删除"),
status=200)
group = group_repo.get_group_by_id(group_id)
if not group:
return Response(general_message(400, "group is delete",
"该备份组已删除"),
status=400)
if group.is_default:
return Response(general_message(400, "default app",
"默认应用不允许删除"),
status=400)
new_group = group_repo.get_group_by_id(new_group_id)
if not new_group:
return Response(general_message(
400, "new group not exist",
"组ID {0} 不存在".format(new_group_id)),
status=400)
services = group_service.get_group_services(group_id)
for service in services:
try:
app_manage_service.truncate_service(self.tenant, service)
except Exception as le:
logger.exception(le)
group.delete()
result = general_message(200, "success", "操作成功")
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def put(self, request, *args, **kwargs):
"""
应用拓扑图打开(关闭)对外端口
:param request:
:param args:
:param kwargs:
:return:
"""
try:
open_outer = request.data.get("open_outer", False)
close_outer = request.data.get("close_outer", False)
container_port = request.data.get("container_port", None)
# 开启对外端口
if open_outer:
tenant_service_port = port_service.get_service_port_by_port(
self.service, int(container_port))
code, msg, data = port_service.manage_port(
self.tenant, self.service, self.response_region,
int(container_port), "open_outer",
tenant_service_port.protocol,
tenant_service_port.port_alias)
if code != 200:
return Response(general_message(412, "open outer fail",
u"打开对外端口失败"),
status=412)
return Response(general_message(200, "open outer success",
u"开启成功"),
status=200)
# 关闭改服务所有对外端口
if close_outer:
tenant_service_ports = port_service.get_service_ports(
self.service)
for tenant_service_port in tenant_service_ports:
code, msg, data = port_service.manage_port(
self.tenant, self.service, self.response_region,
tenant_service_port.container_port, "close_outer",
tenant_service_port.protocol,
tenant_service_port.port_alias)
if code != 200:
return Response(general_message(
412, "open outer fail", u"关闭对外端口失败"),
status=412)
return Response(general_message(200, "close outer success",
u"关闭对外端口成功"),
status=200)
# 校验要依赖的服务是否开启了对外端口
open_outer_services = port_repo.get_service_ports(
self.tenant.tenant_id,
self.service.service_id).filter(is_outer_service=True)
if not open_outer_services:
service_ports = port_repo.get_service_ports(
self.tenant.tenant_id, self.service.service_id)
port_list = [
service_port.container_port
for service_port in service_ports
]
if len(port_list) == 1:
# 一个端口直接开启
tenant_service_port = port_service.get_service_port_by_port(
self.service, int(port_list[0]))
code, msg, data = port_service.manage_port(
self.tenant, self.service, self.response_region,
int(port_list[0]), "open_outer",
tenant_service_port.protocol,
tenant_service_port.port_alias)
if code != 200:
return Response(general_message(
412, "open outer fail", u"打开对外端口失败"),
status=412)
return Response(general_message(200, "open outer success",
u"开启成功"),
status=200)
else:
# 多个端口需要用户选择后开启
return Response(general_message(
201,
"the service does not open an external port",
u"该服务未开启对外端口",
list=port_list),
status=201)
else:
return Response(general_message(
202, "the service has an external port open",
u"该服务已开启对外端口"),
status=200)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def post(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: integer
paramType: form
- name: protocol
description: 端口协议
required: true
type: string
paramType: form
- name: port_alias
description: 端口别名
required: true
type: string
paramType: form
- name: is_inner_service
description: 是否打开对内服务
required: true
type: boolean
paramType: form
- name: is_outer_service
description: 是否打开对外服务
required: true
type: boolean
paramType: form
"""
port = request.data.get("port", None)
protocol = request.data.get("protocol", None)
port_alias = request.data.get("port_alias", None)
is_inner_service = request.data.get('is_inner_service', False)
is_outer_service = request.data.get('is_outer_service', False)
try:
if not port:
return Response(general_message(400, "params error",
u"缺少端口参数"),
status=400)
if not protocol:
return Response(general_message(400, "params error",
u"缺少协议参数"),
status=400)
if not port_alias:
port_alias = self.service.service_alias.upper().replace(
"-", "_") + str(port)
code, msg, port_info = port_service.add_service_port(
self.tenant, self.service, port, protocol, port_alias,
is_inner_service, is_outer_service)
if code != 200:
return Response(general_message(code, "add port error", msg),
status=code)
result = general_message(200,
"success",
"端口添加成功",
bean=model_to_dict(port_info))
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
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)
if not container_port:
return Response(general_message(400, "container_port not specify",
u"端口变量名未指定"),
status=400)
try:
code, msg, data = port_service.manage_port(self.tenant,
self.service,
self.response_region,
int(container_port),
action, protocol,
port_alias)
if code != 200:
return Response(general_message(code, "change port fail", msg),
status=code)
result = general_message(200,
"success",
"操作成功",
bean=model_to_dict(data))
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def get(self, request, *args, **kwargs):
"""
获取服务的端口信息
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: serviceAlias
description: 服务别名
required: true
type: string
paramType: path
"""
try:
tenant_service_ports = port_service.get_service_ports(self.service)
port_list = []
for port in tenant_service_ports:
port_info = port.to_dict()
variables = port_service.get_port_variables(
self.tenant, self.service, port)
port_info["environment"] = variables["environment"]
outer_url = ""
inner_url = ""
if port_info["environment"]:
if port.is_inner_service:
try:
inner_url = "{0}:{1}".format(
port_info["environment"][0].get("value"),
port_info["environment"][1].get("value"))
except Exception as se:
logger.exception(se)
port_info["inner_url"] = inner_url
outer_service = variables.get("outer_service", None)
if outer_service:
outer_url = "{0}:{1}".format(
variables["outer_service"]["domain"],
variables["outer_service"]["port"])
port_info["outer_url"] = outer_url
port_info["bind_domains"] = []
bind_domains = domain_service.get_port_bind_domains(
self.service, port.container_port)
port_info["bind_domains"] = [
domain.to_dict() for domain in bind_domains
]
bind_tcp_domains = domain_service.get_tcp_port_bind_domains(
self.service, port.container_port)
if bind_tcp_domains:
port_info["bind_tcp_domains"] = [
domain.to_dict() for domain in bind_tcp_domains
]
else:
port_info["bind_tcp_domains"] = []
port_list.append(port_info)
result = general_message(200, "success", "查询成功", list=port_list)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def post(self, request, team_name, group_id, *args, **kwargs):
"""
生成分享订单，会验证是否能够分享
---
parameter:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: group_id
description: 应用组id
required: true
type: string
paramType: path
"""
try:
if group_id == "-1":
code = 400
result = general_message(400, "group id error", "未分组应用不可分享")
return Response(result, status=code)
team_id = self.team.tenant_id
group_count = group_repo.get_group_count_by_team_id_and_group_id(
team_id=team_id, group_id=group_id)
if group_count == 0:
code = 400
result = general_message(code, "group is not yours!",
"这个应用组不是你的!")
return Response(result, status=code)
# 判断是否满足分享条件
data = share_service.check_service_source(
team=self.team,
team_name=team_name,
group_id=group_id,
region_name=self.response_region)
if data and data["code"] == 400:
return Response(data, status=data["code"])
# 判断是否有未完成订单
share_record = share_service.get_service_share_record_by_group_id(
group_id)
if share_record:
if not share_record.is_success and share_record.step < 3:
result = general_message(20021,
"share record not complete",
"之前有分享流程未完成",
bean=share_record.to_dict())
return Response(result, status=200)
fields_dict = {
"group_share_id": make_uuid(),
"group_id": group_id,
"team_name": team_name,
"is_success": False,
"step": 1,
"create_time": datetime.datetime.now(),
"update_time": datetime.datetime.now()
}
service_share_record = share_service.create_service_share_record(
**fields_dict)
result = general_message(200,
"create success",
"创建成功",
bean=service_share_record.to_dict())
return Response(result, status=200)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def get(self, request, *args, **kwargs):
"""
获取compose文件检测信息
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: group_id
description: 组ID
required: true
type: string
paramType: path
- name: check_uuid
description: 检测id
required: true
type: string
paramType: query
- name: compose_id
description: group_compose ID
required: true
type: string
paramType: query
"""
sid = None
try:
check_uuid = request.GET.get("check_uuid", None)
compose_id = request.GET.get("compose_id", None)
if not check_uuid:
return Response(general_message(400, "params error", "参数错误，请求参数应该包含请求的ID"), status=400)
if not compose_id:
return Response(general_message(400, "params error", "参数错误，请求参数应该包含compose ID"), status=400)
group_compose = compose_service.get_group_compose_by_compose_id(compose_id)
code, msg, data = app_check_service.get_service_check_info(self.tenant, self.response_region, check_uuid)
# 开启保存点
sid = transaction.savepoint()
logger.debug("start save compose info ! {0}".format(group_compose.create_status))
save_code, save_msg, service_list = compose_service.save_compose_services(self.tenant, self.user,
self.response_region,
group_compose, data)
if save_code != 200:
transaction.savepoint_rollback(sid)
data["check_status"] = "failure"
save_error = {
"error_type": "check info save error",
"solve_advice": "修改相关信息后重新尝试",
"error_info": "{}".format(save_msg)
}
if data["error_infos"]:
data["error_infos"].append(save_error)
else:
data["error_infos"] = [save_error]
else:
transaction.savepoint_commit(sid)
logger.debug("check result = {0}".format(data))
compose_check_brief = compose_service.wrap_compose_check_info(data)
result = general_message(200, "success", "请求成功", bean=compose_check_brief,
list=[s.to_dict() for s in service_list])
except Exception as e:
logger.exception(e)
result = error_message(e.message)
if sid:
transaction.savepoint_rollback(sid)
return Response(result, status=result["code"])
def post(self, request, *args, **kwargs):
"""
应用迁移
---
parameters:
- name: tenantName
description: 团队名称
required: true
type: string
paramType: path
- name: group_id
description: 组ID
required: true
type: string
paramType: path
- name: region
description: 需要备份的数据中心
required: true
type: string
paramType: form
- name: team
description: 需要迁移到的团队
required: true
type: string
paramType: form
- name: backup_id
description: 备份ID
required: true
type: string
paramType: form
- name: migrate_type
description: 操作类型
required: true
type: string
paramType: form
"""
try:
migrate_region = request.data.get("region", None)
team = request.data.get("team", None)
backup_id = request.data.get("backup_id", None)
migrate_type = request.data.get("migrate_type", "migrate")
event_id = request.data.get("event_id", None)
restore_id = request.data.get("restore_id", None)
if not team:
return Response(general_message(400, "team is null",
"请指明要迁移的团队"),
status=400)
migrate_team = team_services.get_tenant_by_tenant_name(team)
if not migrate_team:
return Response(general_message(404, "team is not found",
"需要迁移的团队{0}不存在".format(team)),
status=404)
regions = region_services.get_team_usable_regions(migrate_team)
if migrate_region not in [r.region_name for r in regions]:
return Response(general_message(
412, "region is not usable",
"无法迁移至数据中心{0},请确保该数据中心可用且团队{1}已开通该数据中心权限".format(
migrate_region, migrate_team.tenant_name)),
status=412)
code, msg, migrate_record = migrate_service.start_migrate(
self.user, self.tenant, self.response_region, migrate_team,
migrate_region, backup_id, migrate_type, event_id, restore_id)
if code != 200:
return Response(general_message(code, "migrate failed", msg),
status=code)
result = general_message(200,
"success",
"操作成功，开始迁移应用",
bean=migrate_record.to_dict())
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def get(self, request, *args, **kwargs):
"""
获取某个插件某个版本的预览信息
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: plugin_id
description: 插件ID
required: true
type: string
paramType: path
- name: build_version
description: 版本
required: true
type: string
paramType: path
"""
try:
wordpress_alias = "wordpress_alias"
mysql_alias = "mysql_alias"
wp_ports = [80, 8081]
mysql_port = [3306]
wp_id = "wp_service_id"
mysql_id = "mysql_service_id"
config_groups = plugin_config_service.get_config_group(
self.plugin_version.plugin_id,
self.plugin_version.build_version)
all_config_group = []
base_ports = []
base_services = []
base_normal = {}
for config_group in config_groups:
config_items = plugin_config_service.get_config_items(
self.plugin_version.plugin_id,
self.plugin_version.build_version,
config_group.service_meta_type)
items = []
for item in config_items:
item_map = {}
item_map[item.attr_name] = item.attr_default_value
items.append(item_map)
if config_group.service_meta_type == PluginMetaType.UPSTREAM_PORT:
for port in wp_ports:
base_port = {}
base_port["service_alias"] = wordpress_alias
base_port["service_id"] = wp_id
base_port["port"] = port
base_port["protocol"] = "http"
base_port["options"] = items
base_ports.append(base_port)
if config_group.service_meta_type == PluginMetaType.DOWNSTREAM_PORT:
for port in mysql_port:
base_service = {}
base_service["service_alias"] = wordpress_alias
base_service["service_id"] = wp_id
base_service["port"] = port
#base_service["protocol"] = "stream"
base_service["protocol"] = "mysql"
base_service["options"] = items
base_service["depend_service_alias"] = mysql_alias
base_service["depend_service_id"] = mysql_id
base_services.append(base_service)
if config_group.service_meta_type == PluginMetaType.UNDEFINE:
base_normal["options"] = items
bean = {
"base_ports": base_ports,
"base_services": base_services,
"base_normal": base_normal.get("options", None)
}
result = general_message(200,
"success",
"查询成功",
bean=bean,
list=all_config_group)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def post(self, request, *args, **kwargs):
"""
新建团队
---
parameters:
- name: team_alias
description: 团队名
required: true
type: string
paramType: body
- name: useable_regions
description: 可用数据中心 ali-sh,ali-hz
required: false
type: string
paramType: body
"""
try:
user = request.user
team_alias = request.data.get("team_alias", None)
useable_regions = request.data.get("useable_regions", "")
regions = []
if not team_alias:
result = general_message(400, "failed", "团队名不能为空")
return Response(result, status=400)
if useable_regions:
regions = useable_regions.split(",")
if Tenants.objects.filter(tenant_alias=team_alias).exists():
result = general_message(400, "failed", "该团队名已存在")
return Response(result, status=400)
else:
enterprise = enterprise_services.get_enterprise_first()
code, msg, team = team_services.add_team(team_alias=team_alias,
user=user,
region_names=regions)
if team:
perm = perms_repo.add_user_tenant_perm(
perm_info={
"user_id": user.user_id,
"tenant_id": team.ID,
"identity": "owner",
"enterprise_id": enterprise.ID
})
if not perm:
result = general_message(400, "invited failed",
"团队关联失败，注册失败")
return Response(result, status=400)
if code == "200":
data = {
"team_name": team.tenant_name,
"team_id": team.tenant_id,
"team_ID": team.ID,
"team_alisa": team.tenant_alias,
"creater": team.creater,
"user_num": 1,
"enterprise_id": team.enterprise_id
}
result = general_message(code,
"create new team success",
"新建团队成功",
bean=data)
return Response(result, status=code)
else:
result = general_message(code, 'failed', msg_show=msg)
return Response(result, status=code)
except TenantExistError as e:
logger.exception(e)
code = 400
result = general_message(code, "team already exists", "该团队已存在")
return Response(result, status=code)
except NoEnableRegionError as e:
logger.exception(e)
code = 400
result = general_message(code, "no enable region", "无可用数据中心")
return Response(result, status=code)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def post(self, request, team_name, share_id, *args, **kwargs):
"""
生成分享应用实体，向数据中心发送分享任务
---
parameter:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: share_id
description: 分享流程ID
required: true
type: string
paramType: path
"""
use_force = parse_argument(request, 'use_force', default=False, value_type=bool)
try:
share_record = share_service.get_service_share_record_by_ID(ID=share_id, team_name=team_name)
if not share_record:
result = general_message(404, "share record not found", "分享流程不存在，请退出重试")
return Response(result, status=404)
if share_record.is_success or share_record.step >= 3:
result = general_message(400, "share record is complete", "分享流程已经完成，请重新进行分享")
return Response(result, status=400)
if not request.data:
result = general_message(400, "share info can not be empty", "分享信息不能为空")
return Response(result, status=400)
app_version_info = request.data.get("app_version_info", None)
share_app_info = request.data.get("share_service_list", None)
if not app_version_info or not share_app_info:
result = general_message(400, "share info can not be empty", "分享应用基本信息或应用信息不能为空")
return Response(result, status=400)
if not app_version_info.get("app_model_id", None):
result = general_message(400, "share app model id can not be empty", "分享应用信息不全")
return Response(result, status=400)
if share_app_info:
for app in share_app_info:
extend_method = app.get("extend_method", "")
if is_singleton(extend_method):
extend_method_map = app.get("extend_method_map")
if extend_method_map and extend_method_map.get("max_node", 1) > 1:
result = general_message(400, "service type do not allow multiple node", "分享应用不支持多实例")
return Response(result, status=400)
# 继续给app_template_incomplete赋值
code, msg, bean = share_service.create_share_info(
share_record=share_record,
share_team=self.team,
share_user=request.user,
share_info=request.data,
use_force=use_force)
result = general_message(code, "create share info", msg, bean=bean)
return Response(result, status=code)
except ServiceHandleException as e:
raise e
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def put(self, request, service_id, *args, **kwargs):
secret_key = request.data.get("secret_key")
# 加密
deploy_key = deploy_repo.get_secret_key_by_service_id(service_id=service_id)
deploy_key_decode = pickle.loads(base64.b64decode(deploy_key)).get("secret_key")
if secret_key != deploy_key_decode:
result = general_message(400, "failed", "密钥错误")
return Response(result, status=400)
ip = request.data.get("ip", None)
# is_online true为上线，false为下线
is_online = request.data.get("is_online", True)
if type(is_online) != bool:
return Response(general_message(400, "is_online type error", "参数类型错误"), status=400)
if not ip:
return Response(general_message(400, "end_point is null", "end_point未指明"), status=400)
try:
service_obj = TenantServiceInfo.objects.get(service_id=service_id)
tenant_obj = Tenants.objects.get(tenant_id=service_obj.tenant_id)
endpoint_dict = dict()
endpoint_dict["ip"] = ip
endpoint_dict["is_online"] = is_online
# 根据ip从数据中心查询， 有就put，没有就post
res, body = region_api.get_third_party_service_pods(service_obj.service_region, tenant_obj.tenant_name,
service_obj.service_alias)
if res.status != 200:
return Response(general_message(412, "region error", "数据中心查询失败"), status=412)
endpoint_list = body["list"]
# 添加
if not endpoint_list:
res, body = region_api.post_third_party_service_endpoints(service_obj.service_region,
tenant_obj.tenant_name,
service_obj.service_alias,
endpoint_dict)
if res.status != 200:
return Response(general_message(412, "region error", "数据中心添加失败"), status=412)
return Response(general_message(200, "success", "修改成功"))
ip_list = []
for endpoint in endpoint_list:
ip_list.append(endpoint["ip"])
if ip not in ip_list:
# 添加
res, body = region_api.post_third_party_service_endpoints(service_obj.service_region,
tenant_obj.tenant_name,
service_obj.service_alias,
endpoint_dict)
if res.status != 200:
return Response(general_message(412, "region error", "数据中心添加失败"), status=412)
return Response(general_message(200, "success", "修改成功"))
# 修改
for endpoint in endpoint_list:
if endpoint["ip"] == ip:
bean = dict()
bean["ep_id"] = endpoint["ep_id"]
bean["is_online"] = is_online
res, body = region_api.put_third_party_service_endpoints(service_obj.service_region, tenant_obj.tenant_name, service_obj.service_alias,
bean)
if res.status != 200:
return Response(general_message(412, "region error", "数据中心修改失败"), status=412)
result = general_message(200, "success", "修改成功")
return Response(result, status=200)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def get(self, request, *args, **kwargs):
"""
组件事件动态
---
parameters:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: page
description: 页数(默认第一页)
required: false
type: string
paramType: query
- name: page_size
description: 每页展示个数(默认3个)
required: false
type: string
paramType: query
"""
try:
page = request.GET.get("page", 1)
page_size = request.GET.get("page_size", 3)
total = 0
regionsList = region_repo.get_team_opened_region(self.tenant)
event_service_dynamic_list = []
for region in regionsList:
try:
events, event_count, has_next = event_service.get_target_events(
"tenant", self.tenant.tenant_id, self.tenant,
region.region_name, int(page), int(page_size))
event_service_dynamic_list = event_service_dynamic_list + events
total = total + event_count
except Exception as e:
logger.error(
"Region api return error {0}, ignore it".format(e))
event_service_dynamic_list = sorted(event_service_dynamic_list,
self.__sort_events)
service_ids = []
for event in event_service_dynamic_list:
if event["Target"] == "service":
service_ids.append(event["TargetID"])
services = service_repo.get_service_by_service_ids(service_ids)
event_service_list = []
for event in event_service_dynamic_list:
if event["Target"] == "service":
for service in services:
if service.service_id == event["TargetID"]:
event["service_alias"] = service.service_alias
event["service_name"] = service.service_cname
event_service_list.append(event)
event_paginator = JuncheePaginator(event_service_list,
int(page_size))
event_page_list = event_paginator.page(page)
total = event_paginator.count
event_list = [event for event in event_page_list]
result = general_message(200,
'success',
"查询成功",
list=event_list,
total=total)
return Response(result, status=result["code"])
except Exception as e:
code = 500
logger.exception(e)
result = error_message(e.message)
return Response(result, status=code)
def post(self, request, *args, **kwargs):
"""
为应用添加环境变量
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: serviceAlias
description: 服务别名
required: true
type: string
paramType: path
- name: name
description: 环境变量说明
required: false
type: string
paramType: form
- name: attr_name
description: 环境变量名称 大写
required: true
type: string
paramType: form
- name: attr_value
description: 环境变量值
required: true
type: string
paramType: form
- name: scope
description: 生效范围 inner(对内),outer(对外)
required: true
type: string
paramType: form
- name: is_change
description: 是否可更改 (默认可更改)
required: false
type: string
paramType: form
"""
name = request.data.get("name", None)
attr_name = request.data.get("attr_name", None)
attr_value = request.data.get("attr_value", None)
scope = request.data.get('scope', None)
is_change = request.data.get('is_change', True)
try:
if not scope:
return Response(general_message(400, "params error", "参数异常"), status=400)
if scope not in ("inner", "outer"):
return Response(general_message(400, "params error", "scope范围只能是inner或outer"), status=400)
code, msg, data = env_var_service.add_service_env_var(self.tenant, self.service, 0, name, attr_name,
attr_value, is_change, scope)
if code != 200:
result = general_message(code, "add env error", msg)
return Response(result, status=code)
result = general_message(code, msg, u"环境变量添加成功", bean=data.to_dict())
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def put(self, request, *args, **kwargs):
"""
修改构建源
---
"""
s_id = transaction.savepoint()
try:
image = request.data.get("image", None)
cmd = request.data.get("cmd", None)
service_source = request.data.get("service_source")
git_url = request.data.get("git_url", None)
code_version = request.data.get("code_version", None)
user_name = request.data.get("user_name", None)
password = request.data.get("password", None)
is_oauth = request.data.get("is_oauth", False)
user_id = request.user.user_id
oauth_service_id = request.data.get("service_id")
git_full_name = request.data.get("full_name")
if not service_source:
return Response(general_message(400, "param error", "参数错误"), status=400)
service_source_user = service_source_repo.get_service_source(
team_id=self.service.tenant_id, service_id=self.service.service_id)
if not service_source_user:
service_source_info = {
"service_id": self.service.service_id,
"team_id": self.service.tenant_id,
"user_name": user_name,
"password": password,
"create_time": datetime.datetime.now().strftime('%Y%m%d%H%M%S')
}
service_source_repo.create_service_source(**service_source_info)
else:
service_source_user.user_name = user_name
service_source_user.password = password
service_source_user.save()
if service_source == "source_code":
if code_version:
self.service.code_version = code_version
else:
self.service.code_version = "master"
if git_url:
if is_oauth:
try:
oauth_service = oauth_repo.get_oauth_services_by_service_id(service_id=oauth_service_id)
oauth_user = oauth_user_repo.get_user_oauth_by_user_id(service_id=oauth_service_id, user_id=user_id)
except Exception as e:
logger.debug(e)
rst = {"data": {"bean": None}, "status": 400, "msg_show": u"未找到OAuth服务, 请检查该服务是否存在且属于开启状态"}
return Response(rst, status=200)
try:
instance = get_oauth_instance(oauth_service.oauth_type, oauth_service, oauth_user)
except Exception as e:
logger.debug(e)
rst = {"data": {"bean": None}, "status": 400, "msg_show": u"未找到OAuth服务"}
return Response(rst, status=200)
if not instance.is_git_oauth():
rst = {"data": {"bean": None}, "status": 400, "msg_show": u"该OAuth服务不是代码仓库类型"}
return Response(rst, status=200)
service_code_from = "oauth_" + oauth_service.oauth_type
self.service.code_from = service_code_from
self.service.git_url = git_url
self.service.git_full_name = git_full_name
self.service.oauth_service_id = oauth_service_id
self.service.creater = user_id
else:
self.service.git_url = git_url
self.service.save()
transaction.savepoint_commit(s_id)
elif service_source == "docker_run":
if image:
version = image.split(':')[-1]
if not version:
version = "latest"
image = image + ":" + version
self.service.image = image
self.service.version = version
self.service.cmd = cmd
self.service.save()
transaction.savepoint_commit(s_id)
result = general_message(200, "success", "修改成功")
except Exception as e:
logger.exception(e)
result = error_message(e.message)
transaction.savepoint_rollback(s_id)
return Response(result, status=result["code"])
def post(self, request, team_name, group_id, *args, **kwargs):
"""
生成分享订单，会验证是否能够分享
---
parameter:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: group_id
description: 应用id
required: true
type: string
paramType: path
"""
scope = request.data.get("scope")
market_name = None
if scope == "goodrain":
target = request.data.get("target")
market_name = target.get("store_id")
if market_name is None:
result = general_message(400, "fail", "参数不全")
return Response(result, status=result.get("code", 200))
try:
if group_id == "-1":
code = 400
result = general_message(400, "group id error", "未分组应用不可分享")
return Response(result, status=code)
team_id = self.team.tenant_id
group_count = group_repo.get_group_count_by_team_id_and_group_id(
team_id=team_id, group_id=group_id)
if group_count == 0:
code = 202
result = general_message(code,
"group is not yours!",
"当前组已删除或您无权限查看!",
bean={})
return Response(result, status=200)
# 判断是否满足分享条件
data = share_service.check_service_source(
team=self.team,
team_name=team_name,
group_id=group_id,
region_name=self.response_region)
if data and data["code"] == 400:
return Response(data, status=data["code"])
fields_dict = {
"group_share_id": make_uuid(),
"group_id": group_id,
"team_name": team_name,
"is_success": False,
"step": 1,
"share_app_market_name": market_name,
"scope": scope,
"create_time": datetime.datetime.now(),
"update_time": datetime.datetime.now(),
}
service_share_record = share_service.create_service_share_record(
**fields_dict)
result = general_message(200,
"create success",
"创建成功",
bean=service_share_record.to_dict())
return Response(result, status=200)
except ServiceHandleException as e:
raise e
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def post(self, request, *args, **kwargs):
"""
应用备份
---
parameters:
- name: tenantName
description: 团队名称
required: true
type: string
paramType: path
- name: group_id
description: 组ID
required: true
type: string
paramType: path
- name: note
description: 备份说明
required: true
type: string
paramType: form
- name: mode
description: 备份模式（full-online|full-offline）
required: true
type: string
paramType: form
"""
try:
group_id = int(kwargs.get("group_id", None))
if not group_id:
return Response(general_message(400, "group id is null",
"请选择需要备份的组"),
status=400)
note = request.data.get("note", None)
mode = request.data.get("mode", None)
if not note:
return Response(general_message(400, "note is null",
"请填写备份信息"),
status=400)
if not mode:
return Response(general_message(400, "mode is null",
"请选择备份模式"),
status=400)
code, running_state_services = groupapp_backup_service.check_backup_condition(
self.tenant, self.response_region, group_id)
if running_state_services:
return Response(general_message(
412, "state service is not closed",
"您有有状态服务未关闭,应用如下 {0}".format(
",".join(running_state_services))),
status=412)
code, msg, back_up_record = groupapp_backup_service.back_up_group_apps(
self.tenant, self.user, self.response_region, group_id, mode,
note)
if code != 200:
return Response(general_message(code, "backup not success",
msg),
status=code)
bean = back_up_record.to_dict()
bean.pop("backup_server_info")
result = general_message(200, "success", "操作成功，正在备份中", bean=bean)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def put(self, request, *args, **kwargs):
"""
compose文件内容修改
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: group_id
description: 组ID
required: true
type: string
paramType: path
- name: group_name
description: 组名称
required: false
type: string
paramType: form
- name: compose_content
description: yaml文件内容
required: false
type: string
paramType: form
"""
try:
group_id = kwargs.get("group_id", None)
yaml_content = request.data.get("compose_content", None)
group_name = request.data.get("group_name", None)
if not yaml_content and not group_name:
return Response(general_message(400, "params error",
"请填入需要修改的参数"),
status=400)
if group_name:
code, msg, group = group_service.update_group(
self.tenant, self.response_region, group_id, group_name)
if code != 200:
return Response(general_message(code,
"group name change error",
msg),
status=code)
if yaml_content:
code, msg, json_data = compose_service.yaml_to_json(
yaml_content)
if code != 200:
return Response(general_message(code, "parse yaml error",
msg),
status=code)
code, msg, new_compose = compose_service.update_compose(
group_id, json_data)
if code != 200:
return Response(general_message(code,
"save yaml content error",
msg),
status=code)
result = general_message(200, u"success", "修改成功")
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def put(self, request, *args, **kwargs):
"""
更新某个版本插件的信息
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: plugin_id
description: 插件ID
required: true
type: string
paramType: path
- name: build_version
description: 插件版本
required: true
type: string
paramType: path
- name: plugin_alias
description: 插件名称
required: false
type: string
paramType: form
- name: update_info
description: 更新信息
required: false
type: string
paramType: form
- name: build_cmd
description: 构建命令
required: false
type: string
paramType: form
- name: image_tag
description: 镜像版本
required: false
type: string
paramType: form
- name: code_version
description: 代码版本
required: false
type: string
paramType: form
- name: min_memory
description: 最小内存
required: false
type: string
paramType: form
"""
try:
plugin_alias = request.data.get("plugin_alias",
self.plugin.plugin_alias)
update_info = request.data.get("update_info",
self.plugin_version.update_info)
build_cmd = request.data.get("build_cmd",
self.plugin_version.build_cmd)
image_tag = request.data.get("image_tag",
self.plugin_version.image_tag)
code_version = request.data.get("code_version",
self.plugin_version.code_version)
min_memory = request.data.get("min_memory",
self.plugin_version.min_memory)
min_cpu = plugin_version_service.calculate_cpu(
self.response_region, min_memory)
self.plugin.plugin_alias = plugin_alias
self.plugin_version.update_info = update_info
self.plugin_version.build_cmd = build_cmd
self.plugin_version.image_tag = image_tag
self.plugin_version.code_version = code_version
self.plugin_version.min_memory = min_memory
self.plugin_version.min_cpu = min_cpu
plugin_service.update_region_plugin_info(self.response_region,
self.team, self.plugin,
self.plugin_version)
# 保存基本信息
self.plugin.save()
# 保存版本信息
self.plugin_version.save()
result = general_message(200, "success", "操作成功")
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def post(self, request, *args, **kwargs):
"""
docker-compose创建应用
---
parameters:
- name: tenantName
description: 租户名
required: true
type: string
paramType: path
- name: group_name
description: 应用组名称
required: true
type: string
paramType: form
- name: yaml_content
description: compose文件内容
required: true
type: string
paramType: form
"""
group_name = request.data.get("group_name", None)
yaml_content = request.data.get("yaml_content", "")
try:
if not group_name:
return Response(general_message(400, 'params error',
"请指明需要创建的compose组名"),
status=400)
if not yaml_content:
return Response(general_message(400, "params error",
"未指明yaml内容"),
status=400)
code, msg, json_data = compose_service.yaml_to_json(yaml_content)
if code != 200:
return Response(general_message(code, "parse yaml error", msg),
status=code)
# 创建组
code, msg, group_info = group_service.add_group(
self.tenant, self.response_region, group_name)
if code != 200:
return Response(general_message(code, "create group error",
msg),
status=code)
code, msg, group_compose = compose_service.create_group_compose(
self.tenant, self.response_region, group_info.ID, json_data)
if code != 200:
return Response(general_message(code,
"create group compose error",
msg),
status=code)
bean = dict()
bean["group_id"] = group_compose.group_id
bean["compose_id"] = group_compose.compose_id
bean["group_name"] = group_info.group_name
result = general_message(200,
"operation success",
"compose组创建成功",
bean=bean)
except Exception as e:
logger.exception(e)
result = error_message()
return Response(result, status=result["code"])
def get(self, request, tenantName, *args, **kwargs):
"""
下载应用包
---
parameters:
- name: tenantName
description: 团队名称
required: true
type: string
paramType: path
- name: format
description: 导出类型 rainbond-app | docker-compose
required: true
type: string
paramType: form
- name: app_id
description: rainbond app id
required: true
type: string
paramType: query
"""
try:
app_id = request.GET.get("app_id", None)
export_format = request.GET.get("format", None)
if not app_id:
return Response(general_message(400, "app id is null",
"请指明需要下载的应用"),
status=400)
if not export_format or export_format not in (
"rainbond-app",
"docker-compose",
):
return Response(general_message(400,
"export format is illegal",
"请指明下载的格式"),
status=400)
code, app = market_app_service.get_rain_bond_app_by_pk(app_id)
if not app:
return Response(general_message(404, "not found", "云市应用不存在"),
status=404)
export_record = export_service.get_export_record(
export_format, app)
if not export_record:
return Response(general_message(400, "no export records",
"该应用无导出记录，无法下载"),
status=400)
if export_record.status != "success":
if export_record.status == "failed":
return Response(general_message(400, "export failed",
"应用导出失败，请重试"),
status=400)
if export_record.status == "exporting":
return Response(general_message(400, "exporting",
"应用正在导出中，请稍后重试"),
status=400)
req, file_name = export_service.get_file_down_req(
export_format, tenantName, app)
response = StreamingHttpResponse(self.file_iterator(req))
response['Content-Type'] = 'application/octet-stream'
response[
'Content-Disposition'] = 'attachment;filename="{0}"'.format(
file_name)
return response
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def get(self, request, team_name, share_id, *args, **kwargs):
"""
查询分享的所有应用信息和插件信息
---
parameter:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
- name: share_id
description: 分享订单ID
required: true
type: string
paramType: path
"""
try:
share_record = share_service.get_service_share_record_by_ID(
ID=share_id, team_name=team_name)
if not share_record:
result = general_message(404, "share record not found",
"分享流程不存在，请退出重试")
return Response(result, status=404)
if share_record.is_success or share_record.step >= 3:
result = general_message(400, "share record is complete",
"分享流程已经完成，请重新进行分享")
return Response(result, status=400)
# 获取分享应用组基本信息
data = dict()
share_group_info = dict()
share_group = share_service.check_whether_have_share_history(
group_id=share_record.group_id)
if share_group:
share_group_info["group_key"] = share_group.group_key
share_group_info["group_name"] = share_group.group_name
share_group_info["version"] = share_group.version
share_group_info["describe"] = share_group.describe
share_group_info["scope"] = share_group.scope
share_group_info["share_id"] = share_group.ID
share_group_info["pic"] = share_group.pic
share_group_info["share_team"] = share_group.share_team
share_group_info["share_user"] = share_group.share_user
share_group_info["is_shared"] = True
data["share_group_info"] = share_group_info
else:
try:
user = user_services.get_user_by_user_name(
user_name=request.user)
if not user:
result = general_message(400, "user failed",
"数据紊乱，非当前用户操作页面")
return Response(result, status=400)
except UserNotExistError as e:
result = general_message(400, e.message, "用户不存在")
return Response(result, status=400)
code, msg, group = group_service.get_group_by_id(
tenant=self.team,
region=self.response_region,
group_id=share_record.group_id)
if code == 200:
share_group_info["group_key"] = make_uuid()
share_group_info["group_name"] = group.get("group_name")
share_group_info["version"] = 'v1.0'
share_group_info[
"describe"] = 'This is a default description.'
share_group_info["scope"] = 'team'
share_group_info["share_id"] = share_record.group_id
share_group_info["pic"] = ''
share_group_info["share_team"] = team_name
share_group_info["share_user"] = str(user.user_id)
share_group_info["is_shared"] = False
data["share_group_info"] = share_group_info
else:
result = general_message(code=code,
msg="failed",
msg_show=msg)
return Response(result, status=code)
service_info_list = share_service.query_share_service_info(
team=self.team, group_id=share_record.group_id)
data["share_service_list"] = service_info_list
plugins = share_service.query_group_service_plugin_list(
team=self.team, group_id=share_record.group_id)
data["share_plugin_list"] = plugins
result = general_message(200, "query success", "获取成功", bean=data)
return Response(result, status=200)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
