(wip) dump

packages/api-server/src/services/submission.services.ts

@@ -5,7 +5,7 @@ import {
   SubmissionStatus,
   type Submission,
   type Problem
-} from '@argoncs/types'
+} from '@argoncs/types' /*=*/
 import { rabbitMQ, judgerExchange, judgerTasksKey, submissionCollection, fetchDomainProblem, fetchContestProblem } from '@argoncs/common'
 import { languageConfigs } from '../../configs/language.configs.js'
 
@@ -45,6 +45,7 @@ async function createSubmission ({ submission, userId, target }: { submission: N
 
   const task: CompilingTask = {
     submissionId,
+    problemId: problem.id,
     type: JudgerTaskType.Compiling,
     source: submission.source,
     language: submission.language,

packages/judge-daemon/src/services/compile.services.ts

@@ -7,27 +7,29 @@ import { type CompilingTask, SandboxStatus, type CompileSucceeded, type CompileF
 import { minio } from '@argoncs/common'
 import { languageConfigs } from '../../configs/language.configs.js'
 
-//=
+/*=*/
+
 export async function compileSubmission ({ task, boxId }: { task: CompilingTask, boxId: number }): Promise<CompileSucceeded | CompileFailed> {
   const workDir = `/var/local/lib/isolate/${boxId}/box`
   const config = languageConfigs[task.language]
   const srcPath = path.join(workDir, config.srcFile)
   const binaryPath = path.join(workDir, config.binaryFile)
   const logPath = path.join(workDir, 'log.txt')
   await fs.writeFile(srcPath, task.source)
-  let command = config.compileCommand
-  command = command.replaceAll('{src_path}', config.srcFile)
-  command = command.replaceAll('{binary_path}', config.binaryFile)
+
+  const command = config.compileCommand
+    .replaceAll('{src_path}', config.srcFile)
+    .replaceAll('{binary_path}', config.binaryFile)
 
   console.log('command:', command);
-  console.log(workDir, config, srcPath, binaryPath, logPath);
+  console.log(workDir, config, srcPath, binaryPath);
 
   const result = await runInSandbox(
     {
       task: {
         constraints: task.constraints,
         command,
-        stderrPath: 'log.txt',
+        stderrPath: logPath,
         env: 'PATH=/bin:/usr/local/bin:/usr/bin'
       },
       boxId
@@ -47,3 +49,39 @@ export async function compileSubmission ({ task, boxId }: { task: CompilingTask,
     }
   }
 }
+
+export async function compileChecker ({ task, boxId }: { task: CompilingTask, boxId: number }): Promise<CompileSucceeded | CompileFailed> {
+
+  const workDir = `/var/local/lib/isolate/${boxId}/box`
+  const srcPath = path.join(workDir, 'checker.cpp')
+  const binaryPath = path.join(workDir, 'checker')
+  const logPath = path.join(workDir, 'checker-log.txt')
+  await fetchCheckerSource(srcPath);
+
+  const command = '/usr/bin/g++ -o2 -w -fmax-errors=3 -std=c++17 checker.cpp -lm -o checker' 
+
+  console.log('command:', command);
+  console.log(workDir, srcPath, binaryPath);
+
+  const result = await runInSandbox(
+    {
+      task: {
+        constraints: {},
+        command,
+        stderrPath: logPath,
+        env: 'PATH=/bin:/usr/local/bin:/usr/bin'
+      },
+      boxId
+    })
+
+  console.log('compiled')
+  if (result.status !== SandboxStatus.Succeeded) {
+    return {
+      status: CompilingStatus.Failed,
+      log: (await fs.readFile(logPath)).toString()
+    }
+  }
+
+  await minio.fPutObject('checkers', task.problemId, binaryPath)
+  return { status: CompilingStatus.Succeeded }
+}

packages/judge-daemon/src/services/grading.services.ts

@@ -10,6 +10,7 @@ import {
 } from './sandbox.services.js'
 
 import { fetchBinary, fetchTestcase } from './storage.services.js'
+import {NotFoundError} from 'http-errors-enhanced'
 
 export async function gradeSubmission ({ task, boxId }: { task: GradingTask, boxId: number }): Promise<GradingResult> {
 
@@ -18,11 +19,16 @@ export async function gradeSubmission ({ task, boxId }: { task: GradingTask, box
   const binaryPath = path.join(workDir, config.binaryFile)
   const inputPath = path.join(workDir, 'in.txt')
   const answerPath = path.join(workDir, 'ans.txt')
+  const checkerPath = path.join(workDir, 'checker');
 
   await fetchBinary({ objectName: task.submissionId, destPath: binaryPath })
   await fetchTestcase({ objectName: task.testcase.input.objectName, versionId: task.testcase.input.versionId, destPath: inputPath })
   await fetchTestcase({ objectName: task.testcase.output.objectName, versionId: task.testcase.output.versionId, destPath: answerPath })
   await makeExecutable(path.join(workDir, config.binaryFile))
+  await fetchChecker({
+    objectName: task.checker.objectName,
+    versionId: task.checker.versionId,
+    destPath: checkerPath })
 
   let command = config.executeCommand
   command = command.replaceAll('{binary_path}', config.binaryFile)
@@ -38,6 +44,7 @@ export async function gradeSubmission ({ task, boxId }: { task: GradingTask, box
       },
       boxId
     })
+
   //return  new Promise((resolve, reject) => resolve({ message: '', status: GradingStatus.Accepted, memory: 1, time: 1, wallTime: 1}));
 
   if (sandboxResult.status === SandboxStatus.Succeeded) {

packages/judge-daemon/src/start.ts

@@ -74,16 +74,13 @@ export async function startJudger (): Promise<void> {
             submissionId: task.submissionId,
             testcaseIndex: task.testcaseIndex
           }
-          // send grade message
         } else if (task.type === JudgerTaskType.Compiling) {
           console.log('compiling')
           result = {
             type: JudgerResultType.Compiling,
             result: (await compileSubmission({ task, boxId })),
             submissionId: task.submissionId
           }
-
-          // send grade message
         } else {
           throw Error('Invalid task type')
         }

packages/result-handler/src/services/result.services.ts

@@ -1,5 +1,5 @@
 import { fetchContestProblem, fetchDomainProblem, fetchSubmission, judgerExchange, judgerTasksKey, rabbitMQ, ranklistRedis, recalculateTeamTotalScore, submissionCollection, teamScoreCollection } from '@argoncs/common'
-import { type CompilingResult, CompilingStatus, type GradingResult, GradingStatus, type GradingTask, JudgerTaskType, type Problem, SubmissionStatus } from '@argoncs/types'
+import { type CompilingResult, CompilingStatus, type GradingResult, GradingStatus, type GradingTask, JudgerTaskType, type Problem, SubmissionStatus } from '@argoncs/types' /*=*/
 import { NotFoundError } from 'http-errors-enhanced'
 import path from 'path'
 

packages/types/src/types/compilation.types.ts

@@ -50,3 +50,9 @@ export interface CompilingResultMessage {
   submissionId: string
   result: CompilingResult
 }
+
+export interface CheckerCompileTask {
+  type: JudgerTaskType.CheckerCompile,
+  source: string,
+  problemId: string,
+}