f-78: watchdog: réservations DHCP des VM en creating, deleting ou error non comparées #78

Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
This commit is contained in:
GnomeZworc 2026-10-19 16:50:35 +02:00
commit ee1737fedc
Signed by: nicolas.boufideline
GPG key ID: 4406BBBF8845D632
6 changed files with 135 additions and 20 deletions

View file

@ -25,28 +25,58 @@ type stateReporter interface {
State(s dhcpbackend.Subnet) (dhcpapi.State, string, error)
}
func expectedHosts(db *badger.DB, subnetName string) ([]dhcpapi.Host, error) {
func expectedHosts(db *badger.DB, subnetName string) (hosts []dhcpapi.Host, transient map[string]bool, err error) {
pairs, err := kv.ListByPrefix(db, prefixVM)
if err != nil {
return nil, fmt.Errorf("listing vms: %w", err)
return nil, nil, fmt.Errorf("listing vms: %w", err)
}
hosts := make([]dhcpapi.Host, 0)
hosts, transient = make([]dhcpapi.Host, 0), map[string]bool{}
for _, vmName := range resourceNames(pairs, prefixVM) {
st, err := state.Get(db, prefixVM+vmName)
if err != nil || st != state.Running {
if err != nil {
continue
}
if st == state.Creating || st == state.Deleting || st == state.Error {
transient[vmName] = true
continue
}
if st != state.Running {
continue
}
vmHosts, err := expectedVMHosts(db, vmName, subnetName)
if err != nil {
return nil, err
return nil, nil, err
}
hosts = append(hosts, vmHosts...)
}
dhcpapi.SortHosts(hosts)
return hosts, nil
return hosts, transient, nil
}
func withoutTransient(served, expected []dhcpapi.Host, transient map[string]bool) []dhcpapi.Host {
wanted := make(map[string]bool, len(expected))
for _, h := range expected {
wanted[canonicalMAC(h)] = true
}
kept := make([]dhcpapi.Host, 0, len(served))
for _, h := range served {
if transient[h.VM] && !wanted[canonicalMAC(h)] {
continue
}
kept = append(kept, h)
}
return kept
}
func canonicalMAC(h dhcpapi.Host) string {
if c, err := dhcpapi.CanonicalHost(h); err == nil {
return c.MAC
}
return h.MAC
}
func expectedVMHosts(db *badger.DB, vmName, subnetName string) ([]dhcpapi.Host, error) {
@ -125,18 +155,19 @@ func checkDHCPState(db *badger.DB, name string, s dhcpbackend.Subnet, r stateRep
n.Notify(kindSubnet, name, "dhcp server has no subnet configuration: it serves nothing")
}
expected, err := expectedHosts(db, name)
expected, transient, err := expectedHosts(db, name)
if err != nil {
n.Notify(kindSubnet, name, fmt.Sprintf("expected dhcp reservations unreadable in database: %v", err))
return
}
hosts := withoutTransient(served.Hosts, expected, transient)
expectedDigest, err := dhcpapi.Digest(dhcpapi.State{Hosts: expected})
if err != nil {
n.Notify(kindSubnet, name, fmt.Sprintf("expected dhcp reservations inconsistent in database: %v", err))
return
}
servedDigest, err := dhcpapi.Digest(dhcpapi.State{Hosts: served.Hosts})
servedDigest, err := dhcpapi.Digest(dhcpapi.State{Hosts: hosts})
if err != nil {
n.Notify(kindSubnet, name, fmt.Sprintf("dhcp reservations reported by the server are inconsistent: %v", err))
return
@ -145,7 +176,7 @@ func checkDHCPState(db *badger.DB, name string, s dhcpbackend.Subnet, r stateRep
return
}
for _, gap := range reservationGaps(expected, served.Hosts) {
for _, gap := range reservationGaps(expected, hosts) {
n.Notify(kindSubnet, name, gap)
}
}

View file

@ -83,7 +83,7 @@ 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)
hosts, _, err := expectedHosts(db, testSubnetName)
if err != nil {
t.Fatalf("expectedHosts: %v", err)
}
@ -105,13 +105,16 @@ func TestExpectedHosts_IgnoresVMsThatAreNotRunning(t *testing.T) {
t.Fatalf("state.Set: %v", err)
}
hosts, err := expectedHosts(db, testSubnetName)
hosts, transient, 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)
}
if !transient["vm-web"] {
t.Errorf("transient = %v, want vm-web: a vm being deleted may still be served", transient)
}
}
func TestExpectedHosts_IgnoresInterfacesOnOtherSubnets(t *testing.T) {
@ -121,7 +124,7 @@ func TestExpectedHosts_IgnoresInterfacesOnOtherSubnets(t *testing.T) {
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)
hosts, _, err := expectedHosts(db, testSubnetName)
if err != nil {
t.Fatalf("expectedHosts: %v", err)
}
@ -135,7 +138,7 @@ func TestExpectedHosts_SortsByMAC(t *testing.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)
hosts, _, err := expectedHosts(db, testSubnetName)
if err != nil {
t.Fatalf("expectedHosts: %v", err)
}
@ -149,7 +152,7 @@ func TestExpectedHosts_ReportsAnIPWithoutAMAC(t *testing.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 {
if _, _, err := expectedHosts(db, testSubnetName); err == nil {
t.Fatal("an ip absent from the address plan must be reported, not skipped")
}
}
@ -250,6 +253,83 @@ func TestCheckDHCPState_ReportsAStaleReservation(t *testing.T) {
}
}
func TestCheckDHCPState_ToleratesAVMInATransientState(t *testing.T) {
for _, st := range []state.State{state.Creating, state.Deleting, state.Error} {
t.Run(string(st), func(t *testing.T) {
for _, served := range []bool{true, false} {
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", st); err != nil {
t.Fatalf("state.Set: %v", err)
}
b, _ := servedBy(t)
if served {
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("served=%t: notifications = %+v, want none while the vm is %s", served, r.calls, st)
}
}
})
}
}
func TestCheckDHCPState_ToleranceIsLimitedToTheTransientVM(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)
}
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)
}
if err := b.SetVM(twoSubnet(), "vm-gone", []dhcpbackend.Reservation{
{Index: 0, MAC: "00:22:33:00:00:0B", IP: "10.0.5.11", DefaultRoute: true},
}); err != nil {
t.Fatalf("SetVM: %v", err)
}
r := &recorder{}
checkDHCPState(db, testSubnetName, twoSubnet(), b, r)
if len(r.calls) != 1 || !r.hasProblemContaining("stale dhcp reservation on the server: 00:22:33:00:00:0b") {
t.Errorf("notifications = %+v, want only the reservation of the vm that no longer exists", r.calls)
}
}
func TestCheckDHCPState_AReservationOfATransientVMOnAnExpectedMACIsStillCompared(t *testing.T) {
db := newTestDB(t)
seedSubnetWithVM(t, db, "vm-new", "10.0.5.10", "00:22:33:00:00:0A", true)
seedResource(t, db, "vm/", "vm-old", state.Deleting)
b, _ := servedBy(t)
if err := b.SetVM(twoSubnet(), "vm-old", []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 || !r.hasProblemContaining("dhcp reservation diverges") {
t.Errorf("notifications = %+v, want the divergence on the mac a running vm expects", 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)