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
This commit is contained in:
@@ -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)
|
||||
}
|
||||
})
|
||||
|
||||
@@ -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
|
||||
}},
|
||||
|
||||
@@ -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) {
|
||||
|
||||
Reference in New Issue
Block a user