woj-server/internal/service/runner/run_judge.go

package runner

import (
	"fmt"
	"git.0x7f.app/WOJ/woj-server/internal/e"
	"git.0x7f.app/WOJ/woj-server/pkg/file"
	"git.0x7f.app/WOJ/woj-server/pkg/utils"
	"github.com/opencontainers/runtime-spec/specs-go"
	"go.uber.org/zap"
	"os"
	"path/filepath"
	"strings"
	"time"
)

func (s *service) SandboxArgsBuilder(meta *JudgeMeta, cLang *ConfigLanguage, id int) string {
	var args []string

	args = append(args, fmt.Sprintf("--memory_limit=%d", cLang.Runtime.Run.MemoryLimit))
	args = append(args, fmt.Sprintf("--nproc_limit=%d", cLang.Runtime.Run.NProcLimit))
	args = append(args, fmt.Sprintf("--time_limit=%d", cLang.Runtime.Run.TimeLimit))
	args = append(args, fmt.Sprintf("--sandbox_template=%s", cLang.Lang))
	args = append(args, fmt.Sprintf("--sandbox_action=ret"))
	args = append(args, fmt.Sprintf("--uid=1000"))
	args = append(args, fmt.Sprintf("--gid=1000"))
	args = append(args, fmt.Sprintf("--file_input=/woj/problem/data/input/%d.input", id))
	args = append(args, fmt.Sprintf("--file_output=/woj/user/%d.out.usr", id))
	args = append(args, fmt.Sprintf("--file_info=/woj/user/%d.info", id))
	args = append(args, fmt.Sprintf("--program=/woj/user/%s.out", meta.User))

	return strings.Join(args, " ")
}

func (s *service) ProblemRun(meta *JudgeMeta, config *Config, cLang *ConfigLanguage) {
	workDir := filepath.Join(UserDir, meta.User)
	dataDir := filepath.Join(ProblemDir, fmt.Sprintf("%d", meta.Version), "data", "input")

	runtimeArgs := RuntimeArgs{
		Image: ContainerImageRun,
		// sh, woj_launcher:program, woj_launcher:killer, woj_launcher:stat
		Pid:    int64(cLang.Runtime.Run.NProcLimit + 4),
		Memory: uint64(cLang.Runtime.Run.MemoryLimit * 1024 * 1024),
		// woj-sandbox killer will add 1 more second, here we add 1 also
		Timeout: time.Duration((cLang.Runtime.Run.TimeLimit+1000)/1000+1+1) * time.Second,
	}

	ids := make([]int, 0)
	for _, task := range config.Tasks {
		f := func(id int) func() error {
			return func() error {
				testCase := filepath.Join(dataDir, fmt.Sprintf("%d.input", id))
				targetFile := filepath.Join(workDir, fmt.Sprintf("%s.out", meta.User))
				ansFile := filepath.Join(workDir, fmt.Sprintf("%d.out.usr", id))
				ifoFile := filepath.Join(workDir, fmt.Sprintf("%d.info", id))

				args := &RunArgs{
					Program: ProgramArgs{
						Args: []string{
							"sh", "-c",
							"cd /woj/user && /woj/framework/scripts/woj_launcher " +
								s.SandboxArgsBuilder(meta, cLang, id),
						},
					},
					Runtime: runtimeArgs,
				}
				args.Runtime.Mount = []specs.Mount{
					{
						Source:      testCase,
						Destination: fmt.Sprintf("/woj/problem/data/input/%d.input", id),
						Type:        "bind",
						Options:     []string{"rbind", "ro"},
					},
					{
						Source:      targetFile,
						Destination: fmt.Sprintf("/woj/user/%s.out", meta.User),
						Type:        "bind",
						Options:     []string{"rbind", "ro"},
					},
					{
						Source:      ansFile,
						Destination: fmt.Sprintf("/woj/user/%d.out.usr", id),
						Type:        "bind",
						Options:     []string{"rbind"},
					},
					{
						Source:      ifoFile,
						Destination: fmt.Sprintf("/woj/user/%d.info", id),
						Type:        "bind",
						Options:     []string{"rbind"},
					},
				}

				err := utils.NewMust().
					DoAny(func() error { return os.Remove(ansFile) }).
					DoAny(func() error { return os.Remove(ifoFile) }).
					Do(func() error { return file.TouchErr(ansFile) }).
					Do(func() error { return file.TouchErr(ifoFile) }).
					Do(func() error { return s.ContainerRun(args) }).
					Done()

				if err != nil {
					s.log.Info("[run] run failed", zap.Error(err), zap.Any("meta", *meta))
				}
				return err
			}
		}(task.Id)

		id := s.pool.AddTask(f)
		ids = append(ids, id)
	}

	for _, id := range ids {
		_ = s.pool.WaitForTask(id)
	}
}

func (s *service) ProblemJudge(meta *JudgeMeta, config *Config, cLang *ConfigLanguage) {
	workDir := filepath.Join(UserDir, meta.User)
	dataDir := filepath.Join(ProblemDir, fmt.Sprintf("%d", meta.Version), "data")
	judgeDir := filepath.Join(ProblemDir, fmt.Sprintf("%d", meta.Version), "judge")
	script := cLang.JudgeScript()

	runtimeArgs := RuntimeArgs{
		Image:   ContainerImageFull,
		Pid:     int64(cLang.Runtime.Check.NProcLimit + 2), // bash + make
		Memory:  uint64(cLang.Runtime.Check.MemoryLimit * 1024 * 1024),
		Timeout: time.Duration((cLang.Runtime.Check.TimeLimit+1000)/1000) * time.Second,
	}

	ids := make([]int, 0)
	for _, task := range config.Tasks {
		f := func(id int) func() error {
			return func() error {
				ansFile := filepath.Join(workDir, fmt.Sprintf("%d.out.usr", id))
				jdgFile := filepath.Join(workDir, fmt.Sprintf("%d.judge", id))

				args := &RunArgs{
					Program: ProgramArgs{
						Args: []string{
							"sh", "-c",
							fmt.Sprintf("cd /woj/user && make -f %s judge", script),
						},
						Env: []string{
							fmt.Sprintf("TEST_NUM=%d", id),
							fmt.Sprintf("CMP=%s", cLang.Judge.Cmp),
						},
					},
					Runtime: runtimeArgs,
				}
				args.Runtime.Mount = []specs.Mount{
					{
						Source:      judgeDir,
						Destination: "/woj/problem/judge",
						Type:        "bind",
						Options:     []string{"rbind", "ro"},
					},
					{
						Source:      dataDir,
						Destination: "/woj/problem/data",
						Type:        "bind",
						Options:     []string{"rbind", "ro"},
					},
					{
						Source:      ansFile,
						Destination: fmt.Sprintf("/woj/user/%d.out.usr", id),
						Type:        "bind",
						Options:     []string{"rbind"},
					},
					{
						Source:      jdgFile,
						Destination: fmt.Sprintf("/woj/user/%d.judge", id),
						Type:        "bind",
						Options:     []string{"rbind"},
					},
				}

				err := utils.NewMust().
					DoAny(func() error { return os.Remove(jdgFile) }).
					Do(func() error { return file.TouchErr(jdgFile) }).
					Do(func() error { return s.ContainerRun(args) }).
					Done()

				if err != nil {
					s.log.Info("[judge] judge failed", zap.Error(err), zap.Any("meta", *meta))
				}
				return err
			}
		}(task.Id)

		id := s.pool.AddTask(f)
		ids = append(ids, id)
	}

	for _, id := range ids {
		_ = s.pool.WaitForTask(id)
	}
}

func (s *service) RunAndJudge(meta *JudgeMeta) (*JudgeStatus, int32, e.Status) {
	// 1. ensure problem/user exists
	status := s.ValidatePath(meta)
	if status != e.Success {
		return &JudgeStatus{Message: "check failed"}, 0, status
	}

	// 2. config
	config, cLang, status := s.GetConfig(meta, true)
	if status != e.Success {
		return &JudgeStatus{Message: status.String()}, 0, status
	}

	// 3. run user program
	s.ProblemRun(meta, config, cLang)

	// 4. run judge
	s.ProblemJudge(meta, config, cLang)

	// 5. check result
	result, pts := s.CheckResults(meta, config, cLang)

	return result, pts, e.Success
}