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:
http_domain = region_services.get_region_httpdomain(
self.service.service_region)
sld_suffix = "{0}.{1}".format(self.tenant.tenant_name, http_domain)
result = general_message(200, "success", "查询成功",
{"sld_suffix": sld_suffix})
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def __get_port_access_url(self, tenant, service, port):
domain = region_services.get_region_httpdomain(service.service_region)
suf_port = 80
if domain:
if ":" in domain:
domain_split = domain.split(":")
if len(domain_split) == 2:
suf_port = int(domain_split[1])
domain = str(domain_split[0])
url = "http://{0}.{1}.{2}.{3}:{4}".format(port,
service.service_alias,
tenant.tenant_name,
domain, suf_port)
urls = [url]
domains = domain_repo.get_service_domain_by_container_port(
service.service_id, port)
if domains:
for d in domains:
if d.protocol != "http":
urls.insert(0, "https://{0}".format(d.domain_name))
else:
urls.insert(0, "http://{0}".format(d.domain_name))
return urls
def get_port_variables(self, tenant, service, port_info):
data = {"environment": []}
if port_info.is_inner_service:
envs = env_var_service.get_env_by_container_port(
tenant, service, port_info.container_port)
for env in envs:
val = {
"desc": env.name,
"name": env.attr_name,
"value": env.attr_value
}
data["environment"].append(val)
if port_info.is_outer_service:
service_region = service.service_region
if port_info.protocol != 'http' and port_info.protocol != "https":
cur_region = service_region.replace("-1", "")
tcpdomain = region_services.get_region_tcpdomain(
region_name=cur_region)
# domain = "{0}.{1}.{2}.{3}".format(port_info.container_port, service.service_alias, tenant.tenant_name,
# tcpdomain)
# if port_info.protocol == "tcp":
# domain = tcpdomain
domain = tcpdomain
data["outer_service"] = {
"domain": domain,
"port": port_info.mapping_port,
}
if port_info.lb_mapping_port != 0:
data["outer_service"]["port"] = port_info.lb_mapping_port
elif port_info.protocol == 'http':
httpdomain = region_services.get_region_httpdomain(
service.service_region)
domain = httpdomain
port = 80
if httpdomain and ":" in httpdomain:
info = httpdomain.split(":", 1)
if len(info) == 2:
port = int(info[1])
domain = str(info[0])
data["outer_service"] = {
"domain":
"{0}.{1}.{2}.{3}".format(port_info.container_port,
service.service_alias,
tenant.tenant_name, domain),
"port":
port
}
return data
def get_tenant_service_access_url(self, tenant, service):
tenant_ports = TenantServicesPort.objects.filter(
tenant_id=tenant.tenant_id,
service_id=service.service_id,
is_outer_service=1,
protocol='http')
if not tenant_ports:
return ''
# 如果有多个对外端口，取第一个
tenant_port = tenant_ports[0]
wild_domain = region_services.get_region_httpdomain(
service.service_region)
access_url = "http://{0}.{1}.{2}.{3}".format(
tenant_port.container_port, service.service_alias,
tenant.tenant_name, wild_domain)
return access_url
def get_internet_topological_graph(self, group_id, team_name):
result = dict()
service_id_list = ServiceGroupRelation.objects.filter(
group_id=group_id).values_list("service_id", flat=True)
service_list = TenantServiceInfo.objects.filter(
service_id__in=service_id_list)
outer_http_service_list = []
for service in service_list:
port_list = TenantServicesPort.objects.filter(
service_id=service.service_id)
# 判断服务是否有对外端口
outer_http_service = False
if len(port_list) > 0:
outer_http_service = reduce(lambda x, y: x or y, [
t.is_outer_service and t.protocol == 'http'
for t in list(port_list)
])
if outer_http_service:
outer_http_service_list.append(service)
# 每个对外可访问的服务
result_list = []
for service_info in outer_http_service_list:
service_domain_result = {}
service_region = service_info.service_region
port_list = TenantServicesPort.objects.filter(
service_id=service_info.service_id)
service_domain_list = ServiceDomain.objects.filter(
service_id=service_info.service_id)
port_map = {}
for port in port_list:
port_info = port.to_dict()
exist_service_domain = False
# 打开对外端口
if port.is_outer_service:
if port.protocol != 'http' and port.protocol != "https":
cur_region = service_region.replace("-1", "")
domain = "{0}.{1}.{2}-s1.goodrain.net".format(
service_info.service_alias, team_name, cur_region)
tcpdomain = region_services.get_region_tcpdomain(
service_region)
if tcpdomain:
domain = tcpdomain
outer_service = {"domain": domain}
try:
outer_service['port'] = port.mapping_port
except Exception as e:
logger.exception(e)
outer_service['port'] = '-1'
elif port.protocol == 'http':
exist_service_domain = True
httpdomain = region_services.get_region_httpdomain(
service_region)
outer_service = {
"domain":
"{0}.{1}{2}".format(service_info.service_alias,
team_name, httpdomain),
"port":
10080
}
else:
outer_service = {"domain": 'error', "port": '-1'}
# 外部url
if outer_service['port'] == '-1':
port_info['outer_url'] = 'query error!'
else:
if service_info.port_type == "multi_outer":
if port.protocol == "http":
port_info['outer_url'] = '{0}.{1}:{2}'.format(
port.container_port,
outer_service['domain'],
outer_service['port'])
else:
port_info['outer_url'] = '{0}:{1}'.format(
outer_service['domain'],
outer_service['port'])
else:
port_info['outer_url'] = '{0}:{1}'.format(
outer_service['domain'], outer_service['port'])
# 自定义域名
if exist_service_domain:
if len(service_domain_list) > 0:
for domain in service_domain_list:
if port.container_port == domain.container_port:
if port_info.get('domain_list') is None:
if domain.protocol == "https":
port_info['domain_list'] = [
"https://" + domain.domain_name
]
else:
port_info['domain_list'] = [
"http://" + domain.domain_name
]
else:
if domain.protocol == "https":
port_info['domain_list'].append(
"https://" + domain.domain_name)
else:
port_info['domain_list'].append(
"http://" + domain.domain_name)
port_map[port.container_port] = port_info
service_domain_result["service_alias"] = service_info.service_alias
service_domain_result["service_cname"] = service_info.service_cname
service_domain_result["port_map"] = port_map
result_list.append(service_domain_result)
result["result_list"] = result_list
return result
def get_group_topological_graph_details(self, team, team_id, team_name,
service, region_name):
result = {}
# 服务信息
tenant_id = team_id
tenant_name = team_name
service_id = service.service_id
service_alias = service.service_alias
service_cname = service.service_cname
service_region = service.service_region
deploy_version = service.deploy_version
total_memory = service.min_memory * service.min_node
# 服务名称
result['tenant_id'] = tenant_id
result['service_alias'] = service_alias
result['service_cname'] = service_cname
result['service_region'] = service_region
result['deploy_version'] = deploy_version
result['total_memory'] = total_memory
result['cur_status'] = 'Unknown'
# 服务端口信息
port_list = TenantServicesPort.objects.filter(service_id=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)])
# result['is_internet'] = outer_port_exist
# result["ports"] = map(lambda x: x.to_dict(), port_list)
# 域名信息
service_domain_list = ServiceDomain.objects.filter(
service_id=service_id)
port_map = {}
# 判断是否存在自定义域名
for port in port_list:
port_info = port.to_dict()
exist_service_domain = False
# 打开对外端口
if port.is_outer_service:
if port.protocol != 'http' and port.protocol != "https":
cur_region = service_region.replace("-1", "")
domain = "{0}.{1}.{2}-s1.goodrain.net".format(
service_alias, tenant_name, cur_region)
# if settings.STREAM_DOMAIN_URL[service_region] != "":
# domain = settings.STREAM_DOMAIN_URL[service_region]
tcpdomain = region_services.get_region_tcpdomain(
service_region)
if tcpdomain:
domain = tcpdomain
outer_service = {"domain": domain}
try:
outer_service['port'] = port.mapping_port
except Exception as e:
logger.exception(e)
outer_service['port'] = '-1'
elif port.protocol == 'http':
exist_service_domain = True
httpdomain = region_services.get_region_httpdomain(
service_region)
outer_service = {
"domain":
"{0}.{1}{2}".format(service_alias, tenant_name,
httpdomain),
"port":
10080
}
else:
outer_service = {"domain": 'error', "port": '-1'}
# 外部url
if outer_service['port'] == '-1':
port_info['outer_url'] = 'query error!'
else:
if service.port_type == "multi_outer":
if port.protocol == "http":
port_info['outer_url'] = '{0}.{1}:{2}'.format(
port.container_port, outer_service['domain'],
outer_service['port'])
else:
port_info['outer_url'] = '{0}:{1}'.format(
outer_service['domain'], outer_service['port'])
else:
port_info['outer_url'] = '{0}:{1}'.format(
outer_service['domain'], outer_service['port'])
# 自定义域名
if exist_service_domain:
if len(service_domain_list) > 0:
for domain in service_domain_list:
if port.container_port == domain.container_port:
if port_info.get('domain_list') is None:
if domain.protocol == "https":
port_info['domain_list'] = [
"https://" + domain.domain_name
]
else:
port_info['domain_list'] = [
"http://" + domain.domain_name
]
else:
if domain.protocol == "https":
port_info['domain_list'].append(
"https://" + domain.domain_name)
else:
port_info['domain_list'].append(
"http://" + domain.domain_name)
port_map[port.container_port] = port_info
result["port_list"] = port_map
# pod节点信息
try:
status_data = region_api.check_service_status(
region=region_name,
tenant_name=team_name,
service_alias=service.service_alias,
enterprise_id=team.enterprise_id)
region_data = status_data["bean"]
pod_list = region_api.get_service_pods(
region=region_name,
tenant_name=team_name,
service_alias=service.service_alias,
enterprise_id=team.enterprise_id)
region_data["pod_list"] = pod_list["list"]
except Exception as e:
logger.exception(e)
region_data = {}
# result["region_data"] = region_data
result = dict(result, **region_data)
# 依赖服务信息
relation_list = TenantServiceRelation.objects.filter(
tenant_id=tenant_id, service_id=service_id)
relation_id_list = set([x.dep_service_id for x in relation_list])
relation_service_list = TenantServiceInfo.objects.filter(
service_id__in=relation_id_list)
relation_service_map = {x.service_id: x for x in relation_service_list}
relation_port_list = TenantServicesPort.objects.filter(
service_id__in=relation_id_list)
relation_map = {}
for relation_port in relation_port_list:
tmp_service_id = relation_port.service_id
if tmp_service_id in relation_service_map.keys():
tmp_service = relation_service_map.get(tmp_service_id)
relation_info = relation_map.get(tmp_service_id)
if relation_info is None:
relation_info = []
# 处理依赖服务端口
if relation_port.is_inner_service:
relation_info.append({
"service_cname":
tmp_service.service_cname,
"service_alias":
tmp_service.service_alias,
"mapping_port":
relation_port.mapping_port,
})
relation_map[tmp_service_id] = relation_info
result["relation_list"] = relation_map
result["status"] = 200
return result
def get_group_topological_graph_details(self, team, team_id, team_name, service, region_name):
result = dict()
# 组件信息
result['tenant_id'] = team_id
result['service_alias'] = service.service_alias
result['service_cname'] = service.service_cname
result['service_region'] = service.service_region
result['deploy_version'] = service.deploy_version
result['total_memory'] = service.min_memory * service.min_node
result['cur_status'] = 'Unknown'
# 组件端口信息
port_list = TenantServicesPort.objects.filter(service_id=service.service_id)
# 域名信息
service_domain_list = ServiceDomain.objects.filter(service_id=service.service_id)
port_map = {}
# 判断是否存在自定义域名
for port in port_list:
port_info = port.to_dict()
exist_service_domain = False
# 打开对外端口
if port.is_outer_service:
if port.protocol != 'http' and port.protocol != "https":
cur_region = service.service_region.replace("-1", "")
domain = "{0}.{1}.{2}-s1.goodrain.net".format(service.service_alias, team_name, cur_region)
tcpdomain = region_services.get_region_tcpdomain(service.service_region)
if tcpdomain:
domain = tcpdomain
outer_service = {"domain": domain}
if port.lb_mapping_port != 0:
outer_service['port'] = port.lb_mapping_port
else:
outer_service['port'] = port.mapping_port
elif port.protocol == 'http' or port.protocol == 'https':
exist_service_domain = True
httpdomain = region_services.get_region_httpdomain(service.service_region)
outer_service = {"domain": "{0}.{1}.{2}".format(service.service_alias, team_name, httpdomain), "port": ""}
# 外部url
if outer_service['port'] == '-1':
port_info['outer_url'] = 'query error!'
else:
if port.protocol == "http":
# 5.0版本策略展示即可，暂时注掉
# port_info['outer_url'] = '{0}.{1}:{2}'.format(port.container_port, outer_service['domain'],
# outer_service['port'])
port_info['outer_url'] = ''
else:
# port_info['outer_url'] = '{0}:{1}'.format(outer_service['domain'], outer_service['port'])
port_info['outer_url'] = ''
# 自定义域名
if exist_service_domain:
if len(service_domain_list) > 0:
for domain in service_domain_list:
if port.container_port == domain.container_port:
domain_path = domain.domain_path if domain.domain_path else '/'
if port_info.get('domain_list') is None:
if domain.protocol == "https":
port_info['domain_list'] = ["https://" + domain.domain_name + domain_path]
else:
port_info['domain_list'] = ["http://" + domain.domain_name + domain_path]
else:
if domain.protocol == "https":
port_info['domain_list'].append("https://" + domain.domain_name + domain_path)
else:
port_info['domain_list'].append("http://" + domain.domain_name + domain_path)
port_map[port.container_port] = port_info
result["port_list"] = port_map
# pod节点信息
region_data = dict()
try:
status_data = region_api.check_service_status(
region=region_name,
tenant_name=team_name,
service_alias=service.service_alias,
enterprise_id=team.enterprise_id)
region_data = status_data["bean"]
pod_list = region_api.get_service_pods(
region=region_name,
tenant_name=team_name,
service_alias=service.service_alias,
enterprise_id=team.enterprise_id)
region_data["pod_list"] = pod_list["list"]
except region_api.CallApiError as e:
if e.message["httpcode"] == 404:
region_data = {"status_cn": "创建中", "cur_status": "creating"}
elif service.create_status != "complete":
region_data = {"status_cn": "创建中", "cur_status": "creating"}
result = dict(result, **region_data)
# 依赖组件信息
relation_list = TenantServiceRelation.objects.filter(tenant_id=team_id, service_id=service.service_id)
relation_id_list = set([x.dep_service_id for x in relation_list])
relation_service_list = TenantServiceInfo.objects.filter(service_id__in=relation_id_list)
relation_service_map = {x.service_id: x for x in relation_service_list}
relation_port_list = TenantServicesPort.objects.filter(service_id__in=relation_id_list)
relation_map = {}
for relation_port in relation_port_list:
tmp_service_id = relation_port.service_id
if tmp_service_id in relation_service_map.keys():
tmp_service = relation_service_map.get(tmp_service_id)
relation_info = relation_map.get(tmp_service_id)
if relation_info is None:
relation_info = []
# 处理依赖组件端口
if relation_port.is_inner_service:
relation_info.append({
"service_cname": tmp_service.service_cname,
"service_alias": tmp_service.service_alias,
"mapping_port": relation_port.mapping_port,
})
relation_map[tmp_service_id] = relation_info
result["relation_list"] = relation_map
result["status"] = 200
if service.service_source == "third_party":
result["cur_status"] = "third_party"
return result
