def create_services(self, region_name, tenant, user, service_alias, service_infos):
# get temporary service
temporary_service = service_repo.get_service_by_tenant_and_alias(tenant.tenant_id, service_alias)
if not temporary_service:
return 11005, "service not found", "组件不存在", -1
group_id = service_group_relation_repo.get_group_id_by_service(temporary_service)
# save services
code, msg = self.save_multi_services(
region_name=region_name,
tenant=tenant,
group_id=group_id,
service=temporary_service,
user=user,
service_infos=service_infos)
if code != 200:
return code, msg, "创建多组件应用失败", -1
code, msg = app_manage_service.delete(user, tenant, temporary_service, True)
if code != 200:
return code, "Service id: " + temporary_service.service_id + ";error \
deleting temporary service", msg, -1
return 200, "successfully create the multi-services", "成功创建多组件应用", group_id
def create_services(self, region_name, tenant, user, service_alias,
service_infos):
# get temporary service
temporary_service = service_repo.get_service_by_tenant_and_alias(
tenant.tenant_id, service_alias)
if not temporary_service:
raise AbortRequest("service not found",
"组件不存在",
status_code=404,
error_code=11005)
group_id = service_group_relation_repo.get_group_id_by_service(
temporary_service)
# save services
service_ids = self.save_multi_services(region_name=region_name,
tenant=tenant,
group_id=group_id,
service=temporary_service,
user=user,
service_infos=service_infos)
code, msg = app_manage_service.delete(user, tenant, temporary_service,
True)
if code != 200:
raise AbortRequest("Service id: " + temporary_service.service_id +
"; error deleting temporary service",
msg,
status_code=400,
error_code=code)
return group_id, service_ids
def dep_services_changes(self, component, dep_uuids, component_names={}, level="svc"):
"""
find out the dependencies that need to be created and
the dependencies that need to be removed
"""
dep_relations = dep_relation_repo.get_service_dependencies(self.service.tenant_id, self.service.service_id)
service_ids = [item.dep_service_id for item in dep_relations]
# get service_share_uuid by service_id
service_share_uuids = service_source_repo.get_service_sources_by_service_ids(service_ids).values_list(
"service_share_uuid", flat=True)
group_id = service_group_relation_repo.get_group_id_by_service(self.service)
# dep services from exist service
new_dep_services = service_repo.list_by_svc_share_uuids(group_id, dep_uuids)
if level == "app":
exist_uuids = [svc["service_share_uuid"] for svc in new_dep_services]
# dep services from apps
# combine two types of dep_services
for new_dep_service in self.new_dep_services_from_apps(component, dep_uuids, component_names):
if new_dep_service["service_share_uuid"] not in exist_uuids:
new_dep_services.append(new_dep_service)
# filter existing dep services
def dep_service_existed(service):
if service.get("service_id", None) is None:
return service["service_share_uuid"] in service_share_uuids
return service["service_id"] in service_ids
add = [svc for svc in new_dep_services if not dep_service_existed(svc)]
if not add:
return None
return {
"add": add,
}
def __get_current_app_and_version(self):
"""
:return:
app object
app_version object
"""
from console.services.market_app_service import market_app_service
group_id = service_group_relation_repo.get_group_id_by_service(
self.service)
service_ids = group_service_relation_repo.get_services_by_group(
group_id).values_list("service_id", flat=True)
versions = service_source_repo.get_service_sources(
self.tenant.tenant_id,
service_ids).exclude(version=None).values_list("version",
flat=True)
sorted_versions = sorted(
versions,
key=lambda x: map(lambda y: int(filter(str.isdigit, str(y))),
x.split(".")))
current_version = sorted_versions[-1]
if not self.install_from_cloud:
app, app_version = rainbond_app_repo.get_rainbond_app_and_version(
self.tenant.enterprise_id, self.service_source.group_key,
current_version)
else:
app, app_version = market_app_service.get_app_from_cloud(
self.tenant, self.service_source.group_key, current_version)
self.market_id = app.market_id
if app_version:
self.template = json.loads(app_version.app_template)
self.current_app = app
self.current_version = app_version
def get_service_by_service_key(self, service, dep_service_key):
"""
get service according to service_key that is sometimes called service_share_uuid.
"""
group_id = service_group_relation_repo.get_group_id_by_service(service)
dep_services = service_repo.list_by_svc_share_uuids(group_id, [dep_service_key])
if not dep_services:
logger.warning("service share uuid: {}; failed to get dep service: \
service not found".format(dep_service_key))
return None
return dep_services[0]
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 dep_services_changes(self, dep_uuids):
"""
find out the dependencies that need to be created and
the dependencies that need to be removed
"""
dep_relations = dep_relation_repo.get_service_dependencies(self.service.tenant_id, self.service.service_id)
service_ids = [item.dep_service_id for item in dep_relations]
group_id = service_group_relation_repo.get_group_id_by_service(self.service)
new_dep_services = service_repo.list_by_svc_share_uuids(group_id, dep_uuids)
add = [svc for svc in new_dep_services if svc.service_id not in service_ids]
if not add:
return None
return {
"add": add,
}
def __get_current_app_and_version(self):
"""
:return:
app object
app_version object
"""
group_id = service_group_relation_repo.get_group_id_by_service(self.service)
service_ids = group_service_relation_repo.get_services_by_group(group_id).values_list("service_id", flat=True)
service_sources = service_source_repo.get_service_sources(self.tenant.tenant_id, service_ids)
versions = service_sources.exclude(version=None).values_list("version", flat=True)
if versions:
def foobar(y):
try:
s = filter(str.isdigit, str(y))
return int(s)
except ValueError:
# compatible with old version like 'RELEASE.2018-04-19T2'
return -1
sorted_versions = sorted(versions, key=lambda x: map(foobar, x.split(".")))
current_version = sorted_versions[-1]
current_version_source = service_sources.filter(version=current_version).first()
else:
current_version = None
current_version_source = None
if not self.install_from_cloud:
app, app_version = rainbond_app_repo.get_rainbond_app_and_version(self.tenant.enterprise_id,
self.service_source.group_key, current_version)
else:
app, app_version = app_market_service.cloud_app_model_to_db_model(self.market, self.service_source.group_key,
current_version)
if app_version:
self.template = json.loads(app_version.app_template)
self.current_app = app
self.current_version = app_version
if current_version_source:
self.service_source.create_time = current_version_source.create_time
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
