jschoubben
3e61b70517
All of mesh-build-go's buildstep Go module leaves mesh-catalog for modules/mesh-delivery-sdk: the step run, fetch and release and the regenerate-and-compare step as the package steprun, the CPU share as steprun/buildcpu, the conformance kit as steprun/conformance, the seat generator as seatgen with cmd/seatgen, and cmd/mesh-pack. The three build modules and the builder's and checker's tests import the SDK and keep no copy; the SDK requires nothing of mesh-catalog. Code the build modules share is the delivery domain's SDK, not one module's package. It carries the build-module round's two new files of that package (dropdetected.go 247c422f, storedbuilds.go 904b8aed). Builds: design 47 G §464, §680, §327, §420, §495 Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
53 lines
2.1 KiB
Go
53 lines
2.1 KiB
Go
package steprun
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
|
|
sdkstep "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep"
|
|
)
|
|
|
|
// Guard is a build module's check that the toolchain installed on its node is the one its recipe builds with
|
|
// (novox/hq ADR 0469 §1; issue 1473). The same guard serves ADR 0470 §4's postgres major for the integration
|
|
// level, with its own Probe and Want.
|
|
type Guard struct {
|
|
// Language is the toolchain's key part: go or typescript (ToolchainKey).
|
|
Language string
|
|
// Want is the toolchain version the recipe builds with, and Recipe the recipe's own version. The indexer
|
|
// compares both texts as they are written here.
|
|
Want, Recipe string
|
|
// Probe reads the installed version (go version, node --version).
|
|
Probe func(ctx context.Context) (installed string, err error)
|
|
Node string
|
|
// Put is the toolchains state's Put (stdio.State(the seat's toolchains state).Put).
|
|
Put Put
|
|
}
|
|
|
|
// Check probes the installed version, writes it to <node>.<language> of the toolchains state every time it runs,
|
|
// and answers nil when it is the recipe's. Otherwise it answers a *Refusal naming both versions; the installed
|
|
// version is written even then, so the indexer sees that builders disagree. A probe that fails is a *Refusal
|
|
// naming its failure, and nothing is written. A write that fails is an error that is not a Refusal.
|
|
func (g Guard) Check(ctx context.Context) error {
|
|
installed, err := g.Probe(ctx)
|
|
if err != nil {
|
|
return &Refusal{Text: fmt.Sprintf("the installed %s version could not be read: %v", g.Language, err), Want: g.Want}
|
|
}
|
|
key, err := sdkstep.ToolchainKey(g.Node, g.Language)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
raw, err := sdkstep.EncodeToolchain(sdkstep.Toolchain{Language: g.Language, Version: installed, Recipe: g.Recipe, At: now().UTC()})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := g.Put(key, json.RawMessage(raw)); err != nil {
|
|
return fmt.Errorf("steprun: writing the toolchain %s: %w", key, err)
|
|
}
|
|
if installed != g.Want {
|
|
return &Refusal{Text: fmt.Sprintf("%s %s installed, the recipe builds with %s %s", g.Language, installed, g.Language, g.Want),
|
|
Want: g.Want, Have: installed}
|
|
}
|
|
return nil
|
|
}
|