def check_create(self, task):
using_status = Env.ActiveStatusList
# 当前题目使用的环境
using_task_envs = task.envs.filter(env__status__in=using_status)
# 检查是否已创建环境
if using_task_envs.filter(**self.group_filter_params).exists():
raise MsgException(error.TASK_ENV_EXIST)
# 检查环境数量是否已满
using_envs = Env.objects.filter(status__in=using_status)
if using_envs.count(
) >= self.base_handler.creater_class.get_all_env_limit():
raise MsgException(error.FULL_ENV_CAPACITY)
def get_env(self, template_env):
test_env_map = self.get_test_env_map(template_env)
if not test_env_map or not test_env_map.test_env or \
test_env_map.test_env.status not in Env.ActiveStatusList:
raise MsgException(error.TEST_ENV_NOT_EXIST)
return test_env_map.test_env
def _run_script(self, client, cmd):
cmd = cmd.encode('utf-8')
stdin, stdout, stderr = client.exe(cmd)
err = stderr.readlines()
if err:
raise MsgException("%s %s" % (error.RUN_SCRIPT_ERROR, err))
def _check_task(self, task, envterminal):
# checker_path = self._get_checker_script_path(task, envterminal)
# if checker_path is None or not os.path.exists(checker_path):
# raise MsgException(error.CHECK_SCRIPT_PATH_NULL)
#
# try:
# script_module = imp.load_source('xctf_checker_script', checker_path)
# result = script_module.checker(envterminal.float_ip, self.get_env_service_port(envterminal))
# except Exception, e:
# raise e
# return result
task_env = self.get_task_env(task)
docker_envterminal = task_env.env.envterminal_set.filter(
sub_id=envterminal.checker).first()
if not envterminal:
raise MsgException(error.ENVTERMINAL_NOT_EXIST)
try:
# 上传checker文件到checker机器上
self._upload_checker_file(task, envterminal, docker_envterminal)
# rpc调用checker
result = checker(docker_envterminal.float_ip, "/home/checker.py",
envterminal.float_ip,
self.get_env_service_port(envterminal))
except Exception as e:
logger.info("check error msg[%s]", str(e))
return None
return result
def get_task_env(self, task, raise_exception=True):
using_task_envs = task.envs.filter(
env__status__in=Env.ActiveStatusList)
task_env = using_task_envs.filter(**self.group_filter_params).first()
if raise_exception and not task_env:
raise MsgException(error.TASK_ENV_NOT_EXIST)
return task_env
def get_lesson_env(self, lesson):
template_lesson_env = self.get_template_lesson_env(lesson)
using_lesson_envs = lesson.envs.filter(
env__status__in=Env.ActiveStatusList)
# 由于页面没有配置小组环境，没有小组模板环境，显式查询是否有小组环境
lesson_env = using_lesson_envs.filter(type=LessonEnv.Type.GROUP,
group_users=self.user).first()
if lesson_env:
return lesson_env
using_lesson_envs = using_lesson_envs.filter(
type=template_lesson_env.type)
if template_lesson_env.type == LessonEnv.Type.PRIVATE:
lesson_env = using_lesson_envs.filter(
**self.group_filter_params).first()
else:
lesson_env = using_lesson_envs.filter(
shared_users=self.user).first()
if not lesson_env:
raise MsgException(error.LESSON_ENV_NOT_EXIST)
return lesson_env
def check_create(self, template_env):
using_status = Env.ActiveStatusList
test_env_map = self.get_test_env_map(template_env)
# 检查自己环境是否已存在
if test_env_map and test_env_map.test_env and test_env_map.test_env.status in using_status:
raise MsgException(error.TEST_ENV_EXIST)
# 检查环境数量是否已满
using_envs = Env.objects.filter(status__in=using_status)
if using_envs.count() >= self.base_handler.creater_class.get_all_env_limit():
raise MsgException(error.FULL_ENV_CAPACITY)
# 检查自己环境数量是否已满
my_using_envs = using_envs.filter(user=self.user)
if my_using_envs.count() >= self.base_handler.creater_class.get_person_env_limit():
raise MsgException(error.FULL_PERSONAL_ENV_CAPACITY)
return test_env_map
def execute_script(self, task, envterminal_sub_id, mode):
if not self.base_handler.is_admin:
raise MsgException(error.NO_PERMISSION)
mode_exec = {
2: self._init_task,
3: self._clean_task,
4: self._push_flag,
5: self._check_task,
}
if mode not in mode_exec:
raise MsgException(error.NO_PERMISSION)
task_env = self.get_task_env(task)
envterminal = task_env.env.envterminal_set.filter(
sub_id=envterminal_sub_id).first()
if not envterminal:
raise MsgException(error.ENVTERMINAL_NOT_EXIST)
return mode_exec[mode](task, envterminal)
def delay(self, task):
task_env = self.get_task_env(task)
if task_env.env.status not in Env.UsingStatusList or not task_env.destroy_time:
raise MsgException(error.NO_PERMISSION)
left_time = datetime.timedelta(minutes=15)
delay_time = datetime.timedelta(hours=1)
# only fewer than 15 minites can delay
if task_env.destroy_time < timezone.now() or task_env.destroy_time > timezone.now() + left_time:
raise MsgException(error.NO_PERMISSION)
task_env.destroy_time = task_env.destroy_time + delay_time
try:
task_env.save()
except Exception as e:
logger.error('delay taskenv[env_id=%s] error: %s', task_env.id, e)
raise e
return task_env
def get_task_env(self, task):
template_task_env = self.get_template_task_env(task)
using_task_envs = task.envs.filter(type=template_task_env.type, env__status__in=Env.ActiveStatusList)
if template_task_env.type == TaskEnv.Type.PRIVATE:
task_env = using_task_envs.filter(**self.group_filter_params).first()
else:
task_env = using_task_envs.filter(shared_users=self.user).first()
if not task_env:
raise MsgException(error.TASK_ENV_NOT_EXIST)
return task_env
def check_create(self, task):
template_task_env = self.get_template_task_env(task)
using_status = Env.ActiveStatusList
# 当前环境类型使用的环境
using_type_task_envs = task.envs.filter(type=template_task_env.type, env__status__in=using_status)
# 所有正在使用的场景
using_envs = Env.objects.filter(status__in=using_status)
if template_task_env.type == TaskEnv.Type.PRIVATE:
# 检查是否已存在私有环境
if using_type_task_envs.filter(**self.group_filter_params).exists():
raise MsgException(error.TASK_ENV_EXIST)
# 检查总体环境数量是否已满
if using_envs.count() >= self.base_handler.creater_class.get_all_env_limit():
raise MsgException(error.FULL_ENV_CAPACITY)
if not self.team:
# 检查个人环境数量是否已满
my_using_envs = using_envs.filter(user=self.user)
# 由于共享环境/队伍环境存在，需排除所有共享环境/队伍环境
if my_using_envs.count() - self.base_handler.creater_class.get_ignored_using_env_count(self.user) >= self.base_handler.creater_class.get_person_env_limit():
raise MsgException(error.FULL_PERSONAL_ENV_CAPACITY)
elif template_task_env.type == TaskEnv.Type.SHARED:
# 检查是否已存在共享给自己的环境
if using_type_task_envs.filter(shared_users=self.user).exists():
raise MsgException(error.TASK_ENV_EXIST)
# 如果已存在未共享给自己的共享环境, 由于只会添加共享引用不会创建场景, 所以不需要检查数量限制
task_env = using_type_task_envs.first()
if task_env:
# 直接返回无需创建的存在的共享环境
return template_task_env, task_env
else:
# 检查环境数量是否已满
if using_envs.count() >= self.base_handler.creater_class.get_all_env_limit():
raise MsgException(error.FULL_ENV_CAPACITY)
# 共享环境不检查个人环境数量是否已满
else:
raise MsgException(error.NO_PERMISSION)
return template_task_env, None
def get_template_task_env(self, task):
template_task_env = task.envs.filter(
env__status=Env.Status.TEMPLATE).first()
if not template_task_env:
raise MsgException(error.TASK_ENV_NOT_CONFIGURED)
return template_task_env
def get_template_lesson_env(self, lesson):
template_lesson_env = lesson.envs.filter(
env__status=Env.Status.TEMPLATE).first()
if not template_lesson_env:
raise MsgException(error.LESSON_ENV_NOT_CONFIGURED)
return template_lesson_env
def _check_team(self):
# 不检查管理员
if self.team and not self.base_handler.is_admin:
if self.user.team != self.team:
raise MsgException(error.NO_PERMISSION)