def _delete_show_version(self, delete_data):
project_id = delete_data['project_id']
template = delete_data['template']
show_version_id = delete_data['show_version_id']
username = delete_data['username']
if show_version_id == '-1':
models.Template.objects.filter(id=template.id).update(
draft='', draft_time=None, draft_updator='', draft_version=0)
client.ContextActivityLogClient(project_id=project_id,
user=username,
resource_type="template",
resource=template.name,
resource_id=template.id,
extra='',
description="删除草稿").log_modify()
else:
show_version = models.ShowVersion.objects.get(
template_id=template.id, id=show_version_id)
version_name = show_version.name
show_version.delete()
client.ContextActivityLogClient(
project_id=project_id,
user=username,
resource_type="template",
resource=template.name,
resource_id=template.id,
extra=show_version_id,
description=f"删除版本[{version_name}]").log_modify()
def _delete_show_version(self, delete_data):
project_id = delete_data["project_id"]
template = delete_data["template"]
show_version_id = delete_data["show_version_id"]
username = delete_data["username"]
if show_version_id == "-1":
models.Template.objects.filter(id=template.id).update(
draft="", draft_time=None, draft_updator="", draft_version=0
)
client.ContextActivityLogClient(
project_id=project_id,
user=username,
resource_type="template",
resource=template.name,
resource_id=template.id,
extra="",
description=_("删除草稿"),
).log_modify()
else:
show_version = models.ShowVersion.objects.get(template_id=template.id, id=show_version_id)
version_name = show_version.name
show_version.delete()
client.ContextActivityLogClient(
project_id=project_id,
user=username,
resource_type="template",
resource=template.name,
resource_id=template.id,
extra=show_version_id,
description=_("删除版本[{}]").format(version_name),
).log_modify()
def create_release(self, release_data):
release_result = instantiate_resources(self.access_token,
self.username,
release_data,
project_kind=self.project_kind)
template_name = release_data["template_name"]
log_params = {
"project_id":
release_data["project_id"],
"user":
self.username,
"resource_type":
"template",
"resource":
template_name,
"resource_id":
release_data["template_id"],
"extra":
json.dumps({
"variable_info": release_data["variable_info"],
"instance_entity": release_data["instance_entity"],
"ns_list": release_data["ns_list"],
}),
}
# only one namespace
if release_result["success"]:
ret = release_result["success"][0]
release_id = ret["instance_id"]
log_params["description"] = "实例化模板集[{}]到命名空间[{}]".format(
template_name, ret["ns_name"])
client.ContextActivityLogClient(**log_params).log_add(
activity_status="succeed")
return release_id
ret = release_result["failed"][0]
release_id = ret["instance_id"]
if ret["res_type"]:
description = "实例化模板集[{template_name}]到命名空间[{namespace}]时，实例化{res_name}失败，" "错误消息：{err_msg}".format(
template_name=template_name,
namespace=ret["ns_name"],
res_name=ret["res_type"],
err_msg=ret["err_msg"])
else:
description = "实例化模板集[{template_name}]到命名空间[{namespace}]失败，错误消息：{err_msg}".format(
template_name=template_name,
namespace=ret["ns_name"],
err_msg=ret["err_msg"])
log_params["description"] = description
client.ContextActivityLogClient(**log_params).log_add(
activity_status="failed")
return release_id
def update_release(self, release_data):
project_id = release_data["project_id"]
namespace_id = release_data["namespace_id"]
namespace_info = get_namespace_by_id(self.access_token, project_id,
namespace_id)
release_id = release_data["release_id"]
log_params = {
"project_id":
project_id,
"user":
self.username,
"resource_type":
"instance",
"resource":
release_data["name"],
"resource_id":
release_id,
"extra":
json.dumps({
"namespace": namespace_info["name"],
"variable_info": release_data["variable_info"]
}),
}
try:
update_resources(self.access_token, self.username, release_data,
namespace_info)
except Exception as e:
log_params["description"] = f"rollupdate failed: {e}"
client.ContextActivityLogClient(**log_params).log_modify(
activity_status="failed")
update_inst_params = {"ins_state": InsState.UPDATE_FAILED.value}
else:
log_params["description"] = f"rollupdate success"
client.ContextActivityLogClient(**log_params).log_modify(
activity_status="succeed")
update_inst_params = {"ins_state": InsState.UPDATE_SUCCESS.value}
update_inst_params.update({
"oper_type": ROLLING_UPDATE_INSTANCE,
"variables": release_data["variable_info"].get(namespace_id) or {}
})
InstanceConfig.objects.filter(
instance_id=release_id,
category=release_data["resource_name"],
name=release_data["name"],
namespace=namespace_id,
).update(**update_inst_params)
return release_id
def delete(self):
"""删除节点
1. 检查节点状态
2. 查询容器数量
3. 调用ops删除节点
"""
self.check_perm()
# 查询节点
node_info = self.get_node_ip()
# 检查操作
self.check_host_removing(node_info)
self.check_host_stop_scheduler(node_info)
self.node_ip = node_info.get('inner_ip')
# 检测容器是否存在
self.check_host_exist_container()
# 调用BCS
with client.ContextActivityLogClient(
project_id=self.project_id,
user=self.username,
resource_type=ACTIVITY_RESOURCE_TYPE,
resource=self.node_ip,
resource_id=self.node_id
).log_delete():
# 更新状态
self.update_nodes([self.node_ip], status=CommonStatus.Removing)
# 删除节点上的label
self.delete_node_labels()
log = self.delete_node_via_bcs()
if not log.is_finished and log.is_polling:
log.polling_task()
return Response({})
def update(self, request, project_id, cluster_id, namespace, name):
namespace_id = self.get_namespace_id(request, project_id, cluster_id,
namespace, name)
# 校验查看权限
self.can_use(request, project_id, cluster_id, namespace_id)
config = request.data['config']
# 下发配置
with log_client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type='ingress',
resource=name,
description=_("集群:{}, 更新mesos ingress:{}").format(
cluster_id, name),
).log_modify():
client = mesos.MesosClient(request.user.token.access_token,
project_id,
cluster_id,
env=None)
client.update_custom_resource(name, namespace, config)
# 集群，命名空间，ingress确定唯一
InstanceConfig.objects.filter(namespace=namespace_id,
category='ingress',
name=name,
is_deleted=False).update(
updator=request.user.username,
updated=timezone.now(),
is_bcs_success=True,
config=config)
return response.Response()
def create(self, request, project_id):
slz = serializers.CreateCLBSLZ(data=request.data)
slz.is_valid(raise_exception=True)
data = slz.validated_data
# 校验集群权限
clb_utils.can_use_cluster(request, project_id, data['cluster_id'])
# 通过clb_name渲染deployment
# 替换clb中的'_'为'-', 后缀使用6位随机字符,并且长度限制为253以内，以满足后台的限制
# resource_name包含: clb_name[:246] + '-' + random(6)
replaced_name = data['clb_name'].replace('_', '-')
data['resource_name'] = f'{replaced_name[:246]}-{get_random_string(6).lower()}'
data['creator'] = data['updator'] = request.user.username
data['project_id'] = request.project.project_id
data['vpc_id'] = self.get_vpc_id(request, data['region'], data['clb_name'])
# 创建并返回记录
with client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type='lb',
resource=data['clb_name'],
description=_("集群:{}, 创建云lb controler").format(data['cluster_id']),
).log_add():
record = CloudLoadBlancer.objects.create(data)
data = CloudLoadBlancer.objects.parse_record(record)
return response.Response(data)
def batch_delete(self, request, project_id):
self.slz = serializers.VariableDeleteSLZ(data=request.GET)
self.slz.is_valid(raise_exception=True)
id_list = self.slz.data['id_list']
query_sets = Variable.objects.filter(project_id=project_id,
category='custom',
id__in=id_list)
name_list = query_sets.values_list('name', flat=True)
del_id_list = list(query_sets.values_list('id', flat=True))
deled_id_list = []
with client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type="variable",
resource=','.join(name_list),
resource_id=json.dumps(del_id_list),
description=_("删除变量")).log_delete():
for _s in query_sets:
# 删除后KEY添加 [deleted]前缀
_del_prefix = '[deleted_%s]' % int(time.time())
_s.key = "%s%s" % (_del_prefix, _s.key)
_s.is_deleted = True
_s.deleted_time = timezone.now()
_s.save()
deled_id_list.append(_s.id)
return Response({
"code": 0,
"message": "OK",
"data": {
"deled_id_list": deled_id_list
}
})
def put(self, request, project_id, pk):
"""复制模板
"""
self.request = request
# 验证用户是否使用权限
template = validate_template_id(project_id, pk, is_return_tempalte=True)
perm = bcs_perm.Templates(request, project_id, pk, template.name)
perm.can_edit(raise_exception=True)
self.project_id = project_id
self.pk = pk
data = request.data
data['project_id'] = project_id
self.slz = TemplateCreateSLZ(data=data)
self.slz.is_valid(raise_exception=True)
new_template_name = self.slz.data['name']
# 验证模板名是否已经存在
is_exist = Template.default_objects.filter(
name=new_template_name, project_id=project_id).exists()
if is_exist:
detail = {
'field': ['{prefix_msg}[{tmpl_name}]{suffix_msg}'.format(
prefix_msg=_("模板集名称"),
tmpl_name=new_template_name,
suffix_msg=_("已经存在")
)]
}
raise ValidationError(detail=detail)
# 验证 old模板集id 是否正确
old_tems = self.get_queryset()
if not old_tems.exists():
detail = {
'field': [_("要复制的模板集不存在")]
}
raise ValidationError(detail=detail)
old_tem = old_tems.first()
username = request.user.username
template_id, version_id, show_version_id = old_tem.copy_tempalte(
project_id, new_template_name, username)
# 注册资源到权限中心
perm.register(template_id, new_template_name)
# 记录操作日志
client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type="template",
resource=new_template_name,
resource_id=template_id,
description=_("复制模板集")
).log_add()
return Response({
"code": 0,
"message": "OK",
"data": {
"template_id": template_id,
"version_id": version_id,
"show_version_id": show_version_id,
}
})
def create(self, request, project_id):
"""创建lb
1. 下发service
2. 下发deployment
"""
slz = lb_slz.CreateOrUpdateMesosLBSLZ(data=request.data)
slz.is_valid(raise_exception=True)
data = slz.data
# 保存数据，便于后续下发时，组装下发配置
with activity_client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type="lb",
resource=data["name"],
extra=json.dumps(data),
).log_add():
MesosLoadBalancer.objects.create(
project_id=project_id,
cluster_id=data["cluster_id"],
name=data["name"],
ip_list=json.dumps(data["ip_list"]),
data_dict=json.dumps(data),
status=mesos_lb_constants.MESOS_LB_STATUS.NOT_DEPLOYED.value,
namespace=data["namespace"],
)
return Response()
def update_record(self, request, project_id, cluster_id, namespace, name):
"""更新执行集群+namespace+name的lb记录"""
lb_queryset = self.get_lb_queryset(project_id, cluster_id, namespace,
name)
# 仅允许LB处于未部署状态时，才允许编辑
if lb_queryset.first().status not in [
mesos_lb_constants.MESOS_LB_STATUS.NOT_DEPLOYED.value,
mesos_lb_constants.MESOS_LB_STATUS.STOPPED.value,
]:
raise ValidationError(_("LB必须处于未部署状态或停用状态，当前状态不允许更新"))
# 获取数据
slz = lb_slz.CreateOrUpdateMesosLBSLZ(data=request.data)
slz.is_valid(raise_exception=True)
data = slz.data
# 更新属性
with activity_client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type="lb",
resource=name,
extra=json.dumps(data),
description=_("更新Mesos LB, 集群: {},命名空间: {},名称: {}").format(
cluster_id, namespace, name),
).log_modify():
lb_queryset.update(ip_list=json.dumps(data["ip_list"]),
data_dict=json.dumps(data))
return Response()
def reinstall(self):
self.ratelimit()
# 校验集群编辑权限
self.check_perm()
# 通过node id获取Ip信息
node_info = self.get_node_ip()
log = self.get_node_last_log()
node_ip = node_info.get('inner_ip')
params = json.loads(log.params)
# 校验权限
if node_info.get('status') not in [NodeStatus.Removed, NodeStatus.InitialFailed]:
raise error_codes.CheckFailed(_("IP: {}正在操作中，请勿重复操作").format(node_ip))
with client.ContextActivityLogClient(
project_id=self.project_id,
user=self.username,
resource_type=ACTIVITY_RESOURCE_TYPE,
resource=node_ip,
resource_id=self.node_id,
).log_modify():
self.update_nodes([node_ip])
# 调用OPS api
self.need_nat = params['need_nat']
self.master_ip_list = params['master_ip_list']
self.module_id_list = params['module_id_list']
self.ip_list = [node_ip]
log = self.create_node_by_bcs(
[node_info], control_ip=params['control_ip'], config=params['config'], websvr=params['websvr']
)
if not log.is_finished and log.is_polling:
log.polling_task()
return Response({})
def post(self, request, project_id, template_id):
if is_create_template(template_id):
# template dict like {'desc': '', 'name': ''}
tpl_args = request.data.get('template', {})
template = create_template_with_perm_check(request, project_id,
tpl_args)
else:
template = get_template_by_project_and_id(project_id, template_id)
self.can_edit_template(request, template)
serializer = serializers_new.TemplateDraftSLZ(
template, data=request.data, context={'template_id': template.id})
serializer.is_valid(raise_exception=True)
serializer.save(draft_updator=request.user.username)
validated_data = serializer.validated_data
# 记录操作日志
client.ContextActivityLogClient(project_id=template.project_id,
user=request.user.username,
resource_type='template',
resource=template.name,
resource_id=template.id,
extra=json.dumps(validated_data),
description=_("保存草稿")).log_modify()
return Response({
'template_id': template.id,
'show_version_id': -1,
'real_version_id': validated_data['real_version_id'],
})
def delete(self):
# 添加权限限制
self.check_cluster_perm()
# 针对导入/纳管的集群，需要删除节点记录
cluster = cluster_utils.get_cluster(self.access_token, self.project_id, self.cluster_id)
if cluster["state"] == ClusterState.Existing.value:
self.delete_cluster_nodes(self.access_token, self.project_id, self.cluster_id)
# 更新集群状态为删除中
data = self.update_cluster_status(status=CommonStatus.Removing)
# 删除平台数据库记录的已经实例化，但是没有删除的实例信息
ns_id_list = self.get_cluster_ns_list()
self.clean_instance(ns_id_list)
self.delete_namespaces()
self.delete_helm_release()
# 下发删除任务
with client.ContextActivityLogClient(
project_id=self.project_id,
user=self.username,
resource_type=ACTIVITY_RESOURCE_TYPE,
resource=data['name'],
resource_id=self.cluster_id
).log_delete():
snapshot = self.get_cluster_snapshot()
self.config = json.loads(snapshot.get('configure', '{}'))
self.control_ip = self.config.pop('control_ip', [])
self.websvr = self.config.pop('websvr', [])
task = self.delete_cluster_via_bcs()
if task and not task.is_finished and task.is_polling:
task.polling_task()
return Response({})
def delete_single(
self, request, data, project_id, muster_id, show_version_name, res_name, muster_name):
"""删除单个类型
"""
ns_id_list = data.get("namespace_list")
category = data.get("category")
if not (ns_id_list and category):
raise error_codes.CheckFailed.f(u"参数不能为空!")
project_kind = request.project.kind
category = get_real_category(project_kind, category)
if category not in MODULE_DICT:
raise error_codes.CheckFailed.f(u"category: %s 不存在!" % category)
# 获取要删除的实例的信息
inst_info = self.get_instance_info(ns_id_list, [res_name], category=category)
# 获取项目信息
flag, project_kind = self.get_project_kind(request, project_id)
if not flag:
return project_kind
with client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type="instance",
resource=res_name,
resource_id=res_name,
extra=json.dumps({
"muster_id": muster_id,
"show_version_name": show_version_name,
"res_name": res_name,
"category": category
}),
description=u"删除模板集实例"
).log_delete():
return self.delete_handler(request, inst_info, project_id, project_kind)
def _log_activity(self, status, msg=''):
show_version = self.release_data.show_version
template = show_version.related_template
if status == 'succeed':
description = f'deploy template [{template.name}] in ns [{self.namespace}] success'
else:
description = f'deploy template [{template.name}] in ns [{self.namespace}] failed: {msg}'
extra = {}
for res_file in self.release_data.template_files:
files_ids = [str(f['id']) for f in res_file['files']]
extra[res_file['resource_name']] = ','.join(files_ids)
log_params = {
'project_id': self.release_data.project_id,
'user': self.username,
'resource_type': 'template',
'resource': template.name,
'resource_id': template.id,
'extra': json.dumps(extra),
'description': description,
}
client.ContextActivityLogClient(**log_params).log_add(
activity_status=status)
def destroy(self, request, project_id, pk):
"""删除nginx ingress
1. 标识LB配置
2. 删除节点标签nodetype
3. 删除helm记录
"""
lb_conf = self.get_object()
# 标识LB被删除
self.delete_lb_conf(lb_conf)
# 删除节点标签
delete_node_id_list = [
node_id for node_id in json.loads(lb_conf.ip_info)
]
self.delete_node_label(request, delete_node_id_list, project_id,
lb_conf)
# 删除helm release
release = self.get_helm_release(lb_conf.cluster_id,
K8S_LB_CHART_NAME,
namespace_id=lb_conf.namespace_id,
namespace=lb_conf.namespace)
if not release:
return Response()
user_log = log_client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type='lb',
resource="%s:%s" % (lb_conf.cluster_id, lb_conf.namespace_id),
resource_id=pk)
release.destroy(username=request.user.username,
access_token=request.user.token.access_token)
user_log.log_delete(activity_status="succeed")
return Response()
def delete_all(self, request, data, project_id, muster_id, show_version_name, res_name, muster_name):
"""删除所有类型"""
ns_id_list = data.get("namespace_list")
id_list = data.get("id_list")
if not (ns_id_list and id_list):
raise error_codes.CheckFailed(_("参数不能为空!"))
# 获取项目信息
flag, project_kind = self.get_project_kind(request, project_id)
if not flag:
return project_kind
# 获取所有模板名称
tmpl_category_name_map = {}
for info in id_list:
category_name = info["id"]
tmpl_category_name_map[category_name] = info["category"]
# 获取要删除的实例信息
inst_info = self.get_instance_info(ns_id_list, tmpl_category_name_map.keys())
# instance_version_ids = [val["info"].instance_id for key, val in inst_info.items()]
with client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type="instance",
resource=muster_name,
resource_id=muster_id,
extra=json.dumps(
{
"muster_id": muster_id,
"show_version_name": show_version_name,
"tmpl_category_name_map": tmpl_category_name_map,
}
),
description=_("删除模板集实例"),
).log_delete():
resp = self.delete_handler(request, inst_info, project_id, project_kind)
return resp
def upgrade_by_ops(self, request, params):
with client.ContextActivityLogClient(
project_id=params["project_id"],
user=request.user.username,
resource_type="cluster",
resource_id=params["cluster_id"],
description=_("升级集群版本"),
).log_modify():
ops_client = ops.OPSClient(
request.user.token.access_token,
params["project_id"],
params["cluster_id"],
params.get("coes") or params.get("coes_name"),
params["platform"],
request.user.username,
)
task_info = ops_client.upgrade_cluster(
{
"master_ip_list": params["master_ip_list"],
"control_ip": params["control_ip"],
"node_ip_list": params["node_ip_list"],
"update_type": params["update_type"],
}
)
return task_info
def delete_services(self, request, project_id, cluster_id, namespace, name):
username = request.user.username
# 检查用户是否有命名空间的使用权限
namespace_dict = self.check_namespace_use_perm(request, project_id, [namespace])
namespace_id = namespace_dict.get(namespace)
flag, project_kind = self.get_project_kind(request, project_id)
if not flag:
return project_kind
# 删除service
resp = self.delete_single_service(request, project_id, project_kind, cluster_id, namespace, namespace_id, name)
# 添加操作审计
activity_client.ContextActivityLogClient(
project_id=project_id,
user=username,
resource_type="instance",
resource=name,
resource_id=0,
extra=json.dumps({}),
description=u"删除Service[%s]命名空间[%s]" % (
name, namespace)
).log_modify(activity_status="succeed" if resp.get("code") == ErrorCode.NoError else "failed")
# 已经删除的，需要将错误信息翻译一下
message = resp.get('message', '')
is_delete_before = True if 'node does not exist' in message or 'not found' in message else False
if is_delete_before:
message = u"%s[命名空间:%s]已经被删除，请手动刷新数据" % (name, namespace)
return Response({
"code": resp.get("code"),
"message": message,
"data": {}
})
def force_delete(self):
"""强制删除
1. 检查状态
2. 调用ops删除节点
"""
self.check_perm()
# 判断节点是否允许删除
self.can_delete_node(self.request.user.token.access_token, self.project_id, self.cluster_id)
# 查询节点
node_info = self.get_node_ip()
self.check_host_stop_scheduler(node_info)
self.check_host_removing(node_info)
# 调用BCS
self.node_ip = node_info.get('inner_ip')
with client.ContextActivityLogClient(
project_id=self.project_id,
user=self.username,
resource_type=ACTIVITY_RESOURCE_TYPE,
resource=self.node_ip,
resource_id=self.node_id,
).log_delete():
# 更新状态
self.update_nodes([self.node_ip], status=CommonStatus.Removing)
# 删除节点上的label
self.delete_node_labels()
log = self.delete_node_via_bcs()
if not log.is_finished and log.is_polling:
log.polling_task()
return Response({})
def create(self, request, project_id):
slz = LoadBalancesSLZ(data=request.data)
slz.is_valid(raise_exception=True)
data = slz.data
creator = request.user.username
# 针对mesos，权限相关放大到集群即可
self.can_use_perm(request, project_id, data['cluster_id'])
handled_data = self.handle_data(data)
with activity_client.ContextActivityLogClient(
project_id=project_id,
user=creator,
resource_type="lb",
resource_id=data["cluster_id"],
resource=data['name'],
description=u"创建LoadBalance",
extra=json.dumps(data),
).log_add() as ual_client:
MesosLoadBlance.objects.create(
project_id=project_id,
cluster_id=data['cluster_id'],
namespace_id=data['namespace_id'],
namespace=data['namespace'],
name=data['name'],
creator=creator,
updator=creator,
ip_list=json.dumps(data['ip_list']),
data=json.dumps(data['constraints']),
data_dict=json.dumps(handled_data)
)
ual_client.update_log(activity_status='succeed')
return Response({"code": 0, "message": "ok"})
def deploy(self, request, project_id, cluster_id, namespace, name):
"""部署LB到集群"""
lb_queryset = self.get_lb_queryset(project_id, cluster_id, namespace,
name)
lb = lb_queryset.first()
access_token = request.user.token.access_token
# 组装下发配置
lb_conf = lb_utils.MesosLBConfig(access_token, project_id, cluster_id,
lb)
svc_conf = lb_conf._service_config()
deploy_conf = lb_conf._deployment_config()
# 创建lb，包含service和deployment
with activity_client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type="lb",
resource=name,
description=_("启动Mesos LoadBalancer"),
).log_start():
lb_utils.deploy_mesos_lb(access_token, project_id, cluster_id,
svc_conf, deploy_conf)
lb_queryset.update(
status=mesos_lb_constants.MESOS_LB_STATUS.DEPLOYING.value)
return Response()
def update(self, request, project_id, lb_id):
slz = UpdateLoadBalancesSLZ(data=request.data)
slz.is_valid(raise_exception=True)
data = slz.data
updater = request.user.username
# 检查是否有命名空间的使用权限
self.can_use_perm(request, project_id, data['cluster_id'])
handled_data = self.handle_data(data)
with activity_client.ContextActivityLogClient(
project_id=project_id,
user=updater,
resource_type="lb",
resource=data['name'],
resource_id=data['cluster_id'],
description=u"更新LoadBalance",
extra=json.dumps(data),
).log_modify() as ual_client:
MesosLoadBlance.objects.filter(id=lb_id).update(
project_id=project_id,
cluster_id=data['cluster_id'],
namespace_id=data['namespace_id'],
namespace=data['namespace'],
name=data['name'],
updator=updater,
ip_list=json.dumps(data['ip_list']),
data=json.dumps(data['constraints']),
data_dict=json.dumps(handled_data)
)
ual_client.update_log(activity_status="succeed")
return Response({"code": 0, "message": "ok"})
def delete_services(self, request, project_id, cluster_id, namespace, name):
username = request.user.username
# 检查用户是否有命名空间的使用权限
namespace_id = app_utils.get_namespace_id(
request.user.token.access_token, project_id, (cluster_id, namespace), cluster_id=cluster_id
)
app_utils.can_use_namespace(request, project_id, namespace_id)
flag, project_kind = self.get_project_kind(request, project_id)
if not flag:
return project_kind
# 删除service
resp = self.delete_single_service(request, project_id, project_kind, cluster_id, namespace, namespace_id, name)
# 添加操作审计
activity_client.ContextActivityLogClient(
project_id=project_id,
user=username,
resource_type="instance",
resource=name,
resource_id=0,
extra=json.dumps({}),
description=_("删除Service[{}]命名空间[{}]").format(name, namespace),
).log_modify(activity_status="succeed" if resp.get("code") == ErrorCode.NoError else "failed")
# 已经删除的，需要将错误信息翻译一下
message = resp.get('message', '')
is_delete_before = True if 'node does not exist' in message or 'not found' in message else False
if is_delete_before:
message = _("{}[命名空间:{}]已经被删除，请手动刷新数据").format(name, namespace)
return Response({"code": resp.get("code"), "message": message, "data": {}})
def delete(self, request, project_id, lb_id):
# 判断 lb 的状态
validate_res, validate_msg = self.validate_lb(
request, project_id, lb_id, "delete")
if not validate_res:
return Response(validate_msg)
username = request.user.username
with activity_client.ContextActivityLogClient(
project_id=project_id,
user=username,
resource_type="lb",
resource=lb_id,
resource_id=lb_id,
).log_modify() as ual_client:
lb_info = MesosLoadBlance.objects.filter(id=lb_id)
lb_info.update(
is_deleted=True,
deleted_time=datetime.datetime.now(),
name="%s:deleted:%s" % (lb_id, lb_info[0].name)
)
ual_client.update_log(
activity_status='succeed',
description=u"LB[%s]删除成功" % lb_id,
)
return Response({
"code": 0,
"message": "删除成功!",
})
def create(self, request, project_id, is_validate_perm=True):
"""新建命名空间
k8s 流程：新建namespace配置文件并下发 -> 新建包含仓库账号信息的sercret配置文件并下发 -> 在paas-cc上注册
mesos流程：新建包含仓库账号信息的sercret配置文件并下发 -> 在paas-cc上注册
"""
serializer = CreateNamespaceSLZ(data=request.data,
context={
'request': request,
'project_id': project_id
})
serializer.is_valid(raise_exception=True)
data = serializer.data
# 判断权限
cluster_id = data['cluster_id']
perm = bcs_perm.Namespace(request, project_id, bcs_perm.NO_RES,
cluster_id)
perm.can_create(raise_exception=is_validate_perm)
data = serializer.data
description = _('集群: {}, 创建命名空间: 命名空间[{}]').format(
cluster_id, data["name"])
with client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type='namespace',
resource=data['name'],
description=description).log_add():
result = self.create_flow(request, project_id, data, perm)
return response.Response(result)
def delete(self, request, project_id, cluster_id, namespace, name):
namespace_id = self.get_namespace_id(request, project_id, cluster_id,
namespace, name)
# 校验查看权限
self.can_use(request, project_id, cluster_id, namespace_id)
with log_client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type='ingress',
resource=name,
description=_("集群:{}, 删除mesos ingress:{}").format(
cluster_id, name),
).log_delete():
client = mesos.MesosClient(request.user.token.access_token,
project_id,
cluster_id,
env=None)
client.delete_custom_resource(name, namespace)
# 删除成功则更新记录
now_time = timezone.now()
InstanceConfig.objects.filter(namespace=namespace_id,
category='ingress',
name=name).update(
updator=request.user.username,
updated=now_time,
deleted_time=now_time,
is_deleted=True,
is_bcs_success=True,
)
return response.Response()
def delete(self):
# 添加权限限制
self.check_cluster_perm()
# 更新集群状态为删除中
data = self.update_cluster_status(status=CommonStatus.Removing)
# 删除平台数据库记录的已经实例化，但是没有删除的实例信息
ns_id_list = self.get_cluster_ns_list()
self.clean_instance(ns_id_list)
self.delete_namespaces()
self.delete_helm_release()
# 下发删除任务
with client.ContextActivityLogClient(
project_id=self.project_id,
user=self.username,
resource_type=ACTIVITY_RESOURCE_TYPE,
resource=data['name'],
resource_id=self.cluster_id).log_delete():
snapshot = self.get_cluster_snapshot()
self.config = json.loads(snapshot.get('configure', '{}'))
self.control_ip = self.config.pop('control_ip', [])
self.websvr = self.config.pop('websvr', [])
log = self.delete_cluster_via_bcs()
if not log.is_finished and log.is_polling:
log.polling_task()
return Response({})
def post(self, request, project_id, clb_id):
# 获取配置
record = CloudLoadBlancer.objects.retrieve_record(clb_id)
# 校验使用集群权限
clb_utils.can_use_cluster(request, project_id, record['cluster_id'])
# 获取 repo 地址
repo_domain = paas_cc.get_jfrog_domain(request.user.token.access_token, project_id, record['cluster_id'])
if not repo_domain:
repo_domain = settings.DEFAUT_MESOS_LB_JFROG_DOMAIN
record['repo_domain'] = repo_domain
mesos_json = json.loads(render_to_string('mesos.json', record))
with client.ContextActivityLogClient(
project_id=project_id,
user=request.user.username,
resource_type='lb',
resource=record['resource_name'],
description=_("集群:{}, 创建clb关联deployment:{}").format(record['cluster_id'], record['resource_name']),
).log_add():
clb_utils.create_mesos_deployment(
request.user.token.access_token, project_id, record['cluster_id'], record['namespace'], mesos_json
)
# 更改状态
self.update_clb_status(clb_id, clb_constants.CLB_CREATED_STATUS)
return response.Response()
