diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionstep_integration_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionstep_integration_test.go index 230d16f7..42615f58 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionstep_integration_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionstep_integration_test.go @@ -5,6 +5,7 @@ package main import ( "bytes" "encoding/json" + "fmt" "strings" "testing" "time" @@ -241,3 +242,133 @@ func readInput(t *testing.T, nc *nats.Conn, in buildstep.RunInput) []byte { } return out.Bytes() } + +// Design 47 H §745 (acceptance test 117, the assigner's half; H-A-108), started whole on the bus: the assigner serves the step +// validate on the seat mesh-wants. A take-in whose manifest names an unknown field fails it `manifest-refused` naming it, the +// validator being the revision's own entry of the module holding the seat mesh-catalog, run on the Go build seat over the +// revision's manifests and the previous revision's; a take-in that changes a manifest with no problem passes it; a take-in whose +// entries make a cycle fails it `cycle` naming the cycle, with no validator asked. +func TestTheValidateStepServedWholeRefusesAManifestProblemAndACycle(t *testing.T) { + b := startBed(t, "") + nc, err := nats.Connect(b.srv.ClientURL()) + if err != nil { + t.Fatal(err) + } + t.Cleanup(nc.Close) + const commit = "2222222222222222222222222222222222222222" + if _, err := b.js.CreateOrUpdateConsumer(b.ctx, "EVENTS", jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-assigner", + FilterSubjects: []string{enginereads.SubjectPrefix + "*", "mesh.mod." + buckets.IndexerModule + ".event.views.>", meshcatalog.SubjectCatalogRevisionAll, + nodebuildgo.SubjectStepEndedAll}, AckPolicy: jetstream.AckExplicitPolicy}); err != nil { + t.Fatal(err) + } + indexer := meshcatalog.CatalogEntry{Module: "indexer", Repository: "novox/mesh-delivery", Commit: commit, Path: "modules/mesh-delivery-indexer", + Fp: "src2:ix", Serves: []string{"seat:" + meshcatalog.Seat + ".revision"}, Manifest: map[string]any{"module": "indexer"}, ManifestDigest: "d-ix"} + entry := func(module, digest string, manifest map[string]any, edges ...meshcatalog.Edge) meshcatalog.CatalogEntry { + manifest["module"] = module + return meshcatalog.CatalogEntry{Module: module, Manifest: manifest, ManifestDigest: digest, Edges: edges} + } + b.cat.mu.Lock() + b.cat.rev[trunkBranch] = 9 + b.cat.at = map[string]map[int64][]meshcatalog.CatalogEntry{trunkBranch: { + 6: {indexer, entry("web", "d-web-1", map[string]any{"version": "1"})}, + 7: {indexer, entry("web", "d-web-2", map[string]any{"version": "2", "colour": "red"})}, + 8: {indexer, entry("web", "d-web-3", map[string]any{"version": "3"})}, + 9: {indexer, entry("a", "d-a", map[string]any{}, meshcatalog.Edge{From: "a:x", To: "b:y", Kind: 3}, meshcatalog.Edge{From: "b:y", To: "a:x", Kind: 3}), + entry("b", "d-b", map[string]any{})}, + }} + b.cat.mu.Unlock() + ended := make(chan meshwants.StepEnded, 4) + ends, err := nc.Subscribe("mesh.seat.mesh-wants.event.step-ended.n1", func(m *nats.Msg) { + var e meshwants.StepEnded + _ = json.Unmarshal(m.Data, &e) + ended <- e + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = ends.Unsubscribe() }) + subscribed(t, nc) + from := b.journal.mark() + b.start(t) + b.journal.await(t, from, "the composition step is heard on", "the steps served", 30*time.Second) + select { + case <-b.seatListRead: + case <-time.After(30 * time.Second): + t.Fatal("the assigner did not read the seat list within 30 s") + } + queue, _ := buildstep.AskStream(buildstep.AskGo) + worker, err := b.js.CreateOrUpdateConsumer(b.ctx, queue, jetstream.ConsumerConfig{Durable: "stand-in", FilterSubject: "mesh.seat.node-build-go.accept.check.mesh-wants", AckPolicy: jetstream.AckExplicitPolicy}) + if err != nil { + t.Fatal(err) + } + ask := func(revision int64, module string, run func()) meshwants.StepEnded { + t.Helper() + id := fmt.Sprintf("validate-%d", revision) + step, _ := json.Marshal(meshwants.StepRun{Pipeline: fmt.Sprintf("%s.%d", trunkBranch, revision), Step: meshwants.StepRunStepValidate, Module: module, + Branch: trunkBranch, Revision: revision, Commit: commit}) + msg := nats.NewMsg(meshwants.AcceptSubjectStep) + msg.Header.Set("x-event-id", id) + msg.Data = step + if err := nc.PublishMsg(msg); err != nil { + t.Fatal(err) + } + if run != nil { + run() + } + for { + select { + case e := <-ended: + if e.ID == id { + return e + } + case <-time.After(30 * time.Second): + t.Fatalf("the validate step of revision %d said no end", revision) + } + } + } + // The stand-in Go build seat runs the validator: it refuses a manifest naming the field colour, and accepts every other. + validator := func() { + t.Helper() + got, err := worker.Next(jetstream.FetchMaxWait(30 * time.Second)) + if err != nil { + t.Fatalf("no validator run is asked: %v", err) + } + _ = got.Ack() + a, err := buildstep.DecodeStepAsk(got.Data()) + if err != nil || a.Run == nil || a.Run.Program.Repository != "novox/mesh-delivery" || a.Run.Program.Commit != commit { + t.Fatalf("the validator's run ask %s: %v", got.Data(), err) + } + req, err := composer.Decode(readInput(t, nc, a.Run.Input)) + if err != nil || len(req.Cases) != 2 || req.Cases[0].Name != changeCase || req.Cases[1].Name != beforeCase { + t.Fatalf("the validator's request: %+v %v", req, err) + } + v := composer.Verdict{V: composer.Version} + for _, c := range req.Cases { + reads := map[string]composer.ManifestRead{} + for module, m := range c.Manifests { + reads[module] = composer.ManifestRead{Accepted: true} + if strings.Contains(string(m.Raw), "colour") { + reads[module] = composer.ManifestRead{Refused: `unknown field "colour"`} + } + } + v.Cases = append(v.Cases, composer.CaseVerdict{Name: c.Name, Manifests: reads}) + } + out, _ := json.Marshal(v) + end, _ := json.Marshal(buildstep.StepEnded{V: 1, ID: a.ID, Ask: a.ID, Asker: runAsker, Node: "b1", Outcome: buildstep.OutcomePassed, Output: string(out), At: time.Now().UTC()}) + if _, err := b.js.Publish(b.ctx, nodebuildgo.SubjectStepEnded("b1"), end); err != nil { + t.Fatal(err) + } + } + if e := ask(7, "web", validator); e.Outcome != meshwants.StepEndedOutcomeFailed || !strings.HasPrefix(e.Said, reasonManifestRefused+": ") || !strings.Contains(e.Said, `web: unknown field "colour"`) { + t.Errorf("the validate step of a manifest naming an unknown field ended %+v", e) + } + if e := ask(8, "web", validator); e.Outcome != meshwants.StepEndedOutcomePassed { + t.Errorf("the validate step of a manifest with no problem ended %+v", e) + } + if e := ask(9, "a", nil); e.Outcome != meshwants.StepEndedOutcomeFailed || e.Said != reasonCycle+": a:x → b:y → a:x" { + t.Errorf("the validate step of a take-in making a cycle ended %+v", e) + } + if info, err := worker.Info(b.ctx); err != nil || info.NumPending != 0 { + t.Errorf("a validator is asked for the cycle: %+v %v", info, err) + } +} 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 1aa2c41d..20ea0c21 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 @@ -24,6 +24,7 @@ import ( "time" "git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient" + mconds "git.novox.be/novox/mesh-contracts/health-and-repair/go/clients/meshconditionsclient" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-assigner/asks" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient" @@ -31,6 +32,8 @@ import ( "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient" 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-delivery/modules/mesh-delivery-sdk/buildstep" "git.novox.be/novox/mesh-delivery/modules/mesh-grants/grantsstate" @@ -44,7 +47,6 @@ import ( mma "git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner" occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient" oc "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel" - "git.novox.be/novox/mesh-contracts/provisioning/go/clients/meshprovisionerclient" mdseat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery" stdio "git.novox.be/novox/mesh-sdk/go" "git.novox.be/novox/mesh-sdk/go/announce" @@ -77,6 +79,8 @@ type bed struct { buckets map[string]jetstream.KeyValue // placed is, by node, the modules the bed's assignments names on it (place). placed map[string][]string + // builds is, by node and module, the build a placement names (placeBuild, design 47 H §750). + builds map[string]map[string]string // journal is what the programs the bed starts write in their journal. journal *journal // cat is the catalog half the seat mesh-catalog serves the assigner (serveCatalog). @@ -90,6 +94,9 @@ type catalogBed struct { entries map[string]map[string]meshcatalog.CatalogEntry rev map[string]int64 bodies map[string]string + // at is, by branch and revision, a revision's entries a test keeps whole: the verb revision answers a revision asked by its + // number from here, and the current one otherwise. + at map[string]map[int64][]meshcatalog.CatalogEntry } // journal is a program's journal as the bed hears it: a test awaits a line in it (await) where the line is the only sign @@ -211,6 +218,14 @@ func startBed(t *testing.T, leaveOut string) *bed { t.Fatal(err) } } + // The seat mesh-catalog's version-released, kept by age, which the assigner reads whole and follows: a placement's build is + // named by the version released at it (design 47 H §750, H-A-99). + if _, err := js.CreateStream(ctx, keptStream(meshcatalog.StreamVersionReleased, meshcatalog.SubjectVersionReleased, jetstream.StreamConfig{MaxAge: 90 * 24 * time.Hour})); err != nil { + t.Fatal(err) + } + if _, err := js.CreateOrUpdateConsumer(ctx, meshcatalog.StreamVersionReleased, jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-assigner", AckPolicy: jetstream.AckExplicitPolicy}); err != nil { + t.Fatal(err) + } // The builder's stream of build ends, kept last per subject (its manifest's `last-per-subject`, design 47 G A-181), which the assigner // reads whole at its start and follows through its durable, as the grants part makes it (from the last of each subject). if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: buildsStreamName, Subjects: []string{process.ModuleStreamSubject(builds.BuilderModule, builds.BuildEndedEvent+".>")}, MaxAge: 168 * time.Hour}); err != nil { // kept by age, as the bus keeps it live (2026-11-15): read whole from its first message all the same (A-233) @@ -229,7 +244,7 @@ func startBed(t *testing.T, leaveOut string) *bed { // machineEvent; the grants part's own test holds the derivation). if _, err := js.CreateOrUpdateConsumer(ctx, "EVENTS", jetstream.ConsumerConfig{Durable: "n1_mesh-delivery-assigner", FilterSubjects: []string{enginereads.SubjectPrefix + "*", "mesh.mod." + buckets.IndexerModule + ".event.views.>", - "mesh.mod." + buckets.TellerModule + ".event.views.>", meshcatalog.SubjectCatalogRevisionAll}, AckPolicy: jetstream.AckExplicitPolicy}); err != nil { + "mesh.mod." + buckets.TellerModule + ".event.views.>", meshcatalog.SubjectCatalogRevisionAll, pipelineEndedSubject}, AckPolicy: jetstream.AckExplicitPolicy}); err != nil { t.Fatal(err) } // The operator-channel seat's stream of conditions, which the assigner says its conditions on. @@ -506,7 +521,7 @@ func (b *bed) place(t *testing.T, node, module string) { } pl := mma.Assignments{Node: node} for _, m := range b.placed[node] { - pl.Modules = append(pl.Modules, mma.PlacedModule{Module: m}) + pl.Modules = append(pl.Modules, mma.PlacedModule{Module: m, Build: b.builds[node][m]}) } values, err := mmac.AssignmentsValues(pl) if err != nil { @@ -560,61 +575,131 @@ func (b *bed) get(t *testing.T, bucket, key string) []byte { return nil } -// 1297/B4 on the bus, 1906/D5: the controller sends ace, g14 and shanks builds while the canary ace does not run F healthy yet. -// Started whole, the assigner wants F on the canary and writes no difference at all: there is no send to compare with (ADR 0539 -// §8). 1945/AC19, AC21: shanks, which runs the older fingerprint (composed and granted) with no want, gets its first want at that -// fingerprint, never at F; g14, which runs a build of the old form, gets none, so web is on neither list there and the assigner -// raises the condition naming g14, web and the canary rule; once ace runs F healthy, g14's first want names F and the condition is -// cleared. +// moverAt is one mover of a pipeline the bed's runner says ended: its module, the fingerprint and version it released, its tier. +type moverAt struct { + module, fp, version string + tier int64 +} + +// ended says the runner's pipeline-ended of the trunk's pipeline at source, with outcome, each mover's required steps passed when +// the pipeline passed and its validate step failed when it did not (design 47 H §746, §750). +func (b *bed) ended(t *testing.T, source int64, outcome string, movers ...moverAt) string { + t.Helper() + pipeline := fmt.Sprintf("%s.%d", trunkBranch, source) + step := mpr.StepResult{Step: mpr.StepResultStepValidate, Status: mpr.StepResultStatusRequired, Outcome: mpr.StepResultOutcomePassed} + if outcome != mpr.PipelineEndedOutcomePassed { + step.Outcome = mpr.StepResultOutcomeFailed + } + e := mpr.PipelineEnded{V: 1, Pipeline: pipeline, Branch: trunkBranch, Source: source, Outcome: outcome} + for _, m := range movers { + e.Movers = append(e.Movers, mpr.MoverEnded{Module: m.module, Fingerprint: m.fp, Version: m.version, Tier: m.tier, Steps: []mpr.StepResult{step}}) + } + raw, _ := json.Marshal(e) + if _, err := b.js.Publish(b.ctx, mpr.SubjectPipelineEnded(trunkBranch, fmt.Sprint(source)), raw); err != nil { + t.Fatal(err) + } + return pipeline +} + +// readsVersion says node's node-engine reads a want by version (the node-engine seat's manifest-reads-changed, design 47 H §772). +func (b *bed) readsVersion(t *testing.T, node string) { + t.Helper() + body, _ := json.Marshal(nodeengine.ManifestReadsChangedEvent{V: 1, Node: node, ManifestReads: []string{nodeengine.ManifestReadWordWantVersion}, + At: time.Now().UTC().Format(time.RFC3339Nano), Why: enginereads.ReadsStarted}) + if _, err := b.js.Publish(b.ctx, enginereads.SubjectPrefix+node, body); err != nil { + t.Fatal(err) + } +} + +// runs says node runs module at fp, healthy, as its node-engine writes its have and says `running`. +func (b *bed) runs(t *testing.T, node, module, fp string) { + t.Helper() + have, _ := nodeengineclient.EncodeHave(nodeengine.HaveByNodeModuleValue{Fp: fp, Phase: nodeengineclient.PhaseRunning, Health: nodeengineclient.HealthOK}) + b.putJSON(t, buckets.Have, node+"."+module, have) +} + +// placeBuild names build in the placement of module on node (design 47 H §750, H-A-99). +func (b *bed) placeBuild(t *testing.T, node, module, build string) { + t.Helper() + if b.builds == nil { + b.builds = map[string]map[string]string{} + } + if b.builds[node] == nil { + b.builds[node] = map[string]string{} + } + b.builds[node][module] = build + b.place(t, node, module) +} + +// versionsOf are the versions the want of module on node named, in the order written, each once. +func (b *bed) versionsOf(t *testing.T, node, module string) []string { + t.Helper() + key, _ := mwc.WantKey(node, module) + history, err := b.buckets[buckets.Wants()].History(b.ctx, key) + if err != nil { + t.Fatalf("the want of %s on %s has no history: %v", module, node, err) + } + var out []string + for _, e := range history { + if w, err := mwc.DecodeWant(e.Value()); err == nil && (len(out) == 0 || out[len(out)-1] != w.Version) { + out = append(out, w.Version) + } + } + return out +} + +// Design 47 H §750, §751, §772 (acceptance test 113, the assigner's half), started whole on the bus: a want is the newest +// released version whose pipeline passed, written tier by tier. A provider (db) and its consumer (app) passed in one pipeline: +// db is wanted on ace and g14 naming its version, the pipeline and rank 1, whatever build the acting part (the node-engine +// module, whose pipeline never passed) runs, with no grant, no canary and no healthy provider; app's want waits until db runs +// on both, then names rank 2, and the pipeline says pipeline-wanted running. A failed pipeline's version is not wanted, and an +// older end heard after a newer one writes nothing. g14's placement naming db's first build reverts its want to the version +// released at it. A pipeline whose first tier never runs raises tier-late within tier-bound and writes no later tier. shanks, +// whose node-engine does not say it reads a want by version, has its want held, awaiting its hand placement. DLV-F5r (ADR 0621 +// §3, ADR 0631 §2): the assigner's first views wait on the indexer, whose late answer clears the condition naming it. func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) { - // DLV-F5r (ADR 0621 §3): the indexer's runtime starts together with the assigner and answers its first views only - // after the assigner asked; within the bound the assigner writes the wants from what they answer. up := make(chan struct{}) catalogLate = up - // ADR 0631 §2: while the indexer does not answer, past the first-view bound the assigner raises the condition naming - // the indexer and graph, and reads nothing of the indexer's state; the answer clears it. firstViewBound, firstViewWait = 300*time.Millisecond, 50*time.Millisecond - t.Cleanup(func() { catalogLate, firstViewBound, firstViewWait = nil, 0, 0 }) + tierBoundUnit = time.Second + t.Cleanup(func() { catalogLate, firstViewBound, firstViewWait, tierBoundUnit = nil, 0, 0, time.Minute }) for _, name := range append(append([]string{}, readBuckets...), watched()...) { if strings.HasPrefix(name, buckets.IndexerModule+"_") { t.Errorf("the assigner reads the indexer's state %s itself", name) } } b := startBed(t, "") - fNew, fOld := meshcatalogclient.SourcePrefix2+strings.Repeat("b", 64), meshcatalogclient.SourcePrefix2+strings.Repeat("a", 64) - digest := b.manifest(t, "web", `{"module":"web","version":"1"}`) - mod, _ := meshcatalogclient.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: fNew, Manifest: digest, Repository: "novox/web", Commit: strings.Repeat("1", 40), Path: meshcatalogclient.RootPath}) - b.putModule(t, "web", mod) - built, err := builds.EncodeBuilderBuild(builds.BuilderBuild{State: builds.BuildDone, By: "builder.novox.1", Step: "pushed", Manifest: digest}) - if err != nil { - t.Fatal(err) + t.Cleanup(func() { + if t.Failed() { + b.journal.mu.Lock() + t.Log(b.journal.text.String()) + b.journal.mu.Unlock() + } + }) + b.settings = map[string]string{"MESH_ASSIGNER_TIER_BOUND_FILE": "3"} // tier-bound 3 s at the test's unit + fpOf := func(c byte) string { return meshcatalogclient.SourcePrefix2 + strings.Repeat(string(c), 64) } + // The trunk's catalog half names every module at its newest fingerprint; none is built, granted or provided as the old rules + // asked. The acting part engine runs an older build on ace, and no pipeline of its newer one passed. + for module, fp := range map[string]string{"web": fpOf('b'), "db": fpOf('2'), "app": fpOf('3'), "cache": fpOf('5'), "api": fpOf('6'), "engine": fpOf('e')} { + digest := b.manifest(t, module, fmt.Sprintf(`{"module":%q,"version":"1"}`, module)) + mod, _ := meshcatalogclient.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: fp, Manifest: digest, Repository: "novox/" + module, Commit: strings.Repeat("1", 40), Path: meshcatalogclient.RootPath}) + b.putModule(t, module, mod) } - bkey, _ := builds.BuilderBuildKey("web", fNew) - b.putBuild(t, bkey, built) - for _, fp := range []string{fNew, fOld} { - gkey, _ := grantsstate.PartGrantKey("web", fp) - grant, _ := grantsstate.EncodeGrant(grantsstate.Grant{}) - b.putJSON(t, buckets.Grants, gkey, grant) - } - runs := map[string]string{"ace": fOld, "g14": "build-9", "shanks": fOld} for _, node := range []string{"ace", "g14", "shanks"} { b.compose(t, node, 'c') - have, _ := nodeengineclient.EncodeHave(nodeengine.HaveByNodeModuleValue{Fp: runs[node], Phase: nodeengineclient.PhaseRunning, Health: nodeengineclient.HealthOK}) - b.putJSON(t, buckets.Have, node+".web", have) b.place(t, node, "web") } - b.compose(t, "shanks", 'a') + for _, node := range []string{"ace", "g14"} { + b.place(t, node, "db") + b.place(t, node, "app") + b.readsVersion(t, node) + } + b.place(t, "ace", "engine") + b.runs(t, "ace", "engine", fpOf('d')) + b.place(t, "ace", "cache") + b.place(t, "ace", "api") b.start(t) - // DLV-F5r (ADR 0621 §1-§3, design 25 § 12 on a fresh mesh): the assigner asks nothing of the bus module (its manifest - // has no bus-state entry, the bed runs no bus module and holds no binding of one), and while it still waits on the - // indexer its runtime of its own answers each first-view tool to the readers its manifest's callers lists name, at - // its mark, and refuses every other account, the assigner's own included. - firstViewsBeforeAnyNewFormState(t, b, map[string][]string{ - "assignments": {"n1.mesh-grants", "n1.node-tools", "n1.mesh-delivery-indexer", "n1.mesh-delivery-builder", "n1.mesh-delivery-checker"}, - "seat-holders": {"n1.node-tools", "n1.mesh-delivery-builder", "n1.mesh-delivery-view", "n1.mesh-delivery-teller", "n1.mesh-delivery-checker", "n1.mesh-delivery-indexer"}, // A-298, A-302: the parts following it - "wants": {"n1.mesh-grants"}, - }) - // The reader raises the finding of the first view through the module's finding writer (A-26), its id escaped as a key's name. + firstViewsBeforeAnyNewFormState(t, b, []string{"assignments", "seat-holders", "wants"}) graphKey := views.FindingKey(views.FindingScope, keys.EscapeName(assignment.Module()+"."+meshcatalog.Seat+"."+views.BranchState(meshcatalog.StateCatalogRevisions, trunkBranch)), views.UnansweredKind) graphRaised := func() bool { e, err := b.buckets[assign.FindingsBucket()].Get(b.ctx, graphKey) @@ -631,66 +716,128 @@ func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) { t.Fatalf("the seat answered, and the condition naming its revision verb stands (finding %s)", graphKey) } } - - wkey, _ := mwc.WantKey("ace", "web") - want, err := mwc.DecodeWant(b.get(t, buckets.Wants(), wkey)) - if err != nil || want.Fp != fNew { - t.Fatalf("the canary ace's want = %+v, %v", want, err) + nc, err := nats.Connect(b.srv.ClientURL()) + if err != nil { + t.Fatal(err) } - if w := b.wantNow(t, "shanks", "web", "shanks' first want at what it runs", func(w mwc.Want) bool { return w.Fp != "" }); w.Fp != fOld || !w.Self { - t.Errorf("shanks' want = %+v, want the fingerprint it runs, the node composing it, held back from F", w) + t.Cleanup(nc.Close) + wanted := make(chan meshwants.PipelineWanted, 8) + sub, err := nc.Subscribe("mesh.seat."+meshwants.Seat+".event."+meshwants.EventPipelineWanted+".>", func(m *nats.Msg) { + var e meshwants.PipelineWanted + _ = json.Unmarshal(m.Data, &e) + wanted <- e + }) + if err != nil { + t.Fatal(err) } - // DLV-O5 (ADR 0615 §5, ADR 0619 §2): each want is said on the assigner's views family, its value whole at its revision, - // and the first view at the mark followed by those events holds it as the bucket does; a waiter on put never wakes. - b.viewsHold(t, "wants", wkey) - var neither oc.Condition - for deadline := time.Now().Add(10 * time.Second); time.Now().Before(deadline) && neither.Key == ""; time.Sleep(100 * time.Millisecond) { - for k, c := range b.conditionsSaid(t) { - if strings.HasSuffix(k, ".neither") && c.State == occ.StateRaised { - neither = c + t.Cleanup(func() { _ = sub.Unsubscribe() }) + subscribed(t, nc) + pipelineWanted := func(pipeline, outcome string) meshwants.PipelineWanted { + t.Helper() + for { + select { + case e := <-wanted: + if e.Pipeline == pipeline { + if e.Outcome != outcome { + t.Fatalf("pipeline-wanted of %s said %+v, want %s", pipeline, e, outcome) + } + return e + } + case <-time.After(15 * time.Second): + t.Fatalf("no pipeline-wanted of %s", pipeline) } } } - if neither.Subject.Machine != "g14" || !strings.HasPrefix(neither.Subject.ID, "g14.web") || neither.Severity != occ.SeverityUrgent || !strings.Contains(neither.Explanation, "canary") { - t.Errorf("the condition of web on neither list on g14 = %+v", neither) + + // §772: web passed; ace and g14 are wanted at its version, shanks' want is held awaiting its hand placement. + web := b.ended(t, 4, mpr.PipelineEndedOutcomePassed, moverAt{"web", fpOf('b'), "1.0.0", 1}) + if w := b.wantNow(t, "ace", "web", "web's want at its passed version", func(w mwc.Want) bool { return w.Version == "1.0.0" }); w.Fp != fpOf('b') || w.Pipeline != web || w.Rank != 1 || w.Hold { + t.Errorf("ace's want of web = %+v", w) } + if w := b.wantNow(t, "shanks", "web", "shanks' want held", func(w mwc.Want) bool { return w.Hold }); w.Words != mwc.HoldAwaitsHandPlacement || w.Version != "1.0.0" { + t.Errorf("shanks' want of web = %+v, want held awaiting its hand placement", w) + } + + // §750, §751: tier 1 (db) is wanted at once on every placing machine, tier 2 (app) only once db runs on both. + first := b.ended(t, 5, mpr.PipelineEndedOutcomePassed, moverAt{"db", fpOf('2'), "1.0.0", 1}, moverAt{"app", fpOf('3'), "1.0.0", 2}) + for _, node := range []string{"ace", "g14"} { + if w := b.wantNow(t, node, "db", "db's want at 1.0.0", func(w mwc.Want) bool { return w.Version == "1.0.0" }); w.Fp != fpOf('2') || w.Pipeline != first || w.Rank != 1 { + t.Errorf("%s's want of db = %+v", node, w) + } + } + if b.hasKey(buckets.Wants(), "want.ace.app") || b.hasKey(buckets.Wants(), "want.g14.app") { + t.Error("app, the consumer in tier 2, is wanted before its provider runs") + } + if b.hasKey(buckets.Wants(), "want.ace.engine") { + t.Error("the acting part is wanted with no pipeline of it passed") + } + b.runs(t, "ace", "db", fpOf('2')) + b.runs(t, "g14", "db", fpOf('2')) + for _, node := range []string{"ace", "g14"} { + if w := b.wantNow(t, node, "app", "app's want once db runs", func(w mwc.Want) bool { return w.Version == "1.0.0" }); w.Fp != fpOf('3') || w.Rank != 2 { + t.Errorf("%s's want of app = %+v", node, w) + } + b.runs(t, node, "app", fpOf('3')) + } + pipelineWanted(first, meshwants.PipelineWantedOutcomeRunning) + + // §750: a failed pipeline's version is not wanted; a newer passed one is, and an older end heard after it writes nothing. + b.ended(t, 6, mpr.PipelineEndedOutcomeFailed, moverAt{"db", fpOf('7'), "1.1.0", 1}) + b.ended(t, 8, mpr.PipelineEndedOutcomePassed, moverAt{"db", fpOf('9'), "1.2.0", 1}) + b.wantNow(t, "ace", "db", "db's want at 1.2.0", func(w mwc.Want) bool { return w.Version == "1.2.0" }) + b.ended(t, 7, mpr.PipelineEndedOutcomePassed, moverAt{"db", fpOf('8'), "1.1.5", 1}) + // §751: cache never runs, so its tier is late within tier-bound and api, tier 2, is never wanted; the late end is also the + // barrier after which the older end of db was heard. + late := b.ended(t, 10, mpr.PipelineEndedOutcomePassed, moverAt{"cache", fpOf('5'), "1.0.0", 1}, moverAt{"api", fpOf('6'), "1.0.0", 2}) + b.wantNow(t, "ace", "cache", "cache's want", func(w mwc.Want) bool { return w.Version == "1.0.0" }) + if e := pipelineWanted(late, meshwants.PipelineWantedOutcomeTierLate); len(e.NotRunning) != 1 || e.NotRunning[0].Module != "cache" || !slices.Equal(e.NotRunning[0].Machines, []string{"ace"}) { + t.Errorf("pipeline-wanted tier-late = %+v, want cache on ace not running", e) + } + lateKey := views.FindingKey(mconds.ScopeDelivery, assign.KeyID(late), kindTierLate) + if raw := b.get(t, assign.FindingsBucket(), lateKey); !strings.Contains(string(raw), "cache on ace") { + t.Errorf("the finding tier-late = %s", raw) + } + if b.hasKey(buckets.Wants(), "want.ace.api") { + t.Error("api, tier 2 of a late pipeline, is wanted") + } + for _, node := range []string{"ace", "g14"} { + if got := b.versionsOf(t, node, "db"); !slices.Equal(got, []string{"1.0.0", "1.2.0"}) { + t.Errorf("%s's want of db named %v, want 1.0.0 then 1.2.0: no failed and no older version", node, got) + } + } + + // §750, H-A-99: g14's placement names db's first build, which the builder made and the catalog released as 1.0.0: its want + // names that build and version, with no pipeline and no rank, while ace stays at 1.2.0. + made, _ := json.Marshal(builds.BuildEnded{Module: "db", Fingerprint: fpOf('2'), Outcome: builds.BuildDone, Made: map[string]string{"image": "sha256:d1"}}) + if _, err := b.js.Publish(b.ctx, process.ModuleStreamSubject(builds.BuilderModule, builds.BuildEndedEventName("db", fpOf('2'))), made); err != nil { + t.Fatal(err) + } + rel, _ := json.Marshal(meshcatalog.VersionReleasedEvent{Module: "db", Source: 5, Version: "1.0.0", Artifacts: []meshcatalog.VersionArtifact{{Artifact: "db:image", Digest: "sha256:d1"}}}) + if _, err := b.js.Publish(b.ctx, meshcatalog.SubjectVersionReleased, rel); err != nil { + t.Fatal(err) + } + b.placeBuild(t, "g14", "db", fpOf('2')) + if w := b.wantNow(t, "g14", "db", "g14's want back at db's first build", func(w mwc.Want) bool { return w.Fp == fpOf('2') }); w.Version != "1.0.0" || w.Pipeline != "" || w.Rank != 0 { + t.Errorf("g14's want of db at its placement's build = %+v", w) + } + if w := b.wantNow(t, "ace", "db", "ace's want of db", func(mwc.Want) bool { return true }); w.Version != "1.2.0" { + t.Errorf("ace's want of db = %+v, want 1.2.0", w) + } + + wkey, _ := mwc.WantKey("ace", "web") + // DLV-O5 (ADR 0615 §5, ADR 0619 §2): each want is said on the assigner's views family, its value whole at its revision. + b.viewsHold(t, "wants", wkey) if keys, err := b.buckets[buckets.Differences()].Keys(b.ctx); err == nil && len(keys) != 0 { t.Errorf("differences were written: %v", keys) } - if e, err := b.buckets[buckets.Wants()].Get(b.ctx, "want.g14.web"); err == nil { - t.Errorf("g14, which runs an old-form build and is held back by the canary, was given a want: %s", e.Value()) - } - // 1945/AC21: once the canary ace runs F healthy, g14's first want names F by the rules as usual, and web leaves neither list - // there by itself: the condition is cleared. - healthyF, _ := nodeengineclient.EncodeHave(nodeengine.HaveByNodeModuleValue{Fp: fNew, Phase: nodeengineclient.PhaseRunning, Health: nodeengineclient.HealthOK}) - b.putJSON(t, buckets.Have, "ace.web", healthyF) - if w := b.wantNow(t, "g14", "web", "g14's first want at F once the canary runs it healthy", func(w mwc.Want) bool { return w.Fp != "" }); w.Fp != fNew || !w.Self { - t.Errorf("g14's want = %+v, want F, the node composing it", w) + // Issue 1126 (ADR 0547 §2): placed through the catalogue's assignments, ace composes its own: its own want says so. + values, err := mmac.AssignmentsValues(mma.Assignments{Node: "ace", Modules: []mma.PlacedModule{{Module: "web"}}}) + if err != nil { + t.Fatal(err) } - cleared := false - for deadline := time.Now().Add(10 * time.Second); time.Now().Before(deadline) && !cleared; time.Sleep(100 * time.Millisecond) { - c, ok := b.conditionsSaid(t)[neither.Key] - cleared = ok && c.State == occ.StateCleared - } - if !cleared { - t.Errorf("the condition of web on neither list on g14 was not cleared once g14 got its want") - } - - // Issue 1126 (ADR 0547 §2): the catalogue's assignments reaches the indexer's state naming web on every node the - // assignments name it on. Each node then composes its own: its want names the build alone (Self, no composition), and - // its own want says it composes its own, which the node agent reads (mesh-host's TestNats...ComposesAndAppliesItsOwn). - for _, node := range []string{"ace", "g14", "shanks"} { - values, err := mmac.AssignmentsValues(mma.Assignments{Node: node, Modules: []mma.PlacedModule{{Module: "web"}}}) - if err != nil { - t.Fatal(err) - } - for _, k := range slices.Sorted(maps.Keys(values)) { - b.putJSON(t, plc.AssignmentsBucket(), k, values[k]) - } - } - if w := b.wantNow(t, "ace", "web", "ace's want once placed: the build alone, composed by the node", func(w mwc.Want) bool { return w.Self }); w.Fp != fNew { - t.Errorf("ace's want once placed = %+v", w) + for _, k := range slices.Sorted(maps.Keys(values)) { + b.putJSON(t, plc.AssignmentsBucket(), k, values[k]) } nkey, _ := mwc.WantNodeKey("ace") var self bool @@ -704,63 +851,8 @@ func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) { t.Error("ace's own want does not say it composes its own once placed") } - // ADR 0603 (L3, D15): one source revision changes a provider (db), its new consumer (app) and a build module (tool, whose - // recipe moved: ace runs its first build and the second, under the agreed toolchain, is the one the source revision names). - // The keys are written as their writers write them: the indexer's modules and manifests, the builder's builds, the - // controller's grants, the assignments seat's assignments and the provisioner's provisions. The build module's want moves at - // once and the provider's with it; the consumer's waits for its provision, with the words naming it, and moves once the - // provisioner provides it (rule 8, ADR 0570 §4): nothing waits for a turn or an order, only for a key. - offer := `"provides":[{"name":"database","scope":"mesh","answered-by":"helper"}]` - dbDigest := b.manifest(t, "db", `{"module":"db","version":"1",`+offer+`}`) - appDigest := b.manifest(t, "app", `{"module":"app","version":"1","requires":["database"]}`) - toolDigest := b.manifest(t, "tool", `{"module":"tool","version":"1"}`) - asked := func(state, why string) { - raw, err := meshprovisionerclient.Encode(meshprovisionerclient.Provision{V: meshprovisionerclient.Version, Provision: "database", Consumer: meshprovisionerclient.End{Module: "app", Node: "ace"}, - Provider: meshprovisionerclient.End{Module: "db", Node: "ace"}, State: state, Why: why, At: time.Now()}) - if err != nil { - t.Fatal(err) - } - b.putJSON(t, "mesh-provisioner_provisions", "ace.app.database", raw) - } - // The provisioner keys it from the manifests, as soon as they are known and whether the provider is placed yet or not. - asked(meshprovisionerclient.Asked, "the provider's build is not done") - fpOf := func(c byte) string { return meshcatalogclient.SourcePrefix2 + strings.Repeat(string(c), 64) } - toolOld := fpOf('1') - for module, row := range map[string]struct { - fp, digest string - }{"db": {fpOf('2'), dbDigest}, "app": {fpOf('3'), appDigest}, "tool": {fpOf('4'), toolDigest}} { - mod, _ := meshcatalogclient.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: row.fp, Manifest: row.digest, Repository: "novox/" + module, Commit: strings.Repeat("2", 40), Path: meshcatalogclient.RootPath}) - b.putModule(t, module, mod) - fps := []string{row.fp} - if module == "tool" { - fps = append(fps, toolOld) - } - for _, fp := range fps { - built, _ := builds.EncodeBuilderBuild(builds.BuilderBuild{State: builds.BuildDone, By: "builder.novox.1", Step: "pushed", Manifest: row.digest}) - bkey, _ := builds.BuilderBuildKey(module, fp) - b.putBuild(t, bkey, built) - gkey, _ := grantsstate.PartGrantKey(module, fp) - grant, _ := grantsstate.EncodeGrant(grantsstate.Grant{}) - b.putJSON(t, buckets.Grants, gkey, grant) - } - b.place(t, "ace", module) - } - runsOld, _ := nodeengineclient.EncodeHave(nodeengine.HaveByNodeModuleValue{Fp: toolOld, Phase: nodeengineclient.PhaseRunning, Health: nodeengineclient.HealthOK}) - b.putJSON(t, buckets.Have, "ace.tool", runsOld) - if w := b.wantNow(t, "ace", "tool", "the build module's want at the second build", func(w mwc.Want) bool { return w.Fp == fpOf('4') }); w.Fp != fpOf('4') { - t.Errorf("tool's want = %+v", w) - } - b.wantNow(t, "ace", "db", "the provider's want at its fingerprint", func(w mwc.Want) bool { return w.Fp == fpOf('2') }) - if e, err := b.buckets[buckets.Wants()].Get(b.ctx, "want.ace.app"); err == nil { - t.Errorf("app was wanted while its provision was asked: %s", e.Value()) - } - asked(meshprovisionerclient.Provided, "") - if w := b.wantNow(t, "ace", "app", "the consumer's want once its provision is provided", func(w mwc.Want) bool { return w.Fp == fpOf('3') }); w.Fp != fpOf('3') { - t.Errorf("app's want = %+v", w) - } - - // Design 47 H-A-104: ace's engine says manifest-reads-changed; the assigner writes its words and when it said them into - // its state engine-reads, asking no verb; g14's engine said nothing, so the state holds no key of it. + // Design 47 H-A-104: ace's engine says manifest-reads-changed again; the assigner writes its words and when it said them into + // its state engine-reads, asking no verb; shanks' engine said nothing, so the state holds no key of it. watch, err := b.buckets[engineReadsBucket()].Watch(b.ctx, "ace", jetstream.UpdatesOnly()) if err != nil { t.Fatal(err) @@ -780,8 +872,8 @@ func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) { case <-time.After(15 * time.Second): t.Fatal("the assigner did not write ace's words into its state engine-reads") } - if _, err := b.buckets[engineReadsBucket()].Get(b.ctx, "g14"); err == nil { - t.Error("the state engine-reads holds a key of g14, whose engine said nothing") + 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") } } @@ -827,11 +919,14 @@ func (b *bed) conditionsSaid(t *testing.T) map[string]oc.Condition { // 1906/D8 (scenario D of acceptance test 18, ADR 0539 §19), whole on the bus: the assigner is stopped while it writes the wants // of forty modules and another is started; every module's want is written, and each exactly once, by revision: nothing lost -// and nothing written again. +// and nothing written again. The wants follow one passed pipeline of the forty, all in tier 1 (design 47 H §750, §751). func TestTheAssignerReplacedResumesWithNothingLostOrRepeated(t *testing.T) { b := startBed(t, "") const modules = 40 names := make([]string, modules) + var movers []moverAt + b.compose(t, "ace", 'c') + b.readsVersion(t, "ace") for i := range names { name := fmt.Sprintf("mod%02d", i) names[i] = name @@ -839,18 +934,10 @@ func TestTheAssignerReplacedResumesWithNothingLostOrRepeated(t *testing.T) { digest := b.manifest(t, name, fmt.Sprintf(`{"module":%q,"version":"1"}`, name)) mod, _ := meshcatalogclient.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: fp, Manifest: digest, Repository: "novox/" + name, Commit: strings.Repeat("1", 40), Path: meshcatalogclient.RootPath}) b.putModule(t, name, mod) - built, err := builds.EncodeBuilderBuild(builds.BuilderBuild{State: builds.BuildDone, By: "builder.novox.1", Step: "pushed", Manifest: digest}) - if err != nil { - t.Fatal(err) - } - bkey, _ := builds.BuilderBuildKey(name, fp) - b.putBuild(t, bkey, built) - gkey, _ := grantsstate.PartGrantKey(name, fp) - grant, _ := grantsstate.EncodeGrant(grantsstate.Grant{}) - b.putJSON(t, buckets.Grants, gkey, grant) - b.compose(t, "ace", 'c') b.place(t, "ace", name) + movers = append(movers, moverAt{name, fp, "1.0.0", 1}) } + b.ended(t, 3, mpr.PipelineEndedOutcomePassed, movers...) count := func() int { keys, err := b.buckets[buckets.Wants()].Keys(b.ctx) if err != nil { @@ -971,6 +1058,9 @@ func TestABackupAnswerIsWrittenIntoTheNodesWant(t *testing.T) { b.fixture(t, "web", fNew, `{"module":"web","version":"1"}`) fRun := meshcatalogclient.SourcePrefix2 + strings.Repeat("a", 64) // a held have names the build it keeps running b.compose(t, "ace", 'b') + b.readsVersion(t, "ace") + // The want follows the passed version (design 47 H §750). + b.ended(t, 3, mpr.PipelineEndedOutcomePassed, moverAt{"web", fNew, "1.0.0", 1}) b.putWant(t, "ace", "web", mwc.Want{Fp: fNew, Self: true}) // a placed node's want names the build alone held, _ := nodeengineclient.EncodeHave(nodeengine.HaveByNodeModuleValue{Fp: fRun, Phase: nodeengineclient.PhaseHeld, Health: nodeengineclient.HealthWaits, Detail: "no space left"}) b.putJSON(t, buckets.Have, "ace.web", held) @@ -1015,10 +1105,11 @@ func TestABackupAnswerIsWrittenIntoTheNodesWant(t *testing.T) { if w2.Words == w1.Words { t.Errorf("the second answer left the want as it was: %+v", w2) } - // Issue 1966 note 165 (AC165-1): the move is superseded, the trunk and then the want naming another build; the pass takes + // Issue 1966 note 165 (AC165-1): the move is superseded, a newer passed version and then the want naming another build; the pass takes // the backup ask away and clears the condition of the failed backup. fOther := meshcatalogclient.SourcePrefix2 + strings.Repeat("c", 64) - b.fixture(t, "web", fOther, `{"module":"web","version":"2"}`) // the trunk moves on: the want follows + b.fixture(t, "web", fOther, `{"module":"web","version":"2"}`) + b.ended(t, 4, mpr.PipelineEndedOutcomePassed, moverAt{"web", fOther, "2.0.0", 1}) // a newer version passed: the want follows for deadline := time.Now().Add(15 * time.Second); ; time.Sleep(50 * time.Millisecond) { cleared := false for k, c := range b.conditionsSaid(t) { @@ -1488,8 +1579,9 @@ func serveOwner(t *testing.T, b *bed, nc *nats.Conn, owner string, tools map[str // firstViewsBeforeAnyNewFormState serves the assigner's first-view tools as its runtime of its own does (the tools bundle's // viewTools over the bed's buckets, the env its manifest's bundle writes, the caller the runtime proves from the subject's -// last token), before any new-form state exists, and asks each from every reader granted and from the others. -func firstViewsBeforeAnyNewFormState(t *testing.T, b *bed, granted map[string][]string) { +// last token), before any new-form state exists, and asks each from every reader: every account is answered (design 47 H §752, +// H-A-41: no seat or tool names its callers). +func firstViewsBeforeAnyNewFormState(t *testing.T, b *bed, tools []string) { t.Helper() raw, err := os.ReadFile(filepath.Join("..", "..", "module.json")) if err != nil { @@ -1593,19 +1685,16 @@ func firstViewsBeforeAnyNewFormState(t *testing.T, b *bed, granted map[string][] }, tool)(b.ctx, "") } readers := []string{"n1.mesh-grants", "n1.node-tools", "n1.mesh-delivery-indexer", "n1.mesh-delivery-assigner", "n1.mesh-delivery-builder", "n1.mesh-delivery-checker", "n1.mesh-delivery-teller"} - for tool, allowed := range granted { + for _, tool := range tools { for _, user := range readers { a, err := ask(user, tool) - switch { - case slices.Contains(allowed, user) && err != nil: + if err != nil { t.Errorf("%s's first view of %s before any new-form state: %v", user, tool, err) - case slices.Contains(allowed, user): - keys, _ := b.buckets[viewedStates()[tool]].Keys(b.ctx) - if a.Owner != assignment.Module() || a.State != tool || len(a.Values) != len(keys) { - t.Errorf("%s's first view of %s = %+v, the state holds %v", user, tool, a, keys) - } - case err == nil || !strings.Contains(err.Error(), "refused"): - t.Errorf("%s, granted no first view of %s, was answered %+v, %v", user, tool, a, err) + continue + } + keys, _ := b.buckets[viewedStates()[tool]].Keys(b.ctx) + if a.Owner != assignment.Module() || a.State != tool || len(a.Values) != len(keys) { + t.Errorf("%s's first view of %s = %+v, the state holds %v", user, tool, a, keys) } } } @@ -1679,6 +1768,15 @@ func serveCatalog(t *testing.T, b *bed, nc *nats.Conn) { _ = m.Respond([]byte(`{"result":{"none-yet":true},"node":"n0"}`)) return } + if kept, ok := b.cat.at[branch][in.Revision]; ok { + rev := meshcatalog.CatalogRevision{Kind: "trunk", Branch: in.Branch, Revision: in.Revision} + for _, e := range kept { + rev.Entries = append(rev.Entries, meshcatalog.EntryRef{Module: e.Module, Digest: e.ManifestDigest}) + } + raw, _ := json.Marshal(map[string]any{"result": meshcatalog.RevisionAnswer{Revision: &rev, Entries: kept}, "node": "n0"}) + _ = m.Respond(raw) + return + } rev := meshcatalog.CatalogRevision{Kind: "trunk", Branch: in.Branch, Revision: b.cat.rev[branch]} var entries []meshcatalog.CatalogEntry for _, name := range slices.Sorted(maps.Keys(b.cat.entries[branch])) { diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/tiers.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/tiers.go index f8a040e4..5211d564 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/tiers.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/tiers.go @@ -300,5 +300,9 @@ func (p *passer) tierDeadline(at time.Time) { // with the content ${config:tier-bound}; zero, its default, for a file missing or empty. func tierBoundSetting(getenv func(string) string) (time.Duration, error) { minutes, err := settingFile(getenv("MESH_ASSIGNER_TIER_BOUND_FILE")) - return time.Duration(minutes) * time.Minute, err + return time.Duration(minutes) * tierBoundUnit, err } + +// tierBoundUnit is the unit of the setting tier-bound, a minute; the whole test sets a shorter one, so a tier passes its bound +// without a test waiting minutes. +var tierBoundUnit = time.Minute