From c8ba486318817e4141b8b54ad678ca378e75dbb3 Mon Sep 17 00:00:00 2001 From: jochen Date: Sun, 22 Nov 2026 02:00:07 +0100 Subject: [PATCH] I6 (2b): the indexer keeps the seat list as one object and hands it by seat-list MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit At each trunk seat-definition move (said or not) the indexer writes the trunk's definitions, resolved, as one JSON array sorted by seat into its objects seat-lists under its sha256, when not held, and deletes every object but the newest two, never the one just kept; one journal line per write and delete. Its process serves the chunked verb seat-list: digest, size and chunks, then the object's bytes; a list not kept yet is refused naming it. The manifest serves seat-list and declares seat-lists in its old objects section at 64 MiB. composer.Request gains seat-list, the digest of the bytes Seats were filled from; the judge reads Seats alone. Builds: design 47 H2 §814, §820; H-A-441, H-A-443 (1) --- .../cmd/mesh-delivery-indexer/main.go | 10 +- .../cmd/mesh-delivery-indexer/objects.go | 23 +++ .../cmd/mesh-delivery-indexer/seatlist.go | 20 ++- .../mesh-delivery-indexer/seatlist_test.go | 26 ++- .../internal/index/seatlists.go | 162 ++++++++++++++++++ .../internal/index/seatlists_test.go | 123 +++++++++++++ .../mesh-delivery-indexer/manifest_test.go | 12 +- modules/mesh-delivery-indexer/module.json | 4 +- .../mesh-delivery-sdk/composer/composer.go | 4 + .../composer/composer_test.go | 5 + 10 files changed, 373 insertions(+), 16 deletions(-) create mode 100644 modules/mesh-delivery-indexer/internal/index/seatlists.go create mode 100644 modules/mesh-delivery-indexer/internal/index/seatlists_test.go diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/main.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/main.go index 352505c32..b43acbc05 100644 --- a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/main.go +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/main.go @@ -318,13 +318,16 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro seatDefs := process.AwaitBucket(ctx, js, conn, index.Bucket(cred.Module, index.SeatDefinitionsState), "no seat definition is kept", logger.Printf) marks := process.AwaitBucket(ctx, js, conn, index.Bucket(cred.Module, views.MarksState), "no change is said on the views family, so every reader waits on its first view", logger.Printf) seatBus := &seatBus{defs: awaitedSource{ctx, seatDefs}, marks: awaitedSource{ctx, marks}} + // The seat lists, one object per digest (design 47 H2 §814, §820; H-A-441, H-A-443), kept at each trunk definition's move + // and handed by the verb seat-list. + seatLists := newBusObjects(js, cred, index.SeatListsObjects) // The build modules are found again at every change of the seat list (buildmodules.go), once the indexer is made. var buildFollow atomic.Pointer[buildModulesFollow] seatReader, saySeats := followSeatList(seatBus, saySeatDefinition(js, cred), logger.Printf, func() { if b := buildFollow.Load(); b != nil { go b.refresh() // never inside the reader's change: the refresh reads the reader's definitions } - }) + }, seatLists) readWhenBound(seatReader, seatDefs, marks) var fillFollow atomic.Pointer[versionsFill] // Kept while named (design 47 G §675): the want and the running build that name a fingerprint, heard below. @@ -336,9 +339,10 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro inputsStore := awaitedStore{b: process.AwaitBucket(ctx, js, conn, index.Bucket(cred.Module, index.InputsState), "no input of a run ask is kept, so the verb input answers none", logger.Printf)} inObjects := &inputObjects{js: js, module: cred.Module} stopInput, err := calls.AnswerSeat(meshcatalog.Seat, seatlist.Definition(seatReader.Reader, meshcatalog.Seat), map[string]process.SeatHandler{ - meshcatalog.VerbInput: index.InputVerb(inputsStore, inObjects, conn, buscalls.SeatAckWithin, logger.Printf)}) + meshcatalog.VerbInput: index.InputVerb(inputsStore, inObjects, conn, buscalls.SeatAckWithin, logger.Printf), + meshcatalog.VerbSeatList: index.SeatListVerb(seatBus.defs, seatLists, conn, buscalls.SeatAckWithin, logger.Printf)}) if err != nil { - return fmt.Errorf("answering the verb input: %w", err) + return fmt.Errorf("answering the verbs input and seat-list: %w", err) } defer stopInput() // The state takeins: hand acts ask there (watched below), and a running take-in keeps what it waits on (H2 §803, H-A-409). diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/objects.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/objects.go index 6cc947290..8b306ec4a 100644 --- a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/objects.go +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/objects.go @@ -14,6 +14,7 @@ import ( "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" + "git.novox.be/novox/mesh-sdk/go/buscalls" "git.novox.be/novox/mesh-sdk/go/catalogue" "git.novox.be/novox/mesh-sdk/go/process" "git.novox.be/novox/mesh-sdk/go/views" @@ -109,6 +110,28 @@ func (b *busObjects) Names(ctx context.Context) ([]string, error) { return names, nil } +// List is every object the store holds, a deleted one left out (index.SeatLists). +func (b *busObjects) List(ctx context.Context) ([]buscalls.ObjectInfo, error) { + o, err := b.open(ctx) + if err != nil { + return nil, err + } + infos, err := o.List(ctx) + if errors.Is(err, jetstream.ErrNoObjectsFound) { + return []buscalls.ObjectInfo{}, nil + } + if err != nil { + return nil, err + } + out := make([]buscalls.ObjectInfo, 0, len(infos)) + for _, i := range infos { + if !i.Deleted { + out = append(out, buscalls.ObjectInfo{Name: i.Name, Size: i.Size, Chunks: i.Chunks, Digest: i.Digest, Modified: i.ModTime}) + } + } + return out, nil +} + func (b *busObjects) Fill(ctx context.Context) (int64, int64, error) { o, err := b.open(ctx) if err != nil { diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/seatlist.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/seatlist.go index 9c25c0283..69fa8d95e 100644 --- a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/seatlist.go +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/seatlist.go @@ -110,18 +110,26 @@ func (b *seatBus) said(c index.SeatDefinitionChanged) { // seatlist.Part, novox/hq ADR 0636 §7), which gives catalogue what it holds at every change, and wraps say so that each move // the indexer says is also heard by the reader. Its two tools are not served: the indexer's process serves no request // subject (ADR 0437 §4), and its list is its own state seat-definitions, which indexer_seat_definition and the seat's verb -// seat-definitions read. It returns the part, whose status the indexer's health can show. -func followSeatList(bus *seatBus, say func(context.Context, index.SeatDefinitionChanged) error, logf func(string, ...any), changed func()) (*seatlist.Part, func(context.Context, index.SeatDefinitionChanged) error) { +// seat-definitions read. It returns the part, whose status the indexer's health can show. At each trunk definition's move, +// said or not, the seat list is kept as one object in lists, the objects seat-lists (design 47 H2 §814, §820, H-A-441), a +// failure said in logf. +func followSeatList(bus *seatBus, say func(context.Context, index.SeatDefinitionChanged) error, logf func(string, ...any), changed func(), lists index.SeatLists) (*seatlist.Part, func(context.Context, index.SeatDefinitionChanged) error) { part := seatlist.NewPart(toolPrefix) part.Follow(bus, changed, logf) return part, func(ctx context.Context, c index.SeatDefinitionChanged) error { - if err := say(ctx, c); err != nil { - return err + if c.Source != index.SourceTrunk { // only a trunk's definition is the seat list's + return say(ctx, c) } - if c.Source == index.SourceTrunk { // only a trunk's definition is the seat list's + err := say(ctx, c) + if err == nil { bus.said(c) } - return nil + if lists != nil { + if _, kerr := index.KeepSeatList(ctx, bus.defs, lists, logf); kerr != nil { + logf("the seat list is not kept in %s after %s moved: %v", index.SeatListsObjects, c.Seat, kerr) + } + } + return err } } diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/seatlist_test.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/seatlist_test.go index 1eb5b65e0..2b5b6c514 100644 --- a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/seatlist_test.go +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/seatlist_test.go @@ -1,7 +1,10 @@ package main import ( + "context" "errors" + "fmt" + "strings" "sync" "testing" "time" @@ -10,6 +13,8 @@ import ( "git.novox.be/novox/mesh-sdk/go/seatlist" "git.novox.be/novox/mesh-sdk/go/views" + + "mesh-delivery-indexer/internal/index" ) type unboundSource struct { @@ -44,7 +49,17 @@ func (b *awaitedFake) Ready(f func(jetstream.KeyValue)) { b.ready = append(b.rea func TestTheSeatListIsReadAgainWhenItsStatesAreBound(t *testing.T) { src := &unboundSource{} bus := &seatBus{defs: src, marks: src} - part, _ := followSeatList(bus, nil, t.Logf, nil) + var mu sync.Mutex + var unkept []string + logf := func(f string, a ...any) { + t.Logf(f, a...) + if strings.HasPrefix(f, "the seat list is not kept") { + mu.Lock() + unkept = append(unkept, fmt.Sprintf(f, a...)) + mu.Unlock() + } + } + part, say := followSeatList(bus, func(context.Context, index.SeatDefinitionChanged) error { return nil }, logf, nil, &busObjects{}) reader := part.Reader() <-reader.Ready() if reader.Status().Heard { @@ -76,5 +91,14 @@ func TestTheSeatListIsReadAgainWhenItsStatesAreBound(t *testing.T) { if _, ok := seatlist.Definition(part.Reader, "no-such-seat")(); ok { t.Error("a seat the list does not hold is answered a definition") } + // Design 47 H2 §814 (H-A-441): a trunk definition's move keeps the seat list in seat-lists, a pull request's does not; here + // the list holds no definition, so the keeping is refused and said. + _ = say(context.Background(), index.SeatDefinitionChanged{Seat: "a", Source: "pull-7", Digest: "d"}) + _ = say(context.Background(), index.SeatDefinitionChanged{Seat: "a", Source: index.SourceTrunk, Digest: "d"}) + mu.Lock() + defer mu.Unlock() + if len(unkept) != 1 || !strings.Contains(unkept[0], "holds no trunk definition") { + t.Errorf("the moves kept the seat list as %q, want one try, for the trunk's", unkept) + } var _ seatlist.Bus = bus } diff --git a/modules/mesh-delivery-indexer/internal/index/seatlists.go b/modules/mesh-delivery-indexer/internal/index/seatlists.go new file mode 100644 index 000000000..6c7593630 --- /dev/null +++ b/modules/mesh-delivery-indexer/internal/index/seatlists.go @@ -0,0 +1,162 @@ +package index + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "slices" + "strings" + "time" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" + + "git.novox.be/novox/mesh-sdk/go/buscalls" + "git.novox.be/novox/mesh-sdk/go/views" +) + +// The seat list as one object (design 47 H2 §814, §820; H-A-441): the trunk's seat definitions, resolved with their +// includes, as one JSON array in composer.Request.Seats' form sorted by seat, kept in the indexer's objects seat-lists +// under its digest (the sha256 of those bytes), written at each trunk seat-definition-changed or -removed; every object +// but the newest two is deleted at each new list. The seat mesh-catalog's verb seat-list hands its digest, size and bytes, and +// a validate run's asker fills its request's seats from them, so every run of one seat list judges the same bytes. + +// SeatListsObjects is the indexer's objects store of seat lists, in its old objects section (a foundation part, ADR 0619 +// §2): 64 MiB, one object per digest. +const SeatListsObjects = "seat-lists" + +// seatListsKept is how many seat lists the objects keep: the newest two. +const seatListsKept = 2 + +// SeatLists is the objects seat-lists as the indexer's process reaches them, to write, prune and hand out. +type SeatLists interface { + // Put stores data whole under name, replacing one of that name. + Put(ctx context.Context, name string, data []byte) error + // Get is the object's bytes; ErrNoObject when it holds none of that name. + Get(ctx context.Context, name string) ([]byte, error) + // Delete removes the object; one it does not hold is no error. + Delete(ctx context.Context, name string) error + // List is every object the store holds, a deleted one left out. + List(ctx context.Context) ([]buscalls.ObjectInfo, error) +} + +// SeatListOf is the trunk's seat list as the object holds it, and its digest: each trunk definition resolved, in the +// order of its seat's name. A list with no seat is an error: no validator judges by an empty list. +func SeatListOf(defs views.Source) ([]byte, string, error) { + keys, err := defs.Keys() + if err != nil { + return nil, "", fmt.Errorf("the %s state cannot be listed: %w", SeatDefinitionsState, err) + } + type seatDef struct { + seat string + def json.RawMessage + } + var seats []seatDef + for _, key := range keys { + seat, ok := strings.CutSuffix(key, "."+SourceTrunk) + if !ok || strings.HasPrefix(key, outOfStepPrefix) { + continue + } + v, ok, err := defs.Get(key) + if err != nil { + return nil, "", fmt.Errorf("%s.%s cannot be read: %w", SeatDefinitionsState, key, err) + } + if !ok || v == nil { + continue + } + var e SeatDefinitionEntry + if err := json.Unmarshal(v.Value, &e); err != nil || e.Digest == "" || len(e.Definition) == 0 { + continue // an entry that holds no definition is no seat of the list + } + seats = append(seats, seatDef{seat, e.Definition}) + } + slices.SortFunc(seats, func(a, b seatDef) int { return strings.Compare(a.seat, b.seat) }) + list := make([]json.RawMessage, 0, len(seats)) + for _, s := range seats { + list = append(list, s.def) + } + if len(list) == 0 { + return nil, "", fmt.Errorf("the %s state holds no trunk definition, so there is no seat list", SeatDefinitionsState) + } + raw, err := json.Marshal(list) + if err != nil { + return nil, "", err + } + sum := sha256.Sum256(raw) + return raw, hex.EncodeToString(sum[:]), nil +} + +// KeepSeatList writes the trunk's seat list into seat-lists under its digest when the objects do not hold it, then deletes +// every object but the newest two, never the list just kept. It answers the list's digest; each write and each delete is +// one line in logf. +func KeepSeatList(ctx context.Context, defs views.Source, o SeatLists, logf func(string, ...any)) (string, error) { + raw, digest, err := SeatListOf(defs) + if err != nil { + return "", err + } + held, err := o.List(ctx) + if err != nil { + return "", fmt.Errorf("the objects %s cannot be listed: %w", SeatListsObjects, err) + } + if !slices.ContainsFunc(held, func(i buscalls.ObjectInfo) bool { return i.Name == digest }) { + if err := o.Put(ctx, digest, raw); err != nil { + return "", fmt.Errorf("the seat list %s cannot be kept in %s: %w", digest, SeatListsObjects, err) + } + logf("seat list %s kept in %s (%d bytes)", digest, SeatListsObjects, len(raw)) + if held, err = o.List(ctx); err != nil { + return digest, fmt.Errorf("the objects %s cannot be listed: %w", SeatListsObjects, err) + } + } + slices.SortFunc(held, func(a, b buscalls.ObjectInfo) int { return b.Modified.Compare(a.Modified) }) // newest first + kept := 0 + for _, i := range held { + if i.Name == digest || kept < seatListsKept { + kept++ + continue + } + if err := o.Delete(ctx, i.Name); err != nil { + return digest, fmt.Errorf("the seat list %s cannot be deleted from %s: %w", i.Name, SeatListsObjects, err) + } + logf("seat list %s deleted from %s: only the newest %d are kept", i.Name, SeatListsObjects, seatListsKept) + } + return digest, nil +} + +// SeatListVerb is the seat mesh-catalog's verb seat-list, served by the indexer's process (H-A-443: the owner hands its +// objects, ADR 0596): the trunk's seat list's digest and size, then the bytes of its object in seat-lists in chunks of at +// most buscalls.SeatChunkBytes on the call's chunk subjects, each acknowledged before the next. A list the objects do not +// hold yet is refused naming it, never answered with other bytes. A caller that does not acknowledge within within ends +// the send, said in logf. +func SeatListVerb(defs views.Source, o SeatLists, line buscalls.ChunkLine, within time.Duration, logf func(string, ...any)) func(caller string, body json.RawMessage) (any, error) { + return func(_ string, raw json.RawMessage) (any, error) { + var in meshcatalog.SeatListInput + if err := json.Unmarshal(raw, &in); err != nil { + return nil, fmt.Errorf("the arguments are not JSON: %w", err) + } + if !callToken.MatchString(in.Call) { + return nil, errors.New("call is one token of 16 to 64 letters, digits, - or _: 128 random bits the caller chooses") + } + ctx := context.Background() + _, digest, err := SeatListOf(defs) + if err != nil { + return nil, err + } + body, err := o.Get(ctx, digest) + if errors.Is(err, ErrNoObject) { + return nil, fmt.Errorf("the seat list %s is not kept in %s yet: it is written at the trunk's next seat-definition change", digest, SeatListsObjects) + } + if err != nil { + return nil, fmt.Errorf("the seat list %s cannot be read from %s: %w", digest, SeatListsObjects, err) + } + send := buscalls.SeatChunks{Seat: meshcatalog.Seat, Verb: meshcatalog.VerbSeatList, Call: in.Call} + total := int64((len(body) + buscalls.SeatChunkBytes - 1) / buscalls.SeatChunkBytes) + go func() { // the send subscribes to the acknowledgements itself and ends when every chunk is sent or one is not acknowledged + if err := send.Send(line, body, within, logf); err != nil { + logf("the send %s of the seat list %s: %v", in.Call, digest, err) + } + }() + return meshcatalog.SeatListAnswer{Digest: digest, Size: int64(len(body)), Chunks: total}, nil + } +} diff --git a/modules/mesh-delivery-indexer/internal/index/seatlists_test.go b/modules/mesh-delivery-indexer/internal/index/seatlists_test.go new file mode 100644 index 000000000..d00f43b52 --- /dev/null +++ b/modules/mesh-delivery-indexer/internal/index/seatlists_test.go @@ -0,0 +1,123 @@ +package index + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "slices" + "strings" + "testing" + "time" + + "github.com/nats-io/nats.go" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" + + "git.novox.be/novox/mesh-sdk/go/buscalls" + "git.novox.be/novox/mesh-sdk/go/views" +) + +// memSeatLists is seat-lists in memory; each put is a second newer than the last. +type memSeatLists struct { + objects map[string][]byte + at map[string]time.Time + clock time.Time +} + +func (m *memSeatLists) Put(_ context.Context, name string, data []byte) error { + m.clock = m.clock.Add(time.Second) + m.objects[name], m.at[name] = data, m.clock + return nil +} + +func (m *memSeatLists) Get(_ context.Context, name string) ([]byte, error) { + d, ok := m.objects[name] + if !ok { + return nil, ErrNoObject + } + return d, nil +} + +func (m *memSeatLists) Delete(_ context.Context, name string) error { + delete(m.objects, name) + return nil +} + +func (m *memSeatLists) List(context.Context) ([]buscalls.ObjectInfo, error) { + out := []buscalls.ObjectInfo{} + for n, d := range m.objects { + out = append(out, buscalls.ObjectInfo{Name: n, Size: uint64(len(d)), Modified: m.at[n]}) + } + return out, nil +} + +func (m *memSeatLists) names() []string { + var out []string + for n := range m.objects { + out = append(out, n) + } + slices.Sort(out) + return out +} + +// noLine is a chunk line that hears nothing, so a send ends at once, said. +type noLine struct{} + +func (noLine) Publish(string, []byte) error { return nil } +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) { + 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} + } + defs := memSource{ + SeatDefinitionKey("a-b"): entry("a-b", SourceTrunk, `{"seat":"a-b"}`), + SeatDefinitionKey("a"): entry("a", SourceTrunk, `{"seat":"a"}`), + "a.pull-7": entry("a", "pull-7", `{"seat":"a","pull":7}`), + outOfStepPrefix + "c." + SourceTrunk: entry("c", SourceTrunk, `{"seat":"c"}`), + } + want := `[{"seat":"a"},{"seat":"a-b"}]` // by seat, not by key: "a-b.trunk" sorts before "a.trunk" + sum := sha256.Sum256([]byte(want)) + digest := hex.EncodeToString(sum[:]) + raw, got, err := SeatListOf(defs) + if err != nil || string(raw) != want || got != digest { + t.Fatalf("SeatListOf = %s %s (%v), want %s %s", raw, got, err, want, digest) + } + if _, _, err := SeatListOf(memSource{}); err == nil { + t.Error("an empty seat list was given a digest") + } + + lists := &memSeatLists{objects: map[string][]byte{}, at: map[string]time.Time{}} + verb := SeatListVerb(defs, lists, noLine{}, time.Second, t.Logf) + if _, err := verb("", json.RawMessage(`{"call":"0123456789abcdef0123456789abcdef"}`)); err == nil || !strings.Contains(err.Error(), "not kept in seat-lists yet") { + t.Errorf("a list not kept yet was answered: %v", err) + } + for _, old := range []string{"old-1", "old-2", "old-3"} { + _ = lists.Put(context.Background(), old, []byte("[]")) + } + if d, err := KeepSeatList(context.Background(), defs, lists, t.Logf); err != nil || d != digest { + t.Fatalf("KeepSeatList = %s (%v), want %s", d, err, digest) + } + if names := lists.names(); !slices.Equal(names, []string{digest, "old-3"}) || string(lists.objects[digest]) != want { + t.Errorf("seat-lists holds %v, want the list kept and the newest other", names) + } + before := lists.at[digest] + if _, err := KeepSeatList(context.Background(), defs, lists, t.Logf); err != nil || !lists.at[digest].Equal(before) || len(lists.objects) != 2 { + t.Errorf("the same list kept again was written again, or another deleted: %v %v", lists.names(), err) + } + + if _, err := verb("", json.RawMessage(`{"call":"x"}`)); err == nil || !strings.Contains(err.Error(), "128 random bits") { + t.Errorf("a call that is no token was taken: %v", err) + } + a, err := verb("", json.RawMessage(`{"call":"0123456789abcdef0123456789abcdef"}`)) + if err != nil || a != (meshcatalog.SeatListAnswer{Digest: digest, Size: int64(len(want)), Chunks: 1}) { + t.Errorf("seat-list = %+v (%v), want its digest, size and one chunk", a, err) + } +} diff --git a/modules/mesh-delivery-indexer/manifest_test.go b/modules/mesh-delivery-indexer/manifest_test.go index acdaa0f5b..39223ee20 100644 --- a/modules/mesh-delivery-indexer/manifest_test.go +++ b/modules/mesh-delivery-indexer/manifest_test.go @@ -149,9 +149,11 @@ func TestManifestDeclarations(t *testing.T) { // 1238/AC1, 1444 (reads the build // capped at 512 MiB, under the local name the indexer opens. W4.14 (design 47, Reverted): their form is 1. Design 47 H // §742 (H-A-105): no catch-up tool of the indexer's follows a restore, indexer_take_in having gone with the builder-log // index; the gate's gate_head_take is the one hand take of a head. - if len(m.Objects) != 1 || m.Objects[0].Name != index.CatalogRevisionsObjects || m.Objects[0].MaxMiB != 512 || - m.Objects[0].Form != 1 || m.Objects[0].CatchUp != "" { - t.Errorf("objects = %+v, want %s capped at 512 MiB, form 1, no catch-up tool", m.Objects, index.CatalogRevisionsObjects) + // Design 47 H2 §814, §820 (H-A-441): the seat lists, one object per digest, 64 MiB, in the old section too. + if len(m.Objects) != 2 || m.Objects[0].Name != index.CatalogRevisionsObjects || m.Objects[0].MaxMiB != 512 || + m.Objects[0].Form != 1 || m.Objects[0].CatchUp != "" || m.Objects[1].Name != index.SeatListsObjects || m.Objects[1].MaxMiB != 64 { + t.Errorf("objects = %+v, want %s capped at 512 MiB, form 1, no catch-up tool, and %s at 64 MiB", m.Objects, + index.CatalogRevisionsObjects, index.SeatListsObjects) } // D-11 (ADR 0634 §1): the holders and buckets the indexer names (internal/index/names.go) are its manifest's: its own // name and states with their revisions, and the states it reads, each as `.`. @@ -306,8 +308,8 @@ func TestManifestDeclarations(t *testing.T) { // 1238/AC1, 1444 (reads the build // ADR 0604 §2, ADR 0636 §4: it holds the seat mesh-catalog, serving its four verbs and seat-definitions from its tools // bundle (which stays without a request subject); ADR 0663 §1: and revision, in the same runtime of its own. if len(m.Claims) != 1 || m.Claims[0].Name != index.CatalogSeat || m.Claims[0].Scope != catalogue.ScopeMesh || - !slices.Equal(m.Claims[0].Serves, []string{"modules", "module", "provides", "dependents", index.SeatDefinitionsVerb, "revision", "entry", "registrations", "register", "policy", "watch", "unwatch", "versions", "outdated", "input"}) { - t.Errorf("claims = %+v, want mesh-catalog with its seven verbs (entry: design 47 G §675)", m.Claims) + !slices.Equal(m.Claims[0].Serves, []string{"modules", "module", "provides", "dependents", index.SeatDefinitionsVerb, "seat-list", "revision", "entry", "registrations", "register", "policy", "watch", "unwatch", "versions", "outdated", "input"}) { + t.Errorf("claims = %+v, want mesh-catalog with its verbs (entry: design 47 G §675; seat-list: H2 §814)", m.Claims) } for _, e := range []string{index.SeatDefinitionChangedEvent, index.SeatDefinitionRemovedEvent} { if slices.Contains(m.Emits, e) { diff --git a/modules/mesh-delivery-indexer/module.json b/modules/mesh-delivery-indexer/module.json index dc1ad3aac..e28281ab1 100644 --- a/modules/mesh-delivery-indexer/module.json +++ b/modules/mesh-delivery-indexer/module.json @@ -13,6 +13,7 @@ "provides", "dependents", "seat-definitions", + "seat-list", "revision", "entry", "registrations", @@ -147,7 +148,8 @@ { "name": "mesh-delivery-indexer-findings", "events": ["finding-written.*", "finding-cleared.*", "findings-stated.*"], "max-age-days": 7, "max-mib": 16 } ], "objects": [ - { "name": "catalog-revisions", "max-mib": 512, "form": 1 } + { "name": "catalog-revisions", "max-mib": 512, "form": 1 }, + { "name": "seat-lists", "max-mib": 64 } ], "emits": [ "take-in.pending", diff --git a/modules/mesh-delivery-sdk/composer/composer.go b/modules/mesh-delivery-sdk/composer/composer.go index 019708074..eac635813 100644 --- a/modules/mesh-delivery-sdk/composer/composer.go +++ b/modules/mesh-delivery-sdk/composer/composer.go @@ -67,6 +67,10 @@ type Request struct { // them (the definitions of the seat mesh-catalog, resolved), raw so that this package names no seat (ADR 0635 §4, ADR 0636 // §1). The judge and the composer read them. None is no list at hand: a composer handed none judges no machine (ADR 0636 §1). Seats []json.RawMessage `json:"seats,omitempty"` + // SeatList is the sha256 of the bytes Seats were filled from: the object of the seat mesh-catalog's seat-list, or a + // revision's own definitions in the same form (design 47 H2 §814; H-A-441, H-A-443), so a verdict says which seat list + // judged it. The asker fetches the bytes and fills Seats before the run; the judge reads Seats alone. Empty is none named. + SeatList string `json:"seat-list,omitempty"` // BlameTries bounds the composer's search for the modules a machine that does not compose blames: it composes at // most this many times more, the assigner's setting blame-tries, since the composer has no settings of its own // (design 47 G §721, §729; A-469i). None is no search: the composer blames only what its composition holds or diff --git a/modules/mesh-delivery-sdk/composer/composer_test.go b/modules/mesh-delivery-sdk/composer/composer_test.go index c8c80c300..b14d35f09 100644 --- a/modules/mesh-delivery-sdk/composer/composer_test.go +++ b/modules/mesh-delivery-sdk/composer/composer_test.go @@ -63,6 +63,11 @@ func TestAManifestIsItsBytesOrItsDigest(t *testing.T) { if back, derr := Decode(wire); err != nil || derr != nil || back.BlameTries != 20 || !strings.Contains(string(wire), `"blame_tries":20`) { t.Errorf("blame_tries 20 went as %s and read back %d (%v, %v)", wire, back.BlameTries, err, derr) } + // Design 47 H2 §814 (H-A-441): the seat list a request's seats were filled from reads back by its digest. + wire, err = json.Marshal(Request{V: Version, SeatList: "0123abcd"}) + if back, derr := Decode(wire); err != nil || derr != nil || back.SeatList != "0123abcd" || !strings.Contains(string(wire), `"seat-list":"0123abcd"`) { + t.Errorf("seat-list went as %s and read back %q (%v, %v)", wire, back.SeatList, err, derr) + } // H3 (design 47 G A-470j, A-470k): a case's none, each module the revision gives no fingerprint with its none words, // reads back whole; a case naming none leaves the field off the wire. wire, err = json.Marshal(Request{V: Version, Cases: []Case{{Name: "change", Manifests: map[string]Manifest{},