Files
mesh-delivery/modules/mesh-delivery-builder/internal/build/unbuildable.go
T
jschoubben bcff47d257 B6 (H-A-425): a plan no seat builds is kept in the state unbuildable and said in one line
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
2026-11-22 01:37:32 +01:00

157 lines
5.4 KiB
Go

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 <module>, 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
}