def post(self, request, *args, **kwargs):
"""
分享插件
TODO 此功能暂时不全
"""
result = {}
try:
data = json.loads(request.body)
plugin_id = data.get("plugin_id", None)
plugin_version = data.get("build_version", None)
share_verion = data.get("share_verion", plugin_version)
region = self.request.COOKIES.get('region')
if not plugin_id:
return JsonResponse(general_message(400, "params error",
"参数异常"),
status=400)
base_info = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, plugin_id)
pbv = plugin_svc.get_tenant_plugin_version_by_plugin_id_and_version(
self.tenant, plugin_id, plugin_version)
image = ""
config = plugin_svc.get_plugin_config(self.tenant, plugin_id,
plugin_version)
config_group = json.dumps(config["config_group"])
plugin_share_svc.create_share_info(self.tenant, self.user.user_id,
base_info, pbv, share_verion,
image, config_group)
result = general_message(200, "success", "操作成功")
except Exception as e:
logger.exception(e)
result = error_message()
return JsonResponse(result, status=result["code"])
def post(self, request, plugin_id, build_version, *args, **kwargs):
"""构建插件"""
result = {}
try:
config = json.loads(request.body)
update_info = config.get("update_info", None)
pbv = plugin_svc.get_tenant_plugin_version_by_plugin_id_and_version(
self.tenant, self.plugin_id, build_version)
if not pbv:
return JsonResponse(general_message(404, "plugin not found",
"插件不存在"),
status=404)
if pbv.plugin_version_status == "fixed":
return JsonResponse(general_message(
403, "current version is fixed", "该版本已固定，不能构建"),
status=403)
if pbv.build_status == "building":
return JsonResponse(general_message(403, "too offen",
"构建中，请稍后再试"),
status=403)
if update_info:
pbv.update_info = update_info
pbv.save()
region = self.request.COOKIES.get('region')
event_id = make_uuid()
base_info = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, self.plugin_id)
try:
plugin_svc.build_plugin(region, self.tenant, event_id,
self.plugin_id, build_version,
base_info.origin)
pbv.build_status = "building"
logger.debug("plugin build status is {}".format(
pbv.build_status))
pbv.event_id = event_id
pbv.save()
bean = {"event_id": event_id}
result = general_message(200, "success", "操作成功", bean=bean)
except Exception as e:
logger.exception(e)
result = general_message(500, "region invoke error", "操作失败")
except Exception as e:
logger.exception(e)
result = error_message()
return JsonResponse(result, status=result["code"])
def get(self, request, plugin_id, *args, **kwargs):
result = {}
region = self.request.COOKIES.get('region')
try:
base_info = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, plugin_id)
data = base_info.to_dict()
pbvs = plugin_svc.get_tenant_plugin_versions(
region, self.tenant, plugin_id)
if len(pbvs) != 0:
pbv = pbvs[0]
data.update(pbv.to_dict())
result = general_message(200, "success", "查询成功", bean=data)
except Exception as e:
logger.exception(e)
result = error_message()
return JsonResponse(result, status=result["code"])
def put(self, request, plugin_id, build_version, *args, **kwargs):
"""更新指定版本的插件信息"""
result = {}
try:
data = json.loads(request.body)
pbv = plugin_svc.get_tenant_plugin_version_by_plugin_id_and_version(
self.tenant, plugin_id, build_version)
if not pbv:
return JsonResponse(general_message(404, "plugin not found",
"该版本插件不存在"),
status=404)
base_info = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, plugin_id)
plugin_alias = data.get("plugin_alias", base_info.plugin_alias)
update_info = data.get("update_info", pbv.update_info)
build_cmd = data.get("build_cmd", pbv.build_cmd)
image_tag = data.get("image_tag", pbv.image_tag)
code_version = data.get("code_version", pbv.code_version)
min_memory = data.get("min_memory", pbv.min_memory)
region = self.request.COOKIES.get('region')
min_cpu = plugin_svc.calculate_cpu(region, int(min_memory))
update_params = {
"min_memory": min_memory,
"build_cmd": build_cmd,
"update_info": update_info,
"min_cpu": min_cpu,
"code_version": code_version,
"image_tag": image_tag
}
# 更新数据
new_pbv = plugin_svc.update_plugin_version_by_unique_key(
self.tenant, plugin_id, build_version, **update_params)
base_info.plugin_alias = plugin_alias
base_info.save()
bean = new_pbv.to_dict()
result = general_message(200, "success", "操作成功", bean=bean)
except Exception as e:
logger.exception(e)
result = error_message()
return JsonResponse(result, status=result["code"])
def get(self, request, plugin_id, *args, **kwargs):
context = self.get_context()
try:
context["pluginStatus"] = "active"
build_version = request.GET.get("build_version", None)
context["plugin_id"] = plugin_id
base_info = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, plugin_id)
if not base_info:
return HttpResponse("插件不存在", status=404)
build_version_info = plugin_svc.get_tenant_plugin_version_by_plugin_id_and_version(
self.tenant, plugin_id, build_version)
context["base_info"] = base_info
context["build_version_info"] = build_version_info
context["web_socket_url"] = self.get_ws_url(
settings.EVENT_WEBSOCKET_URL[self.response_region],
"event_log")
logger.debug(context["web_socket_url"])
except Exception as e:
logger.exception(e)
return TemplateResponse(self.request, "www/plugin/config_plugin.html",
context)
def get(self, request, plugin_id, build_version, *args, **kwargs):
"""获取某版本插件配置"""
result = {}
try:
region = self.request.COOKIES.get('region')
# 获取插件最新的配置信息
base_info = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, plugin_id)
if not base_info:
return JsonResponse(general_message(404, "plugin not exist",
"插件不存在"),
status=404)
data = plugin_svc.get_plugin_config(self.tenant, plugin_id,
build_version)
web_socket_url = self.get_ws_url(
settings.EVENT_WEBSOCKET_URL[region], "event_log")
data["web_socket_url"] = web_socket_url
result = general_message(200, "success", "查询成功", bean=data)
except Exception as e:
logger.exception(e)
result = error_message()
return JsonResponse(data=result, status=result["code"])
def get(self, request, plugin_id, *args, **kwargs):
result = {}
try:
# 获取插件最新的配置信息
build_version = request.GET.get("build_version", None)
base_info = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, plugin_id)
if not base_info:
return JsonResponse({"msg": "插件不存在"}, status=404)
if not build_version:
pbv = plugin_svc.get_tenant_plugin_version_by_plugin_id_and_version(
self.tenant, plugin_id)
build_version = pbv.build_version
data = plugin_svc.get_plugin_config(self.tenant, plugin_id,
build_version)
web_socket_url = self.get_ws_url(
settings.EVENT_WEBSOCKET_URL[self.response_region],
"event_log")
data["web_socket_url"] = web_socket_url
result = general_message(200, "success", "查询成功", bean=data)
except Exception as e:
result = error_message()
return JsonResponse(data=result, status=result["code"])
def post(self, request, plugin_id, *args, **kwargs):
"""创建插件新版本"""
result = {}
try:
region = self.request.COOKIES.get('region')
pbv = plugin_svc.get_tenant_plugin_version_by_plugin_id_and_version(
self.tenant, plugin_id, None)
base_info = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, plugin_id)
if base_info:
if base_info.origin != "source_code":
return JsonResponse(general_message(
403, "market plugin can not create new version",
"云市插件不能创建版本"),
status=403)
if not pbv:
return JsonResponse(general_message(
403, "current version not exist", "插件不存在任何版本，无法创建"),
status=403)
if pbv.build_status != "build_success":
return JsonResponse(general_message(
403, "no useable plugin version", "您的插件构建未成功，无法创建新版本"),
status=403)
plugin_id, new_version = plugin_svc.copy_config_to_new_version(
self.tenant, self.plugin_id, pbv.build_version)
pbv.plugin_version_status = "fixed"
pbv.save()
bean = {"plugin_id": plugin_id, "new_version": new_version}
result = general_message(200, "success", "操作成功", bean=bean)
except Exception as e:
logger.exception(e)
result = error_message()
return JsonResponse(result, status=result["code"])
def post(self, request, plugin_id, *args, **kwargs):
result = {}
build_version = None
try:
config = json.loads(request.body)
min_memory = config["min_memory"]
build_version = config["build_version"]
config_group = config['config_group']
update_info = config['update_info']
build_cmd = config["build_cmd"]
image_tag = config.get("image_tag", None)
code_version = config.get("code_version", None)
if config_group:
is_success, msg = plugin_svc.check_config(*config_group)
if not is_success:
result["status"] = "failure"
result["msg"] = msg
return JsonResponse(result)
plugin = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, plugin_id)
min_cpu = plugin_svc.calculate_cpu(self.response_region,
int(min_memory))
pbv = plugin_svc.get_tenant_plugin_version_by_plugin_id_and_version(
self.tenant, plugin_id, build_version)
if pbv.build_status == "unbuild":
# 删除原有配置项目
plugin_svc.delete_config_group_by_group_id_and_version(
plugin_id, build_version)
# 重新创建新配置
plugin_svc.create_config_group(plugin_id, build_version,
config_group)
# 更新参数
update_params = {
"min_memory": min_memory,
"build_cmd": build_cmd,
"update_info": update_info
}
plugin_svc.update_plugin_version_by_unique_key(
self.tenant, plugin_id, build_version, **update_params)
build_version = pbv.build_version
else:
# 重新创建新的数据
new_version = make_uuid()[:6] + datetime.datetime.now(
).strftime('%Y%m%d%H%M%S')
if plugin.build_source == "dockerfile":
code_version = config.get("code_version", "master")
if plugin.build_source == "image":
image_tag = config.get("image", "lastest")
new_pbv = plugin_svc.create_plugin_build_version(
self.response_region, pbv.plugin_id, pbv.tenant_id,
self.user.user_id, update_info, new_version, "unbuild",
min_memory, min_cpu, build_cmd, image_tag, code_version)
plugin_svc.create_config_group(plugin_id,
new_pbv.build_version,
config_group)
build_version = new_version
bean = {"plugin_id": plugin_id, "build_version": build_version}
result = general_message(200, "success", "查询成功", bean=bean)
except Exception as e:
logger.exception(e)
result = error_message()
return JsonResponse(result, status=result["code"])
def get(self, request, *args, **kwargs):
self.response_region = self.service.service_region
self.tenant_region = TenantRegionInfo.objects.get(
tenant_id=self.service.tenant_id,
region_name=self.service.service_region)
context = self.get_context()
context["tenantName"] = self.tenantName
context['serviceAlias'] = self.serviceAlias
fr = request.GET.get("fr", "deployed")
context["fr"] = fr
# 判断是否社区版云帮
context["community"] = False
if sn.instance.is_private():
context["community"] = True
try:
regionBo = rpmManager.get_work_region_by_name(self.response_region)
memory_post_paid_price = regionBo.memory_trial_price # 内存按需使用价格
disk_post_paid_price = regionBo.disk_trial_price # 磁盘按需使用价格
net_post_paid_price = regionBo.net_trial_price # 网络按需使用价格
if self.service.category == "application":
# forbidden blank page
if self.service.code_version is None or self.service.code_version == "" or (
self.service.git_project_id == 0
and self.service.git_url is None):
codeRepositoriesService.initRepositories(
self.tenant, self.user, self.service, "gitlab_new", "",
"", "master")
self.service = TenantServiceInfo.objects.get(
service_id=self.service.service_id)
if ServiceCreateStep.objects.filter(
service_id=self.service.service_id,
tenant_id=self.tenant.tenant_id).count() > 0:
app_step = ServiceCreateStep.objects.get(
service_id=self.service.service_id,
tenant_id=self.tenant.tenant_id).app_step
logger.debug("create service step" + str(app_step))
if app_step == 2:
codeRepositoriesService.codeCheck(self.service)
return self.redirect_to(
'/apps/{0}/{1}/app-waiting/'.format(
self.tenant.tenant_name,
self.service.service_alias))
if app_step == 3:
return self.redirect_to(
'/apps/{0}/{1}/app-setting/'.format(
self.tenant.tenant_name,
self.service.service_alias))
if app_step == 4:
return self.redirect_to(
'/apps/{0}/{1}/app-language/'.format(
self.tenant.tenant_name,
self.service.service_alias))
elif self.service.category == 'app_publish':
# 市场安装
if ServiceCreateStep.objects.filter(
service_id=self.service.service_id,
tenant_id=self.tenant.tenant_id).count() > 0:
return self.redirect_to(
'/apps/{0}/{1}/deploy/setting/'.format(
self.tenantName, self.serviceAlias))
# service_consume_detail_list = TenantConsumeDetail.objects.filter(tenant_id=self.tenant.tenant_id,
# service_id=self.service.service_id).order_by("-ID")
# last_hour_cost = None
# if len(service_consume_detail_list) > 0:
# last_hour_cost = service_consume_detail_list[0]
# if last_hour_cost is not None:
# last_hour_cost.memory_fee = round(
# last_hour_cost.memory / 1024 * memory_post_paid_price * last_hour_cost.node_num, 2)
# last_hour_cost.disk_fee = round(last_hour_cost.disk / 1024 * disk_post_paid_price, 2)
# last_hour_cost.net_fee = round(last_hour_cost.net / 1024 * net_post_paid_price, 2)
# last_hour_cost.total_fee = last_hour_cost.disk_fee + last_hour_cost.memory_fee + last_hour_cost.net_fee
# context["last_hour_cost"] = last_hour_cost
context['is_tenant_free'] = (self.tenant.pay_type == "free")
context["tenantServiceInfo"] = self.service
context["myAppStatus"] = "active"
context["perm_users"] = self.get_user_perms()
context[
"totalMemory"] = self.service.min_node * self.service.min_memory
context["tenant"] = self.tenant
context["region_name"] = self.service.service_region
# context["websocket_uri"] = settings.WEBSOCKET_URL[self.service.service_region]
context["event_websocket_uri"] = self.make_event_ws_uri(
settings.EVENT_WEBSOCKET_URL[self.service.service_region])
context["monitor_websocket_uri"] = self.make_monitor_ws_uri(
settings.EVENT_WEBSOCKET_URL[self.service.service_region])
context["wild_domain"] = settings.WILD_DOMAINS[
self.service.service_region]
if ServiceGroupRelation.objects.filter(
service_id=self.service.service_id).count() > 0:
gid = ServiceGroupRelation.objects.get(
service_id=self.service.service_id).group_id
context["group_id"] = gid
else:
context["group_id"] = -1
service_domain = False
if TenantServicesPort.objects.filter(
service_id=self.service.service_id,
is_outer_service=True,
protocol='http').exists():
context["hasHttpServices"] = True
service_domain = True
is_public_cloud = (sn.instance.cloud_assistant == "goodrain"
and (not sn.instance.is_private()))
http_port_str = settings.WILD_PORTS[self.response_region]
if not is_public_cloud:
# 如果不为公有云
http_port_str = settings.WILD_PORTS["cloudbang"]
context['http_port_str'] = ":" + http_port_str
service_attach_info = None
try:
service_attach_info = ServiceAttachInfo.objects.get(
tenant_id=self.tenant.tenant_id,
service_id=self.service.service_id)
attachManage = ServiceAttachInfoManage()
if not attachManage.is_during_monthly_payment(
service_attach_info):
if attachManage.is_need_to_update(service_attach_info,
self.service.min_memory,
self.service.min_node):
service_attach_info.min_memory = self.service.min_memory
service_attach_info.min_node = self.service.min_node
service_attach_info.save()
except ServiceAttachInfo.DoesNotExist:
pass
if service_attach_info is None:
service_attach_info = self.generate_service_attach_info()
now = datetime.datetime.now()
if service_attach_info.buy_end_time < now:
if service_attach_info.memory_pay_method == "prepaid" or service_attach_info.disk_pay_method == "prepaid":
service_attach_info.disk_pay_method = "postpaid"
service_attach_info.memory_pay_method = "postpaid"
service_attach_info.save()
if fr == "deployed":
if self.service.service_type == 'mysql':
service_manager = self.get_manage_app(http_port_str)
context['service_manager'] = service_manager
# inner service
innerPorts = {}
tsps = TenantServicesPort.objects.filter(
service_id=self.service.service_id, is_inner_service=True)
for tsp in tsps:
innerPorts[tsp.container_port] = True
if len(tsps) > 0:
context["hasInnerServices"] = True
envMap = {}
envVarlist = TenantServiceEnvVar.objects.filter(
service_id=self.service.service_id,
scope__in=("outer", "both"),
is_change=False)
if len(envVarlist) > 0:
for evnVarObj in envVarlist:
arr = envMap.get(evnVarObj.service_id)
if arr is None:
arr = []
arr.append(evnVarObj)
envMap[evnVarObj.service_id] = arr
context["envMap"] = envMap
containerPortList = []
opend_service_port_list = TenantServicesPort.objects.filter(
service_id=self.service.service_id, is_inner_service=True)
if len(opend_service_port_list) > 0:
for opend_service_port in opend_service_port_list:
containerPortList.append(
opend_service_port.container_port)
context["containerPortList"] = containerPortList
if self.service.code_from != "image_manual":
baseservice = ServiceInfo.objects.get(
service_key=self.service.service_key,
version=self.service.version)
if baseservice.update_version != self.service.update_version:
context["updateService"] = True
context["docker_console"] = settings.MODULES["Docker_Console"]
context["publish_service"] = settings.MODULES[
"Publish_Service"]
# get port type
context["visit_port_type"] = self.service.port_type
if self.service.port_type == "multi_outer":
context[
"http_outer_service_ports"] = self.get_outer_service_port(
)
service_consume_list = ServiceConsume.objects.filter(
tenant_id=self.tenant.tenant_id,
service_id=self.service.service_id).order_by("-ID")
last_hour_cost = None
if service_consume_list:
last_hour_cost = service_consume_list[0]
context["last_hour_cost"] = last_hour_cost
elif fr == "relations":
# service relationships
tsrs = TenantServiceRelation.objects.filter(
service_id=self.service.service_id)
relationsids = []
if len(tsrs) > 0:
for tsr in tsrs:
relationsids.append(tsr.dep_service_id)
context["serviceIds"] = relationsids
# service map
map = {}
sids = []
tenantServiceList = baseService.get_service_list(
self.tenant.pk,
self.user,
self.tenant.tenant_id,
region=self.response_region)
for tenantService in tenantServiceList:
if TenantServicesPort.objects.filter(
service_id=tenantService.service_id,
is_inner_service=True).exists():
sids.append(tenantService.service_id)
if tenantService.service_id != self.service.service_id:
map[tenantService.service_id] = tenantService
if tenantService.service_id in relationsids:
map[tenantService.service_id] = tenantService
context["serviceMap"] = map
# env map
envMap = {}
envVarlist = TenantServiceEnvVar.objects.filter(
service_id__in=sids, scope__in=("outer", "both"))
for evnVarObj in envVarlist:
arr = envMap.get(evnVarObj.service_id)
if arr is None:
arr = []
arr.append(evnVarObj)
envMap[evnVarObj.service_id] = arr
context["envMap"] = envMap
# 当前服务的连接信息
currentEnvMap = {}
currentEnvVarlist = TenantServiceEnvVar.objects.filter(
service_id=self.service.service_id,
scope__in=("outer", "both"),
is_change=False)
if len(currentEnvVarlist) > 0:
for evnVarObj in currentEnvVarlist:
arr = currentEnvMap.get(evnVarObj.service_id)
if arr is None:
arr = []
arr.append(evnVarObj)
currentEnvMap[evnVarObj.service_id] = arr
context["currentEnvMap"] = currentEnvMap
containerPortList = []
opend_service_port_list = TenantServicesPort.objects.filter(
service_id=self.service.service_id, is_inner_service=True)
if len(opend_service_port_list) > 0:
for opend_service_port in opend_service_port_list:
containerPortList.append(
opend_service_port.container_port)
context["containerPortList"] = containerPortList
# add dir mnt
mtsrs = TenantServiceMountRelation.objects.filter(
service_id=self.service.service_id)
mntsids = []
if len(mtsrs) > 0:
for mnt in mtsrs:
mntsids.append(mnt.dep_service_id)
context["mntsids"] = mntsids
elif fr == "statistic":
context['statistic_type'] = self.statistic_type
if self.service.service_type in ('mysql', ):
context['ws_topic'] = '{0}.{1}.statistic'.format(
self.tenant.tenant_id[-12:],
self.service.service_id[-12:])
else:
# context['ws_topic'] = '{0}.{1}.statistic'.format(self.tenant.tenant_name, self.service.service_alias)
if self.service.port_type == "multi_outer":
context['ws_topic'] = '{0}.{1}.statistic'.format(
self.tenant.tenant_name,
self.service.service_alias)
# tsps = TenantServicesPort.objects.filter(service_id=self.service.service_id, is_outer_service=True)
# for tsp in tsps:
# context['ws_topic'] = '{0}.{1}_{2}.statistic'.format(self.tenant.tenant_name, self.service.service_alias, str(tsp.container_port))
else:
context['ws_topic'] = '{0}.{1}.statistic'.format(
self.tenant.tenant_name,
self.service.service_alias)
service_port_list = TenantServicesPort.objects.filter(
tenant_id=self.tenant.tenant_id,
service_id=self.service.service_id)
has_outer_port = False
for p in service_port_list:
if (p.is_outer_service and p.protocol
== "http") or self.service.service_type == 'mysql':
has_outer_port = True
break
context["has_outer_port"] = has_outer_port
has_analyis_plugin = "no"
tenant_service_relations = plugin_svc.get_tenant_service_plugin_relation(
self.service.service_id)
for re in tenant_service_relations:
plugin = plugin_svc.get_tenant_plugin_by_plugin_id(
self.tenant, re.plugin_id)
if plugin.category == "analyst-plugin:perf" or plugin.category == "performance_analysis":
has_analyis_plugin = "yes"
context["has_analyis_plugin"] = has_analyis_plugin
elif fr == "log":
pass
elif fr == "settings":
nodeList = []
memoryList = []
port_changeable = self.service.code_from
context["port_changeable"] = port_changeable
try:
sem = ServiceExtendMethod.objects.get(
service_key=self.service.service_key,
app_version=self.service.version)
nodeList.append(sem.min_node)
next_node = sem.min_node + sem.step_node
while (next_node <= sem.max_node):
nodeList.append(next_node)
next_node = next_node + sem.step_node
num = 1
memoryList.append(str(sem.min_memory))
next_memory = sem.min_memory * pow(2, num)
while (next_memory <= sem.max_memory):
memoryList.append(str(next_memory))
num = num + 1
next_memory = sem.min_memory * pow(2, num)
except Exception as e:
nodeList.append(1)
memoryList.append(str(self.service.min_memory))
memoryList.append("256")
memoryList.append("512")
memoryList.append("1024")
memoryList.append("2048")
memoryList.append("4096")
memoryList.append("8192")
context["nodeList"] = nodeList
context["memoryList"] = memoryList
context["memorydict"] = self.memory_choices()
context["extends_choices"] = self.extends_choices()
context["add_port"] = settings.MODULES["Add_Port"]
if custom_config.GITLAB_SERVICE_API:
context["git_tag"] = True
else:
context["git_tag"] = False
context["mnt_share_choices"] = self.mnt_share_choices()
context[
"http_outer_service_ports"] = self.get_outer_service_port(
)
# service git repository
try:
context["httpGitUrl"] = codeRepositoriesService.showGitUrl(
self.service)
if self.service.code_from == "gitlab_manual":
href_url = self.service.git_url
if href_url.startswith('git@'):
href_url = "http://" + href_url.replace(":",
"/")[4:]
context["href_url"] = href_url
except Exception as e:
pass
if service_domain:
# service domain
# domain_num = ServiceDomain.objects.filter(service_id=self.service.service_id).count()
# if domain_num == 1:
# domain = ServiceDomain.objects.get(service_id=self.service.service_id)
# context["serviceDomain"] = domain
serviceDomainlist = ServiceDomain.objects.filter(
service_id=self.service.service_id)
if len(serviceDomainlist) > 0:
data = {}
for domain in serviceDomainlist:
if data.get(domain.container_port) is None:
data[domain.container_port] = [
domain.domain_name
]
else:
data[domain.container_port].append(
domain.domain_name)
context["serviceDomainDict"] = data
port_list = TenantServicesPort.objects.filter(
service_id=self.service.service_id)
outer_port_exist = False
if len(port_list) > 0:
outer_port_exist = reduce(
lambda x, y: x or y,
[t.is_outer_service for t in list(port_list)])
context["ports"] = list(port_list)
context["outer_port_exist"] = outer_port_exist
# 付费用户或者免费用户的mysql,免费用户的docker
context[
"outer_auth"] = self.tenant.pay_type != "free" or self.service.service_type == 'mysql' or self.service.language == "docker"
# 付费用户,管理员的application类型服务可以修改port
context["port_auth"] = (
self.tenant.pay_type != "free" or self.user.is_sys_admin
) and self.service.service_type == "application"
context["envs"] = TenantServiceEnvVar.objects.filter(
service_id=self.service.service_id,
scope__in=("inner", "both")).exclude(container_port=-1)
# 获取挂载信息,查询
volume_list = TenantServiceVolume.objects.filter(
service_id=self.service.service_id)
# result_list = []
# for volume in list(volume_list):
# tmp_path = volume.volume_path
# if tmp_path:
# volume.volume_path = tmp_path.replace("/app", "", 1)
# result_list.append(volume)
context["volume_list"] = volume_list
if self.service.code_from is not None and self.service.code_from in (
"image_manual"):
context["show_git"] = False
else:
context["show_git"] = True
# 获取组和服务的关系
sgrs = ServiceGroupRelation.objects.filter(
tenant_id=self.tenant.tenant_id,
region_name=self.response_region)
serviceGroupIdMap = {}
for sgr in sgrs:
serviceGroupIdMap[sgr.service_id] = sgr.group_id
context["serviceGroupIdMap"] = serviceGroupIdMap
serviceGroupNameMap = {}
group_list = context["groupList"]
for group in group_list:
serviceGroupNameMap[group.ID] = group.group_name
context["serviceGroupNameMap"] = serviceGroupNameMap
# cloud_assistant为goodrain表示为公有云
context['cloud_assistant'] = sn.instance.cloud_assistant
# is_private表示为私有云
context["is_private"] = sn.instance.is_private()
# 显示镜像构建的应用的镜像名
if self.service.service_key == "0000" and self.service.language == "docker-image":
isrs = ImageServiceRelation.objects.filter(
tenant_id=self.tenant.tenant_id,
service_id=self.service.service_id)
if isrs:
isr = isrs[0]
context['image_url'] = isr.image_url
elif fr == "cost":
# service_attach_info = None
# try:
# service_attach_info = ServiceAttachInfo.objects.get(tenant_id=self.tenant.tenant_id,
# service_id=self.service.service_id)
# except ServiceAttachInfo.DoesNotExist:
# pass
# if service_attach_info is None:
# service_attach_info = self.generate_service_attach_info()
context["service_attach_info"] = service_attach_info
context[
"total_buy_memory"] = service_attach_info.min_memory * service_attach_info.min_node
context["service"] = self.service
service_consume_list = ServiceConsume.objects.filter(
tenant_id=self.tenant.tenant_id,
service_id=self.service.service_id).order_by("-ID")
last_hour_consume = None
if len(list(service_consume_list)) > 0:
last_hour_consume = list(service_consume_list)[0]
context["last_hour_consume"] = last_hour_consume
service_total_memory_fee = Decimal(0)
service_total_disk_fee = Decimal(0)
service_total_net_fee = Decimal(0)
consume_list = list(service_consume_list)
for service_consume in consume_list:
service_consume.memory_pay_method = "postpaid"
service_consume.disk_pay_method = "postpaid"
if service_attach_info.buy_start_time <= service_consume.time and service_consume.time <= service_attach_info.buy_end_time:
if service_attach_info.memory_pay_method == "prepaid":
service_consume.memory_pay_method = "prepaid"
if service_attach_info.disk_pay_method == "prepaid":
service_consume.disk_pay_method = "prepaid"
service_total_memory_fee += service_consume.memory_money
service_total_disk_fee += service_consume.disk_money
service_total_net_fee += service_consume.net_money
context["service_consume_list"] = consume_list[:24]
context["service_total_memory_fee"] = service_total_memory_fee
context["service_total_disk_fee"] = service_total_disk_fee
context["service_total_net_fee"] = service_total_net_fee
elif fr == "mnt":
pass
elif fr == "expansion":
pass
elif fr == "ports":
pass
elif fr == "plugin":
pass
else:
return self.redirect_to('/apps/{0}/{1}/detail/'.format(
self.tenant.tenant_name, self.service.service_alias))
except Exception as e:
logger.exception(e)
return TemplateResponse(self.request, "www/service_detail.html",
context)
