def bind_tcpdomain(self, tenant, user, service, end_point, container_port,
default_port, rule_extensions, default_ip):
tcp_rule_id = make_uuid(tenant.tenant_name)
ip = str(end_point.split(":")[0])
ip = ip.replace(' ', '')
port = end_point.split(":")[1]
data = dict()
data["service_id"] = service.service_id
data["container_port"] = int(container_port)
data["ip"] = ip
data["port"] = int(port)
data["tcp_rule_id"] = tcp_rule_id
if rule_extensions:
data["rule_extensions"] = rule_extensions
try:
# 给数据中心传送数据添加策略
region_api.bindTcpDomain(service.service_region,
tenant.tenant_name, data)
except region_api.CallApiError as e:
if e.status != 404:
raise e
region = region_repo.get_region_by_region_name(service.service_region)
domain_info = dict()
domain_info["tcp_rule_id"] = tcp_rule_id
domain_info["service_id"] = service.service_id
domain_info["service_name"] = service.service_alias
domain_info["service_alias"] = service.service_cname
domain_info["create_time"] = self.get_time_now()
domain_info["container_port"] = int(container_port)
domain_info["tenant_id"] = tenant.tenant_id
# 查询端口协议
tenant_service_port = port_repo.get_service_port_by_port(
service.tenant_id, service.service_id, container_port)
if tenant_service_port:
protocol = tenant_service_port.protocol
else:
protocol = ''
if protocol:
domain_info["protocol"] = protocol
else:
domain_info["protocol"] = 'tcp'
domain_info["end_point"] = end_point
domain_info["region_id"] = region.region_id
rule_extensions_str = ""
if rule_extensions:
# 拼接字符串，存入数据库
for rule in rule_extensions:
last_index = len(rule_extensions) - 1
if last_index == rule_extensions.index(rule):
rule_extensions_str += rule["key"] + ":" + rule["value"]
continue
rule_extensions_str += rule["key"] + ":" + rule["value"] + ","
domain_info["rule_extensions"] = rule_extensions_str
if int(end_point.split(":")[1]) != default_port:
domain_info["type"] = 1
tcp_domain.add_service_tcpdomain(**domain_info)
domain_info.update({"rule_extensions": rule_extensions})
return domain_info
def get_region_list_by_team_name(self, team_name):
regions = region_repo.get_active_region_by_tenant_name(
tenant_name=team_name)
if regions:
region_name_list = []
for region in regions:
regionconfig = region_repo.get_region_by_region_name(
region.region_name)
if regionconfig and regionconfig.status in ("1", "3"):
region_info = {
"service_status": region.service_status,
"is_active": region.is_active,
"region_status": regionconfig.status,
"team_region_alias": regionconfig.region_alias,
"region_tenant_id": region.region_tenant_id,
"team_region_name": region.region_name,
"region_scope": regionconfig.scope,
"region_create_time": regionconfig.create_time,
"websocket_uri": regionconfig.wsurl,
"tcpdomain": regionconfig.tcpdomain
}
region_name_list.append(region_info)
return region_name_list
else:
return []
def get_app_share_region(self, app):
app_template = json.loads(app.app_template)
apps = app_template["apps"]
first_app = apps[0]
if first_app:
region = first_app.get("service_region", None)
else:
group = group_repo.get_group_by_id(app.tenant_service_group_id)
if group:
region = group.region_name
else:
region = None
if region:
region_config = region_repo.get_region_by_region_name(region)
if region_config:
return region
region = None
else:
region = None
if not region and app.source == "market":
regions = region_repo.get_usable_regions()
if not regions:
return None
else:
return regions[0].region_name
else:
return None
def manage_port(self, tenant, service, region_name, container_port, action, protocol, port_alias):
if port_alias:
port_alias = str(port_alias).strip()
region = region_repo.get_region_by_region_name(region_name)
code, msg = self.__check_params(action, protocol, port_alias, service.service_id)
if code != 200:
return code, msg, None
deal_port = port_repo.get_service_port_by_port(tenant.tenant_id, service.service_id, container_port)
if action == "open_outer":
code, msg = self.__open_outer(tenant, service, region, deal_port)
elif action == "only_open_outer":
code, msg = self.__only_open_outer(tenant, service, region, deal_port)
elif action == "close_outer":
code, msg = self.__close_outer(tenant, service, deal_port)
elif action == "open_inner":
code, msg = self.__open_inner(tenant, service, deal_port)
elif action == "close_inner":
code, msg = self.__close_inner(tenant, service, deal_port)
elif action == "change_protocol":
code, msg = self.__change_protocol(tenant, service, deal_port, protocol)
elif action == "change_port_alias":
code, msg = self.__change_port_alias(tenant, service, deal_port, port_alias)
new_port = port_repo.get_service_port_by_port(tenant.tenant_id, service.service_id, container_port)
if code != 200:
return code, msg, None
return 200, u"操作成功", new_port
def create_tenant_on_region(self, team_name, region_name):
tenant = team_repo.get_team_by_team_name(team_name)
if not tenant:
return 404, u"需要开通的团队{0}不存在".format(team_name), None
region_config = region_repo.get_region_by_region_name(region_name)
if not region_config:
return 404, u"需要开通的数据中心{0}不存在".format(region_name), None
tenant_region = region_repo.get_team_region_by_tenant_and_region(tenant.tenant_id, region_name)
if not tenant_region:
tenant_region_info = {"tenant_id": tenant.tenant_id, "region_name": region_name, "is_active": False}
tenant_region = region_repo.create_tenant_region(**tenant_region_info)
if not tenant_region.is_init:
res, body = region_api.create_tenant(region_name, tenant.tenant_name,
tenant.tenant_id, tenant.enterprise_id)
if res["status"] != 200:
return res["status"], u"数据中心创建租户失败", None
tenant_region.is_active = True
tenant_region.is_init = True
# TODO 将从数据中心获取的租户信息记录到tenant_region, 当前只是用tenant的数据填充
tenant_region.region_tenant_id = tenant.tenant_id
tenant_region.region_tenant_name = tenant.tenant_name
tenant_region.region_scope = region_config.scope
tenant_region.enterprise_id = tenant.enterprise_id
tenant_region.save()
else:
if (not tenant_region.region_tenant_id) or \
(not tenant_region.region_tenant_name) or \
(not tenant_region.enterprise_id):
tenant_region.region_tenant_id = tenant.tenant_id
tenant_region.region_tenant_name = tenant.tenant_name
tenant_region.region_scope = region_config.scope
tenant_region.enterprise_id = tenant.enterprise_id
tenant_region.save()
group_repo.get_or_create_default_group(tenant.tenant_id, region_name)
return 200, u"success", tenant_region
def get(self, request, *args, **kwargs):
try:
res, data = region_api.get_port(self.response_region,
self.tenant.tenant_name)
if int(res.status) != 200:
result = general_message(400, "call region error", "请求数据中心异常")
return Response(result, status=400)
region = region_repo.get_region_by_region_name(
self.response_region)
ip = region.tcpdomain
ip_port_list = list()
ip_dict = dict()
ip_dict["ip"] = ip
ip_dict["port"] = data["bean"]
ip_port_list.append(ip_dict)
result = general_message(200,
"success",
"可用端口查询成功",
list=ip_port_list)
return Response(result, status=200)
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=500)
def _request(self, url, method, headers=None, body=None, *args, **kwargs):
region_name = kwargs.get("region")
retries = kwargs.get("retries", 2)
d_connect, d_red = self.get_default_timeout_conifg()
timeout = kwargs.get("timeout", d_red)
if kwargs.get("for_test"):
region = region_name
region_name = region.region_name
else:
region = region_repo.get_region_by_region_name(region_name)
if not region:
raise ServiceHandleException(
"region {0} not found".format(region_name), error_code=10412)
client = self.get_client(region_config=region)
if not client:
raise ServiceHandleException(
msg="create region api client failure",
msg_show="创建集群通信客户端错误，请检查集群配置",
error_code=10411)
try:
if body is None:
response = client.request(url=url,
method=method,
headers=headers,
timeout=urllib3.Timeout(
connect=d_connect, read=timeout),
retries=retries)
else:
response = client.request(url=url,
method=method,
headers=headers,
body=body,
timeout=urllib3.Timeout(
connect=d_connect, read=timeout),
retries=retries)
return response.status, response.data
except urllib3.exceptions.SSLError:
self.destroy_client(region_config=region)
raise ServiceHandleException(error_code=10411,
msg="SSLError",
msg_show="访问数据中心异常，请稍后重试")
except socket.timeout as e:
raise self.CallApiError(self.apitype, url, method,
Dict({"status": 101}), {
"type": "request time out",
"error": str(e),
"error_code": 10411,
})
except MaxRetryError as e:
logger.debug("error url {}".format(url))
logger.exception(e)
raise ServiceHandleException(error_code=10411,
msg="MaxRetryError",
msg_show="访问数据中心异常，请稍后重试")
except Exception as e:
logger.debug("error url {}".format(url))
logger.exception(e)
raise ServiceHandleException(error_code=10411,
msg="Exception",
msg_show="访问数据中心异常，请稍后重试")
def add_region(self, region_data):
region = region_repo.get_region_by_region_name(
region_data["region_name"])
if region:
raise RegionExistException("数据中心{0}已存在".format(
region_data["region_name"]))
region = region_repo.create_region(region_data)
return region
def _wrapper_director_download_url(self, region_name, raw_url):
region = region_repo.get_region_by_region_name(region_name)
if region:
splits_texts = region.wsurl.split("://")
if splits_texts[0] == "wss":
return "https://" + splits_texts[1] + raw_url
else:
return "http://" + splits_texts[1] + raw_url
def bind_domain(self, tenant, user, service, domain_name, container_port,
protocol, certificate_id, domain_type, rule_extensions):
code, msg = self.__check_domain_name(tenant.tenant_name, domain_name,
domain_type, certificate_id)
if code != 200:
return code, msg
certificate_info = None
http_rule_id = make_uuid(domain_name)
if certificate_id:
certificate_info = domain_repo.get_certificate_by_pk(
int(certificate_id))
data = dict()
data["domain"] = domain_name
data["service_id"] = service.service_id
data["tenant_id"] = tenant.tenant_id
data["container_port"] = int(container_port)
data["protocol"] = protocol
data["http_rule_id"] = http_rule_id
# 证书信息
data["certificate"] = ""
data["private_key"] = ""
data["certificate_name"] = ""
if rule_extensions:
data["rule_extensions"] = rule_extensions
if certificate_info:
data["certificate"] = base64.b64decode(
certificate_info.certificate)
data["private_key"] = certificate_info.private_key
data["certificate_name"] = certificate_info.alias
data["certificate_id"] = certificate_info.certificate_id
region_api.bind_http_domain(service.service_region, tenant.tenant_name,
data)
domain_info = dict()
region = region_repo.get_region_by_region_name(service.service_region)
domain_info["service_id"] = service.service_id
domain_info["service_name"] = service.service_alias
domain_info["domain_name"] = domain_name
domain_info["domain_type"] = domain_type
domain_info["service_alias"] = service.service_cname
domain_info["create_time"] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
domain_info["container_port"] = int(container_port)
domain_info["protocol"] = "http"
if certificate_id:
domain_info["protocol"] = "https"
if rule_extensions:
domain_info["rule_extensions"] = rule_extensions
domain_info[
"certificate_id"] = certificate_info.ID if certificate_info else 0
domain_info["http_rule_id"] = http_rule_id
domain_info["type"] = 1
domain_info["service_alias"] = service.service_cname
domain_info["tenant_id"] = tenant.tenant_id
domain_info["region_id"] = region.region_id
domain_repo.add_service_domain(**domain_info)
return 200, u"success"
def __get_stream_outer_url(self, tenant, service, port):
region = region_repo.get_region_by_region_name(service.service_region)
if region:
service_tcp_domain = tcp_domain.get_service_tcpdomain(tenant.tenant_id, region.region_id, service.service_id, port.container_port)
if service_tcp_domain:
return service_tcp_domain.end_point
else:
return None
def _wrapper_director_download_url(self, region_name, raw_url):
region = region_repo.get_region_by_region_name(region_name)
if region:
splits_texts = region.url.split(":")
if len(splits_texts) > 2:
index = region.url.index(":", 6)
return region.url[:index] + ":6060" + raw_url
else:
return region.url + ":6060" + raw_url
def _wrapper_director_download_url(self, region_name, raw_url):
region = region_repo.get_region_by_region_name(region_name)
if region:
splits_texts = region.url.split(":")
if len(splits_texts) > 2:
temp_url = splits_texts[0] + "://" + region.tcpdomain
# index = region.url.index(":", 6)
return temp_url + ":6060" + raw_url
else:
return "http://" + region.tcpdomain + ":6060" + raw_url
def update_tcpdomain(self, tenant, user, service, end_point,
container_port, tcp_rule_id, protocol, type,
rule_extensions, default_ip):
ip = end_point.split(":")[0]
ip.replace(' ', '')
port = end_point.split(":")[1]
data = dict()
data["service_id"] = service.service_id
data["container_port"] = int(container_port)
if default_ip != ip:
data["ip"] = ip
data["port"] = int(port)
data["tcp_rule_id"] = tcp_rule_id
if rule_extensions:
data["rule_extensions"] = rule_extensions
try:
# 给数据中心传送数据修改策略
region_api.updateTcpDomain(service.service_region,
tenant.tenant_name, data)
except region_api.CallApiError as e:
if e.status != 404:
raise e
region = region_repo.get_region_by_region_name(service.service_region)
# 先删除再添加
service_tcp_domain = tcp_domain.get_service_tcpdomain_by_tcp_rule_id(
tcp_rule_id)
service_tcp_domain.delete()
domain_info = dict()
domain_info["tcp_rule_id"] = tcp_rule_id
domain_info["service_id"] = service.service_id
domain_info["service_name"] = service.service_alias
domain_info["service_alias"] = service.service_cname
domain_info["create_time"] = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
domain_info["container_port"] = int(container_port)
domain_info["tenant_id"] = tenant.tenant_id
domain_info["protocol"] = protocol
domain_info["end_point"] = end_point
domain_info["type"] = type
rule_extensions_str = ""
if rule_extensions:
# 拼接字符串，存入数据库
for rule in rule_extensions:
last_index = len(rule_extensions) - 1
if last_index == rule_extensions.index(rule):
rule_extensions_str += rule["key"] + ":" + rule["value"]
continue
rule_extensions_str += rule["key"] + ":" + rule["value"] + ","
domain_info["region_id"] = region.region_id
tcp_domain.add_service_tcpdomain(**domain_info)
return 200, u"success"
def create_tenant_on_region(self, team_name, region_name):
tenant = team_repo.get_team_by_team_name(team_name)
if not tenant:
return 404, u"需要开通的团队{0}不存在".format(team_name), None
region_config = region_repo.get_region_by_region_name(region_name)
if not region_config:
return 404, u"需要开通的数据中心{0}不存在".format(region_name), None
if region_config.scope == "public":
logger.debug("open public region {0} ".format(region_name))
is_pass = self.get_enterprise_region_token_from_market(
tenant.tenant_id, tenant.enterprise_id, region_name,
region_config.url)
if not is_pass:
return 500, u"数据中心访问token获取异常", None
tenant_region = region_repo.get_team_region_by_tenant_and_region(
tenant.tenant_id, region_name)
if not tenant_region:
tenant_region_info = {
"tenant_id": tenant.tenant_id,
"region_name": region_name,
"is_active": False
}
tenant_region = region_repo.create_tenant_region(
**tenant_region_info)
if not tenant_region.is_init:
res, body = region_api.create_tenant(region_name,
tenant.tenant_name,
tenant.tenant_id,
tenant.enterprise_id)
logger.debug("create region tenant : res, {0}, body {1}".format(
res, body))
tenant_region.is_active = True
tenant_region.is_init = True
# TODO 将从数据中心获取的租户信息记录到tenant_region, 当前只是用tenant的数据填充
tenant_region.region_tenant_id = tenant.tenant_id
tenant_region.region_tenant_name = tenant.tenant_name
tenant_region.region_scope = region_config.scope
tenant_region.enterprise_id = tenant.enterprise_id
tenant_region.save()
else:
if (not tenant_region.region_tenant_id) or \
(not tenant_region.region_tenant_name) or \
(not tenant_region.enterprise_id):
tenant_region.region_tenant_id = tenant.tenant_id
tenant_region.region_tenant_name = tenant.tenant_name
tenant_region.region_scope = region_config.scope
tenant_region.enterprise_id = tenant.enterprise_id
tenant_region.save()
group_repo.get_or_create_default_group(tenant.tenant_id, region_name)
return 200, u"success", tenant_region
def _request(self, url, method, headers=None, body=None, client=None, *args, **kwargs):
region_name = kwargs["region"]
region = region_repo.get_region_by_region_name(region_name)
if not region:
raise Exception("region {0} not found".format(region_name))
verify_ssl = False
# 判断是否为https请求
wsurl_split_list = region.url.split(':')
if wsurl_split_list[0] == "https":
verify_ssl = True
config = Configuration(verify_ssl, region.ssl_ca_cert, region.cert_file, region.key_file, region_name=region_name)
client = self.get_client(config)
retry_count = 2
while retry_count:
try:
if body is None:
response = client.request(
url=url, method=method, headers=headers)
else:
response = client.request(
url=url, method=method, headers=headers, body=body)
# if len(content) > 10000:
# record_content = '%s .....ignore.....' % content[:1000]
# else:
# record_content = content
# if body is not None and len(body) > 1000:
# record_body = '%s .....ignore.....' % body[:1000]
# else:
# record_body = body
return response.status, response.data
except socket.timeout, e:
logger.error('client_error', "timeout: %s" % url)
logger.exception('client_error', e)
raise self.CallApiError(
self.apitype, url, method,
Dict({
"status": 101
}), {"type": "request time out",
"error": str(e)})
except socket.error, e:
retry_count -= 1
if retry_count:
logger.error("client_error", "retry request: %s" % url)
else:
logger.exception('client_error', e)
raise self.ApiSocketError(
self.apitype, url, method,
Dict({
"status": 101
}), {"type": "connect error",
"error": str(e)})
def post(self, request):
"""
初始化团队和数据中心信息
---
parameters:
- name: team_alias
description: 团队别名
required: true
type: string
paramType: form
- name: region_name
description: 数据中心名称
required: true
type: string
paramType: form
"""
try:
team_alias = request.data.get("team_alias", None)
region_name = request.data.get("region_name", None)
if not team_alias:
return Response(general_message(400, "team alias is null", "团队名称不能为空"), status=400)
if not region_name:
return Response(general_message(400, "region name is null", "请选择数据中心"), status=400)
r = re.compile('^[a-zA-Z0-9_\\-\\u4e00-\\u9fa5]+$')
if not r.match(team_alias):
return Response(general_message(400, "team alias is not allow", "组名称只支持中英文下划线和中划线"), status=400)
team = team_services.get_team_by_team_alias(team_alias)
if team:
return Response(general_message(409, "region alias is exist", "团队名称{0}已存在".format(team_alias)), status=409)
region = region_repo.get_region_by_region_name(region_name)
if not region:
return Response(general_message(404, "region not exist", "需要开通的数据中心{0}不存在".format(region_name)), status=404)
enterprise = console_enterprise_service.get_enterprise_by_enterprise_id(self.user.enterprise_id)
if not enterprise:
return Response(general_message(404, "user's enterprise is not found", "无法找到用户所在的数据中心"))
team = team_services.create_team(self.user, enterprise, [region_name], team_alias)
# 为团队开通默认数据中心并在数据中心创建租户
tenant_region = region_services.create_tenant_on_region(enterprise.enterprise_id, team.tenant_name, team.region)
# 公有云，如果没有领过资源包，为开通的数据中心领取免费资源包
if settings.MODULES.get('SSO_LOGIN'):
result = region_services.get_enterprise_free_resource(tenant_region.tenant_id, enterprise.enterprise_id,
tenant_region.region_name, self.user.nick_name)
logger.debug("get free resource on [{}] to team {}: {}".format(tenant_region.region_name, team.tenant_name,
result))
self.user.is_active = True
self.user.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 get_region_access_info(self, team_name, region_name):
"""获取一个团队在指定数据中心的身份认证信息"""
url, token = client_auth_service.get_region_access_token_by_tenant(team_name, region_name)
# 如果团队所在企业所属数据中心信息不存在则使用通用的配置(兼容未申请数据中心token的企业)
region_info = region_repo.get_region_by_region_name(region_name)
url = region_info.url
if not token:
token = region_info.token
else:
token = "Token {}".format(token)
return url, token
def get_upload_url(self, region, event_id):
region = region_repo.get_region_by_region_name(region)
raw_url = "/app/upload"
upload_url = ""
if region:
splits_texts = region.wsurl.split("://")
if splits_texts[0] == "wss":
upload_url = "https://" + splits_texts[1] + raw_url
else:
upload_url = "http://" + splits_texts[1] + raw_url
return upload_url + "/" + event_id
def manage_port(self,
tenant,
service,
region_name,
container_port,
action,
protocol,
port_alias,
k8s_service_name="",
user_name=''):
if port_alias:
port_alias = str(port_alias).strip()
region = region_repo.get_region_by_region_name(region_name)
code, msg = self.__check_params(action, container_port, protocol,
port_alias, service.service_id)
if code != 200:
return code, msg, None
# Compatible with methods that do not return code, such as __change_port_alias
code = 200
deal_port = port_repo.get_service_port_by_port(tenant.tenant_id,
service.service_id,
container_port)
if action == "open_outer":
code, msg = self.__open_outer(tenant, service, region, deal_port,
user_name)
elif action == "only_open_outer":
code, msg = self.__only_open_outer(tenant, service, region,
deal_port, user_name)
elif action == "close_outer":
code, msg = self.__close_outer(tenant, service, deal_port,
user_name)
elif action == "open_inner":
code, msg = self.__open_inner(tenant, service, deal_port,
user_name)
elif action == "close_inner":
code, msg = self.__close_inner(tenant, service, deal_port,
user_name)
elif action == "change_protocol":
code, msg = self.__change_protocol(tenant, service, deal_port,
protocol, user_name)
elif action == "change_port_alias":
self.change_port_alias(tenant, service, deal_port, port_alias,
k8s_service_name, user_name)
new_port = port_repo.get_service_port_by_port(tenant.tenant_id,
service.service_id,
container_port)
if code != 200:
return code, msg, None
return 200, "操作成功", new_port
def put(self, request, *args, **kwargs):
"""
编辑http策略
"""
try:
container_port = request.data.get("container_port", None)
domain_name = request.data.get("domain_name", None)
certificate_id = request.data.get("certificate_id", None)
service_id = request.data.get("service_id", None)
domain_path = request.data.get("domain_path", None)
domain_cookie = request.data.get("domain_cookie", None)
domain_heander = request.data.get("domain_heander", None)
rule_extensions = request.data.get("rule_extensions", None)
http_rule_id = request.data.get("http_rule_id", None)
the_weight = request.data.get("the_weight", 100)
# 判断参数
if not service_id or not container_port or not domain_name or not http_rule_id:
return Response(general_message(400, "parameters are missing", "参数缺失"), status=400)
service = service_repo.get_service_by_service_id(service_id)
if not service:
return Response(general_message(400, "not service", "服务不存在"), status=400)
# 判断域名格式(如果用户添加的域名与默认域名后缀一致，那么他后缀必须是 "租户别名.默认后缀"
#
# 比如默认域名后缀是:37e53f.grapps.cn 这个值来自于region_info http_domain
# 那么如果它绑定 xxx.37e53f.grapps.cn是不允许的，只能绑定：
# xxx.yaufe6r5.37e53f.grapps.cn
#
# 此限制是防止租户之间盗用域名。)
region = region_repo.get_region_by_region_name(service.service_region)
if domain_name.endswith(region.httpdomain):
domain_name_spt = domain_name.split(region.httpdomain)
if self.tenant.tenant_name != domain_name_spt[0].split('.')[len(domain_name_spt[0].split('.'))-2]:
return Response(general_message(400, "the domain name format is incorrect", "域名格式不正确"), status=400)
# 编辑域名
code, msg, data = domain_service.update_httpdomain(self.tenant, self.user, service, domain_name, container_port,
certificate_id, DomainType.WWW, domain_path,
domain_cookie, domain_heander, http_rule_id, the_weight, rule_extensions)
if code != 200:
return Response(general_message(code, "bind domain error", msg), status=code)
result = general_message(200, "success", "策略编辑成功")
except Exception as e:
logger.exception(e)
result = error_message(e.message)
return Response(result, status=result["code"])
def __event_ws(self, request, region, sufix_uri):
region = region_repo.get_region_by_region_name(region_name=region)
if not region:
default_uri = settings.EVENT_WEBSOCKET_URL[region]
if default_uri == "auto":
host = request.META.get('HTTP_HOST').split(':')[0]
return "ws://{0}:6060/{1}".format(host, sufix_uri)
else:
return "{0}/{1}".format(default_uri, sufix_uri)
else:
if region.wsurl == "auto":
host = request.META.get('HTTP_HOST').split(':')[0]
return "ws://{0}:6060/{1}".format(host, sufix_uri)
else:
return "{0}/{1}".format(region.wsurl, sufix_uri)
def get_log_domain(self, request, region):
region = region_repo.get_region_by_region_name(region_name=region)
if not region:
default_uri = settings.LOG_DOMAIN[region]
if default_uri == "auto":
host = request.META.get('HTTP_HOST').split(':')[0]
return '{0}:6060'.format(host)
return default_uri
else:
if region.wsurl == "auto":
host = request.META.get('HTTP_HOST').split(':')[0]
return '{0}:6060'.format(host)
else:
if "://" in region.wsurl:
return region.wsurl.split("://", 1)[1]
return region.wsurl
def add_region(self, region_data):
region = region_repo.get_region_by_region_name(
region_data["region_name"])
if region:
raise ServiceHandleException(status_code=400,
msg="",
msg_show="集群ID{0}已存在".format(
region_data["region_name"]))
try:
region_api.test_region_api(region_data)
except ServiceHandleException:
raise ServiceHandleException(status_code=400,
msg="test link region field",
msg_show="连接集群测试失败，请确认网络和集群状态")
region = region_repo.create_region(region_data)
return region
def initial(self, request, *args, **kwargs):
super(RegionTenantHeaderView, self).initial(request, *args, **kwargs)
self.response_region = kwargs.get("region_name", None)
if not self.response_region:
self.response_region = request.GET.get("region_name", None)
if not self.response_region:
self.response_region = request.GET.get("region", None)
if not self.response_region:
self.response_region = request.META.get('HTTP_X_REGION_NAME', None)
if not self.response_region:
self.response_region = self.request.COOKIES.get('region_name', None)
self.region_name = self.response_region
if not self.response_region:
raise ImportError("region_name not found !")
region = region_repo.get_region_by_region_name(self.region_name)
if not region:
raise AbortRequest("region not found", "数据中心不存在", status_code=404, error_code=404)
self.region = region
def get_file_down_req(self, export_format, tenant_name, app):
export_record = app_export_record_repo.get_export_record_by_unique_key(app.group_key, app.version,
export_format)
region = self.get_app_share_region(app)
download_url = self.__get_down_url(region, export_record.file_path)
file_name = export_record.file_path.split("/")[-1]
url, token = client_auth_service.get_region_access_token_by_tenant(
tenant_name, region)
if not token:
region_info = region_repo.get_region_by_region_name(region)
if region_info:
token = region_info.token
req = urllib2.Request(download_url)
if token:
req.add_header("Authorization", "Token {}".format(token))
return req, file_name
def get_service_labels(self, service):
service_label_ids = service_label_repo.get_service_labels(service.service_id).values_list("label_id", flat=True)
region_config = region_repo.get_region_by_region_name(service.service_region)
node_label_ids = []
# 判断标签是否被节点使用
if region_config:
node_label_ids = node_label_repo.get_node_label_by_region(region_config.region_id).exclude(
label_id__in=service_label_ids).values_list("label_id",
flat=True)
used_labels = label_repo.get_labels_by_label_ids(service_label_ids)
unused_labels = []
if node_label_ids:
unused_labels = label_repo.get_labels_by_label_ids(node_label_ids)
result = {
"used_labels": [label.to_dict() for label in used_labels],
"unused_labels": [label.to_dict() for label in unused_labels],
}
return result
def add_region(self, region_data):
ent = enterprise_services.get_enterprise_by_enterprise_id(
region_data.get("enterprise_id"))
if not ent:
raise ServiceHandleException(status_code=404,
msg="enterprise not found",
msg_show="企业不存在")
region = region_repo.get_region_by_region_name(
region_data["region_name"])
if region:
raise ServiceHandleException(status_code=400,
msg="",
msg_show="集群ID{0}已存在".format(
region_data["region_name"]))
try:
region_api.test_region_api(region_data)
except ServiceHandleException:
raise ServiceHandleException(status_code=400,
msg="test link region field",
msg_show="连接集群测试失败，请确认网络和集群状态")
region = region_repo.create_region(region_data)
return region
def __save_port(self, tenant, service, tenant_service_ports):
port_list = []
for port in tenant_service_ports:
port.pop("ID")
new_port = TenantServicesPort(**port)
new_port.service_id = service.service_id
new_port.tenant_id = tenant.tenant_id
port_list.append(new_port)
if port_list:
TenantServicesPort.objects.bulk_create(port_list)
region = region_repo.get_region_by_region_name(
service.service_region)
# 为每一个端口状态是打开的生成默认域名
for port in port_list:
if port.is_outer_service:
if port.protocol == "http":
service_domains = domain_repo.get_service_domain_by_container_port(
service.service_id, port.container_port)
# 在domain表中保存数据
if service_domains:
for service_domain in service_domains:
service_domain.is_outer_service = True
service_domain.save()
else:
# 在service_domain表中保存数据
service_id = service.service_id
service_name = service.service_alias
container_port = port.container_port
domain_name = str(container_port) + "." + str(
service_name) + "." + str(
tenant.tenant_name) + "." + str(
region.httpdomain)
create_time = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
protocol = "http"
http_rule_id = make_uuid(domain_name)
tenant_id = tenant.tenant_id
service_alias = service.service_cname
region_id = region.region_id
domain_repo.create_service_domains(
service_id, service_name, domain_name,
create_time, container_port, protocol,
http_rule_id, tenant_id, service_alias,
region_id)
# 给数据中心发请求添加默认域名
data = dict()
data["domain"] = domain_name
data["service_id"] = service.service_id
data["tenant_id"] = tenant.tenant_id
data["tenant_name"] = tenant.tenant_name
data["protocol"] = protocol
data["container_port"] = int(container_port)
data["http_rule_id"] = http_rule_id
try:
region_api.bind_http_domain(
service.service_region, tenant.tenant_name,
data)
except Exception as e:
logger.exception(e)
domain_repo.delete_http_domains(http_rule_id)
continue
else:
service_tcp_domains = tcp_domain.get_service_tcp_domains_by_service_id_and_port(
service.service_id, port.container_port)
if service_tcp_domains:
for service_tcp_domain in service_tcp_domains:
# 改变tcpdomain表中状态
service_tcp_domain.is_outer_service = True
service_tcp_domain.save()
else:
# ip+port
# 在service_tcp_domain表中保存数据
res, data = region_api.get_port(
region.region_name, tenant.tenant_name)
if int(res.status) != 200:
continue
end_point = str(region.tcpdomain) + ":" + str(
data["bean"])
service_id = service.service_id
service_name = service.service_alias
create_time = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
container_port = port.container_port
protocol = port.protocol
service_alias = service.service_cname
tcp_rule_id = make_uuid(end_point)
tenant_id = tenant.tenant_id
region_id = region.region_id
tcp_domain.create_service_tcp_domains(
service_id, service_name, end_point,
create_time, container_port, protocol,
service_alias, tcp_rule_id, tenant_id,
region_id)
# 默认ip不需要传给数据中心
# ip = end_point.split(":")[0]
port = end_point.split(":")[1]
data = dict()
data["service_id"] = service.service_id
data["container_port"] = int(container_port)
# data["ip"] = ip
data["port"] = int(port)
data["tcp_rule_id"] = tcp_rule_id
logger.debug(
'--------------------------------->{0}'.format(
data["port"]))
try:
# 给数据中心传送数据添加策略
region_api.bindTcpDomain(
service.service_region, tenant.tenant_name,
data)
except Exception as e:
logger.exception(e)
tcp_domain.delete_tcp_domain(tcp_rule_id)
continue
def get_region_by_region_name(self, region_name):
return region_repo.get_region_by_region_name(region_name=region_name)
