package check import ( "context" "fmt" "maps" "slices" "strings" "git.novox.be/novox/mesh-sdk/go/catalogue" "git.novox.be/novox/mesh-delivery/modules/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..), 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 st.j.Seats.Modules() { if st.j.languageOf(bm) == "" { continue } if _, alters := changed[bm]; !alters { continue } var built []string for module, m := range changed { if isBuildModule := st.j.languageOf(module) != ""; !isBuildModule && buildsWith(m, st.j.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 }