mesh-delivery-pipeline: a cycle ends only its own steps; the end judgement ends the pipeline

A cycle ended every open step of the pipeline at once and named edges outside
it. It now ends not asked only the steps of the movers without steps, names
the edges inside a strongly connected group alone, and leaves the pipeline's
end to the end judgement, so running steps run to their end.

Builds: design 47 H H-A-176, H-A-175, H-A-163, G §270, G-22 A-326
This commit is contained in:
2026-11-20 18:15:47 +01:00
parent ef086e0b75
commit a7b2fb0ffa
2 changed files with 91 additions and 60 deletions
@@ -173,9 +173,10 @@ func TestAToolchainEdgeIsNotAwaitedByTheBuildModulesOwnInputs(t *testing.T) {
} }
} }
// Design 47 H H-A-175 (G §270, A-326; H-A-101 (2)): a cycle among a pipeline's movers without steps ends the pipeline failed // Design 47 H H-A-175, H-A-176 (G §270, A-326; H-A-101 (2), H-A-163): when every mover without steps waits only on movers
// at its placing, its why `cycle` naming each artifact and edge kind, each of their steps ended not asked; a cycle through // without steps, their steps are placed ended not asked, the why `cycle` naming the edges inside the cycle alone; a step
// a build module's own inputs is broken (G §270) and placed; a mover waiting on a placed mover only waits. // of another mover is asked as ever, and the pipeline ends by the end judgement, at once when no required step is open; a
// cycle through a build module's own inputs is broken (G §270) and placed; a mover waiting on a placed mover only waits.
func TestACycleAmongUnplacedMoversEndsThePipelineFailed(t *testing.T) { func TestACycleAmongUnplacedMoversEndsThePipelineFailed(t *testing.T) {
reg, base := placeFixture() reg, base := placeFixture()
reg.Policy = catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "bypass", Integration: "bypass", Validate: "bypass", Composition: "bypass"}} reg.Policy = catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "bypass", Integration: "bypass", Validate: "bypass", Composition: "bypass"}}
@@ -183,22 +184,22 @@ func TestACycleAmongUnplacedMoversEndsThePipelineFailed(t *testing.T) {
return catalog.CatalogEntry{Module: m, Artifacts: []catalog.Artifact{{Ref: m + ":go", Language: "go"}}, Edges: edges} return catalog.CatalogEntry{Module: m, Artifacts: []catalog.Artifact{{Ref: m + ":go", Language: "go"}}, Edges: edges}
} }
e := func(from, to string, kind int64) catalog.Edge { return catalog.Edge{From: from, To: to, Kind: kind} } e := func(from, to string, kind int64) catalog.Edge { return catalog.Edge{From: from, To: to, Kind: kind} }
cycle := []catalog.CatalogEntry{entry("a", e("b:go", "a:go", 1)), entry("b", e("a:go", "b:go", 1))}
for _, c := range []struct { for _, c := range []struct {
name string name string
entries []catalog.CatalogEntry entries []catalog.CatalogEntry
failed bool outcome string
placed []string asked []string
notAsked []string
}{ }{
{"a cycle G §270 breaks is placed", []catalog.CatalogEntry{ {"a cycle G §270 breaks is placed", []catalog.CatalogEntry{
entry("mesh-sdk", e("mesh-build-go:files", "mesh-sdk:go", 3)), entry("mesh-sdk", e("mesh-build-go:files", "mesh-sdk:go", 3)),
entry("mesh-build-go", e("mesh-sdk:go", "mesh-build-go:go", 1))}, false, []string{"mesh-sdk"}}, entry("mesh-build-go", e("mesh-sdk:go", "mesh-build-go:go", 1))}, seat.PipelineOutcomeRunning, []string{"mesh-sdk"}, nil},
{"a cycle no rule breaks ends the pipeline failed naming it", []catalog.CatalogEntry{ {"a cycle beside a free mover ends its own steps and the free one is asked",
entry("a", e("b:go", "a:go", 1)), append(slices.Clone(cycle), entry("c"), entry("d", e("a:go", "d:go", 1))), seat.PipelineOutcomeRunning, []string{"c"}, []string{"a", "b", "d"}},
entry("b", e("a:go", "b:go", 1)), {"a cycle alone ends the pipeline failed at once", cycle, seat.PipelineOutcomeFailed, nil, []string{"a", "b"}},
entry("c")}, true, []string{"a", "b", "c"}},
{"a mover waiting on a placed mover waits", []catalog.CatalogEntry{ {"a mover waiting on a placed mover waits", []catalog.CatalogEntry{
entry("a", e("b:go", "a:go", 1)), entry("a", e("b:go", "a:go", 1)), entry("b")}, seat.PipelineOutcomeRunning, []string{"b"}, nil},
entry("b")}, false, []string{"b"}},
} { } {
entries := map[string]catalog.CatalogEntry{"mesh-build-go": base["mesh-build-go"]} entries := map[string]catalog.CatalogEntry{"mesh-build-go": base["mesh-build-go"]}
p := seat.Pipeline{Pipeline: "main.4", Branch: "main", Source: 4, Outcome: seat.PipelineOutcomeRunning} p := seat.Pipeline{Pipeline: "main.4", Branch: "main", Source: 4, Outcome: seat.PipelineOutcomeRunning}
@@ -207,30 +208,32 @@ func TestACycleAmongUnplacedMoversEndsThePipelineFailed(t *testing.T) {
p.Movers = append(p.Movers, seat.Mover{Module: en.Module, Commit: "c", Fingerprint: "src2:" + en.Module}) p.Movers = append(p.Movers, seat.Mover{Module: en.Module, Commit: "c", Fingerprint: "src2:" + en.Module})
} }
s := &Starter{Name: "the-runner"} s := &Starter{Name: "the-runner"}
asks, _, ended, _ := s.placeMovers(&p, func(string) (catalog.Registration, bool) { return reg, true }, entries, time.Unix(1, 0)) asks, _, ended, notAsked := s.placeMovers(&p, func(string) (catalog.Registration, bool) { return reg, true }, entries, time.Unix(1, 0))
var got []string if p.Outcome != c.outcome || (c.outcome == seat.PipelineOutcomeFailed) != (len(ended) > 0) || (len(c.asked) > 0) != (len(asks) > 0) {
for _, m := range p.Movers { t.Errorf("%s: pipeline %s (%s), %d asks, %d ended; want %s", c.name, p.Outcome, p.Why, len(asks), len(ended), c.outcome)
if placed(p, m.Module) { }
got = append(got, m.Module) said := map[int]bool{}
for _, i := range append(ended, notAsked...) {
said[i] = true
}
var asked, ends []string
for i, st := range p.Steps {
switch {
case st.Outcome == seat.StepResultOutcomeNotAsked && strings.HasPrefix(st.Why, "cycle: ") && said[i]:
if !slices.Contains(ends, st.Module) {
ends = append(ends, st.Module)
}
if st.Why != "cycle: a:go before b:go (kind 1); b:go before a:go (kind 1)" {
t.Errorf("%s: %s's %s why %q, want the cycle's two edges alone", c.name, st.Module, st.Step, st.Why)
}
case open(st) || st.Outcome == seat.StepResultOutcomeWaiting:
if !slices.Contains(asked, st.Module) {
asked = append(asked, st.Module)
} }
} }
if !slices.Equal(got, c.placed) {
t.Errorf("%s: placed %v, want %v", c.name, got, c.placed)
}
if !c.failed {
if p.Outcome != seat.PipelineOutcomeRunning || len(ended) != 0 || len(asks) == 0 {
t.Errorf("%s: pipeline %s (%s), %d ended, %d asks; want running and asked", c.name, p.Outcome, p.Why, len(ended), len(asks))
}
continue
}
if p.Outcome != seat.PipelineOutcomeFailed || !strings.HasPrefix(p.Why, "cycle: ") || !strings.Contains(p.Why, "a:go before b:go (kind 1)") ||
!strings.Contains(p.Why, "b:go before a:go (kind 1)") || len(asks) != 0 || len(ended) == 0 {
t.Errorf("%s: pipeline %s why %q, %d asks, %d ended; want failed naming the cycle, nothing asked", c.name, p.Outcome, p.Why, len(asks), len(ended))
}
for _, st := range p.Steps {
if st.Outcome != seat.StepResultOutcomeBypassed && (st.Outcome != seat.StepResultOutcomeNotAsked || st.Why != p.Why) {
t.Errorf("%s: %s's %s = %s (%s), want not asked naming the cycle", c.name, st.Module, st.Step, st.Outcome, st.Why)
} }
if !slices.Equal(asked, c.asked) || !slices.Equal(ends, c.notAsked) {
t.Errorf("%s: open %v, ended not asked %v; want %v and %v", c.name, asked, ends, c.asked, c.notAsked)
} }
} }
} }
@@ -369,8 +369,10 @@ func (s *Starter) placeMovers(p *seat.Pipeline, reg func(module string) (catalog
} }
} }
} }
if ended := cycled(p, waits, unregistered, reg, entries, now, s.Name); len(ended) > 0 { if steps, ended := cycled(p, waits, unregistered, reg, entries, now, s.Name); ended {
return nil, unregistered, ended, notAsked return nil, unregistered, steps, notAsked
} else {
notAsked = append(notAsked, steps...)
} }
// A mover placed after the validate ended has its composition asked, or not asked, at once (§745). // A mover placed after the validate ended has its composition asked, or not asked, at once (§745).
more, _ := releaseCompositions(p, now) more, _ := releaseCompositions(p, now)
@@ -379,44 +381,70 @@ func (s *Starter) placeMovers(p *seat.Pipeline, reg func(module string) (catalog
return asks, unregistered, ended, notAsked return asks, unregistered, ended, notAsked
} }
// cycled ends p failed at its placing when every mover still without steps waits only on movers without steps (H-A-175; // cycled ends not asked, at p's placing, the steps of every mover still without steps when each waits only on movers
// G §270 and A-326 break a build module's own inputs before this): a cycle no build can start, its why `cycle` naming each // without steps (H-A-175, H-A-176; G §270 and A-326 break a build module's own inputs before this): a cycle no build can
// artifact and edge kind on it. The waiting movers' steps are placed ended not asked (as H-A-101 (2) does), and every other // start, and the movers that wait only on it. Their steps are placed ended not asked (as H-A-101 (2) does), the why
// step still open ends not asked, the way a holderless pipeline ends at once (A-470g). It answers the steps it ended, // `cycle` naming each artifact and edge kind whose two movers share a strongly connected group; no step already asked is
// none when there is no such cycle. // touched. The pipeline then ends by the end judgement of H-A-163 (endPipeline), failed once no required step is open,
func cycled(p *seat.Pipeline, waits []seat.Mover, unregistered []string, reg func(module string) (catalog.Registration, bool), entries map[string]catalog.CatalogEntry, now time.Time, name string) []int { // its running steps running to their own end. It answers the steps it ended not asked, or, when the pipeline ended, every
// step it ended, and whether the pipeline ended.
func cycled(p *seat.Pipeline, waits []seat.Mover, unregistered []string, reg func(module string) (catalog.Registration, bool), entries map[string]catalog.CatalogEntry, now time.Time, name string) ([]int, bool) {
if len(waits) == 0 || len(unregistered) > 0 { if len(waits) == 0 || len(unregistered) > 0 {
return nil return nil, false
} }
var on []string after := map[string][]string{}
edges := map[string][]catalog.Edge{}
for _, m := range waits { for _, m := range waits {
for _, x := range awaited(*p, m.Module, entries) { for _, x := range awaited(*p, m.Module, entries) {
if placed(*p, moduleOf(x.From)) { from := moduleOf(x.From)
return nil if placed(*p, from) {
return nil, false
} }
after[m.Module] = append(after[m.Module], from)
edges[m.Module] = append(edges[m.Module], x)
}
}
comp := components(waits, after)
var on []string
for _, m := range waits {
for _, x := range edges[m.Module] {
if comp[moduleOf(x.From)] == comp[m.Module] {
on = append(on, fmt.Sprintf("%s before %s (kind %d)", x.From, x.To, x.Kind)) on = append(on, fmt.Sprintf("%s before %s (kind %d)", x.From, x.To, x.Kind))
} }
} }
}
sort.Strings(on) sort.Strings(on)
why := "cycle: " + strings.Join(on, "; ") why := "cycle: " + strings.Join(on, "; ")
var ended []int
for _, m := range waits { for _, m := range waits {
r, _ := reg(m.Module) r, _ := reg(m.Module)
steps, _ := Place(*p, m, r, entries, now, name) steps, _ := Place(*p, m, r, entries, now, name)
p.Steps = append(p.Steps, steps...) for k := range steps {
} st := &steps[k]
var ended []int if st.Outcome == seat.StepResultOutcomeBypassed {
for i := range p.Steps {
st := &p.Steps[i]
if st.Outcome == seat.StepResultOutcomeBypassed || (!open(*st) && st.Outcome != seat.StepResultOutcomeWaiting) {
continue continue
} }
st.Outcome, st.Why, st.Ask, st.Shared, st.Ended = seat.StepResultOutcomeNotAsked, why, "", nil, &now st.Outcome, st.Why, st.Ask, st.Shared, st.Ended = seat.StepResultOutcomeNotAsked, why, "", nil, &now
p.Unlogged = append(p.Unlogged, endEntry(p.Pipeline, *st, now)) p.Unlogged = append(p.Unlogged, endEntry(p.Pipeline, *st, now))
ended = append(ended, len(p.Steps)+k)
}
p.Steps = append(p.Steps, steps...)
}
var approvals []int
for i, st := range p.Steps {
if st.Step == seat.StepResultStepApproval && st.Outcome == seat.StepResultOutcomeWaiting {
approvals = append(approvals, i)
}
}
if !endPipeline(p, now, nil) {
return ended, false
}
for _, i := range approvals {
if p.Steps[i].Outcome == seat.StepResultOutcomeNotAsked {
ended = append(ended, i) ended = append(ended, i)
} }
p.Outcome, p.Why, p.Ended = seat.PipelineOutcomeFailed, why, &now }
p.EndCount++ return ended, true
return ended
} }
// sayNotAsked says the step-ended of each step of p placed not asked because its mover's dependency did not build, naming // sayNotAsked says the step-ended of each step of p placed not asked because its mover's dependency did not build, naming