Go Playground の仕組みを調べてみた

<input type="button" value="Run" id="run" />

<script src="/playground.js"></script>
<script>
  playground({
    codeEl: "#code",
    outputEl: "#output",
    runEl: "#run, #embedRun",
    fmtEl: "#fmt",
    fmtImportEl: "#imports",
    shareEl: "#share",
    shareURLEl: "#shareURL",
    enableHistory: true,
    enableShortcuts: true,
    enableVet: true,
    toysEl: ".js-playgroundToysEl",
  });
</script>

function playground(opts) {
  var transport = new HTTPTransport(opts['enableVet']);

  function run() {
    transport.Run(
      body(),
      highlightOutput(PlaygroundOutput(output[0]))
    );
  }

  $(opts.runEl).click(run);
}

function HTTPTransport(enableVet) {
  return {
    Run: function (body, output, options) {
      $.ajax('/compile', {
        type: 'POST',
        data: { version: 2, body: body, withVet: enableVet },
        dataType: 'json',
        success: function (data) {
          ...
        },
        error: function () {
          ...
        },
      });
      ...
    },
  };
}

func compileAndRun(ctx context.Context, req *request) (*response, error) {
	// Go コードのビルド
	br, err := sandboxBuild(ctx, tmpDir, []byte(req.Body), req.WithVet)
	if err != nil {
		return nil, err
	}

	// ビルドしたバイナリをバックエンドサーバーで実行
	execRes, err := sandboxRun(ctx, br.exePath, br.testParam)

	rec := new(Recorder)
	rec.Stdout().Write(execRes.Stdout)
	rec.Stderr().Write(execRes.Stderr)
	events, err := rec.Events()

	return &response{
		Events:      events,
		Status:      execRes.ExitCode,
		IsTest:      br.testParam != "",
		TestsFailed: fails,
		VetErrors:   br.vetOut,
		VetOK:       req.WithVet && br.vetOut == "",
	}, nil
}

func sandboxBuild(ctx context.Context, tmpDir string, in []byte, vet bool) (br *buildResult, err error) {
br.exePath = filepath.Join(tmpDir, "a.out")

	var goArgs []string
	goArgs = append(goArgs, "build")

	goArgs = append(goArgs, "-o", br.exePath, "-tags=faketime")

	cmd := exec.Command("/usr/local/go/bin/go", goArgs...)

	if err := cmd.Start(); err != nil {
		return nil, fmt.Errorf("error starting go build: %v", err)
	}

	return br, nil
}

func sandboxRun(ctx context.Context, exePath string, testParam string) (execRes sandboxtypes.Response, err error) {
	// ビルドしたバイナリファイルの読み込み
	exeBytes, err := os.ReadFile(exePath)

	ctx, cancel := context.WithTimeout(ctx, maxRunTime)
	defer cancel()
	sreq, err := http.NewRequestWithContext(ctx, "POST", sandboxBackendURL(), bytes.NewReader(exeBytes))

	sreq.GetBody = func() (io.ReadCloser, error) { return io.NopCloser(bytes.NewReader(exeBytes)), nil }

	// バックエンドサーバーにリクエストを送信
	res, err := sandboxBackendClient().Do(sreq)

	defer res.Body.Close()

	if err := json.NewDecoder(res.Body).Decode(&execRes); err != nil {
		log.Printf("JSON decode error from backend: %v", err)
		return execRes, errors.New("error parsing JSON from backend")
	}
	return execRes, nil
}

var (
	mode       = flag.String("mode", "server", "Whether to run in \"server\" mode or \"contained\" mode. The contained mode is used internally by the server mode.")
)

func main() {
	flag.Parse()
	// フラグによる分岐
	if *mode == "contained" {
		// gVisor で標準入力で受け取ったバイナリを実行
		runInGvisor()
		panic("runInGvisor didn't exit")
	}

	// チャネルの初期化
	readyContainer = make(chan *Container)

	mux := http.NewServeMux()
	// バイナリファイルが送られたら、runHandler で処理
	mux.Handle("/run", ochttp.WithRouteTag(http.HandlerFunc(runHandler), "/run"))

	// worker の立ち上げ
	makeWorkers()

	httpServer = &http.Server{
		Addr:    *listenAddr,
		Handler: &ochttp.Handler{Handler: mux},
	}
	// server の起動
	log.Fatal(httpServer.ListenAndServe())
}

func makeWorkers() {
	ctx := context.Background()
	for i := 0; i < *numWorkers; i++ {
		go workerLoop(ctx)
	}
}

func workerLoop(ctx context.Context) {
	for {
		c, err := startContainer(ctx)
		if err != nil {
			log.Printf("error starting container: %v", err)
			time.Sleep(5 * time.Second)
			continue
		}
		readyContainer <- c
	}
}

func startContainer(ctx context.Context) (c *Container, err error) {
	name := "play_run_" + randHex(8)

	cmd := exec.Command("docker", "run",
		"--name="+name,
		"--rm",
		"--tmpfs=/tmpfs:exec",
		"-i", // 標準入力を受け付ける状態で待機

		"--runtime=runsc", // gVisor のランタイム
		"--network=none",
		"--memory="+fmt.Sprint(memoryLimitBytes),

		*container,
		"--mode=contained") // mode の分岐用のフラグ

	stdin, err := cmd.StdinPipe()
	pr, pw := io.Pipe()
	stdout := &limitedWriter{dst: &bytes.Buffer{}, n: maxOutputSize + int64(len(containedStartMessage))}
	stderr := &limitedWriter{dst: &bytes.Buffer{}, n: maxOutputSize}
	cmd.Stdout = &switchWriter{switchAfter: []byte(containedStartMessage), dst1: pw, dst2: stdout}
	cmd.Stderr = stderr

	// docker run の実行。
	// 標準入力に書き込まれるのを待つ状態の container を立ち上げる
	if err := cmd.Start(); err != nil {
		return nil, err
	}

	ctx, cancel := context.WithCancel(ctx)
	c = &Container{
		name:      name,
		stdin:     stdin,
		stdout:    stdout,
		stderr:    stderr,
		cmd:       cmd,
		cancelCmd: cancel,
		waitErr:   make(chan error, 1),
	}

	return c, nil
}

func runHandler(w http.ResponseWriter, r *http.Request) {
...

c, err := getContainer(r.Context())

...
}

func getContainer(ctx context.Context) (*Container, error) {
	select {
	case c := <-readyContainer:
		return c, nil
	case <-ctx.Done():
		return nil, ctx.Err()
	}
}

func runHandler(w http.ResponseWriter, r *http.Request) {
	...
	// バイナリの読み込み
	bin, err := io.ReadAll(http.MaxBytesReader(w, r.Body, maxBinarySize))

	// コンテナの標準入力にバイナリを書き込んで、Go コードの実行
	if _, err := c.stdin.Write(bin); err != nil {
		log.Printf("failed to write binary to child: %v", err)
		http.Error(w, "unknown error during docker run", http.StatusInternalServerError)
		return
	}
	c.stdin.Close()

	err = c.Wait()
	res := &sandboxtypes.Response{}
	res.Stdout = c.stdout.dst.Bytes()
	res.Stderr = cleanStderr(c.stderr.dst.Bytes())
	sendResponse(w, res)
}

package main

import (
	"fmt"
	"time"
)

func main() {
	for i := 0; i < 3; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println(time.Now())
	}
}

{
  "Errors": "",
  "Events": [
    {
      "Message": "2009-11-10 23:00:01 +0000 UTC m=+1.000000001\n",
      "Kind": "stdout",
      "Delay": 1000000000
    },
    {
      "Message": "2009-11-10 23:00:02 +0000 UTC m=+2.000000001\n",
      "Kind": "stdout",
      "Delay": 1000000000
    },
    {
      "Message": "2009-11-10 23:00:03 +0000 UTC m=+3.000000001\n",
      "Kind": "stdout",
      "Delay": 1000000000
    }
  ],
  "VetErrors": ""
}