116 lines
4.2 KiB
Go
116 lines
4.2 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// The shape ADR 0480 clauses 1, 2, 3 and 5 give the bus's manifest: the upstream image by digest, the mesh's two
|
|
// programs mounted read-only under /opt, unpacked by archive resources the container names under restart-on
|
|
// (the node-engine does not look inside a mounted directory), and the container the same one it was.
|
|
func TestTheBussManifestMountsItsProgramsIntoTheUpstreamImage(t *testing.T) {
|
|
raw, err := os.ReadFile("../../module.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var m struct {
|
|
Data struct {
|
|
Own []struct {
|
|
ID string `json:"id"`
|
|
Backup struct {
|
|
Dump string `json:"dump"`
|
|
} `json:"backup"`
|
|
} `json:"own"`
|
|
} `json:"data"`
|
|
Resources []map[string]any `json:"resources"`
|
|
Build struct {
|
|
On any `json:"on"`
|
|
Artifacts []struct {
|
|
Name, Kind, From, Language, System, Binary string
|
|
} `json:"artifacts"`
|
|
} `json:"build"`
|
|
}
|
|
if err := json.Unmarshal(raw, &m); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m.Build.On != nil {
|
|
t.Error("build.on is declared: nothing is built on a base image any more")
|
|
}
|
|
artifacts := map[string]struct{ Name, Kind, From, Language, System, Binary string }{}
|
|
for _, a := range m.Build.Artifacts {
|
|
artifacts[a.Name] = a
|
|
if a.Kind == "image" {
|
|
t.Errorf("artifact %s is an image built from a Dockerfile (ADR 0452)", a.Name)
|
|
}
|
|
}
|
|
if a := artifacts["server"]; a.Kind != "upstream" || !strings.Contains(a.From, "@sha256:") {
|
|
t.Errorf("server is %+v: an upstream image pinned by digest", a)
|
|
}
|
|
if a := artifacts["snapshot"]; a.Kind != "bundle" || a.Language != "go" || a.System != "alpine" ||
|
|
a.From != "cmd/mesh-nats-snapshot" || a.Binary != "mesh-nats-snapshot" {
|
|
t.Errorf("snapshot is %+v: a Go bundle of the module's own package, stamped for alpine", a)
|
|
}
|
|
if a := artifacts["entrypoint"]; a.Kind != "archive" || a.From != "program" {
|
|
t.Errorf("entrypoint is %+v: an archive of program/", a)
|
|
}
|
|
if _, err := os.Stat("../../program/entrypoint.sh"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if _, err := os.Stat("../../Dockerfile"); err == nil {
|
|
t.Error("the Dockerfile is still there")
|
|
}
|
|
|
|
byID := map[string]map[string]any{}
|
|
for _, r := range m.Resources {
|
|
byID[r["id"].(string)] = r
|
|
}
|
|
server := byID["server"]
|
|
if server["name"] != "mesh-broker-nats" || server["artifact"] != "server" {
|
|
t.Errorf("the container is %v on artifact %v: it keeps its name, which the dump and the jails use", server["name"], server["artifact"])
|
|
}
|
|
volumes, _ := server["volumes"].([]any)
|
|
restart, _ := server["restart-on"].([]any)
|
|
for _, p := range []struct{ resource, artifact, mount string }{
|
|
{"program-snapshot", "snapshot", ":/opt/mesh:ro"},
|
|
{"program-entrypoint", "entrypoint", ":/opt/mesh-entrypoint:ro"},
|
|
} {
|
|
r := byID[p.resource]
|
|
if r == nil || r["type"] != "archive" || r["artifact"] != p.artifact {
|
|
t.Errorf("%s is %v: an archive resource unpacking %s", p.resource, r, p.artifact)
|
|
continue
|
|
}
|
|
// Under a directory the module declares (ADR 0030: nothing is mounted from a path no resource covers).
|
|
if dir, _, _ := strings.Cut(strings.TrimPrefix(r["path"].(string), "${dir:"), "}"); !strings.HasPrefix(r["path"].(string), "${dir:") ||
|
|
byID[dir] == nil || byID[dir]["type"] != "directory" {
|
|
t.Errorf("%s is at %v: not under a directory the module declares", p.resource, r["path"])
|
|
}
|
|
mounted := false
|
|
for _, v := range volumes {
|
|
if v == r["path"].(string)+p.mount {
|
|
mounted = true
|
|
}
|
|
}
|
|
if !mounted {
|
|
t.Errorf("%s is not mounted read-only as %s", p.resource, p.mount)
|
|
}
|
|
named := false
|
|
for _, v := range restart {
|
|
named = named || v == p.resource
|
|
}
|
|
if !named {
|
|
t.Errorf("%s is not in the container's restart-on: a new program would leave the old one running", p.resource)
|
|
}
|
|
}
|
|
args, _ := server["args"].([]any)
|
|
if len(args) != 2 || args[0] != "sh" || args[1] != "/opt/mesh-entrypoint/entrypoint.sh" {
|
|
t.Errorf("args are %v: the entrypoint run through sh, so no execute bit is relied on", args)
|
|
}
|
|
for _, d := range m.Data.Own {
|
|
if d.ID == "jetstream" && !strings.Contains(d.Backup.Dump, "docker exec -i mesh-broker-nats /opt/mesh/mesh-nats-snapshot snapshot") {
|
|
t.Errorf("the dump is %q: it calls the mounted program", d.Backup.Dump)
|
|
}
|
|
}
|
|
}
|