mesh-admin
b654b320a1
mesh/merge-gate head b654b320a18a merged into trunk 584aa2d7d7a5 — pass: builds build-agent, mesh-controller → ace, g14, novox, shanks; no bus step; every …
mesh/repo-check head b654b320a18a merged into trunk 584aa2d7d7a5 — pass: its merge-check.sh passed
mesh/delivery delivered
The resolver follows ADR 0303, but four comments still stated ADR 0210's retired rule that two modules declaring one package collide, and an agent took them as the rule. What stays exclusive is what a module owns: a path, a unit, a name, and a package declared present by one module and absent by another.
86 lines
3.4 KiB
Go
86 lines
3.4 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// novox/hq issue 190, step 5 (ADR 0222): what the mesh computes for a module is held to the rule
|
|
// every module is — no two modules on a machine declare one path, unit or name (a package may be declared by
|
|
// several, novox/hq ADR 0303). The
|
|
// private network once declared the container runtime's file and service beside the runtime's own
|
|
// module, and nothing refused it, because the collision check only ever saw catalogue manifests.
|
|
|
|
func runtimesOwn() Manifest {
|
|
return Manifest{Module: "docker", Resources: []map[string]any{
|
|
{"id": "daemon", "type": "file", "path": "/etc/docker/daemon.json", "into": "json",
|
|
"content": `{"live-restore": true}`},
|
|
{"id": "runtime", "type": "service", "unit": "docker.service", "state": "running",
|
|
"reload-on": []any{"daemon"}},
|
|
}}
|
|
}
|
|
|
|
func TestAGeneratedResourceCollidingWithAModulesIsRefused(t *testing.T) {
|
|
r := Resolution{Node: "workstation", Modules: []Manifest{
|
|
{Module: "mesh-network", Computed: "mesh-network", Provides: Offers("private-network")},
|
|
runtimesOwn(),
|
|
}}
|
|
_, err := r.Declaration(Rendering{Generators: map[string]Generator{"mesh-network": reloading{}}})
|
|
if err == nil {
|
|
t.Fatal("a generated resource declaring the runtime's file beside the runtime's module was accepted")
|
|
}
|
|
for _, want := range []string{"mesh-network", "docker", "/etc/docker/daemon.json", "docker.service"} {
|
|
if !strings.Contains(err.Error(), want) {
|
|
t.Errorf("the refusal does not name %s: %v", want, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAGeneratedResourceBesideAModulesOwnIsComposed(t *testing.T) {
|
|
r := Resolution{Node: "workstation", Modules: []Manifest{
|
|
{Module: "mesh-network", Computed: "mesh-network", Provides: Offers("private-network")},
|
|
runtimesOwn(),
|
|
}}
|
|
gen := &fake{on: map[string]bool{"workstation": true}}
|
|
out, err := r.Declaration(Rendering{Generators: map[string]Generator{"mesh-network": gen}})
|
|
if err != nil {
|
|
t.Fatalf("disjoint resources were refused: %v", err)
|
|
}
|
|
if fileNamed(out, "docker.daemon") == nil {
|
|
t.Fatalf("the runtime's own file is missing: %v", out)
|
|
}
|
|
// And a machine not on the network yet generates nothing, which collides with nothing.
|
|
if _, err := r.Declaration(Rendering{Generators: map[string]Generator{"mesh-network": &fake{}}}); err != nil {
|
|
t.Fatalf("a machine off the network was refused: %v", err)
|
|
}
|
|
}
|
|
|
|
// The catalogue's container runtime module states the mesh's registry itself (ADR 0222).
|
|
func TestTheRuntimesModuleTrustsTheMeshsRegistry(t *testing.T) {
|
|
docker := catalogueManifest(t, "docker")
|
|
r := Resolution{Node: "workstation", Modules: []Manifest{docker}}
|
|
out, err := r.Declaration(Rendering{
|
|
SeatReach: map[string]string{"mesh-artifact-store": "anchor.internal:5100"},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
daemon := fileNamed(out, "docker.daemon")
|
|
if daemon == nil || daemon["into"] != "json" {
|
|
t.Fatalf("the runtime's file is not written into: %v", daemon)
|
|
}
|
|
content, _ := daemon["content"].(string)
|
|
if !strings.Contains(content, `"insecure-registries": ["anchor.internal:5100"]`) ||
|
|
!strings.Contains(content, `"live-restore": true`) {
|
|
t.Fatalf("the runtime's file says %q", content)
|
|
}
|
|
|
|
out, err = r.Declaration(Rendering{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if content, _ := fileNamed(out, "docker.daemon")["content"].(string); strings.Contains(content, "insecure-registries") {
|
|
t.Fatalf("with no store on the network, the runtime is told %q", content)
|
|
}
|
|
}
|