Merge branch 'feat/taskqueue'

5 files changed, 510 insertions, 190 deletions

diff --git a/backend/taskqueue/processor.go b/backend/taskqueue/processor.go
index 1d4c412..b64b01c 100644
--- a/backend/taskqueue/processor.go
+++ b/backend/taskqueue/processor.go
@@ -6,195 +6,150 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"strings"
-
-	"github.com/hibiken/asynq"
 
 	"github.com/nsfisis/iosdc-japan-2024-albatross/backend/db"
 )
 
-type ExecProcessor struct {
+type processor struct {
 	q *db.Queries
-	c chan string
 }
 
-func NewExecProcessor(q *db.Queries, c chan string) *ExecProcessor {
-	return &ExecProcessor{
+func newProcessor(q *db.Queries) processor {
+	return processor{
 		q: q,
-		c: c,
 	}
 }
 
-func (p *ExecProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error {
-	var payload TaskExecPlayload
-	if err := json.Unmarshal(t.Payload(), &payload); err != nil {
-		return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
-	}
-
+func (p *processor) doProcessTaskCreateSubmissionRecord(
+	ctx context.Context,
+	payload *TaskPayloadCreateSubmissionRecord,
+) (*TaskResultCreateSubmissionRecord, error) {
 	// 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 {
-		return fmt.Errorf("CreateSubmission failed: %v", err)
+		return nil, err
 	}
 
-	{
-		type swiftcRequestData struct {
-			MaxDuration int    `json:"max_duration_ms"`
-			Code        string `json:"code"`
-		}
-		type swiftcResponseData struct {
-			Result string `json:"result"`
-			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))
-		if err != nil {
-			return fmt.Errorf("http.Post 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.Result != "success" {
-			err := p.q.CreateTestcaseExecution(ctx, db.CreateTestcaseExecutionParams{
-				SubmissionID: submissionID,
-				TestcaseID:   nil,
-				Status:       "compile_error",
-				Stdout:       resData.Stdout,
-				Stderr:       resData.Stderr,
-			})
-			if err != nil {
-				return fmt.Errorf("CreateTestcaseExecution failed: %v", err)
-			}
-			p.c <- "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 {
-			Result string `json:"result"`
-			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))
-		if err != nil {
-			return fmt.Errorf("http.Post 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.Result != "success" {
-			err := p.q.CreateTestcaseExecution(ctx, db.CreateTestcaseExecutionParams{
-				SubmissionID: submissionID,
-				TestcaseID:   nil,
-				Status:       "compile_error",
-				Stdout:       resData.Stdout,
-				Stderr:       resData.Stderr,
-			})
-			if err != nil {
-				return fmt.Errorf("CreateTestcaseExecution failed: %v", err)
-			}
-			p.c <- "compile_error"
-			return fmt.Errorf("wasmc failed: %v", resData.Stderr)
-		}
-	}
+	return &TaskResultCreateSubmissionRecord{
+		TaskPayload:  payload,
+		SubmissionID: int(submissionID),
+	}, nil
+}
 
-	testcases, err := p.q.ListTestcasesByGameID(ctx, int32(payload.GameID))
+func (p *processor) doProcessTaskCompileSwiftToWasm(
+	_ context.Context,
+	payload *TaskPayloadCompileSwiftToWasm,
+) (*TaskResultCompileSwiftToWasm, error) {
+	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("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 {
-			Result string `json:"result"`
-			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 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 fmt.Errorf("http.Post failed: %v", err)
-		}
-		resData := testrunResponseData{}
-		if err := json.NewDecoder(res.Body).Decode(&resData); err != nil {
-			return fmt.Errorf("json.Decode failed: %v", err)
-		}
-		if resData.Result != "success" {
-			err := p.q.CreateTestcaseExecution(ctx, db.CreateTestcaseExecutionParams{
-				SubmissionID: submissionID,
-				TestcaseID:   &testcase.TestcaseID,
-				Status:       resData.Result,
-				Stdout:       resData.Stdout,
-				Stderr:       resData.Stderr,
-			})
-			if err != nil {
-				return fmt.Errorf("CreateTestcaseExecution failed: %v", err)
-			}
-			p.c <- resData.Result
-			return fmt.Errorf("testrun failed: %v", resData.Stderr)
-		}
-		if !isTestcaseExecutionCorrect(testcase.Stdout, resData.Stdout) {
-			err := p.q.CreateTestcaseExecution(ctx, db.CreateTestcaseExecutionParams{
-				SubmissionID: submissionID,
-				TestcaseID:   &testcase.TestcaseID,
-				Status:       "wrong_answer",
-				Stdout:       resData.Stdout,
-				Stderr:       resData.Stderr,
-			})
-			if err != nil {
-				return fmt.Errorf("CreateTestcaseExecution failed: %v", err)
-			}
-			p.c <- "wrong_answer"
-			return fmt.Errorf("testrun failed: %v", resData.Stdout)
-		}
+	res, err := http.Post("http://worker:80/api/swiftc", "application/json", bytes.NewBuffer(reqJson))
+	if err != nil {
+		return nil, fmt.Errorf("http.Post failed: %v", err)
+	}
+	resData := swiftcResponseData{}
+	if err := json.NewDecoder(res.Body).Decode(&resData); err != nil {
+		return nil, fmt.Errorf("json.Decode failed: %v", err)
 	}
+	return &TaskResultCompileSwiftToWasm{
+		TaskPayload: payload,
+		Status:      resData.Status,
+		Stdout:      resData.Stdout,
+		Stderr:      resData.Stderr,
+	}, nil
+}
 
-	p.c <- "success"
-	return nil
+func (p *processor) doProcessTaskCompileWasmToNativeExecutable(
+	_ context.Context,
+	payload *TaskPayloadCompileWasmToNativeExecutable,
+) (*TaskResultCompileWasmToNativeExecutable, error) {
+	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 nil, fmt.Errorf("json.Marshal failed: %v", err)
+	}
+	res, err := http.Post("http://worker:80/api/wasmc", "application/json", bytes.NewBuffer(reqJson))
+	if err != nil {
+		return nil, fmt.Errorf("http.Post failed: %v", err)
+	}
+	resData := wasmcResponseData{}
+	if err := json.NewDecoder(res.Body).Decode(&resData); err != nil {
+		return nil, fmt.Errorf("json.Decode failed: %v", err)
+	}
+	return &TaskResultCompileWasmToNativeExecutable{
+		TaskPayload: payload,
+		Status:      resData.Status,
+		Stdout:      resData.Stdout,
+		Stderr:      resData.Stderr,
+	}, nil
 }
 
-func isTestcaseExecutionCorrect(expectedStdout, actualStdout string) bool {
-	expectedStdout = strings.TrimSpace(expectedStdout)
-	actualStdout = strings.TrimSpace(actualStdout)
-	return actualStdout == expectedStdout
+func (p *processor) doProcessTaskRunTestcase(
+	_ context.Context,
+	payload *TaskPayloadRunTestcase,
+) (*TaskResultRunTestcase, error) {
+	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("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)
+	}
+	return &TaskResultRunTestcase{
+		TaskPayload: payload,
+		Status:      resData.Status,
+		Stdout:      resData.Stdout,
+		Stderr:      resData.Stderr,
+	}, nil
 }
diff --git a/backend/taskqueue/processor_wrapper.go b/backend/taskqueue/processor_wrapper.go
new file mode 100644
index 0000000..b1fbd16
--- /dev/null
+++ b/backend/taskqueue/processor_wrapper.go
@@ -0,0 +1,112 @@
+// Code generated by go generate; DO NOT EDIT.
+
+package taskqueue
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/hibiken/asynq"
+)
+
+type processorWrapper struct {
+	impl    processor
+	results chan TaskResult
+}
+
+func newProcessorWrapper(impl processor) *processorWrapper {
+	return &processorWrapper{
+		impl:    impl,
+		results: make(chan TaskResult),
+	}
+}
+
+func (p *processorWrapper) processTaskCompileSwiftToWasm(ctx context.Context, t *asynq.Task) error {
+	var payload TaskPayloadCompileSwiftToWasm
+	if err := json.Unmarshal(t.Payload(), &payload); err != nil {
+		err := fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
+		p.results <- &TaskResultCompileSwiftToWasm{Err: err}
+		return err
+	}
+
+	result, err := p.impl.doProcessTaskCompileSwiftToWasm(ctx, &payload)
+	if err != nil {
+		retryCount, _ := asynq.GetRetryCount(ctx)
+		maxRetry, _ := asynq.GetMaxRetry(ctx)
+		isRecoverable := !errors.Is(err, asynq.SkipRetry) && retryCount < maxRetry
+		if !isRecoverable {
+			p.results <- &TaskResultCompileSwiftToWasm{Err: err}
+		}
+		return err
+	}
+	p.results <- result
+	return nil
+}
+
+func (p *processorWrapper) processTaskCompileWasmToNativeExecutable(ctx context.Context, t *asynq.Task) error {
+	var payload TaskPayloadCompileWasmToNativeExecutable
+	if err := json.Unmarshal(t.Payload(), &payload); err != nil {
+		err := fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
+		p.results <- &TaskResultCompileWasmToNativeExecutable{Err: err}
+		return err
+	}
+
+	result, err := p.impl.doProcessTaskCompileWasmToNativeExecutable(ctx, &payload)
+	if err != nil {
+		retryCount, _ := asynq.GetRetryCount(ctx)
+		maxRetry, _ := asynq.GetMaxRetry(ctx)
+		isRecoverable := !errors.Is(err, asynq.SkipRetry) && retryCount < maxRetry
+		if !isRecoverable {
+			p.results <- &TaskResultCompileWasmToNativeExecutable{Err: err}
+		}
+		return err
+	}
+	p.results <- result
+	return nil
+}
+
+func (p *processorWrapper) processTaskCreateSubmissionRecord(ctx context.Context, t *asynq.Task) error {
+	var payload TaskPayloadCreateSubmissionRecord
+	if err := json.Unmarshal(t.Payload(), &payload); err != nil {
+		err := fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
+		p.results <- &TaskResultCreateSubmissionRecord{Err: err}
+		return err
+	}
+
+	result, err := p.impl.doProcessTaskCreateSubmissionRecord(ctx, &payload)
+	if err != nil {
+		retryCount, _ := asynq.GetRetryCount(ctx)
+		maxRetry, _ := asynq.GetMaxRetry(ctx)
+		isRecoverable := !errors.Is(err, asynq.SkipRetry) && retryCount < maxRetry
+		if !isRecoverable {
+			p.results <- &TaskResultCreateSubmissionRecord{Err: err}
+		}
+		return err
+	}
+	p.results <- result
+	return nil
+}
+
+func (p *processorWrapper) processTaskRunTestcase(ctx context.Context, t *asynq.Task) error {
+	var payload TaskPayloadRunTestcase
+	if err := json.Unmarshal(t.Payload(), &payload); err != nil {
+		err := fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
+		p.results <- &TaskResultRunTestcase{Err: err}
+		return err
+	}
+
+	result, err := p.impl.doProcessTaskRunTestcase(ctx, &payload)
+	if err != nil {
+		retryCount, _ := asynq.GetRetryCount(ctx)
+		maxRetry, _ := asynq.GetMaxRetry(ctx)
+		isRecoverable := !errors.Is(err, asynq.SkipRetry) && retryCount < maxRetry
+		if !isRecoverable {
+			p.results <- &TaskResultRunTestcase{Err: err}
+		}
+		return err
+	}
+	p.results <- result
+	return nil
+}
diff --git a/backend/taskqueue/queue.go b/backend/taskqueue/queue.go
index 53ec6d6..515a406 100644
--- a/backend/taskqueue/queue.go
+++ b/backend/taskqueue/queue.go
@@ -20,6 +20,84 @@ 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,
+	stdin string,
+	stdout string,
+) error {
+	task, err := newTaskRunTestcase(
+		gameID,
+		userID,
+		code,
+		submissionID,
+		testcaseID,
+		stdin,
+		stdout,
+	)
+	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 cd67948..cbe83b1 100644
--- a/backend/taskqueue/tasks.go
+++ b/backend/taskqueue/tasks.go
@@ -6,24 +6,191 @@ 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
+	Stdin        string
+	Stdout       string
+}
+
+func newTaskRunTestcase(
+	gameID int,
+	userID int,
+	code string,
+	submissionID int,
+	testcaseID int,
+	stdin string,
+	stdout string,
+) (*asynq.Task, error) {
+	payload, err := json.Marshal(TaskPayloadRunTestcase{
+		TaskPayloadBase: TaskPayloadBase{
+			GameID: gameID,
+			UserID: userID,
+			Code:   code,
+		},
+		SubmissionID: submissionID,
+		TestcaseID:   testcaseID,
+		Stdin:        stdin,
+		Stdout:       stdout,
 	})
 	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 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 485d6d3..317f61c 100644
--- a/backend/taskqueue/worker_server.go
+++ b/backend/taskqueue/worker_server.go
@@ -7,27 +7,35 @@ import (
 )
 
 type WorkerServer struct {
-	server  *asynq.Server
-	queries *db.Queries
-	c       chan string
+	server    *asynq.Server
+	processor *processorWrapper
 }
 
-func NewWorkerServer(redisAddr string, queries *db.Queries, c chan string) *WorkerServer {
+func NewWorkerServer(redisAddr string, queries *db.Queries) *WorkerServer {
+	server := asynq.NewServer(
+		asynq.RedisClientOpt{
+			Addr: redisAddr,
+		},
+		asynq.Config{},
+	)
+	processor := newProcessorWrapper(newProcessor(queries))
 	return &WorkerServer{
-		server: asynq.NewServer(
-			asynq.RedisClientOpt{
-				Addr: redisAddr,
-			},
-			asynq.Config{},
-		),
-		queries: queries,
-		c:       c,
+		server:    server,
+		processor: processor,
 	}
 }
 
 func (s *WorkerServer) Run() error {
 	mux := asynq.NewServeMux()
-	mux.Handle(TaskTypeExec, NewExecProcessor(s.queries, s.c))
+
+	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 TaskResult {
+	return s.processor.results
+}