puma-plus-core 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7469b96ede0673b7911a6fd2dc4c1cf6f2a4341f0b32f169a7bb5cf0fc67bfd6
+  data.tar.gz: 822ebdf9defc1f8c205bf394de0a0d57554dbc2bb68396ab5c5110b85474ef18
+SHA512:
+  metadata.gz: dd7c1bdffcf47bd05f1350a84bbe0357c4bebd80d32f8a362650631f9f5b00342813f82721cabe1608563f54d3dc3da339460e723d351f5f4430aafd039e4272
+  data.tar.gz: 5b5ef21560e7d01aa7160f4f185fd8d6aff9c8a1e470f9e5bf6edd8ed1a87f15d2f07db7ebb536b065c835e655961c041ca93876a8e0619476f6597b49e67eee

data/ext/puma_plus_core/extconf.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Builds the Go server at install time.
+#
+# Not a C extension, despite living under ext/ and being named extconf.rb.
+# RubyGems has exactly one hook that runs a build during `gem install`, and this
+# is it -- so the file exists to satisfy that convention, writes a Makefile that
+# runs `go build`, and compiles no C at all.
+#
+# This path only runs for the source gem. A platform gem
+# (puma-plus-core-X.Y.Z-x86_64-linux) ships the binary already built and has no
+# extension, so no Go toolchain is needed for the common install.
+
+require "mkmf"
+require "fileutils"
+
+GEM_ROOT = File.expand_path("../..", __dir__)
+EXE_DIR = File.join(GEM_ROOT, "exe")
+EXE = File.join(EXE_DIR, RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ ? "puma-plus-server.exe" : "puma-plus-server")
+GO_SRC = File.join(GEM_ROOT, "go")
+
+def abort_with(message)
+  # Written to stdout as well: RubyGems shows mkmf.log on failure, but the
+  # reason belongs where someone will actually see it.
+  warn message
+  File.write("Makefile", "all:\n\t@echo '#{message.lines.first.strip}'; exit 1\n")
+  exit 1
+end
+
+go = find_executable0("go")
+unless go
+  abort_with(<<~MSG)
+    puma-plus-core: no Go toolchain found, and no prebuilt binary ships for this platform.
+
+    Either install Go #{PumaPlusGoMinimum = '1.24'} or newer, or install a platform-specific gem if one
+    exists for #{RUBY_PLATFORM}.
+  MSG
+end
+
+version = `#{go} version`.to_s[/go(\d+)\.(\d+)/, 0].to_s
+unless version.empty?
+  major, minor = version.sub("go", "").split(".").map(&:to_i)
+  if major < 1 || (major == 1 && minor < 24)
+    abort_with("puma-plus-core: Go #{version} is too old; 1.24 or newer is required.")
+  end
+end
+
+unless File.directory?(GO_SRC)
+  abort_with("puma-plus-core: the gem is missing its Go sources at #{GO_SRC}.")
+end
+
+FileUtils.mkdir_p(EXE_DIR)
+
+# A Makefile rather than shelling out here, so the build runs in the phase
+# RubyGems expects and its output is captured the way a compile would be.
+#
+# The three-target shape matters and is not decoration. RubyGems runs
+# `make clean`, `make`, `make install`, and then `make clean` AGAIN. A Makefile
+# whose clean target removes the installed binary therefore deletes its own
+# output on that last pass and reports success -- which is exactly what happened
+# here: the gem installed, said nothing, and shipped an empty exe/ directory.
+#
+# So this mirrors what a C extension does. The build writes into this directory,
+# install copies it out to exe/, and clean only removes the local copy.
+#
+# -mod=vendor is deliberate: the gem vendors its dependencies, so the build is
+# offline and reproducible. An install that reached out to proxy.golang.org
+# would fail in exactly the sandboxed and air-gapped environments people deploy
+# from.
+LOCAL = File.join(Dir.pwd, File.basename(EXE))
+
+File.write("Makefile", <<~MAKE)
+  all:
+  \tcd #{GO_SRC} && #{go} build -mod=vendor -trimpath -ldflags "-s -w" -o #{LOCAL} ./cmd/puma-plus
+
+  install: all
+  \tmkdir -p #{EXE_DIR}
+  \tcp #{LOCAL} #{EXE}
+  \t@echo "puma-plus-core: installed #{EXE}"
+
+  clean:
+  \trm -f #{LOCAL}
+MAKE
+
+puts "puma-plus-core: will build #{EXE} with #{go}"

data/go/cmd/puma-plus/main.go

@@ -0,0 +1,472 @@
+// Command puma-plus is the Go front half of the puma-plus web server: it owns
+// HTTP, measures request queue time, and dispatches requests to Ruby worker
+// threads over a unix socket.
+package main
+
+import (
+	"context"
+	"crypto/tls"
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/evanphx/puma-plus/internal/control"
+	"github.com/evanphx/puma-plus/internal/frontend"
+	"github.com/evanphx/puma-plus/internal/metrics"
+	"github.com/evanphx/puma-plus/internal/queue"
+	"github.com/evanphx/puma-plus/internal/realtime"
+
+	wt "github.com/quic-go/webtransport-go"
+)
+
+func main() {
+	var (
+		listen   = flag.String("listen", "127.0.0.1:9292", "HTTP listen address")
+		sock     = flag.String("worker-socket", "", "unix socket workers dial (default: a temp path)")
+		appPath  = flag.String("app", "", "path to the Rack app (config.ru or .rb)")
+		threads  = flag.Int("threads", 5, "Ruby worker threads to run")
+		ractors  = flag.Int("ractors", 0, "serve from N Ractors in one process instead of threads+forks (0 = off)")
+		maxConns = flag.Int("max-conns", 512, "maximum worker connections")
+		spawn    = flag.Bool("spawn", true, "spawn the Ruby worker; false to run one yourself")
+		timeout  = flag.Duration("acquire-timeout", 30*time.Second, "max queue wait before shedding with 503")
+		debugHdr = flag.Bool("debug-headers", false, "add X-PumaPlus-* timing headers to responses")
+		ctrlAddr = flag.String("control", "127.0.0.1:9293", "control listen address for /stats, /metrics, /health")
+
+		workers   = flag.Int("workers", 1, "Ruby worker processes to start")
+		autoscale = flag.Bool("autoscale", false, "scale worker processes from measured queue time")
+		target    = flag.Duration("target-queue-p95", 25*time.Millisecond, "queue-time p95 the controller steers toward")
+		minW      = flag.Int("min-workers", 1, "floor for autoscaling")
+		maxW      = flag.Int("max-workers", 8, "ceiling for autoscaling")
+		memLimit  = flag.Int64("mem-limit-mb", 0, "total worker RSS cap in MB (0 disables the guard)")
+		decisions = flag.String("decision-log", "", "path for the controller decision log (JSONL)")
+
+		h2c      = flag.Bool("h2c", false, "also serve cleartext HTTP/2 on -listen")
+		tlsAddr  = flag.String("listen-tls", "", "HTTPS address serving h2 and h1 via ALPN (e.g. 127.0.0.1:9443)")
+		h3Addr   = flag.String("listen-h3", "", "HTTP/3 address over QUIC/UDP (e.g. 127.0.0.1:9443)")
+		tlsHosts = flag.String("tls-hosts", "localhost", "comma-separated names for the generated dev certificate")
+		tlsCert  = flag.String("tls-cert", "", "PEM certificate chain for -listen-tls and -listen-h3 (default: generate a dev cert)")
+		tlsKey   = flag.String("tls-key", "", "PEM private key matching -tls-cert")
+
+		websockets       = flag.Bool("websockets", true, "let Go own WebSocket/WebTransport connections on the app's behalf")
+		webtransportFlag = flag.Bool("webtransport", true, "accept WebTransport sessions (requires -listen-h3)")
+	)
+	flag.Parse()
+
+	logger := log.New(os.Stderr, "[puma-plus] ", log.LstdFlags|log.Lmicroseconds)
+
+	socketPath := *sock
+	if socketPath == "" {
+		dir, err := os.MkdirTemp("", "puma-plus-")
+		if err != nil {
+			logger.Fatalf("temp dir: %v", err)
+		}
+		defer os.RemoveAll(dir)
+		socketPath = filepath.Join(dir, "workers.sock")
+	}
+
+	reg := queue.NewRegistry(*maxConns)
+	var hub *realtime.Hub
+	var rtb *frontend.RTBridge
+
+	acc, err := frontend.NewAcceptor(socketPath, reg, logger)
+	if err != nil {
+		logger.Fatalf("worker socket: %v", err)
+	}
+	defer acc.Close()
+	go func() {
+		if err := acc.Serve(); err != nil {
+			logger.Printf("worker acceptor stopped: %v", err)
+		}
+	}()
+	logger.Printf("worker socket at %s", acc.Addr())
+
+	var worker *exec.Cmd
+	if *spawn {
+		if *appPath == "" {
+			logger.Fatal("-app is required when -spawn is set")
+		}
+		worker, err = spawnShepherd(socketPath, *appPath, *workers, *threads, *ractors, logger)
+		if err != nil {
+			logger.Fatalf("spawn shepherd: %v", err)
+		}
+	} else {
+		logger.Printf("not spawning; run: ruby -Igem/lib gem/exe/puma-plus-worker --socket %s --app <app> --threads %d",
+			socketPath, *threads)
+	}
+
+	col := metrics.NewCollector(time.Now())
+
+	// The 1 Hz tick rotates the histogram windows and refreshes the rate
+	// averages. Everything expensive in the metrics path happens here rather
+	// than per request, which is what keeps the hot path at two clock reads and
+	// a few atomic adds.
+	tickDone := make(chan struct{})
+	go func() {
+		t := time.NewTicker(time.Second)
+		defer t.Stop()
+		for {
+			select {
+			case now := <-t.C:
+				col.Tick(now)
+			case <-tickDone:
+				return
+			}
+		}
+	}()
+	defer close(tickDone)
+
+	ctrlSrv := &http.Server{
+		Addr:              *ctrlAddr,
+		Handler:           metrics.NewHandler(col, reg, *threads).Mux(),
+		ReadHeaderTimeout: 5 * time.Second,
+	}
+	go func() {
+		logger.Printf("control endpoints on http://%s (/stats /metrics /health)", *ctrlAddr)
+		if err := ctrlSrv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logger.Printf("control listener: %v", err)
+		}
+	}()
+
+	if *autoscale {
+		cfg := control.DefaultConfig()
+		cfg.TargetQueueP95 = *target
+		cfg.MinWorkers, cfg.MaxWorkers = *minW, *maxW
+		cfg.ThreadsPerWorker = *threads
+		cfg.MemLimitBytes = *memLimit << 20
+
+		scaler := shepherdOrNone(acc)
+		if *ractors > 0 {
+			// A unit of capacity stays -threads slots wide, exactly as it is for a
+			// forked worker -- the unit is just made of Ractors instead of threads.
+			//
+			// This matters more than it looks. The controller adds ONE unit per
+			// decision, and a decision costs a confirmation window no actuator can
+			// shorten. Making a unit a single Ractor was measured: the same
+			// controller needed 25 decisions to reach capacity 30 where forking
+			// needed 5, and lost on latency by 300x despite each spawn being ~125x
+			// faster. Granularity beat latency outright.
+			cfg.SpawnCooldown = 250 * time.Millisecond
+
+			scaler = frontend.NewRactorShepherd(acc, reg, *ractors, *threads, logger)
+			logger.Printf("autoscaling ractors: unit = %d ractors, spawn cooldown %s "+
+				"(fork-mode default is %s)",
+				*threads, cfg.SpawnCooldown, control.DefaultConfig().SpawnCooldown)
+		}
+
+		var journal *control.Journal
+		if *decisions != "" {
+			journal, err = control.NewJournal(*decisions)
+			if err != nil {
+				logger.Fatalf("decision log: %v", err)
+			}
+			defer journal.Close()
+			logger.Printf("decision log at %s", *decisions)
+		}
+
+		loop := control.NewLoop(cfg, scaler, reg,
+			collectorAdapter{col}, journal, logger)
+		stop := make(chan struct{})
+		go loop.Run(time.Second, stop)
+		defer close(stop)
+		logger.Printf("autoscaling on: target queue p95 %s, workers %d..%d, shed past %s",
+			cfg.TargetQueueP95, cfg.MinWorkers, cfg.MaxWorkers, cfg.ShedLimit())
+	}
+
+	hopts := frontend.Options{
+		AcquireTimeout: *timeout,
+		DebugHeaders:   *debugHdr,
+		Logger:         logger,
+		Collector:      col,
+	}
+	handler := frontend.NewHandler(reg, hopts)
+
+	var wtServer *wt.Server
+	if *websockets {
+		hub = realtime.NewHub()
+		acc.AttachHub(hub)
+		rtb = frontend.NewRTBridge(hub, reg, col, hopts, logger)
+		handler.AttachRealtime(rtb)
+
+		// WebTransport needs HTTP/3, which needs a UDP listener. Without one
+		// there is nothing to attach it to, and saying so beats silently
+		// accepting -webtransport and never serving a session.
+		if *h3Addr != "" {
+			wtServer = &wt.Server{
+				CheckOrigin: func(*http.Request) bool { return true },
+			}
+			rtb.AttachWebTransport(wtServer)
+			logger.Printf("webtransport enabled on the HTTP/3 listener")
+		} else if *webtransportFlag {
+			logger.Printf("webtransport requested but -listen-h3 is unset; " +
+				"WebTransport requires HTTP/3 and has no HTTP/1.1 fallback")
+		}
+		logger.Printf("realtime enabled: Go owns WebSocket/WebTransport connections, Ruby sees messages")
+	}
+
+	lopts := frontend.ListenerOptions{
+		Handler: handler,
+		Logger:  logger,
+		Addr:    *listen,
+		H2C:     *h2c,
+		TLSAddr: *tlsAddr,
+		H3Addr:  *h3Addr,
+	}
+	if wtServer != nil {
+		lopts.WebTransport = wtServer
+	}
+	if *tlsAddr != "" || *h3Addr != "" {
+		// QUIC has no cleartext mode, so h3 needs a certificate unconditionally.
+		var cert tls.Certificate
+		var err error
+
+		switch {
+		case *tlsCert != "" && *tlsKey != "":
+			cert, err = frontend.LoadCertificate(*tlsCert, *tlsKey)
+			if err != nil {
+				logger.Fatalf("%v", err)
+			}
+			desc, problem := frontend.DescribeCertificate(cert)
+			logger.Printf("tls certificate from %s: %s", *tlsCert, desc)
+			if problem != "" {
+				// Loud but not fatal. Refusing to boot over an expiring cert would
+				// turn a warning into an outage, and the operator may be mid-renewal.
+				logger.Printf("WARNING: %s", problem)
+			}
+
+		case *tlsCert != "" || *tlsKey != "":
+			// Half a keypair is always a mistake, and silently falling back to a
+			// self-signed cert would look like the real one had loaded.
+			logger.Fatal("-tls-cert and -tls-key must be given together")
+
+		default:
+			cert, err = frontend.DevCertificate(strings.Split(*tlsHosts, ",")...)
+			if err != nil {
+				logger.Fatalf("dev certificate: %v", err)
+			}
+			logger.Printf("tls: no -tls-cert given, using a generated self-signed " +
+				"certificate; clients must skip verification")
+		}
+		lopts.Cert = cert
+	}
+
+	listeners, err := frontend.Start(lopts)
+	if err != nil {
+		logger.Fatalf("listeners: %v", err)
+	}
+	if *listen != "" {
+		proto := "HTTP/1.1"
+		if *h2c {
+			proto = "HTTP/1.1 + h2c"
+		}
+		logger.Printf("listening on http://%s (%s)", *listen, proto)
+	}
+	if *tlsAddr != "" {
+		kind := "self-signed dev cert"
+		if *tlsCert != "" {
+			kind = "cert from " + *tlsCert
+		}
+		logger.Printf("listening on https://%s (h2, h1 via ALPN; %s)", *tlsAddr, kind)
+	}
+	if *h3Addr != "" {
+		logger.Printf("listening on https://%s (HTTP/3 over QUIC; self-signed dev cert)", *h3Addr)
+	}
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
+	<-sig
+	logger.Printf("shutting down")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if hub != nil {
+		hub.CloseAll(1001, "server shutting down")
+	}
+	listeners.Shutdown(ctx)
+	_ = ctrlSrv.Shutdown(ctx)
+
+	if worker != nil && worker.Process != nil {
+		_ = worker.Process.Signal(syscall.SIGTERM)
+		done := make(chan struct{})
+		go func() { _, _ = worker.Process.Wait(); close(done) }()
+		select {
+		case <-done:
+		case <-time.After(5 * time.Second):
+			_ = worker.Process.Kill()
+		}
+	}
+}
+
+// shepherdOrNone adapts the acceptor's shepherd slot to the control.Shepherd
+// interface, tolerating the shepherd not having connected yet.
+func shepherdOrNone(acc *frontend.Acceptor) control.Shepherd {
+	return lazyShepherd{acc}
+}
+
+type lazyShepherd struct{ acc *frontend.Acceptor }
+
+func (l lazyShepherd) SetWorkers(n int) error {
+	if s := l.acc.Shepherd(); s != nil {
+		return s.SetWorkers(n)
+	}
+	return frontend.ErrNoShepherd
+}
+
+func (l lazyShepherd) WorkerCount() int {
+	if s := l.acc.Shepherd(); s != nil {
+		return s.WorkerCount()
+	}
+	return 0
+}
+
+func (l lazyShepherd) WorkerPIDs() []int {
+	if s := l.acc.Shepherd(); s != nil {
+		return s.WorkerPIDs()
+	}
+	return nil
+}
+
+func (l lazyShepherd) Connected() bool {
+	s := l.acc.Shepherd()
+	return s != nil && s.Connected()
+}
+
+// collectorAdapter exposes the metrics collector as the controller's
+// MetricSource, keeping the two packages independent of each other.
+type collectorAdapter struct{ col *metrics.Collector }
+
+func (a collectorAdapter) QueueP95() time.Duration {
+	_, p95, _ := a.col.QuantilesNs(a.col.QueueTime, metrics.ScaleWindow)
+	return time.Duration(p95)
+}
+
+func (a collectorAdapter) PredictedWait(depth, capacity int) time.Duration {
+	return a.col.PredictedWait(depth, capacity)
+}
+
+func (a collectorAdapter) ArrivalRate() float64 { return a.col.ArrivalSlow.Value() }
+func (a collectorAdapter) ServiceMean() float64 { return a.col.ServiceSlow.Value() }
+func (a collectorAdapter) CPUFraction() float64 { return a.col.CPUFraction.Value() }
+
+// GVLFraction reports the measurement and whether it is real.
+//
+// A worker without the native extension reports zero GVL wait, which is
+// indistinguishable from "measured, and there is no contention". Treating an
+// absent extension as "no contention" would make the controller confidently add
+// threads to a GVL-bound process -- the exact mistake this measurement exists to
+// prevent. So an all-zero average is reported as unknown, and the controller
+// falls back to io_fraction plus gain probing.
+func (a collectorAdapter) GVLFraction() (float64, bool) {
+	return a.col.GVLFractionValue()
+}
+
+// spawnShepherd starts the Ruby shepherd process.
+//
+// Deliberately an explicit exec of `ruby`, not puma-dev's `$SHELL -l -i -c`
+// heredoc (puma-dev/dev/app.go:240-268). That heredoc exists to make rbenv/rvm
+// shims resolve and to source .powconfig/.env/.pumaenv, which is environment
+// archaeology the spike does not need and which makes failures hard to read.
+func spawnShepherd(socketPath, appPath string, workers, threads, ractors int, logger *log.Logger) (*exec.Cmd, error) {
+	worker, libs, err := rubyWorker()
+	if err != nil {
+		return nil, err
+	}
+
+	args := make([]string, 0, 2*len(libs)+6)
+	for _, dir := range libs {
+		args = append(args, "-I", dir)
+	}
+	args = append(args, worker, "--socket", socketPath, "--app", appPath)
+	if ractors > 0 {
+		// Ractor mode is single-process on purpose: a Ractor is already a unit of
+		// real parallelism, so forking on top of it would be scaling the same
+		// axis twice while paying fork's dead time for the privilege.
+		args = append(args, "--ractors", strconv.Itoa(ractors))
+	} else {
+		args = append(args, "--threads", strconv.Itoa(threads), "--workers", strconv.Itoa(workers))
+	}
+
+	cmd := exec.Command("ruby", args...)
+	cmd.Stdout = os.Stderr
+	cmd.Stderr = os.Stderr
+	if err := cmd.Start(); err != nil {
+		return nil, err
+	}
+	if ractors > 0 {
+		logger.Printf("spawned ruby worker pid=%d ractors=%d app=%s", cmd.Process.Pid, ractors, appPath)
+	} else {
+		logger.Printf("spawned ruby shepherd pid=%d workers=%d threads=%d app=%s",
+			cmd.Process.Pid, workers, threads, appPath)
+	}
+	return cmd, nil
+}
+
+// rubyWorker locates the worker script and the -I paths it needs.
+//
+// Told, not guessed. PUMA_PLUS_WORKER and PUMA_PLUS_RUBY_LIB are set by the
+// `puma-plus` launcher, which is Ruby living inside the gem and therefore knows
+// exactly where everything is. That matters because the layout genuinely
+// differs: a checkout has gem/exe, gem/lib and gem/ext/puma_plus_gvl, while an
+// installed gem has exe/ and lib/ with the compiled extension wherever RubyGems
+// decided to put it. Any path this process constructs for itself is correct in
+// at most one of those.
+//
+// The search remains for running the Go binary directly from a checkout, which
+// is how every test and benchmark drives it.
+func rubyWorker() (string, []string, error) {
+	if w := os.Getenv("PUMA_PLUS_WORKER"); w != "" {
+		if _, err := os.Stat(w); err != nil {
+			return "", nil, fmt.Errorf("PUMA_PLUS_WORKER=%s: %w", w, err)
+		}
+		var libs []string
+		if l := os.Getenv("PUMA_PLUS_RUBY_LIB"); l != "" {
+			libs = filepath.SplitList(l)
+		}
+		return w, libs, nil
+	}
+
+	root, err := searchForRepoRoot()
+	if err != nil {
+		return "", nil, err
+	}
+	return filepath.Join(root, "gem", "exe", "puma-plus-worker"), []string{
+		filepath.Join(root, "gem", "lib"),
+		// The optional GVL extension, if it has been built. Absent is fine: the
+		// gem falls back to the cheaper heuristics.
+		filepath.Join(root, "gem", "ext", "puma_plus_gvl"),
+	}, nil
+}
+
+// searchForRepoRoot locates the gem alongside this binary's source tree. The spike runs
+// from a checkout; a real install would resolve the gem through RubyGems.
+func searchForRepoRoot() (string, error) {
+	exe, err := os.Executable()
+	if err == nil {
+		dir := filepath.Dir(exe)
+		for i := 0; i < 5; i++ {
+			if _, err := os.Stat(filepath.Join(dir, "gem", "exe", "puma-plus-worker")); err == nil {
+				return dir, nil
+			}
+			dir = filepath.Dir(dir)
+		}
+	}
+	wd, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+	for i := 0; i < 5; i++ {
+		if _, err := os.Stat(filepath.Join(wd, "gem", "exe", "puma-plus-worker")); err == nil {
+			return wd, nil
+		}
+		wd = filepath.Dir(wd)
+	}
+	return "", fmt.Errorf("cannot locate the puma-plus gem; run from the repo root or pass -spawn=false")
+}

data/go/go.mod

@@ -0,0 +1,20 @@
+module github.com/evanphx/puma-plus
+
+go 1.26.1
+
+require golang.org/x/sys v0.47.0
+
+require (
+	github.com/quic-go/quic-go v0.61.0
+	golang.org/x/net v0.57.0
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	github.com/dunglas/httpsfv v1.1.0 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/quic-go/qpack v0.6.0 // indirect
+	github.com/quic-go/webtransport-go v0.12.0 // indirect
+	golang.org/x/crypto v0.54.0 // indirect
+	golang.org/x/text v0.40.0 // indirect
+)

data/go/go.sum

@@ -0,0 +1,38 @@
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dunglas/httpsfv v1.1.0 h1:Jw76nAyKWKZKFrpMMcL76y35tOpYHqQPzHQiwDvpe54=
+github.com/dunglas/httpsfv v1.1.0/go.mod h1:zID2mqw9mFsnt7YC3vYQ9/cjq30q41W+1AnDwH8TiMg=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/quic-go/go-ossfuzz-seeds v0.1.0 h1:APacT+iIaNF6fd8AGEiN3bT/Jtkd2jz4v4TzM7MFjy0=
+github.com/quic-go/go-ossfuzz-seeds v0.1.0/go.mod h1:3IOHRbJIc+L6YKMwfDtJAM9Vj9k0YY4muhuyUYk5tbk=
+github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
+github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
+github.com/quic-go/quic-go v0.61.0 h1:ui88A53s8MSVYLC56en0KQ17HARk+9986Dn0SBfKNvA=
+github.com/quic-go/quic-go v0.61.0/go.mod h1:9So2anK4Tp22URSQq00k+Vo2PNkle96ycDPDHL4s9vs=
+github.com/quic-go/webtransport-go v0.12.0 h1:CpnKNwZvdV0LD73xoHO8QaR0NI3llqpWRwnazdZS0sE=
+github.com/quic-go/webtransport-go v0.12.0/go.mod h1:GHne8aRFJ24h73pAMrcywXtuaz/ShBXCLXLvG/NPFdU=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+go.uber.org/mock v0.5.2 h1:LbtPTcP8A5k9WPXj54PPPbjcI4Y6lhyOZXn+VS7wNko=
+go.uber.org/mock v0.5.2/go.mod h1:wLlUxC2vVTPTaE3UD51E0BGOAElKrILxhVSDYQLld5o=
+golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
+golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
+golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
+golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
+golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
+golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=