Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions changelog.d/fixed-merge-lane-gone-front.md
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
- Serialized merge lane: a front pull request that is closed, merged outside the lane, turned into a draft or retargeted now leaves on the next automerge sweep pass, with a `front check: …` exit reason, and the next waiting pull request is promoted. The sweeps list open pull requests only, so no merge path ever called in for such a front again and it held every waiter until the front timeout (up to four timeouts when its checks were last seen pending). Each pass now reads every front of a `hive-serialized` repository once; open fronts are unchanged.
9 changes: 9 additions & 0 deletions src/docs/operator-reference.md
Original file line number Diff line number Diff line change
Expand Up @@ -885,6 +885,15 @@ GitHub: ...`, since nothing was applied; a 5xx or transport error on the
merge call is not definitive, so that front keeps waiting and re-validates
until the front timeout.

A front pull request that is closed, merged outside the lane, turned into a
draft or retargeted to another branch leaves on the next automerge sweep
pass. The merge paths list open pull requests only, so none of them calls in
for it again; instead every pass reads each front of a `hive-serialized`
repository once and releases a front in one of those states with a reason
such as `front check: pull request is closed` or `front check: pull request
is already merged`, and the next waiting pull request is promoted. An open
front, including one waiting on its required checks, is left as it is.

A front that GitHub still reports as `blocked` after its head contains the
current target tip and all required checks pass also leaves immediately. The
lane re-reads the PR after observing passing checks, so a block in the earlier
Expand Down
41 changes: 41 additions & 0 deletions src/pkg/github/automerge/automerge_lane_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -601,3 +601,44 @@ func TestLaneSweep_HeldQueuedFrontLeavesTheLane(t *testing.T) {
}
}
}

// A front PR closed or merged outside the lane is not in the open-PR lists
// the lanes walk, so no path calls in for it again. Every pass asks the lane,
// once per hive-serialized repo it covers, to release such fronts; a direct
// repo and a repo the pass does not target are never consulted.
func TestLaneSweep_PassReleasesGoneFronts(t *testing.T) {
var merged []int
api := newSelfAuthoredAutoMergeAPI(t, nil, &merged)
defer api.Close()
g := &laneGate{answer: laneAnswer(hgithub.LaneOutcomeLeft, "#25: front check: pull request is closed")}
c := newLaneSweepEngine(api.URL, config.MergeStrategyHiveSerialized, g.gate, Options{})

c.sweepPass(context.Background(), 5, true, nil, "tick")
if len(g.reqs) != 1 {
t.Fatalf("lane requests = %+v, want one front check", g.reqs)
}
if req := g.reqs[0]; !req.ReleaseGoneFronts || req.Repo != "acme/widget" || req.Number != 0 || req.Branch != "" || req.FrontOnly || req.Authorize != nil || req.Path != hgithub.PRAuditPathSweep {
t.Fatalf("lane request = %+v, want a repo-wide front check from the sweep", req)
}

g.reqs = nil
g.answer = func(context.Context, hgithub.LaneMergeRequest) (hgithub.LaneMergeResult, error) {
return hgithub.LaneMergeResult{Outcome: hgithub.LaneOutcomeWaiting}, errors.New("lane record unwritable")
}
c.sweepPass(context.Background(), 5, true, SweepTargets{"acme/widget": {7: true}}, "event")
if len(g.reqs) != 1 || !g.reqs[0].ReleaseGoneFronts {
t.Fatalf("targeted pass lane requests = %+v, want the repo's front check (a lane error is only logged)", g.reqs)
}

g.reqs = nil
c.sweepPass(context.Background(), 5, true, SweepTargets{"acme/other": {7: true}}, "event")
if len(g.reqs) != 0 {
t.Fatalf("pass targeting another repo consulted the lane: %+v", g.reqs)
}

direct := &laneGate{answer: func(context.Context, hgithub.LaneMergeRequest) (hgithub.LaneMergeResult, error) {
t.Fatal("a direct repo must never consult the lane")
return hgithub.LaneMergeResult{}, nil
}}
newLaneSweepEngine(api.URL, config.MergeStrategyDirect, direct.gate, Options{}).sweepPass(context.Background(), 5, true, nil, "tick")
}
32 changes: 32 additions & 0 deletions src/pkg/github/automerge/automerge_sweep.go
Original file line number Diff line number Diff line change
Expand Up @@ -1853,6 +1853,7 @@ func (c *Engine) sweepPass(ctx context.Context, maxMerges int, acmmAllowed bool,
result.Merged = append(result.Merged, laneResult.Merged...)
}
}
c.releaseGoneLaneFronts(ctx, targets)
if stageResult, stageErr := c.ApplyStageLabels(ctx); stageErr != nil {
c.warn("stage labels reconcile failed", "error", stageErr, "items", stageResult.Items, "writes", stageResult.Writes)
} else if stageResult.Writes+stageResult.Comments > 0 {
Expand Down Expand Up @@ -2346,6 +2347,37 @@ func (c *Engine) rejectBeforeLane(ctx context.Context, serialized bool, gate hgi
return AutoMergeSweepEvent{}, reason, nil
}

// releaseGoneLaneFronts asks the serialized lane, once per pass and
// hive-serialized repo, to release a front PR that was closed, merged outside
// the lane, made a draft or retargeted. The lanes above list open PRs only, so
// no path calls in for such a front again: without this it held every waiter
// until the front timeout (up to 4x that while its checks were last pending).
// The lane reads one PR per front and never merges here.
func (c *Engine) releaseGoneLaneFronts(ctx context.Context, targets SweepTargets) {
for _, repo := range c.activeRepos() {
owner, name := c.transport.SplitRepo(repo)
fullRepo := owner + "/" + name
if !targets.selectsRepo(fullRepo) {
continue
}
serialized, gate := c.serializedLane(repo)
if !serialized || gate == nil {
continue
}
res, err := hgithub.RunSerializedLane(ctx, gate, hgithub.LaneMergeRequest{
Repo: fullRepo,
Path: hgithub.PRAuditPathSweep,
ReleaseGoneFronts: true,
})
switch {
case err != nil:
c.warn("automerge sweep: serialized lane could not check its fronts", "repo", fullRepo, "error", err)
case res.Outcome == hgithub.LaneOutcomeLeft:
c.info("automerge sweep: a closed, merged or retargeted PR left the serialized lane front", "repo", fullRepo, "lane_reason", res.Reason)
}
}
}

// mergeThroughLane hands a PR that passed every gate of its sweep path to the
// serialized lane. Only the lane's front PR merges, after the lane's final
// re-check and authorize (the path's own authorization for the exact head).
Expand Down
6 changes: 6 additions & 0 deletions src/pkg/github/merge_lane_gate.go
Original file line number Diff line number Diff line change
Expand Up @@ -43,6 +43,12 @@ type LaneMergeRequest struct {
// never merges it, and lets it leave with the lane's own reason; any
// other PR is not recorded.
FrontOnly bool
// ReleaseGoneFronts asks the lane to read every current front of Repo
// (Number and Branch unset) and release one that can no longer merge into
// its branch: closed, merged outside the lane, a draft or retargeted. The
// sweeps list open PRs only, so no path calls in for such a front again.
// The lane never merges, enqueues or writes to GitHub here.
ReleaseGoneFronts bool
}

// LaneMergeResult is what the lane did. Reason is set for every no-merge.
Expand Down
36 changes: 36 additions & 0 deletions src/pkg/mergelane/gate.go
Original file line number Diff line number Diff line change
@@ -1,3 +1,3 @@
package mergelane

import (
Expand Down Expand Up @@ -37,6 +37,9 @@
// the lane runs; otherwise the PR records its eligibility and, only when it
// is at the front, runs one lane round that may end in the pinned merge.
func (l *Lane) Merge(ctx context.Context, req ghub.LaneMergeRequest) (ghub.LaneMergeResult, error) {
if req.ReleaseGoneFronts {
return l.releaseGoneFronts(ctx, req.Repo)
}
branch := strings.TrimSpace(req.Branch)
if branch == "" {
p, err := l.opts.GitHub.PullRequest(ctx, req.Repo, req.Number)
Expand Down Expand Up @@ -91,6 +94,39 @@
return ghub.LaneMergeResult{Outcome: string(dec.Outcome), Reason: dec.Reason}, err
}

// releaseGoneFronts serves the sweep's once-per-pass front check: every front
// of repo whose PR can no longer merge into its branch leaves at once. The
// outcome is left when any front left, with one "#N: reason" per front.
func (l *Lane) releaseGoneFronts(ctx context.Context, repo string) (ghub.LaneMergeResult, error) {
if strings.TrimSpace(repo) == "" {
err := errors.New("mergelane: a repo is required to check its fronts")
return ghub.LaneMergeResult{Outcome: ghub.LaneOutcomeRefused, Reason: err.Error()}, err
}
recs, err := l.opts.Store.Lanes(repo)
if err != nil {
return ghub.LaneMergeResult{Outcome: ghub.LaneOutcomeWaiting, Reason: "reading the lane failed: " + err.Error()}, err
}
res := ghub.LaneMergeResult{Outcome: ghub.LaneOutcomeWaiting}
var left []string
var errs []error
for _, rec := range recs {
if rec.Front == nil {
continue
}
reason, err := l.releaseGoneFront(ctx, rec.Repo, rec.Branch, rec.Front.PR)
if err != nil {
errs = append(errs, err)
}
if reason != "" {
left = append(left, fmt.Sprintf("#%d: %s", rec.Front.PR, reason))
}
}
if len(left) > 0 {
res.Outcome, res.Reason = ghub.LaneOutcomeLeft, strings.Join(left, "; ")
}
return res, errors.Join(errs...)
}

// nativeMergeQueue returns a refusal when branch has GitHub's native merge
// queue or when that cannot be established (fail closed).
func (l *Lane) nativeMergeQueue(ctx context.Context, repo, branch string) string {
Expand Down
187 changes: 187 additions & 0 deletions src/pkg/mergelane/gone_front_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,187 @@
package mergelane

import (
"context"
"strings"
"testing"

ghub "github.com/hivecommons/hive/pkg/github"
)

func (h *harness) releaseGone() (ghub.LaneMergeResult, error) {
h.t.Helper()
return h.lane.Merge(context.Background(), ghub.LaneMergeRequest{
Repo: testRepo, Path: ghub.PRAuditPathSweep, ReleaseGoneFronts: true,
})
}

// A front PR closed, merged, drafted or retargeted outside the lane gets no
// further round from its merge path (the sweeps list open PRs only), so it
// held every waiter until the front timeout. The sweep's front check releases
// it at once with prShape's reason and promotes the oldest waiter, without
// any GitHub write.
func TestGoneFrontLeavesOnTheSweepFrontCheck(t *testing.T) {
for _, tc := range []struct {
name string
apply func(*PullRequest)
want string
}{
{"closed", func(p *PullRequest) { p.Open = false }, "pull request is closed"},
{"merged elsewhere", func(p *PullRequest) { p.Open, p.Merged = false, true }, "pull request is already merged"},
{"draft", func(p *PullRequest) { p.Draft = true }, "pull request is a draft"},
{"retargeted", func(p *PullRequest) { p.Base = "release" }, `pull request now targets "release", not "main"`},
} {
t.Run(tc.name, func(t *testing.T) {
h := newGateHarness(t)
p := h.f.addPR(1, "h1")
h.f.addPR(2, "h2")
for _, n := range []int{1, 2, 3} {
h.acquire(n)
}
deadline := h.record().Front.DeadlineAt
tc.apply(p)
calls := len(h.f.calls)

res, err := h.releaseGone()
if err != nil {
t.Fatalf("releaseGone: %v", err)
}
want := "front check: " + tc.want
expectGate(t, res, ghub.LaneOutcomeLeft, "#1: "+want)
rec := h.record()
if rec.Front == nil || rec.Front.PR != 2 || !h.now.Before(deadline) {
t.Fatalf("front = %+v at %s, want #2 promoted before deadline %s", rec.Front, h.now, deadline)
}
if len(rec.Waiting) != 1 || rec.Waiting[0].PR != 3 {
t.Fatalf("waiting = %+v, want only #3", rec.Waiting)
}
if exit := rec.LastExit; exit == nil || exit.PR != 1 || exit.Reason != want || !exit.At.Equal(h.now) {
t.Fatalf("last exit = %+v, want #1 with %q", exit, want)
}
exits := h.eventsFor(ActionFrontExit)
if len(exits) != 1 || exits[0].PR != 1 || exits[0].Head != "h1" || exits[0].Reason != want {
t.Fatalf("front exit audit = %+v", exits)
}
if enters := h.eventsFor(ActionFrontEnter); len(enters) != 2 || enters[1].PR != 2 {
t.Fatalf("front enter audit = %+v, want #2 entering after #1", enters)
}
if got := h.f.calls[calls:]; len(got) != 1 || got[0] != "PullRequest" {
t.Fatalf("GitHub calls = %v, want one PR read", got)
}
if len(h.f.merges) != 0 || len(h.f.updates) != 0 || len(h.f.comments) != 0 {
t.Fatalf("front check wrote to GitHub: merges=%v updates=%v comments=%v", h.f.merges, h.f.updates, h.f.comments)
}
// The promoted front then runs its own round and merges.
expectGate(t, h.gate(2), ghub.LaneOutcomeMerged, "merged")
})
}
}

// An open front is untouched, including one legitimately waiting on CI: the
// check reads the PR and changes nothing, so its deadline, extensions and
// pending-checks state stay as they were.
func TestOpenFrontStaysOnTheSweepFrontCheck(t *testing.T) {
h := newGateHarness(t)
p := h.f.addPR(1, "h1")
h.f.setRun(p.Head, "build", "in_progress", "")
h.acquire(1)
h.acquire(2)
expectOutcome(t, h.advance(1), OutcomeWaiting, "build (in_progress)")
before := h.record()
if !before.Front.ChecksPending {
t.Fatalf("front = %+v, want it waiting on pending checks", before.Front)
}
events := len(h.events)

res, err := h.releaseGone()
if err != nil {
t.Fatalf("releaseGone: %v", err)
}
if res.Outcome != ghub.LaneOutcomeWaiting || res.Reason != "" {
t.Fatalf("result = %+v, want waiting with no reason", res)
}
after := h.record()
if after.Front == nil || *after.Front != *before.Front || after.LastExit != nil || len(after.Waiting) != 1 {
t.Fatalf("record changed:\nbefore %+v\nafter %+v", before, after)
}
if len(h.events) != events {
t.Fatalf("open front check audited %+v", h.events[events:])
}
}

// A front whose PR cannot be read stays (the timeout still bounds it), and
// the error is reported to the sweep.
func TestUnreadableFrontStaysOnTheSweepFrontCheck(t *testing.T) {
h := newGateHarness(t)
h.f.addPR(1, "h1").Open = false
h.acquire(1)
h.acquire(2)
h.f.errs["PullRequest"] = errBoom
res, err := h.releaseGone()
if err == nil || !strings.Contains(err.Error(), "#1") {
t.Fatalf("err = %v, want the PR read failure for #1", err)
}
if res.Outcome != ghub.LaneOutcomeWaiting || h.frontPR() != 1 || h.record().LastExit != nil {
t.Fatalf("result = %+v, front = #%d; want #1 kept", res, h.frontPR())
}
}

// The release is fenced on the front it read: a front that changed while the
// PR was being read (here released by its path, promoting #2) is not ended.
func TestGoneFrontCheckIsFencedOnTheFrontItRead(t *testing.T) {
h := newGateHarness(t)
h.f.addPR(1, "h1").Open = false
for _, n := range []int{1, 2, 3} {
h.acquire(n)
}
h.f.on("PullRequest", 1, func() {
if err := h.lane.Release(testRepo, testBranch, 1, "released by its merge path"); err != nil {
t.Fatalf("Release: %v", err)
}
})
res, err := h.releaseGone()
if err != nil || res.Outcome != ghub.LaneOutcomeWaiting {
t.Fatalf("result = %+v, %v; want waiting, nothing left by the check", res, err)
}
if rec := h.record(); rec.Front == nil || rec.Front.PR != 2 || len(rec.Waiting) != 1 || rec.LastExit == nil || rec.LastExit.Reason != "released by its merge path" {
t.Fatalf("record = %+v, want #2 at the front and #3 waiting", rec)
}
}

// Every branch's front of the repo is checked; an empty lane and another
// repo's lane cost no GitHub call.
func TestGoneFrontCheckCoversEveryBranchOfTheRepo(t *testing.T) {
h := newGateHarness(t)
h.f.addPR(1, "h1").Open = false
rel := h.f.addPR(5, "h5")
rel.Base = "release"
h.acquire(1)
if _, err := h.lane.Acquire(testRepo, "release", 5, "sweep"); err != nil {
t.Fatal(err)
}
if _, err := h.lane.Acquire("acme/other", testBranch, 1, "sweep"); err != nil {
t.Fatal(err)
}
res, err := h.releaseGone()
if err != nil {
t.Fatalf("releaseGone: %v", err)
}
expectGate(t, res, ghub.LaneOutcomeLeft, "#1: front check: pull request is closed")
if h.frontPR() != 0 {
t.Fatalf("main front = #%d, want empty", h.frontPR())
}
if rec, _, _ := h.lane.Snapshot(testRepo, "release"); rec.Front == nil || rec.Front.PR != 5 {
t.Fatalf("release front = %+v, want #5 kept", rec.Front)
}
if rec, _, _ := h.lane.Snapshot("acme/other", testBranch); rec.Front == nil || rec.Front.PR != 1 {
t.Fatalf("other repo front = %+v, want untouched", rec.Front)
}
if n := h.f.count("PullRequest"); n != 2 {
t.Fatalf("PR reads = %d, want one per front of %s", n, testRepo)
}

empty := newGateHarness(t)
if res, err := empty.releaseGone(); err != nil || res.Outcome != ghub.LaneOutcomeWaiting || len(empty.f.calls) != 0 {
t.Fatalf("empty lane: %+v, %v, calls %v", res, err, empty.f.calls)
}
}
Loading
Loading