fix(dhcp): one refused reservation no longer stops the apply
driver / lint (pull_request) Successful in 18s
driver / standard (pull_request) Failing after 22s
driver / types (pull_request) Successful in 1m22s
driver / test (3.12) (pull_request) Successful in 1m28s
driver / test (3.13) (pull_request) Successful in 1m26s
driver / lowest (pull_request) Successful in 38s
driver / build (pull_request) Successful in 38s
driver / security (pull_request) Successful in 1m11s
CI / driver (pull_request) Failing after 2m57s
driver / publish (pull_request) Skipped

apply_dhcp_reservationset wrote the diff one reservation at a time and
committed only after the last. A write the device refused -- on
OPNsense, an address in a subnet Kea does not manage -- ended the run
before the commit: every later reservation went unwritten, and the
earlier ones stayed saved but inactive. The next diff read those back as
configured, reported no changes and never committed them.

A refused change now gets a "[failed] <mac> -> <ip>: <reason>" line and
the others are still written. Any non-empty diff commits, also one whose
every write was refused, so writes an interrupted earlier run saved take
effect. DhcpApplyError (a RuntimeError, exported) is raised after the
commit with how many of how many changes were refused.

Refs NetOrk/netork#2381
This commit is contained in:
christianmanivong committed 2026-11-11 22:03:52 +01:00
1 parent 6c7f164004
commit c74173523a
5 files changed
+160 -19

No files matched your search

+90 -1
View File
@@ -14,7 +14,7 @@ from typing import Any
import pytest
from napalm_device_types import DhcpServerMixin, FirewallDriver, ResidentialGatewayDriver
from napalm_device_types.dhcp import normalize_mac
from napalm_device_types.dhcp import DhcpApplyError, normalize_mac
from napalm_device_types.models import DhcpReservationDict
@@ -209,6 +209,95 @@ class TestApplyReservationSet:
assert lines == ["[commit] no changes"]
class _RefusingDhcpServer(_FakeDhcpServer):
"""A server that refuses the reservations for the IPs in *refused*, as Kea does
for one whose subnet it does not manage."""
def __init__(self, live: list[DhcpReservationDict] | None = None, *, refused: set[str]) -> None:
super().__init__(live)
self.refused = refused
def apply_dhcp_reservation(
self, reservation: DhcpReservationDict, *, uuid: str | None = None
) -> dict[str, Any]:
if reservation["ip"] in self.refused:
raise ValueError(f"No Kea-managed subnet contains {reservation['ip']}")
return super().apply_dhcp_reservation(reservation, uuid=uuid)
def _three() -> list[DhcpReservationDict]:
return [
_reservation(mac="aa:bb:cc:dd:ee:01", ip="10.10.20.50"),
_reservation(mac="aa:bb:cc:dd:ee:02", ip="10.10.99.5", subnet=""),
_reservation(mac="aa:bb:cc:dd:ee:03", ip="10.10.20.52"),
]
class TestApplyWithARefusedReservation:
"""One reservation the server refuses must not hold back the others, and what was
written must take effect: a server that saved a write and was never committed shows
it as configured, so the next apply finds nothing to do and never commits it."""
def test_the_others_are_still_written(self):
driver = _RefusingDhcpServer(refused={"10.10.99.5"})
with pytest.raises(DhcpApplyError):
list(driver.apply_dhcp_reservationset(_three()))
assert [entry["reservation"]["ip"] for entry in driver.applied] == [
"10.10.20.50",
"10.10.20.52",
]
def test_what_was_written_is_committed(self):
driver = _RefusingDhcpServer(refused={"10.10.99.5"})
with pytest.raises(DhcpApplyError):
list(driver.apply_dhcp_reservationset(_three()))
assert driver.commits == 1
def test_a_refused_set_still_commits(self):
# An earlier apply that stopped before its commit left saved writes behind; a
# run whose every write is refused commits too, so those take effect.
driver = _RefusingDhcpServer(refused={"10.10.99.5"})
with pytest.raises(DhcpApplyError):
list(driver.apply_dhcp_reservationset([_three()[1]]))
assert driver.commits == 1
def test_progress_names_the_refused_one_and_why(self):
driver = _RefusingDhcpServer(refused={"10.10.99.5"})
lines: list[str] = []
with pytest.raises(DhcpApplyError) as raised:
for line in driver.apply_dhcp_reservationset(_three()):
lines.append(line)
failed = [line for line in lines if line.startswith("[failed]")]
assert failed == [
"[failed] aa:bb:cc:dd:ee:02 -> 10.10.99.5: No Kea-managed subnet contains 10.10.99.5"
]
assert lines[-1] == "[commit] applied 2 add(s), 0 update(s)"
assert "1 of 3" in str(raised.value)
def test_a_refused_update_is_reported_like_an_add(self):
driver = _RefusingDhcpServer(
[_reservation(uuid="u1", ip="10.10.20.9")], refused={"10.10.20.50"}
)
with pytest.raises(DhcpApplyError, match="1 of 1"):
list(driver.apply_dhcp_reservationset([_reservation()]))
assert driver.applied == []
assert driver.commits == 1
def test_the_error_is_a_runtime_error(self):
# Callers that catch RuntimeError for a failed apply keep working.
assert issubclass(DhcpApplyError, RuntimeError)
class TestKeysThatCannotNameOneReservation:
def test_a_live_reservation_without_mac_is_never_matched(self):
driver = _FakeDhcpServer([_reservation(uuid="b", mac="")])