diff --git a/modules/mesh-delivery-checker/cmd/mesh-delivery-checker-tools/main.go b/modules/mesh-delivery-checker/cmd/mesh-delivery-checker-tools/main.go index 4d5aa37..5972f6f 100644 --- a/modules/mesh-delivery-checker/cmd/mesh-delivery-checker-tools/main.go +++ b/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) { diff --git a/modules/mesh-delivery-checker/internal/check/checker.go b/modules/mesh-delivery-checker/internal/check/checker.go index e168211..aad5c53 100644 --- a/modules/mesh-delivery-checker/internal/check/checker.go +++ b/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 diff --git a/modules/mesh-delivery-checker/internal/check/rank_test.go b/modules/mesh-delivery-checker/internal/check/rank_test.go index 801fe8e..e436dd4 100644 --- a/modules/mesh-delivery-checker/internal/check/rank_test.go +++ b/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) + } + } +} diff --git a/modules/mesh-delivery-checker/internal/check/read.go b/modules/mesh-delivery-checker/internal/check/read.go index 11be7c4..ed7eaec 100644 --- a/modules/mesh-delivery-checker/internal/check/read.go +++ b/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