checker_status reads the node-engine at its running commit, as the checker's decision does, so it stops listing every candidate as waiting for a trunk move (issue 568)

modules/mesh-delivery-checker/cmd/mesh-delivery-checker-tools/main.go

@@ -53,6 +53,25 @@ func read(s stdio.KeptState) check.StateRead {
 	}}
 }
 
+// runsOf says which commit the mesh runs of a module from the indexer's modules state, as the checker's own record of it does
+// (the commit the module's record was computed at); "" when the record is not readable.
+type runsOf struct{ modules check.StateRead }
+
+func (r runsOf) CommitOf(module string) string {
+	if r.modules.Get == nil {
+		return ""
+	}
+	raw, err := r.modules.Get(module)
+	if err != nil || len(raw) == 0 {
+		return ""
+	}
+	m, err := delivery.DecodeModule(raw)
+	if err != nil {
+		return ""
+	}
+	return m.Commit
+}
+
 // stateStore is a state the tools write: the tries.
 type stateStore struct {
 	check.StateRead
@@ -197,6 +216,7 @@ func main() {
 		StepStates:   map[string]check.StateRead{"mesh-build-go": read(stdio.State("mesh-build-go.steps")), "mesh-build-node": read(stdio.State("mesh-build-node.steps"))},
 		HaveState:    read(stdio.State("node-engine.have")), StepBound: stepBound(),
 		TurnState: read(stdio.State("mesh-delivery-gate.turns"))}
+	r.Runs = runsOf{read(stdio.State("mesh-delivery-indexer.modules"))} // the node-engine at the commit the mesh runs, as the checker reads it
 	tries := stdio.State(check.TriesState)
 	source := stdio.State("mesh-delivery-gate.source")
 	trunks := func() (map[string]string, error) {

modules/mesh-delivery-checker/internal/check/checker.go

@@ -272,13 +272,20 @@ func (ch *Checker) stale(v delivery.Verdict, cs *Case) bool {
 // besideNow are the commits a sibling is read at now, by repository: its trunk head, and for the node-engine the commit the
 // mesh runs when the indexer names one, as besideFor places them.
 func (ch *Checker) besideNow() map[string]string {
-	now := ch.heads()
-	if ch.Runs != nil {
-		if c := ch.Runs.CommitOf(nodeEngineModule); c != "" {
-			if now == nil {
-				now = map[string]string{}
+	return besideAt(ch.heads(), ch.Runs)
+}
+
+// besideAt places the commits a sibling is read at: the trunk heads, with the node-engine at the commit the mesh runs when
+// runs names one (ADR 0548 §6). The checker's decision and the status read the same commits through it.
+func besideAt(now map[string]string, runs interface{ CommitOf(module string) string }) map[string]string {
+	if runs != nil {
+		if c := runs.CommitOf(nodeEngineModule); c != "" {
+			out := make(map[string]string, len(now)+1)
+			for r, h := range now {
+				out[r] = h
 			}
-			now[nodeEngineRepo] = c
+			out[nodeEngineRepo] = c
+			return out
 		}
 	}
 	return now

modules/mesh-delivery-checker/internal/check/rank_test.go

@@ -75,3 +75,40 @@ func TestCheckerStatusNamesTheWaitingChecksByKind(t *testing.T) { // 1897/AC4
 		t.Errorf("waiting = %v, want %v", st.Waiting, want)
 	}
 }
+
+// 568 note 21: a verdict that read the node-engine at its running commit is not waiting for a trunk move while that commit
+// is still the one the mesh runs, though the node-engine's trunk has moved on (ADR 0548 §6).
+func TestCheckerStatusReadsTheNodeEngineAtItsRunningCommit(t *testing.T) { // 568/21
+	cand := candidateOf(t, group(1), pullOf(repoA, 1, head1))
+	ckey, _ := delivery.CandidatesKey(group(1))
+	vkey := keyOf(t, group(1), cand)
+	dc, _ := delivery.DecodeCandidate(cand)
+	judged, err := delivery.EncodeVerdict(delivery.Verdict{Group: group(1), Heads: dc.HeadsHash, Trunk: map[string]string{repoA: trunkA}, Beside: map[string]string{nodeEngineRepo: "run111"}, State: delivery.VerdictPass, Levels: passing().Levels})
+	if err != nil {
+		t.Fatal(err)
+	}
+	heads := func() (map[string]string, error) {
+		return map[string]string{repoA: trunkA, nodeEngineRepo: "trunk222"}, nil
+	}
+	for _, row := range []struct {
+		name string
+		runs runsAt
+		want int
+	}{
+		{"the running commit the verdict read", runsAt{nodeEngineModule: "run111"}, 0},
+		{"the running commit moved", runsAt{nodeEngineModule: "run999"}, 1},
+		{"no running commit known: the trunk's", nil, 1},
+	} {
+		rd := Reader{CandidateState: fakeState{ckey: cand}.read(), VerdictState: fakeState{vkey: judged}.read(), Trunks: heads}
+		if row.runs != nil {
+			rd.Runs = row.runs
+		}
+		st, err := rd.Status()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := len(st.Waiting[KindTrunk]); got != row.want {
+			t.Errorf("%s: waiting for a trunk move = %v, want %d", row.name, st.Waiting[KindTrunk], row.want)
+		}
+	}
+}

modules/mesh-delivery-checker/internal/check/read.go

@@ -41,7 +41,10 @@ type Reader struct {
 	Trunks func() (map[string]string, error)
 	// TurnState is the gate's merge turns (ADR 0548 §3); without it no check is named as held by a turn.
 	TurnState StateRead
-	Now       func() time.Time
+	// Runs says which commit the mesh runs of a module (the indexer's modules), as the checker's decision reads it: the
+	// node-engine a verdict names is compared at its running commit, not at the trunk's (ADR 0548 §6); nil knows none.
+	Runs interface{ CommitOf(module string) string }
+	Now  func() time.Time
 }
 
 // VerdictRead is a verdict as stored with the full report of the status of each pull request it judged (Report), when the
@@ -489,7 +492,7 @@ func (r Reader) Status() (Status, error) {
 			case IsNodesFailure(v):
 				st.Waiting[KindNodes] = append(st.Waiting[KindNodes], c.Group)
 			case heads != nil:
-				if cs := CaseOf(c, heads); cs != nil && (!sameTrunk(v.Trunk, cs.Trunk) || besideMoved(v.Beside, heads)) {
+				if cs := CaseOf(c, heads); cs != nil && (!sameTrunk(v.Trunk, cs.Trunk) || besideMoved(v.Beside, besideAt(heads, r.Runs))) {
 					st.Waiting[KindTrunk] = append(st.Waiting[KindTrunk], c.Group)
 					if why := heldBy(turns, c, heads); why != "" {
 						st.HeldByTurn[c.Group] = why