Commit `387b381242`

387b381242a77e37af3a58b7301f6365b176603b

parent: 3e75710732

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

cmc <hello@cleberg.net> · 2026-09-07 02:32 UTC

store, control, wiki: reuse a job's success across commits with the same tree

A rebase gives every commit a new sha and the same tree. Dedupe keyed on
the sha re-ran every job on every rebase; keyed on the tree, a success
stands for the new commit, which gets it as its status naming the build.
Scheduled and tag builds carry no tree and are never reused.

Closes #177

Layout: unified · split

.gitbay/wiki/Users.org +7

		@@ -96,6 +96,13 @@ repository header, the count in the facts bar, and the list at
96	96	=/bookmarks=. Bookmarks are public and counted; pins are private and
97	97	drive the rail. Read access is all a bookmark needs.
98	98
	99	A job's result is a property of the commit's tree, not its sha: a
	100	rebase onto a base that touched nothing the branch did gives every
	101	commit a new sha and the same tree, and a job that already passed for
	102	that tree is not run again — the new commit gets the earlier result as
	103	its =ci/<job>= status, naming the build it came from. Scheduled and tag
	104	jobs are never reused this way; their trigger is the clock or the tag.
	105
99	106	* Profiles
100	107
101	108	A profile is what =/{owner}= shows: a one-line description, a website, a

internal/ci/sched.go +1 −1

		@@ -101,7 +101,7 @@ func (s *Scheduler) RunDue(now time.Time) {
101	101	continue
102	102	}
103	103	steps, _ := json.Marshal(job.Steps)
104		n, err := s.St.CreateBuild(repo.ID, job.Name, sha, repo.DefaultBranch, string(steps), job.Image, true)
	104	n, err := s.St.CreateBuild(repo.ID, job.Name, sha, repo.DefaultBranch, string(steps), job.Image, "", true)
105	105	if err != nil {
106	106	slog.Error("scheduler: queueing build", "repo", repo.Path(), "job", job.Name, "err", err)
107	107	continue

internal/control/build.go +15 −2

		@@ -227,7 +227,8 @@ func runBuildTrigger(c *Ctx, args []string) int {
227	227	continue
228	228	}
229	229	steps, _ := json.Marshal(j.Steps)
230		n, err := c.Store.CreateBuild(repo.ID, j.Name, sha, repo.DefaultBranch, string(steps), j.Image, true)
	230	tree, _ := gitutil.ResolveTree(RepoDir(c.Cfg.Server.Root, repo.OwnerName, repo.Name), sha)
	231	n, err := c.Store.CreateBuild(repo.ID, j.Name, sha, repo.DefaultBranch, string(steps), j.Image, tree, true)
231	232	if err != nil {
232	233	return c.fail(protocol.ExitFailure, "%v", err)
233	234	}
		@@ -613,6 +614,12 @@ func queueJobs(
613	614	if err != nil {
614	615	built = nil
615	616	}
	617	// A job's result is a property of the tree, not the commit: a rebase
	618	// onto a base that touched nothing the branch did gives every commit
	619	// a new sha and the same tree, and re-running the suite over it
	620	// proves nothing it did not already prove (#177). A success recorded
	621	// against the tree stands for the new commit.
	622	tree, _ := gitutil.ResolveTree(dir, sha)
616	623	// The changed-file list a job's path filters run against, computed
617	624	// once and only if some job actually declares one. When the diff
618	625	// base does not exist or the diff itself fails, filtered stays
		@@ -669,6 +676,12 @@ func queueJobs(
669	676	if b, ok := built[j.Name]; ok && (b.Status == "success" \|\| b.Status == "pending" \|\| b.Status == "running") {
670	677	continue
671	678	}
	679	if prev, ok, _ := st.SuccessBuildForTree(repo.ID, tree, j.Name); ok && prev.SHA != sha {
	680	url := fmt.Sprintf("%s/%s/builds/%d", siteURL, repo.Path(), prev.Number)
	681	st.SetCommitStatus(repo.ID, sha, "ci/"+j.Name, "success",
	682	fmt.Sprintf("passed in build %d as %.10s, same tree", prev.Number, prev.SHA), url, userID)
	683	continue
	684	}
672	685	// Scheduled jobs run on their cron, not on push; a default-branch
673	686	// push (re)registers them.
674	687	if j.Schedule != "" {
		@@ -688,7 +701,7 @@ func queueJobs(
688	701	continue
689	702	}
690	703	steps, _ := json.Marshal(j.Steps)
691		n, err := st.CreateBuild(repo.ID, j.Name, sha, ref, string(steps), j.Image, trusted)
	704	n, err := st.CreateBuild(repo.ID, j.Name, sha, ref, string(steps), j.Image, tree, trusted)
692	705	if err != nil {
693	706	slog.Error("queueing build", "repo", repo.Path(), "job", j.Name, "err", err)
694	707	continue

internal/control/build_test.go +57 −1

		@@ -432,7 +432,7 @@ func TestQueueBranchBuildsAlreadyBuiltJobRecordsNoSkippedStatus(t *testing.T) {
432	432	// The same commit already has a build for "unit" from another branch,
433	433	// still pending. Its filter would exclude this push too, so the only
434	434	// way to tell the two paths apart is that this one must record nothing.
435		if _, err := st.CreateBuild(repo.ID, "unit", newSHA, "other", `["echo hi"]`, "", true); err != nil {
	435	if _, err := st.CreateBuild(repo.ID, "unit", newSHA, "other", `["echo hi"]`, "", "", true); err != nil {
436	436	t.Fatal(err)
437	437	}
438	438
		@@ -549,3 +549,59 @@ func TestQueueBranchBuildsRebaseFiltersAgainstMergeBase(t *testing.T) {
549	549	t.Fatal("a rebased branch whose commits change code queued no build")
550	550	}
551	551	}
	552
	553	// A rebase gives a commit a new sha and the same tree. A job that
	554	// succeeded for that tree has nothing left to prove, so the new commit
	555	// gets the earlier result as its status instead of a new build (#177).
	556	func TestQueueBranchBuildsSameTreeReusesSuccess(t *testing.T) {
	557	st, repo, uid := newQueueTestRepo(t)
	558	git := gitRunner(t)
	559	root := t.TempDir()
	560
	561	src := filepath.Join(root, "src")
	562	os.MkdirAll(filepath.Join(src, ".gitbay"), 0o755)
	563	os.WriteFile(filepath.Join(src, ".gitbay", "ci.yml"), []byte(
	564	"jobs:\n unit:\n steps:\n - echo hi\n"), 0o644)
	565	git(root, "init", "-q", "-b", "main", "src")
	566	git(src, "add", ".")
	567	git(src, "commit", "-q", "-m", "base")
	568	first := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
	569	// Same tree, new sha: what a rebase onto an unrelated base produces.
	570	git(src, "commit", "-q", "--allow-empty", "-m", "rewritten")
	571	second := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
	572	if git(src, "rev-parse", first+"^{tree}") != git(src, "rev-parse", second+"^{tree}") {
	573	t.Fatal("fixture: trees differ")
	574	}
	575
	576	dir := RepoDir(root, repo.OwnerName, repo.Name)
	577	os.MkdirAll(filepath.Dir(dir), 0o755)
	578	git(root, "clone", "-q", "--bare", src, dir)
	579
	580	QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", "", first, time.Now())
	581	builds, _ := st.ListBuilds(repo.ID, 10)
	582	if len(builds) != 1 {
	583	t.Fatalf("first commit queued %d builds, want 1", len(builds))
	584	}
	585	if _, ok, err := st.ClaimBuild([]int64{repo.ID}); err != nil \|\| !ok {
	586	t.Fatalf("claim: ok=%v err=%v", ok, err)
	587	}
	588	if err := st.FinishBuild(builds[0].ID, "success"); err != nil {
	589	t.Fatal(err)
	590	}
	591
	592	QueueBranchBuilds(st, root, "https://x.test", repo, uid, "main", first, second, time.Now())
	593	builds, _ = st.ListBuilds(repo.ID, 10)
	594	if len(builds) != 1 {
	595	t.Fatalf("same tree queued a second build: %+v", builds)
	596	}
	597	statuses, _ := st.ListCommitStatuses(repo.ID, second)
	598	found := false
	599	for _, s := range statuses {
	600	if s.Context == "ci/unit" && s.State == "success" && strings.Contains(s.Description, "same tree") {
	601	found = true
	602	}
	603	}
	604	if !found {
	605	t.Fatalf("second commit has no success status from the first: %+v", statuses)
	606	}
	607	}

internal/control/runnernext_test.go +5 −5

		@@ -60,14 +60,14 @@ func setupOrphanRepo(t testing.T) (store.Store, store.Repo, int64, string, str
60	60	func TestRunnerNextSkipsOrphanedBuildAndClaimsNext(t *testing.T) {
61	61	st, repo, uid, root, baseSHA, orphanSHA := setupOrphanRepo(t)
62	62
63		orphanedID, err := st.CreateBuild(repo.ID, "unit", orphanSHA, "main", "[]", "", true)
	63	orphanedID, err := st.CreateBuild(repo.ID, "unit", orphanSHA, "main", "[]", "", "", true)
64	64	if err != nil {
65	65	t.Fatal(err)
66	66	}
67	67	if err := st.SetCommitStatus(repo.ID, orphanSHA, "ci/unit", "pending", "queued", "https://x.test", uid); err != nil {
68	68	t.Fatal(err)
69	69	}
70		realID, err := st.CreateBuild(repo.ID, "unit", baseSHA, "main", "[]", "", true)
	70	realID, err := st.CreateBuild(repo.ID, "unit", baseSHA, "main", "[]", "", "", true)
71	71	if err != nil {
72	72	t.Fatal(err)
73	73	}
		@@ -113,7 +113,7 @@ func TestRunnerNextSkipsOrphanedBuildAndClaimsNext(t *testing.T) {
113	113	// the reachability check must never reject a healthy build.
114	114	func TestRunnerNextClaimsReachableBuildNormally(t *testing.T) {
115	115	st, repo, uid, root, baseSHA, _ := setupOrphanRepo(t)
116		id, err := st.CreateBuild(repo.ID, "unit", baseSHA, "main", "[]", "", true)
	116	id, err := st.CreateBuild(repo.ID, "unit", baseSHA, "main", "[]", "", "", true)
117	117	if err != nil {
118	118	t.Fatal(err)
119	119	}
		@@ -147,7 +147,7 @@ func TestRunnerNextOrphanedQueuePastCapReportsNoPendingBuilds(t *testing.T) {
147	147	st, repo, uid, root, _, orphanSHA := setupOrphanRepo(t)
148	148	total := maxOrphanSkip + 1
149	149	for i := 0; i < total; i++ {
150		if _, err := st.CreateBuild(repo.ID, fmt.Sprintf("job%d", i), orphanSHA, "main", "[]", "", true); err != nil {
	150	if _, err := st.CreateBuild(repo.ID, fmt.Sprintf("job%d", i), orphanSHA, "main", "[]", "", "", true); err != nil {
151	151	t.Fatal(err)
152	152	}
153	153	}
		@@ -194,7 +194,7 @@ func TestRunnerNextClaimsBuildWhenReachabilityCannotBeChecked(t *testing.T) {
194	194	// No RepoDir created on disk at all: Reachable will fail to even stat
195	195	// the repository, which must not be read as "orphaned".
196	196	root := t.TempDir()
197		id, err := st.CreateBuild(repo.ID, "unit", strings.Repeat("a", 40), "main", "[]", "", true)
	197	id, err := st.CreateBuild(repo.ID, "unit", strings.Repeat("a", 40), "main", "[]", "", "", true)
198	198	if err != nil {
199	199	t.Fatal(err)
200	200	}

internal/hookd/hookd.go +1 −1

		@@ -302,7 +302,7 @@ func (s *Server) queueTagBuilds(repo store.Repo, userID int64, tag, pushed strin
302	302	continue
303	303	}
304	304	steps, _ := json.Marshal(j.Steps)
305		n, err := s.st.CreateBuild(repo.ID, j.Name, sha, tag, string(steps), j.Image, true)
	305	n, err := s.st.CreateBuild(repo.ID, j.Name, sha, tag, string(steps), j.Image, "", true)
306	306	if err != nil {
307	307	slog.Error("queueing tag build", "repo", repo.Path(), "job", j.Name, "err", err)
308	308	continue

internal/store/builds.go +21 −5

		@@ -19,6 +19,7 @@ type Build struct {
19	19	Ref string
20	20	Steps string // JSON array of shell commands
21	21	Image string // container image for the steps; "" means the runner default
	22	Tree string // the commit's tree; "" when not deduplicated by tree
22	23	Status string // pending\|running\|success\|failure
23	24	CreatedAt string
24	25	StartedAt string
		@@ -39,7 +40,7 @@ var truncNotice = []byte("\n[log truncated: reached the " +
39	40
40	41	// CreateBuild allocates the per-repo build number in the same transaction
41	42	// as the insert, like issue and MR numbers.
42		func (s *Store) CreateBuild(repoID int64, job, sha, ref, stepsJSON, image string, trusted bool) (int64, error) {
	43	func (s *Store) CreateBuild(repoID int64, job, sha, ref, stepsJSON, image, tree string, trusted bool) (int64, error) {
43	44	tx, err := s.DB.Begin()
44	45	if err != nil {
45	46	return 0, err
		@@ -53,21 +54,21 @@ func (s *Store) CreateBuild(repoID int64, job, sha, ref, stepsJSON, image string
53	54	return 0, err
54	55	}
55	56	if _, err := tx.Exec(
56		"INSERT INTO builds (repo_id, number, job, sha, ref, steps, image, trusted) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
57		repoID, n, job, sha, ref, stepsJSON, image, trusted); err != nil {
	57	"INSERT INTO builds (repo_id, number, job, sha, ref, steps, image, tree, trusted) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
	58	repoID, n, job, sha, ref, stepsJSON, image, tree, trusted); err != nil {
58	59	return 0, err
59	60	}
60	61	return n, tx.Commit()
61	62	}
62	63
63	64	const buildSelect = `
64		SELECT id, repo_id, number, job, sha, ref, steps, image, status, created_at, started_at, finished_at, trusted
	65	SELECT id, repo_id, number, job, sha, ref, steps, image, tree, status, created_at, started_at, finished_at, trusted
65	66	FROM builds`
66	67
67	68	func scanBuild(row interface{ Scan(...any) error }) (Build, error) {
68	69	var b Build
69	70	var trusted int
70		err := row.Scan(&b.ID, &b.RepoID, &b.Number, &b.Job, &b.SHA, &b.Ref, &b.Steps, &b.Image,
	71	err := row.Scan(&b.ID, &b.RepoID, &b.Number, &b.Job, &b.SHA, &b.Ref, &b.Steps, &b.Image, &b.Tree,
71	72	&b.Status, &b.CreatedAt, &b.StartedAt, &b.FinishedAt, &trusted)
72	73	b.Trusted = trusted != 0
73	74	return b, err
		@@ -315,6 +316,21 @@ func (s *Store) CancelBuild(id int64) error {
315	316
316	317	// SuccessBuildFor finds a passed build of the commit for the job, on any
317	318	// ref: what a cancelled duplicate can point back at.
	319	// SuccessBuildForTree is SuccessBuildFor keyed by tree rather than
	320	// commit: a rebase that changes nothing in the tree has already been
	321	// built (#177). An empty tree never matches.
	322	func (s *Store) SuccessBuildForTree(repoID int64, tree, job string) (Build, bool, error) {
	323	if tree == "" {
	324	return Build{}, false, nil
	325	}
	326	b, err := scanBuild(s.DB.QueryRow(buildSelect+
	327	" WHERE repo_id = ? AND tree = ? AND job = ? AND status = 'success' ORDER BY number DESC LIMIT 1", repoID, tree, job))
	328	if errors.Is(err, sql.ErrNoRows) {
	329	return Build{}, false, nil
	330	}
	331	return b, err == nil, err
	332	}
	333
318	334	func (s *Store) SuccessBuildFor(repoID int64, sha, job string) (Build, bool, error) {
319	335	b, err := scanBuild(s.DB.QueryRow(buildSelect+
320	336	" WHERE repo_id = ? AND sha = ? AND job = ? AND status = 'success' ORDER BY number DESC LIMIT 1", repoID, sha, job))

internal/store/builds_test.go +43 −7

		@@ -21,11 +21,11 @@ func TestReapStaleBuilds(t *testing.T) {
21	21	t.Fatal(err)
22	22	}
23	23
24		stuck, err := s.CreateBuild(1, "test", "abc123", "main", `["true"]`, "", true)
	24	stuck, err := s.CreateBuild(1, "test", "abc123", "main", `["true"]`, "", "", true)
25	25	if err != nil {
26	26	t.Fatal(err)
27	27	}
28		fresh, err := s.CreateBuild(1, "pages", "abc123", "main", `["true"]`, "", true)
	28	fresh, err := s.CreateBuild(1, "pages", "abc123", "main", `["true"]`, "", "", true)
29	29	if err != nil {
30	30	t.Fatal(err)
31	31	}
		@@ -87,11 +87,11 @@ func TestBuildsForCommitTiming(t *testing.T) {
87	87	}
88	88	// Two runs of the same job on one commit: the retry is what counts.
89	89	for range 2 {
90		if _, err := s.CreateBuild(repoID, "test", "abc123", "main", `["true"]`, "", true); err != nil {
	90	if _, err := s.CreateBuild(repoID, "test", "abc123", "main", `["true"]`, "", "", true); err != nil {
91	91	t.Fatal(err)
92	92	}
93	93	}
94		if _, err := s.CreateBuild(repoID, "lint", "def456", "main", `["true"]`, "", true); err != nil {
	94	if _, err := s.CreateBuild(repoID, "lint", "def456", "main", `["true"]`, "", "", true); err != nil {
95	95	t.Fatal(err)
96	96	}
97	97	if _, err := s.DB.Exec(`UPDATE builds SET started_at = '2026-08-28T04:42:54Z',
		@@ -140,10 +140,10 @@ func TestClaimBuildScopedToRepos(t *testing.T) {
140	140	t.Fatal(err)
141	141	}
142	142	// Queued first, so an unscoped claim would take it.
143		if _, err := s.CreateBuild(theirs, "evil", "abc123", "main", `["true"]`, "", true); err != nil {
	143	if _, err := s.CreateBuild(theirs, "evil", "abc123", "main", `["true"]`, "", "", true); err != nil {
144	144	t.Fatal(err)
145	145	}
146		wanted, err := s.CreateBuild(mine, "deploy", "def456", "main", `["true"]`, "", true)
	146	wanted, err := s.CreateBuild(mine, "deploy", "def456", "main", `["true"]`, "", "", true)
147	147	if err != nil {
148	148	t.Fatal(err)
149	149	}
		@@ -182,7 +182,7 @@ func TestBuildLogSaysWhenItTruncates(t *testing.T) {
182	182	if _, err := s.CreateRepo("user", uid, "orgo", "public"); err != nil {
183	183	t.Fatal(err)
184	184	}
185		id, err := s.CreateBuild(1, "test", "abc123", "main", `["true"]`, "", true)
	185	id, err := s.CreateBuild(1, "test", "abc123", "main", `["true"]`, "", "", true)
186	186	if err != nil {
187	187	t.Fatal(err)
188	188	}
		@@ -212,3 +212,39 @@ func TestBuildLogSaysWhenItTruncates(t *testing.T) {
212	212	t.Errorf("log grew to %d, past the cap plus one chunk", len(log))
213	213	}
214	214	}
	215
	216	// A success is found by tree across commits; an empty tree never matches,
	217	// so builds queued without one (scheduled, tag) are never reused (#177).
	218	func TestSuccessBuildForTree(t *testing.T) {
	219	s := open(t)
	220	if err := s.MigrateUp(); err != nil {
	221	t.Fatal(err)
	222	}
	223	uid, err := s.CreateUser("cmc", true)
	224	if err != nil {
	225	t.Fatal(err)
	226	}
	227	repoID, err := s.CreateRepo("user", uid, "app", "public")
	228	if err != nil {
	229	t.Fatal(err)
	230	}
	231	if _, err := s.CreateBuild(repoID, "unit", "aaa", "main", `["true"]`, "", "tree1", true); err != nil {
	232	t.Fatal(err)
	233	}
	234	b, _ := s.BuildsForCommit(repoID, "aaa")
	235	if _, ok, err := s.ClaimBuild([]int64{repoID}); err != nil \|\| !ok {
	236	t.Fatalf("claim: ok=%v err=%v", ok, err)
	237	}
	238	if err := s.FinishBuild(b["unit"].ID, "success"); err != nil {
	239	t.Fatal(err)
	240	}
	241	if prev, ok, _ := s.SuccessBuildForTree(repoID, "tree1", "unit"); !ok \|\| prev.SHA != "aaa" {
	242	t.Fatalf("success not found by tree: ok=%v prev=%+v", ok, prev)
	243	}
	244	if _, ok, _ := s.SuccessBuildForTree(repoID, "tree1", "other"); ok {
	245	t.Error("matched a different job")
	246	}
	247	if _, ok, _ := s.SuccessBuildForTree(repoID, "", "unit"); ok {
	248	t.Error("an empty tree matched")
	249	}
	250	}

internal/store/migrations/0045_build_tree.down.sql added +2

		@@ -0,0 +1,2 @@
	1	DROP INDEX builds_by_tree;
	2	ALTER TABLE builds DROP COLUMN tree;

internal/store/migrations/0045_build_tree.up.sql added +6

		@@ -0,0 +1,6 @@
	1	-- The tree a build's commit points at. A rebase gives a commit a new sha
	2	-- and the same tree; a job's result is a property of the tree, so a
	3	-- success recorded against it stands for the new commit too (#177).
	4	-- Empty for scheduled and tag builds, which are not deduplicated.
	5	ALTER TABLE builds ADD COLUMN tree TEXT NOT NULL DEFAULT '';
	6	CREATE INDEX builds_by_tree ON builds (repo_id, tree, job);

internal/store/statuses_test.go +1 −1

		@@ -17,7 +17,7 @@ func TestChecksForCommit(t *testing.T) {
17	17	if err != nil {
18	18	t.Fatal(err)
19	19	}
20		if _, err := s.CreateBuild(repoID, "test", "abc123", "main", `["true"]`, "", true); err != nil {
	20	if _, err := s.CreateBuild(repoID, "test", "abc123", "main", `["true"]`, "", "", true); err != nil {
21	21	t.Fatal(err)
22	22	}
23	23	if _, err := s.DB.Exec(`UPDATE builds SET started_at = '2026-08-28T04:42:54Z',

Commit 387b381242

Commit `387b381242`