Files
napalm-proxmox/tests/test_time_sync.py
T
Christian Manivong 66828a9564
driver / lint (pull_request) Successful in 13s
driver / standard (pull_request) Successful in 16s
driver / types (pull_request) Successful in 51s
driver / test (3.13) (pull_request) Successful in 53s
driver / test (3.12) (pull_request) Successful in 1m0s
driver / lowest (pull_request) Successful in 28s
driver / build (pull_request) Successful in 25s
driver / security (pull_request) Successful in 54s
CI / driver (pull_request) Successful in 2m3s
driver / publish (pull_request) Skipped
test(time-sync): follow napalm-device-types 4.36.0, which keeps DHCP's servers
napalm-device-types 4.36.0 (released after main's last CI run) changed
PosixTimeSyncMixin: get_time_sync() reports DHCP-provided servers apart
(dhcp_ntp_servers), and configure_time_sync() no longer comments out the
DHCP client's chrony sourcedir; it gives back one that 4.35.0 took out
(NetOrk/netork#2380). CI installs the newest release, so five time-sync
tests failed on every branch.

The tests now expect that behaviour, read DHCP's servers apart, and check
that a node 4.35.0 aligned gets its DHCP sourcedir back. The floor moves
to 4.36.0, so the lowest-versions job tests the same behaviour; README,
CHANGELOG and the module docstring say what a write leaves alone.
2026-11-13 08:55:37 +01:00

398 lines
15 KiB
Python

"""Time sync on a Proxmox VE node and a Proxmox Backup Server (NetOrk/netork#2365).
Neither API keeps time servers: both products run chrony on Debian. The servers
are napalm-device-types' ``PosixTimeSyncMixin``'s, over the driver's SSH session
(``run_command``, as root); the zone is read from the host the same way and
written through the product's own ``PUT /nodes/{node}/time``, which also keeps
``/etc/timezone`` for the web UI. One netOrk device is one node: a PVE node in a
cluster has its own clock, and only that node is written.
The readings are what ``reading_command`` prints on a PVE 8 / PBS 3 host (Debian
12's chrony 4.3, its configuration comments shortened).
"""
from __future__ import annotations
from typing import Any
from unittest.mock import patch
import pytest
from napalm_device_types import CommandResult, PosixTimeSyncMixin, TimeSyncMixin
from proxmoxer.core import ResourceException
from napalm_proxmox import ProxmoxBackupDriver, ProxmoxDriver
from tests.conftest import _build_mock_api
from tests.pbs_fake import FakePbsApi, forbidden
_ACTIVE_CHRONY = """\
chrony chrony active
chronyd chrony active
systemd-timesyncd systemd-timesyncd inactive
ntpsec ntpd inactive
ntp ntpd inactive
ntpd ntpd inactive
openntpd openntpd inactive"""
_CHRONYC_SYNCED = """\
MS Name/IP address Stratum Poll Reach LastRx Last sample
===============================================================================
^- 162.159.200.123 3 6 377 41 +814us[ +814us] +/- 14ms
^* 185.248.188.98 2 6 377 40 -45us[ -63us] +/- 10ms"""
#: Debian 12's /etc/chrony/chrony.conf as Proxmox VE 8 and PBS 3 ship it.
_CHRONY_CONF = """\
# Welcome to the chrony configuration file. See chrony.conf(5) for more
# information about usable directives.
# Include configuration files found in /etc/chrony/conf.d.
confdir /etc/chrony/conf.d
# Use Debian vendor zone.
{pool}pool 2.debian.pool.ntp.org iburst
# Use time sources from DHCP.
{dhcp}sourcedir /run/chrony-dhcp
# Use NTP sources found in /etc/chrony/sources.d.
sourcedir /etc/chrony/sources.d
keyfile /etc/chrony/chrony.keys
driftfile /var/lib/chrony/chrony.drift
ntsdumpdir /var/lib/chrony
logdir /var/log/chrony
maxupdateskew 100.0
rtcsync
makestep 1 3
leapsectz right/UTC"""
_MARK = "#napalm-time-sync: "
def _reading(
zone: str = "Europe/Berlin",
*,
servers: tuple[str, ...] = (),
dhcp: tuple[str, ...] = (),
deaf_to_dhcp: bool = False,
timedatectl: bool = True,
) -> str:
"""What the reading prints; *servers* in netOrk's sources file, the vendor's pool
commented out with it (as a write leaves the host), *dhcp* in the DHCP client's
sources file. *deaf_to_dhcp* is a host napalm-device-types 4.35.0 aligned: its write
commented out the DHCP ``sourcedir`` too."""
written = bool(servers)
conf = _CHRONY_CONF.format(pool=_MARK if written else "", dhcp=_MARK if deaf_to_dhcp else "")
parts = ["@@ts timedatectl"]
if timedatectl:
parts += [
f"Timezone={zone}",
"LocalRTC=no",
"CanNTP=yes",
"NTP=yes",
"NTPSynchronized=yes",
"TimeUSec=Wed 2026-11-11 14:23:16 CET",
"RTCTimeUSec=Wed 2026-11-11 13:23:16 CET",
]
parts += ["@@ts zone", zone if timedatectl else ""]
parts += ["@@ts active", _ACTIVE_CHRONY, "@@ts timesync", "@@ts chronyc", _CHRONYC_SYNCED]
parts += ["@@ts chrony 0 main /etc/chrony/chrony.conf", conf, ""]
if dhcp:
parts += ["@@ts chrony 11 sourcedir /run/chrony-dhcp/vmbr0.sources"]
parts += [f"server {s} iburst" for s in dhcp]
parts += [""]
if written:
parts += ["@@ts chrony 14 sourcedir /etc/chrony/sources.d/netork.sources"]
parts += [f"{'pool' if '.pool.' in s else 'server'} {s} iburst" for s in servers]
parts += [""]
parts += ["@@ts end", ""]
return "\n".join(parts)
class Node:
"""The node's command channel: the readings in turn (the last one stays), and
every other command succeeds. Records ``(command, privileged, stdin)``."""
def __init__(self, *readings: str) -> None:
self.readings = list(readings)
self.calls: list[tuple[str, bool, bytes | None]] = []
def __call__(
self,
command: str,
*,
privileged: bool = False,
timeout: float = 60,
stdin: bytes | None = None,
) -> CommandResult:
self.calls.append((command, privileged, stdin))
if "@@ts timedatectl" in command:
reading = self.readings.pop(0) if len(self.readings) > 1 else self.readings[0]
return CommandResult(reading, "", 0)
if command.startswith("t=$(mktemp)"):
return CommandResult("/tmp/tmp.Xk3fQ9", "", 0)
return CommandResult("", "", 0)
def root(self) -> list[str]:
return [c for c, privileged, _ in self.calls if privileged]
def staged(self) -> list[bytes]:
return [stdin for _, _, stdin in self.calls if stdin is not None]
def _pve(*readings: str, node: str | None = None) -> tuple[ProxmoxDriver, Any, Node]:
args = {"verify_ssl": False} if node is None else {"verify_ssl": False, "node": node}
driver = ProxmoxDriver("pve1.example.com", "root", "secret", optional_args=args)
api = _build_mock_api()
with patch("napalm_proxmox.driver.ProxmoxAPI", return_value=api):
driver.open()
shell = Node(*readings)
driver.run_command = shell # type: ignore[method-assign]
return driver, api, shell
def _pbs(*readings: str, **responses: Any) -> tuple[ProxmoxBackupDriver, FakePbsApi, Node]:
api = FakePbsApi(**responses)
driver = ProxmoxBackupDriver("pbs1.example.com", "root@pam", "secret")
with patch("napalm_proxmox.backup_driver.ProxmoxAPI", return_value=api):
driver.open()
shell = Node(*readings)
driver.run_command = shell # type: ignore[method-assign]
return driver, api, shell
# -- the contract -----------------------------------------------------------------------------
@pytest.mark.parametrize("cls", [ProxmoxDriver, ProxmoxBackupDriver], ids=["pve", "pbs"])
def test_both_drivers_read_and_write_servers_and_zone(cls: type) -> None:
assert issubclass(cls, TimeSyncMixin)
assert issubclass(cls, PosixTimeSyncMixin)
assert callable(getattr(cls, "get_time_sync", None))
assert callable(getattr(cls, "configure_time_sync", None))
assert cls.time_sync_writes == frozenset({"ntp_servers", "timezone"})
# -- reading ----------------------------------------------------------------------------------
def test_pve_reads_chrony_and_the_zone_in_one_round_trip() -> None:
driver, api, shell = _pve(_reading())
assert driver.get_time_sync() == {
"ntp_servers": ["2.debian.pool.ntp.org"],
"dhcp_ntp_servers": [],
"timezone": "Europe/Berlin",
"synchronized": True,
"daemon": "chrony",
}
assert len(shell.calls) == 1
assert shell.root() == [] # the reading writes nothing
api.nodes.return_value.time.put.assert_not_called()
def test_pbs_reads_chrony_and_the_zone() -> None:
driver, api, shell = _pbs(_reading("Europe/Vienna", servers=("10.0.0.1",)))
assert driver.get_time_sync() == {
"ntp_servers": ["10.0.0.1"],
"dhcp_ntp_servers": [],
"timezone": "Europe/Vienna",
"synchronized": True,
"daemon": "chrony",
}
assert len(shell.calls) == 1
assert not [c for c in api.calls if c[0] != "GET"]
def test_servers_from_dhcp_are_read_apart_from_the_configured_ones() -> None:
"""A node that gets its time giver by DHCP (option 42): chrony reads the DHCP
client's sources file, and those servers are not the node's own (NetOrk/netork#2380)."""
driver, _, _ = _pve(_reading(dhcp=("192.168.1.1",)))
reading = driver.get_time_sync()
assert reading["ntp_servers"] == ["2.debian.pool.ntp.org"]
assert reading["dhcp_ntp_servers"] == ["192.168.1.1"]
def test_a_host_without_a_zone_of_its_own_reads_the_apis() -> None:
"""No timedatectl and no /etc/timezone or /etc/localtime link: the API's word."""
driver, api, _ = _pve(_reading(timedatectl=False))
api.nodes.return_value.time.get.return_value = {"timezone": "Europe/Paris"}
assert driver.get_time_sync()["timezone"] == "Europe/Paris"
def test_no_zone_anywhere_reads_none() -> None:
driver, _, _ = _pbs(_reading(timedatectl=False), **{"nodes/localhost/time": forbidden()})
assert driver.get_time_sync()["timezone"] is None
def test_a_cut_reading_raises() -> None:
driver, _, _ = _pve("@@ts timedatectl\nTimezone=Europe/Berlin\n")
with pytest.raises(ValueError, match="cut short"):
driver.get_time_sync()
@pytest.mark.parametrize("make", [_pve, _pbs], ids=["pve", "pbs"])
def test_get_ntp_servers_is_what_get_time_sync_reads(make: Any) -> None:
servers = ("10.0.0.1", "0.de.pool.ntp.org")
driver, _, _ = make(_reading(servers=servers))
assert list(driver.get_ntp_servers()) == list(servers)
assert driver.get_ntp_servers() == {s: {} for s in driver.get_time_sync()["ntp_servers"]}
def test_get_ntp_servers_no_longer_asks_an_api_path_pve_does_not_have() -> None:
"""``GET /nodes/{node}/ntp`` does not exist; asking it read as "no servers"."""
driver, api, _ = _pve(_reading())
assert driver.get_ntp_servers() == {"2.debian.pool.ntp.org": {}}
api.nodes.return_value.ntp.get.assert_not_called()
# -- writing the zone -------------------------------------------------------------------------
def test_pve_writes_the_zone_through_its_node_api_and_reads_it_back() -> None:
driver, api, shell = _pve(_reading("Europe/Vienna"))
result = driver.configure_time_sync(timezone="Europe/Vienna")
assert result["success"], result["output"]
assert [s["step"] for s in result["steps"]] == ["timezone", "verify"]
api.nodes.return_value.time.put.assert_called_once_with(timezone="Europe/Vienna")
assert shell.root() == [] # not timedatectl: the API keeps /etc/timezone as well
def test_in_a_cluster_only_this_node_is_written() -> None:
driver, api, _ = _pve(_reading("Europe/Vienna"), node="pve2")
api.nodes.reset_mock()
driver.configure_time_sync(timezone="Europe/Vienna")
assert {c.args for c in api.nodes.call_args_list} == {("pve2",)}
api.nodes.return_value.time.put.assert_called_once_with(timezone="Europe/Vienna")
def test_pbs_writes_the_zone_through_its_api() -> None:
driver, api, _ = _pbs(_reading("Europe/Vienna"), **{"PUT nodes/localhost/time": None})
result = driver.configure_time_sync(timezone="Europe/Vienna")
assert result["success"], result["output"]
assert ("PUT", "nodes/localhost/time", {"timezone": "Europe/Vienna"}) in api.calls
def test_a_refused_zone_fails_the_step_and_says_why() -> None:
"""An API token without ``Sys.Modify``: the step fails, nothing else is tried."""
driver, api, shell = _pbs(_reading(), **{"PUT nodes/localhost/time": forbidden()})
result = driver.configure_time_sync(timezone="Europe/Vienna")
assert not result["success"]
assert result["steps"][-1]["step"] == "timezone"
assert "403" in result["steps"][-1]["output"]
assert shell.calls == []
def test_a_zone_the_device_did_not_take_fails_verify() -> None:
driver, api, _ = _pve(_reading("Europe/Berlin"))
result = driver.configure_time_sync(timezone="Europe/Vienna")
assert not result["success"]
assert result["steps"][-1] == {
"step": "verify",
"ok": False,
"output": "the device is in the time zone Europe/Berlin",
}
def test_a_proxmoxer_error_on_the_zone_is_the_steps_output() -> None:
driver, api, _ = _pve(_reading())
api.nodes.return_value.time.put.side_effect = ResourceException(
400, "Bad Request", "Parameter verification failed: timezone: No such timezone"
)
result = driver.configure_time_sync(timezone="Europe/Vienna")
assert not result["success"]
assert "No such timezone" in result["steps"][0]["output"]
# -- writing the servers ----------------------------------------------------------------------
@pytest.mark.parametrize("make", [_pve, _pbs], ids=["pve", "pbs"])
def test_servers_go_to_chronys_sources_d_and_the_vendor_pool_stops_counting(make: Any) -> None:
servers = ["10.0.0.1", "0.de.pool.ntp.org"]
driver, _, shell = make(_reading(), _reading(servers=tuple(servers)))
result = driver.configure_time_sync(ntp_servers=servers)
assert result["success"], result["output"]
assert shell.staged() == [b"server 10.0.0.1 iburst\npool 0.de.pool.ntp.org iburst\n"]
root = shell.root()
assert any(
"/etc/chrony/sources.d/netork.sources" in c and c.startswith("install") for c in root
)
# line 8 is the vendor's pool, in the main file, which chronyd reads only when it
# starts. Line 11, the DHCP client's sourcedir, stays: DHCP's servers count.
sed = next(c for c in root if c.startswith("sed -i"))
assert "8{" in sed and "11{" not in sed and sed.endswith("/etc/chrony/chrony.conf")
assert root[-1] == "systemctl restart chrony.service"
def test_a_write_gives_back_the_dhcp_sourcedir_an_earlier_write_took() -> None:
"""A node napalm-device-types 4.35.0 aligned hears DHCP again (NetOrk/netork#2380)."""
servers = ("10.0.0.1",)
driver, _, shell = _pve(_reading(servers=servers, deaf_to_dhcp=True), _reading(servers=servers))
result = driver.configure_time_sync(ntp_servers=list(servers))
assert result["success"], result["output"]
root = shell.root()
sed = next(c for c in root if c.startswith("sed -i"))
assert "11{s/^#napalm-time-sync: (sourcedir" in sed
assert sed.endswith("/etc/chrony/chrony.conf")
assert root[-1] == "systemctl restart chrony.service"
def test_servers_already_written_are_written_the_same_way_again() -> None:
"""No churn: the second write stages the same file and comments out nothing."""
servers = ("10.0.0.1",)
driver, _, shell = _pve(_reading(servers=servers))
result = driver.configure_time_sync(ntp_servers=list(servers))
assert result["success"], result["output"]
assert shell.staged() == [b"server 10.0.0.1 iburst\n"]
assert not [c for c in shell.root() if c.startswith("sed")]
assert "chronyc reload sources" in shell.root()
def test_both_values_in_one_change() -> None:
driver, api, _ = _pve(_reading(), _reading("Europe/Vienna", servers=("10.0.0.1",)))
result = driver.configure_time_sync(ntp_servers=["10.0.0.1"], timezone="Europe/Vienna")
assert result["success"], result["output"]
assert [s["step"] for s in result["steps"]] == ["ntp_servers", "timezone", "verify"]
api.nodes.return_value.time.put.assert_called_once_with(timezone="Europe/Vienna")
def test_the_templates_refusals_hold() -> None:
driver, api, shell = _pve(_reading())
with pytest.raises(ValueError):
driver.configure_time_sync()
with pytest.raises(ValueError):
driver.configure_time_sync(ntp_servers=["not a server"])
with pytest.raises(ValueError):
driver.configure_time_sync(timezone="CET-1CEST,M3.5.0,M10.5.0/3")
assert shell.calls == []
api.nodes.return_value.time.put.assert_not_called()