refactor : 예외 처리 강화 및 클래스 분리

src/main/java/org/ezcode/codetest/application/submission/dto/event/payload/InitTestcaseListPayload.java

@@ -3,7 +3,7 @@
 import java.util.List;
 import java.util.stream.IntStream;
 
-import org.ezcode.codetest.domain.problem.model.ProblemInfo;
+import org.ezcode.codetest.application.submission.model.SubmissionContext;
 import org.ezcode.codetest.domain.problem.model.entity.Testcase;
 
 public record InitTestcaseListPayload(
@@ -17,10 +17,10 @@ public record InitTestcaseListPayload(
     String status
 
 ) {
-    public static List<InitTestcaseListPayload> from(ProblemInfo info) {
-        return IntStream.rangeClosed(1, info.getTestcaseCount())
+    public static List<InitTestcaseListPayload> from(SubmissionContext ctx) {
+        return IntStream.rangeClosed(1, ctx.getTestcaseCount())
             .mapToObj(seq -> {
-                Testcase tc = info.testcaseList().get(seq - 1);
+                Testcase tc = ctx.getTestcases().get(seq - 1);
                 return new InitTestcaseListPayload(
                     seq,
                     tc.getInput(),

src/main/java/org/ezcode/codetest/application/submission/dto/event/payload/TestcaseResultPayload.java

@@ -1,7 +1,6 @@
 package org.ezcode.codetest.application.submission.dto.event.payload;
 
 import org.ezcode.codetest.application.submission.model.JudgeResult;
-import org.ezcode.codetest.domain.submission.dto.AnswerEvaluation;
 
 public record TestcaseResultPayload(
 
@@ -18,10 +17,10 @@ public record TestcaseResultPayload(
     String message
 
 ) {
-    public static TestcaseResultPayload fromEvaluation(int seqId, JudgeResult result, AnswerEvaluation evaluation) {
+    public static TestcaseResultPayload fromEvaluation(int seqId, boolean isPassed, JudgeResult result) {
         return new TestcaseResultPayload(
             seqId,
-            evaluation.isPassed(),
+            isPassed,
             result.actualOutput(),
             result.executionTime(),
             result.memoryUsage(),

src/main/java/org/ezcode/codetest/application/submission/dto/request/compile/CodeCompileRequest.java

@@ -1,5 +1,10 @@
 package org.ezcode.codetest.application.submission.dto.request.compile;
 
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+
+import org.ezcode.codetest.application.submission.model.SubmissionContext;
+
 public record CodeCompileRequest(
 
     String source_code,
@@ -9,4 +14,14 @@ public record CodeCompileRequest(
     String stdin
 
 ) {
+    public static CodeCompileRequest of(int seqId, SubmissionContext ctx) {
+        return new CodeCompileRequest(
+            ctx.getSourceCode(),
+            ctx.getJudge0Id(),
+            ctx.getInput(seqId));
+    }
+
+    private static String encodeBase64(String str) {
+        return Base64.getEncoder().encodeToString(str.getBytes(StandardCharsets.UTF_8));
+    }
 }

src/main/java/org/ezcode/codetest/application/submission/dto/response/compile/ExecutionResultResponse.java

@@ -19,6 +19,18 @@ public record ExecutionResultResponse(
     ExecutionStatus status
 
 ) {
+    public static ExecutionResultResponse ofCompileError() {
+        return new ExecutionResultResponse(
+            null,
+            0.0,
+            0L,
+            null,
+            null,
+            "Compilation Error",
+            1,
+            new ExecutionResultResponse.ExecutionStatus(6, "Compilation Error")
+        );
+    }
 
     public long getMemory() {
         return this.memory == null ? 0L : memory;

src/main/java/org/ezcode/codetest/application/submission/model/SubmissionContext.java

@@ -1,8 +1,15 @@
 package org.ezcode.codetest.application.submission.model;
 
 import org.ezcode.codetest.application.submission.dto.event.payload.SubmissionFinalResultPayload;
+import org.ezcode.codetest.domain.language.model.entity.Language;
+import org.ezcode.codetest.domain.problem.model.ProblemInfo;
+import org.ezcode.codetest.domain.problem.model.entity.Problem;
+import org.ezcode.codetest.domain.problem.model.entity.Testcase;
 import org.ezcode.codetest.domain.submission.model.SubmissionAggregator;
+import org.ezcode.codetest.domain.user.model.entity.User;
+import org.ezcode.codetest.infrastructure.event.dto.submission.SubmissionMessage;
 
+import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -20,48 +27,102 @@ public record SubmissionContext(
 
     CountDownLatch latch,
 
-    AtomicBoolean notified
+    AtomicBoolean notified,
+
+    User user,
+
+    Language language,
+
+    ProblemInfo problemInfo,
+
+    SubmissionMessage msg
 ) {
-    public static SubmissionContext initialize(int totalTestcaseCount) {
+    public static SubmissionContext initialize(
+        User user, Language language, ProblemInfo problemInfo, SubmissionMessage msg
+    ) {
         return new SubmissionContext(
             new SubmissionAggregator(),
             new AtomicInteger(0),
             new AtomicInteger(0),
             new AtomicReference<>("Accepted"),
-            new CountDownLatch(totalTestcaseCount),
-            new AtomicBoolean(false)
+            new CountDownLatch(problemInfo.getTestcaseCount()),
+            new AtomicBoolean(false),
+            user,
+            language,
+            problemInfo,
+            msg
         );
     }
 
-    public SubmissionFinalResultPayload toFinalResult(int totalTestcaseCount) {
+    public SubmissionFinalResultPayload toFinalResult() {
         return new SubmissionFinalResultPayload(
-            totalTestcaseCount,
+            this.getTestcaseCount(),
             this.getPassedCount(),
             this.getCurrentMessage()
         );
     }
 
     public void incrementPassedCount() {
-        this.passedCount.incrementAndGet();
+        passedCount.incrementAndGet();
     }
 
     public void incrementProcessedCount() {
-        this.processedCount.incrementAndGet();
+        processedCount.incrementAndGet();
     }
 
     public int getPassedCount() {
-        return this.passedCount.get();
+        return passedCount.get();
     }
 
     public String getCurrentMessage() {
-        return this.message.get();
+        return message.get();
     }
 
     public void updateMessage(String message) {
         this.message.set(message);
     }
 
     public void countDown() {
-        this.latch.countDown();
+        latch.countDown();
+    }
+
+    public List<Testcase> getTestcases() {
+        return problemInfo.testcaseList();
+    }
+
+    public int getTestcaseCount() {
+        return problemInfo.getTestcaseCount();
+    }
+
+    public String getSourceCode() {
+        return msg.sourceCode();
+    }
+
+    public long getJudge0Id() {
+        return language.getJudge0Id();
+    }
+
+    public String getInput(int seqId) {
+        return getTestcases().get(seqId - 1).getInput();
+    }
+
+    public String getExpectedOutput(int seqId) {
+        return getTestcases().get(seqId - 1).getOutput();
+    }
+
+    public long getTimeLimit() {
+        return problemInfo.getTimeLimit();
+    }
+
+    public long getMemoryLimit() {
+        return problemInfo.getMemoryLimit();
+    }
+
+    public String getSessionKey() {
+        return msg.sessionKey();
+    }
+
+    public Problem getProblem() {
+        return problemInfo.problem();
     }
 }

src/main/java/org/ezcode/codetest/application/submission/port/ExceptionNotifier.java

@@ -2,6 +2,6 @@
 
 public interface ExceptionNotifier {
 
-    void sendEmbed(String title, String description, String exception, String methodName);
+    void notifyException(String methodName, Throwable t);
 
 }

src/main/java/org/ezcode/codetest/application/submission/service/JudgementService.java

@@ -0,0 +1,109 @@
+package org.ezcode.codetest.application.submission.service;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+import org.ezcode.codetest.application.submission.dto.event.SubmissionErrorEvent;
+import org.ezcode.codetest.application.submission.dto.event.SubmissionJudgingFinishedEvent;
+import org.ezcode.codetest.application.submission.dto.event.TestcaseEvaluatedEvent;
+import org.ezcode.codetest.application.submission.dto.event.TestcaseListInitializedEvent;
+import org.ezcode.codetest.application.submission.dto.event.payload.InitTestcaseListPayload;
+import org.ezcode.codetest.application.submission.dto.event.payload.TestcaseResultPayload;
+import org.ezcode.codetest.application.submission.dto.request.compile.CodeCompileRequest;
+import org.ezcode.codetest.application.submission.model.JudgeResult;
+import org.ezcode.codetest.application.submission.model.SubmissionContext;
+import org.ezcode.codetest.application.submission.port.ExceptionNotifier;
+import org.ezcode.codetest.application.submission.port.JudgeClient;
+import org.ezcode.codetest.application.submission.port.ProblemEventService;
+import org.ezcode.codetest.application.submission.port.SubmissionEventService;
+import org.ezcode.codetest.domain.submission.exception.SubmissionException;
+import org.ezcode.codetest.domain.submission.exception.code.SubmissionExceptionCode;
+import org.ezcode.codetest.domain.submission.model.SubmissionResult;
+import org.ezcode.codetest.domain.submission.model.TestcaseEvaluationInput;
+import org.ezcode.codetest.domain.submission.service.SubmissionDomainService;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class JudgementService {
+
+    private final SubmissionDomainService submissionDomainService;
+    private final SubmissionEventService submissionEventService;
+    private final ProblemEventService problemEventService;
+    private final JudgeClient judgeClient;
+    private final Executor judgeTestcaseExecutor;
+    private final ExceptionNotifier exceptionNotifier;
+
+    public void publishInitTestcases(SubmissionContext ctx) {
+        submissionEventService.publishInitTestcases(
+            new TestcaseListInitializedEvent(ctx.getSessionKey(), InitTestcaseListPayload.from(ctx))
+        );
+    }
+
+    public void runTestcases(SubmissionContext ctx) throws InterruptedException {
+        IntStream.rangeClosed(1, ctx.getTestcaseCount())
+            .forEach(seqId -> runTestcaseAsync(seqId, ctx));
+
+        if (!ctx.latch().await(100, TimeUnit.SECONDS)) {
+            throw new SubmissionException(SubmissionExceptionCode.TESTCASE_TIMEOUT);
+        }
+    }
+
+    @Transactional
+    public void finalizeAndPublish(SubmissionContext ctx) {
+        SubmissionResult submissionResult = submissionDomainService.finalizeSubmission(ctx);
+
+        publishFinalResult(ctx);
+        publishProblemSolve(submissionResult);
+    }
+
+    public void publishSubmissionError(String sessionKey, Exception e) {
+        submissionEventService.publishSubmissionError(new SubmissionErrorEvent(sessionKey, e));
+    }
+
+    private void runTestcaseAsync(int seqId, SubmissionContext ctx) {
+        CompletableFuture.runAsync(() -> {
+            try {
+                log.info("[Judge RUN] Thread = {}", Thread.currentThread().getName());
+                String token = judgeClient.submitAndGetToken(CodeCompileRequest.of(seqId, ctx));
+                JudgeResult result = judgeClient.pollUntilDone(token);
+
+                TestcaseEvaluationInput input = TestcaseEvaluationInput.from(result, ctx, seqId);
+
+                boolean isPassed = submissionDomainService.handleEvaluationAndUpdateStats(input, ctx);
+
+                publishTestcaseUpdate(seqId, ctx, isPassed, result);
+            } catch (Exception e) {
+                if (ctx.notified().compareAndSet(false, true)) {
+                    publishSubmissionError(ctx.getSessionKey(), e);
+                    exceptionNotifier.notifyException("runTestcaseAsync", e);
+                }
+            } finally {
+                ctx.countDown();
+            }
+        }, judgeTestcaseExecutor);
+    }
+
+    private void publishTestcaseUpdate(int seqId, SubmissionContext ctx, boolean isPassed, JudgeResult result) {
+        submissionEventService.publishTestcaseUpdate(new TestcaseEvaluatedEvent(
+            ctx.getSessionKey(), TestcaseResultPayload.fromEvaluation(seqId, isPassed, result))
+        );
+    }
+
+    private void publishFinalResult(SubmissionContext ctx){
+        submissionEventService.publishFinalResult(
+            new SubmissionJudgingFinishedEvent(ctx.getSessionKey(), ctx.toFinalResult())
+        );
+    }
+
+    private void publishProblemSolve(SubmissionResult submissionResult) {
+        problemEventService.publishProblemSolveEvent(submissionResult);
+    }
+}