From f09bd2668a8b1f80ada9896753ce0fce0dd3f8e1 Mon Sep 17 00:00:00 2001 From: jochen Date: Sun, 22 Nov 2026 19:57:15 +0100 Subject: [PATCH] Assigner: a passed pipeline takes a mover's version released before the pass (H-A-490) An again pipeline on a built, published key ends naming no version, and the runner never says its end again, so its movers kept the old want. At the pass, a mover with no version is matched to the release of its build's parts. Builds: design 47 H2 H-A-490 --- .../cmd/mesh-delivery-assigner/buildended.go | 7 ++++++ .../cmd/mesh-delivery-assigner/main.go | 1 + .../cmd/mesh-delivery-assigner/pipelines.go | 15 ++++++++++- .../mesh-delivery-assigner/pipelines_test.go | 25 +++++++++++++++---- 4 files changed, 42 insertions(+), 6 deletions(-) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/buildended.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/buildended.go index 6b02c229a..7466891ac 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/buildended.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/buildended.go @@ -154,6 +154,13 @@ func (b *builtEnds) madeOf(module, fp string) map[string]string { return parts } +// releasedOf is the version released of module's done build at fp, the release whose parts are what its build.ended made (design +// 47 G A-421); false when no such release is heard. +func (w *world) releasedOf(module, fp string) (string, bool) { + k, ok := w.released.withParts(module, w.ends.madeOf(module, fp)) + return k.Version, ok && k.Version != "" +} + // of is the version of module released from the source revision, with its parts' digests; false before it is heard. func (r *releasedVersions) of(module string, source int64) (assign.KeptBuild, bool) { r.mu.Lock() 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 d0fff5108..22e4783ac 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go @@ -656,6 +656,7 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, // once the first registrations are written (§95, §353). p.ends = newPipelineEnds(kvEnds{ctx, kv}, wake, logger.Printf) p.ends.trunk = w.trunkName + p.ends.releasedOf = w.releasedOf // a version released before its pipeline passed is taken at the pass (H-A-490) p.ends.runEnded = func(group string) error { return p.dropCandidate(ctx, group) } if err := hearEnds(hub, p.ends); err != nil { logger.Printf("a pipeline's end is not heard, so the wants keep the trunk-only form until the assigner starts again: %v", err) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines.go index 65f614222..c1883405f 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines.go @@ -153,6 +153,10 @@ type pipelineEnds struct { trunk func() string // now is the clock of the tier progress (tiers.go); nil is time.Now. now func() time.Time + // releasedOf is the version released of module's build at fp, matched by the parts its build.ended made (world.releasedOf): + // a mover whose version was released before its pipeline passed gets its want at the pass (design 47 H2 H-A-490). nil + // matches none. + releasedOf func(module, fp string) (string, bool) } func newPipelineEnds(st endStore, wake func(), logf func(string, ...any)) *pipelineEnds { @@ -162,7 +166,8 @@ func newPipelineEnds(st endStore, wake func(), logf func(string, ...any)) *pipel // take keeps, for each mover of a passed pipeline that released a version, that version as the newest of its module on the // pipeline's branch, by compare-and-set on a newer version (design 47 H §750): an older version, or the same one again, writes // nothing. A passed mover with no version yet is said in the journal and taken when the runner says the end again naming it -// (H-A-270); it holds its tier in the pipeline's tier progress meanwhile (H-A-277 (1)). It says whether any key changed. +// (H-A-270); it holds its tier in the pipeline's tier progress meanwhile (H-A-277 (1)). A mover whose build's version was +// released before the pass is taken at the pass with that version (H-A-490). It says whether any key changed. func (e *pipelineEnds) take(p mpr.PipelineEnded) (bool, error) { if p.Outcome != mpr.PipelineEndedOutcomePassed || p.Run != "" { return false, nil @@ -185,6 +190,14 @@ func (e *pipelineEnds) take(p mpr.PipelineEnded) (bool, error) { if m.Fingerprint == "" || !moverPassed(m) { continue } + if m.Version == "" && e.releasedOf != nil { + // A version released before its pipeline passed (an again pipeline on a built, published key) is never written + // on the mover, nor its end said again: it is judged at the pass, matched by its build's parts (H-A-490). + if v, ok := e.releasedOf(m.Module, m.Fingerprint); ok { + e.logf("%s: %s passed; its version %s was released before the pass, taken now", p.Pipeline, m.Module, v) + m.Version = v + } + } if m.Version == "" { // The runner writes a mover's version at its release's version-released, and says this end again once it does // (H-A-270 (1), (2)): the skip is said, never silent. diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines_test.go index fb10310eb..aff50e807 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines_test.go @@ -12,6 +12,7 @@ import ( mmac "git.novox.be/novox/mesh-contracts/go/clients/meshmoduleassignerclient" mma "git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner" oc "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" "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" @@ -156,10 +157,15 @@ func TestThePassedVersionIsKept(t *testing.T) { // A6/AC1, A5/AC1 (design 47 H §750): a pass writes, on every node the module is assigned to, the want naming the newest version // released on its branch whose pipeline passed, with the pipeline and the rank; with none passed it writes none. No grant, // canary, provider or composition is asked for. H-A-270 (1): a passed end whose mover names no version yet writes no want and -// says so in the journal; the same end said again naming the version writes it. +// says so in the journal; the same end said again naming the version writes it. H-A-490: a version released before its pipeline +// passed (an again pipeline on a built, published key) gets its want at the pass, matched to the mover's build by its parts. func TestAPassWritesTheWantOfThePassedVersion(t *testing.T) { fp := meshcatalogclient.SourcePrefix2 + strings.Repeat("a", 64) - for _, passed := range []bool{false, true} { + for _, c := range []struct { + name string + passed, releasedBefore bool + }{{"no pipeline passed", false, false}, {"passed, then its version released", true, false}, {"released, then its pipeline passed", true, true}} { + passed := c.passed wantsKV := &memKV{values: map[string][]byte{}} p := newPasser(kvSet{buckets.Wants(): wantsKV, buckets.Asks(): &memKV{values: map[string][]byte{}}}, time.Now()) p.say = func(oc.Condition) error { return nil } @@ -172,7 +178,16 @@ func TestAPassWritesTheWantOfThePassedVersion(t *testing.T) { var journal []string p.ends = newPipelineEnds(newMemEnds(), func() {}, func(f string, a ...any) { journal = append(journal, fmt.Sprintf(f, a...)) }) p.ends.trunk = p.w.trunkName - if passed { + p.ends.releasedOf = p.w.releasedOf + if c.releasedBefore { + // Built and released in an earlier pipeline that failed: the runner's again pipeline ends naming no version. + rel, _ := json.Marshal(meshcatalog.VersionReleasedEvent{Module: "web", Source: 4, Version: "0.1.2", Artifacts: []meshcatalog.VersionArtifact{{Artifact: "web:image", Digest: "sha256:7"}}}) + built, _ := json.Marshal(builds.BuildEnded{Module: "web", Fingerprint: fp, Outcome: builds.BuildDone, Made: map[string]string{"image": "sha256:7"}}) + if err := p.w.released.put(rel); err != nil || p.w.ends.put(built) != nil { + t.Fatal(err) + } + _, _ = p.ends.take(ended(trunkBranch, 5, mpr.PipelineEndedOutcomePassed, mover("web", fp, "", 2, mpr.StepResultOutcomePassed))) + } else if passed { _, _ = p.ends.take(ended(trunkBranch, 5, mpr.PipelineEndedOutcomePassed, mover("web", fp, "", 2, mpr.StepResultOutcomePassed))) p.wants(context.Background()) if len(wantsKV.values) != 0 || !slices.Contains(journal, trunkBranch+".5: web passed with no version yet: taken again when its version is written") { @@ -185,14 +200,14 @@ func TestAPassWritesTheWantOfThePassedVersion(t *testing.T) { key, _ := mwc.WantKey(node, "web") raw, got := wantsKV.values[key] if got != passed { - t.Errorf("passed %v: a want on %s written = %v", passed, node, got) + t.Errorf("%s: a want on %s written = %v", c.name, node, got) continue } if !passed { continue } if w, err := mwc.DecodeWant(raw); err != nil || w.Fp != fp || w.Version != "0.1.2" || w.Pipeline != trunkBranch+".5" || w.Rank != 2 { - t.Errorf("the want on %s = %+v (%v)", node, w, err) + t.Errorf("%s: the want on %s = %+v (%v)", c.name, node, w, err) } } }