From ed78003b236a52b781b8a68cefd6e3d023118af0 Mon Sep 17 00:00:00 2001 From: jochen Date: Tue, 17 Nov 2026 12:50:38 +0100 Subject: [PATCH] assigner: a composition reader names when its step said its end, so a take-up says no end again for a carried reader that passed (A-470l, A-470m) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The step's end, once said, is written on its reader in each run of its candidate naming it, by compare-and-set; a rerun's run carries it with the reader; the take-up at the start skips a reader that ended and is not marked rerun. Builds: design 47 G §719, §727; A-470l, A-470m. --- .../compositionbounds.go | 6 +++- .../compositionrun_test.go | 16 ++++++++++- .../mesh-delivery-assigner/compositionruns.go | 28 +++++++++++++++++++ .../compositionruns_test.go | 11 +++++++- .../mesh-delivery-assigner/compositionstep.go | 14 ++++++++-- .../cmd/mesh-delivery-assigner/main.go | 2 +- 6 files changed, 70 insertions(+), 7 deletions(-) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionbounds.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionbounds.go index b148dbd1..697e2046 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionbounds.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionbounds.go @@ -259,7 +259,8 @@ func (r *compositionRuns) endRunOf(key, ask, outcome, said string, verdict map[s } // readersOfOpen are the readers of every run with no `ended`, each with its ask's id once: what the assigner takes up again at -// its start (§719), each reader's end said from the keys alone (A-468). +// its start (§719), each reader's end said from the keys alone (A-468). A reader whose step said its end already, carried into a +// rerun's run, is taken up only when it is marked `rerun` (A-470l, A-470m). func (r *compositionRuns) readersOfOpen() ([]meshwants.CompositionReader, error) { all, err := r.keys() if err != nil { @@ -276,6 +277,9 @@ func (r *compositionRuns) readersOfOpen() ([]meshwants.CompositionReader, error) continue } for _, c := range run.Readers { + if c.Ended != nil && !c.Rerun { + continue // it ended passed already: only a reader marked rerun says its end again + } if !seen[c.ID] { seen[c.ID] = true out = append(out, c) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionrun_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionrun_test.go index 80961dd4..c86e2027 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionrun_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionrun_test.go @@ -492,7 +492,7 @@ func TestARerunMovesEveryReaderThatDidNotPass(t *testing.T) { return m, true } ends := make(chan meshwants.StepEnded, 16) - steps := &compositionSteps{node: "n1", now: time.Now, logf: t.Logf, run: s.r.run, resume: s.r.resume, + steps := &compositionSteps{node: "n1", now: time.Now, logf: t.Logf, run: s.r.run, resume: s.r.resume, ended: s.runs.stepEnded, say: func(event string, body any, _ string) error { if e, ok := body.(meshwants.StepEnded); ok { ends <- e @@ -549,4 +549,18 @@ func TestARerunMovesEveryReaderThatDidNotPass(t *testing.T) { if len(run.Readers) != 3 || !marks["ask-d"] || marks["ask-b"] || !marks["ask-a2"] { t.Errorf("the new run's readers %+v", run.Readers) } + // A-470m: each reader's `ended` is written once its step said its end, and ask-b's carried into the new run. + deadline := time.After(5 * time.Second) + for { + wake := s.runs.wake() + run, _, _, _ = s.runs.read(runKeyOf("main.7", "g14")) + if !slices.ContainsFunc(run.Readers, func(c meshwants.CompositionReader) bool { return c.Ended == nil }) { + break + } + select { + case <-wake: + case <-deadline: + t.Fatalf("a reader of the new run names no end: %+v", run.Readers) + } + } } diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionruns.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionruns.go index 12b019c4..ec6a8431 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionruns.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionruns.go @@ -536,6 +536,34 @@ func (r *compositionRuns) clearBounds(key, ask string, prefixes ...string) error return errors.Join(errs...) } +// stepEnded writes at as the `ended` of the reader asked under id in each run of its step's candidate naming it, by +// compare-and-set (A-470m): the time its step said its end, carried with it into a rerun's run. +func (r *compositionRuns) stepEnded(id string, step meshwants.StepRun, at time.Time) { + candidate, err := candidateKeyOf(step) + if err != nil { + r.logf("the end of the composition step %s is not written on its runs: %v", id, err) + return + } + keys, err := r.keysOf(candidate, id) + if err != nil { + r.logf("the end of the composition step %s is not written on its runs: %v", id, err) + return + } + at = at.UTC() + for _, key := range keys { + if _, _, err := r.change(key, func(c *meshwants.CompositionRun) bool { + i := slices.IndexFunc(c.Readers, func(c meshwants.CompositionReader) bool { return c.ID == id }) + if i < 0 { + return false + } + c.Readers[i].Ended = &at + return true + }); err != nil { + r.logf("the end of the composition step %s is not written on the composition run %s: %v", id, key, err) + } + } +} + // hasReader is whether readers holds the step asked under id. func hasReader(readers []meshwants.CompositionReader, id string) bool { return slices.ContainsFunc(readers, func(c meshwants.CompositionReader) bool { return c.ID == id }) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionruns_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionruns_test.go index 0dad873e..77f349c5 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionruns_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionruns_test.go @@ -536,8 +536,17 @@ func TestACompositionRunsBoundTimesOwedProgress(t *testing.T) { } ended := now _, _, _ = r.change(runKeyOf("main.3", "n2"), func(c *meshwants.CompositionRun) bool { c.Ended, c.Outcome = &ended, "passed"; return true }) + // A rerun's run carrying readers whose steps said their end (A-470l, A-470m): c passed and is not taken up, d is marked rerun. + _, _, _ = r.change(runKeyOf("main.3", "n1"), func(run *meshwants.CompositionRun) bool { + for _, id := range []string{"c", "d"} { + c := reader(id) + c.Ended, c.Rerun = &ended, id == "d" + run.Readers = append(run.Readers, c) + } + return true + }) readers, err := r.readersOfOpen() - if err != nil || len(readers) != 2 || readers[0].ID != "a" || readers[1].ID != "b" { + if err != nil || len(readers) != 3 || readers[0].ID != "a" || readers[1].ID != "b" || readers[2].ID != "d" { t.Fatalf("the readers taken up: %+v %v", readers, err) } if keys, _ := r.keysOf("main.3", "a"); !slices.Equal(keys, []string{runKeyOf("main.3", "n1"), runKeyOf("main.3", "n2")}) { diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionstep.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionstep.go index 8f12c511..ea1eeaeb 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionstep.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionstep.go @@ -35,8 +35,11 @@ type compositionSteps struct { // run runs one step and answers what it came to; resume judges a step taken up at the start from its runs (takeUp). run func(ctx context.Context, id string, run meshwants.StepRun) stepOutcome resume func(ctx context.Context, id string, run meshwants.StepRun) stepOutcome - now func() time.Time - logf func(string, ...any) + // ended writes, once the step asked under id said its end, that time on its reader in each run naming it (A-470m); nil + // writes none. + ended func(id string, run meshwants.StepRun, at time.Time) + now func() time.Time + logf func(string, ...any) // asker is the name the step's progress names as its asker, read when it is said (stepAskerOf). asker func() string // ticks is a ticker of every d, its channel and its stop (time.NewTicker); nil is the clock's. A test hands its own. @@ -160,7 +163,8 @@ func (c *compositionSteps) say1(ctx context.Context, id string, run meshwants.St c.sayEnd(id, run, &started, o) } -// sayEnd says the end of the step asked under id as the seat's step-ended., its id the ask's. +// sayEnd says the end of the step asked under id as the seat's step-ended., its id the ask's; once said, its time is +// written as its reader's `ended` (A-470m). func (c *compositionSteps) sayEnd(id string, run meshwants.StepRun, started *time.Time, o stepOutcome) { ended := c.now().UTC() if started == nil { @@ -171,6 +175,10 @@ func (c *compositionSteps) sayEnd(id string, run meshwants.StepRun, started *tim Rerun: run.Rerun, By: run.By, Started: started, Ended: &ended, Shared: o.Shared} if err := c.say(meshwants.EventStepEnded+"."+c.node, end, id); err != nil { c.logf("saying the end of the composition step %s: %v", id, err) + return + } + if c.ended != nil { + c.ended(id, run, ended) } } 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 a7c86317..0a455d59 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go @@ -713,7 +713,7 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, if bus != nil && js != nil && inputs != nil && p.publishWants != nil && runs != nil { run := &compositionRun{runs: runs, inputs: &compositionInputs{machines: w.machinesOf, callFile: bus.CallFile}, keeper: inputs, reads: &compositionReads{}, call: bus.CallKept, trunk: trunkOf(iv, w.trunkName), running: w.runningOf, away: away, put: runAskPublisher(js), ask: bus.CallFile, now: time.Now, logf: logger.Printf} - steps := &compositionSteps{node: thisNode, say: p.publishWants, run: run.run, resume: run.resume, now: time.Now, logf: logger.Printf, + steps := &compositionSteps{node: thisNode, say: p.publishWants, run: run.run, resume: run.resume, ended: runs.stepEnded, now: time.Now, logf: logger.Printf, asker: stepAskerOf(seatlist.Definition(gate.Reader, meshwants.Seat))} move := steps.move(ctx) // the readers a rerun carried (§727, A-470d) runs.moved.Store(&move)