def get_metric_confg(self, resource_id):
name_list = str(resource_id).split(APPLICATION_ID_SEPARATOR)
application_id = name_list[0]
metric_id = name_list[1]
resourse_type = name_list[2]
try:
met = Metric.objects.get(id=metric_id)
except Exception:
raise ValidationError('Metric[id:{}]:{}'.format(
metric_id, _("不存在")))
api_json = met.to_api_json()
if resourse_type == 'application':
try:
application = MODULE_DICT.get(resourse_type).objects.get(
id=application_id)
except Exception:
raise ValidationError('{}[id:{}]:{}'.format(
_("应用"), application_id, _("不存在")))
app_config = application.get_config()
app_config_new = handel_custom_network_mode(app_config)
app_spec = app_config_new.get('spec', {}).get('template',
{}).get('spec', {})
api_json['networkMode'] = app_spec.get('networkMode')
api_json['networkType'] = app_spec.get('networkType')
return json.dumps(api_json)
def get_all_template_info_by_project(project_id):
# 获取项目下所有的模板信息
# 暂时不支持YAML模板查询
temps = Template.objects.filter(
project_id=project_id,
edit_mode=TemplateEditMode.PageForm.value).values('id', 'name')
tem_dict = {tem['id']: tem['name'] for tem in temps}
tem_ids = tem_dict.keys()
# 获取所有的可见版本
show_vers = ShowVersion.objects.filter(template_id__in=tem_ids).values(
'id', 'real_version_id', 'name', 'template_id')
resource_list = []
for _show in show_vers:
show_version_id = _show['id']
real_version_id = _show['real_version_id']
template_id = _show['template_id']
template_name = tem_dict.get(template_id)
# 每个版本的具体信息
versioned_entity = VersionedEntity.objects.get(template_id=template_id,
id=real_version_id)
entity = versioned_entity.get_entity()
for category in entity:
ids = entity.get(category)
id_list = ids.split(',') if ids else []
res_list = MODULE_DICT.get(category).objects.filter(
id__in=id_list).values('id', 'name', 'config')
for resource in res_list:
config = resource['config']
resource_list.append({
'template_id':
template_id,
'template_name':
template_name,
'show_version_id':
show_version_id,
'show_version_name':
_show['name'],
'category':
category,
'category_name':
CATE_SHOW_NAME.get(category, category),
'resource_id':
resource['id'],
'resource_name':
resource['name'],
'config':
config
})
return resource_list
def get_all_template_config(project_id):
# 暂时不支持YAML模板查询
tem_ids = Template.objects.filter(
project_id=project_id,
edit_mode=TemplateEditMode.PageForm.value).values_list('id', flat=True)
tem_ids = list(tem_ids)
real_version_ids = ShowVersion.objects.filter(
template_id__in=tem_ids).values_list('real_version_id', flat=True)
real_version_ids = list(real_version_ids)
versioned_entity = VersionedEntity.objects.filter(
id__in=real_version_ids).values('entity', 'id')
# 多个 show_ver 对应 一个 real_version，real_version 需要按show_ver出现的次数重复计数
real_version_count_dict = Counter(real_version_ids)
category_dict = {}
for ver in versioned_entity:
try:
entity = json.loads(ver['entity'])
except Exception as error:
logger.exception('load entity error, %s, %s', ver, error)
continue
# 重复出现的id，需要重复添加
count = real_version_count_dict.get(ver['id'])
i = 0
while i < count:
for category in entity:
ids = entity.get(category)
id_list = ids.split(',') if ids else []
id_list = [int(_id) for _id in id_list]
if category in category_dict:
category_dict[category].extend(id_list)
else:
category_dict[category] = id_list
i = i + 1
resource_list = []
for category in category_dict:
category_id_list = category_dict[category]
# 统计每个id出现的次数
category_id_count_dict = Counter(category_id_list)
res_list = MODULE_DICT.get(category).objects.filter(
id__in=category_id_list).values('config', 'id')
for resource in res_list:
# 重复出现的id，需要重复添加
count = category_id_count_dict.get(resource['id'])
i = 0
while i < count:
resource_list.append({'config': resource['config']})
i = i + 1
return resource_list
def post(self, request, project_id, version_id):
version_entity = validate_version_id(project_id,
version_id,
is_version_entity_retrun=True)
project_kind = request.project.kind
self.slz = VariableNamespaceSLZ(data=request.data,
context={'project_kind': project_kind})
self.slz.is_valid(raise_exception=True)
slz_data = self.slz.data
if 'instance_entity' not in slz_data:
raise ValidationError(_("请选择要实例化的模板"))
instance_entity = slz_data['instance_entity']
lb_services = []
key_list = []
for cate in instance_entity:
cate_data = instance_entity[cate]
cate_id_list = [i.get('id') for i in cate_data if i.get('id')]
# 查询这些配置文件的变量名
for _id in cate_id_list:
if cate in ['metric']:
config = self.get_metric_confg(_id)
else:
try:
resource = MODULE_DICT.get(cate).objects.get(id=_id)
except Exception:
continue
config = resource.config
search_list = check_var_by_config(config)
key_list.extend(search_list)
# mesos Deployment 需要再查询 Application 的配置文件
if cate in ['deployment']:
deployment_app = VersionedEntity.get_application_by_deployment_id(
version_id, _id)
deployment_app_config = deployment_app.config
_search_list = check_var_by_config(deployment_app_config)
key_list.extend(_search_list)
# mesos service 查询需要lb的列表
if project_kind == 2 and cate == 'service':
lb_services = version_entity.get_lb_services_by_ids(
cate_id_list)
key_list = list(set(key_list))
variable_dict = {}
if key_list:
# 验证变量名是否符合规范，不符合抛出异常，否则后续用 django 模板渲染变量也会抛出异常
var_objects = Variable.objects.filter(
Q(project_id=project_id) | Q(project_id=0))
access_token = request.user.token.access_token
namespace_res = paas_cc.get_namespace_list(access_token,
project_id,
limit=ALL_LIMIT)
namespace_data = namespace_res.get('data', {}).get('results') or []
namespace_dict = {
str(i['id']): i['cluster_id']
for i in namespace_data
}
ns_list = slz_data['namespaces'].split(
',') if slz_data['namespaces'] else []
for ns_id in ns_list:
_v_list = []
for _key in key_list:
key_obj = var_objects.filter(key=_key)
if key_obj.exists():
_obj = key_obj.first()
# 只显示自定义变量
if _obj.category == 'custom':
cluster_id = namespace_dict.get(ns_id, 0)
_v_list.append({
"key":
_obj.key,
"name":
_obj.name,
"value":
_obj.get_show_value(cluster_id, ns_id)
})
else:
_v_list.append({
"key": _key,
"name": _key,
"value": ""
})
variable_dict[ns_id] = _v_list
return Response({
"code": 0,
"message": "OK",
"data": {
"lb_services": lb_services,
"variable_dict": variable_dict
}
})
def init_template(project_id, project_code, project_kind, access_token,
username):
"""创建项目时，初始化示例模板集
request.project.english_name
"""
# 判断模板集是否已经创建, 如果已经创建, 删除旧模板
exit_templates = Template.objects.filter(project_id=project_id,
name=TEMPLATE_NAME)
if exit_templates.exists():
_delete_old_init_templates(exit_templates, project_id, project_code,
access_token, username)
template_data = {}
if project_kind == K8S_KIND:
template_data = K8S_TEMPLATE.get('data', {})
elif project_kind == MESOS_KIND:
template_data = MESOS_TEMPLATE.get('data', {})
logger.info(
f'init_template [begin] project_id: {project_id}, project_kind: {ClusterType.get(project_kind)}'
)
# 新建模板集
init_template = Template.objects.create(
project_id=project_id,
name=TEMPLATE_NAME,
desc=TEMPLATE_DESC,
creator=username,
updator=username,
)
new_entity = {}
for cate in template_data:
new_item_id_list = []
data_list = template_data[cate]
for _data in data_list:
_save_data = {}
for _d_key in _data:
# 新建，忽略 id 字段
if _d_key == 'id':
continue
# 目前只有 dict、list这两类非字符格式
_d_value = _data[_d_key]
if isinstance(_d_value, list) or isinstance(_d_value, dict):
_save_data[_d_key] = json.dumps(_d_value)
else:
_save_data[_d_key] = _d_value
_ins = MODULE_DICT.get(cate).objects.create(**_save_data)
new_item_id_list.append(str(_ins.id))
new_entity[cate] = ','.join(new_item_id_list)
# 新建version
new_ver = VersionedEntity.objects.create(
template_id=init_template.id,
entity=json.dumps(new_entity),
version=get_default_version(),
creator=username,
updator=username,
)
# 新建可见版本
ShowVersion.objects.create(
template_id=init_template.id,
real_version_id=new_ver.id,
name='init_version',
)
# 将模板集注册到权限中心
request = RequestClass(username=username,
access_token=access_token,
project_code=project_code)
perm = bcs_perm.Templates(request, project_id, bcs_perm.NO_RES)
perm.register(str(init_template.id), str(init_template.name))
logger.info(
f'init_template [end] project_id: {project_id}, project_kind: {ClusterType.get(project_kind)}'
)
return
