diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/halves.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/halves.go index 52382c4dc..e7ed8cc32 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/halves.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/halves.go @@ -37,6 +37,10 @@ type halves struct { // settled is told once when the first watched branch's first view is answered, for the first pass to wait on. settled chan<- struct{} told bool + + // regMu orders the registrations told to registered: the ones held when it is set, then each change (H-A-270 (3)). + regMu sync.Mutex + registered func(reg meshcatalog.Registration, gone bool) } // follow makes the branch follower on the reader; the reader's start asks the first views. @@ -50,6 +54,15 @@ func (h *halves) follow() error { h.changed(branch, module, entry, deleted) } b.Adopted = h.adopted + // The one handler of registration-changed is the follower's (H-A-270 (3)): the pipeline ends are told each change from it, + // never from a second handler on the hub. + reconcile := b.Registrations.Follower.Changed + b.Registrations.Follower.Changed = func(module string, value json.RawMessage, gone bool, at time.Time) { + if reconcile != nil { + reconcile(module, value, gone, at) + } + h.tellRegistration(module, value, gone) + } h.mu.Lock() h.branches = b h.mu.Unlock() @@ -215,3 +228,39 @@ func (h *halves) watchedOf(module string) []string { slices.SortStableFunc(out, func(x, y string) int { return strings.Compare(keys.EscapeName(x), keys.EscapeName(y)) }) return out } + +// tellRegistration tells registered of one registration the follower holds now, or of one removed. +func (h *halves) tellRegistration(module string, value json.RawMessage, gone bool) { + h.regMu.Lock() + defer h.regMu.Unlock() + if h.registered == nil { + return + } + reg := meshcatalog.Registration{Module: module} + if !gone { + if err := json.Unmarshal(value, ®); err != nil { + h.logf("the registration of %s does not read: %v", module, err) + return + } + } + h.registered(reg, gone) +} + +// followRegistrations tells registered of every registration the branch follower holds and then of each change it takes +// (design 47 G §353): the registrations are followed once, by the follower's one handler of registration-changed (H-A-270 +// (3)). It says false when no follower is made. +func (h *halves) followRegistrations(registered func(meshcatalog.Registration, bool)) bool { + h.mu.Lock() + b := h.branches + h.mu.Unlock() + if b == nil || b.Registrations == nil { + return false + } + h.regMu.Lock() + defer h.regMu.Unlock() + h.registered = registered + for _, reg := range b.Registrations.All() { + registered(reg, false) + } + return true +} diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/halvesnone_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/halvesnone_test.go index cac808d91..35d7fedf4 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/halvesnone_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/halvesnone_test.go @@ -53,6 +53,7 @@ func TestAMeshThatNamesNoBranchSettlesTheAssignersFirstPass(t *testing.T) { // Design 47 H-A-143, H-A-144, G §532: a module's watched branches are its registration's, in its order; once registrations are held a // module none names has none; before the first registrations the gate's source's branches stand in, in the source's order. +// H-A-270 (3): the pipeline ends are told the registrations by the same follower, whether set before its first view or after. func TestAModulesWatchedBranchesAreItsRegistrations(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() @@ -81,11 +82,23 @@ func TestAModulesWatchedBranchesAreItsRegistrations(t *testing.T) { if err := h.follow(); err != nil { t.Fatal(err) } + var live, held []string + if !h.followRegistrations(func(reg seat.Registration, gone bool) { live = append(live, reg.Module) }) { + t.Fatal("no follower of the registrations") + } for _, f := range reader.Followers()[:2] { // the registrations and the gate's source if err := f.Start(ctx); err != nil { t.Fatal(err) } } + h.followRegistrations(func(reg seat.Registration, gone bool) { held = append(held, reg.Module) }) + var regs []string + for _, r := range tc.regs { + regs = append(regs, r.Module) + } + if !slices.Equal(live, regs) || !slices.Equal(held, regs) { + t.Errorf("the ends were told %v at the first view and %v held, want %v", live, held, regs) + } if got := h.watchedOf(tc.module); !slices.Equal(got, tc.want) { t.Errorf("the watched branches of %s are %v, want %v", tc.module, got, tc.want) } 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 810880c60..1f67ede76 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 @@ -880,6 +880,14 @@ func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) { if _, err := b.buckets[engineReadsBucket()].Get(b.ctx, "shanks"); err == nil { t.Error("the state engine-reads holds a key of shanks, whose engine said nothing") } + // H-A-270 (3): registration-changed has one handler, the catalog half's follower, so the start's hub refuses no overlap. + b.journal.await(t, 0, "the kept seat events heard", "the hub started", time.Second) + b.journal.mu.Lock() + overlap := strings.Contains(b.journal.text.String(), "a message has one taker") + b.journal.mu.Unlock() + if overlap { + t.Error("the start's hub refused a handler that overlaps another: a message has one taker") + } } // subscribed returns once the server holds every subscription nc made: nats.go sends a SUB from its flusher, after 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 61f65a13f..7c6230ac3 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go @@ -649,12 +649,12 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, p.ends = newPipelineEnds(kvEnds{ctx, kv}, wake, logger.Printf) p.ends.trunk = w.trunkName p.ends.runEnded = func(group string) error { return p.dropCandidate(ctx, group) } - err := hearEnds(hub, p.ends) - if err == nil && bus != nil { - err = followRegistrations(ctx, hub, bus.Call, p.ends) + 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) } - if err != nil { - logger.Printf("a pipeline's end or a registration is not heard, so the wants keep the trunk-only form until the assigner starts again: %v", err) + // The registrations come from the catalog half's one follower, its one handler of registration-changed (H-A-270 (3)). + if iv == nil || iv.h == nil || !iv.h.followRegistrations(p.ends.registered) { + logger.Printf("the registrations are not followed, so the wants keep the trunk-only form until the assigner starts again: the catalog half is not followed") } } hearReleases(ctx, js, w, wake, findings, logger.Printf) // version-released, machine-away and machine-back 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 2d1604792..dce720685 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/pipelines.go @@ -14,7 +14,6 @@ import ( "github.com/nats-io/nats.go/jetstream" - mcc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient" mprc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshpipelinerunnerclient" mpcat "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" @@ -161,7 +160,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. It says whether any key changed. +// 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 says whether any key changed. func (e *pipelineEnds) take(p mpr.PipelineEnded) (bool, error) { if p.Outcome != mpr.PipelineEndedOutcomePassed || p.Run != "" { return false, nil @@ -174,7 +174,13 @@ func (e *pipelineEnds) take(p mpr.PipelineEnded) (bool, error) { } }() for _, m := range p.Movers { - if m.Version == "" || m.Fingerprint == "" || !moverPassed(m) { + if m.Fingerprint == "" || !moverPassed(m) { + continue + } + 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. + e.logf("%s: %s passed with no version yet: taken again when its version is written", p.Pipeline, m.Module) continue } key := endKey(m.Module, p.Branch) @@ -372,32 +378,3 @@ func (e *pipelineEnds) registered(reg mpcat.Registration, gone bool) { } e.wake() } - -// followRegistrations follows the registrations through the seat mesh-catalog (design 47 G §353): a first view of its verb -// and each registration-changed on the hub. It returns when the hub's handler is registered; the first view is asked on its own -// goroutine. -func followRegistrations(ctx context.Context, hub *process.EventHub, call mcc.Call, e *pipelineEnds) error { - regs := mcc.NewRegistrations(call) - regs.Follower.Logf = e.logf - regs.Follower.Changed = func(module string, value json.RawMessage, gone bool, _ time.Time) { - reg := mpcat.Registration{Module: module} - if !gone { - _ = json.Unmarshal(value, ®) - } - e.registered(reg, gone) - } - if err := hub.Handle(mpcat.SubjectRegistrationChanged, func(m jetstream.Msg) { - if err := regs.Hear(ctx, m.Data()); err != nil { - e.logf("%s: %v", m.Subject(), err) - } - _ = m.Ack() - }); err != nil { - return err - } - go func() { - if err := regs.Start(ctx); err != nil && ctx.Err() == nil { - e.logf("the first view of the registrations is not answered: %v", err) - } - }() - return nil -} 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 53de5242a..90c80e9bb 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 @@ -141,7 +141,8 @@ 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. +// 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. func TestAPassWritesTheWantOfThePassedVersion(t *testing.T) { fp := meshcatalogclient.SourcePrefix2 + strings.Repeat("a", 64) for _, passed := range []bool{false, true} { @@ -154,9 +155,15 @@ func TestAPassWritesTheWantOfThePassedVersion(t *testing.T) { p.w.manifests[mdigest] = parsed{module: "web", manifest: catalogue.Manifest{Module: "web", Requires: []string{"database"}}} placeOn(t, p.w, "g14", "web") placeOn(t, p.w, "ace", "web") - p.ends = newPipelineEnds(newMemEnds(), func() {}, t.Logf) + 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.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") { + t.Errorf("an end naming no version wrote %d wants and said %q", len(wantsKV.values), journal) + } _, _ = p.ends.take(ended(trunkBranch, 5, mpr.PipelineEndedOutcomePassed, mover("web", fp, "0.1.2", 2, mpr.StepResultOutcomePassed))) } p.wants(context.Background())