jochen
7c8497225d
mesh/merge-gate pass: builds new: modules/zfs, sent nowhere; no bus step; every machine composes with the change as it did without (4 of 4 compose)
mesh/repo-check fail: its merge-check.sh failed: --- FAIL: TestASnapshotIsAnsweredFromTheListAfterwardsAndRecorded (0.00s)
mesh/delivery superseded: a newer head of the same pull request
The home server's pool holds the operator's media library, and no mesh tool could say whether it is healthy, how full it is, when it was last scrubbed or what snapshots exist; the only way was a login. This module reads all of it with fixed zfs and zpool commands (list, get, status, iostat, events, history) and has one act, zfs_snapshot, which only adds a snapshot: refused for an unknown dataset, a name outside [A-Za-z0-9._-], an existing snapshot or no why; run as sudo -n zfs snapshot -- ds@name; answered from zfs list afterwards, with any other snapshot that came or went meanwhile; recorded as the event snapshot.taken. No destroy, rollback, set or send exists, and a test holds every command to its verb. Health (ADR 0240): zfs_health on the watch process, unhealthy for a pool not ONLINE, device or data errors, a pool past 90 % full or no ZFS at all; past 80 % and a scrub older than 35 days are warnings. Beside it, the event follower (zpool events -f, as root) keeps ZFS's errors in its journal past a reboot and is judged by its unit, the check the module does not run itself. No seat (ADR 0121), no package: ZFS is the machine's.
105 lines
2.9 KiB
Go
105 lines
2.9 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// The fixtures in testdata are the output of OpenZFS 2.4 (the version the home server runs) in the exact
|
|
// form each command prints it — tab-separated under -H, exact numbers under -p — with the pool, disk and
|
|
// address names replaced by documentation ones.
|
|
|
|
func fixture(t *testing.T, name string) string {
|
|
t.Helper()
|
|
b, err := os.ReadFile(filepath.Join("testdata", name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
// fake is a machine for a test: a table of command lines and their answers, every call kept.
|
|
type fake struct {
|
|
t *testing.T
|
|
answers map[string]Ran
|
|
// after runs once a command line was answered: a snapshot's command changes what the list answers.
|
|
after map[string]func(*fake)
|
|
calls []string
|
|
emitted []map[string]any
|
|
emitErr error
|
|
files map[string]string
|
|
now time.Time
|
|
uid int
|
|
}
|
|
|
|
func newFake(t *testing.T) *fake {
|
|
return &fake{t: t, answers: map[string]Ran{}, after: map[string]func(*fake){}, files: map[string]string{},
|
|
now: time.Date(2026, 10, 9, 12, 0, 0, 0, time.Local), uid: 1000}
|
|
}
|
|
|
|
func (f *fake) on(line string, out string) { f.answers[line] = Ran{Out: out} }
|
|
|
|
func (f *fake) machine() *Machine {
|
|
return &Machine{
|
|
Run: func(_ context.Context, name string, args ...string) Ran {
|
|
line := strings.TrimSpace(name + " " + strings.Join(args, " "))
|
|
f.calls = append(f.calls, line)
|
|
r, ok := f.answers[line]
|
|
if !ok && name == "sudo" && len(args) > 1 {
|
|
// sudo is there; the command it was asked for is not.
|
|
r = Ran{Code: 1, Err: "sudo: " + args[1] + ": command not found"}
|
|
} else if !ok {
|
|
r = Ran{Code: -1, Err: "exec: \"" + name + "\": executable file not found in $PATH"}
|
|
}
|
|
if then, ok := f.after[line]; ok {
|
|
then(f)
|
|
}
|
|
return r
|
|
},
|
|
UID: f.uid,
|
|
Now: func() time.Time { return f.now },
|
|
ReadFile: func(p string) ([]byte, error) {
|
|
s, ok := f.files[p]
|
|
if !ok {
|
|
return nil, os.ErrNotExist
|
|
}
|
|
return []byte(s), nil
|
|
},
|
|
Emit: func(eventType string, body any) error {
|
|
if f.emitErr != nil {
|
|
return f.emitErr
|
|
}
|
|
b := body.(map[string]any)
|
|
b["_type"] = eventType
|
|
f.emitted = append(f.emitted, b)
|
|
return nil
|
|
},
|
|
}
|
|
}
|
|
|
|
func line(name string, argv []string) string { return name + " " + strings.Join(argv, " ") }
|
|
|
|
// withZFS answers the read commands from the healthy fixtures.
|
|
func withZFS(t *testing.T) *fake {
|
|
f := newFake(t)
|
|
f.on(line("zfs", DatasetsArgv()), fixture(t, "zfs-list.txt"))
|
|
f.on(line("zfs", SnapshotsArgv()), fixture(t, "zfs-list-snapshots.txt"))
|
|
f.on(line("zpool", PoolsArgv()), fixture(t, "zpool-list.txt"))
|
|
f.on(line("zpool", StatusArgv()), fixture(t, "zpool-status.txt"))
|
|
return f
|
|
}
|
|
|
|
func ran(f *fake, prefix string) []string {
|
|
var out []string
|
|
for _, c := range f.calls {
|
|
if strings.HasPrefix(c, prefix) {
|
|
out = append(out, c)
|
|
}
|
|
}
|
|
return out
|
|
}
|