348 lines
10 KiB
Go
348 lines
10 KiB
Go
package watchdog
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
dhcpapi "git.g3e.fr/syonad/two/internal/api/dhcp"
|
|
"git.g3e.fr/syonad/two/internal/dhcpbackend"
|
|
"git.g3e.fr/syonad/two/internal/dhcpd"
|
|
"git.g3e.fr/syonad/two/internal/state"
|
|
|
|
"github.com/dgraph-io/badger/v4"
|
|
)
|
|
|
|
const (
|
|
testSubnetName = "sn-000001"
|
|
testVPC = "vp-admin"
|
|
testBridge = "br-000001"
|
|
)
|
|
|
|
func twoSubnet() dhcpbackend.Subnet {
|
|
return dhcpbackend.Subnet{Name: testSubnetName, VPC: testVPC, Bridge: testBridge}
|
|
}
|
|
|
|
func shortTempDir(t *testing.T) string {
|
|
t.Helper()
|
|
dir, err := os.MkdirTemp("", "dhcpd")
|
|
if err != nil {
|
|
t.Fatalf("MkdirTemp: %v", err)
|
|
}
|
|
t.Cleanup(func() { os.RemoveAll(dir) })
|
|
return dir
|
|
}
|
|
|
|
func servedBy(t *testing.T) (dhcpbackend.Two, *dhcpd.Store) {
|
|
t.Helper()
|
|
|
|
b := dhcpbackend.Two{RunDir: shortTempDir(t)}
|
|
s := twoSubnet()
|
|
|
|
store := dhcpd.NewStore(dhcpapi.StatePath(b.RunDir, s.Instance()))
|
|
if err := store.Load(); err != nil {
|
|
t.Fatalf("Load: %v", err)
|
|
}
|
|
|
|
server, err := dhcpapi.Listen(store, dhcpapi.SocketPath(b.RunDir, s.Instance()), slog.New(slog.NewTextHandler(io.Discard, nil)))
|
|
if err != nil {
|
|
t.Fatalf("Listen: %v", err)
|
|
}
|
|
go server.Serve()
|
|
t.Cleanup(func() { server.Close() })
|
|
|
|
_, network, err := net.ParseCIDR("10.0.5.0/24")
|
|
if err != nil {
|
|
t.Fatalf("ParseCIDR: %v", err)
|
|
}
|
|
if err := store.SetSubnet(dhcpd.SubnetConfig{Network: network, InterfaceIP: net.ParseIP("10.0.5.1")}); err != nil {
|
|
t.Fatalf("SetSubnet: %v", err)
|
|
}
|
|
return b, store
|
|
}
|
|
|
|
func seedSubnetWithVM(t *testing.T, db *badger.DB, vmName, ip, mac string, primary bool) {
|
|
t.Helper()
|
|
|
|
seedKV(t, db, "subnet/"+testSubnetName+"/vpc", testVPC)
|
|
seedKV(t, db, "subnet/"+testSubnetName+"/dhcp/"+ip, mac)
|
|
|
|
if err := state.Set(db, "vm/"+vmName, state.Running); err != nil {
|
|
t.Fatalf("state.Set: %v", err)
|
|
}
|
|
seedKV(t, db, "vm/"+vmName+"/nic/0/subnet", testSubnetName)
|
|
seedKV(t, db, "vm/"+vmName+"/nic/0/ip", ip)
|
|
seedKV(t, db, "vm/"+vmName+"/nic/0/primary", fmt.Sprintf("%t", primary))
|
|
}
|
|
|
|
func TestExpectedHosts_ReadsRunningVMsOnThatSubnet(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
|
|
hosts, err := expectedHosts(db, testSubnetName)
|
|
if err != nil {
|
|
t.Fatalf("expectedHosts: %v", err)
|
|
}
|
|
if len(hosts) != 1 {
|
|
t.Fatalf("hosts = %+v, want one", hosts)
|
|
}
|
|
if hosts[0].MAC != "00:22:33:00:00:0A" || hosts[0].IP != "10.0.5.10" {
|
|
t.Errorf("host = %+v, want the mac derived from the address plan", hosts[0])
|
|
}
|
|
if hosts[0].VM != "vm-web" || !hosts[0].DefaultRoute {
|
|
t.Errorf("host = %+v, want vm-web carrying the default route", hosts[0])
|
|
}
|
|
}
|
|
|
|
func TestExpectedHosts_IgnoresVMsThatAreNotRunning(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
if err := state.Set(db, "vm/vm-web", state.Deleting); err != nil {
|
|
t.Fatalf("state.Set: %v", err)
|
|
}
|
|
|
|
hosts, err := expectedHosts(db, testSubnetName)
|
|
if err != nil {
|
|
t.Fatalf("expectedHosts: %v", err)
|
|
}
|
|
if len(hosts) != 0 {
|
|
t.Errorf("hosts = %+v, want none: a vm being deleted is not expected to be served", hosts)
|
|
}
|
|
}
|
|
|
|
func TestExpectedHosts_IgnoresInterfacesOnOtherSubnets(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
seedKV(t, db, "vm/vm-web/nic/1/subnet", "sn-000002")
|
|
seedKV(t, db, "vm/vm-web/nic/1/ip", "10.0.6.10")
|
|
seedKV(t, db, "vm/vm-web/nic/1/primary", "false")
|
|
|
|
hosts, err := expectedHosts(db, testSubnetName)
|
|
if err != nil {
|
|
t.Fatalf("expectedHosts: %v", err)
|
|
}
|
|
if len(hosts) != 1 {
|
|
t.Errorf("hosts = %+v, want only the interface on this subnet", hosts)
|
|
}
|
|
}
|
|
|
|
func TestExpectedHosts_SortsByMAC(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-b", "10.0.5.11", "00:22:33:00:00:0B", true)
|
|
seedSubnetWithVM(t, db, "vm-a", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
|
|
hosts, err := expectedHosts(db, testSubnetName)
|
|
if err != nil {
|
|
t.Fatalf("expectedHosts: %v", err)
|
|
}
|
|
if len(hosts) != 2 || hosts[0].MAC != "00:22:33:00:00:0A" {
|
|
t.Errorf("hosts = %+v, want sorted by mac", hosts)
|
|
}
|
|
}
|
|
|
|
func TestExpectedHosts_ReportsAnIPWithoutAMAC(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
seedKV(t, db, "vm/vm-web/nic/0/ip", "10.0.5.99")
|
|
|
|
if _, err := expectedHosts(db, testSubnetName); err == nil {
|
|
t.Fatal("an ip absent from the address plan must be reported, not skipped")
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPState_MACCaseAloneIsNotADivergence(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
|
|
b, _ := servedBy(t)
|
|
if err := b.SetVM(twoSubnet(), "vm-web", []dhcpbackend.Reservation{
|
|
{Index: 0, MAC: "00:22:33:00:00:0A", IP: "10.0.5.10", DefaultRoute: true},
|
|
}); err != nil {
|
|
t.Fatalf("SetVM: %v", err)
|
|
}
|
|
|
|
r := &recorder{}
|
|
checkDHCPState(db, testSubnetName, twoSubnet(), b, r)
|
|
|
|
if len(r.calls) != 0 {
|
|
t.Errorf("dhcp.Entries stores uppercase macs and the server normalizes to lowercase: that alone must not read as drift, got %+v", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPState_ADivergenceIsReportedOnceNotAsBothMissingAndStale(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
|
|
b, _ := servedBy(t)
|
|
if err := b.SetVM(twoSubnet(), "vm-web", []dhcpbackend.Reservation{
|
|
{Index: 0, MAC: "00:22:33:00:00:0A", IP: "10.0.5.99", DefaultRoute: true},
|
|
}); err != nil {
|
|
t.Fatalf("SetVM: %v", err)
|
|
}
|
|
|
|
r := &recorder{}
|
|
checkDHCPState(db, testSubnetName, twoSubnet(), b, r)
|
|
|
|
if len(r.calls) != 1 {
|
|
t.Errorf("notifications = %+v, want a single diverging-reservation report", r.calls)
|
|
}
|
|
if r.hasProblemContaining("missing on the server") || r.hasProblemContaining("stale dhcp") {
|
|
t.Errorf("without mac normalization the same host reads as both missing and stale: %+v", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPState_SilentWhenServerMatchesDatabase(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
|
|
b, _ := servedBy(t)
|
|
if err := b.SetVM(twoSubnet(), "vm-web", []dhcpbackend.Reservation{
|
|
{Index: 0, MAC: "00:22:33:00:00:0A", IP: "10.0.5.10", DefaultRoute: true},
|
|
}); err != nil {
|
|
t.Fatalf("SetVM: %v", err)
|
|
}
|
|
|
|
r := &recorder{}
|
|
checkDHCPState(db, testSubnetName, twoSubnet(), b, r)
|
|
|
|
if len(r.calls) != 0 {
|
|
t.Errorf("notifications = %+v, want none when the server agrees with the database", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPState_ReportsAReservationTheServerNeverGot(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
|
|
b, _ := servedBy(t)
|
|
|
|
r := &recorder{}
|
|
checkDHCPState(db, testSubnetName, twoSubnet(), b, r)
|
|
|
|
if !r.hasProblemContaining("dhcp reservation missing on the server") {
|
|
t.Errorf("a lost set-host order must be reported, got %+v", r.calls)
|
|
}
|
|
if !r.hasProblemContaining("vm vm-web") {
|
|
t.Errorf("the report must name the vm, got %+v", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPState_ReportsAStaleReservation(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedKV(t, db, "subnet/"+testSubnetName+"/vpc", testVPC)
|
|
|
|
b, _ := servedBy(t)
|
|
if err := b.SetVM(twoSubnet(), "vm-gone", []dhcpbackend.Reservation{
|
|
{Index: 0, MAC: "00:22:33:00:00:0A", IP: "10.0.5.10", DefaultRoute: true},
|
|
}); err != nil {
|
|
t.Fatalf("SetVM: %v", err)
|
|
}
|
|
|
|
r := &recorder{}
|
|
checkDHCPState(db, testSubnetName, twoSubnet(), b, r)
|
|
|
|
if !r.hasProblemContaining("stale dhcp reservation on the server") {
|
|
t.Errorf("a lost del-host order must be reported, got %+v", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPState_ReportsADivergingIP(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
|
|
b, _ := servedBy(t)
|
|
if err := b.SetVM(twoSubnet(), "vm-web", []dhcpbackend.Reservation{
|
|
{Index: 0, MAC: "00:22:33:00:00:0A", IP: "10.0.5.99", DefaultRoute: true},
|
|
}); err != nil {
|
|
t.Fatalf("SetVM: %v", err)
|
|
}
|
|
|
|
r := &recorder{}
|
|
checkDHCPState(db, testSubnetName, twoSubnet(), b, r)
|
|
|
|
if !r.hasProblemContaining("dhcp reservation diverges") {
|
|
t.Errorf("a mac served with the wrong address must be reported, got %+v", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPState_ReportsADivergingDefaultRoute(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedSubnetWithVM(t, db, "vm-web", "10.0.5.10", "00:22:33:00:00:0A", true)
|
|
|
|
b, _ := servedBy(t)
|
|
if err := b.SetVM(twoSubnet(), "vm-web", []dhcpbackend.Reservation{
|
|
{Index: 0, MAC: "00:22:33:00:00:0A", IP: "10.0.5.10", DefaultRoute: false},
|
|
}); err != nil {
|
|
t.Fatalf("SetVM: %v", err)
|
|
}
|
|
|
|
r := &recorder{}
|
|
checkDHCPState(db, testSubnetName, twoSubnet(), b, r)
|
|
|
|
if !r.hasProblemContaining("dhcp default route diverges") {
|
|
t.Errorf("a wrong default route would break multi-subnet routing, got %+v", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPState_ReportsAnUnreachableServer(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedKV(t, db, "subnet/"+testSubnetName+"/vpc", testVPC)
|
|
|
|
b := dhcpbackend.Two{RunDir: shortTempDir(t)}
|
|
|
|
r := &recorder{}
|
|
checkDHCPState(db, testSubnetName, twoSubnet(), b, r)
|
|
|
|
if !r.hasProblemContaining("dhcp server unreachable") {
|
|
t.Errorf("a dead server must be reported, got %+v", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPState_ReportsAServerWithNoSubnetConfiguration(t *testing.T) {
|
|
db := newTestDB(t)
|
|
seedKV(t, db, "subnet/"+testSubnetName+"/vpc", testVPC)
|
|
|
|
b := dhcpbackend.Two{RunDir: shortTempDir(t)}
|
|
s := twoSubnet()
|
|
store := dhcpd.NewStore(dhcpapi.StatePath(b.RunDir, s.Instance()))
|
|
if err := store.Load(); err != nil {
|
|
t.Fatalf("Load: %v", err)
|
|
}
|
|
server, err := dhcpapi.Listen(store, dhcpapi.SocketPath(b.RunDir, s.Instance()), slog.New(slog.NewTextHandler(io.Discard, nil)))
|
|
if err != nil {
|
|
t.Fatalf("Listen: %v", err)
|
|
}
|
|
go server.Serve()
|
|
t.Cleanup(func() { server.Close() })
|
|
|
|
r := &recorder{}
|
|
checkDHCPState(db, testSubnetName, s, b, r)
|
|
|
|
if !r.hasProblemContaining("no subnet configuration") {
|
|
t.Errorf("a server that was never configured serves nothing, got %+v", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCPConfigFile_ReportsAMissingDnsmasqConfig(t *testing.T) {
|
|
r := &recorder{}
|
|
checkDHCPConfigFile(testSubnetName, filepath.Join(t.TempDir(), "absent.conf"), r)
|
|
|
|
if !r.hasProblemContaining("dnsmasq config missing") {
|
|
t.Errorf("notifications = %+v, want the missing config reported", r.calls)
|
|
}
|
|
}
|
|
|
|
func TestCheckDHCP_WithoutABackendChecksNothing(t *testing.T) {
|
|
db := newTestDB(t)
|
|
r := &recorder{}
|
|
|
|
checkDHCP(db, testSubnetName, twoSubnet(), nil, nil, r)
|
|
|
|
if len(r.calls) != 0 {
|
|
t.Errorf("notifications = %+v, want none: the caller already reported the unusable backend", r.calls)
|
|
}
|
|
}
|