Compare commits

...
Author SHA1 Message Date
mesh-tools d1d092980a Merge pull request 'Indexer: the take-in's manifest read sets an unknown top-level word aside (H-A-465)' (#323) from fix/takein-unknown-word into main 2026-11-22 03:15:38 +00:00
jschoubben 241cfd581a The take-in sets an unknown top-level manifest word aside (H-A-465)
The running indexer read every manifest strictly for its fingerprint
inputs, so a manifest carrying a word its SDK does not know yet (class)
got no fingerprint and nothing of the revision delivered. The take-in's
read (ParseManifestForInputs) now sets an unknown top-level word aside,
as the SDK's decoder does, and takes the inputs from the words it knows;
a word inside a known one is still refused. The judgement's read
(judge.Manifest without a predefined list) stays strict.

Builds: design 47 H2 H-A-465
2026-11-22 04:11:49 +01:00
mesh-tools fe5fa6ac94 Merge pull request 'The runner takes out the stayers' steps not asked on a mover that left and places them again at the hand-off (H-A-361)' (#321) from fix/47-H2-end-after-handoff into main 2026-11-21 22:38:18 +00:00
jschoubben 99b25a7db4 H-A-361: a hand-off places again the stayers not asked on a mover that left
On 21 Nov the order was the reverse of the first commit's: mesh-contracts'
old build was withdrawn first (21:50:16), so the stayers that awaited it
were placed not asked, and only then did the hand-offs take it away. A
mover that left is still a dependency of those stayers: their not-asked
steps held the pipeline's end as failures. At the hand-off the steps of
each stayer that ended not asked on a dependency that left, directly or
through a mover itself taken out, are taken out, so the placing that
follows places them again against the newest published package; a
dependency that truly did not build is named again at that placing. The
journal says which movers are placed again.

Builds: design 47 H H-A-361, H-A-53, H-A-223
2026-11-21 23:34:24 +01:00
jschoubben 7606d515fd H-A-361: a hand-off places the movers that stay; a mover that left is not awaited
main.158 and main.163 ended failed seconds after newer pipelines took
movers away: the movers that stay still awaited the movers that left,
whose builds had ended superseded, so the next placing ended them "not
asked: its dependency did not build" and the end judgement counted
them as failures. A mover that left is no longer awaited (the stayer
builds against the newest published package, H-A-53), is never placed
in the older pipeline, and the hand-off places what stays at once and
says in the journal which movers stay.

Builds: design 47 H H-A-361, H-A-53, H-A-223
2026-11-21 23:17:59 +01:00
10 changed files with 286 additions and 14 deletions
@@ -143,8 +143,9 @@ func TestAnArtifactOfNoToolchainHasNoLanguageAndNoLock(t *testing.T) { // 1450/A
func TestAManifestTheParserRefusesLeavesNoInputsAndSaysWhy(t *testing.T) { // 1450/AC5
for name, raw := range map[string]string{
"not json": "not json",
"unknown field": strings.Replace(catalogueManifest(t, "avahi"), `"version": "1",`, `"version": "1", "scope": "everything",`, 1),
"not json": "not json",
// A word inside a known one is still refused; a top-level word is set aside (below).
"unknown field": strings.Replace(catalogueManifest(t, "avahi"), `"name": "tools",`, `"name": "tools", "a-field-from-later": "everything",`, 1),
} {
in := inputsOf("avahi", raw, "t", nil, noBases)
if in.Kept != nil || !strings.HasPrefix(in.None2, "the manifest cannot be read: ") || len(in.None2) <= len("the manifest cannot be read: ") {
@@ -154,6 +155,15 @@ func TestAManifestTheParserRefusesLeavesNoInputsAndSaysWhy(t *testing.T) { // 14
if in := inputsOf("someone-else", catalogueManifest(t, "avahi"), "t", nil, noBases); in.Kept != nil || !strings.Contains(in.None2, "avahi") {
t.Errorf("a manifest of another module: kept %+v none2 %q", in.Kept, in.None2)
}
// H-A-465: a top-level word the running indexer's SDK does not know yet (`class`, which a newer SDK adds) is set
// aside, and the inputs are those of the same manifest without it.
without := inputsOf("avahi", catalogueManifest(t, "avahi"), "t", map[string]string{"go.sum": avahiGoSum}, noBases)
with := inputsOf("avahi", strings.Replace(catalogueManifest(t, "avahi"), `"version": "1",`, `"version": "1", "class": "core",`, 1),
"t", map[string]string{"go.sum": avahiGoSum}, noBases)
if with.Kept == nil || without.Kept == nil || !reflect.DeepEqual(*with.Kept, *without.Kept) || with.None2 != without.None2 ||
!reflect.DeepEqual(with.Languages, without.Languages) || !reflect.DeepEqual(with.ArtifactPaths, without.ArtifactPaths) {
t.Errorf("with an unknown top-level word: %+v (kept %+v), want the inputs without it %+v (kept %+v)", with, with.Kept, without, without.Kept)
}
}
func TestAContextIsNotPinned(t *testing.T) { // 1450 (the rule 1444 keeps: context not pinned, as today's form)
@@ -7,12 +7,12 @@ import (
)
// unreadableAvahi is avahi's manifest with a field the running parser refuses: the shape of a manifest an older SDK could
// not read.
// not read. The field is inside an artifact, since a top-level word the take-in does not know is set aside (H-A-465).
func unreadableAvahi(t *testing.T) string {
t.Helper()
raw := strings.Replace(catalogueManifest(t, "avahi"), `"version": "1",`, `"version": "1", "scope": "everything",`, 1)
raw := strings.Replace(catalogueManifest(t, "avahi"), `"name": "tools",`, `"name": "tools", "a-field-from-later": "everything",`, 1)
if raw == catalogueManifest(t, "avahi") {
t.Fatal("the fixture has no version line")
t.Fatal("the fixture has no artifact named tools")
}
return raw
}
+1 -1
View File
@@ -40,7 +40,7 @@ func Manifest(raw []byte, predefined catalogue.PredefinedList) (m catalogue.Mani
if predefined != nil {
m, err = ParseManifestWith(raw, predefined)
} else {
m, err = ParseManifestForInputs(raw)
m, err = parseManifestFallingBack(raw)
}
if err != nil {
return catalogue.Manifest{}, problemsOf(err)
@@ -27,6 +27,9 @@ func TestTheJudge(t *testing.T) {
want: map[string]string{"a": `secret-`}},
{name: "an unknown field", raws: map[string]string{"a": `{"module":"a","version":"1.0","a-field-from-later":1}`},
want: map[string]string{"a": `"a-field-from-later"`}},
// H-A-465: the take-in sets a top-level word it does not know aside (ForInputs); the judgement still refuses it.
{name: "a word a newer SDK adds", raws: map[string]string{"a": `{"module":"a","version":"1.0","class":"core"}`},
want: map[string]string{"a": `"class"`}},
// Design 47 G §23, §28: a step's status is kept in the registration and never in a manifest.
{name: "a manifest naming a step's status", raws: map[string]string{"a": `{"module":"a","version":"1.0","policy":{"lint":"bypass"}}`},
want: map[string]string{"a": `"policy"`}},
+66 -1
View File
@@ -3995,13 +3995,23 @@ var protectedRoots = []string{"/", "/bin", "/boot", "/dev", "/etc", "/home", "/l
"/var/spool"}
// ParseManifestForInputs reads a manifest for the inputs of its build and its fingerprint: the indexer's and the
// builder's read (novox/hq issue 1751). It is never a judge of config values. A value falling back to a predefined key
// builder's read (novox/hq issue 1751). It is never a judge of config values, and never of words: a top-level word the
// SDK's manifest does not know (a word a newer SDK adds, such as `class`) is set aside, as the SDK's decoder sets it
// aside, and the inputs are taken from the words it knows (design 47 H, H-A-465), so a revision carrying a new word
// still gets its fingerprint from the running indexer. The judgement's read (Manifest, ParseManifest) stays strict: the
// validator built from the revision's own indexer refuses what it does not know. A value falling back to a predefined key
// (ADR 0348 §7) is judged against the list the mesh published when this process holds one (PublishedPredefined);
// where it holds none, as in the indexer and the builder, each key a value names is taken as the value declares it (its
// type, trusted when it is), since the list is read where a manifest is judged: the merge gate from the tree's root,
// the controller from what it published. No input of a fingerprint or a build comes from the list. Everything else
// ParseManifest refuses is refused here too.
func ParseManifestForInputs(raw []byte) (catalogue.Manifest, error) {
return parseManifestFallingBack(withoutUnknownWords(raw))
}
// parseManifestFallingBack is the strict read judging each predefined key a value falls back to against the list the
// mesh published, or, where this process holds none, as the value declares it (fallbacksOf).
func parseManifestFallingBack(raw []byte) (catalogue.Manifest, error) {
list := catalogue.PublishedPredefined()
if list == nil {
list = fallbacksOf(raw)
@@ -4009,6 +4019,61 @@ func ParseManifestForInputs(raw []byte) (catalogue.Manifest, error) {
return parseManifest(raw, list)
}
// withoutUnknownWords is raw without each top-level word the SDK's manifest does not know, the others in their order
// and their values as written; raw itself when it knows every word or is no JSON object (the strict read then says
// what is wrong with it). A word inside a known one is not set aside here: the strict read refuses it.
func withoutUnknownWords(raw []byte) []byte {
decoder := json.NewDecoder(bytes.NewReader(raw))
if t, err := decoder.Token(); err != nil || t != json.Delim('{') {
return raw
}
var out bytes.Buffer
out.WriteByte('{')
kept, setAside := 0, false
for decoder.More() {
t, err := decoder.Token()
if err != nil {
return raw
}
word, _ := t.(string)
var value json.RawMessage
if err := decoder.Decode(&value); err != nil {
return raw
}
if !knownWord(word) {
setAside = true
continue
}
if kept > 0 {
out.WriteByte(',')
}
quoted, _ := json.Marshal(word)
out.Write(quoted)
out.WriteByte(':')
out.Write(value)
kept++
}
if !setAside {
return raw
}
out.WriteByte('}')
return out.Bytes()
}
// knownWord is whether the SDK's manifest knows a top-level word: a manifest of that word alone, valued null, is read
// with nothing set aside. A word the SDK reads by a rule of its own that refuses null is known.
func knownWord(word string) bool {
probe, err := json.Marshal(map[string]json.RawMessage{word: json.RawMessage("null")})
if err != nil {
return true
}
var m catalogue.Manifest
if err := json.Unmarshal(probe, &m); err != nil {
return true
}
return m.SetAside() == ""
}
// fallbacksOf is the list of the predefined keys a manifest's config values fall back to, each as the value declares
// it. A manifest that is not JSON gives an empty list, and the parser says what is wrong with it.
func fallbacksOf(raw []byte) catalogue.PredefinedList {
@@ -139,13 +139,16 @@ var buildKinds = []int64{3, 1}
// awaited are the artifact references mover m's steps wait for in p (§746, H-A-51): the From of each edge of a build kind
// into m from another mover of p, toolchain edges first, each once. A toolchain edge (kind 3) from a build module whose
// own new version is built from m is not awaited: what a build module's new version is built from is built by its
// running version, never waited for (G §270, A-326), so the running build module builds m and the new one the rest.
// running version, never waited for (G §270, A-326), so the running build module builds m and the new one the rest. A
// mover that left p for a newer pipeline is not awaited either: m builds against the newest published package (H-A-53),
// and its build ended superseded is no dependency that did not build (H-A-361).
func awaited(p seat.Pipeline, m string, entries map[string]catalog.CatalogEntry) []catalog.Edge {
var out []catalog.Edge
for _, kind := range buildKinds {
for _, x := range entries[m].Edges {
from := moduleOf(x.From)
if x.Kind != kind || from == m || !Moves(p, from) || slices.ContainsFunc(out, func(e catalog.Edge) bool { return e.From == x.From }) {
if x.Kind != kind || from == m || !Moves(p, from) || slices.Contains(p.Superseded, from) ||
slices.ContainsFunc(out, func(e catalog.Edge) bool { return e.From == x.From }) {
continue
}
if kind == 3 && builtFrom(p, from, entries)[m] {
@@ -179,6 +179,135 @@ func TestAMoversBuildWaitsForItsDependenciesInThePipeline(t *testing.T) {
if _, err := s2.Turn("main.7", view); err != nil || len(s2.publishedRead) != 0 {
t.Errorf("after main.7's end %d answers are kept (%v), want none", len(s2.publishedRead), err)
}
// H-A-361 (main.158 at 22:51, main.163 at 23:00 of 2026-11-21), H-A-53, H-A-223: a newer pipeline takes mesh-sdk and
// builder, whose builds run, and web, not placed yet; app and tool, which awaited them, stay. They are placed and asked
// at the hand-off, building against the newest published package, never ended not asked as if their dependency had
// failed; web is not placed here; the journal says the hand-off and what stays; a later placing and the end judgement
// leave the pipeline running until its kept steps end.
t.Run("a hand-off places the kept movers that awaited a mover that left", func(t *testing.T) {
web := entries["app"]
web.Module, web.Edges = "web", []catalog.Edge{{From: "mesh-sdk:go", To: "web:program", Kind: 1}}
entries["web"] = web
mem := memStore{}
s := &Starter{Pipelines: memCreated{mem}, Store: mem, Say: func(string, any) error { return nil }, Steps: &stepAsks{}, Name: "the-runner",
Registration: func(string) (catalog.Registration, bool) { return reg, true }}
ev := ev
ev.Entries = append(slices.Clone(ev.Entries), catalog.TakeInEntry{Module: "web", Commit: "c4", Fingerprint: "src2:dd"})
if n, err := s.TakenIn(ev, view); n != 1 || err != nil {
t.Fatalf("the take-in started %d (%v)", n, err)
}
var journal []string
h := &Hearer{Store: mem, Name: "the-runner", Say: func(string, any) error { return nil },
Logf: func(f string, a ...any) { journal = append(journal, fmt.Sprintf(f, a...)) },
Release: func(key string) { _, _ = s.Release(mem, key, view) }}
h.SupersedeRunning(seat.Pipeline{Pipeline: "main.9", Branch: "main", Revision: 9, Movers: []seat.Mover{
{Module: "mesh-sdk", Commit: "c5", Fingerprint: "src2:01"}, {Module: "builder", Commit: "c5", Fingerprint: "src2:b2"},
{Module: "web", Commit: "c5", Fingerprint: "src2:d2"}}})
check := func(when string) {
p, _, _ := mem.Get("main.7")
if p.Outcome != seat.PipelineOutcomeRunning {
t.Fatalf("%s: main.7 = %s (%s), want running until its kept steps end", when, p.Outcome, p.Why)
}
for _, m := range []string{"app", "tool"} {
st := stepsOf(p, m)
if len(st) == 0 || st[0].Step != seat.StepResultStepBuild || st[0].Outcome != seat.StepResultOutcomeRunning || st[0].Ask == "" {
t.Errorf("%s: %s's steps = %+v, want its build placed and asked", when, m, st)
}
}
if st := stepsOf(p, "app"); len(st) > 0 && !strings.Contains(st[0].Why, "mesh-sdk") {
t.Errorf("%s: app's build why %q does not say mesh-sdk was taken out (H-A-53)", when, st[0].Why)
}
if placed(p, "web") {
t.Errorf("%s: web, which left, is placed in main.7: %+v", when, stepsOf(p, "web"))
}
}
check("at the hand-off")
if !slices.ContainsFunc(journal, func(l string) bool {
return strings.Contains(l, "main.7: ") && strings.Contains(l, "leave it") && strings.Contains(l, "stay: app, tool")
}) {
t.Errorf("the journal %q does not say the hand-off and that app and tool stay", journal)
}
// A placing heard later (a publish, a step end) and the end judgement again: still running.
if _, err := s.Release(mem, "main.7", view); err != nil {
t.Fatal(err)
}
p, rev, _ := mem.Get("main.7")
if endPipeline(&p, time.Now(), nil) {
_, _ = mem.Update("main.7", p, rev)
}
check("after a later placing and the end judgement")
})
// H-A-361, the reverse order (21:50:16 of 2026-11-21, mesh-contracts' old build withdrawn): builder's build ends without
// passing first, so tool, awaiting it, and ext, awaiting tool, are placed not asked; only then does a newer pipeline take
// builder away. At the hand-off tool and ext, not asked on a dependency that left (ext through tool), are taken out and
// placed again: tool is asked, building against the newest published package, ext waits for tool's build; the journal
// says it, and a later placing and the end judgement leave the pipeline running.
t.Run("a build that did not pass, then a hand-off, places again the movers not asked on the mover that left", func(t *testing.T) {
ext := entries["app"]
ext.Module, ext.Edges = "ext", []catalog.Edge{{From: "tool:program", To: "ext:program", Kind: 1}}
entries["ext"] = ext
mem := memStore{}
s := &Starter{Pipelines: memCreated{mem}, Store: mem, Say: func(string, any) error { return nil }, Steps: &stepAsks{}, Name: "the-runner",
Registration: func(string) (catalog.Registration, bool) { return reg, true }}
ev := ev
ev.Entries = append(slices.Clone(ev.Entries), catalog.TakeInEntry{Module: "ext", Commit: "c6", Fingerprint: "src2:ee"})
if n, err := s.TakenIn(ev, view); n != 1 || err != nil {
t.Fatalf("the take-in started %d (%v)", n, err)
}
var journal []string
h := &Hearer{Store: mem, Name: "the-runner", Say: func(string, any) error { return nil },
Logf: func(f string, a ...any) { journal = append(journal, fmt.Sprintf(f, a...)) },
Release: func(key string) { _, _ = s.Release(mem, key, view) }}
p, _, _ := mem.Get("main.7")
b := stepsOf(p, "builder")[0]
e, err := bs.Decode([]byte(`{"id":"` + b.Ask + `","pipeline":"main.7","step":"build","node":"n1","outcome":"failed","entries":[{"module":"builder","commit":"c2","fingerprint":"src2:bb"}]}`))
if err != nil {
t.Fatal(err)
}
if _, err := h.OnStepEnded(bs, bs.Prefix+"n1", e); err != nil {
t.Fatal(err)
}
// A later placing places ext, whose dependency tool was not asked, not asked too.
if _, err := s.Release(mem, "main.7", view); err != nil {
t.Fatal(err)
}
p, _, _ = mem.Get("main.7")
for _, m := range []string{"tool", "ext"} {
if st := stepsOf(p, m); len(st) == 0 || st[0].Outcome != seat.StepResultOutcomeNotAsked {
t.Fatalf("after builder's build failed, %s's steps = %+v, want placed not asked", m, st)
}
}
h.SupersedeRunning(seat.Pipeline{Pipeline: "main.9", Branch: "main", Revision: 9, Movers: []seat.Mover{
{Module: "builder", Commit: "c5", Fingerprint: "src2:b2"}}})
check := func(when string) {
p, _, _ := mem.Get("main.7")
if p.Outcome != seat.PipelineOutcomeRunning {
t.Fatalf("%s: main.7 = %s (%s), want running until its kept steps end", when, p.Outcome, p.Why)
}
if st := stepsOf(p, "tool"); len(st) == 0 || st[0].Step != seat.StepResultStepBuild || st[0].Outcome != seat.StepResultOutcomeRunning || st[0].Ask == "" {
t.Errorf("%s: tool's steps = %+v, want its build placed again and asked", when, st)
}
if placed(p, "ext") {
t.Errorf("%s: ext's steps = %+v, want it waiting for tool's build, not placed", when, stepsOf(p, "ext"))
}
}
check("at the hand-off")
if !slices.ContainsFunc(journal, func(l string) bool {
return strings.Contains(l, "main.7: tool, ext, not asked on a dependency that left, placed again")
}) {
t.Errorf("the journal %q does not say tool and ext are placed again", journal)
}
if _, err := s.Release(mem, "main.7", view); err != nil {
t.Fatal(err)
}
p, rev, _ := mem.Get("main.7")
if endPipeline(&p, time.Now(), nil) {
_, _ = mem.Update("main.7", p, rev)
}
check("after a later placing and the end judgement")
})
}
// Design 47 G §270, A-326 (H §746, H-A-83 (2)): what a build module's new version is built from is built by its running
@@ -189,7 +189,7 @@ func (s *Starter) placeAgain(p *seat.Pipeline, m seat.Mover, half Half, now time
supersededWhy(*p, m.Module, half.Entries, steps)
var notAsked []int
if failed != "" {
why := "its dependency " + failed + " did not build"
why := notBuiltWhy(failed)
for k := range steps {
st := &steps[k]
if st.Outcome == seat.StepResultOutcomeBypassed {
@@ -134,6 +134,22 @@ func placed(p seat.Pipeline, module string) bool {
return false
}
// notBuiltWhy is the why of a step placed not asked because dependency failed did not build (H-A-101 (2)).
func notBuiltWhy(failed string) string { return "its dependency " + failed + " did not build" }
// notBuiltDependency answers the dependency a step placed not asked names as not built (notBuiltWhy), if it is one.
func notBuiltDependency(st seat.StepResult) (string, bool) {
if st.Outcome != seat.StepResultOutcomeNotAsked {
return "", false
}
d, ok := strings.CutPrefix(st.Why, "its dependency ")
if !ok {
return "", false
}
d, ok = strings.CutSuffix(d, " did not build")
return d, ok && d != ""
}
// Starter starts pipelines (design 47 G §54, §103): it writes a pipeline's key by compare-and-set on its absence, so one
// source revision and module has one pipeline whichever event starts it first, and says pipeline-started for the one it
// wrote.
@@ -409,7 +425,8 @@ func (s *Starter) placeMovers(p *seat.Pipeline, reg func(module string) (catalog
}
all := entries
for _, m := range p.Movers {
if placed(*p, m.Module) {
// A mover that left for a newer pipeline is placed there, never here (H-A-223, H-A-361).
if placed(*p, m.Module) || slices.Contains(p.Superseded, m.Module) {
continue
}
r, ok := reg(m.Module)
@@ -443,7 +460,7 @@ func (s *Starter) placeMovers(p *seat.Pipeline, reg func(module string) (catalog
}
}
if failed != "" {
why := "its dependency " + failed + " did not build"
why := notBuiltWhy(failed)
for k := range steps {
st := &steps[k]
if st.Outcome == seat.StepResultOutcomeBypassed {
@@ -1024,7 +1041,7 @@ func (s *Starter) Release(store Updater, key string, view func(branch string) (H
return false
}
for _, m := range p.Movers {
if !placed(p, m.Module) {
if !placed(p, m.Module) && !slices.Contains(p.Superseded, m.Module) {
return true
}
}
@@ -124,6 +124,7 @@ func (h *Hearer) supersedeRunningOne(key string, newer seat.Pipeline) bool {
ended = append(ended, i)
}
p.Superseded = append(p.Superseded, moved...)
again := takeOutNotAsked(&p)
done := h.endPipeline(&p, now, wr)
if _, err := h.Store.Update(key, p, rev); errors.Is(err, ErrChanged) {
continue
@@ -131,7 +132,17 @@ func (h *Hearer) supersedeRunningOne(key string, newer seat.Pipeline) bool {
h.logf("the running pipeline %s is not written, so its movers moved by %s stay: %v", key, newer.Pipeline, err)
return false
}
h.logf("%s: %s moved by the newer %s leave it, %d of its open steps ended superseded (H-A-223)", key, strings.Join(moved, ", "), newer.Pipeline, len(ended))
var stay []string
for _, m := range p.Movers {
if !slices.Contains(p.Superseded, m.Module) {
stay = append(stay, m.Module)
}
}
h.logf("%s: %s moved by the newer %s leave it, %d of its open steps ended superseded (H-A-223); %d stay: %s (H-A-361)", key,
strings.Join(moved, ", "), newer.Pipeline, len(ended), len(stay), strings.Join(stay, ", "))
if len(again) > 0 {
h.logf("%s: %s, not asked on a dependency that left, placed again (H-A-361)", key, strings.Join(again, ", "))
}
for _, i := range ended {
if err := h.say(seat.EventStepEnded, p, &p.Steps[i]); err != nil {
h.logf("step-ended of %s's %s %s, superseded, is not said: %v", key, p.Steps[i].Module, p.Steps[i].Step, err)
@@ -142,10 +153,44 @@ func (h *Hearer) supersedeRunningOne(key string, newer seat.Pipeline) bool {
h.logf("%v", err)
}
h.appendUnlogged(key)
// The movers that stay and waited on a mover that left are placed now, building against the newest published package
// (H-A-53, H-A-361): no event of the mover that left comes to this pipeline again.
if !done && h.Release != nil {
h.Release(key)
}
return true
}
}
// takeOutNotAsked takes out of p the steps of each mover that stays whose steps ended not asked because a dependency did not
// build, that dependency a mover that left p, or a mover itself taken out here (H-A-361): a left mover is no dependency of
// the movers that stay (H-A-53), so they are placed again, and a dependency that truly did not build is named again at that
// placing. It answers the movers taken out, in p's order.
func takeOutNotAsked(p *seat.Pipeline) []string {
var out []string
for changed := true; changed; {
changed = false
for _, m := range p.Movers {
if slices.Contains(p.Superseded, m.Module) || slices.Contains(out, m.Module) {
continue
}
dep := ""
for _, st := range stepsOf(*p, m.Module) {
if d, ok := notBuiltDependency(st); ok {
dep = d
break
}
}
if dep == "" || (!slices.Contains(p.Superseded, dep) && !slices.Contains(out, dep)) {
continue
}
p.Steps = slices.DeleteFunc(p.Steps, func(st seat.StepResult) bool { return st.Module == m.Module })
out, changed = append(out, m.Module), true
}
}
return out
}
// supersedeStep ends the open or waiting step st of p superseded, naming why, with its step log entry: a step reading a test
// run is answered to leave it, and one with its own ask on a build node to drop it (H-A-223).
func supersedeStep(p *seat.Pipeline, st *seat.StepResult, why string, now time.Time) (leave, drop []seat.StepResult) {