def get_task(self, request, pk=None):
task_info = self.get_object()
task_msg = task_info.task_msg
if task_info.task_status == 1:
return JsonResponse(
R.running(msg="执行中", data=str(task_info.task_id)))
task_info.is_show = True
task_info.save()
if task_msg:
msg = json.loads(task_msg)
if msg["status"] == 200:
if not msg["data"]:
msg["data"] = {"_now": int(timezone.now().timestamp())}
else:
msg["data"]["_now"] = int(timezone.now().timestamp())
try:
HTTP_HOST = request.META.get("HTTP_REFERER")
# 判断前端的请求地址是IP形式或者是域名形式
if HTTP_HOST.count(":") < 2:
HTTP_HOST = HTTP_HOST.replace("http://",
"").replace(
"https://", "")
origin_host = msg["data"]["host"].split(":")
if len(origin_host) >= 2 and HTTP_HOST:
msg["data"][
"host"] = HTTP_HOST[:
-1] + ":" + origin_host[
1]
except Exception as e:
pass
return JsonResponse(msg, status=200)
else:
return JsonResponse(msg, status=200)
return JsonResponse(R.ok())
def destroy(self, request, *args, **kwargs):
"""
删除镜像信息
:param request:
:param args:
:param kwargs:
:return:
"""
user = request.user
if not user.is_superuser:
return JsonResponse(R.build(msg="权限不足"))
network = self.get_object()
count = LayoutServiceNetwork.objects.filter(network_id=network).count()
if count == 0:
try:
docker_network = client.networks.get(
network.net_work_client_id)
docker_network.remove()
except Exception as e:
try:
network_list = client.networks.list()
for network in network_list:
network_configs = network.attrs['IPAM']['Config']
if len(network_configs) > 0:
subnet = network_configs[0]['Subnet']
if subnet != network.net_work_subnet:
continue
network.remove()
except Exception as e:
pass
network.delete()
return JsonResponse(R.ok())
else:
return JsonResponse(
R.build(msg="网卡 %s 正在使用无法删除" % (network.net_work_subnet, )))
def delete_container(task_id):
"""
删除容器任务
:param task_id: 任务id
"""
task_info = TaskInfo.objects.filter(task_id=task_id, task_status=1).first()
if not task_info:
return
operation_args = task_info.operation_args
args = json.loads(operation_args)
container_id = args["container_id"]
container_vul = ContainerVul.objects.filter(
container_id=container_id).first()
msg = R.ok(msg="删除成功")
if container_vul:
# docker 连接容器ID
docker_container_id = container_vul.docker_container_id
try:
# 连接Docker容器
docker_container = client.containers.get(docker_container_id)
# 停止容器运行
docker_container.stop()
# 删除容器
docker_container.remove()
except Exception:
pass
finally:
container_vul.delete()
msg = R.ok(msg="删除成功")
task_info.task_status = 3
task_info.task_msg = json.dumps(msg)
task_info.update_date = timezone.now()
task_info.save()
print("删除漏洞容器成功，任务ID：%s" % (task_id, ))
def stop_container(task_id):
"""
停止 docker 容器
:param task_id: task id
"""
task_info = TaskInfo.objects.filter(task_id=task_id, task_status=1).first()
if not task_info:
return
operation_args = task_info.operation_args
args = json.loads(operation_args)
container_id = args["container_id"]
container_vul = ContainerVul.objects.filter(container_id=container_id).first()
msg = R.ok(msg="停止成功")
if container_vul:
docker_container_id = container_vul.docker_container_id
try:
# 连接 Docker 容器
docker_container = client.containers.get(docker_container_id)
docker_container.stop()
container_vul.container_status = 'stop'
container_vul.save()
msg = R.ok(msg="停止成功")
except NotFound:
container_vul.delete()
msg = R.ok(msg="停止成功")
except Exception:
msg = R.err(msg="停止失败，服务器内部错误")
# execute finish
task_info.task_status = 3
task_info.task_msg = json.dumps(msg)
task_info.update_date = timezone.now()
task_info.save()
print("停止漏洞容器成功，任务ID：%s" % (task_id, ))
def get(self, request):
page_no = int(request.GET.get("page", 1))
score_list = ContainerVul.objects.filter(
is_check=True,
time_model_id='').values('image_id').distinct().values(
'user_id').annotate(score=Sum("image_id__rank")).values(
'user_id', 'score').order_by("-score")
len_score_list = [item for item in score_list if item['score'] != 0]
try:
pages = Paginator(
[item for item in score_list if item['score'] != 0], 20)
page = pages.page(page_no)
except Exception as e:
return JsonResponse(R.err())
result = []
for _data in list(page):
user_info = UserProfile.objects.filter(id=_data["user_id"]).first()
username = ""
pass_container_vuls = ""
user_avatar = ""
if user_info:
username = user_info.username
user_avatar = user_info.avatar
pass_container_vuls = ContainerVul.objects.filter(
is_check=True, user_id=user_info.id,
time_model_id='').values('image_id').distinct().count()
result.append({
"rank": _data["score"],
"name": username,
"image_url": user_avatar,
"pass_container_count": pass_container_vuls
})
data = {'results': result, 'count': len(len_score_list)}
return JsonResponse(R.ok(data=data))
def get_layout(self, request, pk=None):
if not pk or pk == "undefined":
return JsonResponse(R.build(msg="环境不存在"))
user = request.user
if user.is_superuser:
layout_info = Layout.objects.filter(layout_id=pk).first()
else:
layout_info = Layout.objects.filter(layout_id=pk, is_release=True).first()
if not layout_info:
return JsonResponse(R.build(msg="环境不存在或未发布"))
layout_path = os.path.join(DOCKER_COMPOSE, str(layout_info.layout_id))
layout_data = LayoutData.objects.filter(layout_id=layout_info,
file_path="docker-compose" + layout_path.replace(DOCKER_COMPOSE,
""), ).first()
open_host_list = []
is_run = False
if layout_data and layout_data.status == 'running':
service_container_list = LayoutServiceContainer.objects.filter(layout_user_id=layout_data)
for service_container in service_container_list:
service_info = service_container.service_id
container_host = service_container.container_host
if service_info.is_exposed:
if container_host:
open_host_list.extend(container_host.split(","))
is_run = True
result_data = {
"layout": {
"name": layout_info.layout_name,
"desc": layout_info.layout_desc,
},
"open": open_host_list,
"is_run": is_run
}
return JsonResponse(R.ok(data=result_data))
def create_image(task_id):
"""
创建镜像名称
"""
task_info = TaskInfo.objects.filter(task_id=task_id, task_status=1).first()
if not task_info:
return
operation_args = task_info.operation_args
args = json.loads(operation_args)
image_name = args["image_name"].strip()
image_desc = args["image_desc"].strip()
image_rank = args["rank"]
image_vul_name = args["image_vul_name"].strip()
image_info = ImageInfo.objects.filter(image_name=image_name).first()
if not image_info:
image_info = ImageInfo(image_name=image_name,
image_desc=image_desc,
rank=image_rank,
image_vul_name=image_vul_name)
image = None
msg = {}
try:
image = client.images.get(image_name)
except Exception as e:
image_info.is_ok = False
image_info.save()
try:
images = client.images.pull(image_name)
if Image == type(images):
image = images
else:
if len(images) > 0:
image = images[0]
except ImageNotFound:
msg = R.build(msg="%s 不存在")
except Exception:
traceback.print_exc()
msg = R.err(msg="%s 添加失败" % (image_name, ))
if image:
config = image.attrs["ContainerConfig"]
port_list = []
if "ExposedPorts" in config:
port_list = config["ExposedPorts"]
ports = []
for port in port_list:
port = port.replace("/", "").replace("tcp", "").replace("udp", "")
ports.append(port)
image_port = ",".join(ports)
image_info.image_port = image_port
image_info.is_ok = True
image_info.save()
msg = R.ok(msg="%s 添加成功" % (image_name, ),
data=json.dumps({"image_port": image_port}))
task_info.task_status = 3
else:
task_info.task_status = 4
task_info.task_msg = json.dumps(msg)
task_info.save()
def del_comment(self, request, pk=None):
user = request.user
if not pk:
return JsonResponse(R.build(msg="参数不能为空"))
comment_info = Comment.objects.filter(comment_id=pk).first()
if not comment_info:
return JsonResponse(R.build(msg="评论不存在"))
if not user.is_superuser and comment_info.user != user:
return JsonResponse(R.build(msg="权限不足"))
comment_info.delete()
return JsonResponse(R.ok())
def update(self, request, *args, **kwargs):
user = request.user
if not user.is_superuser:
return JsonResponse(R.build(msg="权限不足"))
new_pwd = request.data.get("pwd", "")
new_pwd = new_pwd.strip()
if len(new_pwd) < 6:
return JsonResponse(R.build(msg="密码格式不正确"))
user_info = self.get_object()
user_info.set_password(new_pwd)
user_info.save()
return JsonResponse(R.ok())
def release_layout(self, request, pk=None):
"""
发布环境
"""
if not pk or pk == "undefined":
return JsonResponse(R.build(msg="环境不存在"))
user = request.user
if not user.is_superuser:
return JsonResponse(R.build(msg="权限不足"))
layout_info = Layout.objects.filter(layout_id=pk).first()
if not layout_info:
return JsonResponse(R.build(msg="环境不存在"))
layout_info.is_release = True
layout_info.save()
return JsonResponse(R.ok())
def get_task(self, request, pk=None):
task_info = self.get_object()
task_msg = task_info.task_msg
if task_info.task_status == 1:
return JsonResponse(
R.running(msg="执行中", data=str(task_info.task_id)))
task_info.is_show = True
task_info.save()
if task_msg:
msg = json.loads(task_msg)
if msg["status"] == 200:
return JsonResponse(msg, status=200)
else:
return JsonResponse(msg, status=msg["status"])
return JsonResponse(R.ok())
def create_container_task(container_vul, user_info, request_ip):
"""
创建漏洞容器
:param container_vul: container vul
:param user_info: user info
:param request_ip: request ip
:return:
"""
image_info = container_vul.image_id
user_id = user_info.id
task_id = create_run_container_task(container_vul, user_info)
if user_info.is_superuser or user_id == container_vul.user_id:
operation_args = ImageInfoSerializer(image_info).data
sys_log = SysLog(user_id=user_id, operation_type="容器", operation_name="启动", ip=request_ip,
operation_value=operation_args["image_vul_name"], operation_args=json.dumps(operation_args))
sys_log.save()
setting_config = get_setting_config()
try:
countdown = int(setting_config["time"])
except:
countdown = int(DEFAULT_CONFIG["time"])
if countdown == 0:
run_container.delay(container_vul.container_id, user_id, task_id, countdown)
elif countdown != 0 and countdown > 60:
# run_container(container_vul.container_id, user_id, task_id, countdown)
setting_config = get_setting_config()
if 'del_container' in setting_config:
del_container = setting_config['del_container']
if not del_container or del_container == 0 or del_container == '0':
add_chain_sig = chain(run_container.s(container_vul.container_id, user_id, task_id, countdown) |
stop_container.s().set(countdown=countdown))
else:
add_chain_sig = chain(run_container.s(container_vul.container_id, user_id, task_id, countdown) |
delete_container.s().set(countdown=countdown))
add_chain_sig.apply_async()
else:
task_info = TaskInfo.objects.filter(task_id=task_id).first()
task_info.task_msg = json.dumps(R.build(msg="停止时间最小为 1 分钟"))
task_info.task_status = 4
task_info.update_date = timezone.now()
task_info.save()
else:
task_info = TaskInfo.objects.filter(task_id=task_id).first()
task_info.task_msg = json.dumps(R.build(msg="权限不足"))
task_info.task_status = 3
task_info.update_date = timezone.now()
task_info.save()
return task_id
def create_run_container_task(container_vul, user_info):
"""
创建运行容器任务
:param container_vul: 漏洞容器对象
:param user_info: 用户信息
"""
image_info = container_vul.image_id
image_name = image_info.image_name
image_port = image_info.image_port
user_id = user_info.id
args = {
"image_name": image_name,
"user_id": user_id,
"image_port": image_port
}
task_info = None
if container_vul.container_status == "running":
vul_port = container_vul.vul_port
vul_host = container_vul.vul_host
task_msg = R.ok(data={"host": vul_host, "port": vul_port, "id": str(container_vul.container_id)})
task_info = TaskInfo.objects.filter(operation_args=json.dumps(args), task_msg=json.dumps(task_msg),
operation_type=2, task_name="运行容器：" + image_name, user_id=user_id).first()
if not task_info:
task_info = TaskInfo.objects.filter(operation_args=json.dumps(args), task_msg="", task_status=1, user_id=user_id,
operation_type=2, task_name="运行容器：" + image_name).first()
if not task_info:
task_info = TaskInfo(task_name="运行容器：" + image_name, user_id=user_id, task_status=1,
operation_type=2, operation_args=json.dumps(args), task_msg="", create_date=timezone.now(),
update_date=timezone.now())
task_info.save()
return str(task_info.task_id)
def delete_container_task(container_vul, user_info, request_ip):
"""
删除漏洞容器
:param container_vul: container vul
:param user_info: user info
:param request_ip: request ip
:return:
"""
user_id = user_info.id
task_id = create_delete_container_task(container_vul=container_vul,
user_info=user_info)
if user_info.is_superuser or user_id == container_vul.user_id:
operation_args = ContainerVulSerializer(container_vul).data
sys_log = SysLog(user_id=user_id,
operation_type="容器",
operation_name="删除",
ip=request_ip,
operation_value=operation_args["vul_name"],
operation_args=json.dumps(operation_args))
sys_log.save()
# 下发停止容器任务
delete_container.delay(task_id)
else:
task_info = TaskInfo.objects.filter(task_id=task_id).first()
task_info.task_msg = json.dumps(R.build(msg="权限不足"))
task_info.task_status = 3
task_info.update_date = timezone.now()
task_info.save()
return task_id
def create(self, request, *args, **kwargs):
user = request.user
if not user.is_superuser:
return JsonResponse(R.build(msg="权限不足"))
now_time = datetime.datetime.now()
data = request.data
notice_data = data['notice_content']
title = data["title"]
if not notice_data:
return JsonResponse({"code": 400, "message": "公告内容不能为空"})
if not title:
return JsonResponse({"code": 400, "message": "公告标题不能为空"})
if "update_notice" in data and data["update_notice"] == True:
notice_id = data['notice_id']
update_noticeinfo = Notice.objects.filter(notice_id=notice_id,
is_public=False).first()
update_noticeinfo.update_date = now_time
update_noticeinfo.notice_content = json.dumps(notice_data)
update_noticeinfo.title = title
update_noticeinfo.save()
return JsonResponse({"code": 200, "msg": "公告修改成功"})
else:
notice_info = Notice(notice_id=str(uuid.uuid4()),
title=title,
notice_content=json.dumps(notice_data),
create_date=now_time)
notice_info.save()
return JsonResponse({"code": 200, "msg": "提交成功"})
def rank_layout(self, request, pk=None):
"""
排行
"""
user = request.user
page_no = int(request.GET.get("page", 1))
if not pk or pk == "undefined":
return JsonResponse(R.build(msg="环境不存在"))
layout_info = Layout.objects.filter(layout_id=pk, is_release=True).first()
if not layout_info:
return JsonResponse(R.build(msg="环境不存在"))
score_list = LayoutServiceContainerScore.objects.filter(layout_id=layout_info).values('user_id').annotate(
score=Sum("image_id__rank")).values('user_id', 'score').order_by("-score")
try:
pages = Paginator(score_list, 20)
page = pages.page(page_no)
except Exception as e:
return JsonResponse(R.err())
current_rank = 0
current_score = 0
for i, _score in enumerate(score_list):
user_id = _score["user_id"]
if user.id != user_id:
continue
current_rank = i + 1
current_score = _score["score"]
break
layout_path = os.path.join(DOCKER_COMPOSE, str(layout_info.layout_id))
layout_data = LayoutData.objects.filter(layout_id=layout_info,
file_path="docker-compose" + layout_path.replace(DOCKER_COMPOSE,
""), ).first()
score_count = LayoutServiceContainerScore.objects.filter(layout_id=layout_info, user_id=user.id).count()
score_total_count = LayoutServiceContainer.objects.filter(layout_user_id=layout_data).count()
result = []
for _data in list(page):
user_info = UserProfile.objects.filter(id=_data["user_id"]).first()
username = ""
if user_info:
username = user_info.username
result.append({"score": _data["score"], "username": username})
return JsonResponse({
"result": result,
"count": pages.count,
"current": current_rank,
"progress": "%s/%s" % (score_count, score_total_count,),
"score": current_score
})
def get_layout_batch(self, request, pk=None):
task_id_str = request.POST.get("task_ids", "")
task_id_list = task_id_str.split(",")
task_list = TaskInfo.objects.filter(task_id__in=task_id_list)
result = {}
for task_info in task_list:
args = task_info.operation_args
args_info = json.loads(args)
layout_name = args_info["layout_name"]
image_list = []
# 查询出该编排环境中的所有进行下载任务
progress = 0.0
status = 1
relative_task_all = TaskInfo.objects.filter(
operation_type=8,
user_id=request.user.id,
operation_args__contains=json.dumps(layout_name),
task_status=1)
for single_task in relative_task_all:
task_log = r.get(str(single_task.task_id))
if task_log:
try:
task_log_json = json.loads(task_log)
current_progress = task_log_json["progress"]
progress += current_progress
except Exception as e:
pass
layout_info = Layout.objects.filter(
layout_name=layout_name).first()
if layout_info:
yml_data = yaml.load(layout_info.yml_content,
Loader=yaml.Loader)
services = yml_data["services"]
for service in services:
image_name = services[service]["image"]
image_list.append(image_name)
count = len(image_list)
not_download = 0
for image in image_list:
try:
current_image = client.images.get(image)
if current_image:
count -= 1
if count == 0:
status = 2
except Exception as e:
not_download += 1
if not_download != 0:
result[str(task_info.task_id)] = {
"progress": float(progress / not_download),
"status": status
}
else:
result[str(task_info.task_id)] = {
"progress": 100.0,
"status": 2
}
return JsonResponse(R.ok(data=result))
def get_task(self, request, pk=None):
task_info = self.get_object()
task_msg = task_info.task_msg
if task_info.task_status == 1:
return JsonResponse(
R.running(msg="执行中", data=str(task_info.task_id)))
task_info.is_show = True
task_info.save()
if task_msg:
msg = json.loads(task_msg)
if msg["status"] == 200:
if not msg["data"]:
msg["data"] = {"_now": int(timezone.now().timestamp())}
else:
msg["data"]["_now"] = int(timezone.now().timestamp())
return JsonResponse(msg, status=200)
else:
return JsonResponse(msg, status=msg["status"])
return JsonResponse(R.ok())
def get(self, request):
page_no = int(request.GET.get("page", 1))
score_list = ContainerVul.objects.filter(
is_check=True, time_model_id='').values('user_id').annotate(
score=Sum("image_id__rank")).values('user_id',
'score').order_by("-score")
try:
pages = Paginator(score_list, 20)
page = pages.page(page_no)
except Exception as e:
return JsonResponse(R.err())
result = []
for _data in list(page):
user_info = UserProfile.objects.filter(id=_data["user_id"]).first()
username = ""
if user_info:
username = user_info.username
result.append({"rank": _data["score"], "name": username})
data = {'results': result, 'count': len(score_list)}
return JsonResponse(R.ok(data=data))
def get_batch_task(self, request, pk=None):
task_id_str = request.POST.get("task_ids", "")
task_id_list = task_id_str.split(",")
task_list = TaskInfo.objects.filter(task_id__in=task_id_list)
result = {}
for task_info in task_list:
result[str(task_info.task_id)] = {
"status": task_info.task_status,
"data": json.loads(task_info.task_msg)
}
return JsonResponse(R.ok(data=result))
def upload_img(request):
"""
上传文件图片
"""
user = request.user
if not user.is_superuser:
return JsonResponse(R.build(msg="权限不足"))
img = request.data["img"]
if not img:
return JsonResponse(R.build(msg="请上传图片"))
img_name = img.name
img_suffix = img_name.split(".")[-1]
if img_suffix not in ALLOWED_IMG_SUFFIX:
return JsonResponse(
R.build(msg="不支持此格式图片文件，请上传%s格式文件" %
("、".join(ALLOWED_IMG_SUFFIX), )))
image_name = str(uuid.uuid4()).replace('-', '') + "." + img_suffix
with open(os.path.join(BASE_DIR, "static", image_name), "wb") as f:
for chunk in img.chunks():
f.write(chunk)
return JsonResponse(R.ok(data=image_name))
def get_task_progress(self, request, pk=None):
task_info = self.get_object()
task_id = task_info.task_id
task_log = r.get(str(task_id))
if task_log:
task_log_json = json.loads(task_log)
data = {
"total": task_log_json["total"],
"progress_count": task_log_json["progress_count"],
"progress": task_log_json["progress"],
"layer": []
}
black_list = ["total", "progress_count", "progress"]
layer_list = []
for key in task_log_json:
if key in black_list:
continue
layer_list.append(task_log_json[key])
data["layer"] = layer_list
return JsonResponse(R.ok(data=data))
else:
return JsonResponse(R.ok())
def docker_container_run(docker_container, command=""):
"""
docker 容器启动
:param docker_container: docker 容器对象
:param command: 执行命令,默认为空不执行命令
"""
container_status = str(docker_container.status)
for i in range(DOCKER_CONTAINER_TIME):
docker_container.reload()
container_status = str(docker_container.status)
if 'running' == container_status:
if command:
docker_container.exec_run(command)
break
elif 'exited' == container_status:
pass
time.sleep(1)
data = {"status": container_status}
if "running" != container_status:
return R.err(data=data, msg="漏洞容器启动失败")
else:
return R.ok(data)
def stop_layout(self, request, pk=None):
if not pk or pk == "undefined":
return JsonResponse(R.build(msg="环境不存在"))
user = request.user
if not user.is_superuser:
return JsonResponse(R.build(msg="权限不足"))
layout_info = Layout.objects.filter(layout_id=pk,
is_release=True).first()
if not layout_info:
return JsonResponse(R.build(msg="环境不存在或未发布"))
layout_id = str(layout_info.layout_id)
layout_path = os.path.join(DOCKER_COMPOSE, layout_id)
layout_data = LayoutData.objects.filter(
layout_id=layout_info,
file_path="docker-compose" +
layout_path.replace(DOCKER_COMPOSE, ""),
).first()
if not layout_data:
return JsonResponse(R.build(msg="环境未启动，无法停止"))
if not os.path.exists(layout_path):
return JsonResponse(R.ok())
if layout_data.status == "stop":
return JsonResponse(R.ok())
try:
with transaction.atomic():
container_list = get_project(layout_path).stop()
if container_list:
for container in container_list:
container_id = container.id
LayoutServiceContainer.objects.filter(docker_container_id=container_id) \
.update(container_status="stop")
LayoutServiceContainer.objects.filter(
layout_user_id=layout_data).update(container_status="stop")
layout_data.status = "stop"
layout_data.save()
except Exception as e:
return JsonResponse(R.err())
request_ip = get_request_ip(request)
sys_log = SysLog(user_id=user.id,
operation_type="编排环境",
operation_name="停止",
operation_value=layout_info.layout_name,
operation_args=json.dumps(
LayoutSerializer(layout_info).data),
ip=request_ip)
sys_log.save()
return JsonResponse(R.ok())
def publish_notice(request):
user = request.user
if not user.is_superuser:
return JsonResponse(R.build("权限不足"))
if "id" in request.data:
try:
notice_info = Notice.objects.filter(notice_id=request.data["id"]).first()
notice_info.is_public = True
notice_info.is_newest = True
notice_info.save()
notify.send(request.user,
recipient=UserProfile.objects.all(),
verb="public notice", target=notice_info)
return JsonResponse({"code": 200, "message": "发布成功"})
except Exception as e:
return JsonResponse({"code": 400, "message": "发布失败"})
return JsonResponse({"code": 400, "message": "发布失败"})
def delete_image(self, request, pk=None):
user = request.user
if not pk or pk == "undefined":
return JsonResponse(R.build(msg="环境不存在"))
if not user.is_superuser:
return JsonResponse(R.build(msg="权限不足"))
try:
layout = Layout.objects.filter(layout_id=pk).first()
if not layout:
return JsonResponse(R.build(msg="环境不存在"))
layout_name = layout.layout_name
layout_id = str(layout.layout_id)
layout_path = os.path.join(DOCKER_COMPOSE, layout_id)
with transaction.atomic():
_tmp_file_path = "docker-compose" + layout_path.replace(
DOCKER_COMPOSE, "")
layout_data = LayoutData.objects.filter(
layout_id=layout, file_path=_tmp_file_path).first()
if layout_data and layout_data.status == 'running':
return JsonResponse(R.build(msg="环境正在运行中，请首先停止运行"))
# 删除分数
LayoutServiceContainerScore.objects.filter(
layout_id=layout).delete()
# 删除容器
if layout_data:
LayoutServiceContainer.objects.filter(
layout_user_id=layout_data)
# 删除服务网卡
service_list = LayoutService.objects.filter(layout_id=layout)
if len(service_list) > 0:
for service in service_list:
# service_id = service.service_id
LayoutServiceNetwork.objects.filter(
service_id=service).delete()
# 删除服务
LayoutService.objects.filter(layout_id=layout).delete()
# 删除内容
layout.delete()
# 删除文件和文件夹
shutil.rmtree(layout_path)
request_ip = get_request_ip(request)
sys_log = SysLog(user_id=user.id,
operation_type="编排环境",
operation_name="删除",
operation_value=layout_name,
operation_args=json.dumps(
LayoutSerializer(layout).data),
ip=request_ip)
sys_log.save()
except Exception as e:
traceback.print_exc()
return JsonResponse(R.err())
return JsonResponse(R.ok())
def destroy(self, request, *args, **kwargs):
user = request.user
if not user.is_superuser:
return JsonResponse(R.build("权限不足"))
if "id" in request.data:
notice_id = request.data["id"]
else:
notice = self.get_object()
notice_id = notice.notice_id
if notice_id:
notice_instance = Notice.objects.filter(notice_id=notice_id).first()
notice_instance.delete()
notifications = Notification.objects.all()
for single_notification in notifications:
if single_notification.target_object_id ==notice_id:
single_notification.delete()
return JsonResponse({"code": 200, "message": "删除成功"})
return JsonResponse({"code": 400, "message": "删除失败"})
def flag_layout(self, request, pk=None):
if not pk or pk == "undefined":
return JsonResponse(R.build(msg="环境不存在"))
user = request.user
layout_info = Layout.objects.filter(layout_id=pk,
is_release=True).first()
if not layout_info:
return JsonResponse(R.build(msg="环境不存在或未发布"))
flag = str(request.GET.get("flag", ""))
if not flag:
return JsonResponse(R.build(msg="Flag 不能为空"))
if not flag.startswith("flag-{bmh"):
return JsonResponse(R.build(msg="Flag 格式不正确"))
layout_path = os.path.join(DOCKER_COMPOSE, str(layout_info.layout_id))
layout_data = LayoutData.objects.filter(
layout_id=layout_info,
file_path="docker-compose" +
layout_path.replace(DOCKER_COMPOSE, ""),
).first()
service_container = LayoutServiceContainer.objects.filter(
layout_user_id=layout_data, container_flag=flag).first()
if not service_container:
return JsonResponse(R.build(msg="Flag 不正确"))
service_container_score = LayoutServiceContainerScore.objects.filter(
user_id=user.id, flag=flag,
service_container_id=service_container).first()
if not service_container_score:
service_info = service_container.service_id
image_info = service_container.image_id
service_container_score = LayoutServiceContainerScore(
layout_service_container_score_id=uuid.uuid4(),
user_id=user.id,
layout_id=layout_info,
layout_data_id=layout_data,
service_id=service_info,
image_id=image_info,
create_date=timezone.now(),
service_container_id=service_container,
flag=flag,
update_date=timezone.now())
service_container_score.save()
request_ip = get_request_ip(request)
sys_log = SysLog(user_id=user.id,
operation_type="编排环境",
operation_name="提交Flag",
operation_value=layout_info.layout_name,
operation_args=json.dumps({"flag": flag}),
ip=request_ip)
sys_log.save()
return JsonResponse(R.ok())
def get_queryset(self):
user = self.request.user
if not user.is_superuser:
return JsonResponse(R.build("权限不足"))
query = self.request.GET.get("query", "")
if query:
query = query.strip()
seven_days_ago = datetime.datetime.now()-datetime.timedelta(days=7)
nots = Notice.objects.filter(title__contains=query).all()
for single_not in nots:
if single_not.update_date < seven_days_ago:
single_not.is_newest = False
return nots
else:
seven_days_ago = datetime.datetime.now() - datetime.timedelta(days=7)
nots = Notice.objects.all()
for single_not in nots:
if single_not.update_date < seven_days_ago:
single_not.is_newest = False
return nots
def get_public_notice(request):
notifications = Notification.objects.filter(recipient=request.user)
notices = []
for single_notification in notifications:
if single_notification.target_object_id:
notice = Notice.objects.filter(notice_id=single_notification.target_object_id).first()
if notice:
notices.append(notice)
notices.sort(key=lambda item: item.update_date,reverse=True)
page_no = int(request.GET.get("page", "1"))
pages = Paginator(notices, 20)
page = pages.page(page_no)
results = []
for _data in page:
results.append(_data)
data = {
"results": NoticeInfoSerializer(results, many=True, context={'request': request}).data,
"count": len(notices)
}
return JsonResponse(R.ok(data=data))
