jschoubben
bbadbb2af0
mesh/merge-gate head bbadbb2af021 merged into trunk 289bbf68e4f9 — pass: builds mesh-controller → novox; no bus step; the change touches no module of the m…
mesh/repo-check head bbadbb2af021 merged into trunk 289bbf68e4f9 — pass: its merge-check.sh passed
mesh/delivery delivered
mesh/delivery-group group fix/1886-builder-says-references delivered: every member is delivered
mesh/check failed: integration: github.com/novox/mesh-controller/internal/identity.TestACertificateChainsToTheMeshsOwnAuthority: authority_test.go:45:…
The settle read the say from the builder's bucket while the ask read it through builderSaysReferences; where they differed (a test's say against a bus with no bucket) a module was handed back and taken from its key again at every turn, and the look's loop never ended.
244 lines
11 KiB
Go
244 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
|
|
sdkdelivery "git.novox.be/novox/mesh-sdk/go/delivery"
|
|
|
|
"github.com/novox/mesh-controller/internal/builderkeys"
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
)
|
|
|
|
// theBuilderSays sets what the running builder says for one test.
|
|
func theBuilderSays(t *testing.T, says bool, err error) {
|
|
t.Helper()
|
|
was := builderSaysReferences
|
|
builderSaysReferences = func(context.Context) (bool, error) { return says, err }
|
|
t.Cleanup(func() { builderSaysReferences = was })
|
|
}
|
|
|
|
// askingBuildAgent records the modules build-agent is asked for, by path.
|
|
func askingBuildAgent(t *testing.T) *[]string {
|
|
t.Helper()
|
|
var asked []string
|
|
was := askABuild
|
|
askABuild = func(_ context.Context, _ buildSource, path, _ string) (string, error) {
|
|
asked = append(asked, path)
|
|
return "build-9", nil
|
|
}
|
|
t.Cleanup(func() { askABuild = was })
|
|
return &asked
|
|
}
|
|
|
|
// 1886/AC2: while no running builder says it writes references, a walk asks build-agent for a module of its tier, as
|
|
// before R4e, and takes nothing from the builder's key.
|
|
func TestAWalkAsksBuildAgentWhileTheBuilderDoesNotSayItWritesReferences(t *testing.T) {
|
|
theBuilderSays(t, false, nil)
|
|
asked := askingBuildAgent(t)
|
|
p, byName := aWalkOfOne("sudo")
|
|
askModule(t.Context(), p, "sudo", byName)
|
|
s := p.Modules["sudo"]
|
|
if s.Key || s.Build != "build-9" || s.State != "asked" || len(*asked) != 1 {
|
|
t.Fatalf("the module is not asked of build-agent: %+v, asked %v", s, *asked)
|
|
}
|
|
}
|
|
|
|
// 1886/AC3: once a running builder says it writes references, a walk takes the module from the builder's key (ADR
|
|
// 0498 §8) and asks build-agent for nothing.
|
|
func TestAWalkTakesTheKeyOnceTheBuilderSaysItWritesReferences(t *testing.T) {
|
|
theBuilderSays(t, true, nil)
|
|
asked := askingBuildAgent(t)
|
|
p, byName := aWalkOfOne("sudo")
|
|
askModule(t.Context(), p, "sudo", byName)
|
|
if s := p.Modules["sudo"]; !s.Key || s.Build != "" || len(*asked) != 0 {
|
|
t.Fatalf("the module is not taken from its key: %+v, asked %v", s, *asked)
|
|
}
|
|
}
|
|
|
|
// 1886/AC2: a say that cannot be read leaves the module unasked and says why, so the next look asks it: neither path is
|
|
// guessed.
|
|
func TestASayNotReadLeavesTheModuleUnasked(t *testing.T) {
|
|
theBuilderSays(t, false, errors.New("the bus did not answer"))
|
|
asked := askingBuildAgent(t)
|
|
p, byName := aWalkOfOne("sudo")
|
|
askModule(t.Context(), p, "sudo", byName)
|
|
s := p.Modules["sudo"]
|
|
if s.State != "" || s.Key || len(*asked) != 0 || !strings.Contains(s.Why, "the bus did not answer") {
|
|
t.Fatalf("a say not read: %+v, asked %v", s, *asked)
|
|
}
|
|
if got := unaskedOf(*p); len(got) != 1 {
|
|
t.Fatalf("the module is not left for the next look to ask: %v", got)
|
|
}
|
|
}
|
|
|
|
// 1886/AC2: the one function every ask goes through lets build-agent build any module while the builder does not say
|
|
// it writes references, and refuses it again once it does.
|
|
func TestBuildAgentIsAskedForAnyModuleWhileTheBuilderDoesNotSay(t *testing.T) {
|
|
was := askedModuleOf
|
|
t.Cleanup(func() { askedModuleOf = was })
|
|
askedModuleOf = func(_ context.Context, _ buildSource, path string) (string, error) {
|
|
return strings.TrimPrefix(path, "modules/"), nil
|
|
}
|
|
theBuilderSays(t, false, nil)
|
|
if err := onlyTheBuildersOwn(t.Context(), buildSource{Repository: "novox/mesh-catalog", Seat: "git"}, "modules/sudo"); err != nil {
|
|
t.Fatalf("an ask while the builder does not say is refused: %v", err)
|
|
}
|
|
theBuilderSays(t, true, nil)
|
|
if err := onlyTheBuildersOwn(t.Context(), buildSource{Repository: "novox/mesh-catalog", Seat: "git"}, "modules/sudo"); !errors.Is(err, errNotTheBuildersOwn) {
|
|
t.Fatalf("an ask once the builder says is not refused: %v", err)
|
|
}
|
|
}
|
|
|
|
// 1886/AC4: an open walk that waits on a key the running builder cannot reference (done without a reference, as R4e's
|
|
// own walk did in plan-1792707174627079192) is judged again at the next look: the module is handed back unasked, and
|
|
// that look's ask goes to build-agent. With the builder saying it writes references, the same walk keeps waiting.
|
|
func TestAnOpenWalkWaitingOnAnUnreferencedKeyIsAskedOfBuildAgent(t *testing.T) {
|
|
t.Cleanup(func() {
|
|
keyTakes.Lock()
|
|
keyTakes.running, keyTakes.waits, keyTakes.taken = map[string]bool{}, map[string]string{}, map[string]bool{}
|
|
keyTakes.Unlock()
|
|
})
|
|
fp := "src2:" + strings.Repeat("e", 64)
|
|
unreferenced := builderkeys.Key{Module: "sudo", Fingerprint: fp, Found: true, Revision: 1,
|
|
Build: sdkdelivery.BuilderBuild{State: sdkdelivery.BuildDone, Manifest: strings.Repeat("b", 64),
|
|
Artifacts: []sdkdelivery.BuiltArtifact{{Name: "tools", Kind: "bundle", Digest: "sha256:1"}}}}
|
|
walk := func() (*inventory.Plan, map[string]inventory.Entry, planKeysOf) {
|
|
theBuilderSays(t, true, nil)
|
|
p, byName := aWalkOfOne("sudo")
|
|
askModule(t.Context(), p, "sudo", byName)
|
|
keys := planKeysOf{values: map[string]sdkdelivery.Module{"sudo@c0ffee0123456789": {FP2: fp}},
|
|
keys: map[string]builderkeys.Key{"sudo": unreferenced}}
|
|
return p, byName, keys
|
|
}
|
|
take := func(string, sdkdelivery.Module, string) { t.Fatal("an unreferenced key was taken in") }
|
|
records := recordsOf{builds: map[string]inventory.Build{}}
|
|
|
|
// Said: it waits for the reference, as ADR 0498 §8 has it.
|
|
p, _, keys := walk()
|
|
if _, err := settleKeys(t.Context(), records, keys, p, p.Tiers[0], take); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if s := p.Modules["sudo"]; s.State != "asked" || !s.Key || !strings.Contains(s.Why, "waits for the reference") {
|
|
t.Fatalf("with the builder saying, the walk does not wait for the reference: %+v", s)
|
|
}
|
|
|
|
// Not said: handed back, and the next look asks build-agent.
|
|
p, byName, keys := walk()
|
|
theBuilderSays(t, false, nil)
|
|
asked := askingBuildAgent(t)
|
|
changed, err := settleKeys(t.Context(), records, keys, p, p.Tiers[0], take)
|
|
if err != nil || !changed {
|
|
t.Fatalf("the walk was not judged again: %v %v", changed, err)
|
|
}
|
|
s := p.Modules["sudo"]
|
|
if s.Key || s.State != "" || p.State != inventory.PlanBuilding || !strings.Contains(s.Why, "does not say") {
|
|
t.Fatalf("the module is not handed back to be asked of build-agent: %+v %s", s, p.State)
|
|
}
|
|
for _, m := range unaskedOf(*p) {
|
|
askModule(t.Context(), p, m, byName)
|
|
}
|
|
if s := p.Modules["sudo"]; s.Key || s.Build != "build-9" || len(*asked) != 1 {
|
|
t.Fatalf("the next look did not ask build-agent: %+v, asked %v", s, *asked)
|
|
}
|
|
}
|
|
|
|
// 1886/AC4: a key the running builder failed while it does not say it writes references fails no walk: the module is
|
|
// asked of build-agent, whose build is the one delivered.
|
|
func TestAFailedKeyOfABuilderThatDoesNotSayFailsNoWalk(t *testing.T) {
|
|
theBuilderSays(t, true, nil)
|
|
p, byName := aWalkOfOne("sudo")
|
|
askModule(t.Context(), p, "sudo", byName)
|
|
_ = byName
|
|
fp := "src2:" + strings.Repeat("f", 64)
|
|
theBuilderSays(t, false, nil)
|
|
keys := planKeysOf{values: map[string]sdkdelivery.Module{"sudo@c0ffee0123456789": {FP2: fp}},
|
|
keys: map[string]builderkeys.Key{"sudo": {Module: "sudo", Fingerprint: fp, Found: true,
|
|
Build: sdkdelivery.BuilderBuild{State: sdkdelivery.BuildFailed, Error: "not stored: tools: no reference"}}}}
|
|
if _, err := settleKeys(t.Context(), recordsOf{}, keys, p, p.Tiers[0], func(string, sdkdelivery.Module, string) {}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if s := p.Modules["sudo"]; p.State != inventory.PlanBuilding || s.State != "" || s.Key {
|
|
t.Fatalf("a failed key of a builder that does not say failed the walk: %s %q %+v", p.State, p.Note, s)
|
|
}
|
|
}
|
|
|
|
// 1886/AC6 (ADR 0522 §6): the parts that write references, the builder and the build modules, are build-agent's own until
|
|
// R4g: asked of build-agent and never taken from keys they write themselves, whatever the builder says.
|
|
func TestTheReferenceWritersAreAskedOfBuildAgentWhateverTheBuilderSays(t *testing.T) {
|
|
theBuilderSays(t, true, nil)
|
|
asked := askingBuildAgent(t)
|
|
for _, m := range []string{"mesh-build-go", "mesh-build-node", "mesh-build-image", "mesh-delivery-builder"} {
|
|
p, byName := aWalkOfOne(m)
|
|
askModule(t.Context(), p, m, byName)
|
|
if s := p.Modules[m]; s.Key || s.Build != "build-9" {
|
|
t.Errorf("%s is not asked of build-agent: %+v", m, s)
|
|
}
|
|
}
|
|
if len(*asked) != 4 {
|
|
t.Fatalf("build-agent was asked %v", *asked)
|
|
}
|
|
}
|
|
|
|
// 1886 review round 1 (ADR 0522 §2): the guard of the one ask function judges by the say askModule read, never a second
|
|
// read: a second read that fails, or that says otherwise, fails no plan.
|
|
func TestTheAskGuardUsesTheSayTheWalkRead(t *testing.T) {
|
|
was := askedModuleOf
|
|
t.Cleanup(func() { askedModuleOf = was })
|
|
askedModuleOf = func(_ context.Context, _ buildSource, path string) (string, error) {
|
|
return strings.TrimPrefix(path, "modules/"), nil
|
|
}
|
|
reads := 0
|
|
wasSays := builderSaysReferences
|
|
t.Cleanup(func() { builderSaysReferences = wasSays })
|
|
for _, second := range []struct {
|
|
name string
|
|
says bool
|
|
err error
|
|
}{{"a second read that fails", false, errors.New("the bus did not answer")}, {"a say that turned true", true, nil}} {
|
|
reads = 0
|
|
builderSaysReferences = func(context.Context) (bool, error) {
|
|
reads++
|
|
if reads == 1 {
|
|
return false, nil
|
|
}
|
|
return second.says, second.err
|
|
}
|
|
wasAsk := askABuild
|
|
askABuild = func(ctx context.Context, source buildSource, path, _ string) (string, error) {
|
|
if err := onlyTheBuildersOwn(ctx, source, path); err != nil {
|
|
return "", err
|
|
}
|
|
return "build-9", nil
|
|
}
|
|
p, byName := aWalkOfOne("sudo")
|
|
askModule(t.Context(), p, "sudo", byName)
|
|
askABuild = wasAsk
|
|
if s := p.Modules["sudo"]; p.State == inventory.PlanFailed || s.Build != "build-9" || s.Key {
|
|
t.Errorf("%s: the walk %s, the module %+v", second.name, p.State, s)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1886 merge check hang: the look must judge an ask and a settle by one say. A settle that read the say from another
|
|
// source than the ask (the bus's bucket, against the walk's read) handed a module back, the next ask took it from its key
|
|
// again, and the look's loop never ended: walk_from_keys_integration_test hung.
|
|
func TestTheSettleJudgesByTheSameSayAsTheAsk(t *testing.T) {
|
|
theBuilderSays(t, true, nil)
|
|
p, _ := aWalkOfOne("sudo")
|
|
p.Modules["sudo"] = &inventory.PlanModule{}
|
|
askModule(t.Context(), p, "sudo", map[string]inventory.Entry{"sudo": {Source: inventory.Source{Repository: "novox/mesh-catalog", Path: "modules/sudo", Ref: "main"}}})
|
|
fp := "src2:" + strings.Repeat("1", 64)
|
|
keys := planKeysOf{values: map[string]sdkdelivery.Module{"sudo@c0ffee0123456789": {FP2: fp}},
|
|
keys: map[string]builderkeys.Key{"sudo": {Module: "sudo", Fingerprint: fp, Found: true,
|
|
Build: sdkdelivery.BuilderBuild{State: sdkdelivery.BuildBuilding, By: "shanks"}}}}
|
|
if _, err := settleKeys(t.Context(), recordsOf{}, keys, p, p.Tiers[0], func(string, sdkdelivery.Module, string) {}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if s := p.Modules["sudo"]; !s.Key || s.State != "asked" {
|
|
t.Fatalf("the settle judged by another say than the ask's: %+v", s)
|
|
}
|
|
}
|