copy template files when creating lab instance

Author: zdszero

judge/languages.py

@@ -225,8 +225,7 @@
 }
 
 languages = [
-    {"config": _c_lang_config, "spj": 
-     {"compile": _c_lang_spj_compile, "config": _c_lang_spj_config},
+    {"config": _c_lang_config, "spj": {"compile": _c_lang_spj_compile, "config": _c_lang_spj_config},
      "name": "C", "description": "GCC 9.4", "content_type": "text/x-csrc"},
     {"config": _cpp_lang_config, "spj": {"compile": _cpp_lang_spj_compile, "config": _cpp_lang_spj_config},
      "name": "C++", "description": "G++ 9.4", "content_type": "text/x-c++src"},

judge/testing.py

@@ -1,3 +1,4 @@
+import json
 import zipfile
 import os
 import shutil
@@ -7,22 +8,32 @@
 
 from onl.settings import DATA_DIR
 from problem.models import Problem
-from submission.models import Submission
+from submission.models import JudgeStatus, Submission
 
 
 PROBLEM_DIR = "problems"
 SUBMISSION_DIR = "submissions"
 ZIPFILE_DIR = "zips"
 
+TESTCASE_NAME = "testcases.json"
+TESTER_NAME = "tester"
+
+def create_new_problem_from_template(new_problem_id: str, old_problem_id: str):
+    old_path = PathManager.problem_dir(old_problem_id)
+    new_path = PathManager.problem_dir(new_problem_id)
+    os.makedirs(new_path, exist_ok=True)
+    for filename in os.listdir(old_path):
+        shutil.copyfile(join(old_path, filename), join(new_path, filename))
+    print(f'create problem instance {new_path}')
 
 class PathManager:
     @staticmethod
     def problem_dir(problem_id: str) -> str:
         return join(DATA_DIR, PROBLEM_DIR, problem_id)
 
     @staticmethod
-    def submission_dir(submission_id: str) -> str:
-        return join(DATA_DIR, SUBMISSION_DIR, submission_id)
+    def submission_dir(user_id: str, submission_id: str) -> str:
+        return join(DATA_DIR, SUBMISSION_DIR, user_id, submission_id)
 
     @staticmethod
     def zipfile_path(problem_id: str, zipfile_name: str) -> str:
@@ -104,15 +115,58 @@ def upload(self) -> bool:
 
 
 class SubmissionTester:
-    def __init__(self, submit_id: str, problem_id: str):
-        self.submit_id = submit_id
-        self.problem_id = problem_id
-        self.submission_dir_path = PathManager.submission_dir(submit_id)
-        if not exists(self.submission_dir_path):
-            os.makedirs(self.submission_dir_path, exist_ok=True)
+    def __init__(self, submission: Submission):
+        self.sub = submission
+        self.sub_dirpath = PathManager.submission_dir(str(submission.user_id), submission.id)
+        if not exists(self.sub_dirpath):
+            os.makedirs(self.sub_dirpath, exist_ok=True)
+        prob_dir = PathManager.problem_dir(submission.problem._id) # use display id
+        if not exists(prob_dir):
+            raise Exception("problem dir {} not exists".format(prob_dir))
+        for filename in os.listdir(prob_dir):
+            shutil.copyfile(join(prob_dir, filename), self.sub_dirpath)
 
     def judge(self):
-        tester = join(self.submission_dir_path, "tester")
-        if not exists(tester):
-            raise Exception(f"running submission: tester {tester} not exists")
-        subprocess.run([tester, '--log', '--json'])
+        tester_path = join(self.sub_dirpath, TESTER_NAME)
+        if not exists(tester_path):
+            raise Exception("running submission: tester {} not exists".format(tester_path))
+        print(f"running {tester_path}")
+        subprocess.run([tester_path, '--log', '--json'])
+        log_path = join(self.sub_dirpath, 'logs')
+        if not exists(log_path):
+            raise Exception(f"logs path {log_path} not exists")
+        failed_info = []
+        with open(join(log_path, "results.txt")) as fp:
+            res = json.load(fp)
+            self.sub.grade = res['grade']
+            for idx in res['failed']:
+                log_fp = open(join(log_path, f"testcase{idx}.log"), "r")
+                testcase_fp = open(join(self.sub_dirpath, TESTCASE_NAME), "r")
+                testcase_json_data = json.load(testcase_fp)
+                if "config" in testcase_json_data:
+                    # global config
+                    config = testcase_json_data["config"]
+                else:
+                    cur_data = testcase_json_data["testcases"][idx] 
+                    if "config" in cur_data:
+                        # specific config for testcase
+                        config = ["config"]
+                    else:
+                        # no config
+                        config = None
+                displayed_test = {
+                    "input": testcase_json_data["testcases"][idx]["input"],
+                    "expected_output":testcase_json_data["testcases"][idx]["output"],
+                }
+                # config, "testcase"
+                failed_info.append({
+                    "config": config,
+                    "testcase_index": idx,
+                    "testcase": displayed_test,
+                    "log": log_fp.read()
+                })
+                log_fp.close()
+                testcase_fp.close()
+        self.sub.failed_info = failed_info
+        self.sub.result = JudgeStatus.FINISHED
+        self.sub.save()

problem/views/admin.py

@@ -10,7 +10,7 @@
 from utils.api import APIView, validate_serializer
 from utils.shortcuts import rand_str
 from utils.tasks import delete_files
-from judge.testing import ZipFileUploader
+from judge.testing import ZipFileUploader, create_new_problem_from_template
 
 from ..models import Problem, ProblemTag
 from ..serializers import *
@@ -300,7 +300,7 @@ def post(self, request):
         data = request.data
         try:
             contest = Contest.objects.get(id=data["contest_id"])
-            problem = Problem.objects.get(id=data["problem_id"])
+            old_problem = Problem.objects.get(id=data["problem_id"])
         except (Contest.DoesNotExist, Problem.DoesNotExist):
             return self.error("Contest or Problem does not exist")
         data["lab_id"] = data.pop("problem_id")
@@ -311,19 +311,22 @@ def post(self, request):
         if Problem.objects.filter(contest=contest, _id=data["display_id"]).exists():
             return self.error("Duplicate display id in this contest")
         if "title" not in data:
-            data["title"] = problem.title
+            data["title"] = old_problem.title
         if "description" not in data:
-            data["description"] = problem.description
+            data["description"] = old_problem.description
         data["visible"] = True
         data["is_public"] = True
-        data["code_num"] = problem.code_num
-        data["code_names"] = problem.code_names
+        data["code_num"] = old_problem.code_num
+        data["code_names"] = old_problem.code_names
 
-        tags = problem.tags.all()
+        tags = old_problem.tags.all()
         data["_id"] = data.pop("display_id")
         data["submission_number"] = data["accepted_number"] = 0
-        problem = Problem.objects.create(**data)
-        problem.tags.set(tags)
+        new_problem = Problem.objects.create(**data)
+        new_problem.tags.set(tags)
+
+        create_new_problem_from_template(new_problem._id, old_problem._id)
+
         return self.success()
 
 
@@ -334,7 +337,7 @@ def choose_answers(self, user, problem):
             submission = Submission.objects.filter(problem=problem,
                                                    user_id=user.id,
                                                    language=item,
-                                                   result=JudgeStatus.ACCEPTED).order_by("-create_time").first()
+                                                   result=JudgeStatus.FINISHED).order_by("-create_time").first()
             if submission:
                 ret.append({"language": submission.language, "code": submission.code})
         return ret