mesh-tools
97a2d841c7
The controller plans config, templates and moved providers' provisions, hands bus accounts to the vault and judges the new manifest words, on the feature's SDK and node-engine validator (feature 57, config and provisioning).
283 lines
12 KiB
Go
283 lines
12 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// The case novox/hq issue 153 records: an adopted machine keeps its data where the predecessor put
|
|
// it — a library on its own pool that must never move, a configuration on a second disk owned by
|
|
// whoever the predecessor ran as. A definition may name none of that (ADR 0112); the assignment
|
|
// says it, by the ids the definition declared, and the machine receives concrete paths as always.
|
|
func placeable() Manifest {
|
|
m := mod("arr", nil, nil, nil)
|
|
m.Resources = []map[string]any{
|
|
{"id": "state", "type": "directory", "place": ".", "mode": "0700"},
|
|
{"id": "config", "type": "directory", "mode": "0755", "owner": "1000:1000"},
|
|
{"id": "server", "type": "container", "name": "arr", "image": "arr:1",
|
|
"volumes": []any{"${dir:config}:/config", "${access:series}:/series", "${access:spool}:/downloads:ro"},
|
|
"env": map[string]any{"SPOOL": "${access:spool}"}},
|
|
}
|
|
m.Accesses = []Access{{ID: "series", Mode: AccessReadWrite}, {ID: "spool"}}
|
|
return m
|
|
}
|
|
|
|
func placedBy(values map[string]any) Rendering {
|
|
return Rendering{Settings: SettingsBy{"arr": {LayerOf("node anchor", values)}}}
|
|
}
|
|
|
|
func TestAnAssignmentPlacesDirectoriesAndAccesses(t *testing.T) {
|
|
got, err := Resolve(shelf(placeable()), []string{"arr"}, workstation(), World{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
out, err := got.Declaration(placedBy(map[string]any{
|
|
PlacesSetting: map[string]any{
|
|
"config": map[string]any{"path": "/services/arr/config/", "owner": "1001:2000"},
|
|
},
|
|
AccessesSetting: map[string]any{
|
|
"series": "/storage/media/series",
|
|
"spool": "/storage/downloads",
|
|
},
|
|
}))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
seen := map[string]map[string]any{}
|
|
for _, r := range out {
|
|
seen[r["id"].(string)] = r
|
|
}
|
|
config := seen["arr.config"]
|
|
if config["path"] != "/services/arr/config" || config["owner"] != "1001:2000" {
|
|
t.Fatalf("the placed directory is %v %v; want the assignment's path and owner", config["path"], config["owner"])
|
|
}
|
|
if seen["arr.state"]["path"] != "/var/lib/arr" {
|
|
t.Fatalf("an unplaced directory left the default layout: %v", seen["arr.state"]["path"])
|
|
}
|
|
var accesses []string
|
|
for _, r := range out {
|
|
if r["type"] == "access" {
|
|
accesses = append(accesses, r["path"].(string)+" "+r["mode"].(string))
|
|
}
|
|
}
|
|
if strings.Join(accesses, ",") != "/storage/media/series read-write,/storage/downloads read" {
|
|
t.Fatalf("the accesses reached the machine as %v", accesses)
|
|
}
|
|
server := seen["arr.server"]
|
|
mounts := server["volumes"].([]any)
|
|
if mounts[0] != "/services/arr/config:/config" || mounts[1] != "/storage/media/series:/series" ||
|
|
mounts[2] != "/storage/downloads:/downloads:ro" {
|
|
t.Fatalf("the mounts were not filled with the placed paths: %v", mounts)
|
|
}
|
|
if server["env"].(map[string]any)["SPOOL"] != "/storage/downloads" {
|
|
t.Fatalf("the environment was not filled: %v", server["env"])
|
|
}
|
|
}
|
|
|
|
// An access declared by id and placed by nobody resolves to nowhere, and that is refused with the
|
|
// setting to write — not mounted as the literal, not skipped. The refusal costs the module its
|
|
// place in the declaration, not the machine its declaration (novox/hq ADR 0163, rule 6).
|
|
func TestAnUnplacedAccessIsRefusedByName(t *testing.T) {
|
|
got, err := Resolve(shelf(placeable()), []string{"arr"}, workstation(), World{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
with := placedBy(map[string]any{
|
|
AccessesSetting: map[string]any{"series": "/storage/media/series"},
|
|
})
|
|
composed, err := got.Compose(with)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
why := composed.LeftOut["arr"]
|
|
if why == "" || !strings.Contains(why, `"spool"`) || !strings.Contains(why, AccessesSetting) {
|
|
t.Fatalf("an access nobody placed was not refused by name: %v", composed.LeftOut)
|
|
}
|
|
if _, declared := byID(composed.Resources)["arr.server"]; declared {
|
|
t.Fatal("the module with the unplaced access was declared anyway")
|
|
}
|
|
}
|
|
|
|
// Validated like endpoints: an id the module does not declare reaches nothing, and the refusal
|
|
// says what it does declare; a relative path and a non-numeric owner are refused too.
|
|
func TestPlacementsAreValidated(t *testing.T) {
|
|
m := placeable()
|
|
layers := func(values map[string]any) []Layer { return placedBy(values).Settings["arr"] }
|
|
|
|
_, err := Places(m, layers(map[string]any{PlacesSetting: map[string]any{"data": "/mnt/data"}}))
|
|
if err == nil || !strings.Contains(err.Error(), "does not declare") || !strings.Contains(err.Error(), `"config"`) {
|
|
t.Fatalf("placing an undeclared directory was accepted: %v", err)
|
|
}
|
|
_, err = Places(m, layers(map[string]any{PlacesSetting: map[string]any{"config": "services/arr"}}))
|
|
if err == nil || !strings.Contains(err.Error(), "absolute") {
|
|
t.Fatalf("a relative placement was accepted: %v", err)
|
|
}
|
|
_, err = Places(m, layers(map[string]any{PlacesSetting: map[string]any{
|
|
"config": map[string]any{"path": "/services/arr", "owner": "media"}}}))
|
|
if err == nil || !strings.Contains(err.Error(), "uid:gid") {
|
|
t.Fatalf("a non-numeric owner was accepted: %v", err)
|
|
}
|
|
_, err = AccessPlaces(m, layers(map[string]any{AccessesSetting: map[string]any{"movies": "/storage/media/movies"}}))
|
|
if err == nil || !strings.Contains(err.Error(), "does not declare") || !strings.Contains(err.Error(), `"series"`) {
|
|
t.Fatalf("placing an undeclared access was accepted: %v", err)
|
|
}
|
|
_, err = AccessPlaces(m, layers(map[string]any{AccessesSetting: map[string]any{"series": "media/series"}}))
|
|
if err == nil || !strings.Contains(err.Error(), "absolute") {
|
|
t.Fatalf("a relative access was accepted: %v", err)
|
|
}
|
|
// And the two keys are never stray: they are validated here, not merged into a file.
|
|
if stray := UnusedSettings(m, layers(map[string]any{
|
|
PlacesSetting: map[string]any{"config": "/services/arr/config"},
|
|
AccessesSetting: map[string]any{"series": "/storage/media/series"},
|
|
})); len(stray) != 0 {
|
|
t.Fatalf("the placement keys were reported as unused: %v", stray)
|
|
}
|
|
}
|
|
|
|
// A definition that carries a path still works, as the default the assignment may replace — and
|
|
// the assignment's placement wins where both say.
|
|
func TestADefinitionsPathIsTheDefaultTheAssignmentReplaces(t *testing.T) {
|
|
m := placeable()
|
|
m.Accesses = []Access{{ID: "series", Path: "/services/media/series", Mode: AccessReadWrite}, {ID: "spool", Path: "/services/media/downloads"}}
|
|
got, err := Resolve(shelf(m), []string{"arr"}, workstation(), World{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
out, err := got.Declaration(placedBy(map[string]any{
|
|
PlacesSetting: map[string]any{"config": "/services/arr/config"},
|
|
AccessesSetting: map[string]any{"series": "/storage/media/series"},
|
|
}))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var paths []string
|
|
for _, r := range out {
|
|
if r["type"] == "access" {
|
|
paths = append(paths, r["path"].(string))
|
|
}
|
|
}
|
|
if strings.Join(paths, ",") != "/storage/media/series,/services/media/downloads" {
|
|
t.Fatalf("placed one, defaulted the other: got %v", paths)
|
|
}
|
|
}
|
|
|
|
// A reference to an access the definition does not declare is refused where the author is.
|
|
func TestAnUnknownAccessReferenceIsRefusedAtParse(t *testing.T) {
|
|
_, err := ParseManifest([]byte(`{
|
|
"module": "arr", "version": "1",
|
|
"accesses": [{"id": "series", "mode": "read-write"}],
|
|
"resources": [
|
|
{"id": "state", "type": "directory", "place": ".", "mode": "0700"},
|
|
{"id": "server", "type": "container", "name": "arr", "image": "arr:1",
|
|
"volumes": ["${access:movies}:/movies"]}
|
|
]}`))
|
|
if err == nil || !strings.Contains(err.Error(), "${access:movies}") {
|
|
t.Fatalf("a reference to an undeclared access was accepted: %v", err)
|
|
}
|
|
_, err = ParseManifest([]byte(`{"module": "arr", "version": "1", "accesses": [{"mode": "read"}]}`))
|
|
if err == nil || !strings.Contains(err.Error(), "neither an id nor a path") {
|
|
t.Fatalf("an access with no id and no path was accepted: %v", err)
|
|
}
|
|
}
|
|
|
|
// **Placement is read from the placement, never from a layer's values** (novox/hq ADR 0348 clause 11, issue
|
|
// 651). A `places` or `accesses` among the config values places nothing; the same in Placement does. A
|
|
// mergeable file of today's form still takes every key of the layer as it is said, placement too, so it
|
|
// composes as it did while placement was kept in the layer.
|
|
func TestPlacementIsReadFromThePlacementOnly(t *testing.T) {
|
|
m := placeable()
|
|
said := map[string]any{
|
|
PlacesSetting: map[string]any{"config": "/services/arr/config"},
|
|
AccessesSetting: map[string]any{"series": "/storage/media/series", "spool": "/storage/downloads"},
|
|
"log": "warn",
|
|
}
|
|
among := []Layer{{From: "anchor", Values: said}}
|
|
if placed, err := Places(m, among); err != nil || placed != nil {
|
|
t.Fatalf("a place among the config values placed %v (%v)", placed, err)
|
|
}
|
|
if _, _, err := accessesFor(m, among); err == nil {
|
|
t.Fatal("an access among the config values placed it")
|
|
}
|
|
beside := []Layer{LayerOf("anchor", said)}
|
|
if beside[0].Values["log"] != "warn" || beside[0].Values[PlacesSetting] != nil || beside[0].Placement[PlacesSetting] == nil {
|
|
t.Fatalf("LayerOf split %+v", beside[0])
|
|
}
|
|
if placed, err := Places(m, beside); err != nil || placed["config"].Path != "/services/arr/config" {
|
|
t.Fatalf("the placement did not place: %v (%v)", placed, err)
|
|
}
|
|
|
|
file := map[string]any{"id": "runtime", "type": "file", "path": "/x", "content": `{"a":1}`, "merge": "json"}
|
|
whole, err := ApplySettings(file, among)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
split, err := ApplySettings(file, beside)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if whole["content"] != split["content"] || !strings.Contains(split["content"].(string), `"places"`) {
|
|
t.Fatalf("today's mergeable file composes %q, was %q", split["content"], whole["content"])
|
|
}
|
|
}
|
|
|
|
// **The four words of where an assignment is reached are placement too** (novox/hq ADR 0348 clause 11, issue 736).
|
|
// `endpoints`, `expose`, `reach` and `ports` among a layer's config values say nothing to the filter, the ports or
|
|
// the names; the same in Placement do, and LayerOf puts them there. A mergeable file of today's form still takes
|
|
// every key of the layer as it is said, so it composes as it did while they were kept among the values.
|
|
func TestTheFourWordsAreReadFromThePlacementOnly(t *testing.T) {
|
|
m := Manifest{Module: "forge", Version: "1",
|
|
Listens: []Listening{{Name: "web", Port: 3000, Protocol: "tcp", From: FromMesh}, {Name: "ssh", Port: 22, Protocol: "tcp", From: FromMesh},
|
|
{Name: "api", Port: 8086, Protocol: "tcp", From: FromMesh}},
|
|
Resources: []map[string]any{{"id": "server", "type": "container", "image": "x", "ports": []any{"3000", "222:22", "8086"}}}}
|
|
said := map[string]any{
|
|
ExposeSetting: map[string]any{"22": FromEverywhere},
|
|
PortsSetting: map[string]any{"22": float64(2222)},
|
|
ReachSetting: map[string]any{"3000": "internal"},
|
|
EndpointsSetting: map[string]any{"api": map[string]any{"label": "influx", "port": float64(18086), "reach": "public"}},
|
|
"log": "warn",
|
|
}
|
|
among := []Layer{{From: "anchor", Values: said}}
|
|
if e, err := Exposure(m, among); err != nil || e != nil {
|
|
t.Fatalf("an expose among the config values exposed %v (%v)", e, err)
|
|
}
|
|
if g, err := GivenPorts(m, among); err != nil || g != nil {
|
|
t.Fatalf("a ports among the config values gave %v (%v)", g, err)
|
|
}
|
|
if r, err := Reaches(m, among); err != nil || r != nil {
|
|
t.Fatalf("a reach among the config values reached %v (%v)", r, err)
|
|
}
|
|
if b, err := Endpoints(m, among); err != nil || len(b) != 0 {
|
|
t.Fatalf("an endpoints among the config values configured %v (%v)", b, err)
|
|
}
|
|
|
|
beside := []Layer{LayerOf("anchor", said)}
|
|
if len(beside[0].Values) != 1 || beside[0].Values["log"] != "warn" || len(beside[0].Placement) != 4 {
|
|
t.Fatalf("LayerOf split %+v", beside[0])
|
|
}
|
|
if e, err := Exposure(m, beside); err != nil || e[22] != FromEverywhere {
|
|
t.Fatalf("the placement did not expose: %v (%v)", e, err)
|
|
}
|
|
if g, err := GivenPorts(m, beside); err != nil || g[22] != 2222 || g[8086] != 18086 {
|
|
t.Fatalf("the placement did not give the ports: %v (%v)", g, err)
|
|
}
|
|
if r, err := Reaches(m, beside); err != nil || r[3000] != "internal" || r[8086] != "public" {
|
|
t.Fatalf("the placement did not reach: %v (%v)", r, err)
|
|
}
|
|
if b, err := Endpoints(m, beside); err != nil || b["api"].Label != "influx" {
|
|
t.Fatalf("the placement did not configure the endpoint: %v (%v)", b, err)
|
|
}
|
|
|
|
file := map[string]any{"id": "runtime", "type": "file", "path": "/x", "content": `{"a":1}`, "merge": "json"}
|
|
whole, err := ApplySettings(file, among)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
split, err := ApplySettings(file, beside)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if whole["content"] != split["content"] || !strings.Contains(split["content"].(string), `"endpoints"`) {
|
|
t.Fatalf("today's mergeable file composes %q, was %q", split["content"], whole["content"])
|
|
}
|
|
}
|