def add_service_default_porbe(self, tenant, service):
ports = port_service.get_service_ports(service)
port_length = len(ports)
if port_length >= 1:
container_port = ports[0].container_port
for p in ports:
if p.is_outer_service:
container_port = p.container_port
data = {
"service_id": service.service_id,
"scheme": "tcp",
"path": "",
"port": container_port,
"cmd": "",
"http_header": "",
"initial_delay_second": 2,
"period_second": 3,
"timeout_second": 30,
"failure_threshold": 3,
"success_threshold": 1,
"is_used": True,
"probe_id": make_uuid(),
"mode": "readiness"
}
return probe_service.add_service_probe(tenant, service, data)
return 200, "success", None
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
"""
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_host, inner_port = "127.0.0.1", None
for pf in port_info["environment"]:
if pf.get("name"):
if pf.get("name").endswith("PORT"):
inner_port = pf.get("value")
inner_url = "{0}:{1}".format(inner_host, inner_port)
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)
if bind_domains:
for bind_domain in bind_domains:
if not bind_domain.domain_path:
bind_domain.domain_path = '/'
bind_domain.save()
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)
return Response(result, status=result["code"])
def is_need_to_add_default_probe(self):
if self.service.service_source != "source_code":
return True
else:
ports = port_service.get_service_ports(self.service)
for p in ports:
if p.container_port == 5000:
return False
return True
def get(self, request, team_id, region_name, app_id, *args, **kwargs):
is_outer = request.GET.get("is_outer", False)
if is_outer == "true":
is_outer = True
data = []
start = request.GET.get("start")
end = request.GET.get("end")
step = request.GET.get("step", 60)
if not start or not end:
raise ServiceHandleException(msg="params error", msg_show="缺少query参数")
services_relation = group_service_relation_repo.get_services_by_group(self.app.ID)
service_ids = services_relation.values_list('service_id', flat=True)
if service_ids:
services = service_repo.get_services_by_service_ids(service_ids).exclude(service_source="third_party")
for service in services:
is_outer_service = True
has_plugin = False
service_abled_plugins = app_plugin_service.get_service_abled_plugin(service)
for plugin in service_abled_plugins:
if plugin.category == PluginCategoryConstants.PERFORMANCE_ANALYSIS:
has_plugin = True
if is_outer:
is_outer_service = False
tenant_service_ports = port_service.get_service_ports(service)
for service_port in tenant_service_ports:
if service_port.is_outer_service:
is_outer_service = True
break
if has_plugin and is_outer_service:
dt = {
"service_id": service.service_id,
"service_cname": service.service_cname,
"service_alias": service.service_alias,
"monitors": []
}
for k, v in list(monitor_query_range_items.items()):
monitor = {"monitor_item": k}
body = {}
try:
res, body = region_api.get_query_range_data(self.region_name, self.team.tenant_name,
v % (service.service_id, start, end, step))
except Exception as e:
logger.debug(e)
if body.get("data"):
if body["data"]["result"]:
result_list = []
for result in body["data"]["result"]:
result["value"] = [str(value) for value in result["value"]]
result_list.append(result)
body["data"]["result"] = result_list
monitor.update(body)
dt["monitors"].append(monitor)
data.append(dt)
serializers = ComponentMonitorSerializers(data=data, many=True)
serializers.is_valid(raise_exception=True)
return Response(serializers.data, status=200)
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"] = []
if port.protocol == "http":
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
]
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 put(self, request, *args, **kwargs):
"""
修改实例上下线
:param request:
:param args:
:param kwargs:
:return:
"""
is_online = request.data.get("is_online", True)
ep_id = request.data.get("ep_id", None)
if not ep_id:
return Response(general_message(400, "end_point is null",
"end_point未指明"),
status=400)
# 上线操作需要端口开启状态
tenant_service_ports = port_service.get_service_ports(self.service)
open_list = []
if tenant_service_ports:
for port in tenant_service_ports:
if port.is_outer_service or port.is_inner_service:
open_list.append("1")
if "1" not in open_list:
return Response(general_message(200,
"port is closed",
"端口未开启",
bean={"port_closed": True}),
status=200)
endpoint_dict = dict()
endpoint_dict["ep_id"] = ep_id
endpoint_dict["is_online"] = is_online
res, body = region_api.put_third_party_service_endpoints(
self.response_region, self.tenant.tenant_name,
self.service.service_alias, endpoint_dict)
if res.status != 200:
return Response(general_message(412, "region delete error",
"数据中心修改失败"),
status=412)
result = general_message(200, "success", "修改成功")
return Response(result)
def add_endpoint(self, tenant, service, address, is_online):
try:
_, body = region_api.get_third_party_service_pods(
service.service_region, tenant.tenant_name,
service.service_alias)
except region_api.CallApiError as e:
logger.exception(e)
raise CheckThirdpartEndpointFailed()
if not body:
raise CheckThirdpartEndpointFailed()
endpoint_list = body.get("list", [])
endpoints = [endpoint.address for endpoint in endpoint_list]
endpoints.append(address)
is_domain = self.check_endpoints(endpoints)
# close outer port
if is_domain:
from console.services.app_config import port_service
ports = port_service.get_service_ports(service)
if ports:
logger.debug("close third part port: {0}".format(
ports[0].container_port))
port_service.close_thirdpart_outer(tenant, service, ports[0])
data = {"address": address, "is_online": is_online}
try:
res, _ = region_api.post_third_party_service_endpoints(
service.service_region, tenant.tenant_name,
service.service_alias, data)
# 保存endpoints数据
service_endpoints_repo.update_or_create_endpoints(
tenant, service, endpoints)
except region_api.CallApiError as e:
logger.exception(e)
raise CheckThirdpartEndpointFailed(msg="add endpoint failed",
msg_show="数据中心添加实例地址失败")
if res and res.status != 200:
raise CheckThirdpartEndpointFailed(msg="add endpoint failed",
msg_show="数据中心添加实例地址失败")
def put(self, request, *args, **kwargs):
"""
组件拓扑图打开(关闭)对外端口
:param request:
:param args:
:param kwargs:
:return:
"""
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))
if self.service.service_source == "third_party":
msg, msg_show, code = port_service.check_domain_thirdpart(
self.tenant, self.service)
if code != 200:
logger.exception(msg, msg_show)
return Response(general_message(code, msg, msg_show),
status=code)
code, msg, data = port_service.manage_port(
self.tenant, self.service, self.response_region,
int(container_port), "open_outer",
tenant_service_port.protocol, tenant_service_port.port_alias)
if code != 200:
return Response(general_message(412, "open outer fail",
"打开对外端口失败"),
status=412)
return Response(general_message(200, "open outer success", "开启成功"),
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",
"关闭对外端口失败"),
status=412)
return Response(general_message(200, "close outer success",
"关闭对外端口成功"),
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:
if self.service.service_source == "third_party":
msg, msg_show, code = port_service.check_domain_thirdpart(
self.tenant, self.service)
if code != 200:
logger.exception(msg, msg_show)
return Response(general_message(code, msg, msg_show),
status=code)
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",
"打开对外端口失败"),
status=412)
return Response(general_message(200, "open outer success",
"开启成功"),
status=200)
else:
# 多个端口需要用户选择后开启
return Response(general_message(
201,
"the service does not open an external port",
"该组件未开启对外端口",
list=port_list),
status=201)
else:
return Response(general_message(
202, "the service has an external port open", "该组件已开启对外端口"),
status=200)
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
- name: page
description: 页码
required: false
type: string
paramType: query
- name: page_size
description: 每页数量
required: false
type: string
paramType: query
"""
try:
page_num = int(request.GET.get("page", 1))
page_size = int(request.GET.get("page_size", 25))
dependencies = dependency_service.get_service_dependencies(
self.tenant, self.service)
service_ids = [s.service_id for s in dependencies]
service_group_map = group_service.get_services_group_name(
service_ids)
dep_list = []
for dep in dependencies:
tenant_service_ports = port_service.get_service_ports(dep)
ports_list = []
if tenant_service_ports:
for port in tenant_service_ports:
ports_list.append(port.container_port)
dep_service_info = {
"service_cname": dep.service_cname,
"service_id": dep.service_id,
"service_type": dep.service_type,
"service_alias": dep.service_alias,
"group_name":
service_group_map[dep.service_id]["group_name"],
"group_id": service_group_map[dep.service_id]["group_id"],
"ports_list": ports_list
}
dep_list.append(dep_service_info)
rt_list = dep_list[(page_num - 1) * page_size:page_num * page_size]
service_ports = port_service.get_service_ports(self.service)
port_list = []
if service_ports:
for port in service_ports:
port_list.append(port.container_port)
bean = {"port_list": port_list}
result = general_message(200,
"success",
"查询成功",
list=rt_list,
total=len(dep_list),
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):
"""
应用拓扑图打开(关闭)对外端口
: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
]
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"])
