From 1a3664ad777accd80e8328f822c8b2f33922c65b Mon Sep 17 00:00:00 2001 From: jochen Date: Fri, 20 Nov 2026 04:37:12 +0100 Subject: [PATCH] I10: the indexer's integration tests drive the one model MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The whole test starts the indexer against an embedded bus with the gate's source-moved on its kept stream and a durable per watched branch: a first revision with start true and no movers; one revision per take-in carrying its movers, pinned pipeline.. and said as take-in.taken; the same source-moved given again said from the kept movers with no second revision; pipeline-started pinning, a restart keeping a running pipeline's revision; a take-in on a full store held, said once as take-in.pending and in the state held, taken again on the indexer's own room once pipeline-ended frees a pin; another branch's held take-in leaving main going on, skipped by hand with why in the hand-act log; a branch watched later bound on registration-changed. The packages test takes a mesh-sdk commit in and names mesh-sdk and the module requiring it, not the one requiring nothing of it. The toolchain test drives take-ins; the tests of the forge messages, the verdicts, the pins events of the gate and the view moving between take-ins (H-A-49, H-A-103) go. 7 integration tests (was 13). Builds: design 47 H §743, §744, §749, §768; H-A-12, H-A-30, H-A-49, H-A-50, H-A-90, H-A-92, H-A-97, H-A-102, H-A-103 Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- .../mesh-delivery-indexer/integration_test.go | 913 +----------------- .../packages_integration_test.go | 531 ++-------- .../takein_integration_test.go | 559 +++++++++++ 3 files changed, 698 insertions(+), 1305 deletions(-) create mode 100644 modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/takein_integration_test.go diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/integration_test.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/integration_test.go index 4e68b883..aefeb292 100644 --- a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/integration_test.go +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/integration_test.go @@ -15,7 +15,6 @@ import ( "path/filepath" "slices" "strings" - "sync" "sync/atomic" "testing" "time" @@ -32,15 +31,11 @@ import ( "git.novox.be/novox/mesh-contracts/go/seats/nodeengine" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git" "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/meshdelivery" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-indexer/takein" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/trunk" "git.novox.be/novox/mesh-sdk/go/buscompose" "git.novox.be/novox/mesh-sdk/go/process" "git.novox.be/novox/mesh-sdk/go/seatdef" @@ -51,7 +46,6 @@ import ( "git.novox.be/novox/mesh-sdk/go/views/viewstest" "mesh-delivery-indexer/internal/index" - "mesh-delivery-indexer/judge" ) // busConf is the shape of the composed accounts file (mesh-controller internal/broker): one account with JetStream, the @@ -70,326 +64,12 @@ accounts { } ` -// TestIndexerWhole starts the program the way the node does (its entry, run, with MESH_BROKER_FILE) against an embedded -// bus with the stream FORGE and the indexer's durable _ on it, the buckets the controller makes from the -// manifest's state (mesh-delivery-indexer_candidates, history 10) and mesh-controller_builds holding build records, and -// no mesh-delivery-gate_source bucket. -// -// And the take-in step (ADR 0633, issue 1585 I8a, I8b): the indexer's states pending, verdicts, graph, taken and packages -// and its stream take-in are there, mesh-build-go reported its toolchain, and the node-engine's composition answers the -// build of the indexer that runs. A merge changing the indexer's own tree writes only the indexer's entry, its manifest, -// its verdict and its key of the graph (and the packages it publishes); the rest is pending, said take-in.pending and -// named by indexer_pending with the build it waits for. A group's first member is gathered meanwhile. Started again as -// that build, the indexer takes the revision in and leaves the group gathered; the group's second member and its end -// then make one take-in, said take-in.taken under the group's key. - // The beds' indexer's own findings and first views, named from the module its credential names (design 47 G A-296). var ( findingsBucket = index.Bucket(testIndexer, index.FindingsState) firstViewsBucket = index.Bucket(testIndexer, views.StatusState) ) -func TestIndexerWhole(t *testing.T) { // 1238/AC2, AC10; 1585/T14, T15 - var running atomic.Pointer[string] - first := "fp-the-indexer-that-runs" - running.Store(&first) - // The forge bridge's tool bridge_merged_message (issue 1585): answers the merged message published for a merge, by - // repository@merge, as the bridge does; a restarted indexer holds none in memory and asks it. - var bridgeMessages sync.Map - js, ctx, candidates, _, _ := startIndexerRun(t, func(ctx context.Context, builds buildLog) { - // The builder's log entries of two builds' ends (ADR 0571 clause 1), as the builder appends them. - builds.end(t, "novox/mesh-delivery", "a", "modules/a") - builds.end(t, "novox/mesh-catalog", "c", "modules/c") - }, func(ctx context.Context, js jetstream.JetStream) { - // The states and the stream the controller makes from the indexer's manifest (old sections, ADR 0595 §11). - for bucket, history := range map[string]uint8{index.Bucket(testIndexer, index.PendingState): 1, index.Bucket(testIndexer, index.VerdictsState): index.VerdictsHistory, - index.Bucket(testIndexer, index.TakenState): 1, index.Bucket(testIndexer, index.PackagesState): 1, - index.Bucket(testIndexer, index.SeatDefinitionsState): 1, index.Bucket(testIndexer, index.RequirementsState): 1, findingsBucket: 1, index.Bucket(testIndexer, index.UnjudgedState): 1} { - if _, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: bucket, History: history}); err != nil { - t.Fatal(err) - } - } - seedAssignerSeat(t, ctx, js) - // The take-in events are the indexer's ordinary events (ADR 0633 §5), on the path manifest-accepted takes. - tc, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.ToolchainsBucket("mesh-build-go"), History: 1}) - if err != nil { - t.Fatal(err) - } - key, _ := index.ToolchainKey("n1", "go") - value, err := index.EncodeToolchain(nodebuildgo.Toolchain{Language: "go", Version: "go1.27.1", Recipe: "1", At: ptr(time.Now())}) - if err != nil { - t.Fatal(err) - } - if _, err := tc.Put(ctx, key, value); err != nil { - t.Fatal(err) - } - // The trunk holds the indexer's entry, taken in at an earlier commit with its own manifest; the take-in asks no validation (A-476 a). - seedBuildModules(t, ctx, js, map[string]meshcatalog.CatalogEntry{testIndexer: trunkIndexerEntry(t, ctx, js)}) - // The node-engine's composition on n1 (process.Conn.Call's subjects): the build of the indexer that runs there. - answer := func(m *nats.Msg) { - raw, _ := json.Marshal(map[string]any{"result": map[string]any{"runs": map[string]string{"fp": *running.Load()}}, "node": "n1"}) - _ = m.Respond(raw) - } - bridge := func(m *nats.Msg) { - var ask struct{ Repository, Merge string } - _ = json.Unmarshal(m.Data, &ask) - data, ok := bridgeMessages.Load(ask.Repository + "@" + ask.Merge) - if !ok { - raw, _ := json.Marshal(map[string]any{"error": "the gate holds no merge of " + ask.Repository + " with that commit"}) - _ = m.Respond(raw) - return - } - raw, _ := json.Marshal(map[string]any{"result": map[string]any{"message": json.RawMessage(data.([]byte))}, "node": "n1"}) - _ = m.Respond(raw) - } - for _, subject := range []string{"mesh.mod.mesh-delivery-forge-bridge.call.bridge_merged_message.>", "mesh.mod.mesh-delivery-forge-bridge.tool.bridge_merged_message"} { - if _, err := js.Conn().Subscribe(subject, bridge); err != nil { - t.Fatal(err) - } - } - for _, subject := range []string{"mesh.seat.node-engine.call.composition.n1.>", "mesh.seat.node-engine.tool.composition.n1"} { - if _, err := js.Conn().Subscribe(subject, answer); err != nil { - t.Fatal(err) - } - } - }) - h1, h2 := "0123456789abcdef0123456789abcdef01234567", "89abcdef0123456789abcdef0123456789abcdef" - for _, f := range []forgemsg.Forge{ - {Kind: forgemsg.ForgePull, Repository: "novox/mesh-delivery", Branch: "feat/x", Number: 12, Head: h1, Action: forgemsg.PullUpdated, Dirs: []string{"modules/a"}, DirsKnown: true}, - {Kind: forgemsg.ForgePull, Repository: "novox/mesh-catalog", Branch: "feat/x", Number: 300, Head: h2, Action: forgemsg.PullUpdated, Dirs: []string{"modules/c"}, DirsKnown: true}, - } { - data, err := forgemsg.EncodeForge(f) - if err != nil { - t.Fatal(err) - } - event, _ := forgemsg.ForgeEvent(f.Repository, forgemsg.ForgePull) - if _, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event."+event, data); err != nil { - t.Fatal(err) - } - } - - hash, _ := meshdeliveryclient.HeadsHash([]meshdeliveryclient.Head{{Repository: "novox/mesh-delivery", Number: 12, Head: h1}, {Repository: "novox/mesh-catalog", Number: 300, Head: h2}}) - var c meshcatalog.CandidatesByGroupValue - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - e, err := candidates.Get(ctx, "feat/x") - if err != nil { - continue - } - if c, err = index.DecodeCandidate(e.Value()); err == nil && len(c.Pulls) == 2 { - break - } - } - if c.Group != "feat/x" || c.Base != 0 || c.Heads != hash || len(c.Pulls) != 2 { - t.Fatalf("candidate = %+v within 20 s", c) - } - for _, p := range c.Pulls { - want := map[string]string{"novox/mesh-delivery": "a", "novox/mesh-catalog": "c"}[p.Repository] - if len(p.Modules) != 1 || p.Modules[0] != want { - t.Errorf("%s#%d modules = %v, want [%s]", p.Repository, p.Number, p.Modules, want) - } - } - - // ADR 0615 §5 (DLV-O4): each change of the candidates is said on the indexer's views family, its value whole at its - // revision; a first view taken at the mark, followed by the events after it, holds the candidate as the bucket does; - // and a waiter on manifest-accepted never wakes on it. - views0 := waitViews(t, ctx, js, "candidates", "feat/x") - cur, err := candidates.Get(ctx, "feat/x") - if err != nil || views0.Revision > cur.Revision() || views0.Deleted || len(views0.Value) == 0 || !views0.Created.Equal(bucketCreated(t, ctx, candidates)) { - t.Errorf("views event = %+v, bucket at %d (%v)", views0, cur.Revision(), err) - } - marks, _ := js.KeyValue(ctx, index.Bucket(testIndexer, views.MarksState)) - f := &views.Follower{Owner: testIndexer, Tool: "indexer_read_candidates", State: "candidates", - Ask: func(context.Context, string) (views.Answer, error) { - return views.FirstView(testIndexer, "candidates", jsSource{ctx, candidates}, jsSource{ctx, marks}, "", time.Now()) - }} - if err := f.Start(ctx); err != nil { - t.Fatal(err) - } - for _, e := range viewsEvents(t, ctx, js, "candidates") { - if gap, why := f.Apply(e); gap { - t.Errorf("a gap after the first view: %s", why) - } - } - if v, ok := f.Get("feat/x"); !ok || string(v) != string(cur.Value()) { - t.Errorf("the follower holds %s, the bucket %s", v, cur.Value()) - } - if n := acceptedHeard.Load(); n != 0 { - t.Errorf("a waiter on manifest-accepted woke %d times on the views family", n) - } - - // I8a: pull request 12 merged, changing the indexer's own tree and a's. - manifest, err := os.ReadFile("../../module.json") - if err != nil { - t.Fatal(err) - } - const ix = testIndexer - m1 := forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-delivery", Branch: "feat/x", Number: 12, Head: h1, - Merge: "1111111111111111111111111111111111111111", Root: "r0", - Trees: map[string]string{"modules/" + ix: "tree-indexer-2", "modules/a": "tree-a-2"}, - Manifests: map[string]string{"modules/" + ix: string(manifest), "modules/a": `{"module":"a","version":"1.0"}`}, - Locks: map[string]map[string]string{"modules/" + ix: {"go.sum": "3b5028f0c1e9bde04dd766abd63eb5931bc516bae695cf46f00abcd8510b0381"}}} - merged := func(f forgemsg.Forge) uint64 { - t.Helper() - data, err := forgemsg.EncodeForge(f) - if err != nil { - t.Fatal(err) - } - event, _ := forgemsg.ForgeEvent(f.Repository, forgemsg.ForgeMerged) - bridgeMessages.Store(f.Repository+"@"+f.Merge, data) - ack, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event."+event, data) - if err != nil { - t.Fatal(err) - } - return ack.Sequence - } - m1Key := takein.PendingKey(merged(m1)) - events, err := js.Stream(ctx, "EVENTS") - if err != nil { - t.Fatal(err) - } - // saidAll is every take-in event of kind said under key so far, oldest first. - saidAll := func(kind, key string) []takein.TakeIn { - event, _ := takein.TakeInEvent(kind) - info, err := events.Info(ctx) - if err != nil { - t.Fatal(err) - } - var out []takein.TakeIn - for seq := info.State.FirstSeq; seq <= info.State.LastSeq && seq > 0; seq++ { - msg, err := events.GetMsg(ctx, seq) - if err != nil || msg.Subject != "mesh.mod."+ix+".event."+event { - continue - } - if ti, err := takein.DecodeTakeIn(msg.Data); err == nil && ti.Key == key { - out = append(out, ti) - } - } - return out - } - // said is the last take-in event under kind and key, within 20 s. - said := func(kind, key string) (takein.TakeIn, bool) { - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if all := saidAll(kind, key); len(all) > 0 { - return all[len(all)-1], true - } - } - return takein.TakeIn{}, false - } - // A-476 a, b: the revision changing the indexer's own tree is taken in at once, with the build this program runs and no - // validation ask: it is never said pending, and the build the revision names is not waited for. - if taken, ok := said(takein.TakeInTaken, m1Key); !ok || len(taken.Merges) != 1 || taken.Merges[0].Merge != m1.Merge { - t.Fatalf("take-in.taken.%s = %+v (said %v) within 20 s, want the revision taken in at once", m1Key, taken, ok) - } - if held := saidAll(takein.TakeInPending, m1Key); len(held) != 0 { - t.Errorf("the revision was said pending: %+v", held) - } - get := func(bucket, key string) ([]byte, bool) { - t.Helper() - if bucket == index.ModulesState { // the view of the trunk, from the newest catalog graph revision - e, err := revisionView{js: js}.Get(ctx, key) - if err != nil { - return nil, false - } - return e.Value(), true - } - kv, err := js.KeyValue(ctx, bucket) - if err != nil { - t.Fatal(err) - } - e, err := kv.Get(ctx, key) - if err != nil { - return nil, false - } - return e.Value(), true - } - raw, ok := get(index.ModulesState, ix) - own, err := meshcatalogclient.DecodeModule(raw) - if !ok || err != nil || own.Commit != m1.Merge { - t.Fatalf("modules.%s = %+v (%v), want the indexer at the merge", ix, own, err) - } - if _, ok := get(index.Bucket(testIndexer, index.ManifestsState), own.Manifest); !ok { - t.Errorf("manifests.%s is not written", own.Manifest) - } - if _, ok := get(index.Bucket(testIndexer, index.VerdictsState), own.Manifest); !ok { - t.Errorf("the verdict on the indexer's manifest %s is not written", own.Manifest) - } - repoKey, _ := trunk.RepositoryKey(m1.Repository) - if raw, ok := get(index.ModulesState, "a"); !ok || !strings.Contains(string(raw), m1.Merge) { - t.Errorf("modules.a = %s, want it at the merge %s", raw, m1.Merge) - } - if _, ok := get(index.Bucket(testIndexer, index.TakenState), repoKey); !ok { - t.Errorf("taken.%s is not written", repoKey) - } - - // A group's first member arrives meanwhile; its end is still to come (the knowledge base's remark: it stays across the restart). - members := []meshdeliveryclient.Head{{Repository: "novox/mesh-catalog", Number: 40, Head: "4040404040404040404040404040404040404040"}, - {Repository: "novox/mesh-controller", Number: 41, Head: "4141414141414141414141414141414141414141"}} - g1 := forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-catalog", Branch: "feat/g", Number: 40, Head: members[0].Head, - Merge: "4000000000000000000000000000000000000000", Root: "r0", Trees: map[string]string{"modules/c": "tree-c-2"}, - Manifests: map[string]string{"modules/c": `{"module":"c","version":"1.0"}`}, Group: "feat/g", Members: members} - g2 := forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-controller", Branch: "feat/g", Number: 41, Head: members[1].Head, - Merge: "4100000000000000000000000000000000000000", Root: "r0", Trees: map[string]string{"modules/k": "tree-k-1"}, - Manifests: map[string]string{"modules/k": `{"module":"k","version":"1.0"}`}, Group: "feat/g", Members: members} - g1Key, groupKey := takein.PendingKey(merged(g1)), takein.GroupTakeInKey("feat/g") - if gathered, ok := said(takein.TakeInPending, groupKey); !ok || gathered.What != takein.TakeInGroup || len(gathered.Merges) != 1 { - t.Fatalf("take-in.pending.%s = %+v (said %v) within 20 s, want the group with its first member", groupKey, gathered, ok) - } - // indexer_pending, the tool over the same state, names both waits. - pendingKV, err := js.KeyValue(ctx, index.Bucket(testIndexer, index.PendingState)) - if err != nil { - t.Fatal(err) - } - waits := func() []takein.PendingWait { - t.Helper() - answer, err := index.PendingTools(kvStore{pendingKV}, nil, nil, time.Now)[0].Run(map[string]any{}) - if err != nil { - t.Fatal(err) - } - return answer.(takein.PendingAnswer).Waits - } - var w []takein.PendingWait - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if w = waits(); len(w) == 1 && w[0].Said != "" { - break - } - } - if len(w) != 1 || w[0].Key != groupKey || w[0].What != takein.TakeInGroup || len(w[0].Merges) != 1 || len(w[0].Keys) != 1 || w[0].Keys[0] != g1Key || - w[0].Said != takein.TakeInPendingEvent { - t.Fatalf("indexer_pending = %+v, want only the group gathered, its first member %s", w, g1Key) - } - if _, ok := get(index.ModulesState, "c"); ok { - t.Errorf("modules.c is written while its group is gathered") - } - - // I8b: the group's second member and its end: one take-in of both, said under the group's key. - merged(g2) - end, err := forgemsg.EncodeForgeGroupEnd(forgemsg.ForgeGroupEnd{Group: "feat/g", Members: []forgemsg.GroupMerge{ - {Repository: g1.Repository, Number: g1.Number, Merge: g1.Merge}, {Repository: g2.Repository, Number: g2.Number, Merge: g2.Merge}}}) - if err != nil { - t.Fatal(err) - } - if _, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event."+forgemsg.ForgeGroupEndEvent, end); err != nil { - t.Fatal(err) - } - if taken, ok := said(takein.TakeInTaken, groupKey); !ok || taken.What != takein.TakeInGroup || len(taken.Merges) != 2 { - t.Fatalf("take-in.taken.%s = %+v (said %v) within 20 s of the group's end, want both members", groupKey, taken, ok) - } - var hasC, hasK bool - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline) && !(hasC && hasK && len(w) == 0); time.Sleep(50 * time.Millisecond) { - _, hasC = get(index.ModulesState, "c") - _, hasK = get(index.ModulesState, "k") - w = waits() - } - if !hasC || !hasK || len(w) != 0 { - t.Errorf("after the group's end: modules.c %v, modules.k %v, indexer_pending %+v: want both taken in and nothing waiting", hasC, hasK, w) - } - // One take-in: neither member was said as a revision of its own. - if len(saidAll(takein.TakeInPending, g1Key)) != 0 { - t.Errorf("the group's first member %s was said pending as a revision of its own", g1Key) - } - -} - // trunkIndexerEntry keeps the indexer's own manifest by its digest, accepted, and answers its trunk entry at an earlier commit. func trunkIndexerEntry(t *testing.T, ctx context.Context, js jetstream.JetStream) meshcatalog.CatalogEntry { return trunkIndexerEntryOf(t, ctx, js, func(raw []byte) []byte { return raw }) @@ -615,11 +295,25 @@ func startIndexerRun(t *testing.T, put func(context.Context, buildLog), before . } ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) t.Cleanup(cancel) - if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "FORGE", Subjects: []string{"mesh.stream.mesh-delivery-forge-bridge.event.forge.>"}}); err != nil { + // The gate's source-moved on its kept stream, with the indexer's durable of each watched branch the beds register + // (watchBranch), and the streams of the seat events the indexer consumes on durables of its own: its registration-changed + // and the runner's run-started, pipeline-started and pipeline-ended (design 47 H §743, §749), as the grants part makes them. + if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: meshdelivery.StreamSourceMoved, Subjects: []string{meshdelivery.SubjectSourceMovedAll}}); err != nil { t.Fatal(err) } - if _, err := js.CreateOrUpdateConsumer(ctx, "FORGE", jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-indexer", AckPolicy: jetstream.AckExplicitPolicy}); err != nil { - t.Fatal(err) + for _, b := range []string{"main", "beta"} { + watchBranch(t, ctx, js, b) + } + for stream, subject := range map[string]string{meshcatalog.StreamRegistrationChanged: meshcatalog.SubjectRegistrationChanged, + meshpipelinerunner.StreamRunStarted: meshpipelinerunner.SubjectRunStartedAll, meshpipelinerunner.StreamPipelineStarted: meshpipelinerunner.SubjectPipelineStartedAll, + meshpipelinerunner.StreamPipelineEnded: meshpipelinerunner.SubjectPipelineEndedAll} { + if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: stream, Subjects: []string{subject}}); err != nil { + t.Fatal(err) + } + if _, err := js.CreateOrUpdateConsumer(ctx, stream, jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-indexer", AckPolicy: jetstream.AckExplicitPolicy, + FilterSubjects: []string{subject}}); err != nil { + t.Fatal(err) + } } // The two seat events that name a fingerprint, each on its stream kept last per subject with the indexer's durable on it, and the // state named the grants part makes from the manifest (design 47 G §675, §695); both streams empty, so the start's read ends at once. @@ -685,11 +379,18 @@ func startIndexerRun(t *testing.T, put func(context.Context, buildLog), before . } t.Cleanup(func() { _ = waiter.Unsubscribe() }) // The shared events stream: the indexer's ordinary events and the assigner's views events (ADR 0635 §5). - if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "EVENTS", Subjects: []string{"mesh.mod.*.event.>", "mesh.seat.mesh-catalog.event.>", "mesh.seat.mesh-delivery.event.>", "mesh.seat.mesh-delivery-checker.event.>", + if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "EVENTS", Subjects: []string{"mesh.mod.*.event.>", "mesh.seat.mesh-catalog.event.catalog-revision.*", "mesh.seat.mesh-catalog.event.filling", + "mesh.seat.mesh-catalog.event.full", "mesh.seat.mesh-catalog.event.room", "mesh.seat.mesh-catalog.event.seat-definition-changed", + "mesh.seat.mesh-catalog.event.seat-definition-removed", "mesh.seat.mesh-catalog.event.manifest-accepted", "mesh.seat.mesh-catalog.event.version-released", + "mesh.seat.mesh-catalog.event.versions-filled", "mesh.seat.mesh-delivery-checker.event.>", "mesh.seat.mesh-conditions.event.>", "mesh.seat.operator-channel.event.>", "mesh.seat.go-package-registry.event.>", "mesh.seat.npm-package-registry.event.>", "mesh.seat.mesh-module-assigner.event.>", "mesh.seat.node-build-go.event.>"}}); err != nil { // not the seats kept in streams of their own (wanted and running, above) t.Fatal(err) } + // The indexer's durable on the shared events stream (process.EventHub), which carries its own room (design 47 H §744, H-A-50). + if _, err := js.CreateOrUpdateConsumer(ctx, "EVENTS", jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-indexer", AckPolicy: jetstream.AckExplicitPolicy}); err != nil { + t.Fatal(err) + } // The indexer's own stream of its findings' events (design 47 G §383), which its finding writer says into (A-30). if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: findingsStream, Subjects: []string{ "mesh.stream." + testIndexer + ".event.finding-written.*", "mesh.stream." + testIndexer + ".event.finding-cleared.*", @@ -782,20 +483,6 @@ func seedBuildModules(t *testing.T, ctx context.Context, js jetstream.JetStream, if _, err := manifests.Put(ctx, mkey, mdata); err != nil { t.Fatal(err) } - // A holder the mesh took in has its accepted verdict: the indexer judges and says nothing of it at its start. - if verdicts, err := js.KeyValue(ctx, index.Bucket(testIndexer, index.VerdictsState)); err == nil { - vkey, err := meshcatalogclient.VerdictsKey(digest) - if err != nil { - t.Fatal(err) - } - vdata, err := meshcatalogclient.EncodeVerdict(meshcatalog.VerdictsByDigestValue{Module: b.module, State: meshcatalogclient.VerdictAccepted, Judge: judge.Identity(), At: ptr(time.Now())}) - if err != nil { - t.Fatal(err) - } - if _, err := verdicts.Put(ctx, vkey, vdata); err != nil { - t.Fatal(err) - } - } // The holders sit in a repository of their own, so that a test's merge of mesh-catalog, which lists the modules it names // alone, takes no holder out of the trunk (a module a merge does not list leaves it). held := meshcatalog.ModulesByModuleValue{Repository: "novox/mesh-build-modules", Commit: "4444444444444444444444444444444444444444", Path: "modules/" + b.module, @@ -910,323 +597,6 @@ func (l buildLog) end(t *testing.T, repo, module, path string) { } } -// TestIndexerWritesModulesAtAMerge: a module's record and its newest pointer are in mesh-controller_builds; a merged -// message on FORGE makes modules. within 20 s, the fingerprint of the merge's tree and the recorded inputs. -func TestIndexerWritesModulesAtAMerge(t *testing.T) { // 1239/AC9; I1, I3: the modules are the merged message's, no build record names them (issue 1851) - // The bucket holds only build-agent's record, which no fingerprint reads since R4g (ADR 0530 §1). - var asks jetstream.KeyValue - js, ctx, _, modules := startIndexer(t, func(ctx context.Context, builds buildLog) { - builds.end(t, "novox/mesh-controller", "build-agent", "modules/build-agent") - }, func(ctx context.Context, js jetstream.JetStream) { - var err error - if asks, err = js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.TakeInsState), History: 1}); err != nil { - t.Fatal(err) - } - // A want and a running build said before the start: the indexer removes no entry until both streams were read whole and - // not empty (design 47 G §675, 5188d36a), so the drop below removes entry.dx only with them. - fp := "src2:" + strings.Repeat("b", 64) - at := time.Now().UTC() - want, _ := json.Marshal(meshwants.WantedEvent{V: 1, Node: "n1", Module: "avahi", Fp: fp, Revision: 1, At: &at}) - run, _ := json.Marshal(nodeengine.Running{V: 1, Node: "n2", Module: "avahi", Fingerprint: fp, At: at}) - for subject, data := range map[string][]byte{meshwants.SubjectWanted("n1", "avahi"): want, nodeengine.SubjectRunning("n2", "avahi"): run} { - if _, err := js.Publish(ctx, subject, data); err != nil { - t.Fatal(err) - } - } - }) - const merge = "89abcdef0123456789abcdef0123456789abcdef" - data, err := forgemsg.EncodeForge(forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-delivery", Branch: "feat/x", Number: 12, - Head: "0123456789abcdef0123456789abcdef01234567", Merge: merge, Root: "r0", Trees: map[string]string{"modules/a": "newtree"}, - Manifests: map[string]string{"modules/a": `{"module":"a","version":"1.0"}`}}) - if err != nil { - t.Fatal(err) - } - if _, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event.forge.novox.mesh-delivery.merged", data); err != nil { - t.Fatal(err) - } - var m meshcatalog.ModulesByModuleValue - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if e, err := modules.Get(ctx, "a"); err == nil { - if m, err = meshcatalogclient.DecodeModule(e.Value()); err == nil { - break - } - } - } - if m.Repository != "novox/mesh-delivery" || m.Commit != merge || m.Path != "modules/a" || m.Manifest == "" || m.Fp != "" || m.None != "" { // 1606/AC2 - t.Errorf("module = %+v within 20 s, want path modules/a, its manifest, and no value of today's form", m) - } - // Milestone 47/G W4.13 (design 47, the indexer whole): the source revision taken in is one catalog graph revision kept - // as objects, said as catalog-revision on the seat's subject, every entry it lists stored once by digest. - objects := newBusObjects(js, testAccount, index.CatalogRevisionsObjects) - list, err := index.ListRevisions(ctx, objects, false) - // The bed's catalog holds the claimant of mesh-module-assigner from the start (seedClaimantAlone, A-302): the merge's revision - // is the newest, current, lists the merge's module beside the claimant, and every entry it lists is stored. - if err != nil || len(list.Revisions) == 0 || !list.Revisions[len(list.Revisions)-1].Current || list.Revisions[len(list.Revisions)-1].Entries != 2 || - list.Entries < list.Revisions[len(list.Revisions)-1].Entries || len(list.Unlisted) != 0 || list.Fill.Bytes == 0 { - t.Fatalf("revisions kept = %+v (%v): want the merge's revision newest, current, its two entries stored", list, err) - } - newest := list.Revisions[len(list.Revisions)-1].Revision - events, err := js.Stream(ctx, "EVENTS") - if err != nil { - t.Fatal(err) - } - if msg, err := events.GetLastMsgForSubject(ctx, meshcatalog.SubjectCatalogRevisionAll); err != nil || - !strings.Contains(string(msg.Data), fmt.Sprintf(`"revision":%d`, newest)) { - t.Errorf("catalog-revision said: %v (%v): want revision %d", msg, err, newest) - } - // W4.12 through the process: a recompute by hand moves nothing and answers equal; a candidate's half dropped by hand - // leaves the trunk's revision and its entries. - if err := index.KeepRevision(ctx, objects, meshcatalog.CatalogRevision{Kind: "candidate", Group: "g1", Heads: "h1", Revision: 1, - Entries: []meshcatalog.EntryRef{{Module: "x", Digest: "dx"}}}, map[string][]byte{"dx": []byte(`{"module":"x"}`)}); err != nil { - t.Fatal(err) - } - answer := func(key string, value []byte) index.TakenIn { - t.Helper() - w, err := asks.Watch(ctx, key, jetstream.UpdatesOnly()) - if err != nil { - t.Fatal(err) - } - defer w.Stop() - if _, err := asks.Put(ctx, key, value); err != nil { - t.Fatal(err) - } - for e := range w.Updates() { - if e == nil { - continue - } - if a, err := index.DecodeTakeIn(e.Value()); err == nil && a.Done() { - return *a.Result - } - } - t.Fatalf("%s is not answered", key) - return index.TakenIn{} - } - key, value, _ := index.NewRecomputeAsk("a check", "ctl", time.Now()) - if r := answer(key, value); !r.Stored || !strings.Contains(r.Answer, fmt.Sprintf("equal to the kept revision %d", newest)) { - t.Errorf("indexer_recompute answered %+v: want equal to the kept revision %d", r, newest) - } - key, value, _ = index.NewDropCandidateGraphAsk("g1", "h1", "its gate event never came", "ctl", time.Now()) - if r := answer(key, value); !r.Stored || !slices.Equal(r.Dropped, []string{"entry.dx"}) { - t.Errorf("indexer_drop_candidate_graph answered %+v: want candidate.g1.h1 dropped with entry.dx", r) - } - if after, err := index.ListRevisions(ctx, objects, false); err != nil || len(after.Revisions) != len(list.Revisions) || after.Entries != list.Entries { - t.Errorf("revisions after the drop = %+v (%v): want the trunk's revisions and their entries alone", after, err) - } -} - -// TestIndexerKeepsManifestsAtAMerge: a merged message of mesh-catalog carrying the real manifest of the module avahi and the -// hash of its go.sum (the bridge's Manifests and Locks, issue 1448) makes, within 20 s, modules.avahi with its manifest digest, -// its inputs and the reason it has no fingerprint of the new form, and manifests. with the manifest byte for byte. -// -// And it judges them (novox/hq ADR 0578, issue 1585): with three manifests more, one valid, one refused and one with a -// field the decoder does not know (it waits, ADR 0601 §3), mesh-sdk's bus reader read before the indexer judged composes all three, the field set -// aside and named (a missing verdict is accepted, §3); the indexer writes the three verdicts, says manifest-refused for -// each refusal, and the reader then composes the valid one and holds the others, named, never ending its read. -func TestIndexerKeepsManifestsAtAMerge(t *testing.T) { // 1444/AC4, 1449/AC4, 1585 - // The manifest is avahi's module.json from mesh-catalog at a67f01963f0d9ef0913a63720b89e573ca7a16ef (copied into the - // index package's testdata); the lock hash is the sha256 of modules/avahi/go.sum there. - manifest, err := os.ReadFile("../../internal/index/testdata/catalogue-a67f0196-avahi.module.json") - if err != nil { - t.Fatal(err) - } - const goSum = "3b5028f0c1e9bde04dd766abd63eb5931bc516bae695cf46f00abcd8510b0381" - judged := map[string]string{ - "good": `{"module":"good","version":"1.0","resources":[{"id":"d","type":"directory","path":"/srv/good","mode":"0700"}],"data":{"own":[{"id":"d","path":"${dir:d}","class":"valuable"}]}}`, - "bad": `{"module":"bad","version":"1.0","provides":[{"name":"amqp"}],"resources":[{"id":"d","type":"directory","path":"/srv/bad","mode":"0700"}],"data":{"own":[{"id":"d","path":"${dir:d}","class":"valuable"}]}}`, - "later": `{"module":"later","version":"1.0","a-field-from-later":1,"resources":[{"id":"d","type":"directory","path":"/srv/later","mode":"0700"}],"data":{"own":[{"id":"d","path":"${dir:d}","class":"valuable"}]}}`, - } - js, ctx, _, modules := startIndexer(t, func(ctx context.Context, builds buildLog) { - builds.end(t, "novox/mesh-catalog", "avahi", "modules/avahi") - }, func(ctx context.Context, js jetstream.JetStream) { - // The indexer's state unjudged, as the controller makes it from its manifest; the verdicts state is made only once - // the merge is taken in (issue 1966 note 154: a take-in at the start, before the verdicts state's bind). - if _, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.UnjudgedState), History: 1}); err != nil { - t.Fatal(err) - } - }) - forge := forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-catalog", Branch: "feat/x", Number: 301, - Head: "0123456789abcdef0123456789abcdef01234567", Merge: "89abcdef0123456789abcdef0123456789abcdef", Root: "r0", - Trees: map[string]string{"modules/avahi": "newtree"}, - Manifests: map[string]string{"modules/avahi": string(manifest)}, - Locks: map[string]map[string]string{"modules/avahi": {"go.sum": goSum}}} - for name, raw := range judged { - forge.Manifests["modules/"+name], forge.Trees["modules/"+name] = raw, "tree-"+name - } - data, err := forgemsg.EncodeForge(forge) - if err != nil { - t.Fatal(err) - } - if _, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event.forge.novox.mesh-catalog.merged", data); err != nil { - t.Fatal(err) - } - var m meshcatalog.ModulesByModuleValue - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if e, err := modules.Get(ctx, "avahi"); err == nil { - if m, err = meshcatalogclient.DecodeModule(e.Value()); err == nil { - break - } - } - } - digest := meshcatalogclient.ManifestDigest(manifest) - if m.Manifest != digest || m.None2 != "toolchain not yet reported" || m.Fp2 != "" || m.Inputs2 == nil || m.Inputs2.Tree != "newtree" || - m.Inputs2.Locks["tools"] != goSum || m.Path != "modules/avahi" { // 1606/AC2 - t.Errorf("module = %+v within 20 s, want its path modules/avahi, its manifest digest %s, its inputs and none2 'toolchain not yet reported'", m, digest) - } - kv, err := js.KeyValue(ctx, index.Bucket(testIndexer, index.ManifestsState)) - if err != nil { - t.Fatal(err) - } - e, err := kv.Get(ctx, digest) - if err != nil { - t.Fatalf("manifests.%s: %v", digest, err) - } - if got, err := meshcatalogclient.DecodeManifest(e.Value()); err != nil || got.Module != "avahi" || got.Manifest != string(manifest) { - t.Errorf("manifest = %+v err %v, want avahi and the file's bytes", got, err) - } - - // 1966 (ADR 0668 §4, note 154): the take-in wrote its four manifests with no verdicts state on the bus, so it keeps - // them in its state unjudged; when the verdicts state binds, each is judged as new (bad refused in full, never as a - // warning), every accepted one is said as manifest-accepted, and the state is left empty. - unjudged, err := js.KeyValue(ctx, index.Bucket(testIndexer, index.UnjudgedState)) - if err != nil { - t.Fatal(err) - } - kept, _ := unjudged.Keys(ctx) - for _, raw := range []string{string(manifest), judged["good"], judged["bad"], judged["later"]} { - if !slices.Contains(kept, meshcatalogclient.ManifestDigest([]byte(raw))) { - t.Errorf("the take-in's new manifest %s is not kept unjudged: the state holds %v", meshcatalogclient.ManifestDigest([]byte(raw)), kept) - } - } - verdicts, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.VerdictsState), History: index.VerdictsHistory}) - if err != nil { - t.Fatal(err) - } - want := map[string]string{"good": meshcatalogclient.VerdictAccepted, "bad": meshcatalogclient.VerdictRefused, "later": meshcatalogclient.VerdictManifestWaits} - got := map[string]meshcatalog.VerdictsByDigestValue{} - for deadline := time.Now().Add(10 * time.Second); time.Now().Before(deadline) && len(got) < len(want); time.Sleep(50 * time.Millisecond) { - for name := range want { - if e, err := verdicts.Get(ctx, meshcatalogclient.ManifestDigest([]byte(judged[name]))); err == nil { - if v, err := meshcatalogclient.DecodeVerdict(e.Value()); err == nil { - got[name] = v - } - } - } - } - for name, state := range want { - if v := got[name]; v.State != state || v.Module != name || !strings.HasPrefix(v.Judge, "exe:") { - t.Errorf("the verdict on %s = %+v within 10 s, want %s by the running judge", name, v, state) - } - } - // ADR 0601 §3: the field this judge does not know waits and is named, since no node-engine answers which build of the - // indexer runs here (the unit tests of the index package prove it refused once that build is the trunk's). - if !strings.Contains(strings.Join(got["bad"].Problems, " "), `provides "amqp"`) || strings.Join(got["later"].Unknown, " ") != "a-field-from-later" { - t.Errorf("the refusal names no problem or the wait no field: %+v", got) - } - // The pass ends the state's keys after it wrote and said every verdict. - left, _ := unjudged.Keys(ctx) - for deadline := time.Now().Add(10 * time.Second); len(left) != 0 && time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - left, _ = unjudged.Keys(ctx) - } - if len(left) != 0 { - t.Errorf("the state unjudged still holds %v within 10 s, once every manifest has its verdict", left) - } - // manifest-refused, said once for each refusal (a wait is no refusal). - events, err := js.Stream(ctx, "EVENTS") - if err != nil { - t.Fatal(err) - } - said, acceptedSaid := map[string]bool{}, map[string]bool{} - for seq := uint64(1); ; seq++ { - msg, err := events.GetMsg(ctx, seq) - if err != nil { - break - } - var r meshcatalog.ManifestRefusedEvent - if msg.Subject == "mesh.seat.mesh-catalog.event."+meshcatalog.EventManifestRefused && json.Unmarshal(msg.Data, &r) == nil { - said[r.Module] = true - } - var a meshcatalog.ManifestAcceptedEvent - if msg.Subject == "mesh.seat.mesh-catalog.event."+meshcatalog.EventManifestAccepted && json.Unmarshal(msg.Data, &a) == nil { - acceptedSaid[a.Module] = true - } - } - if !said["bad"] || said["later"] || said["good"] { - t.Errorf("manifest-refused said for %v, want bad only", said) - } - if !acceptedSaid["good"] || acceptedSaid["bad"] || acceptedSaid["later"] { - t.Errorf("manifest-accepted said for %v, want good and no refused or waiting one", acceptedSaid) - } - // How a composer holds a refused module by these verdicts is the node-engine's to test (ADR 0593 §7: the composer - // and its bus reader are its own). -} - -// TestIndexerWritesAGoModuleAgainWhenTheBuildModuleReportsItsToolchain: the bucket mesh-build-go_toolchains exists (the state -// toolchains of the build module, index.ToolchainsBucket) and holds no key; a merged message of mesh-catalog carrying -// avahi's real manifest makes modules.avahi with none2 'toolchain not yet reported'; the bucket made after the indexer started, a put of the key n1.go and the build module's event toolchain.reported (the build -// module's own layout, index.ToolchainKey and EncodeToolchain) makes, within 20 s and with no merge, its fingerprint: -// no builder input is waited for (ADR 0530 §1; issue 1887 I1). -func TestIndexerWritesAGoModuleAgainWhenTheBuildModuleReportsItsToolchain(t *testing.T) { // 1444/AC10 - manifest, err := os.ReadFile("../../internal/index/testdata/catalogue-a67f0196-avahi.module.json") - if err != nil { - t.Fatal(err) - } - const goSum = "3b5028f0c1e9bde04dd766abd63eb5931bc516bae695cf46f00abcd8510b0381" - js, ctx, _, modules := startIndexer(t, func(ctx context.Context, builds buildLog) { - builds.end(t, "novox/mesh-catalog", "avahi", "modules/avahi") - }, func(ctx context.Context, js jetstream.JetStream) { seedBuildModules(t, ctx, js, nil) }) - data, err := forgemsg.EncodeForge(forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-catalog", Branch: "feat/x", Number: 301, - Head: "0123456789abcdef0123456789abcdef01234567", Merge: "89abcdef0123456789abcdef0123456789abcdef", Root: "r0", - Trees: map[string]string{"modules/avahi": "newtree"}, - Manifests: map[string]string{"modules/avahi": string(manifest)}, - Locks: map[string]map[string]string{"modules/avahi": {"go.sum": goSum}}}) - if err != nil { - t.Fatal(err) - } - if _, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event.forge.novox.mesh-catalog.merged", data); err != nil { - t.Fatal(err) - } - none2 := func(want string) string { - var got string - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if e, err := modules.Get(ctx, "avahi"); err == nil { - if m, err := meshcatalogclient.DecodeModule(e.Value()); err == nil { - if got = m.None2; got == want { - break - } - } - } - } - return got - } - if got := none2(sdkstep.ToolchainNoReport); got != sdkstep.ToolchainNoReport { - t.Fatalf("none2 = %q within 20 s, want %q", got, sdkstep.ToolchainNoReport) - } - // The bucket is made only now, as when the build module is assigned after the indexer started (review finding 9): the - // indexer finds it on its own. - kv, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.ToolchainsBucket("mesh-build-go"), History: 1}) - if err != nil { - t.Fatal(err) - } - key, err := index.ToolchainKey("n1", "go") - if err != nil { - t.Fatal(err) - } - value, err := index.EncodeToolchain(nodebuildgo.Toolchain{Language: "go", Version: "go1.27.1", Recipe: "1", At: ptr(time.Now())}) - if err != nil { - t.Fatal(err) - } - if _, err := kv.Put(ctx, key, value); err != nil { - t.Fatal(err) - } - // The build module says it wrote the key (its event on its stream): the indexer then watches the bucket it did not know. - if _, err := js.Publish(ctx, "mesh.stream.mesh-build-go.event.toolchain.reported", []byte(`{"node":"n1","language":"go"}`)); err != nil { - t.Fatal(err) - } - if got := none2(""); got != "" { - t.Errorf("none2 = %q within 20 s of the toolchain key, want a fingerprint and no reason", got) - } -} - // TestIndexerBuildsARunsCandidateAndDropsItWhenEveryMembersPipelineEnded (design 47 G §64, §67 test 64, §190; A-160, A-174): // the indexer starts with the runner's streams run-started and pipeline-ended and its durables on them, its state runs and a // registration of avahi; the runner says run-started of run 9 with avahi at a commit on a branch no registration watches; @@ -1241,16 +611,6 @@ func TestIndexerBuildsARunsCandidateAndDropsItWhenEveryMembersPipelineEnded(t *t const commit = "0123456789abcdef0123456789abcdef01234567" var runs jetstream.KeyValue js, ctx, candidates, _, restart := startIndexerRun(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) { - for stream, subject := range map[string]string{meshpipelinerunner.StreamRunStarted: meshpipelinerunner.SubjectRunStartedAll, - meshpipelinerunner.StreamPipelineEnded: meshpipelinerunner.SubjectPipelineEndedAll} { - if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: stream, Subjects: []string{subject}}); err != nil { - t.Fatal(err) - } - if _, err := js.CreateOrUpdateConsumer(ctx, stream, jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-indexer", AckPolicy: jetstream.AckExplicitPolicy, - FilterSubjects: []string{subject}}); err != nil { - t.Fatal(err) - } - } var err error if runs, err = js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.RunsState), History: 1}); err != nil { t.Fatal(err) @@ -1306,9 +666,9 @@ func TestIndexerBuildsARunsCandidateAndDropsItWhenEveryMembersPipelineEnded(t *t t.Fatalf("candidates.run-9 = %+v within 20 s of run-started, want avahi at the run's commit with its manifest", c) } restart() - ended, _ := json.Marshal(meshpipelinerunner.PipelineEnded{V: 1, Pipeline: "feature-1966-x.0.avahi", Module: "avahi", Branch: "feature/1966-x", Commit: commit, - Outcome: "passed", Steps: []meshpipelinerunner.StepResult{}, Run: "9"}) - if _, err := js.Publish(ctx, meshpipelinerunner.SubjectPipelineEnded("avahi", "feature-1966-x", commit), ended); err != nil { + ended, _ := json.Marshal(meshpipelinerunner.PipelineEnded{V: 1, Pipeline: "feature-1966-x.0", Branch: "feature/1966-x", Run: "9", + Movers: []meshpipelinerunner.MoverEnded{{Module: "avahi", Steps: []meshpipelinerunner.StepResult{}}}, Outcome: meshpipelinerunner.PipelineEndedOutcomePassed}) + if _, err := js.Publish(ctx, meshpipelinerunner.SubjectPipelineEnded("feature-1966-x", "0"), ended); err != nil { t.Fatal(err) } gone := false @@ -1322,69 +682,6 @@ func TestIndexerBuildsARunsCandidateAndDropsItWhenEveryMembersPipelineEnded(t *t } } -// TestIndexerJudgesAnUnreadableVerdictAgainAtStart: the modules bucket holds avahi as an older SDK wrote it, with the reason -// 'the manifest cannot be read', the inputs the merge carried (the tree, the lock hash by file name) and the digest of its -// manifest, which manifests. holds and the running SDK reads; the go toolchain is reported. Within 20 s of the start -// and with no repository merge the value carries a fingerprint and no reason (issue 1923). -func TestIndexerJudgesAnUnreadableVerdictAgainAtStart(t *testing.T) { // 1923/AC3 - manifest, err := os.ReadFile("../../internal/index/testdata/catalogue-a67f0196-avahi.module.json") - if err != nil { - t.Fatal(err) - } - const goSum = "3b5028f0c1e9bde04dd766abd63eb5931bc516bae695cf46f00abcd8510b0381" - digest := meshcatalogclient.ManifestDigest(manifest) - _, ctx, _, modules := startIndexer(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) { - mkey, err := meshcatalogclient.ManifestsKey(digest) - if err != nil { - t.Fatal(err) - } - mdata, err := meshcatalogclient.EncodeManifest(meshcatalog.ManifestsByDigestValue{Module: "avahi", Manifest: string(manifest)}) - if err != nil { - t.Fatal(err) - } - manifests, err := js.KeyValue(ctx, index.Bucket(testIndexer, index.ManifestsState)) - if err != nil { - t.Fatal(err) - } - if _, err := manifests.Put(ctx, mkey, mdata); err != nil { - t.Fatal(err) - } - // The view the indexer starts from is the newest trunk revision its objects keep (milestone 47/G). - stale := meshcatalog.ModulesByModuleValue{Repository: "novox/mesh-catalog", Commit: "89abcdef0123456789abcdef0123456789abcdef", Path: "modules/avahi", - Manifest: digest, None2: "the manifest cannot be read: claims node-build-go, which is a seat in the mesh's own namespace that it does not define", - Inputs2: &meshcatalog.ModulesByModuleValueInputs2{Tree: "tree-avahi", Locks: map[string]string{"go.sum": goSum}}} - seedBuildModules(t, ctx, js, map[string]meshcatalog.CatalogEntry{"avahi": index.CatalogEntryOf("avahi", stale, catalogue.Manifest{}, "", graph.Node{None: stale.None2})}) - kv, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.ToolchainsBucket("mesh-build-go"), History: 1}) - if err != nil { - t.Fatal(err) - } - key, err := index.ToolchainKey("n1", "go") - if err != nil { - t.Fatal(err) - } - value, err := index.EncodeToolchain(nodebuildgo.Toolchain{Language: "go", Version: "go1.27.1", Recipe: "1", At: ptr(time.Now())}) - if err != nil { - t.Fatal(err) - } - if _, err := kv.Put(ctx, key, value); err != nil { - t.Fatal(err) - } - }) - var got meshcatalog.ModulesByModuleValue - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if e, err := modules.Get(ctx, "avahi"); err == nil { - if m, err := meshcatalogclient.DecodeModule(e.Value()); err == nil { - if got = m; got.Fp2 != "" { - break - } - } - } - } - if got.Fp2 == "" || got.None2 != "" { - t.Errorf("avahi = fp2 %q none2 %q within 20 s of the start, want a fingerprint and no reason", got.Fp2, got.None2) - } -} - // TestIndexerCountsOnlyThePlacedBuildNodesToolchains (issue 1940, issue 774): the toolchains bucket holds the report of // n2, where the catalogue no longer places mesh-build-go, at another version than n1's, as ace's v26.12.0 stayed beside // the v26.12.1 of the nodes mesh-build-node runs on. The indexer gives the merged module a fingerprint from n1's @@ -1392,10 +689,6 @@ func TestIndexerJudgesAnUnreadableVerdictAgainAtStart(t *testing.T) { // 1923/AC // disagree (the guard stays); when it is taken off again, the fingerprint comes back. No restart, no timer: the // assignments's watch (ADR 0549 §3), not the controller's assignments. func TestIndexerCountsOnlyThePlacedBuildNodesToolchains(t *testing.T) { - manifest, err := os.ReadFile("../../internal/index/testdata/catalogue-a67f0196-avahi.module.json") - if err != nil { - t.Fatal(err) - } const goSum = "3b5028f0c1e9bde04dd766abd63eb5931bc516bae695cf46f00abcd8510b0381" var assignments, toolchains jetstream.KeyValue place := func(ctx context.Context, t *testing.T, node string, modules ...string) { @@ -1418,7 +711,8 @@ func TestIndexerCountsOnlyThePlacedBuildNodesToolchains(t *testing.T) { up := make(chan struct{}) assignerLate = up t.Cleanup(func() { assignerLate = nil }) - js, ctx, _, modules := startIndexer(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) { + js, ctx, _, modules, restart := startIndexerRun(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) { + registerAvahi(t, ctx, js, "main") kv, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.ToolchainsBucket("mesh-build-go"), History: 1}) if err != nil { t.Fatal(err) @@ -1444,17 +738,10 @@ func TestIndexerCountsOnlyThePlacedBuildNodesToolchains(t *testing.T) { seedBuildModules(t, ctx, js, nil) }) close(up) - data, err := forgemsg.EncodeForge(forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-catalog", Branch: "feat/x", Number: 302, - Head: "0123456789abcdef0123456789abcdef01234567", Merge: "89abcdef0123456789abcdef0123456789abcdef", Root: "r0", - Trees: map[string]string{"modules/avahi": "newtree"}, - Manifests: map[string]string{"modules/avahi": string(manifest)}, - Locks: map[string]map[string]string{"modules/avahi": {"go.sum": goSum}}}) - if err != nil { - t.Fatal(err) - } - if _, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event.forge.novox.mesh-catalog.merged", data); err != nil { - t.Fatal(err) - } + // The gate names the catalogue's commit as main's first source revision; the indexer reads it through the seat git. + forge := serveCommits(t, js.Conn()) + forge.put("89abcdef0123456789abcdef0123456789abcdef", catalogueAt(t, "newtree")) + sayMoved(t, ctx, js, "main", 10, "89abcdef0123456789abcdef0123456789abcdef", true) read := func(ok func(meshcatalog.ModulesByModuleValue) bool) meshcatalog.ModulesByModuleValue { var got meshcatalog.ModulesByModuleValue for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { @@ -1485,27 +772,28 @@ func TestIndexerCountsOnlyThePlacedBuildNodesToolchains(t *testing.T) { t.Fatal(err) } // n2's report, written since its assignments, counts: the builders disagree. A fingerprint already computed is kept - // (issue 1940), and only a new one needs the agreement: a merge moving avahi gets none until they agree. - time.Sleep(500 * time.Millisecond) + // (issue 1940), and only a new one needs the agreement: a take-in moving avahi gets none until they agree. The indexer is + // started again so that it has followed the assignments before the take-in (its start reads them before any branch's + // source-moved), with no sleep. + restart() if e, err := modules.Get(ctx, "avahi"); err != nil { t.Fatal(err) } else if m, err := meshcatalogclient.DecodeModule(e.Value()); err != nil || m.Fp2 != held.Fp2 { t.Fatalf("after n2's assignments avahi has fp2 %q, none2 %q: want its fingerprint %q kept", m.Fp2, m.None2, held.Fp2) } - moved := strings.Replace(string(data), `"newtree"`, `"movedtree"`, 1) - if moved == string(data) { - t.Fatal("the merge names no tree to move") - } - if _, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event.forge.novox.mesh-catalog.merged", []byte(moved)); err != nil { - t.Fatal(err) - } + forge.put("9999999999999999999999999999999999999999", catalogueAt(t, "movedtree")) + sayMoved(t, ctx, js, "main", 11, "9999999999999999999999999999999999999999", false) disagree := func(m meshcatalog.ModulesByModuleValue) bool { return m.Fp2 == "" && strings.HasPrefix(m.None2, "builders disagree: go1.27 recipe 1 on n1; go1.28 recipe 1 on n2") } if m := read(disagree); !disagree(m) { t.Fatalf("within 20 s of a merge after n2's assignments avahi has fp2 %q, none2 %q: want the builders to disagree", m.Fp2, m.None2) } + // The view moves only at a take-in (design 47 H-A-49, H-A-103): with n2's assignments taken away, the next take-in agrees. place(ctx, t, "n2") + restart() + forge.put("8888888888888888888888888888888888888888", catalogueAt(t, "thirdtree")) + sayMoved(t, ctx, js, "main", 12, "8888888888888888888888888888888888888888", false) if m := read(agreed); !agreed(m) { t.Fatalf("within 20 s of n2's assignments taken away avahi has fp2 %q, none2 %q", m.Fp2, m.None2) } @@ -1536,7 +824,7 @@ func serveAssignerAssignments(t *testing.T, ctx context.Context, js jetstream.Je } if _, err := js.CreateOrUpdateConsumer(ctx, "EVENTS", jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-indexer", AckPolicy: jetstream.AckExplicitPolicy, // and the build seat's step-ended the manifest's consumes names (design 47 G §713: the end of a validation ask). - FilterSubjects: []string{"mesh.mod." + assignerHolderModule + ".event.views.>", "mesh.seat.mesh-delivery.event.>", nodebuildgo.SubjectStepEndedAll}}); err != nil { + FilterSubjects: []string{"mesh.mod." + assignerHolderModule + ".event.views.>", meshcatalog.SubjectRoom, nodebuildgo.SubjectStepEndedAll}}); err != nil { t.Fatal(err) } em := views.Emitter{Owner: assignerHolderModule, Subject: process.Account{Node: "n1", Module: assignerHolderModule}.EventSubject, @@ -1614,114 +902,3 @@ func TestIndexerKeepsWhatAWantAndARunningBuildNameAndLetsAGoneOneLeave(t *testin t.Errorf("named holds %v after the want of n2 was said removed, want n1.avahi alone", got) } } - -// TestIndexerAppliesThePinsEventsThroughItsDurableConsumer (design 47 G §153, §216, §579, A-169, A-171, A-176): a pinned of a revision the -// indexer does not hold and a pins-stated, said on the seat mesh-delivery, are applied to the state pins through its durable consumer (the -// key `.` marked missing, the record listed, `made` and `pins-stated` kept), and the consumer's facts reach the state -// consumers for indexer_consumer. -func TestIndexerAppliesThePinsEventsThroughItsDurableConsumer(t *testing.T) { - js, ctx, _, _ := startIndexer(t, func(context.Context, buildLog) {}) - say := func(subject string, body any) { - raw, _ := json.Marshal(body) - if _, err := js.Publish(ctx, subject, raw); err != nil { - t.Fatal(err) - } - } - say(meshdelivery.SubjectPinned, meshdelivery.Pins{Record: "r1", Milestone: "47/G", Catalog: []meshdelivery.PinsCatalogItem{{Branch: "main", Revision: 9}}}) - say(meshdelivery.SubjectPinsStated, meshdelivery.PinsStatedEvent{At: time.Now().UTC().Add(time.Minute)}) - pins, err := js.KeyValue(ctx, index.Bucket(testIndexer, index.PinsState)) - if err != nil { - t.Fatal(err) - } - consumers, err := js.KeyValue(ctx, testIndexer+"_"+process.ConsumersState) - if err != nil { - t.Fatal(err) - } - var v index.PinValue - var f process.ConsumerFacts - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - e, err := pins.Get(ctx, "main.9") - c, cerr := consumers.Get(ctx, "n1_mesh-delivery-indexer") - if _, serr := pins.Get(ctx, index.PinsStatedKey); err == nil && cerr == nil && serr == nil && - json.Unmarshal(e.Value(), &v) == nil && json.Unmarshal(c.Value(), &f) == nil && f.LastEvent == meshdelivery.SubjectPinsStated { - break - } - } - if !slices.Equal(v.Records, []string{"r1"}) || !v.Missing { - t.Errorf("pins main.9 holds %+v within 20 s, want record r1 and missing", v) - } - if f.Stream != "EVENTS" || f.Acknowledged == 0 || f.LastEvent != meshdelivery.SubjectPinsStated { - t.Errorf("consumers holds %+v, want the pins-stated applied on EVENTS", f) - } -} - -// TestIndexerTakesInAWatchedBranchOtherThanTheFirstIntoItsOwnRevision: the seat's verb source lists a second watched branch, -// beta, with the merge of mesh-catalog it names as its head (design 47 G §13, §14, §291, A-93); the indexer started with the -// branch listed reads source.beta, takes the head's merged message in as a pure computation, and keeps branch.beta.1, which -// the branch follower (index.BranchView, as the branch's builds read it) reads; the trunk's modules are left. -func TestIndexerTakesInAWatchedBranchOtherThanTheFirstIntoItsOwnRevision(t *testing.T) { - manifest, err := os.ReadFile("../../internal/index/testdata/catalogue-a67f0196-avahi.module.json") - if err != nil { - t.Fatal(err) - } - const merge = "89abcdef0123456789abcdef0123456789abcdef" - data, err := forgemsg.EncodeForge(forgemsg.Forge{Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-catalog", Branch: "beta", Number: 301, - Head: "0123456789abcdef0123456789abcdef01234567", Merge: merge, Root: "r0", - Trees: map[string]string{"modules/avahi": "betatree"}, Manifests: map[string]string{"modules/avahi": string(manifest)}, - Locks: map[string]map[string]string{"modules/avahi": {"go.sum": "3b5028f0c1e9bde04dd766abd63eb5931bc516bae695cf46f00abcd8510b0381"}}}) - if err != nil { - t.Fatal(err) - } - js, ctx, _, modules := startIndexer(t, func(ctx context.Context, builds buildLog) { - builds.end(t, "novox/mesh-controller", "build-agent", "modules/build-agent") - }, func(ctx context.Context, js jetstream.JetStream) { - seedBuildModules(t, ctx, js, nil) - source := func(m *nats.Msg) { - var ask struct{ Branch string } - _ = json.Unmarshal(m.Data, &ask) - answer := meshdelivery.SourceAnswer{Branch: ask.Branch} - switch ask.Branch { - case "": - answer.Branches = []string{"main", "beta"} - case "beta": - answer.Group, answer.Revision = "g", 9 - answer.Repositories = []meshdelivery.SourceHead{{Repository: "novox/mesh-catalog", Head: merge, Trunk: "beta"}} - } - raw, _ := json.Marshal(map[string]any{"result": answer, "node": "n1"}) - _ = m.Respond(raw) - } - bridge := func(m *nats.Msg) { - raw, _ := json.Marshal(map[string]any{"result": map[string]any{"message": json.RawMessage(data)}, "node": "n1"}) - _ = m.Respond(raw) - } - for subject, h := range map[string]nats.MsgHandler{ - "mesh.seat.mesh-delivery.call.source.>": source, "mesh.seat.mesh-delivery.tool.source": source, - "mesh.mod.mesh-delivery-forge-bridge.call.bridge_merged_message.>": bridge, "mesh.mod.mesh-delivery-forge-bridge.tool.bridge_merged_message": bridge, - } { - if _, err := js.Conn().Subscribe(subject, h); err != nil { - t.Fatal(err) - } - } - }) - objects := newBusObjects(js, testAccount, index.CatalogRevisionsObjects) - var view index.Store - var at int64 - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline) && at == 0; time.Sleep(50 * time.Millisecond) { - if v, _, n, err := index.BranchView(ctx, objects, "beta"); err == nil { - view, at = v, n - } - } - if at != 1 { - t.Fatalf("the branch follower reads beta at revision %d within 20 s of the start, want 1", at) - } - value, _, found, err := view.Get(ctx, "avahi") - if err != nil || !found { - t.Fatalf("branch.beta.1 holds no avahi (%v)", err) - } - if m, err := meshcatalogclient.DecodeModule(value); err != nil || m.Commit != merge || m.Inputs2 == nil { - t.Errorf("avahi at the branch's head = %+v (%v), want commit %s with its inputs", m, err, merge) - } - if e, err := modules.Get(ctx, "avahi"); err == nil { - t.Errorf("modules.avahi = %s, want the trunk's modules left", e.Value()) - } -} diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/packages_integration_test.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/packages_integration_test.go index 7751e791..b50fe15a 100644 --- a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/packages_integration_test.go +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/packages_integration_test.go @@ -5,45 +5,69 @@ package main import ( "context" "encoding/json" - "errors" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git" "os" + "slices" + "strconv" "strings" "testing" "time" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/nodebuildgo" - - "github.com/nats-io/nats.go" "github.com/nats-io/nats.go/jetstream" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" "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-forge-bridge/forgemsg" - "git.novox.be/novox/mesh-sdk/go/buscompose" - "git.novox.be/novox/mesh-sdk/go/catalogue" - "git.novox.be/novox/mesh-sdk/go/seatdef" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/nodebuildgo" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdeliverychecker" - - "mesh-delivery-indexer/internal/fingerprint" "mesh-delivery-indexer/internal/index" ) -// TestAMeshSDKMergeMovesOnlyTheModulesImportingAChangedPackage (ADR 0593 §2-§4; D11): the indexer whole against the -// bus. Two Go modules of the catalogue whose go.sum names mesh-sdk; their builds end reporting their imports (importer: -// buildstep; plain: announce); then mesh-sdk merges a change of buildstep alone, which moves mesh-sdk's version. Within -// 20 s the packages key of mesh-sdk/go names the merge with a digest per package, importer gets a new fingerprint, and -// plain keeps the one it had, though the version line would have moved it. The forge's tools answer on the bus as the -// gitea module's do. A merge of go/ alone before it writes no value of mesh-sdk, whose tree is its named paths'. -func TestAMeshSDKMergeMovesOnlyTheModulesImportingAChangedPackage(t *testing.T) { +// untilModule follows the catalog revisions until the trunk's view holds name with cond true: read again at each revision kept. +func untilModule(t *testing.T, ctx context.Context, js jetstream.JetStream, name string, cond func(meshcatalog.ModulesByModuleValue) bool) meshcatalog.ModulesByModuleValue { + t.Helper() + obs, err := js.ObjectStore(ctx, newBusObjects(nil, testAccount, index.CatalogRevisionsObjects).bucket()) + if err != nil { + t.Fatal(err) + } + wctx, cancel := context.WithTimeout(ctx, waitBound) + defer cancel() + w, err := obs.Watch(wctx) + if err != nil { + t.Fatal(err) + } + defer func() { _ = w.Stop() }() + var m meshcatalog.ModulesByModuleValue + read := func() bool { + e, err := revisionView{js: js}.Get(ctx, name) + if err != nil { + return false + } + m, err = meshcatalogclient.DecodeModule(e.Value()) + return err == nil && cond(m) + } + if read() { + return m + } + for range w.Updates() { + if read() { + return m + } + } + t.Fatalf("modules.%s = %+v after %s", name, m, waitBound) + return m +} + +// TestASourceRevisionMovingMeshSDKNamesItAndItsImporters (design 47 H §743; A-476a; ADR 0593 §2 to §4): the indexer whole against +// the bus. Two Go modules of the catalogue, importer, whose go.sum requires mesh-sdk's Go module, and plain, which requires +// nothing of it, are taken in with mesh-sdk as main's first source revision. A source revision moving mesh-sdk to a commit +// changing its buildstep package is taken in as one revision whose movers are mesh-sdk and importer, of another repository, +// and not plain; the packages key of mesh-sdk/go names that commit with a digest per package. +func TestASourceRevisionMovingMeshSDKNamesItAndItsImporters(t *testing.T) { const ( sdkGo = "git.novox.be/novox/mesh-sdk/go" m1, m2 = "1111111111111111111111111111111111111111", "2222222222222222222222222222222222222222" catalogMerge = "3333333333333333333333333333333333333333" goSumContent = "git.novox.be/novox/mesh-sdk/go v0.1.14 h1:x=\ngit.novox.be/novox/mesh-sdk/go v0.1.14/go.mod h1:y=\n" - goSumHash = "3b5028f0c1e9bde04dd766abd63eb5931bc516bae695cf46f00abcd8510b0381" sdkRoot1, sdk2 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" ) avahi, err := os.ReadFile("../../internal/index/testdata/catalogue-a67f0196-avahi.module.json") @@ -54,20 +78,27 @@ func TestAMeshSDKMergeMovesOnlyTheModulesImportingAChangedPackage(t *testing.T) if err != nil { t.Fatal(err) } + // mesh-sdk publishes its Go module as a package artifact beside its TypeScript one, as its manifest names it today. + sdkManifest = []byte(strings.Replace(string(sdkManifest), `"artifacts": [`, `"artifacts": [{"name": "go", "kind": "package", "language": "go", "paths": ["go"]}, `, 1)) named := func(module string) string { return strings.Replace(string(avahi), `"module": "avahi"`, `"module": "`+module+`"`, 1) } - // mesh-sdk's go directory at each merge: m2 changes buildstep alone. - listing := map[string]map[string]string{ - m1: {"go.mod": "f1", "go.sum": "f2", "stdio.go": "f3", "announce/announce.go": "f4", "buildstep/step.go": "f5"}, - m2: {"go.mod": "f1", "go.sum": "f2", "stdio.go": "f3", "announce/announce.go": "f4", "buildstep/step.go": "f6"}, + // mesh-sdk at each commit: m2 changes buildstep alone, and the objects of its named paths. + sdkAt := func(root, step, src string) repoAt { + return repoAt{trees: map[string]string{"": root}, files: map[string]string{"module.json": string(sdkManifest), "go/go.mod": "module " + sdkGo + "\n\ngo 1.26\n", "package.json": `{"name": "@novox/mesh-sdk"}`}, + listing: map[string]map[string]string{"go": {"go.mod": "f1", "go.sum": "f2", "stdio.go": "f3", "announce/announce.go": "f4", "buildstep/step.go": step}}, + paths: map[string]map[string]string{"": {"go": "9" + src[1:], "src": src, "test": "2222222222222222222222222222222222222222", + "package.json": "3333333333333333333333333333333333333333", "package-lock.json": "4444444444444444444444444444444444444444", + "tsconfig.json": "5555555555555555555555555555555555555555"}}} } - var packages, seatDefs, findings, takeIns jetstream.KeyValue - js, ctx, _, modules := startIndexer(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) { + var packages jetstream.KeyValue + var heard *takeIns + js, ctx, _, _ := startIndexer(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) { var err error if packages, err = js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.PackagesState), History: index.PackagesHistory}); err != nil { t.Fatal(err) } + // The state taken, which names each repository's taken commit the packages are published at (ADR 0593 §2). if _, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.TakenState), History: 1}); err != nil { t.Fatal(err) } @@ -83,427 +114,53 @@ func TestAMeshSDKMergeMovesOnlyTheModulesImportingAChangedPackage(t *testing.T) t.Fatal(err) } } - serveForge(t, js.Conn(), listing, goSumContent) - // The seat definitions' state (DLV-I17), as the grants part makes it from the manifest. - if seatDefs, err = js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.SeatDefinitionsState), History: 5}); err != nil { - t.Fatal(err) - } - // DLV-I19, I20: the indexer's findings and takeins states, and the checker's stream asks with the indexer's durable - // consumer, which carries the checker's verdict event. - if findings, err = js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: findingsBucket, History: 1}); err != nil { - t.Fatal(err) - } - if takeIns, err = js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.TakeInsState), History: 1}); err != nil { - t.Fatal(err) + forge := serveCommits(t, js.Conn()) + forge.put(m1, sdkAt(sdkRoot1, "f5", "6666666666666666666666666666666666666666")) + forge.put(m2, sdkAt(sdk2, "f6", "7777777777777777777777777777777777777777")) + forge.put(catalogMerge, repoAt{trees: map[string]string{"modules/importer": "t1", "modules/plain": "t2"}, + files: map[string]string{"modules/importer/module.json": named("importer"), "modules/plain/module.json": named("plain"), + "modules/importer/go.sum": goSumContent, "modules/plain/go.sum": "golang.org/x/sys v0.1.0 h1:x=\n"}}) + regs := registerAvahi(t, ctx, js, "main") + for _, r := range []meshcatalog.Registration{{V: 1, Module: "importer", Origin: "novox/mesh-catalog", Path: "modules/importer", Branches: []string{"main"}}, + {V: 1, Module: "plain", Origin: "novox/mesh-catalog", Path: "modules/plain", Branches: []string{"main"}}, + {V: 1, Module: "mesh-sdk", Origin: "novox/mesh-sdk", Path: ".", Branches: []string{"main"}}} { + raw, _ := json.Marshal(r) + if _, err := regs.Put(ctx, index.RegistrationKey(r.Module), raw); err != nil { + t.Fatal(err) + } } seedBuildModules(t, ctx, js, nil) - if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: checkerAsksStream, Subjects: []string{meshdeliverychecker.HolderSubjectVerdict(index.CheckerModule)}}); err != nil { - t.Fatal(err) - } - if _, err := js.CreateOrUpdateConsumer(ctx, checkerAsksStream, jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-indexer", AckPolicy: jetstream.AckExplicitPolicy}); err != nil { - t.Fatal(err) - } + heard = hearTakeIns(t, js.Conn()) }) - merged := func(repo string, number int, merge string, f forgemsg.Forge) { + say := func(source int64, start bool, heads ...meshdelivery.SourceMovedEventHeadsItem) { t.Helper() - f.Kind, f.Repository, f.Branch, f.Number, f.Head, f.Merge = forgemsg.ForgeMerged, repo, "feat/x", number, "0123456789abcdef0123456789abcdef01234567", merge - data, err := forgemsg.EncodeForge(f) - if err != nil { - t.Fatal(err) - } - if _, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event.forge."+strings.ReplaceAll(repo, "/", ".")+".merged", data); err != nil { + raw, _ := json.Marshal(meshdelivery.SourceMovedEvent{V: 1, Branch: "main", Source: source, Call: "0123456789abcdef", Start: start, Heads: heads}) + if _, err := js.Publish(ctx, meshdelivery.SubjectSourceMoved("main", strconv.FormatInt(source, 10)), raw); err != nil { t.Fatal(err) } } - module := func(name string, ok func(meshcatalog.ModulesByModuleValue) bool) meshcatalog.ModulesByModuleValue { - t.Helper() - var m meshcatalog.ModulesByModuleValue - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if e, err := modules.Get(ctx, name); err == nil { - if m, err = meshcatalogclient.DecodeModule(e.Value()); err == nil && ok(m) { - return m - } - } - } - t.Fatalf("modules.%s = %+v within 20 s", name, m) - return m - } - sdkObjects := func(src string) map[string]map[string]string { - return map[string]map[string]string{"": {"src": src, "test": "2222222222222222222222222222222222222222", - "package.json": "3333333333333333333333333333333333333333", "package-lock.json": "4444444444444444444444444444444444444444", - "tsconfig.json": "5555555555555555555555555555555555555555"}} - } - // mesh-sdk at m1, then the catalogue's two modules: their go.sum names mesh-sdk, read by the indexer itself. - merged("novox/mesh-sdk", 70, m1, forgemsg.Forge{Root: sdkRoot1, Trees: map[string]string{"": sdkRoot1}, - Manifests: map[string]string{"": string(sdkManifest)}, Paths: sdkObjects("6666666666666666666666666666666666666666")}) - module("mesh-sdk", func(m meshcatalog.ModulesByModuleValue) bool { return m.Commit == m1 }) - merged("novox/mesh-catalog", 301, catalogMerge, forgemsg.Forge{Root: "r0", - Trees: map[string]string{"modules/importer": "t1", "modules/plain": "t2"}, - Manifests: map[string]string{"modules/importer": named("importer"), "modules/plain": named("plain")}, - Locks: map[string]map[string]string{"modules/importer": {"go.sum": goSumHash}, "modules/plain": {"go.sum": goSumHash}}}) - // The toolchain is reported, and each module gets its fingerprint of the version line. - for _, l := range []string{"go", "node"} { - if _, err := js.Publish(ctx, "mesh.stream.mesh-build-"+l+".event.toolchain.reported", []byte(`{"node":"n1","language":"`+l+`"}`)); err != nil { - t.Fatal(err) - } - } - hasFP := func(m meshcatalog.ModulesByModuleValue) bool { return m.Fp2 != "" && m.Packages[sdkGo] == m1 } - importer, plain := module("importer", hasFP), module("plain", hasFP) - - // Each build ends reporting its imports: kept, no fingerprint moving. - for _, b := range []struct { - m meshcatalog.ModulesByModuleValue - name string - imports []string - }{{importer, "importer", []string{sdkGo, sdkGo + "/buildstep"}}, {plain, "plain", []string{sdkGo, sdkGo + "/announce"}}} { - raw, err := builds.EncodeBuildLogEntry(builds.BuildLogEntry{Event: builds.BuildEndedEvent, Module: b.name, FP: b.m.Fp2, - Repository: "novox/mesh-catalog", Directory: "modules/" + b.name, Commit: catalogMerge, Ref: "main", Node: "n1", - At: time.Now().UTC(), Outcome: builds.BuildDone, Imports: b.imports}) - if err != nil { - t.Fatal(err) - } - if _, err := js.Publish(ctx, buscompose.LogSubject(builds.BuilderModule, builds.BuilderLog)+"."+b.name, raw); err != nil { - t.Fatal(err) - } - fp := b.m.Fp2 - module(b.name, func(m meshcatalog.ModulesByModuleValue) bool { - return m.Inputs2 != nil && m.Inputs2.ImportForm != "" && m.Fp2 == fp - }) + say(10, true, meshdelivery.SourceMovedEventHeadsItem{Repository: "novox/mesh-sdk", Commit: m1}, meshdelivery.SourceMovedEventHeadsItem{Repository: "novox/mesh-catalog", Commit: catalogMerge}) + heard.next(t, "main", 10) + heard.acked(t, "main") + untilModule(t, ctx, js, "importer", func(m meshcatalog.ModulesByModuleValue) bool { return m.Fp2 != "" && m.Packages[sdkGo] == m1 }) + plain := untilModule(t, ctx, js, "plain", func(m meshcatalog.ModulesByModuleValue) bool { return m.Fp2 != "" }) + if _, ok := plain.Packages[sdkGo]; ok { + t.Fatalf("plain requires %s: %+v", sdkGo, plain.Packages) } - // mesh-sdk merges a change of go/ alone that leaves its own named paths' objects: its value, a TypeScript package's - // over its named tree, is not written (issue 1758, ADR 0499 clause 6; the operator, 2026-10-25: a module's value moves - // only with the module). - const goOnly = "4444444444444444444444444444444444444444" - merged("novox/mesh-sdk", 72, goOnly, forgemsg.Forge{Root: "cccccccccccccccccccccccccccccccccccccccc", - Trees: map[string]string{"": "cccccccccccccccccccccccccccccccccccccccc"}, Manifests: map[string]string{"": string(sdkManifest)}, - Paths: sdkObjects("6666666666666666666666666666666666666666")}) - // mesh-sdk merges a change of buildstep alone (its version moves: src changed too). - merged("novox/mesh-sdk", 71, m2, forgemsg.Forge{Root: sdk2, Trees: map[string]string{"": sdk2}, - Manifests: map[string]string{"": string(sdkManifest)}, Paths: sdkObjects("7777777777777777777777777777777777777777")}) - sdkAt2 := module("mesh-sdk", func(m meshcatalog.ModulesByModuleValue) bool { return m.Commit == m2 }) - if sdkAt2.Inputs2 == nil || !strings.HasPrefix(sdkAt2.Inputs2.Tree, fingerprint.NamedTreePrefix) { - t.Errorf("mesh-sdk's kept inputs %+v, want a named tree", sdkAt2.Inputs2) + say(11, false, meshdelivery.SourceMovedEventHeadsItem{Repository: "novox/mesh-sdk", Commit: m2}) + taken := heard.next(t, "main", 11) + var movers []string + for _, e := range taken.Entries { + movers = append(movers, e.Module) } - history, err := modules.History(ctx, "mesh-sdk") - if err != nil { - t.Fatal(err) - } - for _, e := range history { - if m, err := meshcatalogclient.DecodeModule(e.Value()); err == nil && m.Commit == goOnly { - t.Errorf("the go/-only merge wrote mesh-sdk's value: %+v", m) - } + slices.Sort(movers) + if !slices.Equal(movers, []string{"importer", "mesh-sdk"}) { + t.Errorf("the take-in of mesh-sdk at %s names the movers %v, want mesh-sdk and its importer, not plain", m2, movers) } key, _ := index.PackagesKey(sdkGo) - var pub meshcatalog.PackagesByModuleValue - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if e, err := packages.Get(ctx, key); err == nil { - if pub, err = index.DecodePublishedPackages(e.Value()); err == nil && pub.Commit == m2 { - break - } - } - } - if pub.Commit != m2 || len(pub.Packages) != 3 { - t.Fatalf("packages.%s = %+v within 20 s, want the merge %s with a digest of go, announce and buildstep", key, pub, m2) - } - // A-476a: mesh-sdk's merge moves importer, of another repository, which imports a package it moved. - moved := module("importer", func(m meshcatalog.ModulesByModuleValue) bool { return m.Fp2 != importer.Fp2 }) - if moved.Packages[sdkGo] != m2 { - t.Errorf("importer moved to %+v, want it built against %s", moved.Packages, m2) - } - // plain imports nothing that changed: its value keeps its fingerprint (one recompute has run: importer moved in it). - if now := module("plain", func(meshcatalog.ModulesByModuleValue) bool { return true }); now.Fp2 != plain.Fp2 { - t.Errorf("plain moved from %s to %s, though it imports nothing the merge changed", plain.Fp2, now.Fp2) - } - - // DLV-I17, I18 (research 081 test 21, design 26): mesh-contracts merges a valid definition, said once; a pull - // request's head whose definition does not parse is kept as its entry naming why while the trunk's stays; it closes - // and its entry goes. - const contractsMerge, badHead = "5555555555555555555555555555555555555555", "6666666666666666666666666666666666666666" - git := `{"format":1,"seat":"git","scope":"mesh","grain":"seat-list","decision":"novox/hq ADR 0111","domain":"Core","delivers":"git"}` - // No index names the seats: the indexer lists the module's `seats/` directory (ADR 0635 §6, D-I5). - seatFiles[contractsMerge] = map[string]string{"seats/git/seat.json": git} - seatFiles[badHead] = map[string]string{"seats/git/seat.json": `{"format":1,"seat":"git"}`} - // The indexer starts with the two build seats and the seat mesh-module-assigner the fixture keeps (seedBuildModules, its claimant - // for A-302) and no other definition: the verb seat-definitions answers them at once (ADR 0636 §4, §8). - if got, err := index.SeatDefinitionsOf(jsSource{ctx, seatDefs}, nil, ""); err != nil || func() string { - list, _ := got.(index.SeatDefinitionList) - var names []string - for _, d := range list.Seats { - names = append(names, d.Seat) - } - return strings.Join(names, ",") - }() != "mesh-module-assigner,node-build-go,node-build-node" { - t.Errorf("seat-definitions of an indexer that kept the build seats and the assigner's alone = %+v, %v", got, err) - } - contracts := `{"module":"mesh-contracts","version":"1.0","build":{"artifacts":[{"name":"go","kind":"package","language":"go","paths":["go"],"series":"0.1","generated-from":"."}]}}` - merged("novox/mesh-contracts", 80, contractsMerge, forgemsg.Forge{Root: "dddddddddddddddddddddddddddddddddddddddd", - Trees: map[string]string{"": "dddddddddddddddddddddddddddddddddddddddd"}, Manifests: map[string]string{"": contracts}}) - entry := func(key string, ok func(index.SeatDefinitionEntry) bool) index.SeatDefinitionEntry { - t.Helper() - var e index.SeatDefinitionEntry - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if v, err := seatDefs.Get(ctx, key); err == nil && json.Unmarshal(v.Value(), &e) == nil && ok(e) { - return e - } - } - t.Fatalf("%s.%s = %+v within 20 s", index.SeatDefinitionsState, key, e) - return e - } - trunk := entry("git.trunk", func(e index.SeatDefinitionEntry) bool { return e.Commit == contractsMerge && e.Digest != "" }) - pull := func(action string) { - t.Helper() - data, _ := forgemsg.EncodeForge(forgemsg.Forge{Kind: forgemsg.ForgePull, Action: action, Repository: "novox/mesh-contracts", Branch: "feat/y", - Number: 81, Head: badHead, Dirs: []string{""}, DirsKnown: true, Manifests: map[string]string{"": contracts}}) - if _, err := js.Publish(ctx, "mesh.stream.mesh-delivery-forge-bridge.event.forge.novox.mesh-contracts.pull", data); err != nil { - t.Fatal(err) - } - } - pull(forgemsg.PullUpdated) - pk := index.SeatDefinitionKey("git", index.SourcePull, "novox/mesh-contracts", 81) - if bad := entry(pk, func(e index.SeatDefinitionEntry) bool { return e.Unparsed != "" }); !strings.Contains(bad.Unparsed, "scope") || bad.Definition != nil { - t.Errorf("the pull request's entry %+v, want why it does not parse and no definition", bad) - } - if now := entry("git.trunk", func(index.SeatDefinitionEntry) bool { return true }); now.Digest != trunk.Digest { - t.Errorf("the trunk's entry moved to %+v on a pull request's head", now) - } - pull(forgemsg.PullClosed) - for deadline := time.Now().Add(20 * time.Second); ; time.Sleep(50 * time.Millisecond) { - if _, err := seatDefs.Get(ctx, pk); errors.Is(err, jetstream.ErrKeyNotFound) { - break - } - if time.Now().After(deadline) { - t.Fatalf("%s is kept 20 s after its pull request closed", pk) - } - } - // The seat's events are on the shared events stream like every seat's. - info, err := js.Stream(ctx, "EVENTS") - if err != nil { - t.Fatal(err) - } - full, err := info.Info(ctx, jetstream.WithSubjectFilter("mesh.seat."+index.CatalogSeat+".event.seat-definition-changed")) - if err != nil { - t.Fatal(err) - } - // Said on the seat's subject: the trunk's git alone; a pull request's head (unparsed, then closed) says nothing (ADR 0636 §4). - if n := full.State.Subjects["mesh.seat."+index.CatalogSeat+".event.seat-definition-changed"]; n != 1 { - t.Errorf("seat-definition-changed said %d times, want 1", n) - } - if m, err := info.GetLastMsgForSubject(ctx, "mesh.seat.mesh-catalog.event.seat-definition-changed"); err != nil || - !strings.Contains(string(m.Data), `"seat":"git"`) || !strings.Contains(string(m.Data), `"source":"trunk"`) || !strings.Contains(string(m.Data), `"digest":"`+trunk.Digest+`"`) { - t.Errorf("seat-definition-changed = %v, %v; want {seat, source, digest} of the trunk's git", m, err) - } - - // DLV-I20 [i]: a pull request's check verdict naming out-of-step files keeps them; a trunk build end of the builder's log - // naming them raises generated-types-out-of-step, and only a clean build end of the same module clears it. DLV-I19 [i]: - // indexer_out_of_step answers both, from the states the indexer wrote. - verdict, _ := json.Marshal(meshdeliverychecker.VerdictHolderEvent{Repository: "novox/mesh-contracts", Pull: 82, Head: badHead, Verdict: "fail", OutOfStep: []string{"go/seats/git/types.go"}}) - if _, err := js.Publish(ctx, meshdeliverychecker.HolderSubjectVerdict(index.CheckerModule), verdict); err != nil { - t.Fatal(err) - } - logEnd := func(outcome string, files ...string) { - t.Helper() - raw, err := builds.EncodeBuildLogEntry(builds.BuildLogEntry{Event: builds.BuildEndedEvent, Module: "mesh-contracts", FP: "src2:mesh-contracts", - Repository: "novox/mesh-contracts", Directory: meshcatalogclient.RootPath, Commit: contractsMerge, Node: "n1", At: time.Now().UTC(), Outcome: outcome}) - if err != nil { - t.Fatal(err) - } - var e map[string]any - _ = json.Unmarshal(raw, &e) - if len(files) > 0 { - e["out-of-step"] = files // BuildLogEntry.OutOfStep, the builder's field (J3), written by its name here - } - raw, _ = json.Marshal(e) - if _, err := js.Publish(ctx, buscompose.LogSubject(builds.BuilderModule, builds.BuilderLog)+".mesh-contracts", raw); err != nil { - t.Fatal(err) - } - } - logEnd(builds.BuildFailed, "go/seats/git/types.go") - outOfStep := func(want int) []index.OutOfStepRow { - t.Helper() - var rows []index.OutOfStepRow - for deadline := time.Now().Add(20 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - if rows, err = index.OutOfStepOf(testIndexer, jsSource{ctx, seatDefs}, jsSource{ctx, findings}); err == nil && len(rows) == want { - return rows - } - } - t.Fatalf("indexer_out_of_step = %+v (%v) within 20 s, want %d rows", rows, err, want) - return nil - } - if rows := outOfStep(2); rows[0].Module != "mesh-contracts" || !strings.Contains(rows[0].Summary, "types.go") || rows[1].Pull != "novox/mesh-contracts#82" { - t.Errorf("indexer_out_of_step = %+v, want the trunk's finding and the pull request's files", rows) - } - // The finding was said by the indexer's finding writer on its own stream (design 47 G §689, A-30): finding-written. - findingWritten := func() bool { - st, err := js.Stream(ctx, findingsStream) - if err != nil { - return false - } - info, err := st.Info(ctx) - return err == nil && info.State.Msgs > 0 - } - for deadline := time.Now().Add(20 * time.Second); !findingWritten() && time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) { - } - if !findingWritten() { - t.Error("the out-of-step finding was written into the findings state but its finding-written was not said on the indexer's findings stream") - } - logEnd(builds.BuildDone) - if rows := outOfStep(1); rows[0].Source != index.SourcePull { - t.Errorf("after a clean build end indexer_out_of_step = %+v, want the pull request's files alone", rows) - } - - // DLV-I19 [i]: indexer_seat_definitions_again for a pull request, asked through the takeins state as the tool asks it, - // reads the head with its own manifest; indexer_seat_definition then answers the pull request's entry beside the trunk's. - const goodHead = "7777777777777777777777777777777777777777" - seatFiles[goodHead] = map[string]string{"module.json": contracts, - "seats/git/seat.json": strings.Replace(git, "ADR 0111", "ADR 0200", 1)} - key, value, err := index.NewSeatDefinitionsAgain("mesh-contracts", 83, goodHead, "the forge did not answer", "person.op", time.Now()) - if err != nil { - t.Fatal(err) - } - if _, err := takeIns.Put(ctx, key, value); err != nil { - t.Fatal(err) - } - p83 := index.SeatDefinitionKey("git", index.SourcePull, "novox/mesh-contracts", 83) - entry(p83, func(e index.SeatDefinitionEntry) bool { return e.Commit == goodHead && e.Digest != "" }) - if a, err := index.SeatDefinitionOf(jsSource{ctx, seatDefs}, nil, "git", "novox/mesh-contracts", 83); err != nil || a.Answered != "novox/mesh-contracts#83" || - a.Entry.Commit != goodHead || a.Trunk == nil || a.Trunk.Digest != trunk.Digest { - t.Errorf("indexer_seat_definition of the pull request = %+v, %v", a, err) - } - - // ADR 0636 §5, D-I3, D-I5: a seat of the mesh's own contracts is taken only from its domain's contracts module, and a move - // there is a handover in either merge order of the two trunks. `wants` (Provisioning) and `vault` (Identity and access) are - // held by mesh-contracts as an older indexer kept them. - seat := func(name, domain string) string { - return `{"format":1,"seat":"` + name + `","scope":"mesh","grain":"seat-list","decision":"d","domain":"` + domain + `"}` - } - for name, domain := range map[string]string{"wants": "Provisioning", "vault": "Identity and access"} { - var d seatdef.Definition - if err := json.Unmarshal([]byte(seat(name, domain)), &d); err != nil { - t.Fatal(err) - } - raw, _ := json.Marshal(d) - held, _ := json.Marshal(index.SeatDefinitionEntry{Seat: name, Source: index.SourceTrunk, Repository: "novox/mesh-contracts", Module: "mesh-contracts", - Directory: ".", Commit: "old", Digest: "old-" + name, Definition: raw}) - if _, err := seatDefs.Put(ctx, name+".trunk", held); err != nil { - t.Fatal(err) - } - } - const dropped, provisioningDef, identity = "8888888888888888888888888888888888888888", "9999999999999999999999999999999999999999", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" - seatFiles[dropped] = map[string]string{"seats/git/seat.json": git} // mesh-contracts without wants and vault - seatFiles[provisioningDef] = map[string]string{"seats/wants/seat.json": seat("wants", "Provisioning")} - seatFiles[identity] = map[string]string{"seats/vault/seat.json": seat("vault", "Identity and access")} - domainModule := func(name string) string { - return strings.Replace(contracts, `"mesh-contracts"`, `"`+name+`"`, 1) - } - // Order 1: the domain's module merges first (its own repository) and takes wants over. - merged("novox/mesh-provisioning", 90, provisioningDef, forgemsg.Forge{Root: "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", - Trees: map[string]string{"": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"}, Manifests: map[string]string{"": domainModule("mesh-provisioning-contracts")}}) - entry("wants.trunk", func(e index.SeatDefinitionEntry) bool { - return e.Module == "mesh-provisioning-contracts" && e.Commit == provisioningDef + untilKey(t, ctx, packages, key, func(v []byte) bool { + pub, err := index.DecodePublishedPackages(v) + return v != nil && err == nil && pub.Commit == m2 && len(pub.Packages) == 3 }) - // mesh-contracts then drops both: wants stays the domain module's; vault, whose module has not merged yet, is kept. - merged("novox/mesh-contracts", 91, dropped, forgemsg.Forge{Root: "dddddddddddddddddddddddddddddddddddddddd", - Trees: map[string]string{"": "dddddddddddddddddddddddddddddddddddddddd"}, Manifests: map[string]string{"": contracts}}) - entry("git.trunk", func(e index.SeatDefinitionEntry) bool { return e.Commit == contractsMerge }) - for _, k := range []string{"wants.trunk", "vault.trunk"} { - if _, err := seatDefs.Get(ctx, k); err != nil { - t.Fatalf("%s is gone after mesh-contracts dropped it: %v", k, err) - } - } - // Order 2 completed: the identity module merges afterwards and takes vault over. - merged("novox/mesh-identity", 92, identity, forgemsg.Forge{Root: "ffffffffffffffffffffffffffffffffffffffff", - Trees: map[string]string{"": "ffffffffffffffffffffffffffffffffffffffff"}, Manifests: map[string]string{"": domainModule("mesh-identity-and-access-contracts")}}) - entry("vault.trunk", func(e index.SeatDefinitionEntry) bool { - return e.Module == "mesh-identity-and-access-contracts" && e.Commit == identity - }) - // The seat list the verb answers: every trunk seat with its digest, the handed-over ones included, never a pull request's. - list, err := index.SeatDefinitionsOf(jsSource{ctx, seatDefs}, nil, "") - raw, _ := json.Marshal(list) - for _, want := range []string{`"seat":"git"`, `"seat":"vault"`, `"seat":"wants"`} { - if err != nil || !strings.Contains(string(raw), want) || strings.Contains(string(raw), `"source":"pull"`) { - t.Errorf("seat-definitions = %s, %v; want %s", raw, err, want) - } - } - // D-29: the indexer reads its own seat list as every part does, so the judge judges against the seats it said: the - // handed-over ones are known to catalogue (the test's seat list holds neither). - for deadline := time.Now().Add(10 * time.Second); ; time.Sleep(20 * time.Millisecond) { - _, wants := catalogue.SeatNamed("wants") - _, vault := catalogue.SeatNamed("vault") - if wants && vault { - break - } - if time.Now().After(deadline) { - t.Fatalf("the indexer's judge does not know the seats it said: wants %v, vault %v", wants, vault) - } - } - // Said: git, wants and vault changed once each beyond the first count; no removal for the handed-over seats. - if m, err := info.GetLastMsgForSubject(ctx, "mesh.seat.mesh-catalog.event.seat-definition-removed"); err == nil { - t.Errorf("a handover said seat-definition-removed: %s", m.Data) - } -} - -// seatFiles are mesh-contracts' files by commit, as the seat git's file answers them. -var seatFiles = map[string]map[string]string{} - -// serveForge answers the seat git's verbs on the bus as its holder, the forge module, does (milestone 47/G W4.15): trees -// (the trees of a commit, or with files the blobs under each directory of mesh-sdk's listing at that commit), file (every -// go.sum holds goSum; a seat definition the commit does not hold is absent) and contains. -func serveForge(t *testing.T, nc *nats.Conn, listing map[string]map[string]string, goSum string) { - t.Helper() - reply := func(m *nats.Msg, result any) { - raw, _ := json.Marshal(map[string]any{"result": result, "node": "n0"}) - _ = m.Respond(raw) - } - trees, err := nc.Subscribe("mesh.seat.git.tool.trees", func(m *nats.Msg) { - var a git.TreesInput - _ = json.Unmarshal(m.Data, &a) - out := git.TreesAnswer{Root: "r0", Trees: map[string]string{}, Commit: a.Commit} - if len(a.Files) > 0 { - out.Files = map[string]map[string]string{} - for _, d := range a.Files { - if a.Repository == "novox/mesh-sdk" && d == "go" && listing[a.Commit] != nil { - out.Files[d] = listing[a.Commit] - } - if fs, ok := seatFiles[a.Commit]; ok && strings.HasPrefix(d, "seats") { // a contracts module's seats/ directory (D-I5) - out.Files[d] = map[string]string{} - for p := range fs { - if rel, ok := strings.CutPrefix(p, d+"/"); ok { - out.Files[d][rel] = "blob" - } - } - } - } - } - reply(m, out) - }) - if err != nil { - t.Fatal(err) - } - file, err := nc.Subscribe("mesh.seat.git.tool.file", func(m *nats.Msg) { - var a git.FileInput - _ = json.Unmarshal(m.Data, &a) - if _, held := seatFiles[a.Ref]; held { // the seat definitions (DLV-I17): a path the commit does not hold is absent - if v, ok := seatFiles[a.Ref][a.Path]; ok { - reply(m, git.FileAnswer{Path: a.Path, Ref: a.Ref, Content: v}) - } else { - reply(m, git.FileAnswer{Path: a.Path, Ref: a.Ref, Absent: true}) - } - return - } - reply(m, git.FileAnswer{Path: a.Path, Ref: a.Ref, Content: goSum}) - }) - if err != nil { - t.Fatal(err) - } - // Each merge here is newer than the one before: a commit is in another only when it is that commit. - contains, err := nc.Subscribe("mesh.seat.git.tool.contains", func(m *nats.Msg) { - var a git.ContainsInput - _ = json.Unmarshal(m.Data, &a) - reply(m, git.ContainsAnswer{Commit: a.Commit, In: a.In, Contains: a.Commit == a.In}) - }) - if err != nil { - t.Fatal(err) - } - t.Cleanup(func() { _ = trees.Unsubscribe(); _ = file.Unsubscribe(); _ = contains.Unsubscribe() }) } diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/takein_integration_test.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/takein_integration_test.go new file mode 100644 index 00000000..f155742f --- /dev/null +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/takein_integration_test.go @@ -0,0 +1,559 @@ +//go:build integration + +package main + +import ( + "context" + "encoding/json" + "errors" + "os" + "strconv" + "strings" + "sync" + "testing" + "time" + + "github.com/nats-io/nats.go" + "github.com/nats-io/nats.go/jetstream" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git" + "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/meshdelivery" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/nodebuildgo" + stdio "git.novox.be/novox/mesh-sdk/go" + "git.novox.be/novox/mesh-sdk/go/keys" + + "mesh-delivery-indexer/internal/index" +) + +// waitBound is how long a bed waits for what the indexer says or writes; a wait is on the bus (an event, a watch), never a sleep. +const waitBound = 20 * time.Second + +// watchBranch makes the indexer's durable of one watched branch on the gate's source-moved, as the grants part makes it (design +// 47 H §743, H-A-30, H-A-90): __, one message at a time, its wait for an acknowledgement longer +// than any hold (§744). +func watchBranch(t *testing.T, ctx context.Context, js jetstream.JetStream, branch string) { + t.Helper() + if _, err := js.CreateOrUpdateConsumer(ctx, meshdelivery.StreamSourceMoved, jetstream.ConsumerConfig{ + Durable: "n1_mesh-delivery-indexer_" + keys.EscapeName(branch), AckPolicy: jetstream.AckExplicitPolicy, MaxAckPending: 1, AckWait: time.Hour, + FilterSubjects: []string{meshdelivery.SubjectSourceMoved(keys.EscapeName(branch), "*")}}); err != nil { + t.Fatal(err) + } +} + +// repoAt is one repository at one commit as the seat git answers it: each module directory's tree, and its files by path. +type repoAt struct { + trees map[string]string + files map[string]string + listing map[string]map[string]string // by directory, the blobs under it (the trees' files) + paths map[string]map[string]string // by directory, the objects of its named paths +} + +// forgeCommits answers the seat git's trees and file for the commits it holds, as the forge module does (A-190); a commit it +// does not hold is refused, a read the take-in cannot make. +type forgeCommits struct { + mu sync.Mutex + at map[string]repoAt +} + +func (f *forgeCommits) put(commit string, r repoAt) { + f.mu.Lock() + defer f.mu.Unlock() + f.at[commit] = r +} + +func (f *forgeCommits) get(commit string) (repoAt, bool) { + f.mu.Lock() + defer f.mu.Unlock() + r, ok := f.at[commit] + return r, ok +} + +// serveCommits serves the seat git's trees and file on the bus from what put holds. +func serveCommits(t *testing.T, nc *nats.Conn) *forgeCommits { + t.Helper() + f := &forgeCommits{at: map[string]repoAt{}} + reply := func(m *nats.Msg, result any) { + raw, _ := json.Marshal(map[string]any{"result": result, "node": "n0"}) + _ = m.Respond(raw) + } + refuse := func(m *nats.Msg, commit string) { + raw, _ := json.Marshal(map[string]any{"error": "the forge holds no commit " + commit}) + _ = m.Respond(raw) + } + trees, err := nc.Subscribe("mesh.seat.git.tool.trees", func(m *nats.Msg) { + var a git.TreesInput + _ = json.Unmarshal(m.Data, &a) + r, ok := f.get(a.Commit) + if !ok { + refuse(m, a.Commit) + return + } + out := git.TreesAnswer{Root: "r-" + a.Commit[:8], Commit: a.Commit, Trees: r.trees} + for _, d := range a.Files { + if l, ok := r.listing[d]; ok { + if out.Files == nil { + out.Files = map[string]map[string]string{} + } + out.Files[d] = l + } + } + for d := range a.Paths { + if p, ok := r.paths[d]; ok { + if out.Paths == nil { + out.Paths = map[string]map[string]string{} + } + out.Paths[d] = p + } + } + reply(m, out) + }) + if err != nil { + t.Fatal(err) + } + file, err := nc.Subscribe("mesh.seat.git.tool.file", func(m *nats.Msg) { + var a git.FileInput + _ = json.Unmarshal(m.Data, &a) + r, ok := f.get(a.Ref) + if !ok { + refuse(m, a.Ref) + return + } + if c, held := r.files[a.Path]; held { + reply(m, git.FileAnswer{Path: a.Path, Ref: a.Ref, Content: c}) + return + } + reply(m, git.FileAnswer{Path: a.Path, Ref: a.Ref, Absent: true}) + }) + if err != nil { + t.Fatal(err) + } + // Each commit here is newer than the one before: a commit is in another only when it is that commit. + contains, err := nc.Subscribe("mesh.seat.git.tool.contains", func(m *nats.Msg) { + var a git.ContainsInput + _ = json.Unmarshal(m.Data, &a) + reply(m, git.ContainsAnswer{Commit: a.Commit, In: a.In, Contains: a.Commit == a.In}) + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = trees.Unsubscribe(); _ = file.Unsubscribe(); _ = contains.Unsubscribe() }) + return f +} + +// catalogueAt is the catalogue repository with avahi's real manifest in modules/avahi at the tree given. +func catalogueAt(t *testing.T, tree string) repoAt { + t.Helper() + manifest, err := os.ReadFile("../../internal/index/testdata/catalogue-a67f0196-avahi.module.json") + if err != nil { + t.Fatal(err) + } + return repoAt{trees: map[string]string{"modules/avahi": tree}, + files: map[string]string{"modules/avahi/module.json": string(manifest), "modules/avahi/go.sum": "golang.org/x/sys v0.1.0 h1:x=\n"}} +} + +// registerAvahi keeps avahi's registration from the catalogue, watching branches, as the registrations part writes it. +func registerAvahi(t *testing.T, ctx context.Context, js jetstream.JetStream, branches ...string) jetstream.KeyValue { + t.Helper() + regs, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.RegistrationsState), History: 1}) + if err != nil { + t.Fatal(err) + } + reg, _ := json.Marshal(meshcatalog.Registration{V: 1, Module: "avahi", Origin: "novox/mesh-catalog", Path: "modules/avahi", Branches: branches}) + if _, err := regs.Put(ctx, index.RegistrationKey("avahi"), reg); err != nil { + t.Fatal(err) + } + return regs +} + +// sayMoved says the gate's source-moved of one source revision of a branch, moving the catalogue to commit. +func sayMoved(t *testing.T, ctx context.Context, js jetstream.JetStream, branch string, source int64, commit string, start bool) { + t.Helper() + e := meshdelivery.SourceMovedEvent{V: 1, Branch: branch, Source: source, Call: "0123456789abcdef", Start: start, + Heads: []meshdelivery.SourceMovedEventHeadsItem{{Repository: "novox/mesh-catalog", Commit: commit}}} + if start { + e.Call = "seed.lead.20261120" + } + raw, _ := json.Marshal(e) + if _, err := js.Publish(ctx, meshdelivery.SubjectSourceMoved(keys.EscapeName(branch), strconv.FormatInt(source, 10)), raw); err != nil { + t.Fatal(err) + } +} + +// takeIns hears what the indexer says of its take-ins: every take-in.taken and take-in.pending, in the order said. +type takeIns struct { + taken chan meshcatalog.TakeInTaken + pending chan meshcatalog.TakeInPending + acks chan string // the escaped branch whose source-moved the indexer acknowledged +} + +func hearTakeIns(t *testing.T, nc *nats.Conn) *takeIns { + t.Helper() + h := &takeIns{taken: make(chan meshcatalog.TakeInTaken, 64), pending: make(chan meshcatalog.TakeInPending, 64), acks: make(chan string, 64)} + prefix := "$JS.ACK." + meshdelivery.StreamSourceMoved + "." + acks, err := nc.Subscribe(prefix+"*.>", func(m *nats.Msg) { + consumer, _, _ := strings.Cut(strings.TrimPrefix(m.Subject, prefix), ".") + if branch, ok := strings.CutPrefix(consumer, "n1_mesh-delivery-indexer_"); ok && (string(m.Data) == "+ACK" || len(m.Data) == 0) { + h.acks <- branch + } + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = acks.Unsubscribe() }) + sub, err := nc.Subscribe("mesh.mod."+testIndexer+".event.take-in.*", func(m *nats.Msg) { + switch m.Subject { + case "mesh.mod." + testIndexer + ".event.take-in.taken": + var e meshcatalog.TakeInTaken + if json.Unmarshal(m.Data, &e) == nil { + h.taken <- e + } + case "mesh.mod." + testIndexer + ".event.take-in.pending": + var e meshcatalog.TakeInPending + if json.Unmarshal(m.Data, &e) == nil { + h.pending <- e + } + } + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = sub.Unsubscribe() }) + return h +} + +// next is the next take-in.taken said, which must be of that branch and source. +func (h *takeIns) next(t *testing.T, branch string, source int64) meshcatalog.TakeInTaken { + t.Helper() + select { + case e := <-h.taken: + if e.Branch != branch || e.Source != source { + t.Fatalf("take-in.taken of %s %d said, want %s %d first: %+v", e.Branch, e.Source, branch, source, e) + } + return e + case <-time.After(waitBound): + t.Fatalf("no take-in.taken of %s %d within %s", branch, source, waitBound) + } + return meshcatalog.TakeInTaken{} +} + +// acked waits for the indexer's acknowledgement of a source-moved of branch: the next one heard must be of that branch. +func (h *takeIns) acked(t *testing.T, branch string) { + t.Helper() + select { + case b := <-h.acks: + if b != keys.EscapeName(branch) { + t.Fatalf("a source-moved of %s acknowledged, want %s", b, branch) + } + case <-time.After(waitBound): + t.Fatalf("no source-moved of %s acknowledged within %s", branch, waitBound) + } +} + +// nextPending is the next take-in.pending said, which must be of that branch and source. +func (h *takeIns) nextPending(t *testing.T, branch string, source int64) meshcatalog.TakeInPending { + t.Helper() + select { + case e := <-h.pending: + if e.Branch != branch || e.Source != source || e.Why == "" { + t.Fatalf("take-in.pending %+v said, want %s %d with why", e, branch, source) + } + return e + case <-time.After(waitBound): + t.Fatalf("no take-in.pending of %s %d within %s", branch, source, waitBound) + } + return meshcatalog.TakeInPending{} +} + +// untilKey watches one key until cond holds of its value (nil when absent or deleted). +func untilKey(t *testing.T, ctx context.Context, kv jetstream.KeyValue, key string, cond func([]byte) bool) { + t.Helper() + wctx, cancel := context.WithTimeout(ctx, waitBound) + defer cancel() + w, err := kv.Watch(wctx, key) + if err != nil { + t.Fatal(err) + } + defer func() { _ = w.Stop() }() + var last []byte + for e := range w.Updates() { + switch { + case e == nil: // the initial values are read + case e.Operation() == jetstream.KeyValuePut: + last = e.Value() + default: + last = nil + } + if cond(last) { + return + } + } + t.Fatalf("%s.%s is %s after %s, not what the bed waits for", kv.Bucket(), key, last, waitBound) +} + +// untilRevisionGone watches the catalog revisions until the object name is no longer kept. +func untilRevisionGone(t *testing.T, ctx context.Context, js jetstream.JetStream, name string) { + t.Helper() + obs, err := js.ObjectStore(ctx, newBusObjects(nil, testAccount, index.CatalogRevisionsObjects).bucket()) + if err != nil { + t.Fatal(err) + } + wctx, cancel := context.WithTimeout(ctx, waitBound) + defer cancel() + w, err := obs.Watch(wctx, jetstream.IgnoreDeletes()) + if err != nil { + t.Fatal(err) + } + defer func() { _ = w.Stop() }() + if _, err := obs.GetInfo(ctx, name); errors.Is(err, jetstream.ErrObjectNotFound) { + return + } + for range w.Updates() { + if _, err := obs.GetInfo(ctx, name); errors.Is(err, jetstream.ErrObjectNotFound) { + return + } + } + t.Fatalf("the catalog revision %s is still kept after %s", name, waitBound) +} + +// setCap sets the cap of the catalog revisions' object store, as its definition's keep would. +func setCap(t *testing.T, ctx context.Context, js jetstream.JetStream, capacity int64) { + t.Helper() + if _, err := js.UpdateObjectStore(ctx, jetstream.ObjectStoreConfig{Bucket: newBusObjects(nil, testAccount, index.CatalogRevisionsObjects).bucket(), MaxBytes: capacity}); err != nil { + t.Fatal(err) + } +} + +// sayPipeline says the runner's pipeline-started or pipeline-ended of a take-in's pipeline . on its revision. +func sayPipeline(t *testing.T, ctx context.Context, js jetstream.JetStream, ended bool, branch string, source int64) { + t.Helper() + b, s := keys.EscapeName(branch), strconv.FormatInt(source, 10) + pipeline := b + "." + s + if !ended { + raw, _ := json.Marshal(meshpipelinerunner.PipelineStarted{V: 1, Pipeline: pipeline, Branch: branch, Source: source, Revision: source, + Movers: []meshpipelinerunner.Mover{{Module: "avahi", Tier: 1}}}) + if _, err := js.Publish(ctx, meshpipelinerunner.SubjectPipelineStarted(b, s), raw); err != nil { + t.Fatal(err) + } + return + } + raw, _ := json.Marshal(meshpipelinerunner.PipelineEnded{V: 1, Pipeline: pipeline, Branch: branch, Source: source, Revision: source, + Outcome: meshpipelinerunner.PipelineEndedOutcomePassed, Movers: []meshpipelinerunner.MoverEnded{{Module: "avahi", Steps: []meshpipelinerunner.StepResult{}, Tier: 1}}}) + if _, err := js.Publish(ctx, meshpipelinerunner.SubjectPipelineEnded(b, s), raw); err != nil { + t.Fatal(err) + } +} + +// pinned is whether a pins value names the record. +func pinned(record string) func([]byte) bool { + return func(v []byte) bool { + var p index.PinValue + return v != nil && json.Unmarshal(v, &p) == nil && len(p.Records) == 1 && p.Records[0] == record + } +} + +func absent(v []byte) bool { return v == nil } + +// TestIndexerWhole starts the indexer whole (its entry, run, with MESH_BROKER_FILE) against an embedded bus, with avahi registered +// from the catalogue watching main and beta, the go toolchain reported, the seat git served and the streams and durables the +// grants part makes (design 47 H §743, §744, §749, §768; H-A-12, H-A-30, H-A-50, H-A-90, H-A-92, H-A-97): +// +// - main's first source revision (start true) is taken in with no mover and pins nothing; the next, moving avahi's tree, is one +// revision main.11 carrying avahi as its one mover, pinned pipeline.main.11, said once as take-in.taken; the same source-moved +// given again says the same from the kept movers and keeps no second revision; +// - pipeline-started of main.12 pins it, a restart keeps main.11 while its pipeline runs and removes main.10; +// - with the store full, main.13 is held, said once as take-in.pending and written in the state held; nothing takes it in on a +// timer: main.11's pipeline-ended frees its pin, the revision goes, the indexer says its room and takes main.13 in on it; +// - beta's take-in whose commit the forge cannot read is held while main's next goes on; the hand skip, with why, is recorded in +// the hand-act log before it is asked, and take-in.taken says it skipped; +// - a branch watched later is bound on registration-changed and its first revision taken in. +func TestIndexerWhole(t *testing.T) { + const ( + c10, c11, c12, c13 = "1010101010101010101010101010101010101010", "1111111111111111111111111111111111111111", "1212121212121212121212121212121212121212", "1313131313131313131313131313131313131313" + unread = "beefbeefbeefbeefbeefbeefbeefbeefbeefbeef" + ) + var forge *forgeCommits + var heard *takeIns + var pins, held, takeinsKV, regs jetstream.KeyValue + js, ctx, _, _, restart := startIndexerRun(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) { + heard = hearTakeIns(t, js.Conn()) + forge = serveCommits(t, js.Conn()) + for commit, tree := range map[string]string{c10: "t10", c11: "t11", c12: "t12", c13: "t13"} { + forge.put(commit, catalogueAt(t, tree)) + } + var err error + for _, b := range []struct { + state string + kv *jetstream.KeyValue + }{{index.HeldState, &held}, {index.TakeInsState, &takeinsKV}} { + if *b.kv, err = js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, b.state), History: 1}); err != nil { + t.Fatal(err) + } + } + regs = registerAvahi(t, ctx, js, "main", "beta") + tc, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.ToolchainsBucket("mesh-build-go"), History: 1}) + if err != nil { + t.Fatal(err) + } + key, _ := index.ToolchainKey("n1", "go") + value, _ := index.EncodeToolchain(nodebuildgo.Toolchain{Language: "go", Version: "go1.27.1", Recipe: "1", At: ptr(time.Now())}) + if _, err := tc.Put(ctx, key, value); err != nil { + t.Fatal(err) + } + seedBuildModules(t, ctx, js, nil) + }) + var err error + if pins, err = js.KeyValue(ctx, index.Bucket(testIndexer, index.PinsState)); err != nil { + t.Fatal(err) + } + objects := newBusObjects(js, testAccount, index.CatalogRevisionsObjects) + + // The first revision: no mover, no pin; its entries are the base. + sayMoved(t, ctx, js, "main", 10, c10, true) + if first := heard.next(t, "main", 10); len(first.Entries) != 0 || first.Revision != 10 { + t.Fatalf("the first revision said %+v, want revision 10 with no entries", first) + } + untilKey(t, ctx, pins, index.PinKey("main", 10), absent) + + // One take-in, one revision carrying its movers, pinned for its pipeline; said again from the kept movers. + sayMoved(t, ctx, js, "main", 11, c11, false) + taken := heard.next(t, "main", 11) + if len(taken.Entries) != 1 || taken.Entries[0].Module != "avahi" || taken.Entries[0].Commit != c11 || taken.Entries[0].Fingerprint == "" || + taken.Entries[0].Repository != "novox/mesh-catalog" || taken.Revision != 11 || taken.Call == "" { + t.Fatalf("take-in.taken of main 11 = %+v, want avahi at %s as its one mover", taken, c11) + } + rev, _, err := index.ReadRevision(ctx, objects, "main.11") + if err != nil || len(rev.Movers) != 1 || rev.Movers[0] != taken.Entries[0] { + t.Fatalf("main.11 = %+v (%v), want it kept carrying the movers said", rev, err) + } + untilKey(t, ctx, pins, index.PinKey("main", 11), pinned("pipeline.main.11")) + info, err := objects.open(ctx) + if err != nil { + t.Fatal(err) + } + before, err := info.GetInfo(ctx, "main.11") + if err != nil { + t.Fatal(err) + } + sayMoved(t, ctx, js, "main", 11, c11, false) + if again := heard.next(t, "main", 11); len(again.Entries) != 1 || again.Entries[0] != taken.Entries[0] || again.Revision != 11 { + t.Errorf("the source-moved given again said %+v, want the kept movers %+v", again, taken.Entries) + } + if after, err := info.GetInfo(ctx, "main.11"); err != nil || after.NUID != before.NUID { + t.Errorf("main.11 was written again (%v): a source-moved given again keeps no second revision", err) + } + + // pipeline-started pins its revision; a restart while main.11's pipeline runs keeps it, and the judge at the start removes + // main.10, which nothing pins and which is no longer current. + sayMoved(t, ctx, js, "main", 12, c12, false) + heard.next(t, "main", 12) + if err := pins.Delete(ctx, index.PinKey("main", 12)); err != nil { // the take-in's own pin, so pipeline-started alone writes it below + t.Fatal(err) + } + sayPipeline(t, ctx, js, false, "main", 12) + untilKey(t, ctx, pins, index.PinKey("main", 12), pinned("pipeline.main.12")) + restart() + untilRevisionGone(t, ctx, js, "main.10") + if _, _, err := index.ReadRevision(ctx, objects, "main.11"); err != nil { + t.Fatalf("main.11 is not kept across a restart while its pipeline runs: %v", err) + } + + // The store full: held, said once, in the state held; taken in on the indexer's own room once a freed pin makes it. + used, _, err := objects.Fill(ctx) + if err != nil { + t.Fatal(err) + } + setCap(t, ctx, js, used+1) + sayMoved(t, ctx, js, "main", 13, c13, false) + if p := heard.nextPending(t, "main", 13); p.Why == "" { + t.Fatalf("take-in.pending %+v names no why", p) + } + untilKey(t, ctx, held, keys.EscapeName("main"), func(v []byte) bool { + var h index.HeldTakeIn + return v != nil && json.Unmarshal(v, &h) == nil && h.Source == 13 && h.Why != "" && !h.Since.IsZero() + }) + setCap(t, ctx, js, 1<<30) // a larger cap alone wakes nothing: no timer takes a held take-in in + sayPipeline(t, ctx, js, true, "main", 11) + if got := heard.next(t, "main", 13); len(got.Entries) != 1 || got.Entries[0].Commit != c13 { + t.Errorf("main 13 taken in on room said %+v, want avahi at %s", got, c13) + } + untilKey(t, ctx, held, keys.EscapeName("main"), absent) + untilKey(t, ctx, pins, index.PinKey("main", 11), absent) + if n := len(heard.pending); n != 0 { + t.Errorf("take-in.pending said %d more times for one held source revision, want once", n) + } + + // Another branch's hold leaves main going on; the hand skip ends it with why in the hand-act log. + sayMoved(t, ctx, js, "beta", 1, unread, true) + heard.nextPending(t, "beta", 1) + sayMoved(t, ctx, js, "main", 14, c13, false) + if next := heard.next(t, "main", 14); len(next.Entries) != 0 { + t.Errorf("main 14 at main 13's head said %+v, want no mover", next) + } + var log []string + tools := index.HeldTools(kvStore{held}, askVia(t, ctx, takeinsKV), time.Now, func(what, why string) error { + log = append(log, what+": "+why) + return nil + }) + pending, err := toolNamed(t, tools, index.PendingTool).Run(map[string]any{}) + if a, ok := pending.(index.PendingAnswer); err != nil || !ok || len(a.Held) != 1 || a.Held[0].Branch != "beta" || a.Held[0].Source != 1 { + t.Fatalf("indexer_pending = %+v (%v), want beta's source revision 1 held", pending, err) + } + if _, err := toolNamed(t, tools, index.TakeInSkipTool).Run(map[string]any{"branch": "beta", "source": float64(1), "why": "the forge lost the commit"}); err != nil { + t.Fatal(err) + } + if skipped := heard.next(t, "beta", 1); !skipped.Skipped || skipped.Why != "the forge lost the commit" || len(skipped.Entries) != 0 { + t.Errorf("the skip said %+v, want skipped with its why and no entries", skipped) + } + if len(log) != 1 { + t.Errorf("the hand-act log holds %v, want the one skip", log) + } + untilKey(t, ctx, held, keys.EscapeName("beta"), absent) + + // A branch watched later: its durable bound on the indexer's own registration-changed. + watchBranch(t, ctx, js, "gamma") + reg, _ := json.Marshal(meshcatalog.Registration{V: 1, Module: "avahi", Origin: "novox/mesh-catalog", Path: "modules/avahi", Branches: []string{"main", "beta", "gamma"}}) + if _, err := regs.Put(ctx, index.RegistrationKey("avahi"), reg); err != nil { + t.Fatal(err) + } + if _, err := js.Publish(ctx, meshcatalog.SubjectRegistrationChanged, []byte(`{"module":"avahi"}`)); err != nil { + t.Fatal(err) + } + sayMoved(t, ctx, js, "gamma", 1, c10, true) + heard.next(t, "gamma", 1) + if _, _, err := index.ReadRevision(ctx, objects, "gamma.1"); err != nil { + t.Errorf("gamma.1 is not kept: %v", err) + } +} + +// toolNamed is the tool of that name. +func toolNamed(t *testing.T, tools []stdio.Tool, name string) stdio.Tool { + t.Helper() + for _, tl := range tools { + if tl.Name == name { + return tl + } + } + t.Fatalf("no tool %s", name) + return stdio.Tool{} +} + +// askVia asks one hand act through the state takeins as the tools do (askTakeIn) and answers once the indexer wrote its answer. +func askVia(t *testing.T, ctx context.Context, kv jetstream.KeyValue) func(string, []byte) (index.TakeInAsk, error) { + return func(key string, value []byte) (index.TakeInAsk, error) { + if _, err := kv.Put(ctx, key, value); err != nil { + return index.TakeInAsk{}, err + } + var a index.TakeInAsk + untilKey(t, ctx, kv, key, func(v []byte) bool { + got, err := index.DecodeTakeIn(v) + if err == nil && got.Done() { + a = got + return true + } + return false + }) + return a, nil + } +}