diff --git a/cmd/mesh-host/engineseat.go b/cmd/mesh-host/engineseat.go index a1ccbe1d..00588ed0 100644 --- a/cmd/mesh-host/engineseat.go +++ b/cmd/mesh-host/engineseat.go @@ -6,6 +6,7 @@ import ( "encoding/json" "errors" "fmt" + "log" "os" "path/filepath" "strings" @@ -17,6 +18,7 @@ import ( "git.novox.be/novox/mesh-contracts/go/seats/nodeengine" occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient" stdio "git.novox.be/novox/mesh-sdk/go" + "git.novox.be/novox/mesh-sdk/go/buscalls" "github.com/novox/mesh-host/internal/accounts" "github.com/novox/mesh-host/internal/agent" "github.com/novox/mesh-host/internal/apply" @@ -378,9 +380,9 @@ func packagesFrom(node string, session *link.Session, composer *atomic.Pointer[s // nec.AnswerBound, selfcompose candidateWithin). The answer is // the seat's shape (nodeengine.ComposeCandidateAnswer), checked as it is encoded; a node whose shadow does not run yet // answers unready, which the checker takes as no answer. -func composeCandidateFrom(node string, shadow *atomic.Pointer[selfcompose.Shadow]) func(candidate string, input bool) (any, error) { - return func(candidate string, input bool) (any, error) { - ask := nodeengine.ComposeCandidateInput{Candidate: candidate, Input: input} +func composeCandidateFrom(node string, shadow *atomic.Pointer[selfcompose.Shadow]) func(candidate string, input bool, call string, line buscalls.ChunkLine) (any, error) { + return func(candidate string, input bool, call string, line buscalls.ChunkLine) (any, error) { + ask := nodeengine.ComposeCandidateInput{Candidate: candidate, Input: input, Call: call} if _, err := nec.EncodeAsk(ask); err != nil { return nil, err } @@ -394,11 +396,7 @@ func composeCandidateFrom(node string, shadow *atomic.Pointer[selfcompose.Shadow defer cancel() a = s.ComposeCandidate(ctx, ask) } - raw, err := nec.EncodeAnswer(a) - if err != nil { - return nil, fmt.Errorf("this node's answer to %s does not fit the seat's shape: %w", candidate, err) - } - return json.RawMessage(raw), nil + return answerComposeCandidate(a, candidate, input, call, line) } } @@ -425,3 +423,35 @@ func entryAgainFrom(composer *atomic.Pointer[selfcompose.Composer]) func(ctx con return c.EntryAgain(ctx, fingerprint) } } + +// answerComposeCandidate encodes the answer of compose-candidate. The verb is marked chunks (A-237b, A-237c): asked with input and a +// call token, the composition input goes in chunks over the link's connection, whatever its size, and the answer names them; +// asked with no token (the checker's, until G removes it, G-6 §321, A-237c) it stays inline in the answer. +func answerComposeCandidate(a nodeengine.ComposeCandidateAnswer, candidate string, input bool, call string, line buscalls.ChunkLine) (any, error) { + var chunked []byte + if input && call != "" && a.Input != nil { + if line == nil { + return nil, errors.New("this engine has no bus connection to send the composition input on") + } + body, err := json.Marshal(a.Input) + if err != nil { + return nil, fmt.Errorf("the composition input of %s cannot be encoded: %w", candidate, err) + } + chunked, a.Input = body, nil + a.Chunks = int64((len(body) + buscalls.SeatChunkBytes - 1) / buscalls.SeatChunkBytes) + } + raw, err := nec.EncodeAnswer(a) + if err != nil { + return nil, fmt.Errorf("this node's answer to %s does not fit the seat's shape: %w", candidate, err) + } + if chunked != nil { + send := buscalls.SeatChunks{Seat: nodeengine.Seat, Verb: nodeengine.VerbComposeCandidate, Call: call} + // The answer names the chunks first; the send runs after it and ends at a chunk the caller does not acknowledge. + go func() { + if err := send.Send(line, chunked, buscalls.SeatAckWithin, log.Printf); err != nil { + log.Printf("the send %s of the composition input of %s: %v", call, candidate, err) + } + }() + } + return json.RawMessage(raw), nil +} diff --git a/cmd/mesh-host/main.go b/cmd/mesh-host/main.go index a788afd5..6c5d5d55 100644 --- a/cmd/mesh-host/main.go +++ b/cmd/mesh-host/main.go @@ -992,6 +992,11 @@ func runLink(ctx context.Context, opts options) error { // The engine's own module, first from its applied record of the build whose fingerprint is its own (design 47 G §527, // §634, A-149); on a first start with no such record, from its first composing. own.Set(ownModuleApplied(appliedStoreFor(opts.state), os.Getenv(compositions.FingerprintVar))) + // The live start's recovery (A-404): a first start whose composing never ends is named by its unit's environment, so it + // serves its seat (root-free); the name the assignments place on this node. Ended by the lookup from the bus after G. + if own.Get() == "" { + own.Set(os.Getenv("MESH_ENGINE_OWN_MODULE")) + } queue := &link.Session{ Own: own, Membership: membership, @@ -1257,6 +1262,7 @@ const ( // anyway. A statement the bus did not take is said at the next look. It reads; it never acts (ADR 0240 // rule 6) — but for going on with a take act stopped at its bound (ADR 0328 §7), which runs beside it. func judgeWhatRuns(ctx context.Context, j *liveness.Judge, queue *link.Session, say link.Announce, reapply, reconcile func(modules ...string)) { + say("the looks of what runs and of the accounts start (A-405)") var missingBefore, inactiveBefore map[string]bool ticker := time.NewTicker(liveness.LookEvery) defer ticker.Stop() @@ -1279,8 +1285,16 @@ func judgeWhatRuns(ctx context.Context, j *liveness.Judge, queue *link.Session, case <-nudged: owed = true } + first := lastAccounts.Load() == nil + began := time.Now() + if first { + say("the first look of what runs begins (A-405)") + } st, changed := j.Look(ctx) owed = owed || changed + if first { + say(fmt.Sprintf("the first look of what runs took %s; units and accounts next (A-405)", time.Since(began).Round(time.Millisecond))) + } var unitSt *units.Statement if u := unitJudge; u != nil { us, unitsChanged := u.Look(ctx) @@ -1294,9 +1308,15 @@ func judgeWhatRuns(ctx context.Context, j *liveness.Judge, queue *link.Session, } var accountSt *accounts.Statement if a := accountJudge; a != nil { + if first { + say(fmt.Sprintf("the first look of the accounts begins at %s (A-405)", time.Since(began).Round(time.Millisecond))) + } as, accountsChanged := a.Look(ctx) accountSt = &as lastAccounts.Store(&as) + if first { + say(fmt.Sprintf("the first look of the accounts ended at %s: %d accounts (A-405)", time.Since(began).Round(time.Millisecond), len(as.Accounts))) + } owed = owed || accountsChanged if accountsChanged { for _, v := range as.Accounts { diff --git a/cmd/mesh-host/nodeagent.go b/cmd/mesh-host/nodeagent.go index 29a2822d..7476a3f8 100644 --- a/cmd/mesh-host/nodeagent.go +++ b/cmd/mesh-host/nodeagent.go @@ -1200,6 +1200,8 @@ func composerEnv(session *link.Session, node string, say func(string), hooks com // And the shadow too: the catalog half read by the fingerprints its wants and runnings name, over its own calls of the seat mesh-catalog's // verb entry on its link session (design 47 G §421): neither the indexer's nor the builder's states are read. env.Entry = selfcompose.EntryCall(session.AskMeshSeat) + // And the registry seats' verb versions, to resolve a want that names its version to its artifacts' digests (A-430a). + env.Registry = selfcompose.EntryCall(session.AskMeshSeat) return env } diff --git a/cmd/mesh-host/nodeagent_integration_test.go b/cmd/mesh-host/nodeagent_integration_test.go index 597da0df..d102635d 100644 --- a/cmd/mesh-host/nodeagent_integration_test.go +++ b/cmd/mesh-host/nodeagent_integration_test.go @@ -29,6 +29,7 @@ import ( "time" nec "git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient" + "git.novox.be/novox/mesh-sdk/go/buscalls" "git.novox.be/novox/mesh-sdk/go/buscompose" "git.novox.be/novox/mesh-sdk/go/declaration" "git.novox.be/novox/mesh-sdk/go/seatlist" @@ -702,7 +703,10 @@ func h8candidate(t *testing.T, b *itBed, fp, running string) { t.Fatal(err) } path := filepath.Join(b.dir, "web.conf") - man := `{"module":"web","version":"2","config":{"greeting":{"type":"string","description":"what the file says","default":"hello"}},` + + // A description past what one answer carries (900 KiB, and under the bus's 1 MiB for one value), so the composition input this + // node sends is over the inline bound (A-237b, A-237c). + pad := strings.Repeat("x", 930_000) + man := `{"module":"web","version":"2","config":{"greeting":{"type":"string","description":"what the file says ` + pad + `","default":"hello"}},` + `"resources":[{"id":"conf","type":"file","path":"` + path + `","mode":"0640","content":"greeting=${config:greeting}\n"},` + `{"id":"tools","type":"package","package":"web-tools"}]}` digest := meshcatalogclient.ManifestDigest([]byte(man)) @@ -728,7 +732,43 @@ func h8candidate(t *testing.T, b *itBed, fp, running string) { t.Fatal(err) } before, _ := b.composed.Status() - got, err := composeCandidateFrom(itNode, &shadowNow)(key, false) + // A-237c: asked with input and no call token (the checker's, until G removes it, G-6 §321) an input past what one answer carries + // is refused; asked with a token it is sent in chunks through the engine's call, whatever its size (A-237b). + if over, err := composeCandidateFrom(itNode, &shadowNow)(key, true, "", nil); err != nil { + t.Fatal(err) + } else if a, err := nec.DecodeAnswer(over.(json.RawMessage)); err != nil || a.Verdict != nec.Refused || !strings.Contains(a.Refused, "an answer on the bus carries") || a.Input != nil { + t.Errorf("an input over the inline bound asked with no token answered %+v (%v)", a, err) + } + line := &ackingLine{chunks: map[string][]byte{}, done: make(chan struct{})} + const call = "0123456789abcdef0123456789abcdef" + acts := &link.HandActs{Node: itNode, ComposeCandidate: composeCandidateFrom(itNode, &shadowNow)} + chunked, err := acts.Call(link.EngineCall{Verb: link.ActComposeCandidate, Line: line, + Args: map[string]any{"candidate": key, "input": true, "call": call}}) + if err != nil { + t.Fatal(err) + } + ca, err := nec.DecodeAnswer(chunked.(json.RawMessage)) + if err != nil || ca.Verdict != nec.Composed || ca.Chunks < 2 || ca.Input != nil { + t.Fatalf("the input asked with a token answered %+v (%v), want the chunks and no inline input", ca, err) + } + line.want = int(ca.Chunks) + select { + case <-line.done: + case <-time.After(10 * time.Second): + t.Fatalf("%d of %d chunks were sent", line.sent(), ca.Chunks) + } + var file []byte + for n := int64(1); n <= ca.Chunks; n++ { + var c buscalls.SeatChunk + if err := json.Unmarshal(line.chunks[buscalls.SeatChunks{Seat: nodeengine.Seat, Verb: nodeengine.VerbComposeCandidate, Call: call}.Chunk(n)], &c); err != nil { + t.Fatal(err) + } + file = append(file, c.Data...) + } + if len(file) <= 900<<10 || !json.Valid(file) { + t.Errorf("the chunks held %d bytes, want a JSON input over 900 KiB", len(file)) + } + got, err := composeCandidateFrom(itNode, &shadowNow)(key, false, "", nil) if err != nil { t.Fatal(err) } @@ -1237,3 +1277,35 @@ func TestNatsTheFirstReadOfTheSeatListEndsTheNodesWait(t *testing.T) { t.Error("the list was read by the reader of a run begun since, not by the one that met no responders") } } + +// ackingLine is a bus connection that acknowledges every chunk published on it, as a caller does, and keeps the chunks. +type ackingLine struct { + mu sync.Mutex + onAck nats.MsgHandler + chunks map[string][]byte + done chan struct{} + want int + closed bool +} + +func (l *ackingLine) Subscribe(_ string, cb nats.MsgHandler) (*nats.Subscription, error) { + l.mu.Lock() + l.onAck = cb + l.mu.Unlock() + return &nats.Subscription{}, nil +} + +func (l *ackingLine) sent() int { l.mu.Lock(); defer l.mu.Unlock(); return len(l.chunks) } + +func (l *ackingLine) Publish(subject string, data []byte) error { + l.mu.Lock() + l.chunks[subject] = data + cb := l.onAck + if l.want > 0 && len(l.chunks) >= l.want && !l.closed { + l.closed = true + close(l.done) + } + l.mu.Unlock() + go cb(&nats.Msg{Subject: strings.Replace(subject, ".chunk.", ".ack.", 1)}) + return nil +} diff --git a/internal/agent/agent.go b/internal/agent/agent.go index 33c2ff60..411b2ad2 100644 --- a/internal/agent/agent.go +++ b/internal/agent/agent.go @@ -1530,7 +1530,7 @@ func (a *Agent) baseline(ctx context.Context, module string, w wantNow, comp com a.mu.Unlock() return false } - if h.Phase == string(nodeengineclient.PhaseHeld) { + if h.Phase == string(nodeengineclient.PhaseHeld) && !judgedAgain(h.Detail) { // Held for a failed backup, and the operator's answer is still to come: the hold is kept, nothing is // backed up again or applied, and the next revision of the want is the answer (ADR 0568 §4). Said, so // why it holds is read from the journal and not guessed (issue 1585: this branch was silent). diff --git a/internal/agent/agent_test.go b/internal/agent/agent_test.go index 0c0c8b5a..d592dd83 100644 --- a/internal/agent/agent_test.go +++ b/internal/agent/agent_test.go @@ -366,6 +366,11 @@ func TestAWantAndItsCompositionApplyTheModuleAndTheHaveNamesBoth(t *testing.T) { if got := partsDifference(map[string]string{"web:c": d3}, []json.RawMessage{container}); got != "" { t.Fatalf("a container whose digest is in the parts differs: %q", got) } + // A-432: a runtime of its own runs the tool runner's program, which the module's parts do not name. + ownRuntime := json.RawMessage(`{"id":"web.own-runtime","type":"process","name":"web-runtime","source":"store/node-tools","digest":"` + d1 + `","run":["./node-tools"],"module":"web"}`) + if got := partsDifference(map[string]string{"web:c": d3}, []json.RawMessage{container, ownRuntime}); got != "" { + t.Fatalf("a runtime of its own differs from the module's parts: %q", got) + } } // R6-A AC2: given a kept declaration and wants and compositions equal to it, when the agent starts, nothing is applied @@ -829,6 +834,10 @@ func TestADataModuleIsBackedUpFirstAndHeldWhenItFails(t *testing.T) { {"restic: the repository is locked", meshwants.WantsByWantNodeModuleValueBackupAgain, 1, 1, nodeengineclient.PhaseRunning, false}, {"restic: the repository is locked", meshwants.WantsByWantNodeModuleValueBackupSkip, 0, 1, nodeengineclient.PhaseRunning, false}, {"restic: the repository is locked", "", 0, 0, nodeengineclient.PhaseHeld, false}, + // A hold the node-engine judges again (novox's indexer, 2026-11-16): its parts differed or its entry was not + // held, which no answer of the operator's releases; at a start it is judged again, here backed up and applied. + {PartsDiffer + " fetched and not in the want's parts: sha256:a03131c6", "", 1, 1, nodeengineclient.PhaseRunning, false}, + {EntryMissing + " the catalog half holds no entry of the build", "", 1, 1, nodeengineclient.PhaseRunning, false}, } { r := newBed(t) r.comps.before(ck1, craw1) diff --git a/internal/agent/parts.go b/internal/agent/parts.go index b324b9a7..222808de 100644 --- a/internal/agent/parts.go +++ b/internal/agent/parts.go @@ -6,6 +6,7 @@ import ( "sort" "strings" + "git.novox.be/novox/mesh-sdk/go/catalogue" "git.novox.be/novox/mesh-sdk/go/declaration" ) @@ -21,6 +22,14 @@ const ( EntryMissing = "entry-missing:" ) +// judgedAgain says a held have's detail is a hold the node-engine judges again at a start, not one that waits for the +// operator's answer: its want's parts differ from its composition (§524) or its entry is not held (§421). Only a failed +// backup or restore point waits for an answer (ADR 0568 §4); novox, 2026-11-16: the indexer held "parts-differ" was kept +// at a start as "held for a failed backup", waiting for an answer nobody was asked. +func judgedAgain(why string) bool { + return strings.HasPrefix(why, PartsDiffer) || heldForEntry(why) +} + // heldForEntry says whether why is a hold for the entry a want names. func heldForEntry(why string) bool { return strings.HasPrefix(why, EntryAsked) || strings.HasPrefix(why, EntryMissing) @@ -47,7 +56,8 @@ func partsDifference(parts map[string]string, resources []json.RawMessage) strin fetched[res.Digest] = true } case *declaration.Process: - if res.Source != "" { + // A runtime of its own runs the tool runner's program, which the tool runner's want checks (A-432). + if res.Source != "" && !strings.HasSuffix(res.ID, "."+catalogue.OwnRuntimeID()) { fetched[res.Digest] = true } case *declaration.Container: diff --git a/internal/compose/composed.go b/internal/compose/composed.go index 15017c4d..eff389e5 100644 --- a/internal/compose/composed.go +++ b/internal/compose/composed.go @@ -161,7 +161,7 @@ func compositions(in Input, node string, fps map[string]string, mode Mode, appli } kept := make(map[string]catalogue.Manifest, len(n.Kept)) for m, man := range n.Kept { - if man.Stubbed && man.RunsAs == "" { + if man.Stubbed && man.RunsAs == "" && !keepsProgram(man) { man.Bundles = runningBundles(n.RunsTools[m], reading.Catalogue[m]) } kept[m] = man @@ -489,6 +489,56 @@ func Stub(m catalogue.Manifest) catalogue.Manifest { // run). What it provides, requires, listens on and grants is its manifest's. A module whose resources runs holds none // of is its Stub, as before. func Carried(m catalogue.Manifest, module string, runs *engcomp.Composed) catalogue.Manifest { + stub := carried(m, module, runs) + if catalogue.IsToolRunner(m) && (len(stub.Bundles) != 1 || stub.Bundles[0].Binary == "") { + if b, ok := runningProgram(module, runs); ok { + stub.Bundles = []catalogue.Bundle{b} + } + } + return stub +} + +// keepsProgram says a held tool runner carries the program it runs (Carried, runningProgram): its one bundle is that +// program, which the tools bundles it serves never replace, or the modules of their own account it runs are held for +// want of it (lead-47 2026-11-16: 40ed063 kept novox's, and the loop over what the runtime serves dropped it again). +func keepsProgram(m catalogue.Manifest) bool { + return catalogue.IsToolRunner(m) && len(m.Bundles) == 1 && m.Bundles[0].Binary != "" +} + +// runningProgram is the program bundle of the tool runner as it runs on the node: its process's source, digest and binary. +// A held tool runner keeps it, so a module of its own account is run by the same program the node runs (novox/hq ADR 0259 +// §8) and is not held for want of a runtime that runs (lead-47 2026-11-16: novox's tool runner was held for a build the +// catalog half held no entry of, and held the new indexer with it). +func runningProgram(module string, runs *engcomp.Composed) (catalogue.Bundle, bool) { + if runs == nil { + return catalogue.Bundle{}, false + } + for _, raw := range runs.Resources { + var r struct { + ID string `json:"id"` + Module string `json:"module"` + Type string `json:"type"` + Source string `json:"source"` + Digest string `json:"digest"` + Run []string `json:"run"` + } + if json.Unmarshal(raw, &r) != nil || r.Type != "process" || r.Source == "" || r.Digest == "" || len(r.Run) == 0 { + continue + } + owner := r.Module + if owner == "" { + owner, _ = declaration.ModuleGuess(r.ID) + } + binary, ok := strings.CutPrefix(r.Run[0], "./") + if owner != module || !ok || binary == "" || strings.Contains(binary, "/") { + continue + } + return catalogue.Bundle{Name: "program", Source: registryforms.Forms.Recorded(r.Source), Digest: r.Digest, Binary: binary}, true + } + return catalogue.Bundle{}, false +} + +func carried(m catalogue.Manifest, module string, runs *engcomp.Composed) catalogue.Manifest { if runs == nil { return Stub(m) } diff --git a/internal/compose/composed_test.go b/internal/compose/composed_test.go index 17fc78a7..11732c84 100644 --- a/internal/compose/composed_test.go +++ b/internal/compose/composed_test.go @@ -19,6 +19,7 @@ func fpFor(c byte) string { return meshcatalogclient.SourcePrefix2 + strings.Rep // to: every resource once, each in its module's composition at the fingerprint given, the module's ownership said on // it; a module given no fingerprint is named as skipped and composed nowhere. func TestCompositionsAreTheDeclarationSplitByModule(t *testing.T) { + t.Run("a held tool runner keeps its program for the modules of their own account", aHeldToolRunnerKeepsItsProgramForTheModulesOfTheirOwnAccount) in := aSmallMesh(t) d, _, err := Compose(in, "laptop") if err != nil { @@ -191,3 +192,54 @@ func TestCompositionsAreTheDeclarationSplitByModule(t *testing.T) { } } } + +// lead-47 2026-11-16: a held tool runner keeps the program it runs (Carried, runningProgram) after what the runtime serves +// is laid on the stubs (Node.RunsTools), so a module of its own account on its node is run by that program, not held +// "the tool runner is not here to run it from" (novox, the new indexer). +func aHeldToolRunnerKeepsItsProgramForTheModulesOfTheirOwnAccount(t *testing.T) { + dg := "sha256:" + strings.Repeat("d", 64) + source := catalogue.ArtifactStoreScheme + "node-tools/runtime/blobs/" + dg + runtime := catalogue.Manifest{Module: "node-tools", Version: "1", ToolRunner: true, + OwnSecrets: catalogue.OwnSecrets{"broker": {Path: "/var/lib/mesh/node-tools/broker"}}} + own := catalogue.Manifest{Module: "mesh-self-check", Version: "1", RunsAs: "mesh-self-check", + OwnSecrets: catalogue.OwnSecrets{"broker": {Path: "/var/lib/mesh/mesh-self-check/broker", Taken: catalogue.TakenAtStart}}, + Bundles: []catalogue.Bundle{{Name: "tools", Source: catalogue.ArtifactStoreScheme + "mesh-self-check/tools/blobs/" + dg, + Digest: dg, Language: "go", Loads: []string{"mesh-self-check-tools"}}}} + store := catalogue.Manifest{Module: "artifacts", Version: "1", + Claims: []catalogue.Claim{{Name: "container-image-registry", Scope: catalogue.ScopeMesh}}, + Listens: []catalogue.Listening{{Name: "registry", Port: 5100, From: catalogue.FromMesh}}} + runs := engcomp.Composed{Node: "anchor", Module: "node-tools", Resources: []json.RawMessage{json.RawMessage( + `{"id":"node-tools.runtime","module":"node-tools","type":"process","name":"node-tools","source":"` + source + + `","digest":"` + dg + `","run":["./node-tools"],"env":{"MESH_TOOL_MODULES":""}}`)}} + in := aMesh(t) + in.Catalogue["node-tools"], in.Catalogue["artifacts"], in.Catalogue["mesh-self-check"] = runtime, store, own + anchor := nodeOf(t, &in, "anchor") + anchor.Assigned = append(anchor.Assigned, "artifacts", "node-tools", "mesh-self-check") + in.BusMinted = []string{"anchor.node-tools", "anchor.mesh-self-check"} + anchor.SealingKey = keyOf(t, "anchor") + anchor.Held = map[string]bool{"node-tools": true} + anchor.Kept = map[string]catalogue.Manifest{"node-tools": Carried(runtime, "node-tools", &runs)} + anchor.RunsTools = ToolsRunning([]engcomp.Composed{runs}) + fps := map[string]string{overlay.Name: fpFor('a'), "artifacts": fpFor('5'), "node-tools": fpFor('e'), "mesh-self-check": fpFor('6')} + out, _, _, err := CompositionsIn(in, "anchor", fps, Foreseeing) + if err != nil { + t.Fatalf("a module of its own account beside a held tool runner: %v", err) + } + ran := false + for _, c := range out { + for _, raw := range c.Resources { + var r struct { + Type string `json:"type"` + Digest string `json:"digest"` + Run []string `json:"run"` + User string `json:"user"` + } + if json.Unmarshal(raw, &r) == nil && r.Type == "process" && r.User == "mesh-self-check" { + ran = r.Digest == dg && len(r.Run) == 1 && r.Run[0] == "./node-tools" + } + } + } + if !ran { + t.Errorf("mesh-self-check is not run by the program node-tools runs: %v", out) + } +} diff --git a/internal/compose/frombus/answer.go b/internal/compose/frombus/answer.go index 9e0ecb9d..660d5c7f 100644 --- a/internal/compose/frombus/answer.go +++ b/internal/compose/frombus/answer.go @@ -141,6 +141,45 @@ func Answer(ctx context.Context, r Reader, mesh Mesh, s Scope, fps map[string]st a.Differs = slices.DeleteFunc(cmp.Differs, func(d nodeengine.CandidateDiffers) bool { return !notFailed(d.Module) }) cmp.Added = slices.DeleteFunc(cmp.Added, func(d nodeengine.CandidateAdded) bool { return !notFailed(d.Module) }) skipped = slices.DeleteFunc(skipped, func(m string) bool { return !notFailed(m) }) + // A module the node runs and an assignment names, but that no build can be given to compose at (what runs of it carries + // no fingerprint, it having started before the node-engine wrote them, and the declaration gives none), is held: kept as + // it runs, said as held with why, never removed and never stopped for it. Only a module no assignment names is removed + // (A-410). + for _, m := range skipped { + if !runs[m] { + continue + } + a.Removed = slices.DeleteFunc(a.Removed, func(x string) bool { return x == m }) + a.Held = append(a.Held, nodeengine.CandidateRefusal{Module: m, + Why: "what runs of " + m + " has no fingerprint and none is given to compose it at, so it is kept as it runs", + Today: "running, kept as it runs"}) + } + skipped = slices.DeleteFunc(skipped, func(m string) bool { return runs[m] }) + // And whatever the candidate's assignment of this node names that runs and was composed to nothing for any other reason + // (the module is in no catalogue the composition reads, so it has no resources and is not even skipped): held the same + // way. Only a module no assignment names is removed (A-410). + placedHere := map[string]bool{} + if p, given := s.Assignments[s.Node]; given && p != nil { + for _, m := range p.Modules { + placedHere[m.Module] = true + } + } else if !given { + for _, m := range trunk[s.Node].Modules { + placedHere[m.Module] = true + } + } + a.Removed = slices.DeleteFunc(a.Removed, func(m string) bool { + if !placedHere[m] { + return false + } + a.Held = append(a.Held, nodeengine.CandidateRefusal{Module: m, + Why: "the assignment names " + m + " on this node, and the composition made nothing of it, so it is kept as it runs", + Today: "running, kept as it runs"}) + return true + }) + if len(a.Removed) == 0 { + a.Removed = nil + } // What the proposal adds, by node and module: placed by a candidate and not by the trunk on that node. added := map[string]bool{} diff --git a/internal/compose/frombus/answer_rows_test.go b/internal/compose/frombus/answer_rows_test.go index fb0e77a7..de6fd3e6 100644 --- a/internal/compose/frombus/answer_rows_test.go +++ b/internal/compose/frombus/answer_rows_test.go @@ -12,6 +12,7 @@ import ( "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" engcomp "github.com/novox/mesh-host/internal/compositions" + "maps" "os" "reflect" "slices" @@ -193,6 +194,47 @@ func answerNamesEveryRefusalAndLeavesAnOldBuildToTheNode(t *testing.T) { if a = Answer(ctx, b, Mesh{}, Scope{Node: "n1", Assignments: given(b), InOwn: []string{"spiegel"}}, fps, withMembership, "p-h1", 3); a.Verdict != nodeengine.CandidateAnswerVerdictSame { t.Errorf("the node's own with its bus membership is answered %+v, want the same", a) } + // (C) A module the node runs and an assignment names, given no fingerprint to compose at (it started before the node + // wrote them): held as it runs, never removed (A-410). One no assignment names is removed. + noFp := maps.Clone(fps) + delete(noFp, "lemurs") + unmarked := make([]engcomp.Composed, 0, len(running)) + for _, c := range running { + if c.Module == "lemurs" { + c.FP = "" + } + unmarked = append(unmarked, c) + } + unmarked = append(unmarked, engcomp.Composed{Node: "n1", Module: "gone", FP: fp("1")}) + a = Answer(ctx, b, Mesh{}, Scope{Node: "n1", Assignments: given(b), InOwn: []string{"spiegel"}}, noFp, unmarked, "p-h1", 3) + if !reflect.DeepEqual(a.Removed, []string{"gone"}) { + t.Errorf("removed %v, want only the module no assignment names", a.Removed) + } + heldIt := false + for _, h := range a.Held { + heldIt = heldIt || h.Module == "lemurs" && h.Why != "" + } + if !heldIt || len(a.Added) != 0 { + t.Errorf("a running module with no fingerprint is answered held %+v added %+v, want held with why and not added", a.Held, a.Added) + } + // (D) One the assignment names whose manifest says its name alone (no resources: what stands in for a module whose entry + // is not held) composes to nothing, and is not even skipped: held too, not removed (A-410). + nameOnly := []byte(`{"module":"ghost","version":"0"}`) + ghostDigest := meshcatalogclient.ManifestDigest(nameOnly) + b.manifests[ghostDigest] = nameOnly + b.modules["ghost"] = meshcatalog.ModulesByModuleValue{Manifest: ghostDigest} + pGhost := b.assignments["n1"] + trunkMods := pGhost.Modules + pGhost.Modules = append(append([]meshmoduleassigner.PlacedModule{}, trunkMods...), meshmoduleassigner.PlacedModule{Module: "ghost"}) + b.assignments["n1"] = pGhost + ghostRuns := append(append([]engcomp.Composed{}, unmarked...), engcomp.Composed{Node: "n1", Module: "ghost", FP: fp("2")}) + a = Answer(ctx, b, Mesh{}, Scope{Node: "n1", Assignments: given(b), InOwn: []string{"spiegel"}}, noFp, ghostRuns, "p-h1", 3) + if !reflect.DeepEqual(a.Removed, []string{"gone"}) || !slices.ContainsFunc(a.Held, func(h nodeengine.CandidateRefusal) bool { return h.Module == "ghost" }) { + t.Errorf("a named module the composition made nothing of: removed %v held %+v, want it held and only gone removed (%.600s)", a.Removed, a.Held, fmt.Sprintf("%+v", a)) + } + pGhost.Modules = trunkMods + b.assignments["n1"] = pGhost + delete(b.modules, "ghost") // Without what runs, the fold composes spiegel from its manifest, as before, and the composition refuses it. if _, _, held, err := Compose(ctx, b, Mesh{}, Scope{Node: "n1", InOwn: []string{"spiegel"}}, fps); err != nil || !strings.Contains(held["spiegel"], "spiegel has not been built for this mesh") { diff --git a/internal/compose/frombus/frombus.go b/internal/compose/frombus/frombus.go index 5c85ada0..2cc0868d 100644 --- a/internal/compose/frombus/frombus.go +++ b/internal/compose/frombus/frombus.go @@ -271,6 +271,11 @@ func taken(name string, raw []byte, m meshcatalog.ModulesByModuleValue) (man cat func input(ctx context.Context, r Reader, mesh Mesh, s Scope, refuse func(module string, err error), wanted map[string]string) (compose.Input, error) { b, err := readBase(ctx, r, mesh, s) b.refuseOwn(refuse) + // The engine is named from the catalogue the base read, before the rest of the input, so a node whose input fails + // still serves its seat (root-free): live on novox 2026-11-14 no pass ended, so the seat was never served (A-403). + if s.Engine != nil && len(b.in.Catalogue) > 0 { + s.Engine(EngineModule(b.in, s.Node, s.OwnFingerprint)) + } if err != nil { return compose.Input{}, err } diff --git a/internal/link/engineseat.go b/internal/link/engineseat.go index d49d8d02..5551322f 100644 --- a/internal/link/engineseat.go +++ b/internal/link/engineseat.go @@ -7,6 +7,7 @@ import ( "encoding/json" "errors" "fmt" + "log" "sort" "strings" "time" @@ -14,6 +15,7 @@ import ( "git.novox.be/novox/mesh-contracts/go/seats/nodeengine" oc "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel" stdio "git.novox.be/novox/mesh-sdk/go" + "git.novox.be/novox/mesh-sdk/go/buscalls" "git.novox.be/novox/mesh-sdk/go/busretry" "git.novox.be/novox/mesh-sdk/go/catalogue" "git.novox.be/novox/mesh-sdk/go/seatlist" @@ -52,6 +54,9 @@ type EngineCall struct { Verb string Caller string Args map[string]any + // Line is the link's bus connection, which a verb marked chunks sends its answer's file on (buscalls.SeatChunks.Send); nil + // where the call did not come over a live link. + Line buscalls.ChunkLine } // EngineFunc answers one call: its result, or why it is refused. @@ -157,12 +162,17 @@ func (l *natsLink) serveEngineSeat(handle EngineFunc, module string) { Description: "the node seat node-engine of " + l.node + " (novox/hq ADR 0563)", QueueGroupDisabled: true, Metadata: map[string]string{"seat": EngineSeat, "scope": "node", "node": l.node}}) if err != nil { + log.Printf("the node seat %s of %s is not served: %v (A-405)", EngineSeat, l.node, err) return } apart := make(chan struct{}, apartAtOnce) + withLine := func(c EngineCall) (any, error) { + c.Line = l.conn // a verb marked chunks sends its file on the link's own connection + return handle(c) + } for _, v := range ServedEngineSeat().Serves { verb := v.Name - answer := EngineAnswer(handle, verb, l.node, apart) + answer := EngineAnswer(withLine, verb, l.node, apart) meta := EngineEndpointMetadata(v, l.node, module) _ = svc.AddEndpoint(verb, answer, micro.WithEndpointSubject(EngineToolSubject(verb, l.node)), micro.WithEndpointMetadata(meta)) @@ -172,6 +182,7 @@ func (l *natsLink) serveEngineSeat(handle EngineFunc, module string) { l.engineMu.Lock() l.engine = svc l.engineMu.Unlock() + log.Printf("the node seat %s of %s is served as %s (A-405)", EngineSeat, l.node, module) } // answeredApart are the verbs answered off the subscription that delivered them: each endpoint's subscription hands its diff --git a/internal/link/handacts.go b/internal/link/handacts.go index 83ae1106..a083f638 100644 --- a/internal/link/handacts.go +++ b/internal/link/handacts.go @@ -8,6 +8,7 @@ import ( "encoding/json" "errors" "fmt" + "git.novox.be/novox/mesh-sdk/go/buscalls" sdkkeys "git.novox.be/novox/mesh-sdk/go/keys" "sort" "strconv" @@ -175,7 +176,8 @@ type HandActs struct { // ComposeCandidate composes a check's candidate (the indexer's candidate key) on this node in shadow and answers per // module, applying and writing nothing; with input, also the composition input it composed from (the verb // compose-candidate, ADR 0593 §7). - ComposeCandidate func(candidate string, input bool) (any, error) + // call is the caller's token for the chunks the input is sent in (A-237b) and line the connection they go on; with no token the input is inline. + ComposeCandidate func(candidate string, input bool, call string, line buscalls.ChunkLine) (any, error) // ManifestReads is what this engine states it reads of a manifest and when its record last carried them (the verb // manifest-reads, novox/hq ADR 0618 §3). ManifestReads func() ([]string, time.Time) @@ -289,7 +291,7 @@ func (h *HandActs) Call(c EngineCall) (any, error) { if b, ok := c.Args["input"].(bool); ok { input = b } - return h.ComposeCandidate(arg("candidate"), input) + return h.ComposeCandidate(arg("candidate"), input, arg("call"), c.Line) case ActManifestReads: if h.ManifestReads == nil { return nil, errors.New("this engine states no manifest reads yet: its node agent has not started") diff --git a/internal/selfcompose/candidate.go b/internal/selfcompose/candidate.go index 643bed97..42edf498 100644 --- a/internal/selfcompose/candidate.go +++ b/internal/selfcompose/candidate.go @@ -9,11 +9,14 @@ import ( "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants" + "git.novox.be/novox/mesh-sdk/go/buscalls" + "git.novox.be/novox/mesh-sdk/go/keys" "github.com/novox/mesh-host/internal/buckets" engcomp "github.com/novox/mesh-host/internal/compositions" "maps" "slices" "sort" + "strings" "sync" "time" @@ -143,13 +146,7 @@ func (s *Shadow) composeCandidate(ctx context.Context, c *Composer, ask nodeengi a.Verdict = nec.Unready return a } - group, heads, err := nec.ParseCompositionKey(ask.Candidate) - if err != nil { - return refuse(err.Error()) - } - // The ask names the check (the composition key, `.`); the indexer keys the group's candidate by - // the group alone (buckets.CandidateKey) and holds its heads hash in the value. - ckey, err := buckets.CandidateKey(group) + key, err := nec.ParseCandidateKey(ask.Candidate) if err != nil { return refuse(err.Error()) } @@ -157,21 +154,48 @@ func (s *Shadow) composeCandidate(ctx context.Context, c *Composer, ask nodeengi return unready(errNotReady.Error()) } base := run.add(c.scratch()) - raw, err := base.get(ctx, buckets.Candidates, ckey) - if err != nil { - return unready(fmt.Sprintf("the indexer's candidate %s cannot be read: %v", ask.Candidate, err)) - } - if raw == nil { - return refuse("the indexer holds no candidate " + ask.Candidate) - } - cand, err := meshcatalog.DecodeCandidatesByGroupValue(raw) - if err != nil { - return refuse(fmt.Sprintf("the indexer's candidate %s cannot be read: %v", ask.Candidate, err)) - } - if cand.Heads != heads { - // The group moved to other heads: the check asked is replaced, and this node composes not a candidate it was - // not asked about. No answer (ADR 0593 §9), never a verdict on the wrong heads. - return unready(fmt.Sprintf("the indexer's candidate of the group %s is at heads %s, not %s: the check asked is replaced", group, cand.Heads, heads)) + var cand meshcatalog.CandidatesByGroupValue + var group, heads string + if key.Kind == nec.CandidateRevision { + // A branch pipeline's catalog graph revision (A-226b): its entries are read through the seat mesh-catalog's verb + // revision and composed as the candidate, each module at the revision's fingerprint. + var answered bool + cand, answered, err = s.revisionCandidate(ctx, base, key) + if err != nil { + return unready(err.Error()) + } + if !answered { + return refuse(fmt.Sprintf("the catalog holds no revision %d of the branch %s", key.Revision, key.Branch)) + } + } else { + group, heads = key.Group, key.HeadsHash + if key.Kind == nec.CandidateRun { + // A run on request's candidate is the indexer's `candidates.run-`, read by its group as a check's is, with no + // heads to compare: the run is asked for by its id alone (A-226c). + group, heads = "run-"+key.Run, "" + } + // The ask names the check (the composition key, `.`); the indexer keys the group's candidate by + // the group alone (buckets.CandidateKey) and holds its heads hash in the value. + ckey, err := buckets.CandidateKey(group) + if err != nil { + return refuse(err.Error()) + } + raw, err := base.get(ctx, buckets.Candidates, ckey) + if err != nil { + return unready(fmt.Sprintf("the indexer's candidate %s cannot be read: %v", ask.Candidate, err)) + } + if raw == nil { + return refuse("the indexer holds no candidate " + ask.Candidate) + } + cand, err = meshcatalog.DecodeCandidatesByGroupValue(raw) + if err != nil { + return refuse(fmt.Sprintf("the indexer's candidate %s cannot be read: %v", ask.Candidate, err)) + } + if key.Kind == nec.CandidateCheck && cand.Heads != heads { + // The group moved to other heads: the check asked is replaced, and this node composes not a candidate it was + // not asked about. No answer (ADR 0593 §9), never a verdict on the wrong heads. + return unready(fmt.Sprintf("the indexer's candidate of the group %s is at heads %s, not %s: the check asked is replaced", group, cand.Heads, heads)) + } } // Every module's manifest is read before either composition, several at once, into the shadow's own: a composition // reads every manifest in the mesh one by one, which off the control-node took about 35 s each (issue 1126). @@ -214,7 +238,9 @@ func (s *Shadow) composeCandidate(ctx context.Context, c *Composer, ask nodeengi } } }) - if sentSize > maxSentInput { + // An ask with a call token takes the input in chunks, whatever its size (A-237b); one with none is the checker's, answered + // inline until G removes the checker (G-6 §321, A-237c), so past what the bus carries in one answer it is refused. + if sentSize > maxSentInput && ask.Call == "" { // Past what the bus carries in one answer, the checker would hear nothing: refused, saying so. size := sentSize a.Input = nil @@ -481,3 +507,71 @@ func (c *Composer) composeShadow(ctx context.Context, running []engcomp.Composed // candidateNoneNoModule is the words the indexer writes in a candidate's module that the merge preview names no manifest // for: the change removes the module. It is the indexer's text, kept here until the catalogue client names it. const candidateNoneNoModule = "the merge preview names no manifest for the module's directory" + +// revisionCandidate reads the catalog graph revision key names, whole, page by page, through the seat mesh-catalog's verb +// revision (the Entry call, the engine's own name), and makes the candidate it composes as: one pull per repository and +// commit with each module's fingerprint and manifest digest, and a module the base holds that the revision does not marked as +// removed. answered is false when the catalog holds no such revision. +func (s *Shadow) revisionCandidate(ctx context.Context, base *Composer, key nec.Candidate) (cand meshcatalog.CandidatesByGroupValue, answered bool, err error) { + call := base.env.Entry + if call == nil { + return cand, false, errors.New("this node's engine cannot ask the catalog for a revision") + } + in := meshcatalog.RevisionInput{Branch: keys.EscapeName(key.Branch), Revision: key.Revision} + type group struct{ repository, commit string } + pulls := map[group]map[string]meshcatalog.CandidatesByGroupValuePullsItemFpsValue{} + seen := map[string]bool{} + for { + raw, err := call(meshcatalogclient.RevisionVerb, in) + if err != nil { + return cand, false, fmt.Errorf("the catalog's revision %d of %s cannot be read: %w", key.Revision, key.Branch, err) + } + body, said, ok := buscalls.Unwrap(raw) + if !ok { + return cand, false, fmt.Errorf("the catalog's revision %d of %s cannot be read: %s", key.Revision, key.Branch, said) + } + var a meshcatalog.RevisionAnswer + if err := json.Unmarshal(body, &a); err != nil { + return cand, false, fmt.Errorf("the catalog's revision %d of %s is not a revision answer: %w", key.Revision, key.Branch, err) + } + if a.NoneYet || a.Revision == nil || a.Revision.Revision != key.Revision { + return cand, false, nil + } + for _, e := range a.Entries { + seen[e.Module] = true + if e.Fp == "" { + continue // no build at the revision: composed as the trunk holds it + } + g := group{e.Repository, e.Commit} + if pulls[g] == nil { + pulls[g] = map[string]meshcatalog.CandidatesByGroupValuePullsItemFpsValue{} + } + // The catalog entry's manifest-digest is the `sha256:`-prefixed form (the seat's definition, entryManifest); a candidate's + // module and the manifests and verdicts keys carry the 64 hex digits alone (ADR 0429 clause 16, meshcatalogclient). + pulls[g][e.Module] = meshcatalog.CandidatesByGroupValuePullsItemFpsValue{Fp2: e.Fp, Manifest: strings.TrimPrefix(e.ManifestDigest, "sha256:")} + } + if a.Next == "" { + break + } + in.After = a.Next + } + removed := map[string]meshcatalog.CandidatesByGroupValuePullsItemFpsValue{} + base.mu.Lock() + for module := range base.modules { + if !seen[module] { + removed[module] = meshcatalog.CandidatesByGroupValuePullsItemFpsValue{None2: candidateNoneNoModule} + } + } + base.mu.Unlock() + cand.Group = key.Branch + for g, fps := range pulls { + cand.Pulls = append(cand.Pulls, meshcatalog.CandidatesByGroupValuePullsItem{Repository: g.repository, Head: g.commit, Fps: fps}) + } + sort.Slice(cand.Pulls, func(i, j int) bool { + return cand.Pulls[i].Repository+cand.Pulls[i].Head < cand.Pulls[j].Repository+cand.Pulls[j].Head + }) + if len(removed) > 0 { + cand.Pulls = append(cand.Pulls, meshcatalog.CandidatesByGroupValuePullsItem{Fps: removed}) + } + return cand, true, nil +} diff --git a/internal/selfcompose/candidate_test.go b/internal/selfcompose/candidate_test.go index dcebd22f..84bde8f3 100644 --- a/internal/selfcompose/candidate_test.go +++ b/internal/selfcompose/candidate_test.go @@ -85,7 +85,18 @@ func TestTheNodeComposesACandidateOnAsk(t *testing.T) { t.Fatal(err) } entry := meshcatalog.CatalogEntry{Module: "lemurs", Fp: fp, Manifest: manifest, Repository: "novox/x", Commit: "c", ManifestDigest: digest} - env.Entry = EntryCall(func(_ context.Context, _, _ string, _ any) (json.RawMessage, error) { + // A-226b: the revision a branch pipeline names is read through the verb revision: revision 362 of main holds lemurs at its + // new build and manifest; no other revision is held. + env.Entry = EntryCall(func(_ context.Context, _, verb string, args any) (json.RawMessage, error) { + if verb == meshcatalog.VerbRevision { + in, _ := args.(meshcatalog.RevisionInput) + if in.Revision != 362 || in.Branch != "main" { + return json.Marshal(meshcatalog.RevisionAnswer{NoneYet: true}) + } + moved := entry + moved.Fp, moved.ManifestDigest = fpNew, "sha256:"+digest2 // the entry carries the prefixed form + return json.Marshal(meshcatalog.RevisionAnswer{Revision: &meshcatalog.CatalogRevision{Branch: "main", Revision: 362}, Entries: []meshcatalog.CatalogEntry{moved}}) + } return json.Marshal(meshcatalog.EntryAnswer{Entry: entry}) }) var handed atomic.Int64 @@ -141,6 +152,27 @@ func TestTheNodeComposesACandidateOnAsk(t *testing.T) { if _, err := nec.EncodeAnswer(r); err != nil { t.Errorf("the refused answer does not fit the seat's shape: %v", err) } + // A-226b: a branch pipeline's revision composes as the candidate, each module at the revision's build; one the catalog does + // not hold, and a run on request's key, are refused in words. + revKey, _ := nec.RevisionKey("main", 362) + rv := s.ComposeCandidate(ctx, nodeengine.ComposeCandidateInput{Candidate: revKey}) + if rv.Verdict != nec.Composed || len(rv.Modules) != 1 || rv.Modules[0].Fp != fpNew || !rv.Modules[0].Changed { + t.Errorf("a catalog revision answered %+v", rv) + } + noRev, _ := nec.RevisionKey("main", 999) + if m := s.ComposeCandidate(ctx, nodeengine.ComposeCandidateInput{Candidate: noRev}); m.Verdict != nec.Refused || !strings.Contains(m.Refused, "holds no revision 999") { + t.Errorf("a revision the catalog does not hold answered %+v", m) + } + // A-226c: a run's key reads the indexer's candidates.run- by its group, with no heads compared; one it holds none of is refused. + candidateOf("run-r1", digest2) + runKey, _ := nec.RunKey("r1") + if m := s.ComposeCandidate(ctx, nodeengine.ComposeCandidateInput{Candidate: runKey}); m.Verdict != nec.Composed || len(m.Modules) != 1 || m.Modules[0].Fp != fpNew || !m.Modules[0].Changed { + t.Errorf("a run's key answered %+v", m) + } + noRun, _ := nec.RunKey("r2") + if m := s.ComposeCandidate(ctx, nodeengine.ComposeCandidateInput{Candidate: noRun}); m.Verdict != nec.Refused || !strings.Contains(m.Refused, "holds no candidate") { + t.Errorf("a run the indexer holds none of answered %+v", m) + } missing, _ := nec.CompositionKey("novox/x#8", "0123456789ab") if m := s.ComposeCandidate(ctx, nodeengine.ComposeCandidateInput{Candidate: missing}); !strings.Contains(m.Refused, "holds no candidate") { t.Errorf("a candidate the indexer does not hold answered %+v", m) diff --git a/internal/selfcompose/entries.go b/internal/selfcompose/entries.go index 0af82b00..5e6f25a4 100644 --- a/internal/selfcompose/entries.go +++ b/internal/selfcompose/entries.go @@ -228,6 +228,12 @@ func (c *Composer) wantedBuilds() map[string]bool { if module != agent.NodeModule && strings.HasPrefix(w.Fp, meshcatalogclient.SourcePrefix2) { out[w.Fp] = true } + // The build its want says is being built describes, for resolution alone, a module whose wanted build has no entry (A-405, A-407). + if module != agent.NodeModule && strings.HasPrefix(w.Newest, meshcatalogclient.SourcePrefix2) { + if _, named := out[w.Newest]; !named { + out[w.Newest] = false + } + } } for _, mods := range c.heard { for _, run := range mods { @@ -309,6 +315,12 @@ func (c *Composer) syncEntries(ctx context.Context) { // layModules lays c.modules and c.manifests from the entries held: what each node was heard to run first, then each module this // node's want names, at the want's fingerprint (a want wins). func (c *Composer) layModules() { + var said []string + defer func() { + for _, line := range said { + c.sayOnceEach(line) + } + }() c.mu.Lock() defer c.mu.Unlock() modules := map[string]meshcatalog.ModulesByModuleValue{} @@ -343,9 +355,26 @@ func (c *Composer) layModules() { } } for module, w := range c.wants { - if module != agent.NodeModule && w.Fp != "" { - lay(module, w.Fp) + if module == agent.NodeModule || w.Fp == "" { + continue } + if k, ok := c.keptEnt[w.Fp]; ok && k.entry.Module != "" { + lay(module, w.Fp) + continue + } + // A module the node runs whose wanted build has no entry stands as the build its want says is being built, for resolution + // alone: what that entry provides, claims and requires stands for the running build. Its want stays held (entryHolds), at + // the want's fingerprint, and nothing new of it is composed (A-405, A-407). + if k, ok := c.keptEnt[w.Newest]; ok && w.Newest != "" && k.entry.Module != "" && c.runsHere(module) { + lay(module, w.Newest) + if m, laid := modules[module]; laid { + m.Fp2 = w.Fp + modules[module] = m + said = append(said, fmt.Sprintf("%s runs a build whose entry the catalog half does not hold, so the node resolves around it as the build %s its want says is being built; its want stays held", module, w.Newest)) + } + continue + } + lay(module, w.Fp) } // A module an assignment places whose entry is not held (not wanted here, not heard running, or its entry asked and not // answered) stands in the catalogue as its name alone, so the placement still finds it: a module held for its entry offers @@ -404,7 +433,7 @@ func (c *Composer) entryHolds() map[string]string { out[module] = fmt.Sprintf("%s the catalog half holds no entry of the build %s, so the node composes nothing new of %s", agent.EntryMissing, w.Fp, module) default: - if missing := partsMissing(e, w); missing != "" { + if _, missing := c.partsOf(module, e, w); missing != "" { out[module] = fmt.Sprintf("the want of %s names no digest for %s, so the node composes nothing new of it", module, missing) } } @@ -412,19 +441,7 @@ func (c *Composer) entryHolds() map[string]string { return out } -// partsMissing names the artifacts of e whose digest w's parts do not give; "" when each has one. -func partsMissing(e meshcatalog.CatalogEntry, w meshwants.WantsByWantNodeModuleValue) string { - var out []string - for _, a := range e.Artifacts { - if w.Parts[a.Ref] == "" { - out = append(out, a.Ref) - } - } - sort.Strings(out) - return strings.Join(out, ", ") -} - -// referenceOf is an artifact's reference made from the digest its want's part names, in the form the artifact store is +// referenceOf is an artifact's reference made from the digest its want's part names, or its version resolves (A-430a), in the form the artifact store is // addressed by (the lead's answer A-50): artifact-store:////blobs/. func referenceOf(module, artifact, digest string) string { return "artifact-store://" + module + "/" + artifact + "/blobs/" + digest @@ -439,7 +456,11 @@ func (c *Composer) buildOf(module, fp string) *builds.BuilderBuild { w, wanted := c.wants[module] k, ok := c.keptEnt[fp] c.mu.Unlock() - if !wanted || w.Fp != fp || !ok || partsMissing(k.entry, w) != "" { + if !wanted || w.Fp != fp || !ok { + return nil + } + parts, missing := c.partsOf(module, k.entry, w) + if missing != "" { return nil } digest, raw, err := entryManifest(k.entry) @@ -452,7 +473,7 @@ func (c *Composer) buildOf(module, fp string) *builds.BuilderBuild { b := builds.BuilderBuild{State: builds.BuildDone, Manifest: digest} for _, a := range k.entry.Artifacts { _, name, _ := strings.Cut(a.Ref, ":") - digest := w.Parts[a.Ref] + digest := parts[a.Ref] b.Artifacts = append(b.Artifacts, builds.BuiltArtifact{Name: name, Kind: a.Kind, Digest: digest, Reference: referenceOf(module, name, digest)}) } @@ -651,3 +672,19 @@ func (c *Composer) askBuildsEntries(fps map[string]string) (pending string) { } return pending } + +// runsHere says whether this node runs the module: heard to, or in what the node runs now (c.mu held; env.Running reads the +// agent's own record). +func (c *Composer) runsHere(module string) bool { + if run, ok := c.heard[c.env.Node][module]; ok && !run.stopped { + return true + } + if c.env.Running != nil { + for _, r := range c.env.Running() { + if r.Module == module { + return true + } + } + } + return false +} diff --git a/internal/selfcompose/entries_test.go b/internal/selfcompose/entries_test.go index 6045d43f..f22da6c9 100644 --- a/internal/selfcompose/entries_test.go +++ b/internal/selfcompose/entries_test.go @@ -259,3 +259,55 @@ func (c *Composer) holdEntry(t *testing.T, module, fp, body string) { } c.keptEnt[fp] = keptEntry{entry: half[fp]} } + +// A-405, A-407: a module the node runs whose wanted build has no entry stands, for resolution alone, as the build its want says +// is being built, at the want's fingerprint, so its want stays held; one not running here, or whose want names no newer build the +// half holds, stands as its name alone. +func runningModuleWithoutEntryStandsAsTheNewestBuild(t *testing.T) { + old := meshcatalogclient.SourcePrefix2 + strings.Repeat("1", 64) + newest := meshcatalogclient.SourcePrefix2 + strings.Repeat("2", 64) + body := `{"module":"postgres","version":"2"}` + for _, tc := range []struct { + name string + runs bool + newest string + holds bool + laid bool + wantFp string + }{ + {"runs, newest entry held", true, newest, true, true, old}, + {"not running here", false, newest, true, false, old}, + {"names no newer build", true, "", false, false, old}, + {"newest entry not held", true, newest, false, false, old}, + } { + t.Run(tc.name, func(t *testing.T) { + env := newFakeBus().env() + env.Node = "n1" + c := New(env) + c.mu.Lock() + c.wants["postgres"] = meshwants.WantsByWantNodeModuleValue{Fp: old, Newest: tc.newest} + c.assignments["n1"] = meshmoduleassigner.Assignments{Node: "n1", Modules: []meshmoduleassigner.PlacedModule{{Module: "postgres"}}} + if tc.runs { + c.heard = map[string]map[string]heardRun{"n1": {"postgres": {fingerprint: old}}} + } + c.mu.Unlock() + if tc.holds { + c.holdEntry(t, "postgres", newest, body) + } + if got := c.wantedBuilds()[newest]; tc.newest != "" && got { + t.Errorf("the newest build is named by a want, want only asked") + } + c.layModules() + c.mu.Lock() + m, ok := c.modules["postgres"] + raw := c.manifests[m.Manifest] + c.mu.Unlock() + if !ok || m.Fp2 != tc.wantFp { + t.Fatalf("modules[postgres] = %+v (%v), want fingerprint %s", m, ok, tc.wantFp) + } + if got := strings.Contains(string(raw), `"version":"2"`); got != tc.laid { + t.Errorf("manifest of the newest build laid = %v, want %v (%s)", got, tc.laid, raw) + } + }) + } +} diff --git a/internal/selfcompose/kept.go b/internal/selfcompose/kept.go index 52abee8c..9e3daa7a 100644 --- a/internal/selfcompose/kept.go +++ b/internal/selfcompose/kept.go @@ -16,9 +16,20 @@ func (c *Composer) KeptBuildOf(_ context.Context, module, digest string) (node, if !ok || w.Fp == "" || w.KeptOn == "" { return "", "", false, nil } - if len(w.Parts) > 0 { + parts := w.Parts + if len(parts) == 0 && w.Version != "" { + // A want naming its version names its digests through the registry seats (A-430a): the resolution the composing made. + c.mu.Lock() + r := c.resolved[resolvedKey{module, w.Fp, w.Version}] + c.mu.Unlock() + if r.parts == nil { + return "", "", false, nil + } + parts = r.parts + } + if len(parts) > 0 { named := false - for _, d := range w.Parts { + for _, d := range parts { if strings.TrimPrefix(d, "sha256:") == strings.TrimPrefix(digest, "sha256:") { named = true } diff --git a/internal/selfcompose/selfcompose.go b/internal/selfcompose/selfcompose.go index d8a65be1..7a12747d 100644 --- a/internal/selfcompose/selfcompose.go +++ b/internal/selfcompose/selfcompose.go @@ -136,6 +136,9 @@ type Env struct { // Set, the composer reads the catalog half by the fingerprints its wants and the runnings it heard name and nothing else of // the indexer's or the builder's states (design 47 G §421, §628); a composer is made with it. Entry meshcatalogclient.Call + // Registry asks the registry seats' verb versions (oci-artifact-registry, container-image-registry) in the engine's own + // name: a want naming its version is resolved to its artifacts' digests through it (design 47 G A-430a). + Registry meshcatalogclient.Call } // ManifestOf is the digest of the manifest of the build a module runs at fp, from the composer's picture of the catalog half; @@ -193,7 +196,9 @@ type Composer struct { entries *meshcatalogclient.Entries keptEnt map[string]keptEntry // notFound is each fingerprint whose entry-not-found the composer told, so it is told once and cleared once. - notFound map[string]bool + notFound map[string]bool + // resolved is each wanted build's digests as its version resolved them through the registry seats (versions.go, A-430a). + resolved map[resolvedKey]versionParts keptWantVal map[string]keptWant keptWants map[string]bool keptWrite sync.Mutex @@ -718,7 +723,9 @@ func (c *Composer) entry(bucket, key string) (v any, has, known bool) { defer c.mu.Unlock() switch bucket { case buckets.Wants: - // A want is composed by its fingerprint alone (fingerprints); its words, rule and newest change nothing composed. + // A want is composed by its fingerprint, version, parts and keeping node (design 47 G §525); its words, rule and newest + // change nothing composed. Judged by its fingerprint alone, a want that gained its parts at the same fingerprint asked no + // pass, and the agent waited for a composition never made (lead-47 2026-11-16, the indexer on novox). module := agent.NodeModule if _, ok := meshwants.ParseWantsByWantNodeNodeKey(key); !ok { node, m, ok := meshwants.ParseWantsByWantNodeModuleKey(key) @@ -728,7 +735,10 @@ func (c *Composer) entry(bucket, key string) (v any, has, known bool) { module = m } w, ok := c.wants[module] - return w.Fp, ok, true + return struct { + Fp, Version, KeptOn string + Parts map[string]string + }{w.Fp, w.Version, w.KeptOn, w.Parts}, ok, true case buckets.Assignments: // Any key of a node, its node key, a module key or its legacy key, stands for the node's whole assignment: a // module key written before its node key names it changes nothing composed. diff --git a/internal/selfcompose/selfcompose_test.go b/internal/selfcompose/selfcompose_test.go index 78830f34..aa32d999 100644 --- a/internal/selfcompose/selfcompose_test.go +++ b/internal/selfcompose/selfcompose_test.go @@ -158,6 +158,8 @@ func quiet(t *testing.T, out <-chan agent.Update) { // names any more is taken back; a node that cannot compose says so once and hands nothing. func TestTheNodeComposesItsWantsFromTheBus(t *testing.T) { t.Run("it reads the catalog half by the fingerprints its wants name", composeFromEntries) + t.Run("a running module without an entry stands as the newest build", runningModuleWithoutEntryStandsAsTheNewestBuild) + t.Run("a want naming its version is resolved through the registry seats", aWantNamingItsVersionIsResolvedThroughTheRegistrySeats) b := newFakeBus() fp := meshcatalogclient.SourcePrefix2 + strings.Repeat("a", 64) digest := meshcatalogclient.ManifestDigest([]byte(lemurs)) diff --git a/internal/selfcompose/shadow.go b/internal/selfcompose/shadow.go index 9c58e4c2..8fb993c5 100644 --- a/internal/selfcompose/shadow.go +++ b/internal/selfcompose/shadow.go @@ -630,7 +630,7 @@ func (s *Shadow) answerProposal(ctx context.Context, proposal string) (nodeengin } // The module is built from its entry and the parts the candidate gives (A-316); an artifact it gives no part for holds it. w := meshwants.WantsByWantNodeModuleValue{Fp: fp, Parts: own.c.Added[pm.Module].Parts, Version: own.c.Added[pm.Module].Version} - if missing := partsMissing(entry, w); missing != "" { + if _, missing := c.partsOf(pm.Module, entry, w); missing != "" { heldAdded[pm.Module] = fmt.Sprintf("the candidate gives no part for %s of %s's build %s, so the node composes nothing new of it", missing, pm.Module, fp) continue } diff --git a/internal/selfcompose/versions.go b/internal/selfcompose/versions.go new file mode 100644 index 00000000..80178265 --- /dev/null +++ b/internal/selfcompose/versions.go @@ -0,0 +1,217 @@ +package selfcompose + +import ( + "encoding/json" + "fmt" + "sort" + "strings" + "time" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/containerimageregistry" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/ociartifactregistry" + "git.novox.be/novox/mesh-sdk/go/buscalls" + "git.novox.be/novox/mesh-sdk/go/catalogue" +) + +// **A want names its version; the node-engine resolves the digests** (design 47 G A-430, A-430a, the lead's answer A-430b). +// A want of a released build names the module's version and no parts: each artifact of the build's entry is looked up at that +// version through the verb `versions` of the registry seat of its kind (oci-artifact-registry for a bundle or an archive, +// container-image-registry for an image), under the name the builder numbered it by: `/`, or the entry's +// package name for a package. An upstream copy is not numbered (it is mirrored by its pinned digest): its digest is the one its +// manifest's `from` pins. A want that names parts (a build no version is known of) is read by its parts as before. A lookup that +// fails is said in the journal, naming the module, the version and the seat, and the module is held whole: never composed partly. + +// resolveAgain is how long a failed lookup stands before it is asked again; a pass is asked then. +const resolveAgain = time.Minute + +// versionsVerb is the verb a lookup asks. +const versionsVerb = "versions" + +// resolvedKey names one resolution: a module's build at a version. +type resolvedKey struct{ module, fp, version string } + +// versionParts is a module's build at a version as resolved: its digests by artifact reference, or why not, and when that was found. +type versionParts struct { + parts map[string]string + failed string + at time.Time +} + +// registryVersions is the answer of either seat's verb `versions`: the two seats answer the same shape. +type registryVersions struct { + Versions []struct { + Digest string `json:"digest"` + Tag string `json:"tag,omitempty"` + Version string `json:"version,omitempty"` + } `json:"versions"` +} + +// seatOfKind is the registry seat an artifact of kind is numbered in, and whether one is (design 51 *The seats*). +func seatOfKind(kind string) (string, bool) { + switch kind { + case catalogue.ArtifactImage: + return containerimageregistry.Seat, true + case catalogue.ArtifactBundle, catalogue.ArtifactArchive: + return ociartifactregistry.Seat, true + } + return "", false +} + +// registryName is the name an artifact of module is numbered under: `/`, or a package's name in its +// ecosystem as the entry gives it. +func registryName(module string, a meshcatalog.Artifact) string { + _, artifact, _ := strings.Cut(a.Ref, ":") + if a.Kind == catalogue.ArtifactPackage && a.Package != nil && a.Package.Name != "" { + return a.Package.Name + } + return module + "/" + artifact +} + +// partsOf is the digest of each artifact of e for want w, by artifact reference, and the artifacts it names no digest for ("" when +// each has one). A want with parts gives them; a want with a version and no parts is resolved through the registry seats. +func (c *Composer) partsOf(module string, e meshcatalog.CatalogEntry, w meshwants.WantsByWantNodeModuleValue) (map[string]string, string) { + parts := w.Parts + if len(parts) == 0 && w.Version != "" && len(e.Artifacts) > 0 { + var why string + if parts, why = c.resolve(module, e, w); why != "" { + return nil, why + } + } + return parts, partsMissing(e, parts) +} + +// partsMissing names the artifacts of e whose digest parts does not give; "" when each has one. +func partsMissing(e meshcatalog.CatalogEntry, parts map[string]string) string { + var out []string + for _, a := range e.Artifacts { + if parts[a.Ref] == "" { + out = append(out, a.Ref) + } + } + sort.Strings(out) + return strings.Join(out, ", ") +} + +// resolve is the digests of module's build at w's version, from what is resolved already or asked of the seats now. why names +// what failed; a failure stands resolveAgain, then is asked again. +func (c *Composer) resolve(module string, e meshcatalog.CatalogEntry, w meshwants.WantsByWantNodeModuleValue) (map[string]string, string) { + key := resolvedKey{module, w.Fp, w.Version} + now := c.now() + c.mu.Lock() + r, ok := c.resolved[key] + c.mu.Unlock() + if ok && (r.failed == "" || now.Sub(r.at) < resolveAgain) { + return r.parts, r.failed + } + parts, failed := c.lookUp(module, e, w) + c.mu.Lock() + if c.resolved == nil { + c.resolved = map[resolvedKey]versionParts{} + } + // Only the resolutions of the builds a want names now are kept. + for k := range c.resolved { + if cur, wanted := c.wants[k.module]; k.module != module && (!wanted || cur.Fp != k.fp || cur.Version != k.version) { + delete(c.resolved, k) + } + } + c.resolved[key] = versionParts{parts: parts, failed: failed, at: now} + c.mu.Unlock() + if failed != "" { + time.AfterFunc(resolveAgain, c.askRehand) + return nil, failed + } + return parts, "" +} + +// lookUp asks each artifact's digest at w's version of the seat of its kind. Every failure is said, naming the module, the version +// and the seat; any failure resolves nothing of the build. +func (c *Composer) lookUp(module string, e meshcatalog.CatalogEntry, w meshwants.WantsByWantNodeModuleValue) (map[string]string, string) { + parts := map[string]string{} + var failed []string + fail := func(seat, ref, why string) { + line := fmt.Sprintf("%s at version %s: the seat %s's verb versions resolves no digest of %s: %s, so the node holds %s and composes nothing of it", + module, w.Version, seat, ref, why, module) + c.sayOnceEach(line) + failed = append(failed, fmt.Sprintf("%s (seat %s: %s)", ref, seat, why)) + } + var manifest *catalogue.Manifest + for _, a := range e.Artifacts { + _, artifact, _ := strings.Cut(a.Ref, ":") + if a.Kind == catalogue.ArtifactUpstream { + if manifest == nil { + _, raw, err := entryManifest(e) + m, derr := catalogue.Decode(raw) + if err != nil || derr != nil { + fail("(none)", a.Ref, "the entry's manifest cannot be read for the digest its upstream copy pins") + continue + } + manifest = &m + } + if d := pinnedDigest(*manifest, artifact); d != "" { + parts[a.Ref] = d + } else { + fail("(none)", a.Ref, "the manifest pins no digest of the upstream copy") + } + continue + } + seat, numbered := seatOfKind(a.Kind) + if !numbered { + fail("(none)", a.Ref, "no registry seat the node-engine reads numbers an artifact of kind "+a.Kind) + continue + } + digest, why := c.versionDigest(seat, registryName(module, a), w) + if why != "" { + fail(seat, a.Ref, why) + continue + } + parts[a.Ref] = digest + } + if len(failed) > 0 { + sort.Strings(failed) + return nil, "no digest is resolved at version " + w.Version + " for " + strings.Join(failed, ", ") + } + return parts, "" +} + +// versionDigest is the digest the seat's verb versions answers for name at w's version (its version or its tag), the newest +// first: a version names one build (A-430a), so the version alone is matched. +func (c *Composer) versionDigest(seat, name string, w meshwants.WantsByWantNodeModuleValue) (string, string) { + if c.env.Registry == nil { + return "", "this node-engine reads no registry seat" + } + raw, err := c.env.Registry("seat:"+seat+"."+versionsVerb, map[string]string{"name": name}) + if err != nil { + return "", fmt.Sprintf("the call for %s failed: %v", name, err) + } + answer, said, ok := buscalls.Unwrap(raw) + if !ok { + return "", fmt.Sprintf("the seat refused %s: %s", name, said) + } + var v registryVersions + if err := json.Unmarshal(answer, &v); err != nil { + return "", fmt.Sprintf("its answer for %s cannot be read: %v", name, err) + } + for _, a := range v.Versions { + if (a.Version == w.Version || a.Tag == w.Version) && a.Digest != "" { + return a.Digest, "" + } + } + return "", fmt.Sprintf("it holds no version %s of %s", w.Version, name) +} + +// pinnedDigest is the digest the manifest's upstream artifact pins in its from (`@sha256:`); "" when none. +func pinnedDigest(m catalogue.Manifest, artifact string) string { + if m.Build == nil { + return "" + } + for _, a := range m.Build.Artifacts { + if a.Name == artifact { + if _, d, ok := strings.Cut(a.From, "@"); ok && strings.HasPrefix(d, "sha256:") { + return d + } + } + } + return "" +} diff --git a/internal/selfcompose/versions_test.go b/internal/selfcompose/versions_test.go new file mode 100644 index 00000000..162d7d52 --- /dev/null +++ b/internal/selfcompose/versions_test.go @@ -0,0 +1,123 @@ +package selfcompose + +import ( + "context" + "encoding/json" + "errors" + "strings" + "sync" + "testing" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants" +) + +// Design 47 G A-430, A-430a (the lead's answer A-430b): a want naming its version and no parts is resolved to its artifacts' +// digests through the verb versions of the registry seat of each artifact's kind, under `/`; an upstream copy +// by the digest its manifest pins. The build is made from those digests. A lookup that fails is said, naming the module, the +// version and the seat, and holds the module whole; a want with parts is read by its parts as before. +func aWantNamingItsVersionIsResolvedThroughTheRegistrySeats(t *testing.T) { + fp := meshcatalogclient.SourcePrefix2 + strings.Repeat("a", 64) + d := func(c string) string { return "sha256:" + strings.Repeat(c, 64) } + manifest := map[string]any{"module": "mail", "version": "1", "build": map[string]any{"artifacts": []any{ + map[string]any{"name": "server", "kind": "upstream", "from": "alpine@" + d("9")}, + map[string]any{"name": "files", "kind": "archive", "from": "files"}, + map[string]any{"name": "web", "kind": "image", "from": "Dockerfile"}, + }}} + entry := meshcatalog.CatalogEntry{Module: "mail", Fp: fp, Manifest: manifest, Artifacts: []meshcatalog.Artifact{ + {Ref: "mail:server", Kind: "upstream"}, {Ref: "mail:files", Kind: "archive"}, {Ref: "mail:web", Kind: "image"}}} + // The seats hold mail/files and mail/web; versions newest first. + held := map[string]string{ + "oci-artifact-registry.mail/files": `{"name":"mail/files","versions":[{"name":"mail/files","kind":"archive","digest":"` + d("2") + `","version":"1.3.0"},{"name":"mail/files","kind":"archive","digest":"` + d("1") + `","version":"1.2.3"}]}`, + "container-image-registry.mail/web": `{"name":"mail/web","versions":[{"name":"mail/web","kind":"image","digest":"` + d("3") + `","version":"1.2.3"}]}`, + "container-image-registry.mail/other": `{"name":"mail/other","versions":[]}`, + } + for name, row := range map[string]struct { + want meshwants.WantsByWantNodeModuleValue + down string // a seat whose call fails + parts map[string]string + missing string // a word the reason holds + said []string + }{ + "resolved": {want: meshwants.WantsByWantNodeModuleValue{Fp: fp, Version: "1.2.3", Self: true}, + parts: map[string]string{"mail:server": d("9"), "mail:files": d("1"), "mail:web": d("3")}}, + "a version a seat does not hold": {want: meshwants.WantsByWantNodeModuleValue{Fp: fp, Version: "2.0.0", Self: true}, + missing: "2.0.0", said: []string{"mail at version 2.0.0", "oci-artifact-registry", "container-image-registry"}}, + "a seat that does not answer": {want: meshwants.WantsByWantNodeModuleValue{Fp: fp, Version: "1.2.3", Self: true}, down: "container-image-registry", + missing: "mail:web", said: []string{"mail at version 1.2.3: the seat container-image-registry"}}, + "parts as before": {want: meshwants.WantsByWantNodeModuleValue{Fp: fp, Version: "1.2.3", Self: true, + Parts: map[string]string{"mail:server": d("9"), "mail:files": d("5"), "mail:web": d("6")}}, + parts: map[string]string{"mail:server": d("9"), "mail:files": d("5"), "mail:web": d("6")}}, + } { + var mu sync.Mutex + var said []string + env := Env{Say: func(line string) { mu.Lock(); said = append(said, line); mu.Unlock() }} + calls := 0 + env.Registry = EntryCall(func(_ context.Context, seat, verb string, args any) (json.RawMessage, error) { + calls++ + if verb != "versions" { + t.Errorf("%s: asked %s.%s", name, seat, verb) + } + if seat == row.down { + return nil, errors.New("no responders") + } + answer, ok := held[seat+"."+args.(map[string]string)["name"]] + if !ok { + return nil, errors.New("not held") + } + return json.RawMessage(answer), nil + }) + env.Entry = EntryCall(func(context.Context, string, string, any) (json.RawMessage, error) { + return nil, errors.New("not asked") + }) + c := New(env) + c.wants["mail"] = row.want + c.keptEnt[fp] = keptEntry{entry: entry} + parts, missing := c.partsOf("mail", entry, row.want) + b := c.buildOf("mail", fp) + if row.missing != "" { + if parts != nil || b != nil || !strings.Contains(missing, row.missing) { + t.Errorf("%s: parts %v, build %v, missing %q: want the module held whole, naming %s", name, parts, b, missing, row.missing) + } + if c.entryHolds()["mail"] == "" { + t.Errorf("%s: the module is not held", name) + } + for _, w := range row.said { + if !strings.Contains(strings.Join(said, "\n"), w) { + t.Errorf("%s: said %q, want a line naming %q", name, said, w) + } + } + continue + } + if missing != "" || len(parts) != len(row.parts) { + t.Fatalf("%s: parts %v, missing %q", name, parts, missing) + } + for ref, digest := range row.parts { + if parts[ref] != digest { + t.Errorf("%s: %s at %s, want %s", name, ref, parts[ref], digest) + } + } + if b == nil || len(b.Artifacts) != 3 { + t.Fatalf("%s: build %+v", name, b) + } + for _, a := range b.Artifacts { + if a.Digest != row.parts["mail:"+a.Name] || a.Reference != referenceOf("mail", a.Name, a.Digest) { + t.Errorf("%s: artifact %+v", name, a) + } + } + // A resolution is asked once, and it names the node keeping the build its digests are of. + before := calls + c.partsOf("mail", entry, row.want) + if calls != before { + t.Errorf("%s: resolved again: %d calls, then %d", name, before, calls) + } + c.wants["mail"] = meshwants.WantsByWantNodeModuleValue{Fp: fp, Version: row.want.Version, Parts: row.want.Parts, KeptOn: "g14", Self: true} + if node, _, kept, _ := c.KeptBuildOf(context.Background(), "mail", row.parts["mail:files"]); !kept || node != "g14" { + t.Errorf("%s: kept on %q %v, want g14", name, node, kept) + } + if _, _, kept, _ := c.KeptBuildOf(context.Background(), "mail", d("7")); kept { + t.Errorf("%s: a digest the want does not resolve to is said kept", name) + } + } +}