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)