The builder finds a build module as the indexer's seed does: the build seat whose acting rule `build` has an `on` matching the artifact's language or kind:image, and that seat's holder, read from the seat list's definitions and the claims of the catalog half's manifests. Task.Module, every lane key, the unpublished modules, the toolchain sources, the ends watched, the sayer and builder_stuck (through `<seat>.steps`) derive from it; the floor's sources are the holders of the seats git and mesh-catalog. buildrun.GoBuildModule, NodeBuildModule, LanguageOf, buildstep.BuildModuleOf use, build.ImageBuildModule and StuckBuildModules are gone from the builder (the checker keeps its own names in two small files until its part reads them from the list). Builds: design 47 G §7, §428, §704, §204, A-82 Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
142 lines
6.3 KiB
Go
142 lines
6.3 KiB
Go
package check
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"maps"
|
|
"slices"
|
|
"strings"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
|
|
|
"git.novox.be/novox/mesh-delivery/sdk/graph"
|
|
)
|
|
|
|
// What the check builds of a candidate before it composes (novox/hq ADR 0603 §10). The builder builds every fingerprint the
|
|
// indexer's candidate carries, as a key of its own (builds.<module>.<fingerprint>), with the build modules that run; the
|
|
// check adds no build path of its own and waits on those keys (awaitBuilds), so the node-engines compose the candidate's
|
|
// modules with their builds. It does not wait on two kinds of changed module, and names them in its composition's warnings:
|
|
//
|
|
// - one built by a build module the change alters (the recipe of mesh-build-go or mesh-build-node enters the fingerprint
|
|
// of every module it builds, ADR 0530 §1): its candidate build is the running build module's, and the check cannot run
|
|
// the candidate's build module to build it (it runs it only for its own digest and tests, ADR 0535 §1), so it is not
|
|
// composed with a build of the changed build module; it is built again once the agreed toolchain moves (ADR 0603 §3).
|
|
// The build module's own build is waited on, as any other: the running build module builds its new source.
|
|
// - one that stands on a module the change alters (build.on): its candidate fingerprint names the base's trunk
|
|
// fingerprint, and no build module builds on another module's artifact (ADR 0487 §1), so its build stands on the
|
|
// trunk's base; the base's own build is waited on.
|
|
//
|
|
// A module the trunk holds no record of yet is not built by the builder until it is merged, so it is not waited on either.
|
|
//
|
|
// A changed build module whose manifest invokes a seat verb or module tool no running build serves is one the check cannot
|
|
// run (ADR 0614 §7): the modules it builds are composed from their manifests, as above, and the words name the verb.
|
|
|
|
// buildsOfTheCheck are the builds the check waits on before it composes (module to fingerprint) and the words for the
|
|
// changed modules it composes without waiting on their build, one line each, sorted. A manifest that cannot be read leaves
|
|
// every build waited on and nothing said of build modules or bases (nothing is said that was not read).
|
|
func (st *state) buildsOfTheCheck(ctx context.Context) (map[string]string, []string) {
|
|
wait := map[string]string{}
|
|
changed := map[string]catalogue.Manifest{}
|
|
readable := true
|
|
for _, p := range st.c.Pulls {
|
|
for module, cm := range p.Fps {
|
|
if cm.Fp2 == "" || cm.Manifest == "" {
|
|
continue // the builder builds no fingerprint of it (candidates.go: none of the new form, or no manifest)
|
|
}
|
|
wait[module] = cm.Fp2
|
|
if !readable || st.j.Read == nil {
|
|
readable = false
|
|
continue
|
|
}
|
|
m, err := st.j.Read.Manifest(ctx, cm.Manifest)
|
|
if err != nil {
|
|
st.j.logf("%s: the manifest of %s cannot be read, so the modules built with a changed build module or base are not named and every build is waited on: %v", st.c.Key, module, err)
|
|
readable = false
|
|
continue
|
|
}
|
|
changed[module] = m
|
|
}
|
|
}
|
|
var words []string
|
|
if st.j.Runs != nil {
|
|
var unheld []string
|
|
for _, module := range slices.Sorted(maps.Keys(wait)) {
|
|
if st.j.Runs.CommitOf(module) == "" {
|
|
unheld = append(unheld, module)
|
|
delete(wait, module)
|
|
}
|
|
}
|
|
if len(unheld) > 0 {
|
|
words = append(words, fmt.Sprintf("%s: the trunk holds no record of it yet, so the builder builds it once it is merged and the check composes it without a build (ADR 0603 §10)",
|
|
strings.Join(unheld, ", ")))
|
|
}
|
|
}
|
|
if !readable {
|
|
return wait, words
|
|
}
|
|
for _, bm := range slices.Sorted(maps.Keys(languageOf)) {
|
|
if _, alters := changed[bm]; !alters {
|
|
continue
|
|
}
|
|
var built []string
|
|
for module, m := range changed {
|
|
if _, isBuildModule := languageOf[module]; !isBuildModule && buildsWith(m, languageOf[bm]) {
|
|
built = append(built, module)
|
|
delete(wait, module)
|
|
}
|
|
}
|
|
slices.Sort(built)
|
|
if len(built) > 0 {
|
|
words = append(words, fmt.Sprintf("the change alters the build module %s: %s, which it builds, are built by the running %s, not the changed one, which the check cannot run, so the check does not wait on their builds; they are built again once the agreed toolchain moves (ADR 0603 §3, §10)",
|
|
bm, strings.Join(built, ", "), bm))
|
|
}
|
|
if unserved := st.unservedVerbs(ctx, changed[bm]); len(unserved) > 0 {
|
|
what := "nothing it builds is in the change"
|
|
if len(built) > 0 {
|
|
what = strings.Join(built, ", ") + ", which it builds, are composed from their manifests"
|
|
}
|
|
words = append(words, fmt.Sprintf("the changed build module %s invokes %s, which no running build serves, so the check cannot run it: %s (ADR 0614 §7)",
|
|
bm, strings.Join(unserved, ", "), what))
|
|
}
|
|
}
|
|
g := graph.OfManifests(changed)
|
|
for _, base := range slices.Sorted(maps.Keys(changed)) {
|
|
if on := g.Dependents(base); len(on) > 0 {
|
|
for _, module := range on {
|
|
delete(wait, module)
|
|
}
|
|
words = append(words, fmt.Sprintf("the change alters %s, a base of %s: their builds stand on the trunk's %s, since no build module builds on a candidate's base, so the check waits on the build of %s alone (ADR 0603 §10)",
|
|
base, strings.Join(on, ", "), base, base))
|
|
}
|
|
}
|
|
return wait, words
|
|
}
|
|
|
|
// buildsWith says whether a manifest has a bundle in the language: the artifacts whose fingerprint names that language's
|
|
// toolchain and its build module's recipe (an archive is packed with no toolchain, ADR 0478 clause 1).
|
|
func buildsWith(m catalogue.Manifest, language string) bool {
|
|
return m.Build != nil && slices.ContainsFunc(m.Build.Artifacts, func(a catalogue.Artifact) bool {
|
|
return a.Kind == catalogue.ArtifactBundle && a.Language == language
|
|
})
|
|
}
|
|
|
|
// unservedVerbs are the seat verbs and module tools m invokes (graph.InvokesOf) that no running build serves, sorted; none
|
|
// when nothing reads what runs, or what runs cannot be read (said in the log: nothing is said that was not read).
|
|
func (st *state) unservedVerbs(ctx context.Context, m catalogue.Manifest) []string {
|
|
if st.j.Serving == nil {
|
|
return nil
|
|
}
|
|
served, err := st.j.Serving.Served(ctx)
|
|
if err != nil {
|
|
st.j.logf("%s: what the running builds serve cannot be read, so no build module is named for a verb it invokes: %v", st.c.Key, err)
|
|
return nil
|
|
}
|
|
var out []string
|
|
for _, v := range graph.InvokesOf(m) {
|
|
if !served(v) {
|
|
out = append(out, v)
|
|
}
|
|
}
|
|
return out
|
|
}
|