Add logging options for queue

cmd/kjudge/main.go

@@ -12,8 +12,7 @@ import (
 	_ "github.com/natsukagami/kjudge/models"
 	"github.com/natsukagami/kjudge/server"
 	"github.com/natsukagami/kjudge/worker"
-	"github.com/natsukagami/kjudge/worker/isolate"
-	"github.com/natsukagami/kjudge/worker/raw"
+	"github.com/natsukagami/kjudge/worker/queue"
 )
 
 var (
@@ -34,15 +33,9 @@ func main() {
 	}
 	defer db.Close()
 
-	var sandbox worker.Sandbox
-	switch *sandboxImpl {
-	case "raw":
-		log.Println("'raw' sandbox selected. WE ARE NOT RESPONSIBLE FOR ANY BREAKAGE CAUSED BY FOREIGN CODE.")
-		sandbox = &raw.Sandbox{}
-	case "isolate":
-		sandbox = isolate.New()
-	default:
-		log.Fatalf("Sandbox %s doesn't exists or not yet implemented.", *sandboxImpl)
+	sandbox, err := worker.NewSandbox(*sandboxImpl)
+	if err != nil {
+		log.Fatalf("%v", err)
 	}
 
 	opts := []server.Opt{}
@@ -51,7 +44,7 @@ func main() {
 	}
 
 	// Start the queue
-	queue := worker.Queue{Sandbox: sandbox, DB: db}
+	queue := queue.NewQueue(db, sandbox)
 
 	// Build the server
 	server, err := server.New(db, opts...)

db/migrations.go

@@ -4,7 +4,7 @@ import (
 	"database/sql"
 	"io/fs"
 	"log"
-	"path/filepath"
+	"path"
 	"regexp"
 	"sort"
 
@@ -44,7 +44,7 @@ func (db *DB) migrate() error {
 
 	// Do migrations one by one
 	for _, name := range versions {
-		sqlFile := filepath.Join(assetsSql, name+".sql")
+		sqlFile := path.Join(assetsSql, name+".sql")
 		file, err := fs.ReadFile(embed.Content, sqlFile)
 		if err != nil {
 			return errors.Wrapf(err, "File %s", sqlFile)

embed/embed_dev.go

@@ -8,18 +8,25 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"runtime"
 )
 
 // Content serves content in the /embed directory.
 var Content fs.FS
 
+func getEmbedDir() string {
+	_, path, _, _ := runtime.Caller(0)
+	return filepath.Dir(path)
+}
+
 func init() {
-	wd, err := os.Getwd()
-	if err != nil {
-		log.Panicf("cannot get current directory: %v", err)
-	}
+	// wd, err := os.Getwd()
+	// if err != nil {
+	// 	log.Panicf("cannot get current directory: %v", err)
+	// }
 
-	embedDir := filepath.Join(wd, "embed")
+	// embedDir := filepath.Join(wd, "embed")
+	embedDir := getEmbedDir()
 	stat, err := os.Stat(embedDir)
 	if err != nil {
 		log.Panicf("cannot stat embed directory: %v", err)

go.mod

@@ -13,7 +13,7 @@ require (
 	github.com/mattn/go-sqlite3 v1.14.0
 	github.com/pkg/errors v0.9.1
 	golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e
-	golang.org/x/net v0.7.0
+	golang.org/x/net v0.7.0 // indirect
 	golang.org/x/text v0.7.0
 	golang.org/x/tools v0.1.12
 	google.golang.org/appengine v1.6.5 // indirect

scripts/windows/production_test.ps1

@@ -0,0 +1,8 @@
+$ErrorActionPreference = "Stop"
+Remove-Item kjudge.db*
+
+& "scripts\windows\production_build.ps1"
+
+Invoke-Expression ".\kjudge $args"
+
+# pwsh -c scripts/windows/production_test.ps1 --sandbox=raw to run this test script

worker/compile.go

@@ -25,9 +25,17 @@ import (
 
 // CompileContext is the information needed to perform compilation.
 type CompileContext struct {
-	DB      *sqlx.Tx
-	Sub     *models.Submission
-	Problem *models.Problem
+	DB        *sqlx.Tx
+	Sub       *models.Submission
+	Problem   *models.Problem
+	AllowLogs bool
+}
+
+func (c *CompileContext) Log(format string, v ...interface{}) {
+	if !c.AllowLogs {
+		return
+	}
+	log.Printf(format, v...)
 }
 
 // Compile performs compilation.
@@ -65,7 +73,7 @@ func Compile(c *CompileContext) (bool, error) {
 		return false, c.Sub.Write(c.DB)
 	}
 
-	log.Printf("[WORKER] Compiling submission %v\n", c.Sub.ID)
+	c.Log("[WORKER] Compiling submission %v\n", c.Sub.ID)
 
 	// Now, create a temporary directory.
 	dir, err := os.MkdirTemp("", "*")
@@ -96,7 +104,8 @@ func Compile(c *CompileContext) (bool, error) {
 		c.Sub.CompiledSource = nil
 		c.Sub.Verdict = models.VerdictCompileError
 	}
-	log.Printf("[WORKER] Compiling submission %v succeeded (result = %v).", c.Sub.ID, result)
+
+	c.Log("[WORKER] Compiling submission %v succeeded (result = %v).", c.Sub.ID, result)
 
 	return result, c.Sub.Write(c.DB)
 }

worker/queue.go → worker/queue/queue.go

@@ -1,4 +1,4 @@
-package worker
+package queue
 
 import (
 	"log"
@@ -7,20 +7,30 @@ import (
 	"github.com/mattn/go-sqlite3"
 	"github.com/natsukagami/kjudge/db"
 	"github.com/natsukagami/kjudge/models"
+	"github.com/natsukagami/kjudge/worker"
+	"github.com/natsukagami/kjudge/worker/sandbox"
 	"github.com/pkg/errors"
 )
 
 // Queue implements a queue that runs each job one by one.
 type Queue struct {
-	DB      *db.DB
-	Sandbox Sandbox
+	DB       *db.DB
+	Sandbox  sandbox.Runner
+	Settings Settings
+}
+
+func NewQueue(db *db.DB, sandbox sandbox.Runner, options ...Option) Queue {
+	setting := DefaultSettings
+	for _, option := range options {
+		setting = option(setting)
+	}
+	return Queue{DB: db, Sandbox: sandbox, Settings: setting}
 }
 
 // Start starts the queue. It is blocking, so might wanna "go run" it.
 func (q *Queue) Start() {
 	// Register the update callback
 	toUpdate := q.startHook()
-
 	for {
 		// Get the newest job
 		job, err := models.FirstJob(q.DB)
@@ -41,6 +51,25 @@ func (q *Queue) Start() {
 	}
 }
 
+// Run starts the queue, solves all pending jobs, then returns
+func (q *Queue) Run() {
+	for {
+		job, err := models.FirstJob(q.DB)
+		if err != nil {
+			log.Printf("[WORKER] Fetching job failed: %+v\n", err)
+			continue
+		}
+		if job == nil {
+			return
+		}
+
+		if err := q.HandleJob(job); err != nil {
+			log.Printf("[WORKER] Handling job failed: %+v\n", err)
+		}
+		_ = job.Delete(q.DB)
+	}
+}
+
 // HandleJob dispatches a job.
 func (q *Queue) HandleJob(job *models.Job) error {
 	// Start a job with a context and submission
@@ -60,7 +89,8 @@ func (q *Queue) HandleJob(job *models.Job) error {
 	}
 	switch job.Type {
 	case models.JobTypeCompile:
-		if _, err := Compile(&CompileContext{DB: tx, Sub: sub, Problem: problem}); err != nil {
+		if _, err := worker.Compile(&worker.CompileContext{
+			DB: tx, Sub: sub, Problem: problem, AllowLogs: q.Settings.LogCompile}); err != nil {
 			return err
 		}
 	case models.JobTypeRun:
@@ -72,16 +102,17 @@ func (q *Queue) HandleJob(job *models.Job) error {
 		if err != nil {
 			return err
 		}
-		if err := Run(q.Sandbox, &RunContext{
-			DB: tx, Sub: sub, Problem: problem, TestGroup: tg, Test: test}); err != nil {
+		if err := worker.Run(q.Sandbox, &worker.RunContext{
+			DB: tx, Sub: sub, Problem: problem, TestGroup: tg, Test: test, AllowLogs: q.Settings.LogRun}); err != nil {
 			return err
 		}
 	case models.JobTypeScore:
 		contest, err := models.GetContest(tx, problem.ContestID)
 		if err != nil {
 			return err
 		}
-		if err := Score(&ScoreContext{DB: tx, Sub: sub, Problem: problem, Contest: contest}); err != nil {
+		if err := worker.Score(&worker.ScoreContext{
+			DB: tx, Sub: sub, Problem: problem, Contest: contest, AllowLogs: q.Settings.LogScore}); err != nil {
 			return err
 		}
 	}

worker/queue/settings.go

@@ -0,0 +1,32 @@
+package queue
+
+type Settings struct {
+	LogCompile bool
+	LogRun     bool
+	LogScore   bool
+}
+
+var DefaultSettings = Settings{LogCompile: true, LogRun: true, LogScore: true}
+
+type Option func(Settings) Settings
+
+func CompileLogs(enable bool) Option {
+	return func(o Settings) Settings {
+		o.LogCompile = enable
+		return o
+	}
+}
+
+func RunLogs(enable bool) Option {
+	return func(o Settings) Settings {
+		o.LogRun = enable
+		return o
+	}
+}
+
+func ScoreLogs(enable bool) Option {
+	return func(o Settings) Settings {
+		o.LogScore = enable
+		return o
+	}
+}