Join: merge feat/47-H2-f2 into feat/47-H2

This commit is contained in:
2026-11-22 03:39:45 +01:00
11 changed files with 332 additions and 48 deletions
@@ -11,6 +11,8 @@ import (
"encoding/hex"
"encoding/json"
"errors"
"os"
"reflect"
"strings"
"testing"
"time"
@@ -19,15 +21,24 @@ import (
"github.com/nats-io/nats.go/jetstream"
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/composer"
"git.novox.be/novox/mesh-sdk/go/buscalls"
"git.novox.be/novox/mesh-sdk/go/catalogue"
"git.novox.be/novox/mesh-sdk/go/seatlist/seatlisttest"
"git.novox.be/novox/mesh-sdk/go/stateobjects"
"mesh-delivery-indexer/internal/index"
"mesh-delivery-indexer/judge"
)
// TestIndexerAnswersARunsInputOverOneMiBInChunks (design 47 G §712, A-237, §681): an input of 3 MiB, kept in the state inputs with
// its object beside it, is answered by the seat mesh-catalog's verb input as a count of chunks and then sent on the call's chunk
// subjects, each acknowledged by the caller; the chunks carry the exact bytes.
//
// Design 47 H2 §814 (H-A-441, H-A-443, H-A-453 (3)): with the seat definitions of the tests' seat list in its state, the indexer
// keeps the seat list as one object of seat-lists named by its digest and hands it by the verb seat-list in chunks; a run by
// hand, which reads that object by its address and gives the judge its request as a file, gives the verdicts the live validate
// gives from the verb's bytes, for the builder's and the runner's manifests.
func TestIndexerAnswersARunsInputOverOneMiBInChunks(t *testing.T) {
body := make([]byte, 3<<20)
if _, err := rand.Read(body); err != nil {
@@ -35,13 +46,30 @@ func TestIndexerAnswersARunsInputOverOneMiBInChunks(t *testing.T) {
}
sum := sha256.Sum256(body)
digest := hex.EncodeToString(sum[:])
js, _, _, _ := startIndexer(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) {
var seatLists jetstream.ObjectStore
js, ctx, _, _ := startIndexer(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) {
kv, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.InputsState), History: 1})
if err != nil {
t.Fatal(err)
}
// The indexer's own seat list (A-186), its state seat-definitions: empty, so the bootstrapped mesh-catalog stands.
if _, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.SeatDefinitionsState), History: 5}); err != nil {
// The indexer's own seat list (A-186), its state seat-definitions: the trunk's definition of every seat of the tests'
// seat list, as the take-in of the contracts modules keeps them; and its objects seat-lists, which the grants part makes.
defs, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.SeatDefinitionsState), History: 5})
if err != nil {
t.Fatal(err)
}
for _, d := range seatlisttest.Definitions() {
raw, err := json.Marshal(d)
if err != nil {
t.Fatal(err)
}
sum := sha256.Sum256(raw)
e, _ := json.Marshal(index.SeatDefinitionEntry{Seat: d.Seat, Source: index.SourceTrunk, Digest: hex.EncodeToString(sum[:]), Definition: raw, At: time.Now().UTC()})
if _, err := defs.Put(ctx, index.SeatDefinitionKey(d.Seat), e); err != nil {
t.Fatal(err)
}
}
if seatLists, err = js.CreateObjectStore(ctx, jetstream.ObjectStoreConfig{Bucket: newBusObjects(nil, testAccount, index.SeatListsObjects).bucket()}); err != nil {
t.Fatal(err)
}
objs, err := js.CreateObjectStore(ctx, jetstream.ObjectStoreConfig{Bucket: catalogue.BusName(testIndexer, catalogue.StateObjectsName(index.InputsState))})
@@ -103,4 +131,102 @@ func TestIndexerAnswersARunsInputOverOneMiBInChunks(t *testing.T) {
if !bytes.Equal(got.Bytes(), body) {
t.Errorf("the chunks carry %d bytes that are not the input's %d", got.Len(), len(body))
}
// §814: the live validate's read, the verb seat-list in chunks (the assigner's seatList), and a run by hand's, the object
// seat-lists/<digest> read by its address.
var list jetstream.ObjectInfo
wctx, cancel := context.WithTimeout(ctx, waitBound)
defer cancel()
w, err := seatLists.Watch(wctx)
if err != nil {
t.Fatal(err)
}
defer func() { _ = w.Stop() }()
for info := range w.Updates() {
if info != nil && !info.Deleted {
list = *info
break
}
}
if list.Name == "" {
t.Fatalf("seat-lists holds no seat list after %s", waitBound)
}
listCall := "fedcba9876543210fedcba9876543210"
listSend := buscalls.SeatChunks{Seat: meshcatalog.Seat, Verb: meshcatalog.VerbSeatList, Call: listCall}
listChunks := make(chan *nats.Msg, 16)
listSub, err := nc.ChanSubscribe(listSend.Chunks(), listChunks)
if err != nil {
t.Fatal(err)
}
defer listSub.Unsubscribe()
listReq, _ := json.Marshal(meshcatalog.SeatListInput{Call: listCall})
m, err := nc.Request("mesh.seat.mesh-catalog.call.seat-list.agent~dev", listReq, 5*time.Second)
if err != nil {
t.Fatal(err)
}
var listReply struct {
Result meshcatalog.SeatListAnswer `json:"result"`
Error string `json:"error"`
}
if err := json.Unmarshal(m.Data, &listReply); err != nil || listReply.Error != "" || listReply.Result.Digest != list.Name || listReply.Result.Size != int64(list.Size) {
t.Fatalf("seat-list = %+v (%q, %v), want the object %s of %d bytes", listReply.Result, listReply.Error, err, list.Name, list.Size)
}
var viaVerb bytes.Buffer
listNext := func() (string, []byte, error) {
select {
case m := <-listChunks:
return m.Subject, m.Data, nil
case <-time.After(20 * time.Second):
return "", nil, buscalls.ErrSeatChunkMissed
}
}
if _, err := listSend.Receive(listReply.Result.Chunks, listNext, ack, &viaVerb); err != nil {
t.Fatal(err)
}
byAddress, err := seatLists.GetBytes(ctx, listReply.Result.Digest)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(viaVerb.Bytes(), byAddress) {
t.Fatalf("the verb's %d bytes are not the object's %d at its address", viaVerb.Len(), len(byAddress))
}
// Both judged over the builder's and the runner's manifests as they stand in this repository: the live validate's
// request from the verb's bytes, and the hand run's request written to a file and read again as cmd/mesh-judge reads it.
manifests := map[string]composer.Manifest{}
for name, file := range map[string]string{"mesh-delivery-builder": "../../../mesh-delivery-builder/module.json", "mesh-delivery-pipeline": "../../../mesh-delivery-pipeline/module.json"} {
raw, err := os.ReadFile(file)
if err != nil {
t.Fatal(err)
}
manifests[name] = composer.Manifest{Raw: raw}
}
judged := func(seatList []byte, viaFile bool) composer.Verdict {
t.Helper()
var seats []json.RawMessage
if err := json.Unmarshal(seatList, &seats); err != nil || len(seats) == 0 {
t.Fatalf("the seat list is no array of definitions (%v)", err)
}
r := composer.Request{V: composer.Version, Cases: []composer.Case{{Name: "change", Manifests: manifests}}, Seats: seats, SeatList: listReply.Result.Digest}
if viaFile {
file, err := json.Marshal(r)
if err != nil {
t.Fatal(err)
}
if r, err = composer.Decode(file); err != nil {
t.Fatal(err)
}
}
v, err := judge.Request(r)
if err != nil {
t.Fatal(err)
}
return v
}
live, byHand := judged(viaVerb.Bytes(), false), judged(byAddress, true)
_, builder := live.Cases[0].Manifests["mesh-delivery-builder"]
_, runner := live.Cases[0].Manifests["mesh-delivery-pipeline"]
if !builder || !runner || !reflect.DeepEqual(byHand, live) {
t.Errorf("the run by hand judged %+v, want the live validate's %+v for the builder's and the runner's manifests", byHand, live)
}
t.Logf("the verdicts of the builder's and the runner's manifests against seat list %s: %+v", listReply.Result.Digest, live.Cases)
}
@@ -31,6 +31,7 @@ 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/seats/meshbuilds"
"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"
@@ -395,7 +396,7 @@ func startIndexerRun(t *testing.T, put func(context.Context, buildLog), before .
"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-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)
"mesh.seat.mesh-module-assigner.event.>", "mesh.seat.node-build-go.event.>", meshbuilds.SubjectVersionReserved}}); 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).
@@ -798,8 +799,9 @@ func serveAssignerAssignments(t *testing.T, ctx context.Context, js jetstream.Je
t.Fatal(err)
}
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.>", meshcatalog.SubjectRoom, nodebuildgo.SubjectStepEndedAll}}); err != nil {
// and the build seat's step-ended the manifest's consumes names (design 47 G §713: the end of a validation ask), and the
// builder's version-reserved, which no stream of its own keeps (design 47 H2 §805).
FilterSubjects: []string{"mesh.mod." + assignerHolderModule + ".event.views.>", meshcatalog.SubjectRoom, nodebuildgo.SubjectStepEndedAll, meshbuilds.SubjectVersionReserved}}); err != nil {
t.Fatal(err)
}
em := views.Emitter{Owner: assignerHolderModule, Subject: process.Account{Node: "n1", Module: assignerHolderModule}.EventSubject,
@@ -362,8 +362,11 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
Packages: awaitedStore{b: packages, js: js, name: index.Bucket(cred.Module, index.PackagesState)}, Files: filesVia(calls.Call), GoSum: goSumVia(calls.Call), GoMod: goModVia(calls.Call),
Heard: heardStore, Runs: awaitedStore{b: runs}, Graph: graph,
// How long a reservation is kept and how long its gathering waits at most (design 47 H2 §805, H-A-424).
ReservedKeep: reservedSetting("reserved-keep", index.DefaultReservedKeep, logger.Printf),
ReservedSettle: reservedSetting("reserved-settle", index.DefaultReservedSettle, logger.Printf),
ReservedKeep: durationSetting("reserved-keep", index.DefaultReservedKeep, logger.Printf),
ReservedSettle: durationSetting("reserved-settle", index.DefaultReservedSettle, logger.Printf),
// How long a take-in waits on another part before it says so, and before it raises take-in-waiting (H2 §803, H-A-461 (2)).
WaitingLine: durationSetting(index.WaitingLineSetting, index.DefaultWaitingLine, logger.Printf),
WaitingBound: durationSetting(index.WaitingBoundSetting, index.DefaultWaitingBound, logger.Printf),
SeatDefinitions: awaitedStore{b: seatDefs}, ReadFile: readFileVia(calls.Call), SaySeatDefinition: saySeats,
Revisions: revisions, EntryIndex: awaitedStore{b: process.AwaitBucket(ctx, js, conn, index.Bucket(cred.Module, index.EntryIndexState), "no entry is found by its fingerprint", logger.Printf)}, // Message a kept call: a read, called again through a transport fault (ADR 0668 §1)
// Each catalog revision may bring another holder of a build seat: the build modules are found again (buildmodules.go).
@@ -690,8 +693,8 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
}
}
// reservedSetting is the setting key read as a duration (stdio.SettingDuration); one that does not read is said and takes def.
func reservedSetting(key string, def time.Duration, logf func(string, ...any)) time.Duration {
// durationSetting is the setting key read as a duration (stdio.SettingDuration); one that does not read is said and takes def.
func durationSetting(key string, def time.Duration, logf func(string, ...any)) time.Duration {
d, err := stdio.SettingDuration(key, def)
if err != nil {
logf("%v: %s is taken", err, def)
@@ -6,6 +6,8 @@ import (
"context"
"encoding/json"
"errors"
"fmt"
"maps"
"os"
"reflect"
"slices"
@@ -17,6 +19,7 @@ import (
"github.com/nats-io/nats.go/jetstream"
"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/meshbuilds"
"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/nodebuildgo"
@@ -67,11 +70,23 @@ func untilModule(t *testing.T, ctx context.Context, js jetstream.JetStream, name
// and not plain; the packages key of mesh-sdk/go names that commit with a digest per package. Design 47 H2 §804: a key a dry
// run left in the state dry-runs is gone at the start, and the take-in of a branch moving mesh-sdk again, a dry run, leaves
// the trunk's packages state byte for byte as before and no key in dry-runs once it answered.
//
// Design 47 H2 §802 (H-A-453 (3)): the catalogue holds 36 modules, among them lib-a and lib-b, required by app-a (a require) and
// app-b (a require and a replace by a directory); a source revision moving the catalogue to a commit that changes a test file
// of lib-a and one of lib-b, and so their trees alone, moves lib-a, lib-b and their importers alone, never the other 32
// modules whose repository's commit moved too.
//
// Design 47 H2 §805 (H-A-453 (3)): the builder's twenty version-reserved of mesh-sdk in that revision's pipeline (twenty
// artifacts of its Go package, as repin_test.go reads them) are kept in heard and gathered, and its pipeline-started keeps one
// re-pin revision of main, importer its mover pinned to the reserved version; the next pipeline's reservation keeps the
// revision after it, so none came between.
func TestASourceRevisionMovingMeshSDKNamesItAndItsImporters(t *testing.T) {
const (
sdkGo = "git.novox.be/novox/mesh-sdk/go"
m1, m2, m3 = "1111111111111111111111111111111111111111", "2222222222222222222222222222222222222222", "4444444444444444444444444444444444444444"
catalogMerge = "3333333333333333333333333333333333333333"
catalogTests = "5555555555555555555555555555555555555555" // a test file of lib-a and one of lib-b changed
catalogModule = "git.novox.be/novox/mesh-catalog/modules/"
goModContent = "module importer\n\nrequire git.novox.be/novox/mesh-sdk/go v0.0.0-00010101000000-000000000000\n"
sdkRoot1, sdk2 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
sdk3 = "cccccccccccccccccccccccccccccccccccccccc"
@@ -97,7 +112,7 @@ func TestASourceRevisionMovingMeshSDKNamesItAndItsImporters(t *testing.T) {
"package.json": "3333333333333333333333333333333333333333", "package-lock.json": "4444444444444444444444444444444444444444",
"tsconfig.json": "5555555555555555555555555555555555555555"}}}
}
var packages, dryRuns jetstream.KeyValue
var packages, dryRuns, heardKV jetstream.KeyValue
var heard *takeIns
js, ctx, _, _ := startIndexer(t, func(context.Context, buildLog) {}, func(ctx context.Context, js jetstream.JetStream) {
var err error
@@ -124,6 +139,10 @@ func TestASourceRevisionMovingMeshSDKNamesItAndItsImporters(t *testing.T) {
forge.put(m1, sdkAt(sdkRoot1, "f5", "6666666666666666666666666666666666666666"))
forge.put(m2, sdkAt(sdk2, "f6", "7777777777777777777777777777777777777777"))
forge.put(m3, sdkAt(sdk3, "f7", "8888888888888888888888888888888888888888"))
// The state heard, declared key-ttl, where a reservation is kept and its gathering held open (§805).
if heardKV, err = js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: index.Bucket(testIndexer, index.HeardState), History: 64, LimitMarkerTTL: time.Minute}); err != nil {
t.Fatal(err)
}
// A dry run's key left by an indexer that stopped mid-run (§804).
if dryRuns, err = js.KeyValue(ctx, index.Bucket(testIndexer, index.DryRunsState)); err != nil {
t.Fatal(err)
@@ -131,14 +150,35 @@ func TestASourceRevisionMovingMeshSDKNamesItAndItsImporters(t *testing.T) {
if _, err := dryRuns.Put(ctx, index.DryRunPrefix("beta", "0123")+index.PackagesState+".left", []byte(`{"value":"e30="}`)); err != nil {
t.Fatal(err)
}
forge.put(catalogMerge, repoAt{trees: map[string]string{"modules/importer": "t1", "modules/plain": "t2"},
catalogue := 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.mod": goModContent, "modules/importer/go.sum": "golang.org/x/sys v0.1.0 h1:x=\n",
"modules/plain/go.mod": "module plain\n\nrequire golang.org/x/sys v0.1.0\n", "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"}},
"modules/plain/go.mod": "module plain\n\nrequire golang.org/x/sys v0.1.0\n", "modules/plain/go.sum": "golang.org/x/sys v0.1.0 h1:x=\n"},
paths: map[string]map[string]string{"": {"modules/lib-a": "a1", "modules/lib-b": "b1"}}}
registrations := []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", "beta"}}} {
{V: 1, Module: "mesh-sdk", Origin: "novox/mesh-sdk", Path: ".", Branches: []string{"main", "beta"}}}
// §802: 34 more modules of the catalogue, 36 with importer and plain: the libraries, their importers and 30 others.
goMods := map[string]string{"lib-a": "module " + catalogModule + "lib-a\n", "lib-b": "module " + catalogModule + "lib-b\n",
"app-a": "module app-a\n\nrequire " + catalogModule + "lib-a v0.0.0-00010101000000-000000000000\n",
"app-b": "module app-b\n\nrequire " + catalogModule + "lib-b v0.0.0-00010101000000-000000000000\n\nreplace " + catalogModule + "lib-b => ../lib-b\n"}
for i := range 30 {
goMods[fmt.Sprintf("m%02d", i)] = fmt.Sprintf("module m%02d\n\nrequire golang.org/x/sys v0.1.0\n", i)
}
for module, goMod := range goMods {
dir := "modules/" + module
catalogue.trees[dir] = "t-" + module
catalogue.files[dir+"/module.json"], catalogue.files[dir+"/go.mod"], catalogue.files[dir+"/go.sum"] = named(module), goMod, "golang.org/x/sys v0.1.0 h1:x=\n"
registrations = append(registrations, meshcatalog.Registration{V: 1, Module: module, Origin: "novox/mesh-catalog", Path: dir, Branches: []string{"main"}})
}
forge.put(catalogMerge, catalogue)
tests := catalogue
tests.trees = maps.Clone(catalogue.trees)
tests.trees["modules/lib-a"], tests.trees["modules/lib-b"] = "t-lib-a-2", "t-lib-b-2"
tests.paths = map[string]map[string]string{"": {"modules/lib-a": "a2", "modules/lib-b": "b2"}}
forge.put(catalogTests, tests)
regs := registerAvahi(t, ctx, js, "main")
for _, r := range registrations {
raw, _ := json.Marshal(r)
if _, err := regs.Put(ctx, index.RegistrationKey(r.Module), raw); err != nil {
t.Fatal(err)
@@ -207,6 +247,72 @@ func TestASourceRevisionMovingMeshSDKNamesItAndItsImporters(t *testing.T) {
return v != nil && err == nil && pub.Commit == m2 && len(pub.Packages) == 3
})
// §802: a commit of the catalogue changing a test file of lib-a and one of lib-b moves those two and their importers alone.
heard.acked(t, "main")
say(12, false, meshdelivery.SourceMovedEventHeadsItem{Repository: "novox/mesh-catalog", Commit: catalogTests})
movers = nil
taken = heard.next(t, "main", 12)
for _, e := range taken.Entries {
movers = append(movers, e.Module)
}
slices.Sort(movers)
if !slices.Equal(movers, []string{"app-a", "app-b", "lib-a", "lib-b"}) {
t.Errorf("the catalogue's commit changing lib-a's and lib-b's tests moves %v of its 36 modules, want lib-a, lib-b and their importers alone", movers)
}
// §805: twenty reservations of mesh-sdk's packages in main's revision of source 12, kept and gathered; its pipeline-started
// keeps one re-pin revision of main, and the next pipeline's reservation the one after it.
objects := newBusObjects(js, testAccount, index.CatalogRevisionsObjects)
untilRevision := func(n int64) meshcatalog.CatalogRevision {
t.Helper()
obs, err := js.ObjectStore(ctx, objects.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() }()
name := index.BranchObject("main", n)
for range w.Updates() {
if rev, _, err := index.ReadRevision(ctx, objects, name); err == nil {
return rev
}
}
t.Fatalf("%s is not kept after %s", name, waitBound)
return meshcatalog.CatalogRevision{}
}
reserve := func(revision int64, version string, artifacts int) {
t.Helper()
for i := range artifacts {
raw, _ := json.Marshal(meshbuilds.VersionReservedEvent{Module: "mesh-sdk", Artifact: fmt.Sprintf("mesh-sdk:p%d", i), Path: sdkGo, Version: version,
Fingerprint: "f-" + version, Revision: index.BranchObject("main", revision)})
if _, err := js.Publish(ctx, meshbuilds.SubjectVersionReserved, raw); err != nil {
t.Fatal(err)
}
}
untilKey(t, ctx, heardKV, index.ReservedKey(index.BranchObject("main", revision), "mesh-sdk"), func(v []byte) bool {
var r index.Reserved
return v != nil && json.Unmarshal(v, &r) == nil && len(r.Reservations) == artifacts
})
}
r := taken.Revision
reserve(r, "0.1.28", 20)
sayPipeline(t, ctx, js, false, "main", r)
if rev := untilRevision(r + 1); rev.CallKind != meshcatalog.CatalogRevisionCallKindRelease || !strings.Contains(rev.Call, index.BranchObject("main", r)+"'s") ||
len(rev.Movers) != 1 || rev.Movers[0].Module != "importer" {
t.Errorf("main.%d = %+v, want one re-pin revision of the twenty reservations, importer its mover", r+1, rev)
}
untilModule(t, ctx, js, "importer", func(m meshcatalog.ModulesByModuleValue) bool { return m.Packages[sdkGo] == "v0.1.28" })
reserve(r+1, "0.1.29", 1)
sayPipeline(t, ctx, js, false, "main", r+1)
if rev := untilRevision(r + 2); !strings.Contains(rev.Call, index.BranchObject("main", r+1)+"'s") {
t.Errorf("main.%d = %+v, want the next pipeline's re-pin: the twenty reservations kept more than one revision", r+2, rev)
}
// A branch's take-in moving mesh-sdk to m3 is a dry run: its packages stay in dry-runs while it runs, the trunk's are
// untouched, and its keys go once it answered (§804).
heard.acked(t, "main")
@@ -196,6 +196,10 @@ type Indexer struct {
// first reservation its gathering settles at the latest: the settings reserved-keep and reserved-settle (design 47 H2
// §805, H-A-424); zero takes the default.
ReservedKeep, ReservedSettle time.Duration
// WaitingLine is how long a take-in waits on another part before it says so and keeps its waiting-on, and WaitingBound
// how long before it raises take-in-waiting: the settings take-in-waiting-line and take-in-waiting-bound (design 47 H2
// §803, H-A-461 (2)); zero takes the default.
WaitingLine, WaitingBound time.Duration
}
func (ix *Indexer) logf(format string, args ...any) {
@@ -513,6 +513,7 @@ func TestTheControlRecords(t *testing.T) {
t.Errorf("a state not on the bus yet stopped the message: %v", err)
}
})
t.Run("seat-list", seatListIsOneObjectByItsDigest)
}
// memSource is a state as views.Source, for the indexer's tools that answer from its own states.
@@ -70,9 +70,10 @@ func (noLine) Subscribe(string, nats.MsgHandler) (*nats.Subscription, error) {
return nil, errors.New("no bus in this test")
}
// Design 47 H2 §814, §820 (H-A-441, H-A-443): the trunk's seat list is one object of seat-lists named by its sha256, in the
// order of its seats, kept at each new list with the newest two, and handed by the verb seat-list.
func TestTheSeatListIsOneObjectByItsDigest(t *testing.T) {
// seatListIsOneObjectByItsDigest is TestTheControlRecords' row "seat-list" (design 47 H2 §814, §820; H-A-441, H-A-443): the
// trunk's seat list is one object of seat-lists named by its sha256, in the order of its seats, kept at each new list with the
// newest two, and handed by the verb seat-list. A row, not a test of its own: the indexer's unit count does not rise (§819).
func seatListIsOneObjectByItsDigest(t *testing.T) {
entry := func(seat, source, def string) *views.Entry {
raw, _ := json.Marshal(SeatDefinitionEntry{Seat: seat, Source: source, Digest: "d-" + seat, Definition: json.RawMessage(def)})
return &views.Entry{Value: raw}
@@ -1,6 +1,7 @@
package index
import (
"cmp"
"context"
"encoding/json"
"errors"
@@ -141,11 +142,15 @@ func TestASourceRevisionIsTakenInAsOneRevision(t *testing.T) {
now := start
timers := make(chan context.CancelFunc)
var mu sync.Mutex
var asked []time.Duration // the bounds the wait asked, in order
var lines []string
wrote := make(chan struct{}, 1)
findings := newFindings()
w := &Indexer{Module: testSelf, TakeIns: running, Findings: findings, Now: func() time.Time { mu.Lock(); defer mu.Unlock(); return now },
Bound: func(parent context.Context, _ time.Duration) (context.Context, context.CancelFunc) {
Bound: func(parent context.Context, d time.Duration) (context.Context, context.CancelFunc) {
mu.Lock()
asked = append(asked, d)
mu.Unlock()
b, cancel := context.WithCancel(parent)
timers <- cancel
return b, cancel
@@ -156,10 +161,10 @@ func TestASourceRevisionIsTakenInAsOneRevision(t *testing.T) {
lines = append(lines, fmt.Sprintf(format, args...))
}}
w.Findings = findingsSignal{findings, wrote}
listing := func(answerAfter time.Duration) {
listing := func(answerAfter, line, bound time.Duration) {
t.Helper()
mu.Lock()
now, lines = start, nil
now, lines, asked = start, nil, nil
mu.Unlock()
release, res := make(chan struct{}), make(chan error)
go func() {
@@ -167,7 +172,7 @@ func TestASourceRevisionIsTakenInAsOneRevision(t *testing.T) {
res <- err
}()
first := <-timers
if answerAfter < WaitingLineAfter {
if answerAfter < line {
close(release)
<-res
return
@@ -177,7 +182,7 @@ func TestASourceRevisionIsTakenInAsOneRevision(t *testing.T) {
mu.Unlock()
first()
second := <-timers // asked once the line is said and the waiting-on written
if answerAfter >= WaitingFindingAfter {
if answerAfter >= bound {
second()
<-wrote
if h := findings.Held(); len(h) != 1 || h[0].Kind != TakeInWaitingKind || h[0].Scope != mcc.ScopeMerge || h[0].ID != "9" {
@@ -189,15 +194,27 @@ func TestASourceRevisionIsTakenInAsOneRevision(t *testing.T) {
t.Fatal(err)
}
}
// The bounds are the settings take-in-waiting-line and take-in-waiting-bound, 1m and 5m when unset (H-A-461 (2)): the
// wait asks the line, then the rest to the bound.
for _, c := range []struct {
after time.Duration
lines int
finding bool
}{{30 * time.Second, 0, false}, {70 * time.Second, 1, false}, {6 * time.Minute, 1, false}} {
listing(c.after)
after, line, bound time.Duration // line and bound zero: the settings unset
lines int
finding bool
}{{30 * time.Second, 0, 0, 0, false}, {70 * time.Second, 0, 0, 1, false}, {6 * time.Minute, 0, 0, 1, false},
{6 * time.Minute, 2 * time.Minute, 10 * time.Minute, 1, false}} {
w.WaitingLine, w.WaitingBound = c.line, c.bound
line, bound := cmp.Or(c.line, time.Minute), cmp.Or(c.bound, 5*time.Minute)
listing(c.after, line, bound)
mu.Lock()
got := slices.Clone(lines)
got, gotAsked := slices.Clone(lines), slices.Clone(asked)
mu.Unlock()
wantAsked := []time.Duration{line}
if c.after >= line {
wantAsked = append(wantAsked, bound-line)
}
if !slices.Equal(gotAsked, wantAsked) {
t.Errorf("answered after %s (line %s, bound %s): bounds asked %v, want %v", c.after, c.line, c.bound, gotAsked, wantAsked)
}
if len(got) != c.lines || (c.lines == 1 && !strings.Contains(got[0], "waits on git trees since 2026-11-22T01:00:00Z")) {
t.Errorf("answered after %s: lines %q, want %d naming git trees and since when", c.after, got, c.lines)
}
@@ -11,17 +11,19 @@ import (
mcc "git.novox.be/novox/mesh-contracts/health-and-repair/go/clients/meshconditionsclient"
)
// A take-in says what it waits on (design 47 H2 §803, H-A-409): a source-moved take-in that waits longer than
// WaitingLineAfter on another part (the seat git's listing or a file, a package's versions, a registry) writes one journal
// A take-in says what it waits on (design 47 H2 §803, H-A-409): a source-moved take-in that waits longer than the
// setting take-in-waiting-line on another part (the seat git's listing or a file, a package's versions, a registry) writes one journal
// line naming the part, the verb and since when, and keeps its waiting-on in the state takeins under the key
// RunningPrefix and the source revision, rewritten at each new wait and removed at the take-in's end; past
// WaitingFindingAfter it raises the finding take-in-waiting (scope merge, id the source revision), cleared when the wait
// ends. indexer_pending answers it beside the held take-ins.
// RunningPrefix and the source revision, rewritten at each new wait and removed at the take-in's end; past the setting
// take-in-waiting-bound it raises the finding take-in-waiting (scope merge, id the source revision), cleared when the wait
// ends. indexer_pending answers it beside the held take-ins. The two bounds are settings with these defaults (H-A-461 (2)).
const (
TakeInWaitingKind = "take-in-waiting"
RunningPrefix = "running."
WaitingLineAfter = time.Minute
WaitingFindingAfter = 5 * time.Minute
WaitingLineSetting = "take-in-waiting-line"
WaitingBoundSetting = "take-in-waiting-bound"
DefaultWaitingLine = time.Minute
DefaultWaitingBound = 5 * time.Minute
)
// WaitingOn is what a running take-in waits on: the part, its verb and since when.
@@ -95,8 +97,8 @@ func passed(ctx, b context.Context, done <-chan struct{}) bool {
return ctx.Err() == nil
}
// waited is f, a call on part's verb: within a running take-in (ctx), a wait past WaitingLineAfter is said and kept, one
// past WaitingFindingAfter raises take-in-waiting until it ends. Outside a take-in it is f alone.
// waited is f, a call on part's verb: within a running take-in (ctx), a wait past take-in-waiting-line is said and kept, one
// past take-in-waiting-bound raises take-in-waiting until it ends. Outside a take-in it is f alone.
func waited[T any](ctx context.Context, part, verb string, f func() (T, error)) (T, error) {
run, ok := ctx.Value(takeInRunKey{}).(*takeInRun)
if !ok {
@@ -115,7 +117,14 @@ func waited[T any](ctx context.Context, part, verb string, f func() (T, error))
func (ix *Indexer) watchWait(ctx context.Context, run *takeInRun, part, verb string, done <-chan struct{}) {
since := ix.now().UTC()
line, cancel := ix.bound(ctx, WaitingLineAfter)
after, bound := ix.WaitingLine, ix.WaitingBound
if after <= 0 {
after = DefaultWaitingLine
}
if bound <= 0 {
bound = DefaultWaitingBound
}
line, cancel := ix.bound(ctx, after)
defer cancel()
if !passed(ctx, line, done) {
return
@@ -123,7 +132,7 @@ func (ix *Indexer) watchWait(ctx context.Context, run *takeInRun, part, verb str
ix.logf("take-in: source revision %d of %s waits on %s %s since %s", run.source, run.branch, part, verb, since.Format(time.RFC3339))
ix.writeWaiting(ctx, RunningTakeIn{Branch: run.branch, Source: run.source, WaitingOn: WaitingOn{Part: part, Verb: verb, Since: since}})
id := strconv.FormatInt(run.source, 10)
finding, cancelFinding := ix.bound(ctx, WaitingFindingAfter-WaitingLineAfter)
finding, cancelFinding := ix.bound(ctx, max(bound-after, 0))
defer cancelFinding()
if !passed(ctx, finding, done) {
return
@@ -136,12 +136,13 @@ func TestManifestDeclarations(t *testing.T) { // 1238/AC1, 1444 (reads the build
if !slices.Equal(m.Uses, []string{"operator-channel"}) || !slices.Contains(m.Invokes, "seat:mesh-module-assigner.assignments") || !slices.Contains(m.Invokes, "seat:mesh-module-assigner.placement") {
t.Errorf("uses = %v, invokes = %v, want the seat operator-channel used and seat:mesh-module-assigner.assignments invoked", m.Uses, m.Invokes)
}
// 1126 note 76: heard keeps the last 64 FORGE messages the indexer handled, for indexer_heard; 8 MiB, each reservation
// and each gathering of them a key of its own time to live (design 47 H2 §805, H-A-420 (3), H-A-436).
// 1126 note 76: heard keeps the last 64 FORGE messages the indexer handled, for indexer_heard, each reservation and each
// gathering of them a key of its own time to live (design 47 H2 §805, H-A-420 (3), H-A-436); 32 MiB, its live fill 4.44 MiB
// (novox, 2026-11-22) more than a quarter of 8 (H-A-461 (3), H-A-437).
// Design 47 H2 §814, §820 (H-A-411 (2), H-A-437): every state names its cap, 8 MiB where the live fill (novox, 2026-11-22)
// is a quarter of it or less, else the smallest power of two above four times the fill: candidates 3.78 MiB at 16,
// manifests 5.21 MiB and seat-definitions 4.19 MiB at 32.
if want := []state{{Name: "candidates", History: 10, MaxMiB: 16}, {Name: "heard", History: 64, MaxMiB: 8, KeyTTL: true}, {Name: "manifests", History: 1, MaxMiB: 32}, {Name: "predefined", History: 5, MaxMiB: 8}, {Name: "taken", History: 1, MaxMiB: 8}, {Name: "takeins", History: 1, MaxMiB: 8}, {Name: "oldsections", History: 1, MaxMiB: 8}, {Name: index.RunsState, History: 1, MaxMiB: 8}, {Name: index.PackagesState, History: index.PackagesHistory, MaxMiB: 8},
// manifests 5.21 MiB, seat-definitions 4.19 MiB and heard 4.44 MiB at 32.
if want := []state{{Name: "candidates", History: 10, MaxMiB: 16}, {Name: "heard", History: 64, MaxMiB: 32, KeyTTL: true}, {Name: "manifests", History: 1, MaxMiB: 32}, {Name: "predefined", History: 5, MaxMiB: 8}, {Name: "taken", History: 1, MaxMiB: 8}, {Name: "takeins", History: 1, MaxMiB: 8}, {Name: "oldsections", History: 1, MaxMiB: 8}, {Name: index.RunsState, History: 1, MaxMiB: 8}, {Name: index.PackagesState, History: index.PackagesHistory, MaxMiB: 8},
{Name: views.MarksState, History: 1, MaxMiB: 8}, {Name: index.FindingsState, History: 5, MaxMiB: 8}, {Name: views.StatusState, History: 1, MaxMiB: 8},
{Name: index.RequirementsState, History: 5, MaxMiB: 8}, {Name: index.SeatDefinitionsState, History: 5, MaxMiB: 32},
{Name: index.EntryIndexState, History: 1, MaxMiB: 8}, {Name: index.NamedState, History: 1, MaxMiB: 4}, // design 47 G §695
@@ -228,11 +229,11 @@ func TestManifestDeclarations(t *testing.T) { // 1238/AC1, 1444 (reads the build
t.Errorf("streams = %+v, want registration-history keeping its history, 64 MiB, and the findings stream at 8 MiB (§387, H2 §783)", m.Streams)
}
// Design 47 H2 §810, §814 (H-A-394 (1)): it claims a seat, so its class is core. §775: it makes kept calls, so it declares
// the kept-call pace, 1 s to 30 s, read while it runs.
// the kept-call pace, 1 s to 30 s, read while it runs. §803 (H-A-461 (2)): a take-in's waiting line and bound, 1m and 5m.
if m.Class != "core" {
t.Errorf("class = %q, want core", m.Class)
}
for key, def := range map[string]string{busretry.PaceFirstSetting: "1s", busretry.PaceMaxSetting: "30s"} {
for key, def := range map[string]string{busretry.PaceFirstSetting: "1s", busretry.PaceMaxSetting: "30s", index.WaitingLineSetting: "1m", index.WaitingBoundSetting: "5m"} {
if c, _ := m.Config[key].(map[string]any); c["default"] != def || c["runtime"] != true || c["type"] != "string" {
t.Errorf("config %s = %v, want a runtime string setting defaulting to %s", key, m.Config[key], def)
}
+15 -1
View File
@@ -130,11 +130,25 @@
"trusted": false,
"default": "30s",
"runtime": true
},
"take-in-waiting-line": {
"type": "string",
"description": "how long a take-in waits on another part (the seat git, a package's versions, a registry) before it writes one journal line and its waiting-on in takeins, a Go duration (design 47 H2 §803, H-A-461 (2)).",
"trusted": false,
"default": "1m",
"runtime": true
},
"take-in-waiting-bound": {
"type": "string",
"description": "how long a take-in waits on another part before it raises the finding take-in-waiting, cleared when the wait ends, a Go duration (design 47 H2 §803, H-A-461 (2)).",
"trusted": false,
"default": "5m",
"runtime": true
}
},
"state": [
{ "name": "candidates", "history": 10, "max-mib": 16 },
{ "name": "heard", "history": 64, "max-mib": 8, "key-ttl": true },
{ "name": "heard", "history": 64, "max-mib": 32, "key-ttl": true },
{ "name": "manifests", "history": 1, "max-mib": 32 },
{ "name": "predefined", "history": 5, "max-mib": 8 },
{ "name": "taken", "history": 1, "max-mib": 8 },