Commit `0d76166636`

0d7616663688c2e7b40c8ae8aad65cc38af82c6d

parent: 7e29c13f48

Verified · cmc ci/build: success ci/test: failure

cmc <hello@cleberg.net> · 2026-09-28 23:24 UTC

e2e: wait up to 60s for a start, stop if gitbayd exits, show why

Closes #300

Layout: unified · split

e2e/acme_test.go +3 −18

 	}
 	t.Cleanup(func() { inst.proc.Process.Kill(); inst.proc.Wait() })
-	wait := func(port int) {
+	waitForPort(t, httpsPort)
-		t.Helper()
+	waitForPort(t, acmeHTTPPort)
-		deadline := time.Now().Add(10 * time.Second)
-		for {
-			conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", port), 200*time.Millisecond)
-			if err == nil {
-				conn.Close()
-				return
-			}
-			if time.Now().After(deadline) {
-				t.Fatalf("port %d never came up", port)
-			}
-			time.Sleep(50 * time.Millisecond)
-		}
-	}
-	wait(httpsPort)
-	wait(acmeHTTPPort)
 	// The helper listener redirects everything to the canonical HTTPS host.
 	client := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error {
 		conn.Close()
 		t.Fatal("handshake unexpectedly succeeded with no CA reachable")
 	}
-	wait(httpsPort) // still listening after the failed handshake
+	waitForPort(t, httpsPort) // still listening after the failed handshake
 	// Certificates cache under the server root.
 	if _, err := os.Stat(filepath.Join(inst.root, "acme")); err != nil {

e2e/lfs_test.go +5 −9

 	"encoding/hex"
 	"encoding/json"
 	"fmt"
-	"net"
 	"net/http"
 	"os"
 	"os/exec"
 	"time"
 )
+// waitForPort waits for a restarted daemon's listener; the failure names
+// the port.
 func waitForPort(t *testing.T, port int) {
 	t.Helper()
-	deadline := time.Now().Add(10 * time.Second)
+	deadline := time.Now().Add(startupWait)
-	for {
+	for !dialable(port) {
-		conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", port), 200*time.Millisecond)
-		if err == nil {
-			conn.Close()
-			return
-		}
 		if time.Now().After(deadline) {
-			t.Fatal("listener did not come back")
+			t.Fatalf("listener on %d did not come back within %s", port, startupWait)
 		}
 		time.Sleep(50 * time.Millisecond)
 	}

e2e/notify_test.go +1 −13

 import (
 	"fmt"
-	"net"
 	"os"
 	"os/exec"
 	"strings"
 		t.Fatal(err)
 	}
 	t.Cleanup(func() { inst.proc.Process.Kill(); inst.proc.Wait() })
-	deadline := time.Now().Add(10 * time.Second)
+	waitForPort(t, inst.port)
-	for {
-		conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", inst.port), 200*time.Millisecond)
-		if err == nil {
-			conn.Close()
-			break
-		}
-		if time.Now().After(deadline) {
-			t.Fatal("daemon did not restart")
-		}
-		time.Sleep(50 * time.Millisecond)
-	}
 	aliceKey := inst.newKey(t, "alice")
 	bobKey := inst.newKey(t, "bob")

e2e/ready_test.go added +106

@@ -0,0 +1,106 @@
	1	package e2e
	2
	3	import (
	4	"bytes"
	5	"fmt"
	6	"net"
	7	"os"
	8	"runtime"
	9	"strings"
	10	"sync"
	11	"testing"
	12	"time"
	13	)
	14
	15	// startupWait bounds how long a gitbayd start may take before its
	16	// listeners answer. CI runs these tests in parallel on a four-core runner
	17	// beside other builds, where a start has taken longer than ten seconds;
	18	// the wait ends early if the daemon exits.
	19	const startupWait = 60 * time.Second
	20
	21	// tailBuffer keeps the last max bytes written to it, for a failure message.
	22	type tailBuffer struct {
	23	mu sync.Mutex
	24	max int
	25	buf []byte
	26	}
	27
	28	func (b *tailBuffer) Write(p []byte) (int, error) {
	29	b.mu.Lock()
	30	defer b.mu.Unlock()
	31	b.buf = append(b.buf, p...)
	32	if over := len(b.buf) - b.max; over > 0 {
	33	b.buf = b.buf[over:]
	34	}
	35	return len(p), nil
	36	}
	37
	38	func (b *tailBuffer) String() string {
	39	b.mu.Lock()
	40	defer b.mu.Unlock()
	41	return string(bytes.TrimSpace(b.buf))
	42	}
	43
	44	// exited reports whether the process has ended without reaping it, so the
	45	// test can still Wait on it. It reads /proc on Linux, where CI runs, and
	46	// reports false elsewhere.
	47	func exited(pid int) bool {
	48	if runtime.GOOS != "linux" {
	49	return false
	50	}
	51	stat, err := os.ReadFile(fmt.Sprintf("/proc/%d/stat", pid))
	52	if err != nil {
	53	return true
	54	}
	55	// The state follows the command name, which is in parentheses.
	56	s := string(stat)
	57	if i := strings.LastIndexByte(s, ')'); i >= 0 && i+2 < len(s) {
	58	return s[i+2] == 'Z'
	59	}
	60	return false
	61	}
	62
	63	func dialable(port int) bool {
	64	conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", port), 200*time.Millisecond)
	65	if err != nil {
	66	return false
	67	}
	68	conn.Close()
	69	return true
	70	}
	71
	72	// waitListening waits until every port accepts a connection. It fails at
	73	// once if the instance's daemon exits, and on either failure names the
	74	// ports that never answered and shows the end of the daemon's stderr.
	75	func (i instance) waitListening(t testing.T, ports ...int) {
	76	t.Helper()
	77	deadline := time.Now().Add(startupWait)
	78	pending := ports
	79	for {
	80	var still []int
	81	for _, p := range pending {
	82	if !dialable(p) {
	83	still = append(still, p)
	84	}
	85	}
	86	if len(still) == 0 {
	87	return
	88	}
	89	pending = still
	90	why := ""
	91	switch {
	92	case i.proc != nil && i.proc.Process != nil && exited(i.proc.Process.Pid):
	93	why = "gitbayd exited"
	94	case time.Now().After(deadline):
	95	why = fmt.Sprintf("gitbayd still not listening after %s", startupWait)
	96	}
	97	if why != "" {
	98	log := "(not captured)"
	99	if i.stderr != nil {
	100	log = i.stderr.String()
	101	}
	102	t.Fatalf("%s on %v; its stderr ends:\n%s", why, pending, log)
	103	}
	104	time.Sleep(50 * time.Millisecond)
	105	}
	106	}

e2e/ssh_test.go +7 −6

 import (
 	"encoding/json"
 	"fmt"
+	"io"
 	"math/rand/v2"
 	"net"
 	"os"
 	httpPort int
 	gitPort  int
 	proc     *exec.Cmd
-	sshDir   string // per-user client keys live here
+	sshDir   string      // per-user client keys live here
-	keyFile  string // server.secret_key_file, outside root
+	keyFile  string      // server.secret_key_file, outside root
+	stderr   *tailBuffer // the end of the first serve's stderr
 }
 // nextPort hands out candidate ports. Seeded randomly so two test processes
 	inst.admin(t, "admin", "secrets", "init")
+	inst.stderr = &tailBuffer{max: 16 << 10}
 	inst.proc = exec.Command(inst.gitbayd, "--config", inst.config, "serve")
-	inst.proc.Stderr = os.Stderr
+	inst.proc.Stderr = io.MultiWriter(os.Stderr, inst.stderr)
 	if err := inst.proc.Start(); err != nil {
 		t.Fatal(err)
 	}
 	// Every listener, not just SSH: the HTTP and git ones come up in their
 	// own goroutines, and a test whose first act is an HTTP request used
 	// to race them and be refused.
-	for _, port := range []int{inst.port, inst.httpPort, inst.gitPort} {
+	inst.waitListening(t, inst.port, inst.httpPort, inst.gitPort)
-		waitForPort(t, port)
-	}
 	return inst
 }

Commit 0d76166636

Commit `0d76166636`