From 1e50642e3cd5a7590e7e0d76e0c6d36f4c62abc0 Mon Sep 17 00:00:00 2001 From: jochen Date: Sat, 21 Nov 2026 12:11:38 +0100 Subject: [PATCH 1/2] Assigner: the pass never waits on the keeping of revisions (H-A-259) A pass that kept a fresh assignment graph revision sat six to eight minutes keeping it and removing the revisions not current, so the wakes of pipeline-ended and running waited for it. The keeping now runs off the pass loop, one at a time and folded; the removal takes each entry's module and fingerprint from the store's listing instead of reading every entry object; each pass and each keeping says its duration. Builds: design 47 H H-A-259; ADR 0682 --- .../cmd/mesh-delivery-assigner/graphfill.go | 12 +- .../mesh-delivery-assigner/graphfill_test.go | 2 +- .../cmd/mesh-delivery-assigner/graphkept.go | 174 +++++++++++++++--- .../mesh-delivery-assigner/graphkept_test.go | 75 ++++++++ .../cmd/mesh-delivery-assigner/main.go | 6 +- .../cmd/mesh-delivery-assigner/objects.go | 37 ++++ .../cmd/mesh-delivery-assigner/pass.go | 4 +- .../cmd/mesh-delivery-assigner/revisions.go | 48 ++++- .../mesh-delivery-assigner/revisions_test.go | 119 ++++++++---- .../internal/assigngraph/keep.go | 25 ++- 10 files changed, 437 insertions(+), 65 deletions(-) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill.go index a3b79267..e2748a48 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill.go @@ -41,7 +41,7 @@ func (p *passer) fillAtStart(ctx context.Context) { } switch { case used >= capacity: - g.full = true + g.setFull(true) p.sayFill(meshwants.EventFull, "start", used, capacity, "the next revision") case used*5 >= capacity*4: p.sayFill(meshwants.EventFilling, "start", used, capacity, "") @@ -56,16 +56,16 @@ func (p *passer) fullBefore(ctx context.Context, c assigngraph.Computed) bool { if !ok { return false } - if g.full && used*5 < capacity*4 { - g.full = false + if g.isFull() && used*5 < capacity*4 { + g.setFull(false) p.sayFill(meshwants.EventRoom, fmt.Sprint(used), used, capacity, "") } if used+assigngraph.NewBytes(ctx, g.objects, c) <= capacity { - g.full = false + g.setFull(false) return false } - if !g.full { - g.full = true + if !g.isFull() { + g.setFull(true) p.sayFill(meshwants.EventFull, fmt.Sprint(used), used, capacity, "the next revision") } p.logf("the assignment graph revision is not kept: %s is full (%d of %d bytes), the last revision stays and no want is written until there is room", assigngraph.RevisionsObjects, used, capacity) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill_test.go index af05f547..0b3fdee7 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill_test.go @@ -63,7 +63,7 @@ func TestTheAssignmentGraphStoreSaysFillingFullAndRoom(t *testing.T) { } o.base = 700 p.graph.started = false - p.keepGraph(ctx) + p.needKeeping(ctx, keepNeed{judge: true}) // a start again: its keeping judges the fill (H-A-259) if len(events) != 1 || events[0] != meshwants.EventFilling { t.Fatalf("at the start past 80 %%: %v", events) } diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept.go index 44385d0c..19018a4a 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept.go @@ -8,6 +8,7 @@ import ( "fmt" "slices" "strings" + "sync" "time" mcc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient" @@ -26,23 +27,60 @@ type graphKeeper struct { objects assigngraph.Objects // halves is every followed branch's catalog graph revision held now. halves func() map[string]mcc.Half - // last is the revision last computed, so a pass whose inputs did not change keeps and says nothing. - last meshwants.AssignmentRevision - has bool + // mu guards what the keeping writes and the pass reads: the revision kept, full, and the need handed over (design 47 H-A-259). + mu sync.Mutex + // handedRev is the revision last handed to the keeping, so a pass whose inputs did not change hands nothing; handed is false + // until one is, and again when its keeping failed or found the store full, so the next pass hands it again. + handedRev meshwants.AssignmentRevision + handed bool // kept is the revision the wants follow, and kept's source the trunk's source revision it carries; ok is false until one is kept. kept meshwants.AssignmentRevision source int64 ok bool said string - // full says the next revision did not fit the store, so no want is written (graphfill.go); started says the first pass judged the fill. + // full says the next revision did not fit the store, so no want is written (graphfill.go); started says the first keeping judged the fill. full, started bool // revisions removes a revision that ceased to be current (revisions.go, H-A-86); nil keeps every revision. revisions *revisionRemover // computed is the revision computed by the last pass, with its entries: its edges. computed assigngraph.Computed + // The keeping off the pass loop (H-A-259): need is what waits to be kept, keeping says one runs; background runs it (nil: at + // once, in the caller), and wake makes a pass once a keeping changed what the pass reads. + need *keepNeed + keeping bool + background func(func()) + wake func() } -// keepGraph computes the revision of this pass and keeps it when the pass's inputs differ from the last computed. +// keepNeed is one need of the keeping: a computed revision to keep (nil: none), and whether the revisions not current are judged. +type keepNeed struct { + c *assigngraph.Computed + judge bool +} + +// keptNow is the revision the wants follow, with its trunk source, and whether one is kept. +func (g *graphKeeper) keptNow() (meshwants.AssignmentRevision, int64, bool) { + g.mu.Lock() + defer g.mu.Unlock() + return g.kept, g.source, g.ok +} + +// isFull says the store did not hold the last revision handed over, so no want is written (design 47 G §181). +func (g *graphKeeper) isFull() bool { + g.mu.Lock() + defer g.mu.Unlock() + return g.full +} + +func (g *graphKeeper) setFull(full bool) { + g.mu.Lock() + g.full = full + g.mu.Unlock() +} + +// keepGraph computes the revision of this pass and hands it to the keeping when the pass's inputs differ from the last handed. The +// keeping and the removing of revisions run off the pass loop, one at a time, and the pass never waits on them: it judges and +// writes the wants from the graph it holds (design 47 H-A-259). func (p *passer) keepGraph(ctx context.Context) { g := p.graph if g == nil || g.objects == nil || g.halves == nil { @@ -56,40 +94,120 @@ func (p *passer) keepGraph(ctx context.Context) { p.logf("the assignment graph leaves out %s", u) } } - if !g.started { + g.mu.Lock() + same := g.handed && assigngraph.Same(g.handedRev, c.Revision) + if !same { + g.handedRev, g.handed = c.Revision, true + } + g.mu.Unlock() + if !same { + p.needKeeping(ctx, keepNeed{c: &c}) + } +} + +// needKeeping hands a need to the keeping: one keeping runs at a time, and a need that comes while one runs is folded into the one +// that waits (the newest revision, and a judging asked by either), so it runs once more (design 47 H-A-259). +func (p *passer) needKeeping(ctx context.Context, n keepNeed) { + g := p.graph + g.mu.Lock() + if w := g.need; w != nil { + n.judge = n.judge || w.judge + if n.c == nil { + n.c = w.c + } + } + g.need = &n + if g.keeping { + g.mu.Unlock() + return + } + g.keeping = true + g.mu.Unlock() + run := func() { + for { + g.mu.Lock() + next := g.need + g.need = nil + if next == nil { + g.keeping = false + g.mu.Unlock() + return + } + g.mu.Unlock() + p.keepOne(ctx, *next) + } + } + if g.background != nil { + g.background(run) + return + } + run() +} + +// keepOne keeps one computed revision, judges the store's fill, says assignment-revision for a revision kept now and removes the +// revisions that ceased to be current; it says its duration in the journal, and wakes a pass when it changed what the pass reads. +func (p *passer) keepOne(ctx context.Context, n keepNeed) { + g := p.graph + start := time.Now() + changed := false + defer func() { + p.logf("the keeping of the assignment graph took %s", time.Since(start).Round(time.Millisecond)) + if changed && g.background != nil && g.wake != nil { + g.wake() + } + }() + if !g.started { // the first keeping, the start's, judges the fill once (graphfill.go) g.started = true p.fillAtStart(ctx) } - if g.has && g.ok && assigngraph.Same(g.last, c.Revision) { - return + if n.c != nil { + full := g.isFull() + fresh := p.keepRevision(ctx, *n.c) + n.judge = n.judge || fresh + changed = fresh || full != g.isFull() + } + if n.judge && g.revisions != nil { + g.revisions.judge() // the revision before ceased to be current + } +} + +// keepRevision keeps c when the store holds it, and says whether a revision was kept now. +func (p *passer) keepRevision(ctx context.Context, c assigngraph.Computed) bool { + g := p.graph + again := func() { // the next pass hands this revision again + g.mu.Lock() + g.handed = false + g.mu.Unlock() } used, _, _ := g.fillOf(ctx) if p.fullBefore(ctx, c) { - return + again() + return false } rev, fresh, err := assigngraph.Keep(ctx, g.objects, c, meshwants.EventAssignmentRevision, p.clock()) if err != nil { p.logf("the assignment graph revision is not kept, so no want is said as wanted until it is: %v", err) - return + again() + return false } - g.last, g.has, g.kept, g.ok = c.Revision, true, rev, true - g.source = 0 + var source int64 for _, cat := range rev.Catalogs { if cat.Branch == p.w.trunkName() { - g.source = cat.Source + source = cat.Source } } + g.mu.Lock() + g.kept, g.ok, g.source = rev, true, source + g.mu.Unlock() if !fresh { - return + return false } p.fillingAfter(ctx, used) - if g.revisions != nil { - g.revisions.judge() // the revision before ceased to be current - } id := fmt.Sprintf("%s-%s-%d", meshwants.EventAssignmentRevision, rev.Kind, rev.Revision) if err := p.wantsSay(meshwants.EventAssignmentRevision, assigngraph.Event(rev), id); err != nil { p.logf("the assignment revision %d is kept but not said: %v", rev.Revision, err) } + return true } // graphInputs are what the pass's assignment graph is computed from: every followed branch's catalog half, the placements, each @@ -147,14 +265,20 @@ func (p *passer) sayWanted(node, module, fp, pipeline string, removed bool) { return } g := p.graph - if g == nil || !g.ok { + var kept meshwants.AssignmentRevision + var source int64 + ok := false + if g != nil { + kept, source, ok = g.keptNow() + } + if !ok { p.logf("the want of %s on %s is written, but no assignment graph revision is kept, so wanted is not said", module, node) return } at := p.clock().UTC() - body := meshwants.WantedEvent{V: keys.Version, Node: node, Module: module, Fp: fp, Pipeline: pipeline, Removed: removed, Revision: g.kept.Revision, Source: g.source, At: &at} + body := meshwants.WantedEvent{V: keys.Version, Node: node, Module: module, Fp: fp, Pipeline: pipeline, Removed: removed, Revision: kept.Revision, Source: source, At: &at} event := strings.TrimPrefix(meshwants.SubjectWanted(keys.EscapeName(node), keys.EscapeName(module)), "mesh.seat."+meshwants.Seat+".event.") - id := fmt.Sprintf("wanted.%s.%s.%s.%t.%d.%s", keys.EscapeName(node), keys.EscapeName(module), fp, removed, g.kept.Revision, at.Format(time.RFC3339Nano)) + id := fmt.Sprintf("wanted.%s.%s.%s.%t.%d.%s", keys.EscapeName(node), keys.EscapeName(module), fp, removed, kept.Revision, at.Format(time.RFC3339Nano)) if err := p.wantsSay(event, body, id); err != nil { p.logf("wanted of %s on %s is not said: %v", module, node, err) } @@ -185,7 +309,7 @@ func (p *passer) namedBuild(module, trunkFP string, unreleased ...bool) func(fp // the mesh-sdk merge moved its fingerprint). return p.w.released.withParts(module, p.w.ends.madeOf(module, fp)) } - if p.graph == nil || !p.graph.ok { + if _, _, kept := p.graphKept(); !kept { p.unheardRelease(module, fp, "no assignment graph revision is kept yet, so no release is looked up") return assign.KeptBuild{}, false } @@ -212,3 +336,11 @@ func (p *passer) unheardRelease(module, fp, why string) { p.logf("the release of %s at fingerprint %s is not heard: %s; its wants and candidates carry no version and no parts", module, fp, why) } } + +// graphKept is the revision the wants follow, with its trunk source, and whether one is kept; with no graph kept, none is. +func (p *passer) graphKept() (meshwants.AssignmentRevision, int64, bool) { + if p.graph == nil { + return meshwants.AssignmentRevision{}, 0, false + } + return p.graph.keptNow() +} diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept_test.go index 225a98df..977f753b 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept_test.go @@ -3,8 +3,10 @@ package main import ( "context" "encoding/json" + "fmt" "slices" "strings" + "sync" "testing" "time" @@ -12,7 +14,9 @@ import ( mcc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient" mwc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshwantsclient" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" + mpr "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants" + "git.novox.be/novox/mesh-sdk/go/catalogue" "mesh-delivery-assigner/internal/assigngraph" "mesh-delivery-assigner/internal/buckets" @@ -132,3 +136,74 @@ func TestTheWantsAreSaidWantedFromTheKeptAssignmentGraphRevision(t *testing.T) { t.Errorf("dropping the run's candidate dropped trunk: %v", err) } } + +// blockedObjects is an object bucket whose every listing waits until free is closed: a keeping that does not end. +type blockedObjects struct { + memObjects + free chan struct{} +} + +func (b blockedObjects) Names(ctx context.Context) ([]string, error) { + <-b.free + return b.memObjects.Names(ctx) +} + +// Design 47 H-A-256, H-A-259: the keeping of the assignment graph runs off the pass loop, so a pass writes the want of a passed +// pipeline while a keeping is blocked, and a pass after it hands nothing more while the same revision waits. +func TestAPassWritesWantsWhileAKeepingIsBlocked(t *testing.T) { + fp := mcc.SourcePrefix2 + strings.Repeat("a", 64) + wantsKV := &memKV{values: map[string][]byte{}} + p := newPasser(kvSet{buckets.Wants(): wantsKV, buckets.Asks(): &memKV{values: map[string][]byte{}}}, time.Now()) + var mu sync.Mutex + var journal strings.Builder + p.logf = func(f string, a ...any) { mu.Lock(); fmt.Fprintf(&journal, f+"\n", a...); mu.Unlock() } + said := func(words string) bool { + mu.Lock() + defer mu.Unlock() + return strings.Contains(journal.String(), words) + } + mdigest := strings.Repeat("e", 64) + mod, _ := mcc.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: fp, Manifest: mdigest, Repository: "novox/web", Commit: strings.Repeat("1", 40), Path: mcc.RootPath}) + putModuleRaw(p.w, trunkBranch, "web", mod) + p.w.manifests[mdigest] = parsed{module: "web", manifest: catalogue.Manifest{Module: "web"}} + placeOn(t, p.w, "ace", "web") + p.ends = newPipelineEnds(newMemEnds(), func() {}, t.Logf) + p.ends.trunk = p.w.trunkName + _, _ = p.ends.take(ended(trunkBranch, 5, mpr.PipelineEndedOutcomePassed, mover("web", fp, "0.1.2", 1, mpr.StepResultOutcomePassed))) + free := make(chan struct{}) + var kept sync.WaitGroup + t.Cleanup(func() { // the keeping ends before the test does, and says its duration + close(free) + kept.Wait() + if !said("the keeping of the assignment graph took ") { + t.Error("the keeping does not say its duration") + } + }) + half := mcc.Half{Revision: meshcatalog.CatalogRevision{Branch: trunkBranch, Kind: "trunk", Revision: 4, Source: 9, + Entries: []meshcatalog.EntryRef{{Module: "web", Digest: "sha256:" + strings.Repeat("a", 64)}}}, + Entries: map[string]meshcatalog.CatalogEntry{"web": {Module: "web", Fp: fp}}} + p.graph = &graphKeeper{objects: blockedObjects{memObjects{}, free}, halves: func() map[string]mcc.Half { return map[string]mcc.Half{trunkBranch: half} }, + background: func(f func()) { kept.Go(f) }} + for range 2 { + done := make(chan struct{}) + go func() { p.pass(context.Background()); close(done) }() + select { + case <-done: + case <-time.After(10 * time.Second): + t.Fatal("the pass waits on the keeping of the assignment graph") + } + } + if !said("the pass took ") { + t.Error("the pass does not say its duration") + } + key, _ := mwc.WantKey("ace", "web") + if w, err := mwc.DecodeWant(wantsKV.values[key]); err != nil || w.Fp != fp || w.Version != "0.1.2" { + t.Errorf("the want of web on ace = %+v (%v), want the passed version", w, err) + } + p.graph.mu.Lock() + keeping, waiting := p.graph.keeping, p.graph.need + p.graph.mu.Unlock() + if !keeping || waiting != nil { + t.Errorf("keeping %v, need waiting %+v: the second pass, of the same inputs, handed its revision again", keeping, waiting) + } +} diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go index 2733c801..2cf37108 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go @@ -613,7 +613,9 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, p.publishWants = wantsPublisher(ctx, js, thisNode) if iv != nil && iv.h != nil { objects := newBusObjects(js, process.Account{Node: thisNode, Module: assignment.Module()}, assigngraph.RevisionsObjects) - p.graph = &graphKeeper{objects: objects, halves: iv.h.views} + // The keeping and removing of revisions runs off the pass loop, and a keeping that changed what the pass reads wakes + // one (design 47 H-A-259). + p.graph = &graphKeeper{objects: objects, halves: iv.h.views, background: func(f func()) { go f() }, wake: wake} keep := func(ctx context.Context, ev meshcatalog.CatalogRevisionEvent) error { return p.keepCandidate(ctx, iv.call, ev) } @@ -628,7 +630,7 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, // The revisions that are not current are removed when one ceases to be current and once now (revisions.go, // design 47 H §764, H-A-86). p.graph.revisions = &revisionRemover{ctx: ctx, objects: objects, inUse: inUseOf(w), logf: logger.Printf} - p.graph.revisions.judge() + p.needKeeping(ctx, keepNeed{judge: true}) } } // The node-engine seat's manifest-reads-changed, for one node (design 47 H-A-104): its words are written into the state diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/objects.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/objects.go index e1833237..be8c7a5f 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/objects.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/objects.go @@ -88,6 +88,43 @@ func (b *busObjects) Names(ctx context.Context) ([]string, error) { return names, nil } +// PutDescribed stores data under name with the entry's module and fingerprint in its metadata, which the listing says (assigngraph.Describer, +// design 47 H-A-259). +func (b *busObjects) PutDescribed(ctx context.Context, name string, data []byte, module, fp string) error { + o, err := b.open(ctx) + if err != nil { + return err + } + _, err = o.Put(ctx, jetstream.ObjectMeta{Name: name, Metadata: map[string]string{entryModuleMeta: module, entryFpMeta: fp}}, bytes.NewReader(data)) + return err +} + +// Described is every object with the module and fingerprint its metadata says, in one listing. +func (b *busObjects) Described(ctx context.Context) ([]assigngraph.Described, error) { + o, err := b.open(ctx) + if err != nil { + return nil, err + } + infos, err := o.List(ctx) + if errors.Is(err, jetstream.ErrNoObjectsFound) { + return []assigngraph.Described{}, nil + } + if err != nil { + return nil, err + } + out := make([]assigngraph.Described, 0, len(infos)) + for _, i := range infos { + out = append(out, assigngraph.Described{Name: i.Name, Module: i.Metadata[entryModuleMeta], Fp: i.Metadata[entryFpMeta]}) + } + return out, nil +} + +// The metadata keys of an entry object's module and fingerprint. +const ( + entryModuleMeta = "module" + entryFpMeta = "fp" +) + // Delete removes the object of that name; one not held is no error (design 47 G §579: a revision nothing pins is removed). func (b *busObjects) Delete(ctx context.Context, name string) error { o, err := b.open(ctx) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go index 8ce224a0..cb7a6f97 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go @@ -141,9 +141,11 @@ func (p *passer) clock() time.Time { } func (p *passer) pass(ctx context.Context) { + start := time.Now() + defer func() { p.logf("the pass took %s", time.Since(start).Round(time.Millisecond)) }() // design 47 H-A-259 p.assignmentsSeat(ctx) p.keepGraph(ctx) - if p.graph == nil || !p.graph.full { // a full assignment graph store keeps the last revision and writes no new want (design 47 G §181) + if p.graph == nil || !p.graph.isFull() { // a full assignment graph store keeps the last revision and writes no new want (design 47 G §181) p.wants(ctx) p.sayPass(ctx, "judged") } else { diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/revisions.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/revisions.go index 57c2d085..a4791124 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/revisions.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/revisions.go @@ -2,6 +2,7 @@ package main import ( "context" + "encoding/json" "fmt" "slices" "strconv" @@ -53,7 +54,7 @@ func trunkRevision(name string) (int64, bool) { // remove removes each kept revision that is not current, and then the entries no kept revision or candidate lists and no want or // running build names (design 47 G §179). func (k *revisionRemover) remove() error { - names, err := k.objects.Names(k.ctx) + names, described, err := k.listing() if err != nil { return err } @@ -107,7 +108,7 @@ func (k *revisionRemover) remove() error { if !ok || listed[digest] { continue } - e, err := assigngraph.ReadEntry(k.ctx, k.objects, digest) + e, err := k.entryOf(n, digest, described) if err != nil { return err } @@ -138,3 +139,46 @@ func inUseOf(w *world) func(module, fp string) bool { return false } } + +// listing is every object's name in one read and, where the bucket says them, each entry object's module and fingerprint by name +// (design 47 H-A-259); nil described where the bucket says none. +func (k *revisionRemover) listing() ([]string, map[string]assigngraph.Described, error) { + d, ok := k.objects.(assigngraph.Describer) + if !ok { + names, err := k.objects.Names(k.ctx) + return names, nil, err + } + listed, err := d.Described(k.ctx) + if err != nil { + return nil, nil, err + } + names := make([]string, 0, len(listed)) + described := make(map[string]assigngraph.Described, len(listed)) + for _, l := range listed { + names = append(names, l.Name) + described[l.Name] = l + } + return names, described, nil +} + +// entryOf is the module and fingerprint of the entry object name: as the listing says them, with no read; an entry put before the +// listing said them is read once and put again with them, so no later judging reads it (design 47 H-A-259). +func (k *revisionRemover) entryOf(name, digest string, described map[string]assigngraph.Described) (meshwants.AssignmentEntry, error) { + if l, ok := described[name]; ok && l.Module != "" && l.Fp != "" { + return meshwants.AssignmentEntry{Module: l.Module, Fp: l.Fp}, nil + } + data, err := k.objects.Get(k.ctx, name) + if err != nil { + return meshwants.AssignmentEntry{}, fmt.Errorf("the entry %s: %w", digest, err) + } + var e meshwants.AssignmentEntry + if err := json.Unmarshal(data, &e); err != nil { + return e, fmt.Errorf("the entry %s: %w", digest, err) + } + if described != nil { + if err := assigngraph.PutEntry(k.ctx, k.objects, name, data, e); err != nil { + k.logf("the entry %s is not put again with its module and fingerprint, so the next judging reads it again: %v", digest, err) + } + } + return e, nil +} diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/revisions_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/revisions_test.go index 5b38752d..32a962a5 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/revisions_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/revisions_test.go @@ -3,6 +3,7 @@ package main import ( "context" "encoding/json" + "strings" "testing" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants" @@ -12,42 +13,98 @@ import ( func (m memObjects) Delete(_ context.Context, name string) error { delete(m, name); return nil } +// describedObjects is memObjects whose listing says each entry's module and fingerprint (assigngraph.Describer), counting the +// entry objects read. +type describedObjects struct { + memObjects + meta map[string][2]string + reads int +} + +func (d *describedObjects) Get(ctx context.Context, name string) ([]byte, error) { + if strings.HasPrefix(name, "entry.") { + d.reads++ + } + return d.memObjects.Get(ctx, name) +} + +func (d *describedObjects) PutDescribed(_ context.Context, name string, data []byte, module, fp string) error { + d.memObjects[name], d.meta[name] = data, [2]string{module, fp} + return nil +} + +func (d *describedObjects) Described(context.Context) ([]assigngraph.Described, error) { + var out []assigngraph.Described + for n := range d.memObjects { + out = append(out, assigngraph.Described{Name: n, Module: d.meta[n][0], Fp: d.meta[n][1]}) + } + return out, nil +} + // Design 47 H §764, H-A-86: with the gate's pins gone, an assignment graph revision that is not current is removed, with the // entries no kept revision or candidate lists and no want or running build names; the current revision, the entries it lists, // a running build's entry and a run's kept candidate with its entries stay. +// H-A-259: where the listing says each entry's module and fingerprint, the judging reads no entry object; an entry put before it +// said them is read once and put again with them. func TestARevisionNotCurrentIsRemoved(t *testing.T) { - objects := memObjects{} - entry := func(module, fp string) string { - e := meshwants.AssignmentEntry{Node: "n1", Module: module, Fp: fp} - d := assigngraph.EntryDigest(e) - raw, _ := json.Marshal(e) - objects[assigngraph.EntryObject(d)] = raw - return d - } - shared, old, running, cand := entry("a", "fp-a"), entry("b", "fp-b1"), entry("c", "fp-c1"), entry("d", "fp-d2") - revision := func(n int64, digests ...string) { - rev := meshwants.AssignmentRevision{Revision: n} - for _, d := range digests { - rev.Entries = append(rev.Entries, meshwants.NodeEntryRef{Node: "n1", Digest: d}) + for _, listed := range []string{"plain", "described", "described-later"} { + objects := memObjects{} + described := &describedObjects{memObjects: objects, meta: map[string][2]string{}} + entry := func(module, fp string) string { + e := meshwants.AssignmentEntry{Node: "n1", Module: module, Fp: fp} + d := assigngraph.EntryDigest(e) + raw, _ := json.Marshal(e) + objects[assigngraph.EntryObject(d)] = raw + if listed == "described" { + described.meta[assigngraph.EntryObject(d)] = [2]string{module, fp} + } + return d } - raw, _ := json.Marshal(rev) - objects[assigngraph.TrunkObject(n)] = raw - } - candRaw, _ := json.Marshal(meshwants.AssignmentRevision{Revision: 1, Kind: "candidate", Group: "run-7", Heads: "h1", - Entries: []meshwants.NodeEntryRef{{Node: "n1", Module: "d", Digest: cand}}}) - objects[assigngraph.CandidateObject("run-7", "h1")] = candRaw - revision(1, shared, old, running) - revision(2, shared, old) - revision(3, shared) - k := &revisionRemover{ctx: context.Background(), objects: objects, logf: t.Logf, - inUse: func(module, fp string) bool { return module == "c" && fp == "fp-c1" }} - k.judge() - has := func(name string) bool { _, ok := objects[name]; return ok } - for name, want := range map[string]bool{assigngraph.TrunkObject(1): false, assigngraph.TrunkObject(2): false, assigngraph.TrunkObject(3): true, - assigngraph.EntryObject(old): false, assigngraph.EntryObject(running): true, assigngraph.EntryObject(shared): true, - assigngraph.EntryObject(cand): true, assigngraph.CandidateObject("run-7", "h1"): true} { - if has(name) != want { - t.Errorf("%s kept = %v, want %v", name, has(name), want) + shared, old, running, cand := entry("a", "fp-a"), entry("b", "fp-b1"), entry("c", "fp-c1"), entry("d", "fp-d2") + revision := func(n int64, digests ...string) { + rev := meshwants.AssignmentRevision{Revision: n} + for _, d := range digests { + rev.Entries = append(rev.Entries, meshwants.NodeEntryRef{Node: "n1", Digest: d}) + } + raw, _ := json.Marshal(rev) + objects[assigngraph.TrunkObject(n)] = raw + } + candRaw, _ := json.Marshal(meshwants.AssignmentRevision{Revision: 1, Kind: "candidate", Group: "run-7", Heads: "h1", + Entries: []meshwants.NodeEntryRef{{Node: "n1", Module: "d", Digest: cand}}}) + objects[assigngraph.CandidateObject("run-7", "h1")] = candRaw + revision(1, shared, old, running) + revision(2, shared, old) + revision(3, shared) + var o revisionObjects = objects + if listed != "plain" { + o = described + } + k := &revisionRemover{ctx: context.Background(), objects: o, logf: t.Logf, + inUse: func(module, fp string) bool { return module == "c" && fp == "fp-c1" }} + k.judge() + has := func(name string) bool { _, ok := objects[name]; return ok } + for name, want := range map[string]bool{assigngraph.TrunkObject(1): false, assigngraph.TrunkObject(2): false, assigngraph.TrunkObject(3): true, + assigngraph.EntryObject(old): false, assigngraph.EntryObject(running): true, assigngraph.EntryObject(shared): true, + assigngraph.EntryObject(cand): true, assigngraph.CandidateObject("run-7", "h1"): true} { + if has(name) != want { + t.Errorf("%s: %s kept = %v, want %v", listed, name, has(name), want) + } + } + switch listed { + case "described": + if described.reads != 0 { + t.Errorf("described: the judging read %d entry objects, want none", described.reads) + } + case "described-later": + if described.meta[assigngraph.EntryObject(running)] != [2]string{"c", "fp-c1"} { + t.Errorf("described-later: the entry in use is not put again with its module and fingerprint: %v", described.meta) + } + reads := described.reads + revision(4, shared) + k.judge() + if described.reads != reads { + t.Errorf("described-later: a second judging read %d entry objects again", described.reads-reads) + } } } } diff --git a/modules/mesh-delivery-assigner/internal/assigngraph/keep.go b/modules/mesh-delivery-assigner/internal/assigngraph/keep.go index 9f340097..e3630837 100644 --- a/modules/mesh-delivery-assigner/internal/assigngraph/keep.go +++ b/modules/mesh-delivery-assigner/internal/assigngraph/keep.go @@ -30,6 +30,29 @@ type Objects interface { Names(ctx context.Context) ([]string, error) } +// Described is one object as the bucket's listing says it: its name, and for an entry object the module and fingerprint put beside +// its bytes (empty for one put before them). +type Described struct { + Name, Module, Fp string +} + +// Describer is an object bucket whose listing says, in one read, each entry object's module and fingerprint, so the removal of the +// revisions not current reads no object per entry (design 47 H-A-259). +type Describer interface { + // PutDescribed stores data whole under name, with module and fp beside it in the listing. + PutDescribed(ctx context.Context, name string, data []byte, module, fp string) error + // Described is every object, as the listing says it. + Described(ctx context.Context) ([]Described, error) +} + +// PutEntry stores the entry object e under name, with its module and fingerprint beside it where the bucket says them. +func PutEntry(ctx context.Context, o Objects, name string, data []byte, e meshwants.AssignmentEntry) error { + if d, ok := o.(Describer); ok { + return d.PutDescribed(ctx, name, data, e.Module, e.Fp) + } + return o.Put(ctx, name, data) +} + // EntryObject is the object name of the entry of that digest (the seat's key form entry.). func EntryObject(digest string) string { return "entry." + digest } @@ -144,7 +167,7 @@ func writeEntries(ctx context.Context, o Objects, c Computed, rev meshwants.Assi if err != nil { return err } - if err := o.Put(ctx, name, data); err != nil { + if err := PutEntry(ctx, o, name, data, e); err != nil { return fmt.Errorf("the entry of %s/%s in %s: %w", ref.Node, ref.Module, RevisionsObjects, err) } held[name] = true From 14254dd0bab1770acb0e68ca7e6db0c542947659 Mon Sep 17 00:00:00 2001 From: jochen Date: Sat, 21 Nov 2026 12:31:51 +0100 Subject: [PATCH 2/2] Assigner: no want before a revision is kept; the full-store verdict stays the pass's Review round 1: the start handed a removal-only keeping to the background while passes wrote wants with no revision kept, so their wanted was never said. A pass now writes no want until the first keeping keeps a revision (that keeping wakes the pass), the start's removal folds into the first pass's keeping, and the pass judges the store's fill itself, through a handle of its own, before it writes. The integration bed makes the revisions' object store, as the grants part does from the manifest. Builds: design 47 H H-A-259, H-A-261; ADR 0682 --- .../cmd/mesh-delivery-assigner/graphfill.go | 22 +++- .../mesh-delivery-assigner/graphfill_test.go | 13 +- .../cmd/mesh-delivery-assigner/graphkept.go | 60 +++++++--- .../mesh-delivery-assigner/graphkept_test.go | 113 ++++++++++++++---- .../integration_test.go | 6 + .../cmd/mesh-delivery-assigner/main.go | 5 +- .../cmd/mesh-delivery-assigner/pass.go | 5 +- 7 files changed, 170 insertions(+), 54 deletions(-) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill.go index e2748a48..4809119e 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill.go @@ -15,7 +15,21 @@ import ( // fillOf is the store's fill now: its bytes and cap, when the bucket says them and has a cap. func (g *graphKeeper) fillOf(ctx context.Context) (used, capacity int64, ok bool) { - f, is := g.objects.(assigngraph.Filler) + return fillIn(ctx, g.objects) +} + +// passObjects is the store as the pass reads its fill: a handle of its own where one is given, so the pass's read never shares one +// with a keeping that runs beside it (design 47 H-A-261). +func (g *graphKeeper) passObjects() assigngraph.Objects { + if g.reads != nil { + return g.reads + } + return g.objects +} + +// fillIn is the fill of the bucket o, when it says one and has a cap. +func fillIn(ctx context.Context, o assigngraph.Objects) (used, capacity int64, ok bool) { + f, is := o.(assigngraph.Filler) if !is { return 0, 0, false } @@ -35,7 +49,7 @@ func (p *passer) sayFill(event, about string, used, capacity int64, refused stri // its cap), so a fill reached while the process was down is said too. func (p *passer) fillAtStart(ctx context.Context) { g := p.graph - used, capacity, ok := g.fillOf(ctx) + used, capacity, ok := fillIn(ctx, g.passObjects()) if !ok { return } @@ -52,7 +66,7 @@ func (p *passer) fillAtStart(ctx context.Context) { // 80 % again. It answers true while the store is full. func (p *passer) fullBefore(ctx context.Context, c assigngraph.Computed) bool { g := p.graph - used, capacity, ok := g.fillOf(ctx) + used, capacity, ok := fillIn(ctx, g.passObjects()) if !ok { return false } @@ -60,7 +74,7 @@ func (p *passer) fullBefore(ctx context.Context, c assigngraph.Computed) bool { g.setFull(false) p.sayFill(meshwants.EventRoom, fmt.Sprint(used), used, capacity, "") } - if used+assigngraph.NewBytes(ctx, g.objects, c) <= capacity { + if used+assigngraph.NewBytes(ctx, g.passObjects(), c) <= capacity { g.setFull(false) return false } diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill_test.go index 0b3fdee7..f4c43ced 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphfill_test.go @@ -61,14 +61,14 @@ func TestTheAssignmentGraphStoreSaysFillingFullAndRoom(t *testing.T) { if len(events) != 0 { t.Fatalf("events %v", events) } - o.base = 700 + o.base, o.cap = 8500, 10000 // past 80 %, with room for the next revision, which the pass judges itself (H-A-261) p.graph.started = false - p.needKeeping(ctx, keepNeed{judge: true}) // a start again: its keeping judges the fill (H-A-259) + p.keepGraph(ctx) // a start again: its first pass judges the fill if len(events) != 1 || events[0] != meshwants.EventFilling { t.Fatalf("at the start past 80 %%: %v", events) } c := assigngraph.Computed{Revision: meshwants.AssignmentRevision{Entries: []meshwants.NodeEntryRef{}}} - o.base = 990 + o.base, o.cap = 990, 1000 if !p.fullBefore(ctx, c) || !p.graph.full || events[len(events)-1] != meshwants.EventFull { t.Fatalf("a revision that does not fit: events %v", events) } @@ -76,8 +76,15 @@ func TestTheAssignmentGraphStoreSaysFillingFullAndRoom(t *testing.T) { if n := len(events); n != 2 { t.Errorf("full is said once: %v", events) } + // H-A-261: the verdict is the pass's own: with the store full the pass writes no want, though a revision is kept. + if held := p.keepGraph(ctx); held != heldFull { + t.Errorf("a pass with the store full answers %q, want %q", held, heldFull) + } o.base = 100 if p.fullBefore(ctx, c) || p.graph.full || events[len(events)-1] != meshwants.EventRoom { t.Errorf("room: events %v", events) } + if held := p.keepGraph(ctx); held != "" { + t.Errorf("a pass with room and a revision kept answers %q, want the wants written", held) + } } diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept.go index 19018a4a..b60771eb 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept.go @@ -25,6 +25,8 @@ import ( // that follows are written from the revision it holds. type graphKeeper struct { objects assigngraph.Objects + // reads is the same store through a handle of the pass's own, for the pass's read of its fill (graphfill.go); nil reads objects. + reads assigngraph.Objects // halves is every followed branch's catalog graph revision held now. halves func() map[string]mcc.Half // mu guards what the keeping writes and the pass reads: the revision kept, full, and the need handed over (design 47 H-A-259). @@ -33,12 +35,14 @@ type graphKeeper struct { // until one is, and again when its keeping failed or found the store full, so the next pass hands it again. handedRev meshwants.AssignmentRevision handed bool + // handedOnce says a revision was handed: the first carries the start's removal (H-A-261). + handedOnce bool // kept is the revision the wants follow, and kept's source the trunk's source revision it carries; ok is false until one is kept. kept meshwants.AssignmentRevision source int64 ok bool said string - // full says the next revision did not fit the store, so no want is written (graphfill.go); started says the first keeping judged the fill. + // full says the next revision did not fit the store, so no want is written (graphfill.go); started says the first pass judged the fill. full, started bool // revisions removes a revision that ceased to be current (revisions.go, H-A-86); nil keeps every revision. revisions *revisionRemover @@ -78,13 +82,21 @@ func (g *graphKeeper) setFull(full bool) { g.mu.Unlock() } -// keepGraph computes the revision of this pass and hands it to the keeping when the pass's inputs differ from the last handed. The -// keeping and the removing of revisions run off the pass loop, one at a time, and the pass never waits on them: it judges and -// writes the wants from the graph it holds (design 47 H-A-259). -func (p *passer) keepGraph(ctx context.Context) { +// heldNoRevision is the pass's words while no assignment graph revision is kept: it writes no want (design 47 H-A-261). +const heldNoRevision = "held: no assignment graph revision is kept yet, so no want is written until the first keeping ends (H-A-261)" + +// heldFull is the pass's words while the next revision does not fit its store (design 47 G §181). +const heldFull = "the assignment graph store is full: no want is written (design 47 G §181)" + +// keepGraph computes the revision of this pass, judges the store's fill itself, and hands the revision to the keeping when the +// pass's inputs differ from the last handed. The keeping and the removing of revisions run off the pass loop, one at a time, and the +// pass never waits on them: it judges and writes the wants from the graph it holds (design 47 H-A-259). It answers why the pass +// writes no want, or "" when it writes them: none while the next revision does not fit the store (G §181), and none while no +// revision is kept (H-A-261), whose keeping wakes a pass when it ends. +func (p *passer) keepGraph(ctx context.Context) string { g := p.graph if g == nil || g.objects == nil || g.halves == nil { - return + return "" } c := assigngraph.Compute(p.graphInputs()) g.computed = c @@ -94,15 +106,32 @@ func (p *passer) keepGraph(ctx context.Context) { p.logf("the assignment graph leaves out %s", u) } } + if !g.started { // the first pass judges the fill once (graphfill.go) + g.started = true + p.fillAtStart(ctx) + } + if p.fullBefore(ctx, c) { + g.mu.Lock() + g.handed = false // handed once it fits + g.mu.Unlock() + return heldFull + } g.mu.Lock() same := g.handed && assigngraph.Same(g.handedRev, c.Revision) + first := !g.handedOnce if !same { - g.handedRev, g.handed = c.Revision, true + g.handedRev, g.handed, g.handedOnce = c.Revision, true, true } g.mu.Unlock() if !same { - p.needKeeping(ctx, keepNeed{c: &c}) + // The start's removal of the revisions not current folds into the first keeping: it keeps the first pass's revision, then + // removes (H-A-261). + p.needKeeping(ctx, keepNeed{c: &c, judge: first}) } + if _, _, ok := g.keptNow(); !ok { + return heldNoRevision + } + return "" } // needKeeping hands a need to the keeping: one keeping runs at a time, and a need that comes while one runs is folded into the one @@ -144,7 +173,7 @@ func (p *passer) needKeeping(ctx context.Context, n keepNeed) { run() } -// keepOne keeps one computed revision, judges the store's fill, says assignment-revision for a revision kept now and removes the +// keepOne keeps one computed revision, says assignment-revision for a revision kept now and removes the // revisions that ceased to be current; it says its duration in the journal, and wakes a pass when it changed what the pass reads. func (p *passer) keepOne(ctx context.Context, n keepNeed) { g := p.graph @@ -156,15 +185,12 @@ func (p *passer) keepOne(ctx context.Context, n keepNeed) { g.wake() } }() - if !g.started { // the first keeping, the start's, judges the fill once (graphfill.go) - g.started = true - p.fillAtStart(ctx) - } if n.c != nil { - full := g.isFull() + _, _, had := g.keptNow() fresh := p.keepRevision(ctx, *n.c) + _, _, has := g.keptNow() n.judge = n.judge || fresh - changed = fresh || full != g.isFull() + changed = fresh || had != has // the first revision kept: the pass writes the wants it held (H-A-261) } if n.judge && g.revisions != nil { g.revisions.judge() // the revision before ceased to be current @@ -180,10 +206,6 @@ func (p *passer) keepRevision(ctx context.Context, c assigngraph.Computed) bool g.mu.Unlock() } used, _, _ := g.fillOf(ctx) - if p.fullBefore(ctx, c) { - again() - return false - } rev, fresh, err := assigngraph.Keep(ctx, g.objects, c, meshwants.EventAssignmentRevision, p.clock()) if err != nil { p.logf("the assignment graph revision is not kept, so no want is said as wanted until it is: %v", err) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept_test.go index 977f753b..5acdb424 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/graphkept_test.go @@ -137,19 +137,55 @@ func TestTheWantsAreSaidWantedFromTheKeptAssignmentGraphRevision(t *testing.T) { } } -// blockedObjects is an object bucket whose every listing waits until free is closed: a keeping that does not end. +// blockedObjects is an object bucket whose listing waits while a gate stands: a keeping that does not end until it is opened. type blockedObjects struct { memObjects - free chan struct{} + mu sync.Mutex + gate chan struct{} } -func (b blockedObjects) Names(ctx context.Context) ([]string, error) { - <-b.free +func (b *blockedObjects) Names(ctx context.Context) ([]string, error) { + b.mu.Lock() + gate := b.gate + b.mu.Unlock() + if gate != nil { + <-gate + } + b.mu.Lock() + defer b.mu.Unlock() return b.memObjects.Names(ctx) } -// Design 47 H-A-256, H-A-259: the keeping of the assignment graph runs off the pass loop, so a pass writes the want of a passed -// pipeline while a keeping is blocked, and a pass after it hands nothing more while the same revision waits. +func (b *blockedObjects) Put(ctx context.Context, name string, data []byte) error { + b.mu.Lock() + defer b.mu.Unlock() + return b.memObjects.Put(ctx, name, data) +} + +func (b *blockedObjects) Get(ctx context.Context, name string) ([]byte, error) { + b.mu.Lock() + defer b.mu.Unlock() + return b.memObjects.Get(ctx, name) +} + +// block stands a gate, opened by the function it answers. +func (b *blockedObjects) block() func() { + gate := make(chan struct{}) + b.mu.Lock() + b.gate = gate + b.mu.Unlock() + return func() { + b.mu.Lock() + b.gate = nil + b.mu.Unlock() + close(gate) + } +} + +// Design 47 H-A-259, H-A-261: the keeping of the assignment graph runs off the pass loop. At the start, while the first keeping is +// blocked, a pass returns and writes no want; the keeping's end wakes a pass, which writes the passed pipeline's want. Later, while a +// keeping of new inputs is blocked, a pass writes the wants from the revision it holds, and a pass of the same inputs hands nothing +// more. Each pass and each keeping says its duration. func TestAPassWritesWantsWhileAKeepingIsBlocked(t *testing.T) { fp := mcc.SourcePrefix2 + strings.Repeat("a", 64) wantsKV := &memKV{values: map[string][]byte{}} @@ -170,21 +206,16 @@ func TestAPassWritesWantsWhileAKeepingIsBlocked(t *testing.T) { p.ends = newPipelineEnds(newMemEnds(), func() {}, t.Logf) p.ends.trunk = p.w.trunkName _, _ = p.ends.take(ended(trunkBranch, 5, mpr.PipelineEndedOutcomePassed, mover("web", fp, "0.1.2", 1, mpr.StepResultOutcomePassed))) - free := make(chan struct{}) + objects := &blockedObjects{memObjects: memObjects{}} var kept sync.WaitGroup - t.Cleanup(func() { // the keeping ends before the test does, and says its duration - close(free) - kept.Wait() - if !said("the keeping of the assignment graph took ") { - t.Error("the keeping does not say its duration") - } - }) + woke := make(chan struct{}, 8) half := mcc.Half{Revision: meshcatalog.CatalogRevision{Branch: trunkBranch, Kind: "trunk", Revision: 4, Source: 9, Entries: []meshcatalog.EntryRef{{Module: "web", Digest: "sha256:" + strings.Repeat("a", 64)}}}, Entries: map[string]meshcatalog.CatalogEntry{"web": {Module: "web", Fp: fp}}} - p.graph = &graphKeeper{objects: blockedObjects{memObjects{}, free}, halves: func() map[string]mcc.Half { return map[string]mcc.Half{trunkBranch: half} }, - background: func(f func()) { kept.Go(f) }} - for range 2 { + p.graph = &graphKeeper{objects: objects, halves: func() map[string]mcc.Half { return map[string]mcc.Half{trunkBranch: half} }, + background: func(f func()) { kept.Go(f) }, wake: func() { woke <- struct{}{} }} + pass := func() { + t.Helper() done := make(chan struct{}) go func() { p.pass(context.Background()); close(done) }() select { @@ -193,17 +224,53 @@ func TestAPassWritesWantsWhileAKeepingIsBlocked(t *testing.T) { t.Fatal("the pass waits on the keeping of the assignment graph") } } - if !said("the pass took ") { - t.Error("the pass does not say its duration") + wantOf := func(node string) (mwc.Want, error) { + key, _ := mwc.WantKey(node, "web") + return mwc.DecodeWant(wantsKV.values[key]) } - key, _ := mwc.WantKey("ace", "web") - if w, err := mwc.DecodeWant(wantsKV.values[key]); err != nil || w.Fp != fp || w.Version != "0.1.2" { - t.Errorf("the want of web on ace = %+v (%v), want the passed version", w, err) + open := objects.block() + t.Cleanup(func() { // the keeping ends before the test does, and says its duration + objects.mu.Lock() + standing := objects.gate != nil + objects.mu.Unlock() + if standing { + open() + } + kept.Wait() + if !said("the keeping of the assignment graph took ") { + t.Error("the keeping does not say its duration") + } + }) + + pass() // the start: the first keeping is blocked + if _, err := wantOf("ace"); err == nil { + t.Error("a pass at the start wrote a want before an assignment graph revision is kept") + } + open() + select { + case <-woke: + case <-time.After(10 * time.Second): + t.Fatal("the first keeping's end wakes no pass") + } + pass() + if w, err := wantOf("ace"); err != nil || w.Fp != fp || w.Version != "0.1.2" { + t.Errorf("the want of web on ace = %+v (%v), want the passed version once a revision is kept", w, err) + } + + open = objects.block() // a keeping of new inputs is blocked + placeOn(t, p.w, "g14", "web") + pass() + pass() // the same inputs again + if w, err := wantOf("g14"); err != nil || w.Fp != fp || w.Version != "0.1.2" { + t.Errorf("the want of web on g14 = %+v (%v), want the passed version while a keeping is blocked", w, err) } p.graph.mu.Lock() keeping, waiting := p.graph.keeping, p.graph.need p.graph.mu.Unlock() if !keeping || waiting != nil { - t.Errorf("keeping %v, need waiting %+v: the second pass, of the same inputs, handed its revision again", keeping, waiting) + t.Errorf("keeping %v, need waiting %+v: the pass of the same inputs handed its revision again", keeping, waiting) + } + if !said("the pass took ") { + t.Error("the pass does not say its duration") } } diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/integration_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/integration_test.go index 8a26a659..810880c6 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/integration_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/integration_test.go @@ -12,6 +12,7 @@ import ( "git.novox.be/novox/mesh-sdk/go/keys" "io" "maps" + "mesh-delivery-assigner/internal/assigngraph" "mesh-delivery-assigner/internal/assignment" "mesh-delivery-assigner/internal/buckets" "mesh-delivery-assigner/internal/puts" @@ -190,6 +191,11 @@ func startBed(t *testing.T, leaveOut string) *bed { if _, err := js.CreateObjectStore(ctx, jetstream.ObjectStoreConfig{Bucket: catalogue.BusName("mesh-delivery-assigner", catalogue.StateObjectsName(buckets.InputsState))}); err != nil { t.Fatal(err) } + // The assignment graph revisions' object store, which the grants part makes from the manifest's objects: no want is written + // before a revision is kept in it (design 47 H-A-261). + if _, err := js.CreateObjectStore(ctx, jetstream.ObjectStoreConfig{Bucket: catalogue.ObjectsBucket("mesh-delivery-assigner", assigngraph.RevisionsObjects)}); err != nil { + t.Fatal(err) + } // The builder's module log, as the runtime raises it (ADR 0297): the running commits are read from it (ADR 0571 clause 1). if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: buscompose.LogStreamName(builds.BuilderModule, builds.BuilderLog), Subjects: []string{buscompose.LogSubject(builds.BuilderModule, builds.BuilderLog) + ".>"}, AllowDirect: true}); err != nil { diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go index 2cf37108..61f65a13 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go @@ -615,7 +615,8 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, objects := newBusObjects(js, process.Account{Node: thisNode, Module: assignment.Module()}, assigngraph.RevisionsObjects) // The keeping and removing of revisions runs off the pass loop, and a keeping that changed what the pass reads wakes // one (design 47 H-A-259). - p.graph = &graphKeeper{objects: objects, halves: iv.h.views, background: func(f func()) { go f() }, wake: wake} + p.graph = &graphKeeper{objects: objects, halves: iv.h.views, background: func(f func()) { go f() }, wake: wake, + reads: newBusObjects(js, process.Account{Node: thisNode, Module: assignment.Module()}, assigngraph.RevisionsObjects)} keep := func(ctx context.Context, ev meshcatalog.CatalogRevisionEvent) error { return p.keepCandidate(ctx, iv.call, ev) } @@ -630,7 +631,7 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, // The revisions that are not current are removed when one ceases to be current and once now (revisions.go, // design 47 H §764, H-A-86). p.graph.revisions = &revisionRemover{ctx: ctx, objects: objects, inUse: inUseOf(w), logf: logger.Printf} - p.needKeeping(ctx, keepNeed{judge: true}) + // The start's removal of the revisions not current folds into the first pass's keeping (H-A-261). } } // The node-engine seat's manifest-reads-changed, for one node (design 47 H-A-104): its words are written into the state diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go index cb7a6f97..56aec212 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pass.go @@ -144,12 +144,11 @@ func (p *passer) pass(ctx context.Context) { start := time.Now() defer func() { p.logf("the pass took %s", time.Since(start).Round(time.Millisecond)) }() // design 47 H-A-259 p.assignmentsSeat(ctx) - p.keepGraph(ctx) - if p.graph == nil || !p.graph.isFull() { // a full assignment graph store keeps the last revision and writes no new want (design 47 G §181) + if held := p.keepGraph(ctx); held == "" { p.wants(ctx) p.sayPass(ctx, "judged") } else { - p.sayPass(ctx, "the assignment graph store is full: no want is written (design 47 G §181)") + p.sayPass(ctx, held) // a full store keeps the last revision (design 47 G §181); none kept yet writes no want (H-A-261) } p.puts(ctx) p.nodeWants(ctx)