From f95a1649414b6c27bd8830175ff6228f6c7418ad Mon Sep 17 00:00:00 2001 From: jochen Date: Fri, 20 Nov 2026 12:12:23 +0100 Subject: [PATCH] indexer: drop the earlier model's trunk and branch revisions at a take-in MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit catalog-revisions kept trunk. and branch.. objects beside the branch-keyed revisions, the newest trunk one marked current, so a reader heard revision 528 while its picture held 1. A branch's take-in now drops every such object no record pins, says the count in the journal, and the revisions tool marks each branch's newest revision current. Builds: design 47 H §743, H-A-135 Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy --- .../internal/index/catalog_revisions.go | 5 ++ .../internal/index/pins.go | 83 +++++++++++++++---- .../internal/index/revision_tools.go | 11 ++- .../internal/index/takein_source_test.go | 34 ++++++++ 4 files changed, 111 insertions(+), 22 deletions(-) diff --git a/modules/mesh-delivery-indexer/internal/index/catalog_revisions.go b/modules/mesh-delivery-indexer/internal/index/catalog_revisions.go index e584f836..d340e193 100644 --- a/modules/mesh-delivery-indexer/internal/index/catalog_revisions.go +++ b/modules/mesh-delivery-indexer/internal/index/catalog_revisions.go @@ -337,6 +337,11 @@ func (ix *Indexer) keepBranchEntries(ctx context.Context, branch string, src int } else if len(removed) > 0 { ix.logf("pins: %d revisions removed (%s), no record pins them and none is current", len(removed), strings.Join(removed, ", ")) } + if dropped, err := ix.dropEarlierFormsLocked(ctx); err != nil { + ix.logf("catalog graph: the revisions of the earlier forms (trunk.*, branch.*) are not dropped: %v", err) + } else if len(dropped) > 0 { + ix.logf("catalog graph: %d revisions of the earlier forms dropped (%s), no record pins them; each branch's newest revision is its current one", len(dropped), strings.Join(dropped, ", ")) + } if _, err := ix.removeUnlisted(ctx); err != nil { ix.logf("catalog graph: the entries nothing lists or names any more are not removed: %v", err) // at the first revision after none does (§675) } diff --git a/modules/mesh-delivery-indexer/internal/index/pins.go b/modules/mesh-delivery-indexer/internal/index/pins.go index 3140815d..439c97c2 100644 --- a/modules/mesh-delivery-indexer/internal/index/pins.go +++ b/modules/mesh-delivery-indexer/internal/index/pins.go @@ -253,25 +253,10 @@ func (ix *Indexer) judgePinsLocked(ctx context.Context) ([]string, error) { return nil, err } current := CurrentRevisions(names) - pinned := map[string]bool{} - pinKeys, err := ix.Pins.Keys(ctx) + pinKeys, pinned, err := ix.pinnedObjects(ctx) if err != nil { return nil, err } - for _, k := range pinKeys { - object, ok := pinObject(k) - if !ok { - continue - } - v, _, found, err := ix.Pins.Get(ctx, k) - if err != nil { - return nil, err - } - var pv PinValue - if found && json.Unmarshal(v, &pv) == nil && len(pv.Records) > 0 { - pinned[object] = true - } - } var removed []string for _, n := range names { if _, _, ok := RevisionGroup(n); !ok || pinned[n] { @@ -301,6 +286,72 @@ func (ix *Indexer) judgePinsLocked(ctx context.Context) ([]string, error) { return removed, nil } +// pinnedObjects are the state pins' keys and the revision objects a record pins. +func (ix *Indexer) pinnedObjects(ctx context.Context) ([]string, map[string]bool, error) { + pinned := map[string]bool{} + pinKeys, err := ix.Pins.Keys(ctx) + if err != nil { + return nil, nil, err + } + for _, k := range pinKeys { + object, ok := pinObject(k) + if !ok { + continue + } + v, _, found, err := ix.Pins.Get(ctx, k) + if err != nil { + return nil, nil, err + } + var pv PinValue + if found && json.Unmarshal(v, &pv) == nil && len(pv.Records) > 0 { + pinned[object] = true + } + } + return pinKeys, pinned, nil +} + +// earlierForm says whether a revision object is of the earlier model's forms, trunk. or branch.., beside the +// branch-keyed . of design 47 H §743 (H-A-135). +func earlierForm(name string) bool { + if _, _, ok := RevisionGroup(name); !ok { + return false + } + return strings.HasPrefix(name, "trunk.") || strings.HasPrefix(name, "branch.") +} + +// dropEarlierFormsLocked drops every revision object of the earlier forms (earlierForm) no record pins, at a branch's take-in +// (design 47 H §743, H-A-135): the branch's newest revision is its current one, and an earlier trunk revision kept beside it +// would be the newest trunk revision a reader hears. It drops none while the pins do not count yet; the caller holds keepMu. +func (ix *Indexer) dropEarlierFormsLocked(ctx context.Context) ([]string, error) { + if ix.PinsPending != nil { + if pending, err := ix.PinsPending(ctx); err != nil || pending != 0 { + return nil, err + } + } + names, err := ix.Revisions.Names(ctx) + if err != nil { + return nil, err + } + pinned := map[string]bool{} + if ix.Pins != nil { + if _, pinned, err = ix.pinnedObjects(ctx); err != nil { + return nil, err + } + } + var dropped []string + for _, n := range names { + if !earlierForm(n) || pinned[n] { + continue + } + if err := ix.Revisions.Delete(ctx, n); err != nil { + return dropped, fmt.Errorf("%s: %w", n, err) + } + dropped = append(dropped, n) + } + sort.Strings(dropped) + return dropped, nil +} + // PinDrop drops one pin of the state pins by hand, by its key . (indexer_pin_drop, design 47 H §765, H-A-57): // every record's, for a pin that names no running pipeline; the finding pin-missing of the key is cleared, and the removal // rule then applies. diff --git a/modules/mesh-delivery-indexer/internal/index/revision_tools.go b/modules/mesh-delivery-indexer/internal/index/revision_tools.go index 24ba847e..279e41e8 100644 --- a/modules/mesh-delivery-indexer/internal/index/revision_tools.go +++ b/modules/mesh-delivery-indexer/internal/index/revision_tools.go @@ -61,7 +61,8 @@ type RevisionSummary struct { Heads string `json:"heads,omitempty"` At *time.Time `json:"at,omitempty"` Entries int `json:"entries"` - // Current says it is the trunk's newest revision, which is kept whatever pins it. + // Current says it is the newest revision of its watched branch (CurrentRevisions, §579; H §743, H-A-135: no longer the + // newest trunk-kind revision over every branch, and never one of the earlier forms), which is kept whatever pins it. Current bool `json:"current,omitempty"` } @@ -84,7 +85,6 @@ func ListRevisions(ctx context.Context, o Objects, candidates bool) (RevisionsAn return out, fmt.Errorf("the objects %s cannot be listed: %w", CatalogRevisionsObjects, err) } listed := map[string]bool{} - var newest int64 entries := []string{} for _, n := range names { if strings.HasPrefix(n, "entry.") { @@ -103,17 +103,16 @@ func ListRevisions(ctx context.Context, o Objects, candidates bool) (RevisionsAn for _, ref := range rev.Entries { listed[EntryObject(ref.Digest)] = true } - if rev.Kind == "trunk" && rev.Revision > newest { - newest = rev.Revision - } if candidates && rev.Kind != "candidate" { continue } out.Revisions = append(out.Revisions, RevisionSummary{Name: n, Kind: rev.Kind, Revision: rev.Revision, Source: rev.Source, Group: rev.Group, Heads: rev.Heads, At: rev.At, Entries: len(rev.Entries)}) } + current := CurrentRevisions(names) for i := range out.Revisions { - out.Revisions[i].Current = out.Revisions[i].Kind == "trunk" && out.Revisions[i].Revision == newest + _, cur := current[out.Revisions[i].Name] + out.Revisions[i].Current = cur && out.Revisions[i].Kind == "trunk" && !earlierForm(out.Revisions[i].Name) } slices.SortFunc(out.Revisions, func(a, b RevisionSummary) int { return strings.Compare(a.Name, b.Name) }) out.Entries = len(entries) diff --git a/modules/mesh-delivery-indexer/internal/index/takein_source_test.go b/modules/mesh-delivery-indexer/internal/index/takein_source_test.go index 7545a99f..d36933e0 100644 --- a/modules/mesh-delivery-indexer/internal/index/takein_source_test.go +++ b/modules/mesh-delivery-indexer/internal/index/takein_source_test.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "errors" + "fmt" "reflect" "testing" @@ -121,6 +122,39 @@ func TestAFirstSourceRevisionIsTakenInWithNoMover(t *testing.T) { } } +// Design 47 H §743, H-A-135: at a branch's take-in the earlier model's revisions (trunk., branch..) no record +// pins are dropped, one a record pins stays, and the branch's newest revision is the current one, no longer the newest trunk. +func TestATakeInDropsTheEarlierFormsNoRecordPins(t *testing.T) { + ctx := context.Background() + ix, objects, _, f := takeInIndexer(t) + for _, n := range []string{"trunk.527", "trunk.528", "branch.master.1"} { + _, rev, _ := RevisionGroup(n) + raw, _ := json.Marshal(meshcatalog.CatalogRevision{Revision: rev, Kind: "trunk", Source: 1000 + rev}) + if err := objects.Put(ctx, n, raw); err != nil { + t.Fatal(err) + } + } + if err := ix.pin(ctx, "trunk.527", "pipeline.old"); err != nil { + t.Fatal(err) + } + start := meshdelivery.SourceMovedEvent{V: 1, Branch: "main", Source: 1, Call: "seed.operator.20261120", Start: true, + Heads: []meshdelivery.SourceMovedEventHeadsItem{{Repository: f.Repository, Commit: f.Merge}}} + if _, err := ix.TakeInSource(ctx, start); err != nil { + t.Fatal(err) + } + a, err := ListRevisions(ctx, objects, false) + if err != nil { + t.Fatal(err) + } + var got []string + for _, r := range a.Revisions { + got = append(got, fmt.Sprintf("%s current=%t", r.Name, r.Current)) + } + if want := []string{"main.1 current=true", "trunk.527 current=false"}; !reflect.DeepEqual(got, want) { + t.Errorf("kept %v, want %v: the unpinned earlier forms dropped, the pinned one kept, main.1 current", got, want) + } +} + // Design 47 H §769: the take-in of a source revision moving the catalogue repository reads `predefined` from that commit's // trees, and one changing a predefined key rewrites it. func TestATakeInOfTheCatalogsCommitRewritesPredefined(t *testing.T) {