Merge origin/main into the join: a placed module's failed build said as refused

Brings mesh-host #224 (issue 1966): newestFPs returns a placed module whose
newest build failed, composedValues writes its refused key at that fingerprint,
takeBuildDone starts the pass on a failed build. Conflict in newestFPs settled
by keeping G's by-entries branch first (design 47 G §421, §628: the node reads
neither the indexer's modules nor the builder's builds; it returns no failed),
and main's failed-build path in the other.

Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
This commit is contained in:
2026-11-12 17:00:32 +01:00
3 changed files with 89 additions and 17 deletions
+49 -3
View File
@@ -76,8 +76,11 @@ func TestTheNodePublishesItsCompositions(t *testing.T) {
digest := meshcatalogclient.ManifestDigest([]byte(lemurs))
oldie := `{"module":"oldie","version":"1","capabilities":["systemd"],"resources":[{"id":"service","type":"service","unit":"oldie.service","state":"running","boot":"enabled"}]}`
odigest := meshcatalogclient.ManifestDigest([]byte(oldie))
for d, json := range map[string]string{digest: lemurs, odigest: oldie} {
man, _ := meshcatalogclient.EncodeManifest(meshcatalog.ManifestsByDigestValue{Module: map[string]string{digest: "lemurs", odigest: "oldie"}[d], Manifest: json})
brokenJSON := strings.ReplaceAll(oldie, "oldie", "broken")
waitingJSON := strings.ReplaceAll(oldie, "oldie", "waiting")
bdigest, wdigest := meshcatalogclient.ManifestDigest([]byte(brokenJSON)), meshcatalogclient.ManifestDigest([]byte(waitingJSON))
for d, json := range map[string]string{digest: lemurs, odigest: oldie, bdigest: brokenJSON, wdigest: waitingJSON} {
man, _ := meshcatalogclient.EncodeManifest(meshcatalog.ManifestsByDigestValue{Module: map[string]string{digest: "lemurs", odigest: "oldie", bdigest: "broken", wdigest: "waiting"}[d], Manifest: json})
key, _ := meshcatalogclient.ManifestsKey(d)
b.kv[buckets.Manifests+"/"+key] = man
}
@@ -100,7 +103,7 @@ func TestTheNodePublishesItsCompositions(t *testing.T) {
t.Fatal(err)
}
place := assignedValues(t, meshmoduleassigner.Assignments{Node: "n1", Decided: meshmoduleassigner.NodeDecided{Hub: true, Address: "10.77.0.1"},
Modules: []meshmoduleassigner.PlacedModule{{Module: "lemurs"}, {Module: "oldie"}}})
Modules: []meshmoduleassigner.PlacedModule{{Module: "lemurs"}, {Module: "oldie"}, {Module: "broken"}, {Module: "waiting"}}})
have, _ := nodeengineclient.EncodeHaveNode(nodeengine.HaveByNodeNodeValue{Record: &nodeengine.NodeRecord{Node: "n1", TunnelKey: "k", SealingKey: "sk", Capabilities: []string{"systemd"}}})
mod, _ := meshcatalogclient.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: fp, Manifest: digest, Repository: "novox/x", Commit: "c"})
omod, _ := meshcatalogclient.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: ofp, Manifest: odigest, Repository: "novox/o", Commit: "c"})
@@ -110,6 +113,12 @@ func TestTheNodePublishesItsCompositions(t *testing.T) {
b.put(t, buckets.Have, "n1.node", have)
b.put(t, buckets.Modules, "lemurs", mod)
b.put(t, buckets.Modules, "oldie", omod)
bfp := meshcatalogclient.SourcePrefix2 + strings.Repeat("d", 64)
wfp := meshcatalogclient.SourcePrefix2 + strings.Repeat("e", 64)
for m, f := range map[string]string{"broken": bfp, "waiting": wfp} {
raw, _ := meshcatalogclient.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: f, Manifest: map[string]string{"broken": bdigest, "waiting": wdigest}[m], Repository: "novox/o", Commit: "c"})
b.put(t, buckets.Modules, m, raw)
}
b.put(t, buckets.Wants, "want.n1.lemurs", want)
b.put(t, buckets.Wants, "want.n1.node", nodeWant)
for _, bucket := range []string{buckets.Wants, buckets.Assignments, buckets.Have, buckets.Modules, ResolvedBucket, builds.BuilderBuildsBucket} {
@@ -195,6 +204,43 @@ func TestTheNodePublishesItsCompositions(t *testing.T) {
t.Errorf("the same build landing again wrote %v", got[3:])
}
// A placed module whose newest build failed is published as a refusal at that build with the build's words (the
// provisioner holds it and does not wait); one whose build is queued or running stays unpublished.
for m, st := range map[string]builds.BuilderBuild{
"broken": {State: builds.BuildFailed, Error: `refused kind: package of language "go"`},
"waiting": {State: builds.BuildQueued},
} {
f := map[string]string{"broken": bfp, "waiting": wfp}[m]
raw, _ := builds.EncodeBuilderBuild(st)
k, _ := builds.BuilderBuildKey(m, f)
b.mu.Lock()
b.kv[builds.BuilderBuildsBucket+"/"+k] = raw
b.mu.Unlock()
b.put(t, builds.BuilderBuildsBucket, k, raw)
}
brokenKey, _ := engcomp.Key("n1", "broken", bfp)
got = waitFor("broken's failed build", func(got []string) bool { return len(got) >= 4 })
// The pass that wrote it says so ("1 key(s) written" was said once before, for oldie); then only brokenKey is new.
for deadline := time.Now().Add(5 * time.Second); time.Now().Before(deadline); time.Sleep(10 * time.Millisecond) {
n := 0
b.mu.Lock()
for _, l := range b.said {
if strings.Contains(l, "this node's composition state: 1 key(s) written") {
n++
}
}
b.mu.Unlock()
if n >= 2 {
break
}
}
if got := state.written(); len(got) != 4 || got[3] != brokenKey {
t.Errorf("a failed build and a queued one wrote %v, want only %s", got[3:], brokenKey)
}
if comp, err := engcomp.Decode(state.kv[brokenKey].Value); err != nil || comp.Refused != `refused kind: package of language "go"` || len(comp.Resources) != 0 {
t.Errorf("the failed build's key: %+v, %v", comp, err)
}
// What is kept: the five keys of a module written last, and one a want names; the rest is deleted.
keep := New(b.env())
keep.pubKept = map[string]ComposedEntry{}