Files
mesh-catalog/modules/mesh-build-image/cmd/mesh-build-image/helpers_test.go
T
jschoubben 1c4739698a CAT-BI1: a copy keeps its wait for the mirror's outcome in the state mirror-waits
The image seat's published and refused reach one instance of the module, not
necessarily the one whose copy waits, so an outcome held only in memory was
dropped. The instance that hears it now writes it into the copy's key, and the
copy reads it there, woken by its watch of the state; build_image_mirror_waits
reads the state.

Claude-Session: https://claude.ai/code/session_01JG73KJNrH5EgFXMKKYSrig
2026-11-04 15:58:37 +01:00

342 lines
10 KiB
Go

package main
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"sync"
"testing"
"time"
stdio "git.novox.be/novox/mesh-sdk/go"
reg "git.novox.be/novox/mesh-contracts/go/seats/containerimageregistry"
"git.novox.be/novox/mesh-sdk/go/delivery"
"git.novox.be/novox/mesh-sdk/go/forgekey"
)
const commitSHA = "0123456789abcdef0123456789abcdef01234567"
// keptStates is the steps state, kept in memory: every write of a key, and the keys that ended.
type keptStates struct {
mu sync.Mutex
steps map[string][]delivery.Step
ended chan string
}
func newStates() *keptStates {
return &keptStates{steps: map[string][]delivery.Step{}, ended: make(chan string, 16)}
}
func (s *keptStates) putStep(key string, value any) (uint64, error) {
st, err := delivery.DecodeStep(value.(json.RawMessage))
if err != nil {
return 0, err
}
s.mu.Lock()
s.steps[key] = append(s.steps[key], st)
s.mu.Unlock()
if st.State != delivery.StepRunning {
s.ended <- key
}
return 1, nil
}
func (s *keptStates) waitEnd(t *testing.T) delivery.Step {
t.Helper()
select {
case key := <-s.ended:
s.mu.Lock()
defer s.mu.Unlock()
v := s.steps[key]
return v[len(v)-1]
case <-time.After(5 * time.Second):
t.Fatal("the step never ended on its key")
return delivery.Step{}
}
}
// cmdRecord is one command a step ran.
type cmdRecord struct {
env []string
name string
line string
}
// fake stands in for git and buildah at the process boundary and for the image seat's holder at the seat's verbs.
type fake struct {
mu sync.Mutex
calls []cmdRecord
digest string // what `buildah images` prints
pushes int // layouts written
failBud forgekey.Ran // what a failing buildah bud answers; a zero Status is a passing bud
// digestFile: "" writes the layout's digest, "none" writes no file, "other" writes another digest.
digestFile string
// pushed is the manifest digest of the last layout written; parts its parts' digests, the manifest last.
pushed string
parts []string
// The holder: held are the parts it holds already; refuse fails every publish; published the publishes it was
// asked, sent the parts it was sent whole; mirrors the mirrors asked, answered by mirrored (published when nil).
held map[string]bool
refuse error
published []reg.PublishInput
sent []string
mirrors []reg.MirrorInput
mirrored func(reg.MirrorInput) (string, reg.Outcome)
outcomes *Outcomes
// elsewhere: the outcome is heard by another instance of the module over the same mirror-waits, not by this
// process; watched: this process's watch of mirror-waits hands that instance's write over; atOnce: the outcome is
// said before the mirror answers.
elsewhere, watched, atOnce bool
// atAsk runs when the mirror is asked.
atAsk func()
}
// memWaits is the state mirror-waits in memory; watch, when set, is handed every write as the state's watch hands it.
type memWaits struct {
mu sync.Mutex
m map[string]json.RawMessage
watch func(stdio.StateChange) error
}
func (w *memWaits) Get(key string) (json.RawMessage, error) {
w.mu.Lock()
defer w.mu.Unlock()
return w.m[key], nil
}
func (w *memWaits) Put(key string, value any) (uint64, error) {
b, err := json.Marshal(value)
if err != nil {
return 0, err
}
w.mu.Lock()
if w.m == nil {
w.m = map[string]json.RawMessage{}
}
w.m[key] = b
watch := w.watch
w.mu.Unlock()
if watch != nil {
_ = watch(stdio.StateChange{State: MirrorWaitsState, Key: key, Op: "put", Value: b})
}
return 1, nil
}
func (w *memWaits) Delete(key string) error {
w.mu.Lock()
defer w.mu.Unlock()
delete(w.m, key)
return nil
}
func (w *memWaits) Keys() ([]string, error) {
w.mu.Lock()
defer w.mu.Unlock()
keys := []string{}
for k := range w.m {
keys = append(keys, k)
}
return keys, nil
}
const imageDigest = "sha256:1111111111111111111111111111111111111111111111111111111111111111"
func newFake(t *testing.T) *fake {
return &fake{digest: imageDigest, held: map[string]bool{}}
}
// address is the registry part of the seat's reference: the seat's name.
func (f *fake) address() string { return reg.Seat }
func sha(b []byte) string {
s := sha256.Sum256(b)
return "sha256:" + hex.EncodeToString(s[:])
}
// writeLayout writes an OCI layout of one config, one layer and their manifest into dir, as buildah push oci: does.
func (f *fake) writeLayout(dir, digestFile string) {
blobs := filepath.Join(dir, "blobs", "sha256")
_ = os.MkdirAll(blobs, 0o755)
put := func(b []byte) map[string]any {
d := sha(b)
_ = os.WriteFile(filepath.Join(blobs, strings.TrimPrefix(d, "sha256:")), b, 0o644)
return map[string]any{"digest": d, "size": len(b)}
}
config := put([]byte(`{"architecture":"amd64","os":"linux"}`))
layer := put([]byte("the layer's bytes"))
config["mediaType"], layer["mediaType"] = "application/vnd.oci.image.config.v1+json", "application/vnd.oci.image.layer.v1.tar+gzip"
raw, _ := json.Marshal(map[string]any{"schemaVersion": 2, "mediaType": "application/vnd.oci.image.manifest.v1+json",
"config": config, "layers": []any{layer}})
manifest := put(raw)
manifest["mediaType"] = "application/vnd.oci.image.manifest.v1+json"
index, _ := json.Marshal(map[string]any{"schemaVersion": 2, "manifests": []any{manifest}})
_ = os.WriteFile(filepath.Join(dir, "index.json"), index, 0o644)
f.pushed = manifest["digest"].(string)
f.parts = []string{config["digest"].(string), layer["digest"].(string), f.pushed}
switch f.digestFile {
case "":
_ = os.WriteFile(digestFile, []byte(f.pushed), 0o644)
case "other":
_ = os.WriteFile(digestFile, []byte(imageDigest), 0o644)
}
}
// call is the holder's side of the seat's verbs.
func (f *fake) call(key string, body any) (json.RawMessage, error) {
raw, _ := json.Marshal(body)
f.mu.Lock()
defer f.mu.Unlock()
switch key {
case "seat:" + reg.Seat + "." + reg.VerbPublish:
var in reg.PublishInput
_ = json.Unmarshal(raw, &in)
f.published = append(f.published, in)
if f.refuse != nil {
return nil, f.refuse
}
a := reg.PublishAnswer{Transfer: in.Transfer}
for _, p := range in.Parts {
if !f.held[p.Digest] {
a.Lacks = append(a.Lacks, p.Digest)
}
}
a.Held = len(a.Lacks) == 0
return json.Marshal(a)
case "seat:" + reg.Seat + "." + reg.VerbPublishPart:
var in reg.PublishPartInput
_ = json.Unmarshal(raw, &in)
if in.Last {
f.sent = append(f.sent, in.Part)
}
return json.Marshal(reg.PublishPartAnswer{Transfer: in.Transfer, Part: in.Part, Complete: in.Last})
case "seat:" + reg.Seat + "." + reg.VerbMirror:
var in reg.MirrorInput
_ = json.Unmarshal(raw, &in)
f.mirrors = append(f.mirrors, in)
if f.atAsk != nil {
f.atAsk()
}
event, o := reg.EventPublished, reg.Outcome{Kind: "upstream", Name: "upstream/" + in.Name, Digest: in.Digest,
Holder: "distribution", Reference: reg.Seat + "/upstream/" + in.Name + "@" + in.Digest}
if f.mirrored != nil {
event, o = f.mirrored(in)
}
if event != "" && f.outcomes != nil {
hearer := f.outcomes
if f.elsewhere {
waits := f.outcomes.Waits.(*memWaits)
if f.watched {
waits.watch = f.outcomes.Changed
}
hearer = &Outcomes{Waits: waits, Node: "g14"}
}
b, _ := json.Marshal(o)
if f.atOnce {
_ = hearer.Heard(event, b)
} else {
// Said after the answer, on the seat's events, as the holder's watch says it.
go func() { _ = hearer.Heard(event, b) }()
}
}
return json.Marshal(reg.MirrorAnswer{Digest: in.Digest, Reference: reg.Seat + "/upstream/" + in.Name + "@" + in.Digest})
}
return nil, fmt.Errorf("no verb %s", key)
}
func (f *fake) run(ctx context.Context, env []string, name string, args ...string) forgekey.Ran {
line := name + " " + strings.Join(args, " ")
f.mu.Lock()
f.calls = append(f.calls, cmdRecord{env: env, name: name, line: line})
f.mu.Unlock()
switch {
case name == "git" && strings.Contains(line, " rev-parse HEAD"):
return forgekey.Ran{Stdout: commitSHA + "\n"}
case name == "buildah" && strings.Contains(line, "--version"):
return forgekey.Ran{Stdout: "buildah version 1.45.1 (image-spec 1.1.0, runtime-spec 1.1.0)\n"}
case name == "buildah" && strings.Contains(line, " bud "):
if f.failBud.Status != 0 || f.failBud.Err != "" {
return f.failBud
}
case name == "buildah" && strings.Contains(line, " images "):
return forgekey.Ran{Stdout: f.digest + "\n"}
case name == "buildah" && strings.Contains(line, " push "):
f.mu.Lock()
defer f.mu.Unlock()
f.pushes++
var digestFile, dir string
for i, a := range args {
if a == "--digestfile" {
digestFile = args[i+1]
}
if strings.HasPrefix(a, "oci:") {
dir = strings.TrimPrefix(a, "oci:")
}
}
f.writeLayout(dir, digestFile)
}
return forgekey.Ran{}
}
func (f *fake) lines() []string {
f.mu.Lock()
defer f.mu.Unlock()
out := []string{}
for _, c := range f.calls {
out = append(out, c.line)
}
return out
}
func (f *fake) called(verb string) []cmdRecord {
f.mu.Lock()
defer f.mu.Unlock()
var out []cmdRecord
for _, c := range f.calls {
if c.name == "buildah" && strings.Contains(c.line, " "+verb+" ") {
out = append(out, c)
}
}
return out
}
// moduleWith is a module on node ace over the fake, with subordinate ranges for its account, and the registry's
// address written where the manifest would bind it.
func moduleWith(t *testing.T, f *fake, states *keptStates) *Module {
t.Helper()
dir := t.TempDir()
write := func(name, body string) string {
p := filepath.Join(dir, name)
if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
t.Fatal(err)
}
return p
}
m := &Module{
Node: "ace", Account: "mesh-build-image", UID: "1234", Home: t.TempDir(), Work: t.TempDir(), Store: t.TempDir(),
Steps: states.putStep, Ctx: context.Background(), Run: f.run, Call: f.call, Outcomes: &Outcomes{Waits: &memWaits{}},
SubUIDFile: write("subuid", "someone:100000:65536\nmesh-build-image:624288:65536\n"),
SubGIDFile: write("subgid", "mesh-build-image:624288:65536\n"),
Tun: write("tun", ""),
MirrorWait: 5 * time.Second,
}
f.outcomes = m.Outcomes
return m
}
func tool(t *testing.T, m *Module, name string) func(map[string]any) (any, error) {
t.Helper()
for _, tl := range m.Tools(m.StepTools()) {
if tl.Name == name {
return tl.Run
}
}
t.Fatalf("no tool %s", name)
return nil
}