From bcff47d257266580809a9bc1176b2a038f21d765 Mon Sep 17 00:00:00 2001 From: jochen Date: Sun, 22 Nov 2026 01:37:32 +0100 Subject: [PATCH] B6 (H-A-425): a plan no seat builds is kept in the state unbuildable and said in one line MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A line per module drowned the journal at 6,500 plans; the plans live on the bus, where builder_unbuildable reads them, and the builder says them once per start and per seat list change. Builds: design 47 H2 §795, §820; H-A-425 --- .../cmd/mesh-delivery-builder-tools/main.go | 1 + .../unbuildable.go | 70 ++++++++ .../cmd/mesh-delivery-builder/main.go | 6 +- .../cmd/mesh-delivery-builder/unbuildable.go | 56 +++++++ .../internal/build/plan.go | 7 +- .../internal/build/plan_test.go | 52 ++++++ .../internal/build/run.go | 13 +- .../internal/build/unbuildable.go | 156 ++++++++++++++++++ .../mesh-delivery-builder/manifest_test.go | 4 +- modules/mesh-delivery-builder/module.json | 4 +- 10 files changed, 359 insertions(+), 10 deletions(-) create mode 100644 modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/unbuildable.go create mode 100644 modules/mesh-delivery-builder/cmd/mesh-delivery-builder/unbuildable.go create mode 100644 modules/mesh-delivery-builder/internal/build/unbuildable.go diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/main.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/main.go index 7cf542486..5475bb16c 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/main.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/main.go @@ -446,6 +446,7 @@ func main() { return stdio.Ask(dropVerbKey, in) }, time.Now, meshhandactsclient.Recorder{Ask: stdio.Ask})...) tools = append(tools, waitsTools(wr, buildAgain, time.Now, meshhandactsclient.Recorder{Ask: stdio.Ask})...) + tools = append(tools, unbuildableTool(unbuildablePage(stdio.State(build.UnbuildableState)))) // the plans no seat builds (§795) tools = append(tools, toolchainsTools(stdio.State(buildrun.ToolchainsHeardState), meshhandactsclient.Recorder{Ask: stdio.Ask}, time.Now)...) // The builder's expiring keys (state bounds): what each bounds and when it ends. tools = append(tools, stdio.Tool{Name: versions.BoundsTool, Description: versions.BoundsDescription, diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/unbuildable.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/unbuildable.go new file mode 100644 index 000000000..0d9bb2aa1 --- /dev/null +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/unbuildable.go @@ -0,0 +1,70 @@ +package main + +import ( + "encoding/json" + "errors" + "sort" + + stdio "git.novox.be/novox/mesh-sdk/go" + + "mesh-delivery-builder/internal/build" + "mesh-delivery-builder/internal/versions" +) + +// unbuildableTool is builder_unbuildable (design 47 H2 §795, H-A-425): the builder's state unbuildable, the plans no seat builds, +// read in one page of at most 768 KB (capped says what it left out), with the summary line of the rows read. +func unbuildableTool(page func() (versions.StatePage, error)) stdio.Tool { + return stdio.Tool{Name: build.UnbuildableTool, + Description: "The modules whose artifact no build seat builds, or whose build seat no module claims, as the builder judged their plans " + + "(its state " + build.UnbuildableState + ", worked out again at every start and every change of the seat list): each module, the fingerprint " + + "judged, the artifact's language and kind, why and when; with the one summary line the builder says of them. At most 768 KB, capped " + + "saying what was left out. Read-only.", + Input: map[string]any{"type": "object", "properties": map[string]any{}}, + Run: func(map[string]any) (any, error) { + pg, err := page() + if err != nil { + return nil, err + } + rows := []build.Unbuildable{} + var unread []string + for k, raw := range pg.Values { + var u build.Unbuildable + if err := json.Unmarshal(raw, &u); err != nil || u.Module == "" { + unread = append(unread, k) + continue + } + rows = append(rows, u) + } + sort.Slice(rows, func(i, j int) bool { return rows[i].Module < rows[j].Module }) + sort.Strings(unread) + out := map[string]any{"line": build.UnbuildableLine(rows), "unbuildable": rows} + if len(unread) > 0 { + out["unreadable"] = unread + } + if pg.More { + out["capped"] = versions.StateCapped{State: build.UnbuildableState, KeysRead: len(pg.Values), StateKeys: pg.Keys, StateBytes: pg.Bytes, InfoWords: pg.InfoWords} + } + return out, nil + }} +} + +// unbuildablePage is the first page of the state unbuildable; a runtime that pages nothing is read key by key. +func unbuildablePage(s stdio.KeptState) func() (versions.StatePage, error) { + return func() (versions.StatePage, error) { + pg, err := onePage(s.Page, s.Info) + if !errors.Is(err, errors.ErrUnsupported) { + return pg, err + } + keys, err := s.Keys() + if err != nil { + return versions.StatePage{}, err + } + out := versions.StatePage{Values: map[string]json.RawMessage{}} + for _, k := range keys { + if e, err := s.Get(k); err == nil && e != nil { + out.Values[k] = e.Value + } + } + return out, nil + } +} diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go index 09e4f7623..0f3f2c632 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go @@ -240,6 +240,8 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro return emitEvent(context.WithoutCancel(ctx), js, cred, event, id, body) }, waitBound, logger.Printf) waitsBucket.Ready(func(kv jetstream.KeyValue) { b.Waits.(*waitsKept).start(ctx, kv) }) + // The plans no seat builds (design 47 H2 §795, H-A-425): kept in the state unbuildable, read by builder_unbuildable. + b.Unbuildables = unbuildableKept{b: process.AwaitBucket(ctx, js, conn, builds.StateBucket(cred.Module, build.UnbuildableState), "the plans no seat builds are said, and builder_unbuildable lists none", logger.Printf)} // The versions a build reserves at its start (design 47 G §369): its state reserved, and the catalog's versions-filled // and version-released heard; nothing is reserved before the fill. reservedKV := process.AwaitBucket(ctx, js, conn, own.reserved, "no version is reserved: builds are made unreserved", logger.Printf) @@ -508,7 +510,8 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro if err := serveSteps(ctx, conn, js, steps, &ackWait); err != nil { return err } - seatGate.Follow(seatlist.ProcessBus(calls.Call, hub), func() { seatsChanged(ctx) }, logger.Printf) + // A change of the seat list judges every plan no seat builds again and says them in one line (design 47 H2 §795). + seatGate.Follow(seatlist.ProcessBus(calls.Call, hub), func() { seatsChanged(ctx); b.SayUnbuildable(ctx) }, logger.Printf) half.holders = func() { seatsChanged(ctx) } for _, pattern := range seatEventPatterns { if err := hub.Handle(pattern, events); err != nil { @@ -529,6 +532,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro if err := b.Sweep(ctx, half.pictured()...); err != nil { errs <- err } + b.SayUnbuildable(ctx) // at the start, once the first views are in: the plans no seat builds in one line (§795) } branches.Changed = half.Changed(ctx) // A catalog revision the builder hears wakes a floor whose tags or requirements were silent (design 47 G A-119). diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/unbuildable.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/unbuildable.go new file mode 100644 index 000000000..cf8dfbe2c --- /dev/null +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/unbuildable.go @@ -0,0 +1,56 @@ +package main + +import ( + "context" + "errors" + + "github.com/nats-io/nats.go/jetstream" + + "git.novox.be/novox/mesh-sdk/go/process" + + "mesh-delivery-builder/internal/build" +) + +// unbuildableKept is the builder's state unbuildable on the bus as build.Unbuildables (design 47 H2 §795, H-A-425). +type unbuildableKept struct{ b *process.AwaitedBucket } + +func (u unbuildableKept) Put(ctx context.Context, module string, value []byte) error { + _, err := u.b.Put(ctx, module, value) + if errors.Is(err, process.ErrNotYet) { + return nil // kept, and written when the state appears + } + return err +} + +// Delete removes module's key when the state holds it: a key not there is no error, and writes no marker. +func (u unbuildableKept) Delete(ctx context.Context, module string) error { + kv := u.b.KV() + if kv == nil { + return nil + } + if _, err := kv.Get(ctx, module); errors.Is(err, jetstream.ErrKeyNotFound) { + return nil + } else if err != nil { + return err + } + return kv.Delete(ctx, module) +} + +func (u unbuildableKept) Keys(ctx context.Context) ([]string, error) { + kv := u.b.KV() + if kv == nil { + return nil, nil + } + l, err := kv.ListKeys(ctx) + if err != nil { + return nil, err + } + defer func() { _ = l.Stop() }() + var out []string + for k := range l.Keys() { + out = append(out, k) + } + return out, nil +} + +var _ build.Unbuildables = unbuildableKept{} diff --git a/modules/mesh-delivery-builder/internal/build/plan.go b/modules/mesh-delivery-builder/internal/build/plan.go index 05db3a88f..fd5132da2 100644 --- a/modules/mesh-delivery-builder/internal/build/plan.go +++ b/modules/mesh-delivery-builder/internal/build/plan.go @@ -82,7 +82,10 @@ func (n *NotPinned) Error() string { // the plan is not kept, so it is made again when they are read (design 47 G A-82). type NoBuildModule struct { Artifact string - Err error + // Language and Kind are the artifact's, as the seat list is asked for them: what the summary of the plans no seat builds counts + // (design 47 H2 §795). + Language, Kind string + Err error } func (n *NoBuildModule) Error() string { return fmt.Sprintf("artifact %s: %v", n.Artifact, n.Err) } @@ -103,7 +106,7 @@ func PlanOf(m catalogue.Manifest, seats *buildrun.BuildSeats) (Plan, error) { task := func(a catalogue.Artifact, language, kind string) error { bm, err := seats.For(language, kind) if err != nil { - return &NoBuildModule{Artifact: a.Name, Err: err} + return &NoBuildModule{Artifact: a.Name, Language: language, Kind: kind, Err: err} } t := Task{Artifact: a.Name, Kind: a.Kind, Module: bm.Module, Language: bm.Toolchain, From: a.From} if a.Kind != catalogue.ArtifactUpstream { diff --git a/modules/mesh-delivery-builder/internal/build/plan_test.go b/modules/mesh-delivery-builder/internal/build/plan_test.go index 3d4a17c62..2147054ef 100644 --- a/modules/mesh-delivery-builder/internal/build/plan_test.go +++ b/modules/mesh-delivery-builder/internal/build/plan_test.go @@ -1,13 +1,16 @@ package build import ( + "context" "errors" + "fmt" "strings" "testing" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/buildrun" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" "git.novox.be/novox/mesh-sdk/go/catalogue" "git.novox.be/novox/mesh-sdk/go/seatdef" @@ -114,9 +117,58 @@ func TestAPlanNamesTheHoldersOfTheBuildSeats(t *testing.T) { if !errors.As(err, &none) { t.Fatalf("with no holder: %v, want NoBuildModule", err) } + if none.Language != "" || none.Kind != "image" { + t.Errorf("the plan no seat builds names %q %q, want the image's kind (design 47 H2 §795)", none.Language, none.Kind) + } + // Design 47 H2 §795, H-A-425: 6,500 plans no seat builds are kept in the state unbuildable and said in one summary line, with + // each language and kind and its count, never a line per module; a module whose look judges its plan so writes its key and + // no line of its own, and the module is removed once it builds. + t.Run("6,500 plans no seat builds are one line", func(t *testing.T) { + var lines []string + kept := &memUnbuildables{vals: map[string][]byte{}} + mf := &fakeManifests{byDigest: map[string]catalogue.Manifest{mdigest('a'): m, mdigest('b'): manifestOf(catalogue.Artifact{Name: "web", Kind: "bundle", Language: "typescript"})}} + b := &Builder{OwnModule: builds.BuilderModule, Seats: seats, Claimer: Claimer{Store: newMem(), By: "novox.builder"}, Manifests: mf, Unbuildables: kept, + Logf: func(f string, a ...any) { lines = append(lines, fmt.Sprintf(f, a...)) }} + holders["node-build-go"], holders["node-build-image"] = "", "" + b.init() + for i := range 6500 { + digest := mdigest('a') + if i%5 == 0 { + digest = mdigest('b') + } + b.known[fmt.Sprintf("m%04d", i)] = meshcatalog.ModulesByModuleValue{Fp2: fp1, Manifest: digest} + } + kept.vals["gone"] = []byte(`{"module":"gone"}`) // a module that builds now + judged := b.SayUnbuildable(context.Background()) + if len(judged) != 6500 || len(kept.vals) != 6500 || kept.vals["gone"] != nil { + t.Fatalf("judged %d, kept %d (gone kept: %v), want 6,500 each and gone removed", len(judged), len(kept.vals), kept.vals["gone"] != nil) + } + if len(lines) != 1 || lines[0] != "6500 "+UnbuildableSaid+": image 5200, typescript bundle 1300" { + t.Errorf("said %d lines %q, want one naming each language and kind with its count", len(lines), lines) + } + lines = nil + delete(kept.vals, "m0001") + b.try(context.Background(), "m0001", b.known["m0001"]) + if kept.vals["m0001"] == nil || len(lines) != 0 { + t.Errorf("a look at a plan no seat builds kept %s and said %q, want its key kept and no line", kept.vals["m0001"], lines) + } + }) holders["node-build-go"], holders["node-build-image"] = "acme-go", "acme-img" p, err := PlanOf(m, seats) if err != nil || len(p.Tasks) != 2 || p.Tasks[0].Module != "acme-img" || p.Tasks[1].Module != "acme-go" || p.Tasks[1].Language != "go" || p.Tasks[0].Language != "" { t.Fatalf("plan = %+v, %v", p, err) } } + +// memUnbuildables is the state unbuildable in memory. +type memUnbuildables struct{ vals map[string][]byte } + +func (m *memUnbuildables) Put(_ context.Context, k string, v []byte) error { m.vals[k] = v; return nil } +func (m *memUnbuildables) Delete(_ context.Context, k string) error { delete(m.vals, k); return nil } +func (m *memUnbuildables) Keys(context.Context) ([]string, error) { + out := make([]string, 0, len(m.vals)) + for k := range m.vals { + out = append(out, k) + } + return out, nil +} diff --git a/modules/mesh-delivery-builder/internal/build/run.go b/modules/mesh-delivery-builder/internal/build/run.go index 155aafa65..fcd1409fd 100644 --- a/modules/mesh-delivery-builder/internal/build/run.go +++ b/modules/mesh-delivery-builder/internal/build/run.go @@ -61,8 +61,10 @@ type Builder struct { Toolchains ToolchainEntries // Waits keeps the toolchain waits of design 47 G §672. Nil holds none: an entry whose fingerprint names another toolchain is // left unbuilt, as before. - Waits Waits - Manifests Manifests + Waits Waits + // Unbuildables keeps the plans no seat builds in the builder's state unbuildable (design 47 H2 §795, H-A-425). Nil keeps none. + Unbuildables Unbuildables + Manifests Manifests // Left, when set, is told a key a look claimed and left building because its end could not be written (issue 1966, // novox/hq ADR 0668 §3; 1748 note 27): no look holds it then, so nothing ends it but builder_build_again or the // builder's next start. Ended is told each key whose end was written. @@ -639,8 +641,10 @@ func (b *Builder) try(ctx context.Context, module string, m meshcatalog.ModulesB var noModule *NoBuildModule if errors.As(planErr, &noModule) { // The seat list or the catalog half does not name the build module yet: nothing is claimed, and the look is made again - // when they do (Reconsider, at each change of either; design 47 G A-82). - end("is not built yet: %v", planErr) + // when they do (Reconsider, at each change of either; design 47 G A-82). The plan is kept in the state unbuildable and + // said in the one summary line (SayUnbuildable), never in a line per module (design 47 H2 §795). + whyEnded = "is not built yet: " + planErr.Error() + b.judgedUnbuildable(ctx, module, m.Fp2, noModule) return } nothing := read && planErr == nil && len(plan.Tasks) == 0 @@ -696,6 +700,7 @@ func (b *Builder) try(ctx context.Context, module string, m meshcatalog.ModulesB return } b.handClaimed(key, cl.Rev) + b.buildable(ctx, module) // the module builds: no longer a plan no seat builds (design 47 H2 §795, H-A-425) if b.Waits != nil { b.Waits.End(ctx, module, m.Fp2, WaitPublished) // a key queued behind a package is claimed once it is published } diff --git a/modules/mesh-delivery-builder/internal/build/unbuildable.go b/modules/mesh-delivery-builder/internal/build/unbuildable.go new file mode 100644 index 000000000..4566d847f --- /dev/null +++ b/modules/mesh-delivery-builder/internal/build/unbuildable.go @@ -0,0 +1,156 @@ +package build + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "sort" + "strings" + "time" +) + +// **The plans no seat builds** (design 47 H2 §795, H-A-425): a module whose artifact no build seat builds, or whose build seat +// no module claims, is kept in the builder's state unbuildable, one key per module, written when its plan is judged and removed +// when the module builds; builder_unbuildable reads that state. The judgement is made again at every start and every change +// of the seat list (SayUnbuildable), and said in one summary line each time, never a line per module. +const ( + // UnbuildableState is the builder's state of the plans no seat builds, one key , 8 MiB. + UnbuildableState = "unbuildable" + // UnbuildableTool is builder_unbuildable, which lists that state. + UnbuildableTool = "builder_unbuildable" + // UnbuildableSaid opens the summary line. + UnbuildableSaid = "modules have an artifact no seat builds" +) + +// Unbuildable is one key of the state unbuildable: the module, the fingerprint whose plan was judged, the first artifact's +// language and kind no seat builds, and why. +type Unbuildable struct { + Module string `json:"module"` + Fingerprint string `json:"fingerprint"` + Language string `json:"language,omitempty"` + Kind string `json:"kind"` + Why string `json:"why"` + At time.Time `json:"at"` +} + +// Unbuildables keeps the state unbuildable: Put writes a module's key, Delete removes it (a key not there is no error) and Keys +// lists the modules it holds. +type Unbuildables interface { + Put(ctx context.Context, module string, value []byte) error + Delete(ctx context.Context, module string) error + Keys(ctx context.Context) ([]string, error) +} + +// unbuildableOf is the key value of module's plan judged at fp with none. +func unbuildableOf(module, fp string, none *NoBuildModule, at time.Time) Unbuildable { + return Unbuildable{Module: module, Fingerprint: fp, Language: none.Language, Kind: none.Kind, Why: none.Error(), At: at.UTC()} +} + +// judgedUnbuildable writes module's key: its plan, judged at fp, names an artifact no seat builds. +func (b *Builder) judgedUnbuildable(ctx context.Context, module, fp string, none *NoBuildModule) { + if b.Unbuildables == nil { + return + } + raw, _ := json.Marshal(unbuildableOf(module, fp, none, b.now())) + if err := b.Unbuildables.Put(ctx, module, raw); err != nil { + b.logf("%s: the plan no seat builds is not kept in the state %s: %v", module, UnbuildableState, err) + } +} + +// buildable removes module's key: the module builds. +func (b *Builder) buildable(ctx context.Context, module string) { + if b.Unbuildables == nil { + return + } + if err := b.Unbuildables.Delete(ctx, module); err != nil { + b.logf("%s: its key of the state %s is not removed: %v", module, UnbuildableState, err) + } +} + +// SayUnbuildable judges the plan of every module the builder knows again, keeps the ones no seat builds in the state unbuildable +// (writing the modules it does not hold yet and removing the ones that build now), and says them in one line: how many, and +// each language and kind with its count (design 47 H2 §795). It answers the modules judged so. +func (b *Builder) SayUnbuildable(ctx context.Context) []Unbuildable { + b.init() + b.mu.Lock() + known := sortedKeys(b.known) + modules := make(map[string]string, len(known)) // the fingerprint each is known at + digests := make(map[string]string, len(known)) + for _, k := range known { + modules[k], digests[k] = b.known[k].Fp2, b.known[k].Manifest + } + b.mu.Unlock() + var out []Unbuildable + now := b.now() + for _, k := range known { + if modules[k] == "" || digests[k] == "" { + continue + } + _, err, _ := b.planOf(ctx, digests[k]) + var none *NoBuildModule + if errors.As(err, &none) { + out = append(out, unbuildableOf(k, modules[k], none, now)) + } + } + if b.Unbuildables != nil { + held := map[string]bool{} + keys, err := b.Unbuildables.Keys(ctx) + if err != nil { + b.logf("the state %s cannot be listed, so the plans no seat builds are written whole: %v", UnbuildableState, err) + } + for _, k := range keys { + held[k] = true + } + judged := map[string]bool{} + for _, u := range out { + judged[u.Module] = true + if held[u.Module] { + continue // written when its plan was judged at its look + } + raw, _ := json.Marshal(u) + if err := b.Unbuildables.Put(ctx, u.Module, raw); err != nil { + b.logf("%s: the plan no seat builds is not kept in the state %s: %v", u.Module, UnbuildableState, err) + } + } + for _, k := range keys { + if !judged[k] { + b.buildable(ctx, k) + } + } + } + b.logf("%s", UnbuildableLine(out)) + return out +} + +// UnbuildableLine is the one summary line of the plans no seat builds: "N modules have an artifact no seat builds:" with each +// language and kind and its count, most first (design 47 H2 §795). +func UnbuildableLine(us []Unbuildable) string { + counts := map[string]int{} + for _, u := range us { + what := u.Kind + if u.Language != "" { + what = u.Language + " " + u.Kind + } + counts[what]++ + } + whats := make([]string, 0, len(counts)) + for w := range counts { + whats = append(whats, w) + } + sort.Slice(whats, func(i, j int) bool { + if counts[whats[i]] != counts[whats[j]] { + return counts[whats[i]] > counts[whats[j]] + } + return whats[i] < whats[j] + }) + parts := make([]string, len(whats)) + for i, w := range whats { + parts[i] = fmt.Sprintf("%s %d", w, counts[w]) + } + line := fmt.Sprintf("%d %s", len(us), UnbuildableSaid) + if len(parts) > 0 { + line += ": " + strings.Join(parts, ", ") + } + return line +} diff --git a/modules/mesh-delivery-builder/manifest_test.go b/modules/mesh-delivery-builder/manifest_test.go index a37f030e9..e2deaff68 100644 --- a/modules/mesh-delivery-builder/manifest_test.go +++ b/modules/mesh-delivery-builder/manifest_test.go @@ -115,7 +115,7 @@ func TestManifestDeclarations(t *testing.T) { // 1607/AC1 if m.Module != "mesh-delivery-builder" { t.Errorf("module = %q", m.Module) } - if want := []state{{Name: "builds", History: 5}, {Name: "engine-reads", History: 1}, {Name: "findings", History: 5}, {Name: "floor-waits", History: 1}, {Name: "hearing", History: 1}, {Name: "instances", History: 1}, {Name: "old-form", History: 1}, {Name: "bounds", History: 1, KeyTTL: true}, {Name: "taken", History: 1, KeyTTL: true, MaxMiB: 8}, {Name: "queues", History: 1}, {Name: "toolchains-heard", History: 1}, {Name: "waits", History: 1, MaxMiB: 4}, {Name: "reserved", History: 1}, {Name: "publish-queue", History: 1, MaxMiB: 4}, {Name: "acted", History: 1, MaxMiB: 1}, {Name: "asked", History: 1}, {Name: "reasks", History: 1}, {Name: "versions", History: 1}, {Name: "first-views", History: 1}}; !reflect.DeepEqual(m.State, want) { // builds.BuilderBuildsHistory + if want := []state{{Name: "builds", History: 5}, {Name: "engine-reads", History: 1}, {Name: "findings", History: 5}, {Name: "floor-waits", History: 1}, {Name: "hearing", History: 1}, {Name: "instances", History: 1}, {Name: "old-form", History: 1}, {Name: "bounds", History: 1, KeyTTL: true}, {Name: "taken", History: 1, KeyTTL: true, MaxMiB: 8}, {Name: "queues", History: 1}, {Name: "toolchains-heard", History: 1}, {Name: "waits", History: 1, MaxMiB: 4}, {Name: "reserved", History: 1}, {Name: "publish-queue", History: 1, MaxMiB: 4}, {Name: "acted", History: 1, MaxMiB: 1}, {Name: "asked", History: 1}, {Name: "reasks", History: 1}, {Name: "versions", History: 1}, {Name: "first-views", History: 1}, {Name: "unbuildable", History: 1, MaxMiB: 8}}; !reflect.DeepEqual(m.State, want) { // builds.BuilderBuildsHistory t.Errorf("state = %+v, want %+v", m.State, want) } // 1887/A4c: the builder chooses no node, so it reads neither presence nor have, invokes no build module's tool and @@ -177,7 +177,7 @@ func TestManifestDeclarations(t *testing.T) { // 1607/AC1 } // 1945: the builder's tools (builder_seat_queue: note 62), served by its tools bundle, and the event it says when it asks an ask again. if want := []string{"builder_announce_again", "builder_ask_again", "builder_ask_drop", "builder_asks", "builder_bounds", "builder_build", "builder_build_again", "builder_builds_since", "builder_engine_reads", "builder_first_view_again", "builder_first_views", - "builder_floor_again", "builder_floor_waits", "builder_old_form", "builder_publish_again", "builder_publish_queue", "builder_release", "builder_reserve_done", "builder_reserved", "builder_reserved_drop", "builder_seat_list", "builder_seat_list_again", "builder_seat_queue", "builder_stuck", "builder_toolchains", "builder_toolchains_drop", "builder_versions", "builder_waits"}; !reflect.DeepEqual(sorted(m.Tools), want) { + "builder_floor_again", "builder_floor_waits", "builder_old_form", "builder_publish_again", "builder_publish_queue", "builder_release", "builder_reserve_done", "builder_reserved", "builder_reserved_drop", "builder_seat_list", "builder_seat_list_again", "builder_seat_queue", "builder_stuck", "builder_toolchains", "builder_toolchains_drop", "builder_unbuildable", "builder_versions", "builder_waits"}; !reflect.DeepEqual(sorted(m.Tools), want) { t.Errorf("tools = %v, want %v", m.Tools, want) } // Design 47 G §672: the toolchain waits' stream, kept 7 days within 16 MiB, and the bound's setting, 60 minutes. diff --git a/modules/mesh-delivery-builder/module.json b/modules/mesh-delivery-builder/module.json index 68322d55e..b7ef33184 100644 --- a/modules/mesh-delivery-builder/module.json +++ b/modules/mesh-delivery-builder/module.json @@ -37,6 +37,7 @@ "builder_toolchains", "builder_toolchains_drop", "builder_waits", + "builder_unbuildable", "builder_ask_drop", "builder_asks", "builder_versions", @@ -140,7 +141,8 @@ { "name": "asked", "history": 1 }, { "name": "reasks", "history": 1 }, { "name": "versions", "history": 1 }, - { "name": "first-views", "history": 1 } + { "name": "first-views", "history": 1 }, + { "name": "unbuildable", "history": 1, "max-mib": 8 } ], "streams": [ { "name": "waits", "events": ["wait-held.**", "wait-ended.**"], "max-age-days": 7, "max-mib": 16 },