def get_region_config_from_db(self, service, plugin_id, build_version):
attrs = service_plugin_config_repo.get_service_plugin_config_var(
service.service_id, plugin_id, build_version)
normal_envs = []
base_normal = dict()
# 上游组件
base_ports = []
# 下游组件
base_services = []
region_env_config = dict()
for attr in attrs:
if attr.service_meta_type == PluginMetaType.UNDEFINE:
if attr.injection == PluginInjection.EVN:
attr_map = json.loads(attr.attrs)
for k, v in attr_map.iteritems():
normal_envs.append({"env_name": k, "env_value": v})
else:
base_normal["options"] = json.loads(attr.attrs)
if attr.service_meta_type == PluginMetaType.UPSTREAM_PORT:
base_ports.append({
"service_id": service.service_id,
"options": json.loads(attr.attrs),
"protocol": attr.protocol,
"port": attr.container_port,
"service_alias": service.service_alias
})
if attr.service_meta_type == PluginMetaType.DOWNSTREAM_PORT:
base_services.append({
"depend_service_alias": attr.dest_service_alias,
"protocol": attr.protocol,
"service_alias": service.service_alias,
"options": json.loads(attr.attrs),
"service_id": service.service_id,
"depend_service_id": attr.dest_service_id,
"port": attr.container_port,
})
config_envs = dict()
complex_envs = dict()
config_envs["normal_envs"] = normal_envs
complex_envs["base_ports"] = base_ports
complex_envs["base_services"] = base_services
complex_envs["base_normal"] = base_normal
config_envs["complex_envs"] = complex_envs
region_env_config["tenant_id"] = service.tenant_id
region_env_config["config_envs"] = config_envs
region_env_config["service_id"] = service.service_id
return region_env_config
def query_share_service_info(self, team, group_id):
service_list = share_repo.get_service_list_by_group_id(
team=team, group_id=group_id)
if service_list:
array_ids = [x.service_id for x in service_list]
deploy_versions = self.get_team_service_deploy_version(
service_list[0].service_region, team, array_ids)
array_keys = []
for x in service_list:
if x.service_key == "application" or x.service_key == "0000" or x.service_key == "":
array_keys.append(x.service_key)
# 查询组件端口信息
service_port_map = self.get_service_ports_by_ids(array_ids)
# 查询组件依赖
dep_service_map = self.get_service_dependencys_by_ids(array_ids)
# 查询组件可变参数和不可变参数
# service_env_change_map, service_env_nochange_map = self.get_service_env_by_ids(array_ids)
service_env_map = self.get_service_env_by_ids(array_ids)
# 查询组件持久化信息
service_volume_map = self.get_service_volume_by_ids(array_ids)
# dependent volume
dep_mnt_map = self.get_dep_mnts_by_ids(team.tenant_id, array_ids)
# 查询组件伸缩方式信息
extend_method_map = self.get_service_extend_method_by_keys(
array_keys)
# 获取组件的健康检测设置
probe_map = self.get_service_probes(array_ids)
all_data_map = dict()
for service in service_list:
data = dict()
data['service_id'] = service.service_id
data['tenant_id'] = service.tenant_id
data['service_cname'] = service.service_cname
data['service_key'] = service.service_key
if (service.service_key == 'application'
or service.service_key == '0000'
or service.service_key == 'mysql'):
data['service_key'] = make_uuid()
service.service_key = data['service_key']
service.save()
# data['need_share'] = True
# else:
# data['need_share'] = False
data["service_share_uuid"] = "{0}+{1}".format(
data['service_key'], data['service_id'])
data['need_share'] = True
data['category'] = service.category
data['language'] = service.language
data['extend_method'] = service.extend_method
data['version'] = service.version
data['memory'] = service.min_memory - service.min_memory % 32
data['service_type'] = service.service_type
data['service_source'] = service.service_source
data['deploy_version'] = deploy_versions[data[
'service_id']] if deploy_versions else service.deploy_version
data['image'] = service.image
data['service_alias'] = service.service_alias
data['service_name'] = service.service_name
data['service_region'] = service.service_region
data['creater'] = service.creater
data["cmd"] = service.cmd
data['probes'] = [
probe.to_dict()
for probe in probe_map.get(service.service_id, [])
]
extend_method = extend_method_map.get(service.service_key)
if extend_method:
e_m = dict()
e_m['min_node'] = service.min_node
e_m['max_node'] = extend_method.max_node
e_m['step_node'] = extend_method.step_node
e_m['min_memory'] = service.min_memory - service.min_memory % 32
e_m['max_memory'] = extend_method.max_memory
e_m['step_memory'] = extend_method.step_memory
e_m['is_restart'] = extend_method.is_restart
data['extend_method_map'] = e_m
else:
data['extend_method_map'] = {
"min_node": service.min_node,
"max_node": 20,
"step_node": 1,
"min_memory": service.min_memory,
"max_memory": 65536,
"step_memory": 128,
"is_restart": 0
}
data['port_map_list'] = list()
if service_port_map.get(service.service_id):
for port in service_port_map.get(service.service_id):
p = dict()
# 写需要返回的port数据
p['protocol'] = port.protocol
p['tenant_id'] = port.tenant_id
p['port_alias'] = port.port_alias
p['container_port'] = port.container_port
p['is_inner_service'] = port.is_inner_service
p['is_outer_service'] = port.is_outer_service
data['port_map_list'].append(p)
data['service_volume_map_list'] = list()
if service_volume_map.get(service.service_id):
for volume in service_volume_map.get(service.service_id):
s_v = dict()
s_v['file_content'] = ''
if volume.volume_type == "config-file":
config_file = volume_repo.get_service_config_file(
volume.ID)
if config_file:
s_v['file_content'] = config_file.file_content
s_v['category'] = volume.category
s_v['volume_type'] = volume.volume_type
s_v['volume_path'] = volume.volume_path
s_v['volume_name'] = volume.volume_name
data['service_volume_map_list'].append(s_v)
data['service_env_map_list'] = list()
data['service_connect_info_map_list'] = list()
if service_env_map.get(service.service_id):
for env_change in service_env_map.get(service.service_id):
if env_change.container_port == 0:
e_c = dict()
e_c['name'] = env_change.name
e_c['attr_name'] = env_change.attr_name
e_c['attr_value'] = env_change.attr_value
e_c['is_change'] = env_change.is_change
if env_change.scope == "outer":
e_c['container_port'] = env_change.container_port
data['service_connect_info_map_list'].append(
e_c)
else:
data['service_env_map_list'].append(e_c)
data['service_related_plugin_config'] = list()
# plugins_attr_list = share_repo.get_plugin_config_var_by_service_ids(service_ids=service_ids)
plugins_relation_list = share_repo.get_plugins_relation_by_service_ids(
service_ids=[service.service_id])
for spr in plugins_relation_list:
service_plugin_config_var = service_plugin_config_repo.get_service_plugin_config_var(
spr.service_id, spr.plugin_id, spr.build_version)
plugin_data = spr.to_dict()
plugin_data["attr"] = [
var.to_dict() for var in service_plugin_config_var
]
data['service_related_plugin_config'].append(plugin_data)
all_data_map[service.service_id] = data
all_data = list()
for service_id in all_data_map:
service = all_data_map[service_id]
service['dep_service_map_list'] = list()
if dep_service_map.get(service['service_id']):
for dep in dep_service_map.get(service['service_id']):
d = dict()
if all_data_map.get(dep.service_id):
# 通过service_key和service_id来判断依赖关系
d['dep_service_key'] = all_data_map[
dep.service_id]["service_share_uuid"]
service['dep_service_map_list'].append(d)
service["mnt_relation_list"] = list()
if dep_mnt_map.get(service_id):
for dep_mnt in dep_mnt_map.get(service_id):
if not all_data_map.get(dep_mnt.dep_service_id):
continue
service["mnt_relation_list"].append({
"service_share_uuid":
all_data_map[dep_mnt.dep_service_id]
["service_share_uuid"],
"mnt_name":
dep_mnt.mnt_name,
"mnt_dir":
dep_mnt.mnt_dir
})
all_data.append(service)
return all_data
else:
return []
def get_service_plugin_config(self, tenant, service, plugin_id,
build_version):
config_groups = plugin_config_service.get_config_group(
plugin_id, build_version)
service_plugin_vars = service_plugin_config_repo.get_service_plugin_config_var(
service.service_id, plugin_id, build_version)
result_bean = dict()
undefine_env = dict()
upstream_env_list = []
downstream_env_list = []
for config_group in config_groups:
items = plugin_config_service.get_config_items(
plugin_id, build_version, config_group.service_meta_type)
if config_group.service_meta_type == PluginMetaType.UNDEFINE:
options = []
normal_envs = service_plugin_vars.filter(
service_meta_type=PluginMetaType.UNDEFINE)
undefine_options = None
if normal_envs:
normal_env = normal_envs[0]
undefine_options = json.loads(normal_env.attrs)
for item in items:
item_option = {
"attr_info": item.attr_info,
"attr_name": item.attr_name,
"attr_value": item.attr_default_value,
"attr_alt_value": item.attr_alt_value,
"attr_type": item.attr_type,
"attr_default_value": item.attr_default_value,
"is_change": item.is_change
}
if undefine_options:
item_option["attr_value"] = undefine_options.get(
item.attr_name, item.attr_default_value)
options.append(item_option)
undefine_env.update({
"service_id":
service.service_id,
"service_meta_type":
config_group.service_meta_type,
"injection":
config_group.injection,
"service_alias":
service.service_alias,
"config":
copy.deepcopy(options),
"config_group_name":
config_group.config_name,
})
if config_group.service_meta_type == PluginMetaType.UPSTREAM_PORT:
ports = port_repo.get_service_ports(service.tenant_id,
service.service_id)
for port in ports:
upstream_envs = service_plugin_vars.filter(
service_meta_type=PluginMetaType.UPSTREAM_PORT,
container_port=port.container_port)
upstream_options = None
if upstream_envs:
upstream_env = upstream_envs[0]
upstream_options = json.loads(upstream_env.attrs)
options = []
for item in items:
item_option = {
"attr_info": item.attr_info,
"attr_name": item.attr_name,
"attr_value": item.attr_default_value,
"attr_alt_value": item.attr_alt_value,
"attr_type": item.attr_type,
"attr_default_value": item.attr_default_value,
"is_change": item.is_change
}
if upstream_options:
item_option["attr_value"] = upstream_options.get(
item.attr_name, item.attr_default_value)
if item.protocol == "" or (
port.protocol in item.protocol.split(",")):
options.append(item_option)
upstream_env_list.append({
"config_group_name":
config_group.config_name,
"service_id":
service.service_id,
"service_meta_type":
config_group.service_meta_type,
"injection":
config_group.injection,
"service_alias":
service.service_alias,
"protocol":
port.protocol,
"port":
port.container_port,
"config":
copy.deepcopy(options)
})
if config_group.service_meta_type == PluginMetaType.DOWNSTREAM_PORT:
dep_services = dependency_service.get_service_dependencies(
tenant, service)
for dep_service in dep_services:
ports = port_repo.list_inner_ports(dep_service.tenant_id,
dep_service.service_id)
for port in ports:
downstream_envs = service_plugin_vars.filter(
service_meta_type=PluginMetaType.DOWNSTREAM_PORT,
dest_service_id=dep_service.service_id,
container_port=port.container_port)
downstream_options = None
if downstream_envs:
downstream_env = downstream_envs[0]
downstream_options = json.loads(
downstream_env.attrs)
options = []
for item in items:
item_option = {
"attr_info": item.attr_info,
"attr_name": item.attr_name,
"attr_value": item.attr_default_value,
"attr_alt_value": item.attr_alt_value,
"attr_type": item.attr_type,
"attr_default_value": item.attr_default_value,
"is_change": item.is_change
}
if downstream_options:
item_option[
"attr_value"] = downstream_options.get(
item.attr_name,
item.attr_default_value)
if item.protocol == "" or (
port.protocol in item.protocol.split(",")):
options.append(item_option)
downstream_env_list.append({
"config_group_name":
config_group.config_name,
"service_id":
service.service_id,
"service_meta_type":
config_group.service_meta_type,
"injection":
config_group.injection,
"service_alias":
service.service_alias,
"protocol":
port.protocol,
"port":
port.container_port,
"config":
copy.deepcopy(options),
"dest_service_id":
dep_service.service_id,
"dest_service_cname":
dep_service.service_cname,
"dest_service_alias":
dep_service.service_alias
})
result_bean["undefine_env"] = undefine_env
result_bean["upstream_env"] = upstream_env_list
result_bean["downstream_env"] = downstream_env_list
return result_bean
