From c9fd571e8e1c957cf9816551a47bb807ac9e361a Mon Sep 17 00:00:00 2001 From: jochen Date: Fri, 20 Nov 2026 03:48:12 +0100 Subject: [PATCH] R15: pipeline-failed is one finding per failing mover MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The finding pipeline-failed has scope delivery and id ., one per mover whose required step failed or could not run, naming the pipeline and the steps, owned by the commit's author as before; that module's next passed pipeline on that branch clears it. Unit tests 84 to 84 (the newer-revision test replaced). Builds: design 47 H §770; lead answers H-A-19, H-A-59 Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- .../internal/pipeline/failed.go | 108 +++++++----------- .../internal/pipeline/failed_test.go | 73 ++++++------ .../internal/pipeline/steps.go | 1 + 3 files changed, 73 insertions(+), 109 deletions(-) diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/failed.go b/modules/mesh-delivery-pipeline/internal/pipeline/failed.go index fab2d0e4..313264ed 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/failed.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/failed.go @@ -59,9 +59,14 @@ func failedSteps(p seat.Pipeline, module string) []seat.StepResult { return out } -func (f *Failures) held(commit string) *condseat.Finding { +// findingID is a mover's finding's id, `.`, each escaped as a key's name is (design 47 H §770). +func findingID(module, branch string) string { return About(module, branch) } + +// held is the finding pipeline-failed of module on branch the findings hold, nil when none (§770). +func (f *Failures) held(module, branch string) *condseat.Finding { + id := findingID(module, branch) for _, h := range f.Findings.Held() { - if h.Scope == mcc.ScopeMerge && h.ID == commit && h.Kind == PipelineFailedKind { + if h.Scope == mcc.ScopeDelivery && h.ID == id && h.Kind == PipelineFailedKind { h := h return &h } @@ -69,24 +74,36 @@ func (f *Failures) held(commit string) *condseat.Finding { return nil } -// StepEnded is what the end of step s of pipeline p says of its head: a failed required step writes the finding of its commit, -// a step of a commit already found failed that is not one writes its owner when it had none, and a passing required step clears -// the findings of the older revisions it makes good. +// StepEnded raises, for the step s of p just ended, the finding pipeline-failed of its mover when a required step of that +// mover failed or could not run: one finding per failing mover, id `.` (design 47 H §770, H-A-19, H-A-59). func (f *Failures) StepEnded(store Updater, p seat.Pipeline, s seat.StepResult) { m, ok := MoverOf(p, s.Module) - if f == nil || f.Findings == nil || !ok || m.Commit == "" { + if f == nil || f.Findings == nil || !ok { return } - ctx := context.Background() - switch { - case len(failedSteps(p, m.Module)) > 0: - f.write(ctx, p, m) - case s.Outcome == seat.StepResultOutcomePassed || s.Outcome == seat.StepResultOutcomeCarried: - f.clearNewer(ctx, store, p, m) + if len(failedSteps(p, m.Module)) > 0 { + f.write(context.Background(), p, m) } } -// write raises or rewrites the mover m's finding (§33). +// Ended clears, for a pipeline that ended passed, each of its movers' finding pipeline-failed on its branch: that module's +// next passed pipeline on that branch clears it (§770). +func (f *Failures) Ended(p seat.Pipeline) { + if f == nil || f.Findings == nil || p.Outcome != seat.PipelineOutcomePassed { + return + } + for _, m := range p.Movers { + if f.held(m.Module, p.Branch) == nil { + continue + } + if err := f.Findings.Clear(context.Background(), mcc.ScopeDelivery, findingID(m.Module, p.Branch), PipelineFailedKind, + "the pipeline "+p.Pipeline+" of "+p.Branch+" passed"); err != nil { + f.logf("the finding %s of %s on %s is not cleared: %v", PipelineFailedKind, m.Module, p.Branch, err) + } + } +} + +// write raises or rewrites the mover m's finding, naming the pipeline and the steps (§770). func (f *Failures) write(ctx context.Context, p seat.Pipeline, m seat.Mover) { steps := failedSteps(p, m.Module) var names []string @@ -98,25 +115,26 @@ func (f *Failures) write(ctx context.Context, p seat.Pipeline, m seat.Mover) { now = f.Now().UTC() } owner, why := "", "" - if old := f.held(m.Commit); old != nil { + if old := f.held(m.Module, p.Branch); old != nil { owner = old.Owner } if owner == "" { owner, why = f.author(m) } - explanation := fmt.Sprintf("The required steps %s of %s did not pass on the branch %s at the commit %s. A newer commit of the branch that passes them clears this.", - strings.Join(names, ", "), m.Module, p.Branch, m.Commit) + explanation := fmt.Sprintf("The required steps %s of %s did not pass in the pipeline %s on the branch %s, at the commit %s. The module's next passed pipeline on the branch clears this.", + strings.Join(names, ", "), m.Module, p.Pipeline, p.Branch, m.Commit) if why != "" { explanation += " " + why } - err := f.Findings.Write(ctx, condseat.Finding{Scope: mcc.ScopeMerge, ID: m.Commit, Kind: PipelineFailedKind, Severity: condseat.FindingSeverityWarning, - Summary: fmt.Sprintf("%s on %s at %s: %s", m.Module, p.Branch, m.Commit, strings.Join(names, ", ")), + id := findingID(m.Module, p.Branch) + err := f.Findings.Write(ctx, condseat.Finding{Scope: mcc.ScopeDelivery, ID: id, Kind: PipelineFailedKind, Severity: condseat.FindingSeverityWarning, + Summary: fmt.Sprintf("%s on %s in %s: %s", m.Module, p.Branch, p.Pipeline, strings.Join(names, ", ")), Headline: fmt.Sprintf("A required step of %s failed on %s", m.Module, p.Branch), - Explanation: explanation, Needs: "a newer commit of " + p.Branch + " that passes " + strings.Join(names, ", "), + Explanation: explanation, Needs: "a passed pipeline of " + m.Module + " on " + p.Branch, Owner: owner, Source: "pipeline-runner." + PipelineFailedKind, Observer: f.Observer, At: now, - Subject: condseat.Subject{Scope: mcc.ScopeMerge, ID: m.Commit}}) + Subject: condseat.Subject{Scope: mcc.ScopeDelivery, ID: id}}) if err != nil { - f.logf("the finding %s of %s at %s is not written: %v", PipelineFailedKind, m.Module, m.Commit, err) + f.logf("the finding %s of %s on %s is not written: %v", PipelineFailedKind, m.Module, p.Branch, err) } } @@ -136,51 +154,3 @@ func (f *Failures) author(m seat.Mover) (string, string) { } return "forge:" + account, "" } - -// clearNewer clears the finding of each older pipeline of the branch moving m's module whose failed steps a newer one passed. -func (f *Failures) clearNewer(ctx context.Context, store Updater, p seat.Pipeline, m seat.Mover) { - pkeys, err := branchKeys(store, p.Branch) - if err != nil { - f.logf("the pipelines of %s on %s are not listed, so no finding %s is cleared: %v", m.Module, p.Branch, PipelineFailedKind, err) - return - } - var all []seat.Pipeline - for _, k := range pkeys { - if q, _, err := store.Get(k); err == nil && Moves(q, m.Module) { - all = append(all, q) - } - } - for _, old := range all { - was, _ := MoverOf(old, m.Module) - if old.Source >= p.Source || f.held(was.Commit) == nil { - continue - } - failed := failedSteps(old, m.Module) - if len(failed) == 0 { - continue - } - made := true - for _, s := range failed { - made = made && passedAfter(all, old, s) - } - if made { - if err := f.Findings.Clear(ctx, mcc.ScopeMerge, was.Commit, PipelineFailedKind, "a newer revision of "+p.Branch+" passes its steps"); err != nil { - f.logf("the finding %s of %s at %s is not cleared: %v", PipelineFailedKind, m.Module, was.Commit, err) - } - } - } -} - -func passedAfter(all []seat.Pipeline, old seat.Pipeline, s seat.StepResult) bool { - for _, q := range all { - if q.Source <= old.Source { - continue - } - for _, t := range q.Steps { - if t.Module == s.Module && t.Artifact == s.Artifact && t.Step == s.Step && (t.Outcome == seat.StepResultOutcomePassed || t.Outcome == seat.StepResultOutcomeCarried) { - return true - } - } - } - return false -} diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/failed_test.go b/modules/mesh-delivery-pipeline/internal/pipeline/failed_test.go index be365795..22105717 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/failed_test.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/failed_test.go @@ -3,7 +3,6 @@ package pipeline import ( "context" "errors" - "strconv" "strings" "testing" @@ -39,9 +38,10 @@ func (h *heldFindings) Held() []condseat.Finding { return out } -// A required step that failed or could not run is the finding pipeline-failed of its commit, owned by the commit's author as -// the forge records it; one whose author is not known has no owner and says why, and the next step end of that commit writes it -// (design 47 G §33, §540, A-191); an optional step that failed says nothing. +// A required step that failed or could not run is the finding pipeline-failed of its mover, id . in the scope +// delivery, owned by the commit's author as the forge records it; one whose author is not known has no owner and says why, and +// the next step end of that mover writes it (design 47 G §33, §540, A-191; H §770, H-A-59); an optional step that failed says +// nothing. func TestAFailedRequiredStepIsTheFindingOfItsCommit(t *testing.T) { for _, c := range []struct { name, step, outcome string @@ -73,17 +73,17 @@ func TestAFailedRequiredStepIsTheFindingOfItsCommit(t *testing.T) { if _, err := h.OnStepEnded(goSeat, goSeat.Prefix+"n1", ended(ask, c.step, c.outcome)); err != nil { t.Fatal(err) } - got, ok := f.held["merge.c1.pipeline-failed"] + got, ok := f.held["delivery.app.main.pipeline-failed"] if ok != c.wantFinding { t.Fatalf("finding written: %v, want %v (%v)", ok, c.wantFinding, f.held) } if !ok { return } - if got.Owner != c.wantOwner || got.Observer != "mesh-delivery-pipeline" || got.Subject.ID != "c1" { + if got.Owner != c.wantOwner || got.Observer != "mesh-delivery-pipeline" || got.Subject.ID != "app.main" { t.Fatalf("finding %+v, want owner %q", got, c.wantOwner) } - for _, name := range []string{"app", "main", "c1", "lint"} { + for _, name := range []string{"app", "main", "c1", "lint", pkey} { if !strings.Contains(got.Explanation, name) { t.Errorf("the explanation does not name %q: %s", name, got.Explanation) } @@ -109,7 +109,7 @@ func TestTheOwnerOfAFailedHeadIsWrittenAtTheNextStepEnd(t *testing.T) { if _, err := h.OnStepEnded(goSeat, goSeat.Prefix+"n1", ended("a1", "lint", "failed")); err != nil { t.Fatal(err) } - if f.held["merge.c1.pipeline-failed"].Owner != "" { + if f.held["delivery.app.main.pipeline-failed"].Owner != "" { t.Fatalf("an owner before the author is known: %+v", f.held) } known = true @@ -119,48 +119,41 @@ func TestTheOwnerOfAFailedHeadIsWrittenAtTheNextStepEnd(t *testing.T) { if _, err := h.OnStepEnded(goSeat, goSeat.Prefix+"n1", ended("a2", "unit", "failed")); err != nil { t.Fatal(err) } - if got := f.held["merge.c1.pipeline-failed"].Owner; got != "forge:bob" { + if got := f.held["delivery.app.main.pipeline-failed"].Owner; got != "forge:bob" { t.Fatalf("owner %q, want forge:bob", got) } } -// A newer revision of the branch passing the step that failed clears the finding of the older commit; one that does not pass -// it, and a newer head failing on its own, leave it, and the newer failing head is a finding of its own (§33, §540). -func TestANewerPassingRevisionClearsTheFinding(t *testing.T) { - h, store, _, _, _, _ := fixture() +// R15/AC1 (design 47 H §770): a pipeline with two failing movers raises two findings, one per mover, id .; +// a later pipeline passing one of them clears that one alone. +func TestEachFailingMoverIsAFindingAndItsNextPassedPipelineClearsIt(t *testing.T) { + h, store, _, _ := twoMovers(t) f := newHeld() h.Failures = &Failures{Findings: f, Now: h.Now, Author: func(string, string) (string, error) { return "alice", nil }} - if _, err := h.OnStepEnded(goSeat, goSeat.Prefix+"n1", ended("a1", "lint", "failed")); err != nil { - t.Fatal(err) + for _, ev := range []StepEnded{ended("a1", "lint", "failed"), libEnded("failed")} { + if _, err := h.OnStepEnded(goSeat, goSeat.Prefix+"n1", ev); err != nil { + t.Fatal(err) + } } - newer := func(source int64, commit, ask string) string { - key := "main." + strconv.FormatInt(source, 10) - store[key] = struct { - p seat.Pipeline - rev uint64 - }{seat.Pipeline{V: 1, Pipeline: key, Branch: "main", Source: source, - Outcome: seat.PipelineOutcomeRunning, Steps: []seat.StepResult{{Module: "app", Artifact: "program", Step: seat.StepResultStepLint, - Status: seat.StepResultStatusRequired, Outcome: seat.StepResultOutcomeRunning, Ask: ask, Seat: nodebuildgo.Seat}}, Movers: []seat.Mover{{Module: "app", Commit: commit, Fingerprint: "src2:aa"}}}, 1} - return key + if _, ok := f.held["delivery.app.main.pipeline-failed"]; !ok || len(f.held) != 2 { + t.Fatalf("findings %v, want one for app and one for lib", f.held) } - // A newer head that fails the step too is a finding of its own, and the older one stays. - key := newer(6, "c2", "b1") - ev := ended("b1", "lint", "failed") - ev.Pipeline, ev.Commit = key, "c2" + if lib := f.held["delivery.lib.main.pipeline-failed"]; !strings.Contains(lib.Explanation, pkey) || !strings.Contains(lib.Summary, "unit") { + t.Errorf("lib's finding %+v, want the pipeline and the step named", lib) + } + // A later pipeline moving lib alone passes: lib's finding clears, app's stands. + store["main.6"] = struct { + p seat.Pipeline + rev uint64 + }{seat.Pipeline{V: 1, Pipeline: "main.6", Branch: "main", Source: 6, Outcome: seat.PipelineOutcomeRunning, + Steps: []seat.StepResult{{Module: "lib", Artifact: "lib:lib", Step: seat.StepResultStepUnit, Status: seat.StepResultStatusRequired, + Outcome: seat.StepResultOutcomeRunning, Ask: "b2", Seat: nodebuildgo.Seat}}, Movers: []seat.Mover{{Module: "lib", Commit: "c4", Fingerprint: "src2:dd"}}}, 1} + ev := libEnded("passed") + ev.ID, ev.Ask, ev.Pipeline, ev.Commit, ev.Fingerprint = "b2", "b2", "main.6", "c4", "src2:dd" if _, err := h.OnStepEnded(goSeat, goSeat.Prefix+"n1", ev); err != nil { t.Fatal(err) } - if _, ok := f.held["merge.c1.pipeline-failed"]; !ok || len(f.held) != 2 { - t.Fatalf("findings %v, want c1 and c2", f.held) - } - // A newest head passing it clears both older commits' findings. - key = newer(7, "c3", "b2") - ev = ended("b2", "lint", "passed") - ev.Pipeline, ev.Commit = key, "c3" - if _, err := h.OnStepEnded(goSeat, goSeat.Prefix+"n1", ev); err != nil { - t.Fatal(err) - } - if len(f.held) != 0 { - t.Fatalf("findings %v stand after a newer revision passed the step", f.held) + if _, stands := f.held["delivery.app.main.pipeline-failed"]; !stands || len(f.held) != 1 { + t.Fatalf("findings %v, want app's alone after lib's pipeline passed", f.held) } } diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/steps.go b/modules/mesh-delivery-pipeline/internal/pipeline/steps.go index e062353a..58be04e4 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/steps.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/steps.go @@ -412,6 +412,7 @@ func (h *Hearer) said(p seat.Pipeline, asked []int, ended bool) error { } } if ended { + h.Failures.Ended(p) if err := h.say(seat.EventPipelineEnded, p, nil); err != nil { return fmt.Errorf("pipeline %s ended but %s is not said: %w", p.Pipeline, seat.EventPipelineEnded, err) }