The owner asked to see the vendor of each MAC where the IEEE registry can be fetched, and never to depend on it. internal/oui downloads MA-L, MA-M and MA-S weekly through the outbound allow-list (timeouts, a size cap and a row-count sanity check, so a truncated or wrong download keeps the previous file), stores one checksummed, atomically written file in <data-dir>/oui that nmon backup includes, and looks MACs up by the longest prefix. A missing registry only leaves the vendor empty. `nmon oui import DIR|FILE` loads the CSVs offline, and the Ansible role can ship them next to the MIB sidecar. internal/hostaddr parses the MAC, prefix, IP and CIDR forms the lookup accepts and classifies a MAC as global, local or multicast. config gains the l2 and oui sections (validated here; the L2 job that reads l2 follows). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01T4PdJUPrakM8fHvN8jYv2x
239 lines
7.7 KiB
Go
239 lines
7.7 KiB
Go
package backup
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestBackupRestoreRoundTripWithMetricStores(t *testing.T) {
|
|
f := newFixture(t)
|
|
hotDir := filepath.Join(f.dir, "vm-hot")
|
|
vm := newFakeVM(t, hotDir)
|
|
out := filepath.Join(t.TempDir(), "b.tar")
|
|
var log bytes.Buffer
|
|
o := f.options(out)
|
|
o.Log = &log
|
|
o.Stores = []VMStore{{Name: "hot", URL: vm.URL, DataDir: hotDir}, {Name: "long", DataDir: ""}}
|
|
res, err := Backup(context.Background(), o)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if res.KeyIncluded || !strings.Contains(log.String(), "NOT included") {
|
|
t.Fatalf("key notice missing: %q", log.String())
|
|
}
|
|
if vm.created != 1 || len(vm.deleted) != 1 || vm.deleted[0] != "snap-1" {
|
|
t.Fatalf("snapshot lifecycle: created %d deleted %v", vm.created, vm.deleted)
|
|
}
|
|
m := res.Manifest
|
|
if m.Rows["devices"] != 3 || m.Inventory != inventoryDB || len(m.Stores) != 1 || len(m.Stores[0].Series) != 1 || len(m.Notes) != 1 {
|
|
t.Fatalf("manifest %+v", m)
|
|
}
|
|
if want := f.clk.Now().Add(-DefaultSettle); !m.Boundary.Equal(want) {
|
|
t.Fatalf("boundary %v want %v", m.Boundary, want)
|
|
}
|
|
|
|
target := filepath.Join(t.TempDir(), "restored")
|
|
sv := &stubVerifier{}
|
|
rr, err := Restore(context.Background(), RestoreOptions{File: out, DataDir: target, Verifier: sv, Clock: f.clk})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if rr.RowsVerified == 0 || rr.SeriesVerified != 1 || !sv.called {
|
|
t.Fatalf("result %+v verifier %+v", rr, sv)
|
|
}
|
|
for _, p := range []string{"inventory.db", "config.yaml", "profiles/custom.yaml", "oui/registry.gz", "hot/indexdb/idx-1"} {
|
|
want := p
|
|
if strings.HasPrefix(p, "hot/") {
|
|
want = "vm-" + p
|
|
}
|
|
if _, err := os.Stat(filepath.Join(target, want)); err != nil {
|
|
t.Errorf("restored tree is missing %s: %v", want, err)
|
|
}
|
|
}
|
|
if _, err := os.Stat(filepath.Join(target, stagingDir)); !errors.Is(err, os.ErrNotExist) {
|
|
t.Errorf("staging dir left behind: %v", err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(target, "secret.key")); !errors.Is(err, os.ErrNotExist) {
|
|
t.Error("key restored although the backup excluded it")
|
|
}
|
|
}
|
|
|
|
func TestBackupWithKeyStatesItAndRestoresIt(t *testing.T) {
|
|
f := newFixture(t)
|
|
out := filepath.Join(t.TempDir(), "b.tar")
|
|
var log bytes.Buffer
|
|
o := f.options(out)
|
|
o.IncludeKey, o.Log = true, &log
|
|
res, err := Backup(context.Background(), o)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !res.KeyIncluded || !strings.Contains(log.String(), "INCLUDED") || strings.Contains(log.String(), "NOT included") {
|
|
t.Fatalf("key notice: %q", log.String())
|
|
}
|
|
keyOut := filepath.Join(t.TempDir(), "k", "secret.key")
|
|
rr, err := Restore(context.Background(), RestoreOptions{File: out, DataDir: filepath.Join(t.TempDir(), "r"), KeyFile: keyOut})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want, _ := os.ReadFile(f.keyFile)
|
|
got, err := os.ReadFile(keyOut)
|
|
if err != nil || !bytes.Equal(got, want) || rr.KeyRestoredTo != keyOut {
|
|
t.Fatalf("key restore: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestBackupRefusesBelowReserveAndWritesNothing(t *testing.T) {
|
|
f := newFixture(t)
|
|
outDir := t.TempDir()
|
|
o := f.options(filepath.Join(outDir, "b.tar"))
|
|
o.ReserveCheck = func() error { return errors.New("3.1% free") }
|
|
_, err := Backup(context.Background(), o)
|
|
if !errors.Is(err, ErrReserve) || !strings.Contains(err.Error(), "3.1% free") {
|
|
t.Fatalf("got %v", err)
|
|
}
|
|
if ents, _ := os.ReadDir(outDir); len(ents) != 0 {
|
|
t.Fatalf("files left after a refused backup: %v", ents)
|
|
}
|
|
}
|
|
|
|
func TestFailedBackupLeavesNoPartialFileAndDeletesNoSnapshotItDidNotMake(t *testing.T) {
|
|
f := newFixture(t)
|
|
vm := newFakeVM(t, filepath.Join(f.dir, "vm-hot"))
|
|
vm.failSnap = true
|
|
outDir := t.TempDir()
|
|
o := f.options(filepath.Join(outDir, "b.tar"))
|
|
o.Stores = []VMStore{{Name: "hot", URL: vm.URL, DataDir: filepath.Join(f.dir, "vm-hot")}}
|
|
if _, err := Backup(context.Background(), o); err == nil {
|
|
t.Fatal("want an error")
|
|
}
|
|
if ents, _ := os.ReadDir(outDir); len(ents) != 0 {
|
|
t.Fatalf("partial output left: %v", ents)
|
|
}
|
|
if left, _ := filepath.Glob(filepath.Join(f.dir, ".backup-*")); len(left) != 0 {
|
|
t.Fatalf("scratch left: %v", left)
|
|
}
|
|
}
|
|
|
|
func TestTruncatedArchiveIsDetected(t *testing.T) {
|
|
f := newFixture(t)
|
|
out := filepath.Join(t.TempDir(), "b.tar")
|
|
if _, err := Backup(context.Background(), f.options(out)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
full, err := os.ReadFile(out)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, cut := range []int{0, 100, len(full) / 2, len(full) - 2048, len(full) - 1024 - 10} {
|
|
cutFile := filepath.Join(t.TempDir(), "cut.tar")
|
|
if err := os.WriteFile(cutFile, full[:cut], 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
target := filepath.Join(t.TempDir(), "r")
|
|
_, err := Restore(context.Background(), RestoreOptions{File: cutFile, DataDir: target})
|
|
if !errors.Is(err, ErrTruncated) {
|
|
t.Errorf("cut at %d of %d: got %v", cut, len(full), err)
|
|
}
|
|
if ents, _ := os.ReadDir(target); len(ents) != 0 {
|
|
t.Errorf("cut at %d left %d files in the data dir", cut, len(ents))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDamagedEntryIsDetected(t *testing.T) {
|
|
f := newFixture(t)
|
|
out := filepath.Join(t.TempDir(), "b.tar")
|
|
if _, err := Backup(context.Background(), f.options(out)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b, _ := os.ReadFile(out)
|
|
i := bytes.Index(b, []byte("timezone: UTC"))
|
|
b[i] = 'T'
|
|
bad := filepath.Join(t.TempDir(), "bad.tar")
|
|
if err := os.WriteFile(bad, b, 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err := Restore(context.Background(), RestoreOptions{File: bad, DataDir: filepath.Join(t.TempDir(), "r")})
|
|
if !errors.Is(err, ErrTruncated) {
|
|
t.Fatalf("got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRestoreRefusesNonEmptyDirectory(t *testing.T) {
|
|
f := newFixture(t)
|
|
out := filepath.Join(t.TempDir(), "b.tar")
|
|
if _, err := Backup(context.Background(), f.options(out)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
target := t.TempDir()
|
|
writeFile(t, filepath.Join(target, "precious"), "x")
|
|
_, err := Restore(context.Background(), RestoreOptions{File: out, DataDir: target})
|
|
if !errors.Is(err, ErrNotEmpty) {
|
|
t.Fatalf("got %v", err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(target, "precious")); err != nil {
|
|
t.Fatalf("restore touched a non-empty directory: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRestoreFailsWhenSeriesDoNotVerifyAndCleansUp(t *testing.T) {
|
|
f := newFixture(t)
|
|
vm := newFakeVM(t, filepath.Join(f.dir, "vm-hot"))
|
|
out := filepath.Join(t.TempDir(), "b.tar")
|
|
o := f.options(out)
|
|
o.Stores = []VMStore{{Name: "hot", URL: vm.URL, DataDir: filepath.Join(f.dir, "vm-hot")}}
|
|
if _, err := Backup(context.Background(), o); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
target := filepath.Join(t.TempDir(), "r")
|
|
_, err := Restore(context.Background(), RestoreOptions{File: out, DataDir: target, Verifier: &stubVerifier{err: errors.New("sha differs")}})
|
|
if !errors.Is(err, ErrVerify) {
|
|
t.Fatalf("got %v", err)
|
|
}
|
|
if ents, _ := os.ReadDir(target); len(ents) != 0 {
|
|
t.Fatalf("failed restore left files: %v", ents)
|
|
}
|
|
}
|
|
|
|
func TestSchedulerRunsDailyAtConfiguredTime(t *testing.T) {
|
|
f := newFixture(t)
|
|
var runs []time.Time
|
|
ran := make(chan struct{}, 4)
|
|
s := &Scheduler{
|
|
Clock: f.clk, At: "03:30",
|
|
Job: func(context.Context) error { return nil },
|
|
OnResult: func(at time.Time, _ error) { runs = append(runs, at); ran <- struct{}{} },
|
|
}
|
|
next, err := s.NextRun(f.clk.Now())
|
|
if err != nil || !next.Equal(time.Date(2026, 10, 23, 3, 30, 0, 0, time.UTC)) {
|
|
t.Fatalf("next %v %v", next, err)
|
|
}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
done := make(chan error)
|
|
go func() { done <- s.Run(ctx) }()
|
|
for f.clk.Waiters() == 0 {
|
|
time.Sleep(time.Millisecond)
|
|
}
|
|
f.clk.Advance(16*time.Hour + 30*time.Minute)
|
|
<-ran
|
|
for f.clk.Waiters() == 0 {
|
|
time.Sleep(time.Millisecond)
|
|
}
|
|
f.clk.Advance(24 * time.Hour)
|
|
<-ran
|
|
cancel()
|
|
if err := <-done; err != nil || len(runs) != 2 {
|
|
t.Fatalf("runs %v err %v", runs, err)
|
|
}
|
|
if _, err := (&Scheduler{At: "25:00"}).NextRun(f.clk.Now()); err == nil {
|
|
t.Fatal("bad time accepted")
|
|
}
|
|
}
|