239 lines
10 KiB
Go
239 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type staticLedger struct {
|
|
entries []LedgerEntry
|
|
err error
|
|
}
|
|
|
|
func (l staticLedger) Apply(string, string, any, string) error { return nil }
|
|
func (l staticLedger) Entries([]string) ([]LedgerEntry, error) { return l.entries, l.err }
|
|
|
|
type staticLog struct {
|
|
evs []LoggedEvent
|
|
err error
|
|
}
|
|
|
|
func (l staticLog) Last(n int, kind string) ([]LoggedEvent, error) {
|
|
var out []LoggedEvent
|
|
for _, e := range l.evs {
|
|
if kind == "" || e.Kind == kind {
|
|
out = append(out, e)
|
|
}
|
|
}
|
|
if len(out) > n {
|
|
out = out[len(out)-n:]
|
|
}
|
|
return out, l.err
|
|
}
|
|
|
|
// §28, §30, §10, §29: zfs_config shows each owned value with its config value, what runs, and how it stands
|
|
// (not managed, as set, not applied yet, waiting, refused, awaiting a load), the package's files with a .pacnew
|
|
// beside them, and what the module says before it leaves a node.
|
|
func TestZfsConfigShowsEveryValueHowItStandsAndWhatTheModuleSaysBeforeLeaving(t *testing.T) {
|
|
f := newFake(t)
|
|
m := f.machine()
|
|
st := memStates{}
|
|
m.States = st
|
|
f.files[ConfigFile] = `{"pool":"tank","arc-max":4096,"module-options":["zfs_txg_timeout=5"],"hostid":"0a0b0c0d","cache-devices":["x"],
|
|
"log-devices":[],"zed":"on","trim-schedule":"","snapshots":{"daily":3}}`
|
|
f.files[ParametersDir+"zfs_arc_max"] = "4294967296\n"
|
|
hb := make([]byte, 4)
|
|
binary.NativeEndian.PutUint32(hb, 0x0a0b0c0d)
|
|
f.files[HostIDFile] = string(hb)
|
|
m.Exists = func(p string) bool { return p == "/etc/default/zfs" || p == "/etc/default/zfs.pacnew" }
|
|
st.Put(StateApplied, "arc-max", AppliedEntry{Before: "1", After: "4294967296", Outcome: OutcomeApplied})
|
|
st.Put(StateApplied, "module-options.zfs_txg_timeout", AppliedEntry{After: "5", Outcome: OutcomeAwaitingLoad})
|
|
st.Put(StateApplied, "hostid", AppliedEntry{After: "0a0b0c0d", Outcome: OutcomeRefused, Why: "the pool's import would need -f"})
|
|
st.Put(StateApplied, "cache-devices", AppliedEntry{Outcome: OutcomeWaiting, WaitsOn: "a scrub of tank", Since: f.now})
|
|
st.Put(StateApplied, "trim-day", AppliedEntry{Outcome: OutcomeApplied}) // a value gone back to not managed is not shown
|
|
a, err := m.ConfigNow(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
by := map[string]ConfigValue{}
|
|
for _, v := range a.Values {
|
|
by[v.Key] = v
|
|
}
|
|
want := map[string]string{"pool": StateAsSet, "arc-max": StateAsSet, "module-options": StateAwaitingLoad, "hostid": StateRefused,
|
|
"cache-devices": StateWaiting, "log-devices": StateNotManaged, "zed": StateAsSet, "trim-schedule": StateNotManaged,
|
|
"trim-day": StateNotManaged, "snapshots": StateAsSet, "arc-min": StateNotManaged}
|
|
for k, w := range want {
|
|
if by[k].State != w {
|
|
t.Errorf("%s: %q, want %q", k, by[k].State, w)
|
|
}
|
|
}
|
|
if len(a.Values) != len(configKeys) {
|
|
t.Errorf("%d values for %d keys", len(a.Values), len(configKeys))
|
|
}
|
|
if by["arc-max"].Running != "4294967296 bytes" || by["hostid"].Running != "0a0b0c0d" || by["hostid"].Why == "" ||
|
|
!strings.Contains(by["hostid"].Note, "check of the pool's import") || by["cache-devices"].WaitsOn != "a scrub of tank" || by["cache-devices"].Since == "" {
|
|
t.Errorf("values: %+v", by)
|
|
}
|
|
if by["arc-min"].Value != nil {
|
|
t.Errorf("an unmanaged value shows %s", by["arc-min"].Value)
|
|
}
|
|
pacnew := false
|
|
for _, fl := range a.Files {
|
|
pacnew = pacnew || (fl.Path == "/etc/default/zfs" && fl.Present && fl.Pacnew)
|
|
}
|
|
all := strings.Join(a.Leaving, " ")
|
|
if !pacnew || !strings.Contains(strings.Join(a.Said, " "), "/etc/default/zfs.pacnew") || len(a.Files) != len(packageFiles) {
|
|
t.Errorf("files %+v said %v", a.Files, a.Said)
|
|
}
|
|
for _, s := range []string{"ZFS's own defaults", "zfs-import-cache.service, zfs-mount.service and zfs.target stay", "/etc/hostid stays"} {
|
|
if !strings.Contains(all, s) {
|
|
t.Errorf("leaving does not say %q: %v", s, a.Leaving)
|
|
}
|
|
}
|
|
delete(f.files, ConfigFile)
|
|
if _, err := m.ConfigNow(context.Background()); err == nil {
|
|
t.Error("an unreadable config file was answered")
|
|
}
|
|
}
|
|
|
|
// §28, A-31: zfs_snapshots_schedule answers the keep counts, each kind's next moment, the pause, what the next
|
|
// run would remove (a keep count of 0 removes nothing, A-35) and the ledger as `{"ledger": [...]}`, which the run reads.
|
|
func TestSnapshotsScheduleAnswersTheLedgerTheRunReads(t *testing.T) {
|
|
e := func(h int) LedgerEntry {
|
|
return LedgerEntry{"tank", "mesh-hourly-x" + string(rune('0'+h)), "hourly", time.Date(2026, 10, 9, h, 0, 0, 0, time.UTC).Format(time.RFC3339)}
|
|
}
|
|
old := LedgerEntry{"tank", "mesh-daily-old", "daily", "2026-09-01T00:00:00Z"}
|
|
cases := []struct {
|
|
name, conf string
|
|
l staticLedger
|
|
paused bool
|
|
remove int
|
|
next map[string]string
|
|
said string
|
|
wantErr bool
|
|
}{
|
|
{name: "counts and surplus", conf: `{"pool":"tank","snapshots":{"hourly":2,"daily":0}}`, l: staticLedger{entries: []LedgerEntry{e(1), e(2), e(3), old}},
|
|
remove: 1, next: map[string]string{"hourly": "2026-10-09T13:00:00"}, said: "would remove 1"},
|
|
{name: "weekly and monthly", conf: `{"pool":"tank","snapshots":{"weekly":1,"monthly":1,"daily":1}}`, next: map[string]string{
|
|
"daily": "2026-10-10T00:00:00", "weekly": "2026-10-12T00:00:00", "monthly": "2026-11-01T00:00:00"}},
|
|
{name: "paused", conf: `{"pool":"tank","snapshots":{"hourly":1}}`, paused: true, said: "paused"},
|
|
{name: "none keeps what exists", conf: `{"pool":"tank","snapshots":{"none":true}}`, l: staticLedger{entries: []LedgerEntry{e(1)}}, said: "are kept"},
|
|
{name: "not managed", conf: `{"pool":"tank"}`, said: "not managed"},
|
|
{name: "refused config still answers the ledger", conf: `{"pool":"tank","snapshots":{"hourly":999}}`, l: staticLedger{entries: []LedgerEntry{e(1)}}, said: "refused"},
|
|
{name: "ledger unreadable", conf: `{"pool":"tank"}`, l: staticLedger{err: errors.New("no bus")}, wantErr: true},
|
|
}
|
|
for _, c := range cases {
|
|
f := withZFS(t)
|
|
f.now = time.Date(2026, 10, 9, 12, 30, 0, 0, time.UTC) // a Friday
|
|
m := f.machine()
|
|
st := memStates{}
|
|
m.States, m.Ledger = st, c.l
|
|
f.files[ConfigFile] = c.conf
|
|
if c.paused {
|
|
st.Put(StateSchedule, KeyPaused, map[string]string{"by": "x", "why": "y"})
|
|
}
|
|
a, err := m.SnapshotSchedule(context.Background())
|
|
if (err != nil) != c.wantErr {
|
|
t.Errorf("%s: %v", c.name, err)
|
|
continue
|
|
}
|
|
if c.wantErr {
|
|
continue
|
|
}
|
|
if len(a.WouldRemove) != c.remove || (c.paused && a.Paused == nil) || !strings.Contains(strings.Join(a.Said, " "), c.said) {
|
|
t.Errorf("%s: %+v", c.name, a)
|
|
}
|
|
for k, v := range c.next {
|
|
if !strings.HasPrefix(a.Next[k], v) {
|
|
t.Errorf("%s: next %s %q, want %q", c.name, k, a.Next[k], v)
|
|
}
|
|
}
|
|
// The run reads the answer as it reads the ledger.
|
|
raw, _ := json.Marshal(a)
|
|
r := f.machine()
|
|
r.Call = func(key string, _ any) (json.RawMessage, error) { return raw, nil }
|
|
got, err := r.ledgerEntries()
|
|
if err != nil || len(got) != len(c.l.entries) {
|
|
t.Errorf("%s: the run reads %v, %v", c.name, got, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// §28: zfs_module_events answers the last N events of the stream, newest first, of one kind when named, with how
|
|
// many of each; a kind the module does not say is refused.
|
|
func TestModuleEventsAreTheStreamsLastNNewestFirstByKind(t *testing.T) {
|
|
f := newFake(t)
|
|
m := f.machine()
|
|
at := func(i int) time.Time { return time.Date(2026, 10, 9, 10, i, 0, 0, time.UTC) }
|
|
m.Log = staticLog{evs: []LoggedEvent{{1, EventApplied, at(1), nil}, {2, EventRefused, at(2), nil}, {3, EventApplied, at(3), nil}, {4, EventRunSkipped, at(4), nil}}}
|
|
a, err := m.ModuleEvents(3, "")
|
|
if err != nil || len(a.Events) != 3 || a.Events[0].Sequence != 4 || a.ByKind[EventApplied] != 1 || a.ByKind[EventRunSkipped] != 1 {
|
|
t.Errorf("last 3: %+v %v", a, err)
|
|
}
|
|
if a, err := m.ModuleEvents(5, EventApplied); err != nil || len(a.Events) != 2 || a.Events[0].Sequence != 3 {
|
|
t.Errorf("one kind: %+v %v", a, err)
|
|
}
|
|
if _, err := m.ModuleEvents(5, "config.nothing"); err == nil {
|
|
t.Error("an unknown kind was answered")
|
|
}
|
|
m.Log = staticLog{err: errors.New("no bus")}
|
|
if _, err := m.ModuleEvents(5, ""); err == nil {
|
|
t.Error("a stream that cannot be read was answered")
|
|
}
|
|
for subject, kind := range map[string]string{"zfs.snapshot.taken.person": EventTakenPerson, "snapshot.taken.schedule": EventTakenSchedule, "other": "other"} {
|
|
if KindOfSubject(subject) != kind {
|
|
t.Errorf("%s is %s", subject, KindOfSubject(subject))
|
|
}
|
|
}
|
|
}
|
|
|
|
// §28: zfs_snapshots_check names each ledger entry whose ZFS snapshot is gone and each mesh- snapshot the ledger
|
|
// does not hold, and changes nothing.
|
|
func TestSnapshotsCheckNamesWhatTheLedgerAndZFSDoNotShare(t *testing.T) {
|
|
f := withZFS(t)
|
|
f.on(line("zfs", SnapshotsArgv()), "tank@mesh-hourly-20261009T1000Z\t1791400000\t1\t2\ntank@mesh-hourly-20261009T1100Z\t1791400000\t1\t2\ntank@by-hand\t1791400000\t1\t2\n")
|
|
f.uid = 0
|
|
f.files[ConfigFile] = `{"pool":"tank"}`
|
|
m := f.machine()
|
|
m.Ledger = staticLedger{entries: []LedgerEntry{{"tank", "mesh-hourly-20261009T1000Z", "hourly", "2026-10-09T10:00:00Z"},
|
|
{"tank", "mesh-hourly-20261009T0900Z", "hourly", "2026-10-09T09:00:00Z"}}}
|
|
a, err := m.CheckSnapshots(context.Background())
|
|
if err != nil || len(a.Gone) != 1 || a.Gone[0].Name != "mesh-hourly-20261009T0900Z" ||
|
|
len(a.Unrecorded) != 1 || a.Unrecorded[0] != "tank@mesh-hourly-20261009T1100Z" {
|
|
t.Errorf("%+v %v", a, err)
|
|
}
|
|
for _, c := range f.calls {
|
|
if strings.Contains(c, "destroy") || strings.Contains(c, " set ") || strings.Contains(c, "snapshot --") {
|
|
t.Errorf("a check changed something: %s", c)
|
|
}
|
|
}
|
|
m.Ledger = staticLedger{err: errors.New("no bus")}
|
|
if _, err := m.CheckSnapshots(context.Background()); err == nil {
|
|
t.Error("a ledger that cannot be read was answered")
|
|
}
|
|
}
|
|
|
|
// §27, §28: zfs_findings shows the follower's keys, none when every device is ONLINE.
|
|
func TestFindingsAreTheFollowersKeys(t *testing.T) {
|
|
f := newFake(t)
|
|
m := f.machine()
|
|
st := memStates{}
|
|
m.States = st
|
|
if a, err := m.FindingsNow(); err != nil || len(a.Findings) != 0 || !strings.Contains(a.Said[0], "No pool or device") {
|
|
t.Errorf("%+v %v", a, err)
|
|
}
|
|
st.Put(StateFindings, "pool.tank.sda", map[string]string{"summary": "sda is FAULTED"})
|
|
if a, err := m.FindingsNow(); err != nil || len(a.Findings) != 1 || a.Findings[0].Key != "pool.tank.sda" {
|
|
t.Errorf("%+v %v", a, err)
|
|
}
|
|
m.States = nil
|
|
if _, err := m.FindingsNow(); err == nil {
|
|
t.Error("no state, no answer")
|
|
}
|
|
}
|