jochen
b98fd0f396
A module could say nothing about what ready means for what it runs, so a web application with its port open and its requests hanging passed everything for eleven hours (issue 145). A long-running resource now carries `health` — the image's own check adopted by name, http, tcp, exec, unit or a module's own tool, with its timing — refused near its author when it names a port or an address, an endpoint the module does not declare, a tool it does not serve, a tool check alone, or a timing outside the record's bounds. It is composed with the endpoint as the port this machine published it on, and sent only to a node-engine whose statement says it reads it: an older one would refuse the whole declaration. The engine is granted its own machine's instance of each health tool. `module check` warns of every long-running resource without `health`, counts them for the catalogue, and refuses them from 2026-11-18. A check's findings stay out of a condition's summary. The node-engine's validator is vendored at its Phase B commit, so what is composed is judged by the words the engine takes.
218 lines
11 KiB
Go
218 lines
11 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/novox/mesh-host/validate"
|
|
)
|
|
|
|
// A module says how each long-running resource is ready (novox/hq ADR 0240 rule 2, to-be 48 §8): `module
|
|
// check` refuses each part out of its bounds, each endpoint named by a port or an address, a tool the
|
|
// module does not serve, and a tool check alone — a test per refusal.
|
|
|
|
const healthDigest = "@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
|
|
// healthManifest is a module of one web container, one running service and one step, with the health
|
|
// given on the container (or on the resource named by on).
|
|
func healthManifest(t *testing.T, on string, health map[string]any, more ...map[string]any) []byte {
|
|
t.Helper()
|
|
resources := []map[string]any{
|
|
{"id": "server", "type": "container", "name": "app-server", "image": "registry.example/app" + healthDigest,
|
|
"ports": []any{"8080"}},
|
|
{"id": "daemon", "type": "service", "unit": "app.service", "state": "running"},
|
|
{"id": "seed", "type": "container", "name": "app-seed", "image": "registry.example/app" + healthDigest,
|
|
"run-once": true},
|
|
{"id": "sweep", "type": "container", "name": "app-sweep", "image": "registry.example/app" + healthDigest,
|
|
"schedule": "0 3 * * *"},
|
|
}
|
|
resources = append(resources, more...)
|
|
for _, r := range resources {
|
|
if r["id"] == on && health != nil {
|
|
r["health"] = health
|
|
}
|
|
}
|
|
m := map[string]any{"module": "app", "requires": []any{"postgres-database"}, "tools": []any{"app_status"},
|
|
"listens": []any{
|
|
map[string]any{"name": "web", "port": 8080, "from": "mesh"},
|
|
map[string]any{"name": "beacon", "port": 9999, "protocol": "udp", "from": "mesh"},
|
|
},
|
|
"resources": resources}
|
|
raw, err := json.Marshal(m)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return raw
|
|
}
|
|
|
|
func TestAWellFormedHealthIsAccepted(t *testing.T) {
|
|
for _, h := range []map[string]any{
|
|
{"kind": "http", "endpoint": "web", "path": "/healthz", "status": 200, "body": "ok", "needs": "postgres-database"},
|
|
{"kind": "tcp", "endpoint": "web", "interval": "10s", "timeout": "2s", "looks": 2, "grace": "0s"},
|
|
{"kind": "runtime"},
|
|
{"kind": "exec", "command": "pg_isready -q", "grace": "4m", "looks": 2, "interval": "30s"},
|
|
} {
|
|
if _, err := ParseManifest(healthManifest(t, "server", h)); err != nil {
|
|
t.Errorf("%v was refused: %v", h, err)
|
|
}
|
|
}
|
|
if _, err := ParseManifest(healthManifest(t, "daemon", map[string]any{"kind": "unit"})); err != nil {
|
|
t.Errorf("a service's own readiness was refused: %v", err)
|
|
}
|
|
// A tool beside a check of another kind on the module.
|
|
raw := healthManifest(t, "server", map[string]any{"kind": "http", "endpoint": "web"},
|
|
map[string]any{"id": "admin", "type": "service", "unit": "app-admin.service", "state": "running",
|
|
"health": map[string]any{"kind": "tool", "tool": "app_status"}})
|
|
if _, err := ParseManifest(raw); err != nil {
|
|
t.Errorf("a tool check beside an http check was refused: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestEveryOutOfBoundsHealthIsRefusedByName(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
on string
|
|
health map[string]any
|
|
says string
|
|
}{
|
|
{"no kind", "server", map[string]any{"endpoint": "web"}, "with no kind"},
|
|
{"an unknown kind", "server", map[string]any{"kind": "ping"}, `of kind "ping"`},
|
|
{"a port", "server", map[string]any{"kind": "tcp", "port": 8080}, "names a port"},
|
|
{"an address", "server", map[string]any{"kind": "http", "endpoint": "web", "address": "127.0.0.1"}, "names a address"},
|
|
{"a url", "server", map[string]any{"kind": "http", "url": "http://localhost:8080/"}, "names a url"},
|
|
{"an unknown key", "server", map[string]any{"kind": "tcp", "endpoint": "web", "retries": 3}, `"retries"`},
|
|
{"no endpoint", "server", map[string]any{"kind": "http"}, "names no endpoint"},
|
|
{"an undeclared endpoint", "server", map[string]any{"kind": "tcp", "endpoint": "admin"}, "does not declare"},
|
|
{"a udp endpoint", "server", map[string]any{"kind": "tcp", "endpoint": "beacon"}, "a check connects over tcp"},
|
|
{"an interval under the floor", "server", map[string]any{"kind": "tcp", "endpoint": "web", "interval": "5s", "timeout": "1s"}, "no more often than every 10s"},
|
|
{"a timeout of the interval", "server", map[string]any{"kind": "tcp", "endpoint": "web", "interval": "10s", "timeout": "10s"}, "under its interval"},
|
|
{"one failing look", "server", map[string]any{"kind": "tcp", "endpoint": "web", "looks": 1}, "at least 2"},
|
|
{"a grace and looks past five minutes", "server", map[string]any{"kind": "tcp", "endpoint": "web", "grace": "4m", "looks": 3, "interval": "30s"}, "at most 5m0s"},
|
|
{"a duration that is not one", "server", map[string]any{"kind": "tcp", "endpoint": "web", "interval": "often"}, "is a duration"},
|
|
{"looks that are not a number", "server", map[string]any{"kind": "tcp", "endpoint": "web", "looks": "three"}, "whole number"},
|
|
{"a path without a slash", "server", map[string]any{"kind": "http", "endpoint": "web", "path": "health"}, "starts with /"},
|
|
{"a status that is not one", "server", map[string]any{"kind": "http", "endpoint": "web", "status": 700}, "is not one"},
|
|
{"a scheme that is not one", "server", map[string]any{"kind": "http", "endpoint": "web", "scheme": "ftp"}, "http or https"},
|
|
{"a status on a tcp check", "server", map[string]any{"kind": "tcp", "endpoint": "web", "status": 200}, "only an http check has"},
|
|
{"an exec with no command", "server", map[string]any{"kind": "exec"}, "says no command"},
|
|
{"a command on an http check", "server", map[string]any{"kind": "http", "endpoint": "web", "command": "true"}, "only an exec check runs"},
|
|
{"a runtime check on a service", "daemon", map[string]any{"kind": "runtime"}, "only a container has"},
|
|
{"a unit check on a container", "server", map[string]any{"kind": "unit"}, "a service's or a process's"},
|
|
{"a tool the module does not serve", "server", map[string]any{"kind": "tool", "tool": "app_admin"}, "does not serve"},
|
|
{"a tool check alone", "server", map[string]any{"kind": "tool", "tool": "app_status"}, "judges itself only by its own tool"},
|
|
{"needs not required", "server", map[string]any{"kind": "tcp", "endpoint": "web", "needs": "redis"}, "does not require"},
|
|
{"health on a step", "seed", map[string]any{"kind": "runtime"}, "does not stay up"},
|
|
{"health on a schedule", "sweep", map[string]any{"kind": "runtime"}, "does not stay up"},
|
|
{"health that is not an object", "server", nil, "is an object"},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
raw := healthManifest(t, c.on, c.health)
|
|
if c.health == nil {
|
|
raw = []byte(strings.Replace(string(raw), `"name":"app-server"`, `"name":"app-server","health":"tcp"`, 1))
|
|
}
|
|
_, err := ParseManifest(raw)
|
|
if err == nil {
|
|
t.Fatalf("%s was accepted", c.name)
|
|
}
|
|
if !strings.Contains(err.Error(), c.says) {
|
|
t.Errorf("refused, but not for saying %q: %v", c.says, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHealthIsComposedAsThePortThisMachineGaveTheEndpoint(t *testing.T) {
|
|
m, err := ParseManifest(healthManifest(t, "server", map[string]any{"kind": "http", "endpoint": "web", "path": "/healthz",
|
|
"needs": "postgres-database"}))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
compose := func(with Rendering) map[string]any {
|
|
out, err := Resolution{Node: "laptop", Modules: []Manifest{m}}.Declaration(with)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
at := indexOfID(out, "app.server")
|
|
if at < 0 {
|
|
t.Fatal("the container was lost")
|
|
}
|
|
return out[at]
|
|
}
|
|
// An engine older than the field is not sent it: it would refuse the whole declaration.
|
|
if h, sent := compose(Rendering{Ports: map[string]map[int]int{"app": {8080: 31001}}})["health"]; sent {
|
|
t.Fatalf("health was sent to an engine that does not read it: %v", h)
|
|
}
|
|
got := compose(Rendering{ReadsHealth: true, Ports: map[string]map[int]int{"app": {8080: 31001}}})["health"].(map[string]any)
|
|
if got["port"] != 31001 || got["endpoint"] != "web" || got["path"] != "/healthz" || got["needs"] != "postgres-database" {
|
|
t.Errorf("composed as %v", got)
|
|
}
|
|
if got["interval"] != "30s" || got["timeout"] != "5s" || got["looks"] != 3 || got["grace"] != "1m0s" {
|
|
t.Errorf("the defaults were not written out: %v", got)
|
|
}
|
|
// The port this machine gives the endpoint moves, and the check moves with it.
|
|
moved := compose(Rendering{ReadsHealth: true, Ports: map[string]map[int]int{"app": {8080: 31002}}})["health"].(map[string]any)
|
|
if moved["port"] != 31002 {
|
|
t.Errorf("after the port moved the check still dials %v", moved["port"])
|
|
}
|
|
// And the catalogue's manifest is untouched by composing it.
|
|
if _, ok := m.Resources[0]["health"].(map[string]any)["port"]; ok {
|
|
t.Error("composing wrote the port into the catalogue's own manifest")
|
|
}
|
|
}
|
|
|
|
func TestTheUndeclaredAreTheLongRunningWithoutHealth(t *testing.T) {
|
|
m, err := ParseManifest(healthManifest(t, "server", map[string]any{"kind": "runtime"}))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := strings.Join(Undeclared(m), ","); got != "daemon" {
|
|
t.Errorf("undeclared: %q; the step and the schedule are not long-running, the server declares", got)
|
|
}
|
|
}
|
|
|
|
func TestATooledHealthIsGrantedToTheEngine(t *testing.T) {
|
|
raw := healthManifest(t, "server", map[string]any{"kind": "http", "endpoint": "web"},
|
|
map[string]any{"id": "admin", "type": "service", "unit": "app-admin.service", "state": "running",
|
|
"health": map[string]any{"kind": "tool", "tool": "app_status"}})
|
|
m, err := ParseManifest(raw)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := HealthChecks(m); len(got) != 1 || got[0] != "app.app_status" {
|
|
t.Errorf("checks %v", got)
|
|
}
|
|
}
|
|
|
|
// What the controller composes the node-engine takes: every kind, composed for an engine that reads it,
|
|
// passes the engine's own validator (mesh-host/validate) — one set of words on both sides.
|
|
func TestEveryComposedHealthIsOneTheNodeEngineTakes(t *testing.T) {
|
|
for _, h := range []map[string]any{
|
|
{"kind": "http", "endpoint": "web", "path": "/healthz", "status": 200, "body": "ok", "needs": "postgres-database"},
|
|
{"kind": "tcp", "endpoint": "web", "interval": "10s", "timeout": "2s", "looks": 2, "grace": "0s"},
|
|
{"kind": "runtime"},
|
|
{"kind": "exec", "command": "pg_isready -q"},
|
|
} {
|
|
m, err := ParseManifest(healthManifest(t, "server", h,
|
|
map[string]any{"id": "admin", "type": "service", "unit": "app-admin.service", "state": "running",
|
|
"health": map[string]any{"kind": "tool", "tool": "app_status"}}))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m.Resources[1]["health"] = map[string]any{"kind": "unit"}
|
|
out, err := Resolution{Node: "laptop", Modules: []Manifest{m}}.Declaration(Rendering{ReadsHealth: true,
|
|
Ports: map[string]map[int]int{"app": {8080: 31001}}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
body, err := json.Marshal(map[string]any{"declaration": validate.Version, "resources": out})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if problems := validate.Declaration(body); len(problems) > 0 {
|
|
t.Errorf("%v composed into something the node-engine refuses: %v", h, problems)
|
|
}
|
|
}
|
|
}
|