From 6bb6071ec1dce0cce59df0cb1c38168918061041 Mon Sep 17 00:00:00 2001 From: nsfisis Date: Wed, 7 Aug 2024 22:14:51 +0900 Subject: refactor(backend): move ownership of channel to send task results --- backend/taskqueue/tasks.go | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'backend/taskqueue/tasks.go') diff --git a/backend/taskqueue/tasks.go b/backend/taskqueue/tasks.go index cd67948..db05553 100644 --- a/backend/taskqueue/tasks.go +++ b/backend/taskqueue/tasks.go @@ -27,3 +27,10 @@ func NewExecTask(gameID, userID int, code string) (*asynq.Task, error) { } return asynq.NewTask(TaskTypeExec, payload), nil } + +type TaskExecResult struct { + Task *TaskExecPlayload + Result string + Stdout string + Stderr string +} -- cgit v1.2.3-70-g09d2 From 4295abfd48ad8ce217b251d07102deb8aee413d5 Mon Sep 17 00:00:00 2001 From: nsfisis Date: Wed, 7 Aug 2024 22:52:44 +0900 Subject: refactor: rename task result's "result" to "status" for consistency --- backend/game/hub.go | 2 +- backend/taskqueue/processor.go | 24 ++++++++++++------------ backend/taskqueue/tasks.go | 2 +- worker/exec.go | 8 ++++---- worker/models.go | 6 +++--- 5 files changed, 21 insertions(+), 21 deletions(-) (limited to 'backend/taskqueue/tasks.go') diff --git a/backend/game/hub.go b/backend/game/hub.go index ef69ddb..27a9847 100644 --- a/backend/game/hub.go +++ b/backend/game/hub.go @@ -209,7 +209,7 @@ func (hub *gameHub) processTaskResults() { Type: playerMessageTypeS2CExecResult, Data: playerMessageS2CExecResultPayload{ Score: nil, - Status: api.GamePlayerMessageS2CExecResultPayloadStatus(taskResult.Result), + Status: api.GamePlayerMessageS2CExecResultPayloadStatus(taskResult.Status), }, } } diff --git a/backend/taskqueue/processor.go b/backend/taskqueue/processor.go index f789e2e..135a7d2 100644 --- a/backend/taskqueue/processor.go +++ b/backend/taskqueue/processor.go @@ -49,7 +49,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { Code string `json:"code"` } type swiftcResponseData struct { - Result string `json:"result"` + Status string `json:"status"` Stdout string `json:"stdout"` Stderr string `json:"stderr"` } @@ -69,7 +69,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { return fmt.Errorf("json.Decode failed: %v", err) } - if resData.Result != "success" { + if resData.Status != "success" { err := p.q.CreateTestcaseResult(ctx, db.CreateTestcaseResultParams{ SubmissionID: submissionID, TestcaseID: nil, @@ -82,7 +82,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { } p.results <- TaskExecResult{ Task: &payload, - Result: "compile_error", + Status: "compile_error", } return fmt.Errorf("swiftc failed: %v", resData.Stderr) } @@ -93,7 +93,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { Code string `json:"code"` } type wasmcResponseData struct { - Result string `json:"result"` + Status string `json:"status"` Stdout string `json:"stdout"` Stderr string `json:"stderr"` } @@ -113,7 +113,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { return fmt.Errorf("json.Decode failed: %v", err) } - if resData.Result != "success" { + if resData.Status != "success" { err := p.q.CreateTestcaseResult(ctx, db.CreateTestcaseResultParams{ SubmissionID: submissionID, TestcaseID: nil, @@ -126,7 +126,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { } p.results <- TaskExecResult{ Task: &payload, - Result: "compile_error", + Status: "compile_error", } return fmt.Errorf("wasmc failed: %v", resData.Stderr) } @@ -144,7 +144,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { Stdin string `json:"stdin"` } type testrunResponseData struct { - Result string `json:"result"` + Status string `json:"status"` Stdout string `json:"stdout"` Stderr string `json:"stderr"` } @@ -165,11 +165,11 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { return fmt.Errorf("json.Decode failed: %v", err) } - if resData.Result != "success" { + if resData.Status != "success" { err := p.q.CreateTestcaseResult(ctx, db.CreateTestcaseResultParams{ SubmissionID: submissionID, TestcaseID: testcase.TestcaseID, - Status: resData.Result, + Status: resData.Status, Stdout: resData.Stdout, Stderr: resData.Stderr, }) @@ -178,7 +178,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { } p.results <- TaskExecResult{ Task: &payload, - Result: resData.Result, + Status: resData.Status, } return fmt.Errorf("testrun failed: %v", resData.Stderr) } @@ -195,7 +195,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { } p.results <- TaskExecResult{ Task: &payload, - Result: "wrong_answer", + Status: "wrong_answer", } return fmt.Errorf("testrun failed: %v", resData.Stdout) } @@ -203,7 +203,7 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { p.results <- TaskExecResult{ Task: &payload, - Result: "success", + Status: "success", } return nil } diff --git a/backend/taskqueue/tasks.go b/backend/taskqueue/tasks.go index db05553..5c518f4 100644 --- a/backend/taskqueue/tasks.go +++ b/backend/taskqueue/tasks.go @@ -30,7 +30,7 @@ func NewExecTask(gameID, userID int, code string) (*asynq.Task, error) { type TaskExecResult struct { Task *TaskExecPlayload - Result string + Status string Stdout string Stderr string } diff --git a/worker/exec.go b/worker/exec.go index 2ef16fa..10bc99a 100644 --- a/worker/exec.go +++ b/worker/exec.go @@ -95,7 +95,7 @@ func execSwiftCompile( if err := os.WriteFile(inPath, []byte(code), 0644); err != nil { return swiftCompileResponseData{ - Result: resultInternalError, + Status: resultInternalError, Stdout: "", Stderr: err.Error(), } @@ -116,7 +116,7 @@ func execSwiftCompile( ) return swiftCompileResponseData{ - Result: convertCommandErrorToResultType(err), + Status: convertCommandErrorToResultType(err), Stdout: stdout, Stderr: stderr, } @@ -148,7 +148,7 @@ func execWasmCompile( ) return wasmCompileResponseData{ - Result: convertCommandErrorToResultType(err), + Status: convertCommandErrorToResultType(err), Stdout: stdout, Stderr: stderr, } @@ -179,7 +179,7 @@ func execTestRun( ) return testRunResponseData{ - Result: convertCommandErrorToResultType(err), + Status: convertCommandErrorToResultType(err), Stdout: stdout, Stderr: stderr, } diff --git a/worker/models.go b/worker/models.go index b838fe0..a7310bd 100644 --- a/worker/models.go +++ b/worker/models.go @@ -33,7 +33,7 @@ func (req *swiftCompileRequestData) validate() error { } type swiftCompileResponseData struct { - Result string `json:"result"` + Status string `json:"status"` Stdout string `json:"stdout"` Stderr string `json:"stderr"` } @@ -44,7 +44,7 @@ type wasmCompileRequestData struct { } type wasmCompileResponseData struct { - Result string `json:"result"` + Status string `json:"status"` Stdout string `json:"stdout"` Stderr string `json:"stderr"` } @@ -78,7 +78,7 @@ func (req *testRunRequestData) validate() error { } type testRunResponseData struct { - Result string `json:"result"` + Status string `json:"status"` Stdout string `json:"stdout"` Stderr string `json:"stderr"` } -- cgit v1.2.3-70-g09d2 From cfe46bf104dec03c81ca38eb6b6a23b372a271b6 Mon Sep 17 00:00:00 2001 From: nsfisis Date: Wed, 7 Aug 2024 23:49:10 +0900 Subject: feat(backend): split task into smaller task types --- backend/game/hub.go | 54 +++++--- backend/taskqueue/processor.go | 253 ++++++++++++++++++++++--------------- backend/taskqueue/tasks.go | 180 ++++++++++++++++++++++++-- backend/taskqueue/worker_server.go | 32 +++-- 4 files changed, 372 insertions(+), 147 deletions(-) (limited to 'backend/taskqueue/tasks.go') diff --git a/backend/game/hub.go b/backend/game/hub.go index 27a9847..58eb180 100644 --- a/backend/game/hub.go +++ b/backend/game/hub.go @@ -33,7 +33,7 @@ type gameHub struct { watchers map[*watcherClient]bool registerWatcher chan *watcherClient unregisterWatcher chan *watcherClient - taskResults chan taskqueue.TaskExecResult + taskResults chan taskqueue.TaskResult } func newGameHub(ctx context.Context, game *game, q *db.Queries, taskQueue *taskqueue.Queue) *gameHub { @@ -49,7 +49,7 @@ func newGameHub(ctx context.Context, game *game, q *db.Queries, taskQueue *taskq watchers: make(map[*watcherClient]bool), registerWatcher: make(chan *watcherClient), unregisterWatcher: make(chan *watcherClient), - taskResults: make(chan taskqueue.TaskExecResult), + taskResults: make(chan taskqueue.TaskResult), } } @@ -161,7 +161,13 @@ func (hub *gameHub) run() { // TODO: assert game state is gaming log.Printf("submit: %v", message.message) code := msg.Data.Code - task, err := taskqueue.NewExecTask(hub.game.gameID, message.client.playerID, code) + codeSize := len(code) // TODO: exclude whitespaces. + task, err := taskqueue.NewTaskCreateSubmissionRecord( + hub.game.gameID, + message.client.playerID, + code, + codeSize, + ) if err != nil { log.Fatalf("failed to create task: %v", err) } @@ -201,19 +207,31 @@ func (hub *gameHub) run() { func (hub *gameHub) processTaskResults() { for taskResult := range hub.taskResults { - for player := range hub.players { - if player.playerID != taskResult.Task.UserID { - continue - } - player.s2cMessages <- &playerMessageS2CExecResult{ - Type: playerMessageTypeS2CExecResult, - Data: playerMessageS2CExecResultPayload{ - Score: nil, - Status: api.GamePlayerMessageS2CExecResultPayloadStatus(taskResult.Status), - }, + switch taskResult := taskResult.(type) { + case *taskqueue.TaskResultCreateSubmissionRecord: + // todo + case *taskqueue.TaskResultCompileSwiftToWasm: + // todo + case *taskqueue.TaskResultCompileWasmToNativeExecutable: + // todo + case *taskqueue.TaskResultRunTestcase: + // todo + for player := range hub.players { + if player.playerID != taskResult.TaskPayload.UserID() { + continue + } + player.s2cMessages <- &playerMessageS2CExecResult{ + Type: playerMessageTypeS2CExecResult, + Data: playerMessageS2CExecResultPayload{ + Score: nil, + Status: api.GamePlayerMessageS2CExecResultPayloadStatus(taskResult.Status), + }, + } } + // broadcast to watchers + default: + panic("unexpected task result type") } - // broadcast to watchers } } @@ -270,10 +288,10 @@ type GameHubs struct { hubs map[int]*gameHub q *db.Queries taskQueue *taskqueue.Queue - taskResults chan taskqueue.TaskExecResult + taskResults chan taskqueue.TaskResult } -func NewGameHubs(q *db.Queries, taskQueue *taskqueue.Queue, taskResults chan taskqueue.TaskExecResult) *GameHubs { +func NewGameHubs(q *db.Queries, taskQueue *taskqueue.Queue, taskResults chan taskqueue.TaskResult) *GameHubs { return &GameHubs{ hubs: make(map[int]*gameHub), q: q, @@ -339,9 +357,9 @@ func (hubs *GameHubs) Run() { } for taskResult := range hubs.taskResults { - hub := hubs.getHub(taskResult.Task.GameID) + hub := hubs.getHub(taskResult.GameID()) if hub == nil { - log.Printf("no such game: %d", taskResult.Task.GameID) + log.Printf("no such game: %d", taskResult.GameID()) continue } hub.taskResults <- taskResult diff --git a/backend/taskqueue/processor.go b/backend/taskqueue/processor.go index b080c46..556bd78 100644 --- a/backend/taskqueue/processor.go +++ b/backend/taskqueue/processor.go @@ -13,125 +13,169 @@ import ( "github.com/nsfisis/iosdc-japan-2024-albatross/backend/db" ) -type ExecProcessor struct { +type processor struct { q *db.Queries - results chan TaskExecResult + results chan TaskResult } -func NewExecProcessor(q *db.Queries, results chan TaskExecResult) *ExecProcessor { - return &ExecProcessor{ +func newProcessor(q *db.Queries) *processor { + return &processor{ q: q, - results: results, + results: make(chan TaskResult), } } -func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { - var payload TaskExecPlayload +func (p *processor) processTaskCreateSubmissionRecord(ctx context.Context, t *asynq.Task) error { + var payload TaskPayloadCreateSubmissionRecord if err := json.Unmarshal(t.Payload(), &payload); err != nil { + // TODO: send result return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry) } // TODO: upsert // Create submission record. submissionID, err := p.q.CreateSubmission(ctx, db.CreateSubmissionParams{ - GameID: int32(payload.GameID), - UserID: int32(payload.UserID), - Code: payload.Code, - CodeSize: int32(len(payload.Code)), // TODO: exclude whitespaces. + GameID: int32(payload.GameID()), + UserID: int32(payload.UserID()), + Code: payload.Code(), + CodeSize: int32(payload.CodeSize), }) if err != nil { + // TODO: send result return fmt.Errorf("CreateSubmission failed: %v", err) } - { - type swiftcRequestData struct { - MaxDuration int `json:"max_duration_ms"` - Code string `json:"code"` - } - type swiftcResponseData struct { - Status string `json:"status"` - Stdout string `json:"stdout"` - Stderr string `json:"stderr"` - } - reqData := swiftcRequestData{ - MaxDuration: 5000, - Code: payload.Code, - } - reqJson, err := json.Marshal(reqData) - if err != nil { - return fmt.Errorf("json.Marshal failed: %v", err) - } - res, err := http.Post("http://worker:80/api/swiftc", "application/json", bytes.NewBuffer(reqJson)) + p.results <- &TaskResultCreateSubmissionRecord{ + TaskPayload: &payload, + SubmissionID: int(submissionID), + } + return nil +} + +func (p *processor) processTaskCompileSwiftToWasm(ctx context.Context, t *asynq.Task) error { + var payload TaskPayloadCompileSwiftToWasm + if err := json.Unmarshal(t.Payload(), &payload); err != nil { + // TODO: send result + return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry) + } + + type swiftcRequestData struct { + MaxDuration int `json:"max_duration_ms"` + Code string `json:"code"` + } + type swiftcResponseData struct { + Status string `json:"status"` + Stdout string `json:"stdout"` + Stderr string `json:"stderr"` + } + reqData := swiftcRequestData{ + MaxDuration: 5000, + Code: payload.Code(), + } + reqJson, err := json.Marshal(reqData) + if err != nil { + // TODO: send result + return fmt.Errorf("json.Marshal failed: %v", err) + } + res, err := http.Post("http://worker:80/api/swiftc", "application/json", bytes.NewBuffer(reqJson)) + if err != nil { + // TODO: send result + return fmt.Errorf("http.Post failed: %v", err) + } + resData := swiftcResponseData{} + if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { + // TODO: send result + return fmt.Errorf("json.Decode failed: %v", err) + } + if resData.Status != "success" { + err := p.q.CreateSubmissionResult(ctx, db.CreateSubmissionResultParams{ + SubmissionID: int32(payload.SubmissionID), + Status: "compile_error", + Stdout: resData.Stdout, + Stderr: resData.Stderr, + }) if err != nil { - return fmt.Errorf("http.Post failed: %v", err) + // TODO: send result + return fmt.Errorf("CreateTestcaseResult failed: %v", err) } - resData := swiftcResponseData{} - if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { - return fmt.Errorf("json.Decode failed: %v", err) - } - if resData.Status != "success" { - err := p.q.CreateSubmissionResult(ctx, db.CreateSubmissionResultParams{ - SubmissionID: submissionID, - Status: "compile_error", - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }) - if err != nil { - return fmt.Errorf("CreateTestcaseResult failed: %v", err) - } - p.results <- TaskExecResult{ - Task: &payload, - Status: "compile_error", - } - return fmt.Errorf("swiftc failed: %v", resData.Stderr) + p.results <- &TaskResultCompileSwiftToWasm{ + TaskPayload: &payload, + Status: "compile_error", } + return fmt.Errorf("swiftc failed: %v", resData.Stderr) } - { - type wasmcRequestData struct { - MaxDuration int `json:"max_duration_ms"` - Code string `json:"code"` - } - type wasmcResponseData struct { - Status string `json:"status"` - Stdout string `json:"stdout"` - Stderr string `json:"stderr"` - } - reqData := wasmcRequestData{ - MaxDuration: 5000, - Code: payload.Code, - } - reqJson, err := json.Marshal(reqData) - if err != nil { - return fmt.Errorf("json.Marshal failed: %v", err) - } - res, err := http.Post("http://worker:80/api/wasmc", "application/json", bytes.NewBuffer(reqJson)) + + // TODO: send result + return nil +} + +func (p *processor) processTaskCompileWasmToNativeExecutable(ctx context.Context, t *asynq.Task) error { + var payload TaskPayloadCompileWasmToNativeExecutable + if err := json.Unmarshal(t.Payload(), &payload); err != nil { + // TODO: send result + return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry) + } + + type wasmcRequestData struct { + MaxDuration int `json:"max_duration_ms"` + Code string `json:"code"` + } + type wasmcResponseData struct { + Status string `json:"status"` + Stdout string `json:"stdout"` + Stderr string `json:"stderr"` + } + reqData := wasmcRequestData{ + MaxDuration: 5000, + Code: payload.Code(), + } + reqJson, err := json.Marshal(reqData) + if err != nil { + // TODO: send result + return fmt.Errorf("json.Marshal failed: %v", err) + } + res, err := http.Post("http://worker:80/api/wasmc", "application/json", bytes.NewBuffer(reqJson)) + if err != nil { + // TODO: send result + return fmt.Errorf("http.Post failed: %v", err) + } + resData := wasmcResponseData{} + if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { + // TODO: send result + return fmt.Errorf("json.Decode failed: %v", err) + } + if resData.Status != "success" { + err := p.q.CreateSubmissionResult(ctx, db.CreateSubmissionResultParams{ + SubmissionID: int32(payload.SubmissionID), + Status: "compile_error", + Stdout: resData.Stdout, + Stderr: resData.Stderr, + }) if err != nil { - return fmt.Errorf("http.Post failed: %v", err) + // TODO: send result + return fmt.Errorf("CreateTestcaseResult failed: %v", err) } - resData := wasmcResponseData{} - if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { - return fmt.Errorf("json.Decode failed: %v", err) - } - if resData.Status != "success" { - err := p.q.CreateSubmissionResult(ctx, db.CreateSubmissionResultParams{ - SubmissionID: submissionID, - Status: "compile_error", - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }) - if err != nil { - return fmt.Errorf("CreateTestcaseResult failed: %v", err) - } - p.results <- TaskExecResult{ - Task: &payload, - Status: "compile_error", - } - return fmt.Errorf("wasmc failed: %v", resData.Stderr) + p.results <- &TaskResultCompileWasmToNativeExecutable{ + TaskPayload: &payload, + Status: "compile_error", } + return fmt.Errorf("wasmc failed: %v", resData.Stderr) + } + + // TODO: send result + return nil +} + +func (p *processor) processTaskRunTestcase(ctx context.Context, t *asynq.Task) error { + var payload TaskPayloadRunTestcase + if err := json.Unmarshal(t.Payload(), &payload); err != nil { + // TODO: send result + return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry) } - testcases, err := p.q.ListTestcasesByGameID(ctx, int32(payload.GameID)) + testcases, err := p.q.ListTestcasesByGameID(ctx, int32(payload.GameID())) if err != nil { + // TODO: send result return fmt.Errorf("ListTestcasesByGameID failed: %v", err) } @@ -148,60 +192,65 @@ func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error { } reqData := testrunRequestData{ MaxDuration: 5000, - Code: payload.Code, + Code: payload.Code(), Stdin: testcase.Stdin, } reqJson, err := json.Marshal(reqData) if err != nil { + // TODO: send result return fmt.Errorf("json.Marshal failed: %v", err) } res, err := http.Post("http://worker:80/api/testrun", "application/json", bytes.NewBuffer(reqJson)) if err != nil { + // TODO: send result return fmt.Errorf("http.Post failed: %v", err) } resData := testrunResponseData{} if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { + // TODO: send result return fmt.Errorf("json.Decode failed: %v", err) } if resData.Status != "success" { err := p.q.CreateTestcaseResult(ctx, db.CreateTestcaseResultParams{ - SubmissionID: submissionID, + SubmissionID: int32(payload.SubmissionID), TestcaseID: testcase.TestcaseID, Status: resData.Status, Stdout: resData.Stdout, Stderr: resData.Stderr, }) if err != nil { + // TODO: send result return fmt.Errorf("CreateTestcaseResult failed: %v", err) } - p.results <- TaskExecResult{ - Task: &payload, - Status: resData.Status, + p.results <- &TaskResultRunTestcase{ + TaskPayload: &payload, + Status: resData.Status, } return fmt.Errorf("testrun failed: %v", resData.Stderr) } if !isTestcaseResultCorrect(testcase.Stdout, resData.Stdout) { err := p.q.CreateTestcaseResult(ctx, db.CreateTestcaseResultParams{ - SubmissionID: submissionID, + SubmissionID: int32(payload.SubmissionID), TestcaseID: testcase.TestcaseID, Status: "wrong_answer", Stdout: resData.Stdout, Stderr: resData.Stderr, }) if err != nil { + // TODO: send result return fmt.Errorf("CreateTestcaseResult failed: %v", err) } - p.results <- TaskExecResult{ - Task: &payload, - Status: "wrong_answer", + p.results <- &TaskResultRunTestcase{ + TaskPayload: &payload, + Status: "wrong_answer", } return fmt.Errorf("testrun failed: %v", resData.Stdout) } } - p.results <- TaskExecResult{ - Task: &payload, - Status: "success", + p.results <- &TaskResultRunTestcase{ + TaskPayload: &payload, + Status: "success", } return nil } diff --git a/backend/taskqueue/tasks.go b/backend/taskqueue/tasks.go index 5c518f4..679b6a0 100644 --- a/backend/taskqueue/tasks.go +++ b/backend/taskqueue/tasks.go @@ -6,31 +6,185 @@ import ( "github.com/hibiken/asynq" ) +type TaskType string + const ( - TaskTypeExec = "exec" + TaskTypeCreateSubmissionRecord TaskType = "create_submission_record" + TaskTypeCompileSwiftToWasm TaskType = "compile_swift_to_wasm" + TaskTypeCompileWasmToNativeExecutable TaskType = "compile_wasm_to_native_executable" + TaskTypeRunTestcase TaskType = "run_testcase" ) -type TaskExecPlayload struct { +type TaskPayloadBase struct { GameID int UserID int Code string } -func NewExecTask(gameID, userID int, code string) (*asynq.Task, error) { - payload, err := json.Marshal(TaskExecPlayload{ - GameID: gameID, - UserID: userID, - Code: code, +type TaskPayloadCreateSubmissionRecord struct { + TaskPayloadBase + CodeSize int +} + +func NewTaskCreateSubmissionRecord( + gameID int, + userID int, + code string, + codeSize int, +) (*asynq.Task, error) { + payload, err := json.Marshal(TaskPayloadCreateSubmissionRecord{ + TaskPayloadBase: TaskPayloadBase{ + GameID: gameID, + UserID: userID, + Code: code, + }, + CodeSize: codeSize, + }) + if err != nil { + return nil, err + } + return asynq.NewTask(string(TaskTypeCreateSubmissionRecord), payload), nil +} + +func (t *TaskPayloadCreateSubmissionRecord) GameID() int { return t.TaskPayloadBase.GameID } +func (t *TaskPayloadCreateSubmissionRecord) UserID() int { return t.TaskPayloadBase.UserID } +func (t *TaskPayloadCreateSubmissionRecord) Code() string { return t.TaskPayloadBase.Code } + +type TaskPayloadCompileSwiftToWasm struct { + TaskPayloadBase + SubmissionID int +} + +func NewTaskCompileSwiftToWasm( + gameID int, + userID int, + code string, + submissionID int, +) (*asynq.Task, error) { + payload, err := json.Marshal(TaskPayloadCompileSwiftToWasm{ + TaskPayloadBase: TaskPayloadBase{ + GameID: gameID, + UserID: userID, + Code: code, + }, + SubmissionID: submissionID, + }) + if err != nil { + return nil, err + } + return asynq.NewTask(string(TaskTypeCompileSwiftToWasm), payload), nil +} + +func (t *TaskPayloadCompileSwiftToWasm) GameID() int { return t.TaskPayloadBase.GameID } +func (t *TaskPayloadCompileSwiftToWasm) UserID() int { return t.TaskPayloadBase.UserID } +func (t *TaskPayloadCompileSwiftToWasm) Code() string { return t.TaskPayloadBase.Code } + +type TaskPayloadCompileWasmToNativeExecutable struct { + TaskPayloadBase + SubmissionID int +} + +func NewTaskCompileWasmToNativeExecutable( + gameID int, + userID int, + code string, + submissionID int, +) (*asynq.Task, error) { + payload, err := json.Marshal(TaskPayloadCompileWasmToNativeExecutable{ + TaskPayloadBase: TaskPayloadBase{ + GameID: gameID, + UserID: userID, + Code: code, + }, + SubmissionID: submissionID, + }) + if err != nil { + return nil, err + } + return asynq.NewTask(string(TaskTypeCompileWasmToNativeExecutable), payload), nil +} + +func (t *TaskPayloadCompileWasmToNativeExecutable) GameID() int { return t.TaskPayloadBase.GameID } +func (t *TaskPayloadCompileWasmToNativeExecutable) UserID() int { return t.TaskPayloadBase.UserID } +func (t *TaskPayloadCompileWasmToNativeExecutable) Code() string { return t.TaskPayloadBase.Code } + +type TaskPayloadRunTestcase struct { + TaskPayloadBase + SubmissionID int + TestcaseID int +} + +func NewTaskRunTestcase( + gameID int, + userID int, + code string, + submissionID int, + testcaseID int, +) (*asynq.Task, error) { + payload, err := json.Marshal(TaskPayloadRunTestcase{ + TaskPayloadBase: TaskPayloadBase{ + GameID: gameID, + UserID: userID, + Code: code, + }, + SubmissionID: submissionID, + TestcaseID: testcaseID, }) if err != nil { return nil, err } - return asynq.NewTask(TaskTypeExec, payload), nil + return asynq.NewTask(string(TaskTypeRunTestcase), payload), nil +} + +func (t *TaskPayloadRunTestcase) GameID() int { return t.TaskPayloadBase.GameID } +func (t *TaskPayloadRunTestcase) UserID() int { return t.TaskPayloadBase.UserID } +func (t *TaskPayloadRunTestcase) Code() string { return t.TaskPayloadBase.Code } + +type TaskResult interface { + Type() TaskType + GameID() int } -type TaskExecResult struct { - Task *TaskExecPlayload - Status string - Stdout string - Stderr string +type TaskResultCreateSubmissionRecord struct { + TaskPayload *TaskPayloadCreateSubmissionRecord + SubmissionID int + Err error } + +func (r *TaskResultCreateSubmissionRecord) Type() TaskType { return TaskTypeCreateSubmissionRecord } +func (r *TaskResultCreateSubmissionRecord) GameID() int { return r.TaskPayload.GameID() } + +type TaskResultCompileSwiftToWasm struct { + TaskPayload *TaskPayloadCompileSwiftToWasm + Status string + Stdout string + Stderr string + Err error +} + +func (r *TaskResultCompileSwiftToWasm) Type() TaskType { return TaskTypeCompileSwiftToWasm } +func (r *TaskResultCompileSwiftToWasm) GameID() int { return r.TaskPayload.GameID() } + +type TaskResultCompileWasmToNativeExecutable struct { + TaskPayload *TaskPayloadCompileWasmToNativeExecutable + Status string + Stdout string + Stderr string + Err error +} + +func (r *TaskResultCompileWasmToNativeExecutable) Type() TaskType { + return TaskTypeCompileWasmToNativeExecutable +} +func (r *TaskResultCompileWasmToNativeExecutable) GameID() int { return r.TaskPayload.GameID() } + +type TaskResultRunTestcase struct { + TaskPayload *TaskPayloadRunTestcase + Status string + Stdout string + Stderr string + Err error +} + +func (r *TaskResultRunTestcase) Type() TaskType { return TaskTypeRunTestcase } +func (r *TaskResultRunTestcase) GameID() int { return r.TaskPayload.GameID() } diff --git a/backend/taskqueue/worker_server.go b/backend/taskqueue/worker_server.go index 67803e2..6dc65d8 100644 --- a/backend/taskqueue/worker_server.go +++ b/backend/taskqueue/worker_server.go @@ -7,31 +7,35 @@ import ( ) type WorkerServer struct { - server *asynq.Server - queries *db.Queries - results chan TaskExecResult + server *asynq.Server + processor *processor } func NewWorkerServer(redisAddr string, queries *db.Queries) *WorkerServer { + server := asynq.NewServer( + asynq.RedisClientOpt{ + Addr: redisAddr, + }, + asynq.Config{}, + ) + processor := newProcessor(queries) return &WorkerServer{ - server: asynq.NewServer( - asynq.RedisClientOpt{ - Addr: redisAddr, - }, - asynq.Config{}, - ), - queries: queries, - results: make(chan TaskExecResult), + server: server, + processor: processor, } } func (s *WorkerServer) Run() error { mux := asynq.NewServeMux() - mux.Handle(TaskTypeExec, NewExecProcessor(s.queries, s.results)) + + mux.HandleFunc(string(TaskTypeCreateSubmissionRecord), s.processor.processTaskCreateSubmissionRecord) + mux.HandleFunc(string(TaskTypeCompileSwiftToWasm), s.processor.processTaskCompileSwiftToWasm) + mux.HandleFunc(string(TaskTypeCompileWasmToNativeExecutable), s.processor.processTaskCompileWasmToNativeExecutable) + mux.HandleFunc(string(TaskTypeRunTestcase), s.processor.processTaskRunTestcase) return s.server.Run(mux) } -func (s *WorkerServer) Results() chan TaskExecResult { - return s.results +func (s *WorkerServer) Results() chan TaskResult { + return s.processor.results } -- cgit v1.2.3-70-g09d2 From 26378c2d2ad1f8cb3f20c7070be3be9a4f0a0ad6 Mon Sep 17 00:00:00 2001 From: nsfisis Date: Thu, 8 Aug 2024 01:28:43 +0900 Subject: refactor(backend): add Queue.Enqueue*() variants --- backend/game/hub.go | 9 +++--- backend/taskqueue/queue.go | 78 ++++++++++++++++++++++++++++++++++++++++++++-- backend/taskqueue/tasks.go | 8 ++--- 3 files changed, 84 insertions(+), 11 deletions(-) (limited to 'backend/taskqueue/tasks.go') diff --git a/backend/game/hub.go b/backend/game/hub.go index 58eb180..b51d977 100644 --- a/backend/game/hub.go +++ b/backend/game/hub.go @@ -162,16 +162,15 @@ func (hub *gameHub) run() { log.Printf("submit: %v", message.message) code := msg.Data.Code codeSize := len(code) // TODO: exclude whitespaces. - task, err := taskqueue.NewTaskCreateSubmissionRecord( + if err := hub.taskQueue.EnqueueTaskCreateSubmissionRecord( hub.game.gameID, message.client.playerID, code, codeSize, - ) - if err != nil { - log.Fatalf("failed to create task: %v", err) + ); err != nil { + // TODO: notify failure to player + log.Fatalf("failed to enqueue task: %v", err) } - hub.taskQueue.Enqueue(task) default: log.Printf("unexpected message type: %T", message.message) } diff --git a/backend/taskqueue/queue.go b/backend/taskqueue/queue.go index 53ec6d6..b7d7381 100644 --- a/backend/taskqueue/queue.go +++ b/backend/taskqueue/queue.go @@ -20,6 +20,80 @@ func (q *Queue) Close() { q.client.Close() } -func (q *Queue) Enqueue(task *asynq.Task, opts ...asynq.Option) (*asynq.TaskInfo, error) { - return q.client.Enqueue(task, opts...) +func (q *Queue) EnqueueTaskCreateSubmissionRecord( + gameID int, + userID int, + code string, + codeSize int, +) error { + task, err := newTaskCreateSubmissionRecord( + gameID, + userID, + code, + codeSize, + ) + if err != nil { + return err + } + _, err = q.client.Enqueue(task) + return err +} + +func (q *Queue) EnqueueTaskCompileSwiftToWasm( + gameID int, + userID int, + code string, + submissionID int, +) error { + task, err := newTaskCompileSwiftToWasm( + gameID, + userID, + code, + submissionID, + ) + if err != nil { + return err + } + _, err = q.client.Enqueue(task) + return err +} + +func (q *Queue) EnqueueTaskCompileWasmToNativeExecutable( + gameID int, + userID int, + code string, + submissionID int, +) error { + task, err := newTaskCompileWasmToNativeExecutable( + gameID, + userID, + code, + submissionID, + ) + if err != nil { + return err + } + _, err = q.client.Enqueue(task) + return err +} + +func (q *Queue) EnqueueTaskRunTestcase( + gameID int, + userID int, + code string, + submissionID int, + testcaseID int, +) error { + task, err := newTaskRunTestcase( + gameID, + userID, + code, + submissionID, + testcaseID, + ) + if err != nil { + return err + } + _, err = q.client.Enqueue(task) + return err } diff --git a/backend/taskqueue/tasks.go b/backend/taskqueue/tasks.go index 679b6a0..990ce65 100644 --- a/backend/taskqueue/tasks.go +++ b/backend/taskqueue/tasks.go @@ -26,7 +26,7 @@ type TaskPayloadCreateSubmissionRecord struct { CodeSize int } -func NewTaskCreateSubmissionRecord( +func newTaskCreateSubmissionRecord( gameID int, userID int, code string, @@ -55,7 +55,7 @@ type TaskPayloadCompileSwiftToWasm struct { SubmissionID int } -func NewTaskCompileSwiftToWasm( +func newTaskCompileSwiftToWasm( gameID int, userID int, code string, @@ -84,7 +84,7 @@ type TaskPayloadCompileWasmToNativeExecutable struct { SubmissionID int } -func NewTaskCompileWasmToNativeExecutable( +func newTaskCompileWasmToNativeExecutable( gameID int, userID int, code string, @@ -114,7 +114,7 @@ type TaskPayloadRunTestcase struct { TestcaseID int } -func NewTaskRunTestcase( +func newTaskRunTestcase( gameID int, userID int, code string, -- cgit v1.2.3-70-g09d2 From 4eb7e89d6a77a4434bd087fbb86873521d30a8f5 Mon Sep 17 00:00:00 2001 From: nsfisis Date: Thu, 8 Aug 2024 01:30:09 +0900 Subject: feat(backend): implement processTaskResults() partially --- backend/game/hub.go | 274 ++++++++++++++++++++++++++++++++++++++--- backend/taskqueue/processor.go | 148 ++++++---------------- backend/taskqueue/queue.go | 4 + backend/taskqueue/tasks.go | 6 + 4 files changed, 305 insertions(+), 127 deletions(-) (limited to 'backend/taskqueue/tasks.go') diff --git a/backend/game/hub.go b/backend/game/hub.go index b51d977..d17ff7c 100644 --- a/backend/game/hub.go +++ b/backend/game/hub.go @@ -4,6 +4,7 @@ import ( "context" "errors" "log" + "strings" "time" "github.com/jackc/pgx/v5/pgtype" @@ -204,36 +205,273 @@ func (hub *gameHub) run() { } } +type codeSubmissionError struct { + Status string + Stdout string + Stderr string +} + +func (err *codeSubmissionError) Error() string { + return err.Stderr +} + func (hub *gameHub) processTaskResults() { for taskResult := range hub.taskResults { switch taskResult := taskResult.(type) { case *taskqueue.TaskResultCreateSubmissionRecord: - // todo + err := hub.processTaskResultCreateSubmissionRecord(taskResult) + if err != nil { + for player := range hub.players { + if player.playerID != taskResult.TaskPayload.UserID() { + continue + } + player.s2cMessages <- &playerMessageS2CExecResult{ + Type: playerMessageTypeS2CExecResult, + Data: playerMessageS2CExecResultPayload{ + Score: nil, + Status: api.GamePlayerMessageS2CExecResultPayloadStatus(err.Status), + }, + } + } + // TODO: broadcast to watchers + } case *taskqueue.TaskResultCompileSwiftToWasm: - // todo + err := hub.processTaskResultCompileSwiftToWasm(taskResult) + if err != nil { + for player := range hub.players { + if player.playerID != taskResult.TaskPayload.UserID() { + continue + } + player.s2cMessages <- &playerMessageS2CExecResult{ + Type: playerMessageTypeS2CExecResult, + Data: playerMessageS2CExecResultPayload{ + Score: nil, + Status: api.GamePlayerMessageS2CExecResultPayloadStatus(err.Status), + }, + } + } + // TODO: broadcast to watchers + } case *taskqueue.TaskResultCompileWasmToNativeExecutable: - // todo - case *taskqueue.TaskResultRunTestcase: - // todo - for player := range hub.players { - if player.playerID != taskResult.TaskPayload.UserID() { - continue + err := hub.processTaskResultCompileWasmToNativeExecutable(taskResult) + if err != nil { + for player := range hub.players { + if player.playerID != taskResult.TaskPayload.UserID() { + continue + } + player.s2cMessages <- &playerMessageS2CExecResult{ + Type: playerMessageTypeS2CExecResult, + Data: playerMessageS2CExecResultPayload{ + Score: nil, + Status: api.GamePlayerMessageS2CExecResultPayloadStatus(err.Status), + }, + } } - player.s2cMessages <- &playerMessageS2CExecResult{ - Type: playerMessageTypeS2CExecResult, - Data: playerMessageS2CExecResultPayload{ - Score: nil, - Status: api.GamePlayerMessageS2CExecResultPayloadStatus(taskResult.Status), - }, + // TODO: broadcast to watchers + } + case *taskqueue.TaskResultRunTestcase: + err := hub.processTaskResultRunTestcase(taskResult) + if err != nil { + for player := range hub.players { + if player.playerID != taskResult.TaskPayload.UserID() { + continue + } + player.s2cMessages <- &playerMessageS2CExecResult{ + Type: playerMessageTypeS2CExecResult, + Data: playerMessageS2CExecResultPayload{ + Score: nil, + Status: api.GamePlayerMessageS2CExecResultPayloadStatus(err.Status), + }, + } } + // TODO: broadcast to watchers } - // broadcast to watchers + // TODO: aggregate results of testcases default: panic("unexpected task result type") } } } +func (hub *gameHub) processTaskResultCreateSubmissionRecord( + taskResult *taskqueue.TaskResultCreateSubmissionRecord, +) *codeSubmissionError { + if taskResult.Err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: taskResult.Err.Error(), + } + } + + if err := hub.taskQueue.EnqueueTaskCompileSwiftToWasm( + taskResult.TaskPayload.GameID(), + taskResult.TaskPayload.UserID(), + taskResult.TaskPayload.Code(), + taskResult.SubmissionID, + ); err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: err.Error(), + } + } + return nil +} + +func (hub *gameHub) processTaskResultCompileSwiftToWasm( + taskResult *taskqueue.TaskResultCompileSwiftToWasm, +) *codeSubmissionError { + if taskResult.Err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: taskResult.Err.Error(), + } + } + + if taskResult.Status != "success" { + if err := hub.q.CreateSubmissionResult(hub.ctx, db.CreateSubmissionResultParams{ + SubmissionID: int32(taskResult.TaskPayload.SubmissionID), + Status: taskResult.Status, + Stdout: taskResult.Stdout, + Stderr: taskResult.Stderr, + }); err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: err.Error(), + } + } + return &codeSubmissionError{ + Status: taskResult.Status, + Stdout: taskResult.Stdout, + Stderr: taskResult.Stderr, + } + } + if err := hub.taskQueue.EnqueueTaskCompileWasmToNativeExecutable( + taskResult.TaskPayload.GameID(), + taskResult.TaskPayload.UserID(), + taskResult.TaskPayload.Code(), + taskResult.TaskPayload.SubmissionID, + ); err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: err.Error(), + } + } + return nil +} + +func (hub *gameHub) processTaskResultCompileWasmToNativeExecutable( + taskResult *taskqueue.TaskResultCompileWasmToNativeExecutable, +) *codeSubmissionError { + if taskResult.Err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: taskResult.Err.Error(), + } + } + + if taskResult.Status != "success" { + if err := hub.q.CreateSubmissionResult(hub.ctx, db.CreateSubmissionResultParams{ + SubmissionID: int32(taskResult.TaskPayload.SubmissionID), + Status: taskResult.Status, + Stdout: taskResult.Stdout, + Stderr: taskResult.Stderr, + }); err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: err.Error(), + } + } + return &codeSubmissionError{ + Status: taskResult.Status, + Stdout: taskResult.Stdout, + Stderr: taskResult.Stderr, + } + } + + testcases, err := hub.q.ListTestcasesByGameID(hub.ctx, int32(taskResult.TaskPayload.GameID())) + if err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: err.Error(), + } + } + if len(testcases) == 0 { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: "no testcases found", + } + } + + for _, testcase := range testcases { + if err := hub.taskQueue.EnqueueTaskRunTestcase( + taskResult.TaskPayload.GameID(), + taskResult.TaskPayload.UserID(), + taskResult.TaskPayload.Code(), + taskResult.TaskPayload.SubmissionID, + int(testcase.TestcaseID), + testcase.Stdin, + testcase.Stdout, + ); err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: err.Error(), + } + } + } + return nil +} + +func (hub *gameHub) processTaskResultRunTestcase( + taskResult *taskqueue.TaskResultRunTestcase, +) *codeSubmissionError { + if taskResult.Err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: taskResult.Err.Error(), + } + } + + if taskResult.Status != "success" { + if err := hub.q.CreateTestcaseResult(hub.ctx, db.CreateTestcaseResultParams{ + SubmissionID: int32(taskResult.TaskPayload.SubmissionID), + TestcaseID: int32(taskResult.TaskPayload.TestcaseID), + Status: taskResult.Status, + Stdout: taskResult.Stdout, + Stderr: taskResult.Stderr, + }); err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: err.Error(), + } + } + return &codeSubmissionError{ + Status: taskResult.Status, + Stdout: taskResult.Stdout, + Stderr: taskResult.Stderr, + } + } + if !isTestcaseResultCorrect(taskResult.TaskPayload.Stdout, taskResult.Stdout) { + if err := hub.q.CreateTestcaseResult(hub.ctx, db.CreateTestcaseResultParams{ + SubmissionID: int32(taskResult.TaskPayload.SubmissionID), + TestcaseID: int32(taskResult.TaskPayload.TestcaseID), + Status: "wrong_answer", + Stdout: taskResult.Stdout, + Stderr: taskResult.Stderr, + }); err != nil { + return &codeSubmissionError{ + Status: "internal_error", + Stderr: err.Error(), + } + } + return &codeSubmissionError{ + Status: "wrong_answer", + Stdout: taskResult.Stdout, + Stderr: taskResult.Stderr, + } + } + return nil +} + func (hub *gameHub) startGame() error { for player := range hub.players { player.s2cMessages <- &playerMessageS2CPrepare{ @@ -376,3 +614,9 @@ func (hubs *GameHubs) StartGame(gameID int) error { } return hub.startGame() } + +func isTestcaseResultCorrect(expectedStdout, actualStdout string) bool { + expectedStdout = strings.TrimSpace(expectedStdout) + actualStdout = strings.TrimSpace(actualStdout) + return actualStdout == expectedStdout +} diff --git a/backend/taskqueue/processor.go b/backend/taskqueue/processor.go index d771e61..ba35a1b 100644 --- a/backend/taskqueue/processor.go +++ b/backend/taskqueue/processor.go @@ -6,7 +6,6 @@ import ( "encoding/json" "fmt" "net/http" - "strings" "github.com/nsfisis/iosdc-japan-2024-albatross/backend/db" ) @@ -46,6 +45,7 @@ func (p *processor) doProcessTaskCompileSwiftToWasm( ctx context.Context, payload *TaskPayloadCompileSwiftToWasm, ) (*TaskResultCompileSwiftToWasm, error) { + _ = ctx type swiftcRequestData struct { MaxDuration int `json:"max_duration_ms"` Code string `json:"code"` @@ -71,27 +71,9 @@ func (p *processor) doProcessTaskCompileSwiftToWasm( if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { return nil, fmt.Errorf("json.Decode failed: %v", err) } - if resData.Status != "success" { - err := p.q.CreateSubmissionResult(ctx, db.CreateSubmissionResultParams{ - SubmissionID: int32(payload.SubmissionID), - Status: "compile_error", - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }) - if err != nil { - return nil, fmt.Errorf("CreateTestcaseResult failed: %v", err) - } - return &TaskResultCompileSwiftToWasm{ - TaskPayload: payload, - Status: "compile_error", - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }, nil - } - return &TaskResultCompileSwiftToWasm{ TaskPayload: payload, - Status: "success", + Status: resData.Status, Stdout: resData.Stdout, Stderr: resData.Stderr, }, nil @@ -101,6 +83,7 @@ func (p *processor) doProcessTaskCompileWasmToNativeExecutable( ctx context.Context, payload *TaskPayloadCompileWasmToNativeExecutable, ) (*TaskResultCompileWasmToNativeExecutable, error) { + _ = ctx type wasmcRequestData struct { MaxDuration int `json:"max_duration_ms"` Code string `json:"code"` @@ -126,27 +109,9 @@ func (p *processor) doProcessTaskCompileWasmToNativeExecutable( if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { return nil, fmt.Errorf("json.Decode failed: %v", err) } - if resData.Status != "success" { - err := p.q.CreateSubmissionResult(ctx, db.CreateSubmissionResultParams{ - SubmissionID: int32(payload.SubmissionID), - Status: "compile_error", - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }) - if err != nil { - return nil, fmt.Errorf("CreateTestcaseResult failed: %v", err) - } - return &TaskResultCompileWasmToNativeExecutable{ - TaskPayload: payload, - Status: "compile_error", - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }, nil - } - return &TaskResultCompileWasmToNativeExecutable{ TaskPayload: payload, - Status: "success", + Status: resData.Status, Stdout: resData.Stdout, Stderr: resData.Stderr, }, nil @@ -156,75 +121,40 @@ func (p *processor) doProcessTaskRunTestcase( ctx context.Context, payload *TaskPayloadRunTestcase, ) (*TaskResultRunTestcase, error) { - testcases, err := p.q.ListTestcasesByGameID(ctx, int32(payload.GameID())) + type testrunRequestData struct { + MaxDuration int `json:"max_duration_ms"` + Code string `json:"code"` + Stdin string `json:"stdin"` + } + type testrunResponseData struct { + Status string `json:"status"` + Stdout string `json:"stdout"` + Stderr string `json:"stderr"` + } + reqData := testrunRequestData{ + MaxDuration: 5000, + Code: payload.Code(), + Stdin: payload.Stdin, + } + reqJson, err := json.Marshal(reqData) if err != nil { - return nil, fmt.Errorf("ListTestcasesByGameID failed: %v", err) + return nil, fmt.Errorf("json.Marshal failed: %v", err) } - - for _, testcase := range testcases { - type testrunRequestData struct { - MaxDuration int `json:"max_duration_ms"` - Code string `json:"code"` - Stdin string `json:"stdin"` - } - type testrunResponseData struct { - Status string `json:"status"` - Stdout string `json:"stdout"` - Stderr string `json:"stderr"` - } - reqData := testrunRequestData{ - MaxDuration: 5000, - Code: payload.Code(), - Stdin: testcase.Stdin, - } - reqJson, err := json.Marshal(reqData) - if err != nil { - return nil, fmt.Errorf("json.Marshal failed: %v", err) - } - res, err := http.Post("http://worker:80/api/testrun", "application/json", bytes.NewBuffer(reqJson)) - if err != nil { - return nil, fmt.Errorf("http.Post failed: %v", err) - } - resData := testrunResponseData{} - if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { - return nil, fmt.Errorf("json.Decode failed: %v", err) - } - if resData.Status != "success" { - err := p.q.CreateTestcaseResult(ctx, db.CreateTestcaseResultParams{ - SubmissionID: int32(payload.SubmissionID), - TestcaseID: testcase.TestcaseID, - Status: resData.Status, - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }) - if err != nil { - return nil, fmt.Errorf("CreateTestcaseResult failed: %v", err) - } - return &TaskResultRunTestcase{ - TaskPayload: payload, - Status: resData.Status, - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }, nil - } - if !isTestcaseResultCorrect(testcase.Stdout, resData.Stdout) { - err := p.q.CreateTestcaseResult(ctx, db.CreateTestcaseResultParams{ - SubmissionID: int32(payload.SubmissionID), - TestcaseID: testcase.TestcaseID, - Status: "wrong_answer", - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }) - if err != nil { - return nil, fmt.Errorf("CreateTestcaseResult failed: %v", err) - } - return &TaskResultRunTestcase{ - TaskPayload: payload, - Status: "wrong_answer", - Stdout: resData.Stdout, - Stderr: resData.Stderr, - }, nil - } + res, err := http.Post("http://worker:80/api/testrun", "application/json", bytes.NewBuffer(reqJson)) + if err != nil { + return nil, fmt.Errorf("http.Post failed: %v", err) + } + resData := testrunResponseData{} + if err := json.NewDecoder(res.Body).Decode(&resData); err != nil { + return nil, fmt.Errorf("json.Decode failed: %v", err) + } + if resData.Status != "success" { + return &TaskResultRunTestcase{ + TaskPayload: payload, + Status: resData.Status, + Stdout: resData.Stdout, + Stderr: resData.Stderr, + }, nil } return &TaskResultRunTestcase{ @@ -232,9 +162,3 @@ func (p *processor) doProcessTaskRunTestcase( Status: "success", }, nil } - -func isTestcaseResultCorrect(expectedStdout, actualStdout string) bool { - expectedStdout = strings.TrimSpace(expectedStdout) - actualStdout = strings.TrimSpace(actualStdout) - return actualStdout == expectedStdout -} diff --git a/backend/taskqueue/queue.go b/backend/taskqueue/queue.go index b7d7381..515a406 100644 --- a/backend/taskqueue/queue.go +++ b/backend/taskqueue/queue.go @@ -83,6 +83,8 @@ func (q *Queue) EnqueueTaskRunTestcase( code string, submissionID int, testcaseID int, + stdin string, + stdout string, ) error { task, err := newTaskRunTestcase( gameID, @@ -90,6 +92,8 @@ func (q *Queue) EnqueueTaskRunTestcase( code, submissionID, testcaseID, + stdin, + stdout, ) if err != nil { return err diff --git a/backend/taskqueue/tasks.go b/backend/taskqueue/tasks.go index 990ce65..cbe83b1 100644 --- a/backend/taskqueue/tasks.go +++ b/backend/taskqueue/tasks.go @@ -112,6 +112,8 @@ type TaskPayloadRunTestcase struct { TaskPayloadBase SubmissionID int TestcaseID int + Stdin string + Stdout string } func newTaskRunTestcase( @@ -120,6 +122,8 @@ func newTaskRunTestcase( code string, submissionID int, testcaseID int, + stdin string, + stdout string, ) (*asynq.Task, error) { payload, err := json.Marshal(TaskPayloadRunTestcase{ TaskPayloadBase: TaskPayloadBase{ @@ -129,6 +133,8 @@ func newTaskRunTestcase( }, SubmissionID: submissionID, TestcaseID: testcaseID, + Stdin: stdin, + Stdout: stdout, }) if err != nil { return nil, err -- cgit v1.2.3-70-g09d2