When one record of a unit goes while another still declares it, what the going record found of the unit is kept for the staying one when that has no finding of its own, so the module's leave gives back the state found before the mesh. The preview test and the new case are one test (A-22). Builds: design 42 zfs-owns-zfs §2, answers A-21, A-22
189 lines
7.7 KiB
Go
189 lines
7.7 KiB
Go
package apply
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/declaration"
|
|
"github.com/novox/mesh-host/internal/store"
|
|
)
|
|
|
|
// novox/hq issue 190, ADR 0222: the private network stops writing the mesh's registry into the
|
|
// container runtime's file, and the runtime's own module writes the same member. Both are moved in
|
|
// one apply, and the machine never loses the member: the network's record goes first (its member
|
|
// leaves the list), the runtime's module is applied after (the member is added back, now recorded
|
|
// as the runtime's), and the daemon is reloaded once, never stopped, disabled or restarted — even
|
|
// though the record going says the unit was found stopped and disabled.
|
|
|
|
const theRegistry = "anchor.internal:5100"
|
|
|
|
func runtimeDecl(t *testing.T, path string, network bool) *declaration.Declaration {
|
|
t.Helper()
|
|
var resources []string
|
|
if network {
|
|
resources = append(resources,
|
|
fmt.Sprintf(`{"id":"networking.registry-trust","type":"file","path":%q,"into":"json","content":%q}`,
|
|
path, `{"insecure-registries":["`+theRegistry+`"]}`),
|
|
`{"id":"networking.registry-trust-reload","type":"service","unit":"docker.service","state":"running",
|
|
"reload-on":["networking.registry-trust"]}`)
|
|
}
|
|
resources = append(resources,
|
|
fmt.Sprintf(`{"id":"docker.daemon","type":"file","path":%q,"into":"json","content":%q}`,
|
|
path, `{"live-restore":true,"insecure-registries":["`+theRegistry+`"]}`),
|
|
`{"id":"docker.runtime","type":"service","unit":"docker.service","state":"running","boot":"enabled",
|
|
"reload-on":["docker.daemon"]}`)
|
|
return parse(t, `{"declaration":1,"resources":[`+strings.Join(resources, ",")+`]}`)
|
|
}
|
|
|
|
func TestTheRegistryMovesToTheRuntimesModuleWithoutLeavingTheList(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "daemon.json")
|
|
if err := os.WriteFile(path, []byte(`{"insecure-registries":["192.0.2.7:5000"]}`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var commands []string
|
|
run := recordingServices(&commands)
|
|
|
|
// Both declare it: the network's record added the member, so the runtime's finds it there.
|
|
_, state, err := Apply(context.Background(), archHost(t), runtimeDecl(t, path, true), store.State{},
|
|
store.OriginDeclared, run, nil, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Say the network's record found the runtime stopped and disabled: giving that back would stop
|
|
// every container on the machine.
|
|
for i := range state.Resources {
|
|
if state.Resources[i].ID == "networking.registry-trust-reload" {
|
|
state.Resources[i].Found = &store.FoundUnit{Unit: "docker.service", State: "stopped", Boot: "disabled"}
|
|
}
|
|
}
|
|
|
|
commands = nil
|
|
report, state, err := Apply(context.Background(), archHost(t), runtimeDecl(t, path, false), state,
|
|
store.OriginDeclared, run, nil, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := fmt.Sprint(readObject(t, path)["insecure-registries"]); got != "[192.0.2.7:5000 "+theRegistry+"]" {
|
|
t.Fatalf("the list after the move: %s", got)
|
|
}
|
|
rec, _ := state.Find("docker.daemon")
|
|
if added := rec.Into.Added["insecure-registries"]; len(added) != 1 || canonical(added[0]) != `"`+theRegistry+`"` {
|
|
t.Errorf("the member is not recorded as the runtime's module's: %s", added)
|
|
}
|
|
reloads := 0
|
|
for _, c := range commands {
|
|
if strings.Contains(c, "docker.service") && (strings.Contains(c, " stop ") || strings.Contains(c, " restart ") ||
|
|
strings.Contains(c, " disable ")) {
|
|
t.Errorf("the runtime was given back as the network's record found it: %q", c)
|
|
}
|
|
if strings.Contains(c, "reload docker.service") {
|
|
reloads++
|
|
}
|
|
}
|
|
if reloads != 1 {
|
|
t.Errorf("the runtime was reloaded %d times; commands were %v", reloads, commands)
|
|
}
|
|
for _, o := range report.Outcomes {
|
|
if o.ID == "networking.registry-trust-reload" && o.Action != "forgotten" {
|
|
t.Errorf("the network's record of the unit was %q: %s", o.Action, o.Detail)
|
|
}
|
|
}
|
|
|
|
// Steady from here on, and undeclaring the runtime's module takes only what it added.
|
|
report, state, err = Apply(context.Background(), archHost(t), runtimeDecl(t, path, false), state,
|
|
store.OriginDeclared, run, nil, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, o := range report.Outcomes {
|
|
if o.ID == "docker.daemon" && o.Action != "unchanged" {
|
|
t.Errorf("a second apply was %q", o.Action)
|
|
}
|
|
}
|
|
if _, _, err := Apply(context.Background(), archHost(t), somethingElse(t), state, store.OriginDeclared, run, nil, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := fmt.Sprint(readObject(t, path)["insecure-registries"]); got != "[192.0.2.7:5000]" {
|
|
t.Errorf("undeclaring the runtime's module left %s", got)
|
|
}
|
|
}
|
|
|
|
// A unit two records name, under opposite conditions, passes between them (design 42 zfs-owns-zfs §2, answer A-21): the
|
|
// going record is forgotten, the preview says so before it happens, and what it found of the unit before the mesh is what
|
|
// the staying record gives back when its module leaves, not what the mesh made of it.
|
|
func TestARecordOfAUnitStillHeldIsForgottenAndPassesWhatItFound(t *testing.T) {
|
|
t.Run("the preview forgets it", func(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "daemon.json")
|
|
var commands []string
|
|
_, state, err := Apply(context.Background(), archHost(t), runtimeDecl(t, path, true), store.State{},
|
|
store.OriginDeclared, recordingServices(&commands), nil, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, step := range Plan(runtimeDecl(t, path, false), state, store.OriginDeclared) {
|
|
if step.ID == "networking.registry-trust-reload" && step.Verb != "forget" {
|
|
t.Errorf("the plan would %s the network's record of a unit docker.runtime holds: %s", step.Verb, step.Why)
|
|
}
|
|
}
|
|
})
|
|
t.Run("what it found passes to the record that stays", func(t *testing.T) {
|
|
// A unit found stopped and disabled, so the mesh's first record of it started it.
|
|
active, enabled := false, false
|
|
var commands []string
|
|
run := func(_ context.Context, name string, args ...string) (string, error) {
|
|
args = oldShape(name, args)
|
|
line := name + " " + strings.Join(args, " ")
|
|
commands = append(commands, line)
|
|
switch {
|
|
case strings.Contains(line, " start "):
|
|
active = true
|
|
case strings.Contains(line, " stop "):
|
|
active = false
|
|
case strings.Contains(line, " enable "):
|
|
enabled = true
|
|
case strings.Contains(line, " disable "):
|
|
enabled = false
|
|
case strings.Contains(line, "is-enabled"):
|
|
if enabled {
|
|
return "enabled", nil
|
|
}
|
|
return "disabled", nil
|
|
case strings.Contains(line, "show") && strings.Contains(line, "ActiveState"):
|
|
if active {
|
|
return "LoadState=loaded\nActiveState=active\nSubState=running", nil
|
|
}
|
|
return "LoadState=loaded\nActiveState=inactive\nSubState=dead", nil
|
|
}
|
|
return "", nil
|
|
}
|
|
unit := func(id, state, boot string) *declaration.Declaration {
|
|
return parse(t, `{"declaration":1,"resources":[{"id":"`+id+`","type":"service","unit":"z.service","state":"`+
|
|
state+`","boot":"`+boot+`"}]}`)
|
|
}
|
|
apply := func(d *declaration.Declaration, known store.State) store.State {
|
|
t.Helper()
|
|
_, known, err := Apply(context.Background(), archHost(t), d, known, store.OriginDeclared, run, nil, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return known
|
|
}
|
|
known := apply(unit("z.on", "running", "enabled"), store.State{})
|
|
known = apply(unit("z.off", "stopped", "disabled"), known) // the value changed: one record goes, the other stays
|
|
if rec, _ := known.Find("z.off"); rec.Found == nil || rec.Found.State != "stopped" || rec.Found.Boot != "disabled" {
|
|
t.Fatalf("the staying record did not receive what the going one found: %+v", rec.Found)
|
|
}
|
|
commands = nil
|
|
apply(somethingElse(t), known) // the module leaves
|
|
for _, c := range commands {
|
|
if strings.Contains(c, " start ") || strings.Contains(c, " enable ") {
|
|
t.Errorf("the unit was given back as the mesh made it, not as it was found: %q", c)
|
|
}
|
|
}
|
|
})
|
|
}
|