From 900316e4bd13fedc317557c2e886bf08f011d32f Mon Sep 17 00:00:00 2001 From: jochen Date: Thu, 19 Nov 2026 12:51:40 +0100 Subject: [PATCH] The tool indexer_catalog_revision and the verb revision of a watched branch read the newest again The default read of the tool and the newest revision of a branch other than the trunk use readNewestOf; a read by number keeps failing loudly. One table covers every reader of the newest revision in the indexer program. Builds: design 47 G A-487d (hq 61bf1215) Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- .../internal/index/kept_trunk_test.go | 90 +++++++++++++------ .../internal/index/revision_tools.go | 14 +-- .../internal/index/revision_verb.go | 10 ++- 3 files changed, 79 insertions(+), 35 deletions(-) diff --git a/modules/mesh-delivery-indexer/internal/index/kept_trunk_test.go b/modules/mesh-delivery-indexer/internal/index/kept_trunk_test.go index d0202f05..ab545752 100644 --- a/modules/mesh-delivery-indexer/internal/index/kept_trunk_test.go +++ b/modules/mesh-delivery-indexer/internal/index/kept_trunk_test.go @@ -8,6 +8,7 @@ import ( "strings" "sync/atomic" "testing" + "time" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" "git.novox.be/novox/mesh-sdk/go/views" @@ -151,10 +152,11 @@ type goneUnderRead struct { *memObjects once atomic.Bool prune func() + on string // when set, only the read of this entry runs the pruning } func (g *goneUnderRead) Get(ctx context.Context, name string) ([]byte, error) { - if strings.HasPrefix(name, "entry.") && g.once.CompareAndSwap(false, true) { + if strings.HasPrefix(name, "entry.") && (g.on == "" || name == g.on) && g.once.CompareAndSwap(false, true) { g.prune() } return g.memObjects.Get(ctx, name) @@ -230,40 +232,76 @@ func TestTrunkViewReadsTheNewerRevisionWhenTheOneNamedIsRemovedUnderIt(t *testin } } -// A-487d: the readers of the newest trunk revision in the indexer program (ModuleInNewestView, SeedEntryHeld, entryOf, the verb -// revision without a kept view) read the newest again when the revision they named is removed under them. -func TestTheNewestTrunkReadersReadAgainWhenTheRevisionIsRemovedUnderThem(t *testing.T) { - cases := map[string]func(ix *Indexer) (bool, error){ - "ModuleInNewestView": func(ix *Indexer) (bool, error) { return ix.ModuleInNewestView(context.Background(), "avahi") }, - "SeedEntryHeld": func(ix *Indexer) (bool, error) { return ix.SeedEntryHeld(context.Background(), "avahi", "fp2") }, - "entryOf": func(ix *Indexer) (bool, error) { - e, err := ix.entryOf(context.Background(), "avahi") +// A-487d: every reader of the newest revision in the indexer program reads the newest again when the revision it named is +// removed under it (ModuleInNewestView, SeedEntryHeld, entryOf, SeedModulesFrom, FillVersions, the tool indexer_catalog_revision +// and the verb revision, trunk's and a watched branch's). +func TestTheNewestRevisionReadersReadAgainWhenTheRevisionIsRemovedUnderThem(t *testing.T) { + ctx := context.Background() + cases := map[string]struct { + branch string + read func(ix *Indexer) (bool, error) + }{ + "ModuleInNewestView": {"", func(ix *Indexer) (bool, error) { return ix.ModuleInNewestView(ctx, "avahi") }}, + "SeedEntryHeld": {"", func(ix *Indexer) (bool, error) { return ix.SeedEntryHeld(ctx, "avahi", "fp2") }}, + "entryOf": {"", func(ix *Indexer) (bool, error) { + e, err := ix.entryOf(ctx, "avahi") return e.Fp == "fp2", err - }, - "Revision": func(ix *Indexer) (bool, error) { - a, err := Revision(context.Background(), ix.Revisions, nil, "avahi", "avahi", meshcatalog.RevisionInput{}) - return a.Revision.Revision == 2, err - }, + }}, + "SeedModulesFrom": {"", func(ix *Indexer) (bool, error) { _, err := ix.SeedModulesFrom(ctx, nil, nil); return err == nil, err }}, + "FillVersions": {"", func(ix *Indexer) (bool, error) { + ix.Versions, ix.Heard = MemoryStore(), MemoryStore() + err := ix.FillVersions(ctx, func(context.Context, string, string) (BuilderVersionsAnswer, error) { + return BuilderVersionsAnswer{}, nil + }) + return err == nil, err + }}, + "indexer_catalog_revision": {"", func(ix *Indexer) (bool, error) { + var tool map[string]any + for _, tl := range CatalogRevisionTools(ix.Revisions, nil, time.Now, nil) { + if tl.Name == CatalogRevisionTool { + got, err := tl.Run(map[string]any{}) + if err != nil { + return false, err + } + tool = got.(map[string]any) + } + } + return tool != nil && tool["name"] == "trunk.2", nil + }}, + "Revision": {"", func(ix *Indexer) (bool, error) { + a, err := Revision(ctx, ix.Revisions, nil, "avahi", "avahi", meshcatalog.RevisionInput{}) + return a.Revision != nil && a.Revision.Revision == 2, err + }}, + "Revision of a branch": {"dev", func(ix *Indexer) (bool, error) { + a, err := Revision(ctx, ix.Revisions, nil, "avahi", "avahi", meshcatalog.RevisionInput{Branch: "dev"}) + return a.Revision != nil && a.Revision.Revision == 2 && len(a.Entries) == 1 && a.Entries[0].Fp == "fp2", err + }}, } - for name, read := range cases { + for name, c := range cases { t.Run(name, func(t *testing.T) { mem := newMemObjects(0) - keep := func(revision int64) { + keep := func(branch string, revision int64) { data, _ := json.Marshal(meshcatalog.CatalogEntry{Module: "avahi", Repository: catalogueRepo, None: "not built", Fp: fmt.Sprintf("fp%d", revision)}) - digest := fmt.Sprintf("d%d", revision) - rev := meshcatalog.CatalogRevision{Revision: revision, Kind: "trunk", Entries: []meshcatalog.EntryRef{{Module: "avahi", Digest: digest}}} - if err := KeepRevision(context.Background(), mem, rev, map[string][]byte{digest: data}); err != nil { + digest := fmt.Sprintf("%s-d%d", branch, revision) + rev := meshcatalog.CatalogRevision{Branch: branch, Revision: revision, Kind: "trunk", Entries: []meshcatalog.EntryRef{{Module: "avahi", Digest: digest}}} + if err := KeepRevision(ctx, mem, rev, map[string][]byte{digest: data}); err != nil { t.Fatal(err) } } - keep(1) - objects := &goneUnderRead{memObjects: mem} - objects.prune = func() { - keep(2) - _ = mem.Delete(context.Background(), RevisionObject(meshcatalog.CatalogRevision{Revision: 1, Kind: "trunk"})) - _ = mem.Delete(context.Background(), EntryObject("d1")) + keep("", 1) + if c.branch != "" { // the trunk stays at revision 1; the branch's revision 1 is removed under the read + keep("", 2) + keep(c.branch, 1) } - if ok, err := read(&Indexer{Revisions: objects}); err != nil || !ok { + objects := &goneUnderRead{memObjects: mem} + pruned := c.branch + objects.on = EntryObject(fmt.Sprintf("%s-d1", pruned)) + objects.prune = func() { + keep(pruned, 2) + _ = mem.Delete(ctx, RevisionObject(meshcatalog.CatalogRevision{Branch: pruned, Revision: 1, Kind: "trunk"})) + _ = mem.Delete(ctx, objects.on) + } + if ok, err := c.read(&Indexer{Revisions: objects}); err != nil || !ok { t.Errorf("answered %v (%v), want revision 2's entry", ok, err) } }) diff --git a/modules/mesh-delivery-indexer/internal/index/revision_tools.go b/modules/mesh-delivery-indexer/internal/index/revision_tools.go index 476e25ca..a21bbd3c 100644 --- a/modules/mesh-delivery-indexer/internal/index/revision_tools.go +++ b/modules/mesh-delivery-indexer/internal/index/revision_tools.go @@ -324,24 +324,28 @@ func CatalogRevisionTools(o Objects, ask func(key string, value []byte) (TakeInA ctx := context.Background() n, _ := args["revision"].(float64) name := "" + var rev meshcatalog.CatalogRevision + var entries []meshcatalog.CatalogEntry switch { case str(args, "group") != "" || str(args, "heads") != "": name = RevisionObject(meshcatalog.CatalogRevision{Kind: "candidate", Group: str(args, "group"), Heads: str(args, "heads")}) case n > 0: name = "trunk." + strconv.FormatInt(int64(n), 10) default: - newest, ok, err := newestTrunk(ctx, o) + newest, newestEntries, ok, err := readNewestOf(ctx, o, TrunkBranch) if err != nil { return nil, fmt.Errorf("the catalog graph revisions cannot be read: %w", err) } if !ok { return nil, ErrNoRevision } - name = RevisionObject(newest) + name, rev, entries = RevisionObject(newest), newest, newestEntries } - rev, entries, err := ReadRevision(ctx, o, name) - if err != nil { - return nil, err + if entries == nil { + var err error + if rev, entries, err = ReadRevision(ctx, o, name); err != nil { + return nil, err + } } return map[string]any{"name": name, "revision": rev, "entries": entries}, nil }}, diff --git a/modules/mesh-delivery-indexer/internal/index/revision_verb.go b/modules/mesh-delivery-indexer/internal/index/revision_verb.go index 20d0d8a1..f2feabb7 100644 --- a/modules/mesh-delivery-indexer/internal/index/revision_verb.go +++ b/modules/mesh-delivery-indexer/internal/index/revision_verb.go @@ -72,7 +72,7 @@ func Revision(ctx context.Context, o Objects, kept *KeptTrunk, holder, caller st var out meshcatalog.RevisionAnswer var newest meshcatalog.CatalogRevision var ok bool - var trunkEntries []meshcatalog.CatalogEntry + var trunkEntries, branchEntries []meshcatalog.CatalogEntry var err error if kept != nil { newest, trunkEntries, ok, err = kept.Newest(ctx, o) @@ -97,14 +97,14 @@ func Revision(ctx context.Context, o Objects, kept *KeptTrunk, holder, caller st return out, fmt.Errorf("the branch %q is no escaped name: %w", in.Branch, err) } if !isTrunkBranch(branch) { - other, found, err := newestOf(ctx, o, branch) + other, entries, found, err := readNewestOf(ctx, o, branch) if err != nil { return out, fmt.Errorf("the catalog graph revisions of %s cannot be read: %w", branch, err) } if !found { return meshcatalog.RevisionAnswer{NoneYet: true}, nil } - newest = other + newest, branchEntries = other, entries } name := RevisionObject(newest) switch { @@ -128,7 +128,9 @@ func Revision(ctx context.Context, o Objects, kept *KeptTrunk, holder, caller st } rev, entries := newest, trunkEntries if !isTrunkBranch(branch) && in.Group == "" && in.Heads == "" { - if rev, entries, err = ReadRevision(ctx, o, name); err != nil { + if name == RevisionObject(newest) { + entries = branchEntries // the newest of the branch, read by readNewestOf (A-487d) + } else if rev, entries, err = ReadRevision(ctx, o, name); err != nil { return out, err } } else if name != RevisionObject(newest) {