def create_config_group(self, app_id, config_group_name, config_items,
deploy_type, enable, service_ids, region_name,
team_name):
# create application config group
group_req = {
"app_id": app_id,
"config_group_name": config_group_name,
"deploy_type": deploy_type,
"enable": enable,
"region_name": region_name,
"config_group_id": make_uuid(),
}
try:
app_config_group_repo.get(region_name, app_id, config_group_name)
except ApplicationConfigGroup.DoesNotExist:
cgroup = app_config_group_repo.create(**group_req)
create_items_and_services(cgroup, config_items, service_ids)
region_app_id = region_app_repo.get_region_app_id(
region_name, app_id)
region_api.create_app_config_group(
region_name, team_name, region_app_id, {
"app_id": region_app_id,
"config_group_name": config_group_name,
"deploy_type": deploy_type,
"service_ids": service_ids,
"config_items": config_items,
})
else:
raise ErrAppConfigGroupExists
return self.get_config_group(region_name, app_id, config_group_name)
def update_governance_mode(self, tenant, region_name, app_id, governance_mode):
# update the value of host env. eg. MYSQL_HOST
component_ids = group_service_relation_repo.list_serivce_ids_by_app_id(tenant.tenant_id, region_name, app_id)
components = service_repo.list_by_ids(component_ids)
components = {cpt.component_id: cpt for cpt in components}
ports = port_repo.list_inner_ports_by_service_ids(tenant.tenant_id, component_ids)
ports = {port.service_id + str(port.container_port): port for port in ports}
envs = env_var_repo.list_envs_by_component_ids(tenant.tenant_id, component_ids)
for env in envs:
if not env.is_host_env():
continue
cpt = components.get(env.service_id)
if not cpt:
continue
port = ports.get(env.service_id + str(env.container_port))
if not port:
continue
if governance_mode == GovernanceModeEnum.KUBERNETES_NATIVE_SERVICE.name:
env.attr_value = port.k8s_service_name if port.k8s_service_name else cpt.service_alias + "-" + str(
port.container_port)
else:
env.attr_value = "127.0.0.1"
env_var_repo.bulk_update(envs)
group_repo.update_governance_mode(tenant.tenant_id, region_name, app_id, governance_mode)
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
self.sync_envs(tenant.tenant_name, region_name, region_app_id, components.values(), envs)
region_api.update_app(region_name, tenant.tenant_name, region_app_id, {"governance_mode": governance_mode})
def update_config_group(self, region_name, app_id, config_group_name,
config_items, enable, service_ids, team_name):
group_req = {
"enable":
enable,
"update_time":
time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())),
}
try:
cgroup = app_config_group_repo.get(region_name, app_id,
config_group_name)
except ApplicationConfigGroup.DoesNotExist:
raise ErrAppConfigGroupNotFound
else:
app_config_group_repo.update(region_name, app_id,
config_group_name, **group_req)
app_config_group_item_repo.delete(cgroup.config_group_id)
app_config_group_service_repo.delete(cgroup.config_group_id)
create_items_and_services(cgroup, config_items, service_ids)
region_app_id = region_app_repo.get_region_app_id(
cgroup.region_name, app_id)
region_api.update_app_config_group(
cgroup.region_name, team_name, region_app_id,
cgroup.config_group_name, {
"service_ids": service_ids,
"config_items": config_items,
})
return self.get_config_group(region_name, app_id, config_group_name)
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 update_governance_mode(tenant, region_name, app_id, governance_mode):
# update the value of host env. eg. MYSQL_HOST
service_ids = group_service_relation_repo.list_serivce_ids_by_app_id(
tenant.tenant_id, region_name, app_id)
ports = port_repo.list_inner_ports_by_service_ids(
tenant.tenant_id, service_ids)
for port in ports:
env = env_var_repo.get_service_host_env(tenant.tenant_id,
port.service_id,
port.container_port)
service = service_repo.get_service_by_tenant_and_id(
tenant.tenant_id, port.service_id)
if governance_mode == GovernanceModeEnum.KUBERNETES_NATIVE_SERVICE.name:
env.attr_value = port.k8s_service_name if port.k8s_service_name else service.service_alias + "-" + str(
port.container_port)
else:
env.attr_value = "127.0.0.1"
env.save()
if service.create_status == "complete":
body = {
"env_name": env.attr_name,
"env_value": env.attr_value,
"scope": env.scope
}
region_api.update_service_env(service.service_region,
tenant.tenant_name,
service.service_alias, body)
group_repo.update_governance_mode(tenant.tenant_id, region_name,
app_id, governance_mode)
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,
{"governance_mode": governance_mode})
def get_app_status(tenant, region_name, app_id):
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
status = region_api.get_app_status(region_name, tenant.tenant_name,
region_app_id)
if status.get("status") == "NIL":
status["status"] = None
return status
def _delete_app(tenant_name, region_name, app_id):
group_repo.delete_group_by_pk(app_id)
upgrade_repo.delete_app_record_by_group_id(app_id)
try:
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
except RegionApp.DoesNotExist:
return
region_api.delete_app(region_name, tenant_name, region_app_id)
def install_app(self, tenant, region_name, app_id, overrides):
if overrides:
overrides = self._parse_overrides(overrides)
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
region_api.install_app(region_name, tenant.tenant_name, region_app_id, {
"overrides": overrides,
})
def get_app_status(tenant, region_name, app_id):
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
status = region_api.get_app_status(region_name, tenant.tenant_name, region_app_id)
if status.get("status") == "NIL":
status["status"] = None
overrides = status.get("overrides", [])
if overrides:
status["overrides"] = [{override.split("=")[0]: override.split("=")[1]} for override in overrides]
return status
def _delete_app(tenant_name, region_name, app_id):
group_repo.delete_group_by_pk(app_id)
upgrade_repo.delete_app_record_by_group_id(app_id)
try:
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
except RegionApp.DoesNotExist:
return
keys = []
migrate_record = migrate_repo.get_by_original_group_id(app_id)
if migrate_record:
for record in migrate_record:
keys.append(record.restore_id)
region_api.delete_app(region_name, tenant_name, region_app_id, {"etcd_keys": keys})
def create_third_party_service(self, tenant, service, user_name):
data = self.__init_third_party_data(tenant, service, user_name)
# env var
envs_info = env_var_repo.get_service_env(tenant.tenant_id,
service.service_id).values(
'container_port', 'name',
'attr_name', 'attr_value',
'is_change', 'scope')
if envs_info:
data["envs_info"] = list(envs_info)
# 端口
ports = port_repo.get_service_ports(tenant.tenant_id,
service.service_id)
ports_info = ports.values('container_port', 'mapping_port', 'protocol',
'port_alias', 'is_inner_service',
'is_outer_service', 'k8s_service_name')
for port_info in ports_info:
port_info["is_inner_service"] = False
port_info["is_outer_service"] = False
if ports_info:
data["ports_info"] = list(ports_info)
# endpoints
endpoints = service_endpoints_repo.get_service_endpoints_by_service_id(
service.service_id).first()
if endpoints:
if endpoints.endpoints_type == "static":
eps = json.loads(endpoints.endpoints_info)
validate_endpoints_info(eps)
endpoints_dict = dict()
endpoints_dict[endpoints.endpoints_type] = endpoints.endpoints_info
data["endpoints"] = endpoints_dict
data["kind"] = service.service_source
# etcd keys
data["etcd_key"] = service.check_uuid
# 数据中心创建
logger.debug('-----------data-----------_>{0}'.format(data))
app_id = service_group_relation_repo.get_group_id_by_service(service)
region_app_id = region_app_repo.get_region_app_id(
service.service_region, app_id)
data["app_id"] = region_app_id
region_api.create_service(service.service_region, tenant.tenant_name,
data)
# 将组件创建状态变更为创建完成
service.create_status = "complete"
self.__handle_service_ports(tenant, service, ports)
service.save()
return service
def get_monitor_metrics(region_name,
tenant,
target,
app_id="",
component_id=""):
region_app_id = ""
if app_id:
region_app_id = region_app_repo.get_region_app_id(
region_name, app_id)
data = region_api.get_monitor_metrics(region_name, tenant, target,
region_app_id, component_id)
if not data:
return None
return data.get("list", [])
def __init__(self,
tenant,
region_name,
app: ServiceGroup,
component_group: ComponentGroup,
new_components,
update_components,
component_deps,
volume_deps,
plugins: [Plugin],
plugin_deps,
plugin_configs,
new_plugins: [Plugin] = None,
config_groups=None,
config_group_items=None,
config_group_components=None):
self.tenant = tenant
self.tenant_id = tenant.tenant_id
self.region_name = region_name
self.app_id = app.app_id
self.app = app
self.component_group = component_group
self.upgrade_group_id = component_group.upgrade_group_id
self.version = component_group.version
self.region_app_id = region_app_repo.get_region_app_id(
self.region_name, self.app_id)
self.governance_mode = app.governance_mode
self.new_components = new_components
self.update_components = update_components
self.component_ids = [
cpt.component.component_id for cpt in self._components()
]
# plugins
self.plugins = plugins
self.new_plugins = new_plugins
self.plugin_deps = plugin_deps
self.plugin_configs = plugin_configs
# component dependencies
self.component_deps = component_deps if component_deps else []
# volume dependencies
self.volume_deps = volume_deps if volume_deps else []
# config groups
self.config_groups = config_groups if config_groups else []
self.config_group_items = config_group_items if config_group_items else []
self.config_group_components = config_group_components if config_group_components else []
def delete_config_group(self, region_name, team_name, app_id,
config_group_name):
cgroup = app_config_group_repo.get(region_name, app_id,
config_group_name)
region_app_id = region_app_repo.get_region_app_id(
cgroup.region_name, app_id)
try:
region_api.delete_app_config_group(cgroup.region_name, team_name,
region_app_id,
cgroup.config_group_name)
except region_api.CallApiError as e:
if e.status != 404:
raise e
app_config_group_item_repo.delete(cgroup.config_group_id)
app_config_group_service_repo.delete(cgroup.config_group_id)
app_config_group_repo.delete(cgroup.region_name, app_id,
config_group_name)
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不合法")
# check username
if username:
try:
data = {"username": username}
user_repo.get_user_by_username(username)
group_repo.update(app_id, **data)
return
except ErrUserNotFound:
raise ServiceHandleException(msg="user not exists", msg_show="用户不存在,请选择其他应用负责人", status_code=404)
# check app name
if app_name:
self.check_app_name(tenant, region_name, app_name)
if overrides:
overrides = self._parse_overrides(overrides)
group = group_repo.get_group_by_unique_key(tenant.tenant_id, region_name, app_name)
if group and int(group.ID) != int(app_id):
raise ServiceHandleException(msg="app already exists", msg_show="应用名{0}已存在".format(app_name))
data = {
"note": note,
}
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 update_kubernetes_services(self, tenant, region_name, app_id,
k8s_services):
service_ids = group_service_relation_repo.list_serivce_ids_by_app_id(
tenant.tenant_id, region_name, app_id)
for k8s_service in k8s_services:
# check k8s_service_name
try:
# whether k8s_service_name exists
port_repo.get_by_k8s_service_name(
tenant.tenant_id, k8s_service["k8s_service_name"])
try:
# k8s_service_name belong to the current k8s_service?
port_repo.check_k8s_service_name(
tenant.tenant_id, k8s_service["service_id"],
k8s_service["port"], k8s_service["k8s_service_name"])
except TenantServicesPort.DoesNotExist:
raise ErrK8sServiceNameExists
except TenantServicesPort.DoesNotExist:
pass
# check if the given k8s_services belong to the app based on app_id
if k8s_service["service_id"] not in service_ids:
raise AbortRequest("service({}) not belong to app({})".format(
k8s_service["service_id"], app_id))
# bulk_update is only available after django 2.2
for k8s_service in k8s_services:
port_repo.update_port(
tenant.tenant_id, k8s_service["service_id"],
k8s_service["port"], **{
"port_alias": k8s_service["port_alias"],
"k8s_service_name": k8s_service["k8s_service_name"],
})
k8s_service["container_port"] = k8s_service["port"]
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
region_api.update_app_ports(region_name, tenant.tenant_name,
region_app_id, k8s_services)
def list_services(tenant_name, region_name, app_id):
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
services = region_api.list_app_services(region_name, tenant_name,
region_app_id)
return services if services else []
def parse_services(region_name: str, tenant_name: str, app_id: int, values: str):
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
return region_api.parse_app_services(region_name, tenant_name, region_app_id, values)
def list_releases(region_name: str, tenant_name: str, app_id: int):
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
return region_api.list_app_releases(region_name, tenant_name, region_app_id)
def get(self, request, *args, **kwargs):
"""
总览 团队信息
---
parameters:
- name: team_name
description: 团队名
required: true
type: string
paramType: path
"""
overview_detail = dict()
users = team_services.get_team_users(self.team)
if users:
user_nums = len(users)
overview_detail["user_nums"] = user_nums
team_service_num = service_repo.get_team_service_num_by_team_id(
team_id=self.team.tenant_id, region_name=self.response_region)
source = common_services.get_current_region_used_resource(self.team, self.response_region)
# 获取tcp和http策略数量
region = region_repo.get_region_by_region_name(self.response_region)
if not region:
overview_detail["region_health"] = False
return Response(general_message(200, "success", "查询成功", bean=overview_detail))
total_tcp_domain = tcp_domain.get_all_domain_count_by_tenant_and_region(self.team.tenant_id, region.region_id)
overview_detail["total_tcp_domain"] = total_tcp_domain
total_http_domain = domain_repo.get_all_domain_count_by_tenant_and_region_id(self.team.tenant_id, region.region_id)
overview_detail["total_http_domain"] = total_http_domain
# 获取分享应用数量
groups = group_repo.get_tenant_region_groups(self.team.tenant_id, region.region_name)
share_app_num = 0
batch_create_app_body = []
if groups:
for group in groups:
share_record = share_repo.get_service_share_record_by_groupid(group_id=group.ID)
if share_record and share_record.step == 3:
share_app_num += 1
try:
region_app_repo.get_region_app_id(region.region_name, group.ID)
except RegionApp.DoesNotExist:
create_app_body = dict()
group_services = base_service.get_group_services_list(self.team.tenant_id, region.region_name, group.ID)
service_ids = []
if group_services:
service_ids = [service["service_id"] for service in group_services]
create_app_body["app_name"] = group.group_name
create_app_body["console_app_id"] = group.ID
create_app_body["service_ids"] = service_ids
batch_create_app_body.append(create_app_body)
if len(batch_create_app_body) > 0:
try:
body = {"apps_info": batch_create_app_body}
applist = region_api.batch_create_application(region.region_name, self.tenant_name, body)
app_list = []
if applist:
for app in applist:
data = RegionApp(
app_id=app["app_id"], region_app_id=app["region_app_id"], region_name=region.region_name)
app_list.append(data)
RegionApp.objects.bulk_create(app_list)
except Exception as e:
logger.exception(e)
team_app_num = group_repo.get_tenant_region_groups_count(self.team.tenant_id, self.response_region)
overview_detail["share_app_num"] = share_app_num
overview_detail["team_app_num"] = team_app_num
overview_detail["team_service_num"] = team_service_num
overview_detail["eid"] = self.team.enterprise_id
overview_detail["team_service_memory_count"] = 0
overview_detail["team_service_total_disk"] = 0
overview_detail["team_service_total_cpu"] = 0
overview_detail["team_service_total_memory"] = 0
overview_detail["team_service_use_cpu"] = 0
overview_detail["cpu_usage"] = 0
overview_detail["memory_usage"] = 0
if source:
try:
overview_detail["region_health"] = True
overview_detail["team_service_memory_count"] = int(source["memory"])
overview_detail["team_service_total_disk"] = int(source["disk"])
overview_detail["team_service_total_cpu"] = int(source["limit_cpu"])
overview_detail["team_service_total_memory"] = int(source["limit_memory"])
overview_detail["team_service_use_cpu"] = int(source["cpu"])
cpu_usage = 0
memory_usage = 0
if int(source["limit_cpu"]) != 0:
cpu_usage = float(int(source["cpu"])) / float(int(source["limit_cpu"])) * 100
if int(source["limit_memory"]) != 0:
memory_usage = float(int(source["memory"])) / float(int(source["limit_memory"])) * 100
overview_detail["cpu_usage"] = round(cpu_usage, 2)
overview_detail["memory_usage"] = round(memory_usage, 2)
except Exception as e:
logger.debug(source)
logger.exception(e)
else:
overview_detail["region_health"] = False
return Response(general_message(200, "success", "查询成功", bean=overview_detail))
else:
data = {"user_nums": 1, "team_service_num": 0, "total_memory": 0, "eid": self.team.enterprise_id}
result = general_message(200, "success", "团队信息总览获取成功", bean=data)
return Response(result, status=200)
def get_detect_process(tenant, region_name, app_id):
region_app_id = region_app_repo.get_region_app_id(region_name, app_id)
process = region_api.get_app_detect_process(region_name, tenant.tenant_name, region_app_id)
return process
def create_region_service(self,
tenant,
service,
user_name,
do_deploy=True,
dep_sids=None):
data = self.__init_create_data(tenant, service, user_name, do_deploy,
dep_sids)
service_dep_relations = dep_relation_repo.get_service_dependencies(
tenant.tenant_id, service.service_id)
# 依赖
depend_ids = [{
"dep_order": dep.dep_order,
"dep_service_type": dep.dep_service_type,
"depend_service_id": dep.dep_service_id,
"service_id": dep.service_id,
"tenant_id": dep.tenant_id
} for dep in service_dep_relations]
data["depend_ids"] = depend_ids
# 端口
ports = port_repo.get_service_ports(tenant.tenant_id,
service.service_id)
ports_info = ports.values('container_port', 'mapping_port', 'protocol',
'port_alias', 'is_inner_service',
'is_outer_service', 'k8s_service_name')
for port_info in ports_info:
port_info["is_inner_service"] = False
port_info["is_outer_service"] = False
if ports_info:
data["ports_info"] = list(ports_info)
# 环境变量
envs_info = env_var_repo.get_service_env(tenant.tenant_id,
service.service_id).values(
'container_port', 'name',
'attr_name', 'attr_value',
'is_change', 'scope')
if envs_info:
data["envs_info"] = list(envs_info)
# 持久化目录
volume_info = volume_repo.get_service_volumes_with_config_file(
service.service_id)
if volume_info:
volume_list = []
for volume in volume_info:
volume_info = model_to_dict(volume)
if volume.volume_type == "config-file":
config_file = volume_repo.get_service_config_file(
volume.ID)
if config_file:
volume_info.update(
{"file_content": config_file.file_content})
volume_list.append(volume_info)
data["volumes_info"] = volume_list
logger.debug(tenant.tenant_name + " start create_service:" +
datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
# 挂载信息
mnt_info = mnt_repo.get_service_mnts(service.tenant_id,
service.service_id)
if mnt_info:
data["dep_volumes_info"] = [{
"dep_service_id": mnt.dep_service_id,
"volume_path": mnt.mnt_dir,
"volume_name": mnt.mnt_name
} for mnt in mnt_info]
# etcd keys
data["etcd_key"] = service.check_uuid
# runtime os name
data["os_type"] = label_service.get_service_os_name(service)
# 数据中心创建
app_id = service_group_relation_repo.get_group_id_by_service(service)
region_app_id = region_app_repo.get_region_app_id(
service.service_region, app_id)
data["app_id"] = region_app_id
region_api.create_service(service.service_region, tenant.tenant_name,
data)
# 将组件创建状态变更为创建完成
service.create_status = "complete"
self.__handle_service_ports(tenant, service, ports)
service.save()
return service
