jschoubben
9372733861
The first want at the switch skips the record hold only where it changes nothing on the node. A slice differing only in the bus's user list is marked user-list-only, so no yes waits on it at the switch; any other change at the same fingerprint is judged as any move, against the declaration's digest.
213 lines
12 KiB
Go
213 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
|
|
sdkdelivery "git.novox.be/novox/mesh-sdk/go/delivery"
|
|
|
|
"github.com/novox/mesh-controller/internal/link"
|
|
)
|
|
|
|
// mailOn is a composition of mesh-mail on ace at fingerprint c, from the given resources, each saying its module.
|
|
func mailOn(t *testing.T, c byte, data bool, resources ...string) sdkdelivery.Composed {
|
|
t.Helper()
|
|
out := sdkdelivery.Composed{Node: "ace", Module: "mesh-mail", FP: sdkdelivery.SourcePrefix2 + strings.Repeat(string(c), 64), Data: data}
|
|
for _, r := range resources {
|
|
out.Resources = append(out.Resources, json.RawMessage(r))
|
|
}
|
|
return out
|
|
}
|
|
|
|
const (
|
|
mailContainer = `{"id":"mesh-mail.server","type":"container","module":"mesh-mail","name":"mail","image":"mail@sha256:1111111111111111111111111111111111111111111111111111111111111111","volumes":["/var/lib/mesh-mail/spool:/spool"]}`
|
|
mailContainer2 = `{"id":"mesh-mail.server","type":"container","module":"mesh-mail","name":"mail","image":"mail@sha256:2222222222222222222222222222222222222222222222222222222222222222","volumes":["/var/lib/mesh-mail/spool:/spool"]}`
|
|
mailSpool = `{"id":"mesh-mail.spool","type":"directory","module":"mesh-mail","path":"/var/lib/mesh-mail/spool"}`
|
|
mailSpoolMoved = `{"id":"mesh-mail.spool","type":"directory","module":"mesh-mail","path":"/srv/mesh-mail/spool"}`
|
|
mailTools = `{"id":"mesh-mail.tools","type":"file","module":"mesh-mail","path":"/usr/lib/mesh-mail/tools.json","content":"a"}`
|
|
mailTools2 = `{"id":"mesh-mail.tools","type":"file","module":"mesh-mail","path":"/usr/lib/mesh-mail/tools.json","content":"b"}`
|
|
mailConfig = `{"id":"mesh-mail.conf","type":"file","module":"mesh-mail","path":"/var/lib/mesh-mail/spool/conf","content":"a"}`
|
|
mailConfig2 = `{"id":"mesh-mail.conf","type":"file","module":"mesh-mail","path":"/var/lib/mesh-mail/spool/conf","content":"b"}`
|
|
)
|
|
|
|
// 1945/AC12: captured pairs of compositions are judged by ADR 0377 §3's tests: a changed container recreates; with no
|
|
// container changed, a directory moved, a file within the data a container mounts changed, or the data declaration
|
|
// changed moves data; a tools file nothing mounts changed is neither.
|
|
func TestAMoveIsJudgedByWhatItRecreatesOrMoves(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
from, to sdkdelivery.Composed
|
|
want sdkdelivery.Judgement
|
|
}{
|
|
{"a new image", mailOn(t, 'a', true, mailContainer, mailSpool, mailTools), mailOn(t, 'b', true, mailContainer2, mailSpool, mailTools), sdkdelivery.JudgedRecreates},
|
|
{"a container gone", mailOn(t, 'a', true, mailContainer, mailSpool), mailOn(t, 'b', true, mailSpool), sdkdelivery.JudgedRecreates},
|
|
{"its spool moved", mailOn(t, 'a', true, mailContainer, mailSpool), mailOn(t, 'b', true, mailContainer, mailSpoolMoved), sdkdelivery.JudgedMovesData},
|
|
{"a file in its spool", mailOn(t, 'a', true, mailContainer, mailSpool, mailConfig), mailOn(t, 'b', true, mailContainer, mailSpool, mailConfig2), sdkdelivery.JudgedMovesData},
|
|
{"its data declaration", mailOn(t, 'a', false, mailContainer, mailSpool), mailOn(t, 'b', true, mailContainer, mailSpool), sdkdelivery.JudgedMovesData},
|
|
{"its tools only", mailOn(t, 'a', true, mailContainer, mailSpool, mailTools), mailOn(t, 'b', true, mailContainer, mailSpool, mailTools2), sdkdelivery.JudgedNeither},
|
|
}
|
|
for _, c := range cases {
|
|
if got, words := judged(c.from, c.to); got != c.want || words == "" {
|
|
t.Errorf("%s: judged %s (%q), want %s", c.name, got, words, c.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1945/AC12: a move is judged against the composition the node's have names: one the node never ran is neither; one
|
|
// whose composition is gone cannot be judged and says why; and with A running, B held and C composed, C is judged
|
|
// against A, and judged again when the have changes.
|
|
func TestAMoveIsJudgedAgainstWhatTheNodeRuns(t *testing.T) {
|
|
at, _, _, haves := aPlace(t, "ace")
|
|
ctx := context.Background()
|
|
a := mailOn(t, 'a', true, mailContainer, mailSpool, mailTools)
|
|
b := mailOn(t, 'b', true, mailContainer2, mailSpool, mailTools)
|
|
c := mailOn(t, 'c', true, mailContainer, mailSpool, mailTools2)
|
|
write := func(comp sdkdelivery.Composed) (string, string) {
|
|
key, _ := sdkdelivery.ComposedKey("ace", comp.Module, comp.FP)
|
|
if _, err := writeComposed(ctx, at, key, comp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
d, _ := sdkdelivery.ComposedDigestOf(comp)
|
|
return key, d
|
|
}
|
|
judgedNow := func(key string) sdkdelivery.ComposedDigest {
|
|
e, err := at.digests.Get(ctx, key)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
v, err := sdkdelivery.DecodeComposedDigest(e.Value())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return v
|
|
}
|
|
keyA, digestA := write(a)
|
|
if v := judgedNow(keyA); v.Judgement != sdkdelivery.JudgedNeither || v.Against != "" {
|
|
t.Errorf("a module the node never ran: %+v", v)
|
|
}
|
|
if v := judgedNow(keyA); v.Policy != "roll" || v.PolicyFrom != "default" {
|
|
t.Errorf("the policy beside the judgement: %+v", v)
|
|
}
|
|
haves["mesh-mail"] = sdkdelivery.Have{FP: a.FP, Composed: digestA, Phase: sdkdelivery.PhaseRunning, Health: sdkdelivery.HealthOK}
|
|
keyB, _ := write(b)
|
|
if v := judgedNow(keyB); v.Judgement != sdkdelivery.JudgedRecreates || v.Against != digestA {
|
|
t.Errorf("B against A: %+v", v)
|
|
}
|
|
// B is held (the assigner writes no want for it); the node still runs A.
|
|
keyC, digestC := write(c)
|
|
if v := judgedNow(keyC); v.Judgement != sdkdelivery.JudgedNeither || v.Against != digestA {
|
|
t.Errorf("C against A, B held: %+v", v)
|
|
}
|
|
// The have changes to C: every judgement of the module is written again, against what runs now (the have watch).
|
|
haves["mesh-mail"] = sdkdelivery.Have{FP: c.FP, Composed: digestC, Phase: sdkdelivery.PhaseRunning, Health: sdkdelivery.HealthOK}
|
|
if n, err := rejudge(ctx, at, "mesh-mail"); err != nil || n == 0 {
|
|
t.Fatalf("rejudged %d (%v)", n, err)
|
|
}
|
|
if v := judgedNow(keyC); v.Against != digestC || v.Judgement != sdkdelivery.JudgedNeither {
|
|
t.Errorf("C once the node runs it: %+v", v)
|
|
}
|
|
if v := judgedNow(keyB); v.Against != digestC || v.Judgement != sdkdelivery.JudgedRecreates {
|
|
t.Errorf("B once the node runs C: %+v", v)
|
|
}
|
|
// A person sets the module's policy: written beside every composition of it.
|
|
at.policy = func(string) (string, string, string) { return "record", "person", "its spool" }
|
|
if _, err := rejudge(ctx, at, "mesh-mail"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if v := judgedNow(keyB); v.Policy != "record" || v.PolicyFrom != "person" || v.PolicyWhy != "its spool" {
|
|
t.Errorf("the person's policy beside B: %+v", v)
|
|
}
|
|
// A have naming a composition the buckets no longer hold.
|
|
haves["mesh-mail"] = sdkdelivery.Have{FP: sdkdelivery.SourcePrefix2 + strings.Repeat("9", 64), Composed: "sha256:" + strings.Repeat("9", 64),
|
|
Phase: sdkdelivery.PhaseRunning, Health: sdkdelivery.HealthOK}
|
|
write(b)
|
|
if v := judgedNow(keyB); v.Judgement != sdkdelivery.JudgedCannot || !strings.Contains(v.Words, "gone") {
|
|
t.Errorf("against a composition that is gone: %+v", v)
|
|
}
|
|
}
|
|
|
|
const (
|
|
busServer = `{"id":"nats.server","type":"container","module":"nats","name":"nats","image":"nats@sha256:4444444444444444444444444444444444444444444444444444444444444444"}`
|
|
busServer2 = `{"id":"nats.server","type":"container","module":"nats","name":"nats","image":"nats@sha256:5555555555555555555555555555555555555555555555555555555555555555"}`
|
|
busUsers = `{"id":"nats.bus-users","type":"file","module":"nats","path":"/etc/nats/users.conf","content":"users: [a]"}`
|
|
busUsers2 = `{"id":"nats.bus-users","type":"file","module":"nats","path":"/etc/nats/users.conf","content":"users: [a, b]"}`
|
|
)
|
|
|
|
// busOn is a composition of the bus on ace from the given resources.
|
|
func busOn(t *testing.T, resources ...string) sdkdelivery.Composed {
|
|
t.Helper()
|
|
out := sdkdelivery.Composed{Node: "ace", Module: "nats", FP: sdkdelivery.SourcePrefix2 + strings.Repeat("b", 64)}
|
|
for _, r := range resources {
|
|
out.Resources = append(out.Resources, json.RawMessage(r))
|
|
}
|
|
return out
|
|
}
|
|
|
|
// ADR 0540 clause 9: a have that names no composition, only a fingerprint (the switch: the node runs the declaration it
|
|
// last applied), is judged against the module's slice of that declaration, read from the kept stream of declarations:
|
|
// an equal slice is unchanged; a slice differing only in the bus's user list is that (round 1's A2, so no yes waits on it at the switch); a changed setting is judged as any move; no declaration to read cannot be judged.
|
|
func TestAHaveWithNoCompositionIsJudgedAgainstTheLastDeclaration(t *testing.T) {
|
|
ctx := context.Background()
|
|
other := `{"id":"mesh-calendar.server","type":"container","module":"mesh-calendar","name":"calendar","image":"cal@sha256:3333333333333333333333333333333333333333333333333333333333333333"}`
|
|
unsaid := `{"id":"mesh-mail.tools","type":"file","path":"/usr/lib/mesh-mail/tools.json","content":"a"}`
|
|
declared := func(resources ...string) []byte {
|
|
body, err := json.Marshal(map[string]any{"node": "ace", "resources": json.RawMessage("[" + strings.Join(resources, ",") + "]")})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
signed, err := json.Marshal(link.Signed{Declaration: body, Signature: []byte("s")}) // as link.Envelope sent it
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return signed
|
|
}
|
|
cases := []struct {
|
|
name string
|
|
last []byte // the node's last declaration on the stream; nil when there is none
|
|
to sdkdelivery.Composed
|
|
want sdkdelivery.Judgement
|
|
inWords string
|
|
userList bool
|
|
}{
|
|
{"an equal slice", declared(mailContainer, other, mailSpool, mailTools), mailOn(t, 'b', true, mailContainer, mailSpool, mailTools), sdkdelivery.JudgedUnchanged, "last applied", false},
|
|
{"a declared resource saying no module is not equal", declared(mailContainer, other, mailSpool, unsaid), mailOn(t, 'b', true, mailContainer, mailSpool, mailTools), sdkdelivery.JudgedNeither, "last applied", false},
|
|
{"a changed image", declared(mailContainer, other, mailSpool, mailTools), mailOn(t, 'b', true, mailContainer2, mailSpool, mailTools), sdkdelivery.JudgedRecreates, "last applied", false},
|
|
{"a changed setting in its spool", declared(mailContainer, mailSpool, mailConfig), mailOn(t, 'b', true, mailContainer, mailSpool, mailConfig2), sdkdelivery.JudgedMovesData, "last applied", false},
|
|
{"a changed tools file", declared(mailContainer, mailSpool, mailTools), mailOn(t, 'b', true, mailContainer, mailSpool, mailTools2), sdkdelivery.JudgedNeither, "last applied", false},
|
|
{"only the bus's user list", declared(busServer, busUsers, other), busOn(t, busServer, busUsers2), sdkdelivery.JudgedNeither, "only the bus's user list", true},
|
|
{"the bus's user list and its container", declared(busServer, busUsers), busOn(t, busServer2, busUsers2), sdkdelivery.JudgedRecreates, "last applied", false},
|
|
{"no declaration kept", nil, mailOn(t, 'b', true, mailContainer, mailSpool, mailTools), sdkdelivery.JudgedCannot, "names no composition", false},
|
|
}
|
|
for _, c := range cases {
|
|
at, _, _, haves := aPlace(t, "ace")
|
|
last := c.last
|
|
at.lastApplied = func(_ context.Context, module string) ([]json.RawMessage, string, bool, error) {
|
|
if last == nil {
|
|
return nil, "", false, nil
|
|
}
|
|
return sliceOfDeclaration(last, module)
|
|
}
|
|
haves[c.to.Module] = sdkdelivery.Have{FP: sdkdelivery.SourcePrefix2 + strings.Repeat("a", 64), Phase: sdkdelivery.PhaseRunning, Health: sdkdelivery.HealthOK}
|
|
key, _ := sdkdelivery.ComposedKey("ace", c.to.Module, c.to.FP)
|
|
digest, err := sdkdelivery.ComposedDigestOf(c.to)
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", c.name, err)
|
|
}
|
|
got, err := judgeMove(ctx, at, key, c.to, digest)
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", c.name, err)
|
|
}
|
|
if got.UserListOnly != c.userList {
|
|
t.Errorf("%s: user list only %v, want %v", c.name, got.UserListOnly, c.userList)
|
|
}
|
|
if got.Judgement != c.want || !strings.Contains(got.Words, c.inWords) {
|
|
t.Errorf("%s: judged %s (%q), want %s", c.name, got.Judgement, got.Words, c.want)
|
|
}
|
|
if _, err := sdkdelivery.EncodeComposedDigest(got); err != nil {
|
|
t.Errorf("%s: the judgement written is refused: %v", c.name, err)
|
|
}
|
|
}
|
|
}
|