From 577ec052055fa4bf3f9b1ec21405b95278610ed1 Mon Sep 17 00:00:00 2001 From: jochen Date: Fri, 20 Nov 2026 17:29:44 +0100 Subject: [PATCH 1/4] Design 47 H1: the runner says a mover waits on its registration when placed from the half or the queue (A-327) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A pipeline placed at its turn in the queue, or once its branch's half was held, dropped its movers with no registration without a word: main.20 and main.22 sat running with every step ended and nothing said why (their mover mesh-delivery-contracts has no registration, so it is never placed and the pipeline never ends). Builds: design 47 G A-327, design 47 H §746 --- .../internal/pipeline/start.go | 7 ++++++- .../internal/pipeline/start_test.go | 19 +++++++++++++++++++ 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/start.go b/modules/mesh-delivery-pipeline/internal/pipeline/start.go index b85ca084..d9ae597d 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/start.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/start.go @@ -610,7 +610,12 @@ func (s *Starter) placeWaiting(store Updater, due func(seat.Pipeline) bool, reg continue } before := len(p.Steps) - asks, _, ended, notAsked := s.placeMovers(&p, reg, half.Entries, now) + asks, unregistered, ended, notAsked := s.placeMovers(&p, reg, half.Entries, now) + // Until its registration arrives, the pipeline says it waits on it (A-327): a mover with no registration has no step, + // and the pipeline does not end before it is placed. + for _, m := range unregistered { + s.logf("%s: %s has no registration yet: its steps wait on its registration, which places them (A-327)", key, m) + } if len(p.Steps) == before { continue } diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/start_test.go b/modules/mesh-delivery-pipeline/internal/pipeline/start_test.go index edb8d2fa..019127c7 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/start_test.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/start_test.go @@ -3,6 +3,8 @@ package pipeline import ( "encoding/json" "errors" + "fmt" + "slices" "strings" "testing" @@ -280,6 +282,23 @@ func TestAPipelineStartedBeforeItsRegistrationIsPlacedWhenItArrives(t *testing.T if n != 1 || err != nil || len(p.Steps) == 0 || len(asks.asks) == before { t.Errorf("the pipeline a runner before this one set aside: placed %d (%v), %d steps, %d asks more, want it started as a newly started one", n, err, len(p.Steps), len(asks.asks)-before) } + + // A-327: a mover with no registration, in a pipeline placed from the half held later (the queue's turn, the half held), + // is said to wait on its registration, so the pipeline that cannot end before it is placed says why. + var logged []string + s.Logf = func(f string, a ...any) { logged = append(logged, fmt.Sprintf(f, a...)) } + held = false + taken = catalog.TakeInTaken{Branch: "next", Source: 8, Entries: []catalog.TakeInEntry{{Module: "app", Commit: "c4", Fingerprint: "src2:dd"}, {Module: "contracts", Commit: "c4", Fingerprint: "src2:ee"}}} + if n, err := s.TakenIn(taken, late); n != 1 || err != nil { + t.Fatalf("the take-in of two movers started %d (%v)", n, err) + } + held, logged = true, nil + if n, err := s.Waiting(store.memStore, "next", late); n != 1 || err != nil { + t.Fatalf("the half of next placed %d (%v), want next.8's registered mover", n, err) + } + if !slices.ContainsFunc(logged, func(l string) bool { return strings.Contains(l, "next.8: contracts has no registration yet") }) { + t.Errorf("placing next.8 said %q, want that contracts waits on its registration (A-327)", logged) + } } // R1/AC1 (design 47 H §747): a start names an event, never a sweep. A take-in starts the pipelines of its own entries -- 2.54.0 From 39a2c6a944390aa61f81a010545e638a094a40bf Mon Sep 17 00:00:00 2001 From: jochen Date: Fri, 20 Nov 2026 17:31:43 +0100 Subject: [PATCH 2/4] Design 47 H1: a pipeline ends failed once it can no longer pass, a mover waiting on its registration named (H-A-163) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit main.20 and main.22 never ended: a mover with no step placed (no registration) held the end even after a placed mover's required step failed and nothing was open. It now holds the end only while the pipeline could still pass. Builds: design 47 H §746, H-A-163, G A-327 --- .../internal/pipeline/steps.go | 15 +++++++- .../internal/pipeline/steps_test.go | 38 ++++++++++++++----- 2 files changed, 41 insertions(+), 12 deletions(-) diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/steps.go b/modules/mesh-delivery-pipeline/internal/pipeline/steps.go index 2564be2d..2d4e5c4f 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/steps.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/steps.go @@ -568,16 +568,21 @@ func stepPassed(s seat.StepResult) bool { // endPipeline ends a pipeline whose every mover is placed and every step ended: passed when every mover's required steps // passed, were carried or had nothing to run, else failed, naming each required step that held it (ADR 0666 §7, §9; -// design 47 H §746). A failed optional step, and an optional step still waiting, hold nothing. An approval step still +// design 47 H §746). A mover with no step placed, waiting on its registration (A-327), holds the end only while the +// pipeline could still pass: once a placed mover's required step did not pass and none is open, it ends failed, naming that +// mover (H-A-163). A failed optional step, and an optional step still waiting, hold nothing. An approval step still // waiting when a required step did not pass is `not asked` (§26). It says whether the pipeline ended now, its end count one // higher. func endPipeline(p *seat.Pipeline, now time.Time) bool { if p.Outcome != seat.PipelineOutcomeRunning { return false } + // A mover with no step placed waits on its registration (A-327): it holds the end only while every placed mover's + // required steps passed, since once one failed or could not run the pipeline can no longer pass (H-A-163). + var unplaced []string for _, m := range p.Movers { if !placed(*p, m.Module) { - return false + unplaced = append(unplaced, m.Module) } } var held []string @@ -598,6 +603,9 @@ func endPipeline(p *seat.Pipeline, now time.Time) bool { held = append(held, strings.TrimSpace(s.Module+" "+s.Artifact+" "+s.Step)+" "+s.Outcome) } } + if len(unplaced) > 0 && len(held) == 0 { + return false + } if len(notAsked) > 0 { if len(held) == 0 { return false @@ -611,6 +619,9 @@ func endPipeline(p *seat.Pipeline, now time.Time) bool { p.Outcome, p.Why = seat.PipelineOutcomePassed, "" if len(held) > 0 { p.Outcome, p.Why = seat.PipelineOutcomeFailed, "required steps not passed: "+strings.Join(held, ", ") + for _, m := range unplaced { + p.Why += "; " + m + " has no registration" + } } for i := range p.Movers { m := &p.Movers[i] diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/steps_test.go b/modules/mesh-delivery-pipeline/internal/pipeline/steps_test.go index caa04a5e..1ff1de19 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/steps_test.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/steps_test.go @@ -291,23 +291,41 @@ func TestApprovalEnds(t *testing.T) { } // An optional step still waiting (a code review nobody has given) does not hold a pipeline's end; a required one does -// (design 47 G A-104). +// (design 47 G A-104). A mover with no step placed, waiting on its registration (A-327), holds the end while every placed +// mover's required steps passed or one is open, and once a placed one did not pass the pipeline ends failed, naming it +// (H-A-163). func TestAnOptionalStepStillWaitingHoldsNoEnd(t *testing.T) { now := time.Date(2026, 11, 11, 12, 0, 0, 0, time.UTC) for name, c := range map[string]struct { - review string - ends bool - }{"optional review waiting": {seat.StepResultStatusOptional, true}, "required review waiting": {seat.StepResultStatusRequired, false}} { - p := seat.Pipeline{Outcome: seat.PipelineOutcomeRunning, Steps: []seat.StepResult{ - {Step: seat.StepResultStepBuild, Status: seat.StepResultStatusRequired, Outcome: seat.StepResultOutcomePassed}, - {Step: seat.StepResultStepReview, Status: c.review, Outcome: seat.StepResultOutcomeWaiting}, - {Step: seat.StepResultStepApproval, Status: seat.StepResultStatusRequired, Outcome: seat.StepResultOutcomePassed}, + review, build, unit string + unregistered bool + ends bool + outcome string + }{ + "optional review waiting": {seat.StepResultStatusOptional, seat.StepResultOutcomePassed, seat.StepResultOutcomePassed, false, true, seat.PipelineOutcomePassed}, + "required review waiting": {seat.StepResultStatusRequired, seat.StepResultOutcomePassed, seat.StepResultOutcomePassed, false, false, ""}, + "unregistered mover, the placed one passed": {seat.StepResultStatusOptional, seat.StepResultOutcomePassed, seat.StepResultOutcomePassed, true, false, ""}, + "unregistered mover, the placed one failed": {seat.StepResultStatusOptional, seat.StepResultOutcomeFailed, seat.StepResultOutcomePassed, true, true, seat.PipelineOutcomeFailed}, + "unregistered mover, failed and a step open": {seat.StepResultStatusOptional, seat.StepResultOutcomeFailed, seat.StepResultOutcomeRunning, true, false, ""}, + "unregistered mover, the placed one could not run": {seat.StepResultStatusOptional, seat.StepResultOutcomePassed, seat.StepResultOutcomeCouldNotRun, true, true, seat.PipelineOutcomeFailed}, + } { + p := seat.Pipeline{Outcome: seat.PipelineOutcomeRunning, Movers: []seat.Mover{{Module: "app"}}, Steps: []seat.StepResult{ + {Step: seat.StepResultStepBuild, Module: "app", Status: seat.StepResultStatusRequired, Outcome: c.build}, + {Step: seat.StepResultStepUnit, Module: "app", Status: seat.StepResultStatusRequired, Outcome: c.unit}, + {Step: seat.StepResultStepReview, Module: "app", Status: c.review, Outcome: seat.StepResultOutcomeWaiting}, + {Step: seat.StepResultStepApproval, Module: "app", Status: seat.StepResultStatusRequired, Outcome: seat.StepResultOutcomePassed}, }} + if c.unregistered { + p.Movers = append(p.Movers, seat.Mover{Module: "contracts"}) + } if got := endPipeline(&p, now); got != c.ends { t.Errorf("%s: ended = %v, want %v", name, got, c.ends) } - if c.ends && p.Outcome != seat.PipelineOutcomePassed { - t.Errorf("%s: outcome %s", name, p.Outcome) + if c.ends && p.Outcome != c.outcome { + t.Errorf("%s: outcome %s, want %s", name, p.Outcome, c.outcome) + } + if c.ends && c.unregistered && !strings.Contains(p.Why, "contracts has no registration") { + t.Errorf("%s: why %q, want it to name the mover waiting on its registration", name, p.Why) } } } -- 2.54.0 From 521cbf089ea5ab68c8e621b90641d4f468582a85 Mon Sep 17 00:00:00 2001 From: jochen Date: Fri, 20 Nov 2026 17:35:19 +0100 Subject: [PATCH 3/4] Design 47 H1: the seat mesh-pipeline-runner gains end-again, a hand act judging a pipeline's end once more (H-A-164) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A pipeline the end judgement before H-A-163 left running had no way to end but a cancel. The runner's process answers end-again, so the end takes its turn in the queue; runner_end_again asks it. The seat's definition changes: its Go and TypeScript contracts are generated again. Builds: design 47 H §746, H-A-163, H-A-164 --- .../go/seats/meshpipelinerunner/contract.go | 16 ++++++++- .../seats/meshpipelinerunner/contract_test.go | 2 ++ .../mesh-pipeline-runner/fixtures/verbs.json | 8 +++++ .../seats/mesh-pipeline-runner/seat.json | 33 +++++++++++++++++++ .../ts/seats/meshpipelinerunner/index.d.ts | 14 ++++++++ .../ts/seats/meshpipelinerunner/index.js | 1 + .../mesh-delivery-pipeline-tools/main_test.go | 2 +- .../mesh-delivery-pipeline-tools/verbtools.go | 9 +++++ .../verbtools_test.go | 4 +++ .../cmd/mesh-delivery-pipeline/verbs.go | 3 +- .../cmd/mesh-delivery-pipeline/verbs_test.go | 2 +- .../internal/pipeline/verbs.go | 18 ++++++++++ .../internal/pipeline/verbs_test.go | 22 +++++++++++++ .../mesh-delivery-pipeline/manifest_test.go | 2 +- modules/mesh-delivery-pipeline/module.json | 2 ++ 15 files changed, 133 insertions(+), 5 deletions(-) diff --git a/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner/contract.go b/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner/contract.go index 926bf85e..ce60aa65 100644 --- a/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner/contract.go +++ b/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner/contract.go @@ -26,6 +26,7 @@ const ( VerbRerun = "rerun" VerbAccept = "accept" VerbCancel = "cancel" + VerbEndAgain = "end-again" VerbPlace = "place" VerbAskAgain = "ask-again" VerbTestRuns = "test-runs" @@ -47,7 +48,7 @@ const ( // Verbs is every verb the seat serves, in its definition's order: a new copy each call. func Verbs() []string { - return []string{VerbRun, VerbStart, VerbShow, VerbList, VerbStands, VerbWhyCarried, VerbKept, VerbReview, VerbRerun, VerbAccept, VerbCancel, VerbPlace, VerbAskAgain, VerbTestRuns, VerbTestRunsDrop} + return []string{VerbRun, VerbStart, VerbShow, VerbList, VerbStands, VerbWhyCarried, VerbKept, VerbReview, VerbRerun, VerbAccept, VerbCancel, VerbEndAgain, VerbPlace, VerbAskAgain, VerbTestRuns, VerbTestRunsDrop} } // Events is every event published on the seat's subject: a new copy each call. @@ -1195,6 +1196,19 @@ type CancelAnswer struct { Pipeline Pipeline `json:"pipeline"` } +// EndAgainInput is what end-again takes. +type EndAgainInput struct { + // the pipeline's key + Pipeline string `json:"pipeline"` + // why, written with the caller the runtime proves in the hand-act log + Why string `json:"why"` +} + +// EndAgainAnswer is what end-again answers. +type EndAgainAnswer struct { + Pipeline Pipeline `json:"pipeline"` +} + // PlaceInput is what place takes. type PlaceInput struct { // the pipeline's key diff --git a/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner/contract_test.go b/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner/contract_test.go index bc6af73a..23b59e9c 100644 --- a/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner/contract_test.go +++ b/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner/contract_test.go @@ -119,6 +119,8 @@ func TestFixtures(t *testing.T) { decode: func(b []byte) (any, error) { var v TestRunsDropAnswer; err := json.Unmarshal(b, &v); return v, err }, subjectIs: nil}, {name: "place asks a waiting pipeline ahead of its turn, with why", subject: "", given: "{\"pipeline\":\"main.3590\",\"why\":\"the operator wants the fix out first\"}", wire: "{\"pipeline\":\"main.3590\",\"why\":\"the operator wants the fix out first\"}", decode: func(b []byte) (any, error) { var v PlaceInput; err := json.Unmarshal(b, &v); return v, err }, subjectIs: nil}, + {name: "end-again asks a running pipeline's end judged once more, with why", subject: "", given: "{\"pipeline\":\"main.20\",\"why\":\"a mover waits on its registration and another failed\"}", wire: "{\"pipeline\":\"main.20\",\"why\":\"a mover waits on its registration and another failed\"}", + decode: func(b []byte) (any, error) { var v EndAgainInput; err := json.Unmarshal(b, &v); return v, err }, subjectIs: nil}, } for _, c := range cases { v, err := c.decode([]byte(c.given)) diff --git a/modules/mesh-delivery-contracts/seats/mesh-pipeline-runner/fixtures/verbs.json b/modules/mesh-delivery-contracts/seats/mesh-pipeline-runner/fixtures/verbs.json index a056bb02..f966db09 100644 --- a/modules/mesh-delivery-contracts/seats/mesh-pipeline-runner/fixtures/verbs.json +++ b/modules/mesh-delivery-contracts/seats/mesh-pipeline-runner/fixtures/verbs.json @@ -336,5 +336,13 @@ "pipeline": "main.3590", "why": "the operator wants the fix out first" } + }, + { + "name": "end-again asks a running pipeline's end judged once more, with why", + "of": "verb:end-again.input", + "given": { + "pipeline": "main.20", + "why": "a mover waits on its registration and another failed" + } } ] diff --git a/modules/mesh-delivery-contracts/seats/mesh-pipeline-runner/seat.json b/modules/mesh-delivery-contracts/seats/mesh-pipeline-runner/seat.json index 1e35b5a9..7a5c3607 100644 --- a/modules/mesh-delivery-contracts/seats/mesh-pipeline-runner/seat.json +++ b/modules/mesh-delivery-contracts/seats/mesh-pipeline-runner/seat.json @@ -474,6 +474,39 @@ }, "class": "act" }, + { + "name": "end-again", + "description": "A running pipeline's end judged once more, as at a step's end: it ends when it can, failed as soon as it can no longer pass (design 47 H §746, H-A-163, H-A-164). Written in the hand-act log.", + "input": { + "type": "object", + "properties": { + "pipeline": { + "type": "string", + "description": "the pipeline's key" + }, + "why": { + "type": "string", + "description": "why, written with the caller the runtime proves in the hand-act log" + } + }, + "required": [ + "pipeline", + "why" + ] + }, + "answer": { + "type": "object", + "properties": { + "pipeline": { + "$ref": "#/defs/Pipeline" + } + }, + "required": [ + "pipeline" + ] + }, + "class": "act" + }, { "name": "place", "description": "A waiting pipeline placed ahead of its turn, its steps asked now; written in the hand-act log (design 47 H §748, H-A-53).", diff --git a/modules/mesh-delivery-contracts/ts/seats/meshpipelinerunner/index.d.ts b/modules/mesh-delivery-contracts/ts/seats/meshpipelinerunner/index.d.ts index 03e13f17..4fb293a0 100644 --- a/modules/mesh-delivery-contracts/ts/seats/meshpipelinerunner/index.d.ts +++ b/modules/mesh-delivery-contracts/ts/seats/meshpipelinerunner/index.d.ts @@ -16,6 +16,7 @@ export declare const verbs: { readonly rerun: "rerun"; readonly accept: "accept"; readonly cancel: "cancel"; + readonly endAgain: "end-again"; readonly place: "place"; readonly askAgain: "ask-again"; readonly testRuns: "test-runs"; @@ -683,6 +684,19 @@ export interface CancelAnswer { "pipeline": Pipeline; } +/** is what end-again takes. */ +export interface EndAgainInput { + /** the pipeline's key */ + "pipeline": string; + /** why, written with the caller the runtime proves in the hand-act log */ + "why": string; +} + +/** is what end-again answers. */ +export interface EndAgainAnswer { + "pipeline": Pipeline; +} + /** is what place takes. */ export interface PlaceInput { /** the pipeline's key */ diff --git a/modules/mesh-delivery-contracts/ts/seats/meshpipelinerunner/index.js b/modules/mesh-delivery-contracts/ts/seats/meshpipelinerunner/index.js index 721b6839..32282d84 100644 --- a/modules/mesh-delivery-contracts/ts/seats/meshpipelinerunner/index.js +++ b/modules/mesh-delivery-contracts/ts/seats/meshpipelinerunner/index.js @@ -16,6 +16,7 @@ export const verbs = { rerun: "rerun", accept: "accept", cancel: "cancel", + endAgain: "end-again", place: "place", askAgain: "ask-again", testRuns: "test-runs", diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main_test.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main_test.go index 2d942ecb..95bb4bda 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main_test.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/main_test.go @@ -42,7 +42,7 @@ func TestTools(t *testing.T) { for _, tl := range UnloggedTools(stdio.State("pipelines"), stdio.Log("step-log"), nil, nil) { names = append(names, tl.Name) } - want := "mesh-pipeline-runner.show mesh-pipeline-runner.list mesh-pipeline-runner.stands mesh-pipeline-runner.why-carried mesh-pipeline-runner.kept runner_first_views runner_first_view_again runner_cancel runner_rerun runner_start runner_run runner_accept runner_place runner_ask_again runner_health runner_waiting runner_unlogged runner_unlogged_append" + want := "mesh-pipeline-runner.show mesh-pipeline-runner.list mesh-pipeline-runner.stands mesh-pipeline-runner.why-carried mesh-pipeline-runner.kept runner_first_views runner_first_view_again runner_cancel runner_rerun runner_start runner_run runner_accept runner_place runner_end_again runner_ask_again runner_health runner_waiting runner_unlogged runner_unlogged_append" if got := strings.Join(names, " "); got != want { t.Errorf("tools %q, want %q", got, want) } diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/verbtools.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/verbtools.go index e3711cc4..7b887bf6 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/verbtools.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/verbtools.go @@ -54,6 +54,15 @@ func VerbTools(ask func(key string, body any) (json.RawMessage, error)) []stdio. } return whyOf(in.Why) }), + verbTool[seat.EndAgainInput](ask, "end_again", seat.VerbEndAgain, + "Judge a running pipeline's end once more by the seat verb end-again (design 47 H H-A-163, H-A-164): it ends as at a step's end, failed as soon as it can no longer pass (a mover with no registration named), and says pipeline-ended; one that still cannot end is answered running. The pipeline's key and why; written in the hand-act log. A pipeline not running is refused by the verb.", + obj([]string{"pipeline", "why"}, map[string]any{"pipeline": str, "why": str}), + func(in seat.EndAgainInput) string { + if in.Pipeline == "" { + return "end-again names the pipeline" + } + return whyOf(in.Why) + }), verbTool[seat.AskAgainInput](ask, "ask_again", seat.VerbAskAgain, "Ask a declined approval step of a pipeline once more by the seat verb ask-again: the pipeline's key, the mover's module (needed when the pipeline moves several) and why.", obj([]string{"pipeline", "why"}, map[string]any{"pipeline": str, "module": str, "why": str}), diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/verbtools_test.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/verbtools_test.go index ff163acd..40f7558e 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/verbtools_test.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline-tools/verbtools_test.go @@ -32,6 +32,10 @@ func TestVerbTools(t *testing.T) { {"place", "runner_place", "seat:mesh-pipeline-runner.place", "", map[string]any{"pipeline": "main.6", "why": "urgent"}, seat.PlaceInput{Pipeline: "main.6", Why: "urgent"}}, {"place no why", "runner_place", "", "names why", map[string]any{"pipeline": "main.6"}, nil}, + // H-A-164: runner_end_again asks the verb end-again with the pipeline and why. + {"end-again", "runner_end_again", "seat:mesh-pipeline-runner.end-again", "", map[string]any{"pipeline": "main.20", "why": "left running"}, + seat.EndAgainInput{Pipeline: "main.20", Why: "left running"}}, + {"end-again no why", "runner_end_again", "", "names why", map[string]any{"pipeline": "main.20"}, nil}, {"ask-again no why", "runner_ask_again", "", "names why", map[string]any{"pipeline": "p"}, nil}, } { t.Run(c.name, func(t *testing.T) { diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/verbs.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/verbs.go index 3d452e2b..20a754bc 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/verbs.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/verbs.go @@ -38,7 +38,7 @@ func answerVerbs(conn *process.Conn, seats *seatlist.Part, v pipeline.Verbs) (fu return conn.AnswerSeat(seat.Seat, seatlist.Definition(seats.Reader, seat.Seat), writeHandlers(v)) } -// writeHandlers are the seat's write verbs the process answers: run, review, rerun, accept, cancel, start, and ask-again; and +// writeHandlers are the seat's write verbs the process answers: run, review, rerun, accept, cancel, end-again, start, and ask-again; and // the test runs' verbs test-runs and test-runs-drop (A-469g, A-470i). func writeHandlers(v pipeline.Verbs) map[string]process.SeatHandler { return map[string]process.SeatHandler{ @@ -47,6 +47,7 @@ func writeHandlers(v pipeline.Verbs) map[string]process.SeatHandler { seat.VerbRerun: verbOf(func(c string, in seat.RerunInput) (any, error) { return v.Rerun(c, in) }), seat.VerbAccept: verbOf(func(c string, in seat.AcceptInput) (any, error) { return v.Accept(c, in) }), seat.VerbCancel: verbOf(func(c string, in seat.CancelInput) (any, error) { return v.Cancel(c, in) }), + seat.VerbEndAgain: verbOf(func(c string, in seat.EndAgainInput) (any, error) { return v.EndAgain(c, in) }), seat.VerbPlace: verbOf(func(c string, in seat.PlaceInput) (any, error) { return v.Place(c, in) }), seat.VerbStart: verbOf(func(c string, in seat.StartInput) (any, error) { return v.Start(c, in) }), seat.VerbAskAgain: verbOf(func(c string, in seat.AskAgainInput) (any, error) { return v.AskAgain(c, in) }), diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/verbs_test.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/verbs_test.go index e9e203fe..d5745ddc 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/verbs_test.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/verbs_test.go @@ -23,7 +23,7 @@ func TestEveryWriteVerbIsServed(t *testing.T) { got = append(got, v) } slices.Sort(got) - want := []string{seat.VerbAccept, seat.VerbAskAgain, seat.VerbCancel, seat.VerbPlace, seat.VerbRerun, seat.VerbReview, seat.VerbStart, seat.VerbRun, seat.VerbTestRuns, seat.VerbTestRunsDrop} + want := []string{seat.VerbAccept, seat.VerbAskAgain, seat.VerbCancel, seat.VerbEndAgain, seat.VerbPlace, seat.VerbRerun, seat.VerbReview, seat.VerbStart, seat.VerbRun, seat.VerbTestRuns, seat.VerbTestRunsDrop} slices.Sort(want) if !slices.Equal(got, want) { t.Errorf("the process answers %v, want %v", got, want) diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/verbs.go b/modules/mesh-delivery-pipeline/internal/pipeline/verbs.go index d7aed473..5264f76e 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/verbs.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/verbs.go @@ -244,6 +244,24 @@ func (v Verbs) Cancel(caller string, in seat.CancelInput) (seat.CancelAnswer, er } } +// EndAgain judges a running pipeline's end once more by hand, recorded in the hand-act log first (design 47 H §746, +// H-A-163, H-A-164): it ends as at a step's end, failed as soon as it can no longer pass, and says it, taking its turn in +// the queue; one that still cannot end is answered running. A pipeline not running is refused. +func (v Verbs) EndAgain(_ string, in seat.EndAgainInput) (seat.EndAgainAnswer, error) { + p, _, err := v.change(in.Pipeline, seat.EventStepEnded, func() error { + return v.record(seat.VerbEndAgain, "judged the end of the pipeline "+in.Pipeline+" again", in.Why) + }, func(p *seat.Pipeline, _ time.Time) (int, error) { + if p.Outcome != seat.PipelineOutcomeRunning { + return -1, fmt.Errorf("the pipeline %s is %s, not running", in.Pipeline, p.Outcome) + } + return -1, nil + }) + if err != nil { + return seat.EndAgainAnswer{}, err + } + return seat.EndAgainAnswer{Pipeline: p}, nil +} + // Rerun asks one step again, recorded in the hand-act log first (§22, §39): the step goes back to running under a new ask, // the ask saying it is a rerun and the caller the bus proved; a failed pipeline runs again and ends once more with its end // count one higher (§325), an approval never asked waiting again. A review waits again; an approval is asked again by diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/verbs_test.go b/modules/mesh-delivery-pipeline/internal/pipeline/verbs_test.go index 93db1039..ed3867e0 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/verbs_test.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/verbs_test.go @@ -156,6 +156,28 @@ func TestAcceptRerunAndCancelWriteByCompareAndSetAndRecordTheirHandAct(t *testin t.Errorf("%d hand acts recorded, want accept, rerun, cancel (3): %v", n, *acts) } + // H-A-163, H-A-164: end-again judges a running pipeline's end once more, a hand act; a pipeline the judgement before + // left running (a mover waiting on its registration, a placed one failed, nothing open) ends failed naming that mover. + if _, err := v.EndAgain("operator", seat.EndAgainInput{Pipeline: pkey, Why: "again"}); err == nil || len(*acts) != 3 { + t.Errorf("end-again of a cancelled pipeline = %v, %d hand acts, want refused and none recorded", err, len(*acts)) + } + store["main.20"] = struct { + p seat.Pipeline + rev uint64 + }{seat.Pipeline{Pipeline: "main.20", Branch: "main", Source: 20, Outcome: seat.PipelineOutcomeRunning, + Movers: []seat.Mover{{Module: "app"}, {Module: "contracts"}}, Steps: []seat.StepResult{ + {Step: seat.StepResultStepBuild, Module: "app", Status: seat.StepResultStatusRequired, Outcome: seat.StepResultOutcomeFailed}}}, 1} + if _, err := v.EndAgain("operator", seat.EndAgainInput{Pipeline: "main.20"}); err == nil { + t.Error("an end-again with no why was taken") + } + e, err := v.EndAgain("operator", seat.EndAgainInput{Pipeline: "main.20", Why: "left running by the judgement before H-A-163"}) + if err != nil || e.Pipeline.Outcome != seat.PipelineOutcomeFailed || e.Pipeline.EndCount != 1 || !strings.Contains(e.Pipeline.Why, "contracts has no registration") { + t.Fatalf("end-again = %+v, %v, want main.20 ended failed naming contracts", e.Pipeline, err) + } + if last := (*said)[len(*said)-1]; !strings.HasPrefix(last, "pipeline-ended.") || len(*acts) != 4 || !strings.Contains((*acts)[3], "mesh-pipeline-runner.end-again") { + t.Errorf("end-again said %q and recorded %v, want pipeline-ended and its hand act", last, *acts) + } + // H-A-101 (1): on a pipeline of two movers a verb names the mover's module; one naming none, or a module the pipeline // does not move, is refused, and the module named picks that mover's step. two, store2, _, _, _, _ := verbsFixture() diff --git a/modules/mesh-delivery-pipeline/manifest_test.go b/modules/mesh-delivery-pipeline/manifest_test.go index ef484842..e500b0a8 100644 --- a/modules/mesh-delivery-pipeline/manifest_test.go +++ b/modules/mesh-delivery-pipeline/manifest_test.go @@ -114,7 +114,7 @@ func TestManifest(t *testing.T) { {"uses operator-channel", equalSets(m.Uses, []string{"operator-channel"})}, // RN25 (§539): the runner's tools carry the prefix runner_. {"first-view tools", equalSets(m.Tools, []string{"runner_first_views", "runner_first_view_again", "runner_health", "runner_unlogged", "runner_unlogged_append", - "runner_start", "runner_run", "runner_accept", "runner_ask_again", "runner_place", "runner_waiting", + "runner_start", "runner_run", "runner_accept", "runner_ask_again", "runner_place", "runner_end_again", "runner_waiting", "runner_test_runs", "runner_test_runs_drop"})}, // A-305 (ADR 0227 rule 8, ADR 0240 rule 2): the process is judged by its unit, as every process of mesh-delivery, // never by a tool of its own; runner_health stays a tool. diff --git a/modules/mesh-delivery-pipeline/module.json b/modules/mesh-delivery-pipeline/module.json index 7087669a..671a0b97 100644 --- a/modules/mesh-delivery-pipeline/module.json +++ b/modules/mesh-delivery-pipeline/module.json @@ -18,6 +18,7 @@ "rerun", "accept", "cancel", + "end-again", "place", "ask-again", "test-runs", @@ -36,6 +37,7 @@ "runner_accept", "runner_ask_again", "runner_place", + "runner_end_again", "runner_waiting", "runner_test_runs", "runner_test_runs_drop" -- 2.54.0 From 07dd8ea8425cafe853883204243c30f43ffe1a5f Mon Sep 17 00:00:00 2001 From: jochen Date: Fri, 20 Nov 2026 17:48:10 +0100 Subject: [PATCH 4/4] Design 47 H1: the end names why each mover has no step, its registration or a publish (H-A-171) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The end judgement took every mover with no step as waiting on its registration; one may wait for the publish of a mover it builds on. The registration lookup tells them apart, and the why names each with its own reason. Builds: design 47 H §746, H-A-163, H-A-171, G A-327 --- .../cmd/mesh-delivery-pipeline/main.go | 1 + .../internal/pipeline/runends.go | 2 +- .../internal/pipeline/start.go | 24 ++++++++- .../internal/pipeline/steps.go | 36 ++++++++------ .../internal/pipeline/steps_test.go | 49 +++++++++++++------ .../internal/pipeline/verbs_test.go | 2 + 6 files changed, 82 insertions(+), 32 deletions(-) diff --git a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/main.go b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/main.go index 10d9e64c..4a8e3877 100644 --- a/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/main.go +++ b/modules/mesh-delivery-pipeline/cmd/mesh-delivery-pipeline/main.go @@ -152,6 +152,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro Kept: keptReader(ctx, kept), Toolchain: toolchainReader(ctx, toolchains), Fills: fills, Recovered: kvRecoveries{ctx, recovered}.Has, Holders: rv.Holders.Holders, Ended: hearer.EndedAtPlacing} hearer.AskSteps = starter.AskSteps + hearer.Unplaced = func(p seat.Pipeline, module string) string { return starter.Unplaced(p, module, rv.Catalog.View) } hearer.Release = func(key string) { if _, err := starter.Release(hearer.Store, key, rv.Catalog.View); err != nil { logger.Printf("the movers of %s waiting for a build are not placed: %v", key, err) diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/runends.go b/modules/mesh-delivery-pipeline/internal/pipeline/runends.go index 3a8ae279..c54faba5 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/runends.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/runends.go @@ -366,7 +366,7 @@ func (h *Hearer) endReader(reader RunReader, run string, r Run) error { if err != nil { return err } - ended := endPipeline(&p, now) + ended := endPipeline(&p, now, h.Unplaced) if _, err := h.Store.Update(reader.Pipeline, p, rev); errors.Is(err, ErrChanged) { continue } else if err != nil { diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/start.go b/modules/mesh-delivery-pipeline/internal/pipeline/start.go index d9ae597d..27174963 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/start.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/start.go @@ -541,6 +541,28 @@ func (s *Starter) Resume(store Updater, branch string, half Half) (int, error) { return asked, first } +// Unplaced says why mover module of p has no step placed (H-A-171): " has no registration" when the registrations +// do not name it (A-327), else " waits on the publish of , …", the packages it awaits not yet published +// as the catalog half of p's branch holds its edges (§746). +func (s *Starter) Unplaced(p seat.Pipeline, module string, view func(branch string) (Half, bool)) string { + if s.Registration == nil { + return module + " has no registration" + } + if _, ok := s.Registration(module); !ok { + return module + " has no registration" + } + var waiting []string + if view != nil { + if half, ok := view(p.Branch); ok { + _, waiting, _ = ready(p, module, half.Entries) + } + } + if len(waiting) == 0 { + return module + " waits on the publish of the movers it builds on" + } + return module + " waits on the publish of " + strings.Join(waiting, ", ") +} + // Registered places, on a registration-changed of reg's module, the steps of that module's mover in every running pipeline // that moves it with none placed, from the registration (design 47 G §21, §23, A-327): a pipeline started before its module // had a registration. Each is written by compare-and-set, so it is placed once, its steps asked, and said; a run on request @@ -612,7 +634,7 @@ func (s *Starter) placeWaiting(store Updater, due func(seat.Pipeline) bool, reg before := len(p.Steps) asks, unregistered, ended, notAsked := s.placeMovers(&p, reg, half.Entries, now) // Until its registration arrives, the pipeline says it waits on it (A-327): a mover with no registration has no step, - // and the pipeline does not end before it is placed. + // and it holds the pipeline's end only while every placed mover's required steps passed (H-A-163, H-A-171). for _, m := range unregistered { s.logf("%s: %s has no registration yet: its steps wait on its registration, which places them (A-327)", key, m) } diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/steps.go b/modules/mesh-delivery-pipeline/internal/pipeline/steps.go index 2d4e5c4f..ecb6ccdc 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/steps.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/steps.go @@ -158,6 +158,9 @@ type Hearer struct { // Turn takes a pipeline's end into the queue, its running key deleted and the next placed (design 47 H §748; // Starter.Turn); nil takes none. Turn func(key string) + // Unplaced says why a mover of a pipeline has no step placed, for the why of its end (H-A-171; Starter.Unplaced): it + // waits on its registration or on a publish; nil says only that it has no step placed. + Unplaced func(p seat.Pipeline, module string) string // Rejoin keys a pipeline running again once its approval is answered and it still runs (H-A-106 (b); Starter.Rejoin); // nil keys none. Rejoin func(key string) @@ -568,21 +571,22 @@ func stepPassed(s seat.StepResult) bool { // endPipeline ends a pipeline whose every mover is placed and every step ended: passed when every mover's required steps // passed, were carried or had nothing to run, else failed, naming each required step that held it (ADR 0666 §7, §9; -// design 47 H §746). A mover with no step placed, waiting on its registration (A-327), holds the end only while the -// pipeline could still pass: once a placed mover's required step did not pass and none is open, it ends failed, naming that -// mover (H-A-163). A failed optional step, and an optional step still waiting, hold nothing. An approval step still -// waiting when a required step did not pass is `not asked` (§26). It says whether the pipeline ended now, its end count one -// higher. -func endPipeline(p *seat.Pipeline, now time.Time) bool { +// design 47 H §746). A mover with no step placed, waiting on its registration (A-327) or on the publish of a mover it +// builds on (§746), holds the end only while the pipeline could still pass: once a placed mover's required step did not +// pass and none is open, it ends failed, the why naming each unplaced mover with the reason unplaced gives (H-A-163, +// H-A-171; nil says only that it has no step placed). A failed optional step, and an optional step still waiting, hold +// nothing. An approval step still waiting when a required step did not pass is `not asked` (§26). It says whether the +// pipeline ended now, its end count one higher. +func endPipeline(p *seat.Pipeline, now time.Time, unplaced func(seat.Pipeline, string) string) bool { if p.Outcome != seat.PipelineOutcomeRunning { return false } - // A mover with no step placed waits on its registration (A-327): it holds the end only while every placed mover's - // required steps passed, since once one failed or could not run the pipeline can no longer pass (H-A-163). - var unplaced []string + // A mover with no step placed waits on its registration or a publish: it holds the end only while every placed mover's + // required steps passed, since once one failed or could not run the pipeline can no longer pass (H-A-163, H-A-171). + var waiting []string for _, m := range p.Movers { if !placed(*p, m.Module) { - unplaced = append(unplaced, m.Module) + waiting = append(waiting, m.Module) } } var held []string @@ -603,7 +607,7 @@ func endPipeline(p *seat.Pipeline, now time.Time) bool { held = append(held, strings.TrimSpace(s.Module+" "+s.Artifact+" "+s.Step)+" "+s.Outcome) } } - if len(unplaced) > 0 && len(held) == 0 { + if len(waiting) > 0 && len(held) == 0 { return false } if len(notAsked) > 0 { @@ -619,8 +623,12 @@ func endPipeline(p *seat.Pipeline, now time.Time) bool { p.Outcome, p.Why = seat.PipelineOutcomePassed, "" if len(held) > 0 { p.Outcome, p.Why = seat.PipelineOutcomeFailed, "required steps not passed: "+strings.Join(held, ", ") - for _, m := range unplaced { - p.Why += "; " + m + " has no registration" + for _, m := range waiting { + why := m + " has no step placed" + if unplaced != nil { + why = unplaced(*p, m) + } + p.Why += "; " + why } } for i := range p.Movers { @@ -633,7 +641,7 @@ func endPipeline(p *seat.Pipeline, now time.Time) bool { // endPipeline is endPipeline with each mover's widens computed into its value at the end (§71, A-207; H-A-51). func (h *Hearer) endPipeline(p *seat.Pipeline, now time.Time) bool { - if !endPipeline(p, now) { + if !endPipeline(p, now, h.Unplaced) { return false } if h.Widens != nil { diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/steps_test.go b/modules/mesh-delivery-pipeline/internal/pipeline/steps_test.go index 1ff1de19..5dc67bc0 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/steps_test.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/steps_test.go @@ -8,6 +8,7 @@ import ( "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient" oc "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel" + catalog "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner" wants "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants" nodebuildgo "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/nodebuildgo" @@ -291,41 +292,57 @@ func TestApprovalEnds(t *testing.T) { } // An optional step still waiting (a code review nobody has given) does not hold a pipeline's end; a required one does -// (design 47 G A-104). A mover with no step placed, waiting on its registration (A-327), holds the end while every placed -// mover's required steps passed or one is open, and once a placed one did not pass the pipeline ends failed, naming it -// (H-A-163). +// (design 47 G A-104). A mover with no step placed, waiting on its registration (A-327) or on the publish of a mover it +// builds on (§746), holds the end while every placed mover's required steps passed or one is open, and once a placed one +// did not pass the pipeline ends failed, naming each with its own reason (H-A-163, H-A-171). func TestAnOptionalStepStillWaitingHoldsNoEnd(t *testing.T) { now := time.Date(2026, 11, 11, 12, 0, 0, 0, time.UTC) + // lib is registered and awaits core's package, which core's passed build has not published yet; contracts has no + // registration. + starter := &Starter{Registration: func(m string) (catalog.Registration, bool) { return catalog.Registration{Module: m}, m != "contracts" }} + view := func(string) (Half, bool) { + return Half{Entries: map[string]catalog.CatalogEntry{"lib": {Edges: []catalog.Edge{{From: "core:go", To: "lib:program", Kind: 1}}}}}, true + } + unplaced := func(p seat.Pipeline, m string) string { return starter.Unplaced(p, m, view) } for name, c := range map[string]struct { review, build, unit string - unregistered bool + waiting []string ends bool outcome string + why []string }{ - "optional review waiting": {seat.StepResultStatusOptional, seat.StepResultOutcomePassed, seat.StepResultOutcomePassed, false, true, seat.PipelineOutcomePassed}, - "required review waiting": {seat.StepResultStatusRequired, seat.StepResultOutcomePassed, seat.StepResultOutcomePassed, false, false, ""}, - "unregistered mover, the placed one passed": {seat.StepResultStatusOptional, seat.StepResultOutcomePassed, seat.StepResultOutcomePassed, true, false, ""}, - "unregistered mover, the placed one failed": {seat.StepResultStatusOptional, seat.StepResultOutcomeFailed, seat.StepResultOutcomePassed, true, true, seat.PipelineOutcomeFailed}, - "unregistered mover, failed and a step open": {seat.StepResultStatusOptional, seat.StepResultOutcomeFailed, seat.StepResultOutcomeRunning, true, false, ""}, - "unregistered mover, the placed one could not run": {seat.StepResultStatusOptional, seat.StepResultOutcomePassed, seat.StepResultOutcomeCouldNotRun, true, true, seat.PipelineOutcomeFailed}, + "optional review waiting": {seat.StepResultStatusOptional, seat.StepResultOutcomePassed, seat.StepResultOutcomePassed, nil, true, seat.PipelineOutcomePassed, nil}, + "required review waiting": {seat.StepResultStatusRequired, seat.StepResultOutcomePassed, seat.StepResultOutcomePassed, nil, false, "", nil}, + "unregistered mover, the placed one passed": {seat.StepResultStatusOptional, seat.StepResultOutcomePassed, seat.StepResultOutcomePassed, []string{"contracts"}, false, "", nil}, + "unregistered mover, the placed one failed": {seat.StepResultStatusOptional, seat.StepResultOutcomeFailed, seat.StepResultOutcomePassed, []string{"contracts"}, true, seat.PipelineOutcomeFailed, []string{"contracts has no registration"}}, + "unregistered mover, failed and a step open": {seat.StepResultStatusOptional, seat.StepResultOutcomeFailed, seat.StepResultOutcomeRunning, []string{"contracts"}, false, "", nil}, + "unregistered mover, the placed one could not run": {seat.StepResultStatusOptional, seat.StepResultOutcomePassed, seat.StepResultOutcomeCouldNotRun, []string{"contracts"}, true, seat.PipelineOutcomeFailed, []string{"contracts has no registration"}}, + "a mover waiting on a publish, the placed one failed": {seat.StepResultStatusOptional, seat.StepResultOutcomeFailed, seat.StepResultOutcomePassed, []string{"contracts", "lib"}, true, seat.PipelineOutcomeFailed, + []string{"contracts has no registration", "lib waits on the publish of core:go"}}, } { - p := seat.Pipeline{Outcome: seat.PipelineOutcomeRunning, Movers: []seat.Mover{{Module: "app"}}, Steps: []seat.StepResult{ + p := seat.Pipeline{Outcome: seat.PipelineOutcomeRunning, Movers: []seat.Mover{{Module: "app"}, {Module: "core"}}, Steps: []seat.StepResult{ {Step: seat.StepResultStepBuild, Module: "app", Status: seat.StepResultStatusRequired, Outcome: c.build}, {Step: seat.StepResultStepUnit, Module: "app", Status: seat.StepResultStatusRequired, Outcome: c.unit}, {Step: seat.StepResultStepReview, Module: "app", Status: c.review, Outcome: seat.StepResultOutcomeWaiting}, {Step: seat.StepResultStepApproval, Module: "app", Status: seat.StepResultStatusRequired, Outcome: seat.StepResultOutcomePassed}, + {Step: seat.StepResultStepBuild, Module: "core", Status: seat.StepResultStatusRequired, Outcome: seat.StepResultOutcomePassed}, }} - if c.unregistered { - p.Movers = append(p.Movers, seat.Mover{Module: "contracts"}) + for _, m := range c.waiting { + p.Movers = append(p.Movers, seat.Mover{Module: m}) } - if got := endPipeline(&p, now); got != c.ends { + if got := endPipeline(&p, now, unplaced); got != c.ends { t.Errorf("%s: ended = %v, want %v", name, got, c.ends) } if c.ends && p.Outcome != c.outcome { t.Errorf("%s: outcome %s, want %s", name, p.Outcome, c.outcome) } - if c.ends && c.unregistered && !strings.Contains(p.Why, "contracts has no registration") { - t.Errorf("%s: why %q, want it to name the mover waiting on its registration", name, p.Why) + for _, w := range c.why { + if !strings.Contains(p.Why, w) { + t.Errorf("%s: why %q, want it to name %q", name, p.Why, w) + } + } + if strings.Contains(p.Why, "lib has no registration") { + t.Errorf("%s: why %q names a registered mover as having no registration", name, p.Why) } } } diff --git a/modules/mesh-delivery-pipeline/internal/pipeline/verbs_test.go b/modules/mesh-delivery-pipeline/internal/pipeline/verbs_test.go index ed3867e0..d3a273a0 100644 --- a/modules/mesh-delivery-pipeline/internal/pipeline/verbs_test.go +++ b/modules/mesh-delivery-pipeline/internal/pipeline/verbs_test.go @@ -167,6 +167,8 @@ func TestAcceptRerunAndCancelWriteByCompareAndSetAndRecordTheirHandAct(t *testin }{seat.Pipeline{Pipeline: "main.20", Branch: "main", Source: 20, Outcome: seat.PipelineOutcomeRunning, Movers: []seat.Mover{{Module: "app"}, {Module: "contracts"}}, Steps: []seat.StepResult{ {Step: seat.StepResultStepBuild, Module: "app", Status: seat.StepResultStatusRequired, Outcome: seat.StepResultOutcomeFailed}}}, 1} + // contracts is named by no registration (H-A-171). + v.Hearer.Unplaced = func(p seat.Pipeline, m string) string { return (&Starter{}).Unplaced(p, m, nil) } if _, err := v.EndAgain("operator", seat.EndAgainInput{Pipeline: "main.20"}); err == nil { t.Error("an end-again with no why was taken") } -- 2.54.0