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
