Files
mesh-delivery/modules/mesh-delivery-indexer/internal/index/buildmodules.go
T
jschoubben 04bfc92d3d §717 (3), the builder, the checker and the indexer follow the assignments by the seat, at the holder the seat-holders view names
buildrun's AssignerHolder asked the seat's verb for the holder every 5 seconds. The builder and the checker now follow
mesh-module-assigner's assignments through views.ProcessReader.FollowSeat with the catalog half's holder function (the
checker gains the catalog half's reader of §614 for it); the indexer reads the claimant from its own catalog
(Indexer.ClaimantNow) and follows its seat-holders view again at each refresh of its build modules. AssignerHolder goes; the
manifests consume the seat-holders view (the checker also the catalog half's events and verbs), and the assigner's
seat-holders first-view tool answers the checker and the indexer. The beds give each part a claimant and a seat-holders view
in place of the seat verb's answer; the indexer's beds hold the claimant from the start, so the merge test reads the newest
revision.

Builds: design 47 G §717, §614, A-298, A-302

Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
2026-11-12 20:17:36 +01:00

170 lines
6.4 KiB
Go

package index
import (
"context"
"fmt"
"maps"
"slices"
"git.novox.be/novox/mesh-sdk/go/catalogue"
"git.novox.be/novox/mesh-sdk/go/seatdef"
)
// The build module of a language is no name in code (design 47 *A module's registration*, "No part fixes a name": every
// module name a part needs is read from the registrations and the catalog graph; *What ADR 0656 leaves to this design*: a
// seat's acting rule `acts`, which "the indexer reads into the catalog graph"). It is the holder of the seat whose acting
// rule builds that language (`acts` {step: build, on: <language>}), found by the claims of the manifests the indexer
// holds; its toolchains are its state toolchains (ToolchainsBucket), and its toolchain reports ride the stream of its
// manifest's `streams` that carries ToolchainReportedEvent.
// ToolchainReportedEvent is the event a build module says each time it wrote its toolchains key, on a stream of its own.
const ToolchainReportedEvent = "toolchain.reported"
// BuildModule is the build module of one language, as the seat list and the manifests say it.
type BuildModule struct {
Language string // the language the seat's acting rule builds
Seat string // the seat whose acting rule it is
Module string // the module whose manifest claims the seat
Stream string // the stream carrying ToolchainReportedEvent, as the bus names it; empty when its manifest declares none
}
// BuildModulesOf are the build modules by language: for each seat whose acting rule is step build on a language, the
// module among manifests that claims it. A language two seats build, a seat two modules claim, a seat nobody claims and a
// holder declaring no stream for its reports are said in the problems; the first two give no build module of that
// language, the last one a build module with no stream.
func BuildModulesOf(defs map[string]seatdef.Definition, manifests []catalogue.Manifest) (map[string]BuildModule, []string) {
var problems []string
seats := map[string][]string{} // language -> the seats building it
for _, name := range slices.Sorted(maps.Keys(defs)) {
for _, r := range defs[name].Acts {
if r.Step != seatdef.StepBuild || r.Acting() == seatdef.OnEvery {
continue
}
seats[r.Acting()] = append(seats[r.Acting()], name)
}
}
out := map[string]BuildModule{}
for _, language := range slices.Sorted(maps.Keys(seats)) {
if len(seats[language]) > 1 {
problems = append(problems, fmt.Sprintf("the seats %v each build %s: no build module of %s is taken", seats[language], language, language))
continue
}
seat := seats[language][0]
var holders []catalogue.Manifest
for _, m := range manifests {
if slices.ContainsFunc(m.Claims, func(c catalogue.Claim) bool { return c.Name == seat }) {
holders = append(holders, m)
}
}
switch len(holders) {
case 0:
problems = append(problems, fmt.Sprintf("no module the indexer holds claims %s, which builds %s", seat, language))
continue
case 1:
default:
var names []string
for _, h := range holders {
names = append(names, h.Module)
}
slices.Sort(names)
problems = append(problems, fmt.Sprintf("the modules %v each claim %s, which builds %s: no build module of %s is taken", names, seat, language, language))
continue
}
b := BuildModule{Language: language, Seat: seat, Module: holders[0].Module}
for _, s := range holders[0].Streams {
if s.Carries(ToolchainReportedEvent) {
b.Stream = catalogue.StreamBusName(s.Name)
break
}
}
if b.Stream == "" {
problems = append(problems, fmt.Sprintf("%s, which builds %s, declares no stream carrying %s: its reports are not heard", b.Module, language, ToolchainReportedEvent))
}
out[language] = b
}
return out, problems
}
// UseBuildModules is what BuildModulesNow found: the build modules whose toolchains the indexer takes in from now on.
func (ix *Indexer) UseBuildModules(by map[string]BuildModule) {
ix.mu.Lock()
defer ix.mu.Unlock()
ix.buildModules = maps.Clone(by)
}
// BuildModules are the build modules by language the indexer takes toolchains of (UseBuildModules).
func (ix *Indexer) BuildModules() map[string]BuildModule {
ix.mu.Lock()
defer ix.mu.Unlock()
return maps.Clone(ix.buildModules)
}
// BuildModulesNow finds the build modules from the seat definitions defs and the manifests of the modules the indexer
// holds (BuildModulesOf), says each problem in the log, uses them (UseBuildModules) and answers them.
func (ix *Indexer) BuildModulesNow(ctx context.Context, defs map[string]seatdef.Definition) (map[string]BuildModule, error) {
manifests, err := ix.heldManifests(ctx)
if err != nil {
return nil, err
}
by, problems := BuildModulesOf(defs, manifests)
for _, p := range problems {
ix.logf("%s", p)
}
ix.UseBuildModules(by)
return by, nil
}
// ClaimantNow is the module whose manifest, among the modules the indexer holds, claims seat: the one claimant, read from the
// indexer's own catalog, the catalog seat's holder needing no catalog half (design 47 G A-302, A-298). None, or more than
// one, is none.
func (ix *Indexer) ClaimantNow(ctx context.Context, seat string) (string, bool) {
manifests, err := ix.heldManifests(ctx)
if err != nil {
ix.logf("who claims %s is not read from the modules held: %v", seat, err)
return "", false
}
var claimants []string
for _, m := range manifests {
if slices.ContainsFunc(m.Claims, func(c catalogue.Claim) bool { return c.Name == seat }) {
claimants = append(claimants, m.Module)
}
}
if len(claimants) != 1 {
return "", false
}
return claimants[0], true
}
// heldManifests are the manifests of the modules the indexer holds, one that cannot be read said in the log.
func (ix *Indexer) heldManifests(ctx context.Context) ([]catalogue.Manifest, error) {
held, err := ix.heldModules(ctx)
if err != nil {
return nil, err
}
var manifests []catalogue.Manifest
for _, key := range slices.Sorted(maps.Keys(held)) {
if held[key].Manifest == "" || ix.Manifests == nil {
continue
}
_, m, err := ix.manifestRaw(ctx, held[key].Manifest)
if err != nil {
ix.logf("modules.%s: its manifest %s cannot be read, so it holds no build seat here: %v", key, held[key].Manifest, err)
continue
}
manifests = append(manifests, m)
}
return manifests, nil
}
// languageBuiltBy is the language module is the build module of, or "".
func (ix *Indexer) languageBuiltBy(module string) string {
ix.mu.Lock()
defer ix.mu.Unlock()
for language, b := range ix.buildModules {
if b.Module == module {
return language
}
}
return ""
}