def delete(self, request, *args, **kwargs): """ 应用数据删除 --- parameters: - name: tenantName description: 团队名称 required: true type: string paramType: path - name: group_id description: 组ID required: true type: string paramType: path - name: new_group_id description: 组ID required: true type: string paramType: query """ try: group_id = int(kwargs.get("group_id", None)) if not group_id: return Response(general_message(400, "group id is null", "请确认需要删除的组"), status=400) new_group_id = request.data.get("new_group_id", None) if not new_group_id: return Response(general_message(400, "new group id is null", "请确认新恢复的组"), status=400) if group_id == new_group_id: return Response(general_message(200, "success", "恢复到当前组无需删除"), status=200) group = group_repo.get_group_by_id(group_id) if not group: return Response(general_message(400, "group is delete", "该备份组已删除"), status=400) if group.is_default: return Response(general_message(400, "default app", "默认应用不允许删除"), status=400) new_group = group_repo.get_group_by_id(new_group_id) if not new_group: return Response( general_message(400, "new group not exist", "组ID {0} 不存在".format(new_group_id)), status=400) services = group_service.get_group_services(group_id) for service in services: try: app_manage_service.truncate_service(self.tenant, service) except Exception as le: logger.exception(le) group.delete() result = general_message(200, "success", "操作成功") except Exception as e: logger.exception(e) result = error_message(e.message) return Response(result, status=result["code"])
def create_new_group(self, tenant, region, old_group_id): old_group = group_repo.get_group_by_id(old_group_id) if old_group: new_group_name = '_'.join([old_group.group_name, make_uuid()[-4:]]) else: new_group_name = make_uuid()[:8] app = group_service.create_app(tenant, region, new_group_name, "备份创建") new_app = group_repo.get_group_by_id(app["ID"]) return new_app
def __create_new_group(self, tenant_id, region, old_group_id): old_group = group_repo.get_group_by_id(old_group_id) new_group_name = '_'.join([old_group.group_name, make_uuid()[-4:]]) new_group = group_repo.add_group(tenant_id, region, new_group_name) return new_group
def get_group_app_metadata(self, group_id, tenant): all_data = dict() compose_group_info = compose_repo.get_group_compose_by_group_id( group_id) compose_service_relation = None if compose_group_info: compose_service_relation = compose_relation_repo.get_compose_service_relation_by_compose_id( compose_group_info.compose_id) group_info = group_repo.get_group_by_id(group_id) service_group_relations = group_service_relation_repo.get_services_by_group( group_id) service_ids = [sgr.service_id for sgr in service_group_relations] services = service_repo.get_services_by_service_ids(*service_ids) all_data["compose_group_info"] = compose_group_info.to_dict( ) if compose_group_info else None all_data["compose_service_relation"] = [ relation.to_dict() for relation in compose_service_relation ] if compose_service_relation else None all_data["group_info"] = group_info.to_dict() all_data["service_group_relation"] = [ sgr.to_dict() for sgr in service_group_relations ] apps = [] total_memory = 0 for service in services: if service.service_source == "third_party" or service.create_status != "complete": continue total_memory += service.min_memory * service.min_node app_info = self.get_service_details(tenant, service) apps.append(app_info) all_data["apps"] = apps return total_memory, json.dumps(all_data)
def get(self, request, *args, **kwargs): # 获取单个tcp/udp策略信息 try: tcp_rule_id = request.GET.get("tcp_rule_id", None) # 判断参数 if not tcp_rule_id: return Response(general_message(400, "parameters are missing", "参数缺失"), status=400) tcpdomain = tcp_domain.get_service_tcpdomain_by_tcp_rule_id(tcp_rule_id) if tcpdomain: bean = tcpdomain.to_dict() service = service_repo.get_service_by_service_id(tcpdomain.service_id) service_alias = service.service_cname if service else '' group_name = '' g_id = 0 if service: gsr = group_service_relation_repo.get_group_by_service_id(service.service_id) if gsr: group = group_repo.get_group_by_id(int(gsr.group_id)) group_name = group.group_name if group else '' g_id = int(gsr.group_id) bean.update({"service_alias": service_alias}) bean.update({"group_name": group_name}) bean.update({"g_id": g_id}) result = general_message(200, "success", "查询成功", bean=bean) else: bean = dict() result = general_message(200, "success", "查询成功", bean=bean) except Exception as e: logger.exception(e) result = error_message(e.message) return Response(result, status=result["code"])
def get_group_app_metadata(self, group_id, tenant): all_data = dict() compose_group_info = compose_repo.get_group_compose_by_group_id( group_id) compose_service_relation = None if compose_group_info: compose_service_relation = compose_relation_repo.get_compose_service_relation_by_compose_id( compose_group_info.compose_id) group_info = group_repo.get_group_by_id(group_id) service_group_relations = group_service_relation_repo.get_services_by_group( group_id) service_ids = [sgr.service_id for sgr in service_group_relations] services = service_repo.get_services_by_service_ids(*service_ids) all_data["compose_group_info"] = compose_group_info.to_dict( ) if compose_group_info else None all_data["compose_service_relation"] = [ relation.to_dict() for relation in compose_service_relation ] if compose_service_relation else None all_data["group_info"] = group_info.to_dict() all_data["service_group_relation"] = [ sgr.to_dict() for sgr in service_group_relations ] apps = [] for service in services: app_info = self.get_service_details(tenant, service) apps.append(app_info) all_data["apps"] = apps return json.dumps(all_data)
def sync_app_services(self, tenant, region_name, app_id): group_services = base_service.get_group_services_list( tenant.tenant_id, region_name, app_id) service_ids = [] if group_services: for service in group_services: service_ids.append(service["service_id"]) try: region_app_id = region_app_repo.get_region_app_id( region_name, app_id) body = {"service_ids": service_ids} region_api.batch_update_service_app_id(region_name, tenant.tenant_name, region_app_id, body) except RegionApp.DoesNotExist: app = group_repo.get_group_by_id(app_id) create_body = { "app_name": app.group_name, "service_ids": service_ids } bean = region_api.create_application(region_name, tenant, create_body) req = { "region_name": region_name, "region_app_id": bean["app_id"], "app_id": app_id } region_app_repo.create(**req)
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 get(self, request, enterprise_id, app_id, *args, **kwargs): page = int(request.GET.get("page", 1)) page_size = int(request.GET.get("page_size", 10)) data = [] count = 0 app = group_repo.get_group_by_id(app_id) if app: try: tenant = team_services.get_team_by_team_id(app.tenant_id) tenant_name = tenant.tenant_name except Exception: tenant_name = None services, count = enterprise_repo.get_enterprise_app_component_list(app_id, page, page_size) if services: for service in services: data.append({ "service_alias": service.service_alias, "service_id": service.service_id, "tenant_id": app.tenant_id, "tenant_name": tenant_name, "region_name": service.service_region, "service_cname": service.service_cname, "service_key": service.service_key, }) result = general_message(200, "success", "获取成功", list=data, total_count=count, page=page, page_size=page_size) return Response(result, status=status.HTTP_200_OK)
def save_data(self, migrate_tenant, migrate_region, user, changed_service_map, metadata, group_id): group = group_repo.get_group_by_id(group_id) apps = metadata["apps"] old_new_service_id_map = dict() service_relations_list = [] service_mnt_list = [] for app in apps: service_base_info = app["service_base"] new_service_id = changed_service_map[ service_base_info["service_id"]]["ServiceID"] new_service_alias = changed_service_map[ service_base_info["service_id"]]["ServiceAlias"] ts = self.__init_app(app["service_base"], new_service_id, new_service_alias, user, migrate_region, migrate_tenant) old_new_service_id_map[app["service_base"] ["service_id"]] = ts.service_id group_service.add_service_to_group(migrate_tenant, migrate_region, group.ID, ts.service_id) self.__save_env(migrate_tenant, ts, app["service_env_vars"]) self.__save_volume(ts, app["service_volumes"]) lb_mapping_port = changed_service_map[ service_base_info["service_id"]].get("LBPorts", None) self.__save_port(migrate_tenant, ts, app["service_ports"], lb_mapping_port) self.__save_compile_env(ts, app["service_compile_env"]) self.__save_service_label(migrate_tenant, ts, migrate_region, app["service_labels"]) # self.__save_service_domain(ts, app["service_domains"]) self.__save_service_event(migrate_tenant, ts, app["service_events"]) self.__save_service_perms(ts, app["service_perms"]) self.__save_service_probes(ts, app["service_probes"]) self.__save_service_source(migrate_tenant, ts, app["service_source"]) self.__save_service_auth(ts, app["service_auths"]) self.__save_service_image_relation(migrate_tenant, ts, app["image_service_relation"]) service_relations = app["service_relation"] service_mnts = app["service_mnts"] if service_relations: service_relations_list[0:0] = list(service_relations) if service_mnts: service_mnt_list[0:0] = list(service_mnts) # 更新状态 ts.create_status = "complete" ts.save() self.__save_service_relations(migrate_tenant, service_relations_list, old_new_service_id_map) self.__save_service_mnt_relation(migrate_tenant, service_mnt_list, old_new_service_id_map)
def get_group_app_metadata(self, group_id, tenant): all_data = dict() compose_group_info = compose_repo.get_group_compose_by_group_id(group_id) compose_service_relation = None if compose_group_info: compose_service_relation = compose_relation_repo.get_compose_service_relation_by_compose_id( compose_group_info.compose_id) group_info = group_repo.get_group_by_id(group_id) service_group_relations = group_service_relation_repo.get_services_by_group(group_id) service_ids = [sgr.service_id for sgr in service_group_relations] services = service_repo.get_services_by_service_ids(service_ids) all_data["compose_group_info"] = compose_group_info.to_dict() if compose_group_info else None all_data["compose_service_relation"] = [ relation.to_dict() for relation in compose_service_relation] if compose_service_relation else None all_data["group_info"] = group_info.to_dict() all_data["service_group_relation"] = [sgr.to_dict() for sgr in service_group_relations] apps = [] total_memory = 0 plugin_ids = [] for service in services: if service.service_source == "third_party" or service.create_status != "complete": continue total_memory += service.min_memory * service.min_node app_info, pids = self.get_service_details(tenant, service) plugin_ids.extend(pids) apps.append(app_info) all_data["apps"] = apps # plugin plugins = [] plugin_build_versions = [] plugin_config_groups = [] plugin_config_items = [] for plugin_id in plugin_ids: plugin = plugin_repo.get_plugin_by_plugin_id(tenant.tenant_id, plugin_id) if plugin is None: continue plugins.append(plugin.to_dict()) bv = build_version_repo.get_last_ok_one(plugin_id, tenant.tenant_id) if bv is None: continue plugin_build_versions.append(bv.to_dict()) pcgs = plugin_config_group_repo.list_by_plugin_id(plugin_id) if pcgs: plugin_config_groups.extend([p.to_dict() for p in pcgs]) pcis = plugin_config_items_repo.list_by_plugin_id(plugin_id) if pcis: plugin_config_items.extend([p.to_dict() for p in pcis]) all_data["plugin_info"] = {} all_data["plugin_info"]["plugins"] = plugins all_data["plugin_info"]["plugin_build_versions"] = plugin_build_versions all_data["plugin_info"]["plugin_config_groups"] = plugin_config_groups all_data["plugin_info"]["plugin_config_items"] = plugin_config_items return total_memory, json.dumps(all_data)
def get_tenant_by_group_id(self, group_id): service_group = group_repo.get_group_by_id(group_id) if not service_group: return None try: tenant = team_repo.get_team_by_team_id(service_group.tenant_id) return tenant except Exception: return None
def delete_group_backup_by_backup_id(self, tenant, region, backup_id, group_id): backup_record = backup_record_repo.get_record_by_backup_id(tenant.tenant_id, backup_id) if not backup_record: return 404, "不存在该备份记录" if backup_record.status == "starting": return 409, "该备份正在进行中" if backup_record.status == "success" and group_repo.get_group_by_id(group_id): return 409, "该备份不可删除" region_api.delete_backup_by_backup_id(region, tenant.tenant_name, backup_id) backup_record_repo.delete_record_by_backup_id(tenant.tenant_id, backup_id) return 200, "success"
def get(self, request, *args, **kwargs): """ 一个组的备份导出 --- parameters: - name: tenantName description: 团队名称 required: true type: string paramType: path - name: group_id description: 组ID required: true type: string paramType: path - name: backup_id description: 备份id required: true type: string paramType: query """ try: group_id = int(kwargs.get("group_id", None)) if not group_id: return Response(general_message(400, "group id is null", "请选择需要导出备份的组"), status=400) team_name = kwargs.get("tenantName", None) if not team_name: return Response(general_message(400, "group id is null", "请选择需要导出备份的组"), status=400) team = team_services.get_tenant_by_tenant_name(team_name) if not team: return Response(general_message(404, "team not found", "团队{0}不存在".format(team_name)), status=404) group = group_repo.get_group_by_id(group_id) if not group: return Response(general_message(404, "group not found", "组{0}不存在".format(group_id)), status=404) backup_id = request.GET.get("backup_id", None) if not backup_id: return Response(general_message(400, "backup id is null", "请指明当前组的具体备份项"), status=400) code, msg, data_str = groupapp_backup_service.export_group_backup(team, backup_id) if code != 200: return Response(general_message(code, "export backup failed", msg), status=code) file_name = group.group_name + ".bak" output = StringIO.StringIO() output.write(data_str) res = StreamingHttpResponse(output.getvalue()) res['Content-Type'] = 'application/octet-stream' res['Content-Disposition'] = 'attachment;filename="{0}"'.format(file_name) return res except Exception as e: logger.exception(e) result = error_message(e.message) return Response(result, status=result["code"])
def import_group_backup(self, tenant, region, group_id, upload_file): group = group_repo.get_group_by_id(group_id) if not group: return 404, "需要导入的组不存在", None services = group_service.get_group_services(group_id) if services: return 409, "请确保需要导入的组中不存在组件", None content = upload_file.read().strip() data = json.loads(AuthCode.decode(content, KEY)) current_backup = backup_record_repo.get_record_by_group_id_and_backup_id( group_id, data["backup_id"]) if current_backup: return 412, "当前团队已导入过该备份", None event_id = make_uuid() group_uuid = make_uuid() params = { "event_id": event_id, "group_id": group_uuid, "status": data["status"], "version": data["version"], "source_dir": data["source_dir"], "source_type": data["source_type"], "backup_mode": data["mode"], "backup_size": data["backup_size"] } body = region_api.copy_backup_data(region, tenant.tenant_name, params) bean = body["bean"] record_data = { "group_id": group.ID, "event_id": event_id, "group_uuid": group_uuid, "version": data["version"], "team_id": tenant.tenant_id, "region": region, "status": bean["status"], "note": data["note"], "mode": data["mode"], "backup_id": bean["backup_id"], "source_dir": data["source_dir"], "source_type": data["source_type"], "backup_size": data["backup_size"], "user": data["user"], "total_memory": data["total_memory"], "backup_server_info": data["backup_server_info"] } new_backup_record = backup_record_repo.create_backup_records( **record_data) return 200, "success", new_backup_record
def get(self, request, *args, **kwargs): """ 查询当前团队 数据中心下所有备份信息 --- parameters: - name: tenantName 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 = int(request.GET.get("page", 1)) page_size = int(request.GET.get("page_size", 10)) backups = groupapp_backup_service.get_all_group_back_up_info( self.tenant, self.response_region) paginator = JuncheePaginator(backups, int(page_size)) backup_records = paginator.page(int(page)) backup_list = list() if backup_records: for backup in backup_records: backup_dict = backup.to_dict() group_obj = group_repo.get_group_by_id( backup_dict["group_id"]) if group_obj: backup_dict["group_name"] = group_obj.group_name backup_dict["is_delete"] = False else: backup_dict["group_name"] = "应用已删除" backup_dict["is_delete"] = True backup_list.append(backup_dict) result = general_message(200, "success", "查询成功", list=backup_list, total=paginator.count) except Exception as e: logger.exception(e) result = error_message(e.message) return Response(result, status=result["code"])
def save_data(self, migrate_tenant, migrate_region, user, changed_service_map, metadata, group_id): group = group_repo.get_group_by_id(group_id) apps = metadata["apps"] old_new_service_id_map = dict() service_relations_list = [] service_mnt_list = [] # restore component for app in apps: service_base_info = app["service_base"] new_service_id = changed_service_map[service_base_info["service_id"]]["ServiceID"] new_service_alias = changed_service_map[service_base_info["service_id"]]["ServiceAlias"] ts = self.__init_app(app["service_base"], new_service_id, new_service_alias, user, migrate_region, migrate_tenant) old_new_service_id_map[app["service_base"]["service_id"]] = ts.service_id group_service.add_service_to_group(migrate_tenant, migrate_region, group.ID, ts.service_id) self.__save_env(migrate_tenant, ts, app["service_env_vars"]) self.__save_volume(migrate_tenant, ts, app["service_volumes"], app["service_config_file"] if 'service_config_file' in app else None) self.__save_port(migrate_tenant, ts, app["service_ports"]) self.__save_compile_env(ts, app["service_compile_env"]) self.__save_service_label(migrate_tenant, ts, migrate_region, app["service_labels"]) self.__save_service_perms(ts, app["service_perms"]) self.__save_service_probes(ts, app["service_probes"]) self.__save_service_source(migrate_tenant, ts, app["service_source"]) self.__save_service_auth(ts, app["service_auths"]) service_relations = app["service_relation"] service_mnts = app["service_mnts"] if service_relations: service_relations_list[0:0] = list(service_relations) if service_mnts: service_mnt_list[0:0] = list(service_mnts) # 更新状态 ts.create_status = "complete" ts.save() # restore plugin info self.__save_plugin_config_items(metadata["plugin_info"]["plugin_config_items"]) self.__save_plugin_config_groups(metadata["plugin_info"]["plugin_config_groups"]) versions = self.__save_plugin_build_versions(migrate_tenant, metadata["plugin_info"]["plugin_build_versions"]) self.__save_plugins(migrate_region, migrate_tenant, metadata["plugin_info"]["plugins"]) for app in apps: # plugin if app.get("service_plugin_relation", None): self.__save_plugin_relations(ts, app["service_plugin_relation"], versions) if app.get("service_plugin_config", None): self.__save_service_plugin_config(ts.service_id, app["service_plugin_config"]) self.__save_service_relations(migrate_tenant, service_relations_list, old_new_service_id_map) self.__save_service_mnt_relation(migrate_tenant, service_mnt_list, old_new_service_id_map)
def get_group_services_by_id(self, group_id): service_group = group_repo.get_group_by_id(group_id) if not service_group: return None, None tenant = team_repo.get_team_by_team_id(service_group.tenant_id) services = group_service_relation_repo.get_services_by_group(group_id) if not services: return tenant, [] service_ids = [service.service_id for service in services] cp_service_ids = copy.copy(service_ids) for service_id in cp_service_ids: service_obj = service_repo.get_service_by_service_id(service_id) if service_obj: if service_obj.service_source == "third_party": service_ids.remove(service_id) return tenant, service_ids
def __copy_backup_record(self, restore_mode, origin_backup_record, current_team, current_region, migrate_team, migrate_region, migrate_type): """拷贝备份数据""" services = group_service.get_group_services( origin_backup_record.group_id) if not services and migrate_type == "recover": # restore on the original group new_group = group_repo.get_group_by_id( origin_backup_record.group_id) if not new_group: new_group = self.__create_new_group_by_group_name( migrate_team.tenant_id, migrate_region, origin_backup_record.group_id) else: new_group = self.__create_new_group(migrate_team.tenant_id, migrate_region, origin_backup_record.group_id) if restore_mode != AppMigrateType.CURRENT_REGION_CURRENT_TENANT: # 获取原有数据中心数据 original_data = region_api.get_backup_status_by_backup_id( current_region, current_team.tenant_name, origin_backup_record.backup_id) new_event_id = make_uuid() new_group_uuid = make_uuid() new_data = original_data["bean"] new_data["event_id"] = new_event_id new_data["group_id"] = new_group_uuid # 存入其他数据中心 body = region_api.copy_backup_data(migrate_region, migrate_team.tenant_name, new_data) bean = body["bean"] params = origin_backup_record.to_dict() params.pop("ID") params["team_id"] = migrate_team.tenant_id params["event_id"] = new_event_id params["group_id"] = new_group.ID params["group_uuid"] = new_group_uuid params["region"] = migrate_region params["backup_id"] = bean["backup_id"] # create a new backup record in the new region new_backup_record = backup_record_repo.create_backup_records( **params) return new_group, new_backup_record return new_group, None
def check_and_get_team_group(self, user, team_name, region_name, group_id): team = team_services.check_and_get_user_team_by_name_and_region( user.user_id, team_name, region_name) if not team: raise ServiceHandleException( msg="no found team or team not join this region", msg_show="目标团队不存在,或团队为加入该数据中心", status_code=404) group = group_repo.get_group_by_id(group_id) if not group: raise ServiceHandleException(msg="no found group app", msg_show="目标应用不存在", status_code=404) if group.tenant_id != team.tenant_id: raise ServiceHandleException( msg="group app and team relation no found", msg_show="目标应用不属于目标团队", status_code=400) return team, group
def delete(self, request, *args, **kwargs): """ 删除组信息 --- parameters: - name: tenantName description: 租户名 required: true type: string paramType: path - name: group_id description: 组id required: true type: string paramType: path """ try: group_id = int(kwargs.get("group_id", None)) service = group_service_relation_repo.get_service_by_group( group_id) group_object = group_repo.get_group_by_id(group_id) if group_object.is_default: result = general_message(400, "默认应用不允许删除", None) return Response(result, status=result["code"]) if not service: code, msg, data = group_service.delete_group_no_service( group_id) else: code = 400 msg = '当前组内有应用,无法删除' result = general_message(code, msg, None) return Response(result, status=result["code"]) if code != 200: result = general_message(code, "delete group error", msg) else: result = general_message(code, "success", msg) except Exception as e: logger.exception(e) result = error_message(e.message) return Response(result, status=result["code"])
def get(self, request, *args, **kwargs): """ 获取单个http策略 """ try: http_rule_id = request.GET.get("http_rule_id", None) # 判断参数 if not http_rule_id: return Response(general_message(400, "parameters are missing", "参数缺失"), status=400) domain = domain_repo.get_service_domain_by_http_rule_id( http_rule_id) if domain: bean = domain.to_dict() if domain.certificate_id: certificate_info = domain_repo.get_certificate_by_pk( int(domain.certificate_id)) service = service_repo.get_service_by_service_id( domain.service_id) service_alias = service.service_cname if service else '' group_name = '' if service: gsr = group_service_relation_repo.get_group_by_service_id( service.service_id) group = group_repo.get_group_by_id(int(gsr.group_id)) group_name = group.group_name if group else '' bean.update({"certificate_name": certificate_info.alias}) bean.update({"service_alias": service_alias}) bean.update({"group_name": group_name}) else: bean = dict() result = general_message(200, "success", "查询成功", bean=bean) except Exception as e: logger.exception(e) result = error_message(e.message) return Response(result, status=result["code"])
def update_group(self, tenant, region_name, app_id, app_name, note="", username=None, overrides="", version="", revision=0): # check app id if not app_id or not str.isdigit(app_id) or int(app_id) < 0: raise ServiceHandleException(msg="app id illegal", msg_show="应用ID不合法") data = { "note": note, } if username: # check username try: data["username"] = username user_repo.get_user_by_username(username) except ErrUserNotFound: raise ServiceHandleException(msg="user not exists", msg_show="用户不存在,请选择其他应用负责人", status_code=404) app = group_repo.get_group_by_id(app_id) # check app name if app_name: self.check_app_name(tenant, region_name, app_name, app) if overrides: overrides = self._parse_overrides(overrides) if app_name: data["group_name"] = app_name if version: data["version"] = version group_repo.update(app_id, **data) region_app_id = region_app_repo.get_region_app_id(region_name, app_id) region_api.update_app(region_name, tenant.tenant_name, region_app_id, { "overrides": overrides, "version": version, "revision": revision, })
def __open_outer(self, tenant, service, region, deal_port): if deal_port.protocol != "http": if self.is_open_outer_steam_port(tenant.tenant_id, service.service_id, deal_port.container_port): return 412, u"非http协议端口只能对外开放一个" if deal_port.protocol == "http": service_domains = domain_repo.get_service_domain_by_container_port( service.service_id, deal_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表中保存数据 gsr = group_service_relation_repo.get_group_by_service_id( service.service_id) group_obj = group_repo.get_group_by_id(gsr.group_id) service_id = service.service_id service_name = service.service_alias group_name = group_obj.group_name container_port = deal_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 g_id = str(gsr.group_id) region_id = region.region_id domain_repo.create_service_domains(service_id, service_name, domain_name, create_time, container_port, protocol, http_rule_id, group_name, tenant_id, service_alias, g_id, 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) return 412, u"数据中心添加策略失败" else: service_tcp_domains = tcp_domain.get_service_tcp_domains_by_service_id_and_port( service.service_id, deal_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: return 400, u"请求数据中心异常" end_point = str(region.tcpdomain) + ":" + str(data["bean"]) gsr = group_service_relation_repo.get_group_by_service_id( service.service_id) group_obj = group_repo.get_group_by_id(gsr.group_id) service_id = service.service_id service_name = service.service_alias create_time = datetime.datetime.now().strftime( '%Y-%m-%d %H:%M:%S') container_port = deal_port.container_port protocol = deal_port.protocol group_name = group_obj.group_name service_alias = service.service_cname tcp_rule_id = make_uuid(end_point) tenant_id = tenant.tenant_id g_id = str(gsr.group_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, group_name, tcp_rule_id, tenant_id, g_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) return 412, u"数据中心添加策略失败" deal_port.is_outer_service = True if service.create_status == "complete": body = region_api.manage_outer_port( service.service_region, tenant.tenant_name, service.service_alias, deal_port.container_port, { "operation": "open", "enterprise_id": tenant.enterprise_id }) logger.debug("open outer port body {}".format(body)) lb_mapping_port = body["bean"]["port"] deal_port.lb_mapping_port = lb_mapping_port deal_port.save() return 200, "success"
def get(self, request, tenantName, *args, **kwargs): try: page = int(request.GET.get("page", 1)) page_size = int(request.GET.get("page_size", 10)) search_conditions = request.GET.get("search_conditions", None) tenant = team_services.get_tenant_by_tenant_name(tenantName) region = region_repo.get_region_by_region_name( self.response_region) total = domain_repo.get_all_domain_count_by_tenant_and_region_id( tenant.tenant_id, region.region_id) start = (page - 1) * page_size remaining_num = total - (page - 1) * page_size end = page_size if remaining_num < page_size: end = remaining_num try: # 查询分页排序 if search_conditions: cursor = connection.cursor() cursor.execute( "select domain_name, type, is_senior, certificate_id, group_name, service_alias, protocol, service_name, container_port, http_rule_id, service_id, domain_path, domain_cookie, domain_heander, the_weight, is_outer_service, g_id from service_domain where tenant_id='{0}' and region_id='{1}' and domain_name like '%{2}%' or service_alias like '%{3}%' or group_name like '%{4}%' order by type desc LIMIT {5},{6};" .format(tenant.tenant_id, region.region_id, search_conditions, search_conditions, search_conditions, start, end)) tenant_tuples = cursor.fetchall() else: cursor = connection.cursor() cursor.execute( "select domain_name, type, is_senior, certificate_id, group_name, service_alias, protocol, service_name, container_port, http_rule_id, service_id, domain_path, domain_cookie, domain_heander, the_weight, is_outer_service, g_id from service_domain where tenant_id='{0}' and region_id='{1}' order by type desc LIMIT {2},{3};" .format(tenant.tenant_id, region.region_id, start, end)) tenant_tuples = cursor.fetchall() except Exception as e: logger.exception(e) result = general_message(405, "faild", "查询数据库失败") return Response(result) # 拼接展示数据 domain_list = list() for tenant_tuple in tenant_tuples: service = service_repo.get_service_by_service_id( tenant_tuple[10]) service_alias = service.service_cname if service else '' group_name = '' if service: gsr = group_service_relation_repo.get_group_by_service_id( service.service_id) group = group_repo.get_group_by_id(int(gsr.group_id)) group_name = group.group_name if group else '' domain_dict = dict() certificate_info = domain_repo.get_certificate_by_pk( int(tenant_tuple[3])) if not certificate_info: domain_dict["certificate_alias"] = '' else: domain_dict["certificate_alias"] = certificate_info.alias domain_dict[ "domain_name"] = tenant_tuple[6] + "://" + tenant_tuple[0] domain_dict["type"] = tenant_tuple[1] domain_dict["is_senior"] = tenant_tuple[2] domain_dict["group_name"] = group_name domain_dict["service_cname"] = service_alias domain_dict["service_alias"] = tenant_tuple[7] domain_dict["container_port"] = tenant_tuple[8] domain_dict["http_rule_id"] = tenant_tuple[9] domain_dict["service_id"] = tenant_tuple[10] domain_dict["domain_path"] = tenant_tuple[11] domain_dict["domain_cookie"] = tenant_tuple[12] domain_dict["domain_heander"] = tenant_tuple[13] domain_dict["the_weight"] = tenant_tuple[14] domain_dict["is_outer_service"] = tenant_tuple[15] domain_dict["group_id"] = int(tenant_tuple[16]) domain_list.append(domain_dict) bean = dict() bean["total"] = total result = general_message(200, "success", "查询成功", list=domain_list, bean=bean) except Exception as e: logger.exception(e) result = error_message(e.message) return Response(result)
def save_data( self, migrate_tenant, migrate_region, user, changed_service_map, metadata, group_id, same_team, same_region, sync_flag=False, ): from console.services.groupcopy_service import groupapp_copy_service group = group_repo.get_group_by_id(group_id) apps = metadata["apps"] old_new_service_id_map = dict() service_relations_list = [] service_mnt_list = [] # restore component for app in apps: service_base_info = app["service_base"] new_service_id = changed_service_map[ service_base_info["service_id"]]["ServiceID"] new_service_alias = changed_service_map[ service_base_info["service_id"]]["ServiceAlias"] ts = self.__init_app(app["service_base"], new_service_id, new_service_alias, user, migrate_region, migrate_tenant) old_new_service_id_map[app["service_base"] ["service_id"]] = ts.service_id group_service.add_service_to_group(migrate_tenant, migrate_region, group.ID, ts.service_id) self.__save_port(migrate_region, migrate_tenant, ts, app["service_ports"], group.governance_mode, app["service_env_vars"], sync_flag) self.__save_env(migrate_tenant, ts, app["service_env_vars"]) self.__save_volume( migrate_tenant, ts, app["service_volumes"], app["service_config_file"] if 'service_config_file' in app else None) self.__save_compile_env(ts, app["service_compile_env"]) self.__save_service_label(migrate_tenant, ts, migrate_region, app["service_labels"]) if sync_flag: self.__save_service_probes(ts, app["service_probes"]) self.__save_service_source(migrate_tenant, ts, app["service_source"]) self.__save_service_auth(ts, app["service_auths"]) self.__save_third_party_service_endpoints( ts, app.get("third_party_service_endpoints", [])) self.__save_service_monitors(migrate_tenant, ts, app.get("service_monitors")) self.__save_component_graphs(ts, app.get("component_graphs")) if ts.service_source == "third_party": app_service.create_third_party_service(migrate_tenant, ts, user.nick_name) probes = probe_repo.get_service_probe(ts.service_id) # 为组件添加默认探针 if not probes: if groupapp_copy_service.is_need_to_add_default_probe(ts): code, msg, probe = app_service.add_service_default_porbe( migrate_tenant, ts) logger.debug( "add default probe; code: {}; msg: {}".format( code, msg)) else: for probe in probes: prob_data = { "service_id": ts.service_id, "scheme": probe.scheme, "path": probe.path, "port": probe.port, "cmd": probe.cmd, "http_header": probe.http_header, "initial_delay_second": probe.initial_delay_second, "period_second": probe.period_second, "timeout_second": probe.timeout_second, "failure_threshold": probe.failure_threshold, "success_threshold": probe.success_threshold, "is_used": (1 if probe.is_used else 0), "probe_id": probe.probe_id, "mode": probe.mode, } try: res, body = region_api.add_service_probe( ts.service_region, migrate_tenant.tenant_name, ts.service_alias, prob_data) if res.get("status") != 200: logger.debug(body) probe.delete() except Exception as e: logger.debug("error", e) probe.delete() service_relations = app["service_relation"] service_mnts = app["service_mnts"] if service_relations: service_relations_list[0:0] = list(service_relations) if service_mnts: service_mnt_list[0:0] = list(service_mnts) # 更新状态 ts.create_status = "complete" ts.save() # restore plugin info self.__save_plugins(migrate_region, migrate_tenant, metadata["plugin_info"]["plugins"]) self.__save_plugin_config_items( metadata["plugin_info"]["plugin_config_items"]) self.__save_plugin_config_groups( metadata["plugin_info"]["plugin_config_groups"]) versions = self.__save_plugin_build_versions( migrate_tenant, metadata["plugin_info"]["plugin_build_versions"]) for app in apps: new_service_id = old_new_service_id_map[app["service_base"] ["service_id"]] # plugin if app.get("service_plugin_relation", None): self.__save_plugin_relations(new_service_id, app["service_plugin_relation"], versions) if app.get("service_plugin_config", None): self.__save_service_plugin_config(new_service_id, app["service_plugin_config"]) self.__save_service_relations(migrate_tenant, service_relations_list, old_new_service_id_map, same_team, same_region) self.__save_service_mnt_relation(migrate_tenant, service_mnt_list, old_new_service_id_map, same_team, same_region) # restore application config group self.__save_app_config_groups(metadata.get("app_config_group_info"), migrate_tenant, migrate_region, group_id, changed_service_map)
def get(self, request, tenantName, *args, **kwargs): try: page = int(request.GET.get("page", 1)) page_size = int(request.GET.get("page_size", 10)) search_conditions = request.GET.get("search_conditions", None) tenant = team_services.get_tenant_by_tenant_name(tenantName) region = region_repo.get_region_by_region_name(self.response_region) total = tcp_domain.get_all_domain_count_by_tenant_and_region(tenant.tenant_id, region.region_id) start = (page - 1) * page_size remaining_num = total - (page - 1) * page_size end = page_size if remaining_num < page_size: end = remaining_num try: # 查询分页排序 if search_conditions: cursor = connection.cursor() cursor.execute( "select end_point, type, protocol, service_name, service_alias, container_port, tcp_rule_id, service_id, is_outer_service from service_tcp_domain where tenant_id='{0}' and region_id='{1}' and end_point like '%{2}%' or service_alias like '%{3}%' or group_name like '%{4}%' order by type desc LIMIT {5},{6};".format( tenant.tenant_id, region.region_id, search_conditions, search_conditions, search_conditions, start, end)) tenant_tuples = cursor.fetchall() else: cursor = connection.cursor() cursor.execute( "select end_point, type, protocol, service_name, service_alias, container_port, tcp_rule_id, service_id, is_outer_service from service_tcp_domain where tenant_id='{0}' and region_id='{1}' order by type desc LIMIT {2},{3};".format( tenant.tenant_id, region.region_id, start, end)) tenant_tuples = cursor.fetchall() except Exception as e: logger.exception(e) result = general_message(405, "faild", "查询数据库失败") return Response(result) # 拼接展示数据 domain_list = list() for tenant_tuple in tenant_tuples: service = service_repo.get_service_by_service_id(tenant_tuple[7]) service_alias = service.service_cname if service else '' group_name = '' group_id = 0 if service: gsr = group_service_relation_repo.get_group_by_service_id(service.service_id) if gsr: group = group_repo.get_group_by_id(int(gsr.group_id)) group_name = group.group_name if group else '' group_id = int(gsr.group_id) domain_dict = dict() domain_dict["end_point"] = tenant_tuple[0] domain_dict["type"] = tenant_tuple[1] domain_dict["protocol"] = tenant_tuple[2] domain_dict["group_name"] = group_name domain_dict["service_alias"] = tenant_tuple[3] domain_dict["container_port"] = tenant_tuple[5] domain_dict["service_cname"] = service_alias domain_dict["tcp_rule_id"] = tenant_tuple[6] domain_dict["service_id"] = tenant_tuple[7] domain_dict["is_outer_service"] = tenant_tuple[8] domain_dict["group_id"] = group_id domain_list.append(domain_dict) bean = dict() bean["total"] = total result = general_message(200, "success", "查询成功", list=domain_list, bean=bean) except Exception as e: logger.exception(e) result = error_message(e.message) return Response(result)
def __create_new_group_by_group_name(self, tenant, region, old_group_id): new_group_name = '_'.join(["备份应用", make_uuid()[-4:]]) app = group_service.create_app(tenant, region, new_group_name) new_app = group_repo.get_group_by_id(app["ID"]) return new_app