From ac38c68febcbecf1e26c461d8b62d33a7808f2d0 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Wed, 11 Nov 2026 22:08:52 +0100 Subject: [PATCH] feat(time-sync): DHCP-provided NTP servers count and are read apart A device that gets the site's time giver through DHCP option 42 is aligned (NetOrk/netork#2380): most clients already learn it that way. 4.35.0 switched that off on every write -- chrony's DHCP sourcedir was commented out, and systemd-timesyncd's link servers failed the verify step -- and folded DHCP's servers into ntp_servers, so an application could not tell configured from DHCP-provided servers. TimeSyncDict gains dhcp_ntp_servers (not required): the servers the device got by DHCP and uses, in its order; [] for none, absent or None where the driver cannot tell. ntp_servers keeps only the configured ones. PosixTimeSyncMixin reads chrony's sources from the DHCP client's sourcedir (CHRONY_DHCP_DIRS, /run/chrony-dhcp by default) as chronyd reads them, and systemd-timesyncd's LinkNTPServers; ntpd and OpenNTPD keep DHCP's servers in a configuration of their own, so there it is unknown. A chrony write now comments out only server, pool and peer lines and leaves every sourcedir and the DHCP client's files alone. A DHCP sourcedir that 4.35.0 commented out behind the mark is given back on the next write, with a restart, so hosts it aligned hear DHCP again. Version 4.36.0. --- CHANGELOG.md | 24 ++++ README.md | 24 ++-- napalm_device_types/_chrony.py | 92 ++++++++----- napalm_device_types/_time_sync_reading.py | 102 ++++++++++++--- napalm_device_types/time_sync.py | 33 +++-- napalm_device_types/time_sync_posix.py | 28 +++- pyproject.toml | 2 +- tests/test_time_sync.py | 14 ++ tests/test_time_sync_posix.py | 149 +++++++++++++++++++--- 9 files changed, 379 insertions(+), 89 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 21c21a1..fcaaafb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,30 @@ recorded here; their history is the git log. ## [Unreleased] +## [4.36.0] - 2026-11-11 + +### Added +- `TimeSyncDict.dhcp_ntp_servers` (not required): the NTP servers a device got by DHCP + (option 42) and uses, in its order; `[]` for none, absent or None where the driver cannot + tell. `ntp_servers` stays the servers configured on the device and no longer holds + DHCP's. A device that gets the site's time giver by DHCP is aligned, so an application + has to tell the two apart (NetOrk/netork#2380). +- `PosixTimeSyncMixin` reads them: chrony's sources from the DHCP client's `sourcedir` + (`CHRONY_DHCP_DIRS`, `/run/chrony-dhcp` by default), systemd-timesyncd's + `LinkNTPServers`. Where ntpd or OpenNTPD runs they are unknown (None). + `timesyncd_link_servers` is public. + +### Changed +- `configure_time_sync` leaves DHCP-provided NTP servers alone. chrony: only `server`, + `pool` and `peer` lines are commented out; no `sourcedir` line is any more, and the DHCP + client's files are left alone. systemd-timesyncd: a link's servers stay and no longer + fail the `verify` step. +- A write gives back a DHCP client's `sourcedir` that 4.35.0 commented out + (`#napalm-time-sync: sourcedir /run/chrony-dhcp`), so a host aligned by 4.35.0 hears DHCP + again; chronyd restarts for it. Another `sourcedir` 4.35.0 took out stays out. +- `timesyncd_servers` returns the configured servers (runtime, then system) without a + link's; the fallback only while there is no server at all. + ## [4.35.0] - 2026-11-11 ### Added diff --git a/README.md b/README.md index ae3d2ce..fee08a6 100644 --- a/README.md +++ b/README.md @@ -348,10 +348,13 @@ cron expressions, gives their next runs and writes them as `OnCalendar` lines. `TimeSyncMixin` (`get_time_sync`, `configure_time_sync`) is how a device keeps its clock: the NTP servers it is configured with, in its order, its time zone as an IANA name, whether -it is synchronised now and which client does it (`TimeSyncDict`). `get_time_sync` is -declared only; `configure_time_sync(ntp_servers=None, timezone=None)` is a fix template -- -`None` leaves a value alone, the device ends up with exactly the servers given, in that -order, and a `verify` step reads it back. A zone that is not in the IANA database, a +it is synchronised now and which client does it (`TimeSyncDict`). The servers it got by +DHCP (option 42) and uses are apart, in `dhcp_ntp_servers` (`[]` for none, left out where +the driver cannot tell): DHCP counts, a device that gets the site's time giver that way is +aligned. `get_time_sync` is declared only; `configure_time_sync(ntp_servers=None, +timezone=None)` is a fix template -- `None` leaves a value alone, the device ends up +configured with exactly the servers given, in that order, its DHCP-provided servers left +alone, and a `verify` step reads it back. A zone that is not in the IANA database, a malformed server, an empty list or a value outside the driver's `time_sync_writes` is refused before anything is written. A driver states in `time_sync_writes` which of `ntp_servers` and `timezone` it can write (a BMC that runs on UTC only: `ntp_servers`). @@ -362,11 +365,14 @@ login user (`timedatectl show`, the active client: chrony's configuration and `c sources`, `timedatectl show-timesync`, `ntp.conf`, OpenNTPD's `ntpd.conf`); the zone by `timedatectl set-timezone`; chrony's servers in a file of their own -- `/etc/chrony/sources.d/netork.sources` where chrony reads that directory, else a `confdir` -or an included `/etc/chrony.d/netork.conf` -- with every other `server`, `pool`, `peer` and -foreign `sourcedir` line commented out behind `#napalm-time-sync: `, then `chronyc reload -sources` or a restart; systemd-timesyncd's in `/etc/systemd/timesyncd.conf.d/netork.conf` -(`NTP=` reset, `FallbackNTP=` emptied), then a restart. ntpd and OpenNTPD are read, not -written. +or an included `/etc/chrony.d/netork.conf` -- with every other `server`, `pool` and `peer` +line commented out behind `#napalm-time-sync: `, then `chronyc reload sources` or a +restart; systemd-timesyncd's in `/etc/systemd/timesyncd.conf.d/netork.conf` (`NTP=` reset, +`FallbackNTP=` emptied), then a restart. What DHCP brings is read apart and kept: chrony's +DHCP `sourcedir` (`CHRONY_DHCP_DIRS`, `/run/chrony-dhcp`) is never commented out -- one +that 4.35.0 commented out comes back on the next write -- and systemd-timesyncd's +`LinkNTPServers` stay. ntpd and OpenNTPD are read, not written; what DHCP gives them is +unknown. ### Access channels: why there is no container model here diff --git a/napalm_device_types/_chrony.py b/napalm_device_types/_chrony.py index 7de1e5c..6c3b422 100644 --- a/napalm_device_types/_chrony.py +++ b/napalm_device_types/_chrony.py @@ -10,10 +10,17 @@ The sources go to one file of their own (:func:`plan_chrony` picks it): 4. else the include file, with an ``include`` line appended to the main configuration (RHEL's ``/etc/chrony.conf``). -Every other source stops counting: a ``server``, ``pool`` or ``peer`` line in any -other file chrony reads is commented out behind :data:`COMMENT_MARK`, and so is a -``sourcedir`` line other than the one the sources file is in -- the DHCP client's -``/run/chrony-dhcp``, whose files are rewritten on every lease and so are left alone. +Every other configured source stops counting: a ``server``, ``pool`` or ``peer`` +line in any other file chrony reads is commented out behind :data:`COMMENT_MARK`. +``sourcedir`` lines stay. The DHCP client's directory (``/run/chrony-dhcp``) and its +files are left alone: DHCP option 42 counts (NetOrk/netork#2380), and the client +rewrites those files on every lease anyway. + +4.35.0 commented out every ``sourcedir`` other than the sources file's, the DHCP +client's among them, which left a host deaf to DHCP. A write gives a DHCP client's +``sourcedir`` back where it finds one behind :data:`COMMENT_MARK`; any other one it +took out stays out, its sources would be commented out now anyway. + chronyd reads its main configuration only when it starts: a change there means a restart. """ @@ -26,7 +33,12 @@ import shlex from dataclasses import dataclass, field from fnmatch import fnmatchcase -from napalm_device_types._time_sync_reading import SOURCE_LINE, ConfigFile +from napalm_device_types._time_sync_reading import ( + CHRONY_DHCP_DIRS, + SOURCE_LINE, + ConfigFile, + in_dhcp_dir, +) #: What a source line taken out of chrony's configuration starts with. COMMENT_MARK = "#napalm-time-sync: " @@ -34,6 +46,8 @@ COMMENT_MARK = "#napalm-time-sync: " INCLUDE_COMMENT = "# napalm-time-sync: the time sources" _DIRECTORY_LINE = re.compile(r"\s*(sourcedir|confdir|include)\s+(.+?)\s*$") +#: A ``sourcedir`` line 4.35.0 commented out. +_MARKED_SOURCEDIR = re.compile(rf"{re.escape(COMMENT_MARK)}sourcedir\s+(.+?)\s*$") @dataclass @@ -43,6 +57,7 @@ class ChronyPlan: target: str # the file the sources go to content: str comment_out: dict[str, list[int]] = field(default_factory=dict) # path: line numbers + restore: dict[str, list[int]] = field(default_factory=dict) # path: marked sourcedir lines include_in: str | None = None # the main configuration an include of target is appended to reload: bool = False # True: ``chronyc reload sources`` takes the change @@ -80,27 +95,27 @@ def _target(main: ConfigFile, sources_file: str, include_file: str) -> tuple[str return include_file, main.path, False -def _dropped_sourcedirs(main: ConfigFile, kept: str | None) -> set[int]: - """The ``sourcedir`` lines of *main* that do not name the directory *kept*.""" - return { - number - for number, kind, args in _directives(main) - if kind == "sourcedir" and (kept is None or kept not in args) - } - - -def _lines_to_comment(f: ConfigFile, dropped: set[int]) -> list[int]: +def _dhcp_sourcedirs_to_restore(main: ConfigFile, dhcp_dirs: tuple[str, ...]) -> list[int]: + """The lines of *main* where 4.35.0 commented out a DHCP client's ``sourcedir``.""" + dhcp = {posixpath.normpath(d) for d in dhcp_dirs} return [ number - for number, line in enumerate(f.lines, start=1) - if SOURCE_LINE.match(line) or (f.kind == "main" and number in dropped) + for number, line in enumerate(main.lines, start=1) + if (marked := _MARKED_SOURCEDIR.match(line)) + and all(posixpath.normpath(arg) in dhcp for arg in marked[1].split()) ] def plan_chrony( - files: list[ConfigFile], servers: list[str], *, sources_file: str, include_file: str + files: list[ConfigFile], + servers: list[str], + *, + sources_file: str, + include_file: str, + dhcp_dirs: tuple[str, ...] = CHRONY_DHCP_DIRS, ) -> ChronyPlan: - """Where *servers* go and what else is commented out. + """Where *servers* go, what else is commented out, and which DHCP ``sourcedir`` + (one of *dhcp_dirs*) comes back. :raises RuntimeError: when the reading found no chrony configuration. """ @@ -108,14 +123,20 @@ def plan_chrony( if main is None: raise RuntimeError("chrony runs, but no chrony configuration was found to write to") target, include_in, is_sources = _target(main, sources_file, include_file) - dropped = _dropped_sourcedirs(main, posixpath.dirname(target) if is_sources else None) - comment_out = _comment_out(files, target, dropped) + comment_out = _comment_out(files, target, dhcp_dirs) + restore = _dhcp_sourcedirs_to_restore(main, dhcp_dirs) return ChronyPlan( target=target, content="".join(f"{source_line(s)}\n" for s in servers), comment_out=comment_out, + restore={main.path: restore} if restore else {}, include_in=include_in, - reload=is_sources and include_in is None and _only_sources_files(files, comment_out), + reload=( + is_sources + and include_in is None + and not restore + and _only_sources_files(files, comment_out) + ), ) @@ -124,25 +145,36 @@ def _only_sources_files(files: list[ConfigFile], changed: dict[str, list[int]]) return all(f.kind == "sourcedir" for f in files if f.path in changed) -def _comment_out(files: list[ConfigFile], target: str, dropped: set[int]) -> dict[str, list[int]]: - """Per file, the lines that take a source; a dropped ``sourcedir``'s files are not read.""" +def _comment_out( + files: list[ConfigFile], target: str, dhcp_dirs: tuple[str, ...] +) -> dict[str, list[int]]: + """Per file, the lines that take a source; the DHCP client's files are left alone.""" found: dict[str, list[int]] = {} for f in files: - if f.path == target or (f.kind == "sourcedir" and f.at in dropped): + if f.path == target or in_dhcp_dir(f, dhcp_dirs): continue - numbers = _lines_to_comment(f, dropped) + numbers = [n for n, line in enumerate(f.lines, start=1) if SOURCE_LINE.match(line)] if numbers: found[f.path] = numbers return found def comment_out_command(path: str, numbers: list[int]) -> str: - """``sed`` that comments out those lines of *path* that still hold a source or a sourcedir.""" + """``sed`` that comments out those lines of *path* that still hold a source.""" edits = " ".join( "-e " - + shlex.quote( - f"{n}{{/^[[:space:]]*(server|pool|peer|sourcedir)[[:space:]]/s/^/{COMMENT_MARK}/;}}" - ) + + shlex.quote(f"{n}{{/^[[:space:]]*(server|pool|peer)[[:space:]]/s/^/{COMMENT_MARK}/;}}") + for n in numbers + ) + return f"sed -i -E {edits} {shlex.quote(path)}" + + +def restore_command(path: str, numbers: list[int]) -> str: + """``sed`` that takes :data:`COMMENT_MARK` off those lines of *path* that are still a + ``sourcedir`` behind it. The mark holds nothing a regular expression or ``sed``'s + ``s///`` would read as special.""" + edits = " ".join( + "-e " + shlex.quote(f"{n}{{s/^{COMMENT_MARK}(sourcedir[[:space:]])/\\1/;}}") for n in numbers ) return f"sed -i -E {edits} {shlex.quote(path)}" diff --git a/napalm_device_types/_time_sync_reading.py b/napalm_device_types/_time_sync_reading.py index 7f81acd..5aaf6da 100644 --- a/napalm_device_types/_time_sync_reading.py +++ b/napalm_device_types/_time_sync_reading.py @@ -14,10 +14,15 @@ One command, as the login user, prints framed sections (``@@ts ...``): line of it reads; * ``ntpd ``, ``openntpd `` -- their configuration; * ``end`` -- the reading is complete. + +What DHCP brought is read apart from the configured servers: chrony's files in a +DHCP client's ``sourcedir`` (:data:`CHRONY_DHCP_DIRS`), systemd-timesyncd's +``LinkNTPServers``. """ from __future__ import annotations +import posixpath import re import shlex from dataclasses import dataclass, field @@ -37,6 +42,11 @@ TIME_SYNC_UNITS: tuple[tuple[str, str], ...] = ( ("openntpd", "openntpd"), ) +#: The ``sourcedir`` a DHCP client writes chrony's sources to, one file per interface +#: and lease: the NetworkManager dispatcher and dhclient hook of Debian, Ubuntu and +#: Red Hat. What chrony reads from there is DHCP's (option 42), not configuration. +CHRONY_DHCP_DIRS: tuple[str, ...] = ("/run/chrony-dhcp", "/var/run/chrony-dhcp") + #: A source line of chrony's or ntpd's configuration: the directive and what follows. SOURCE_LINE = re.compile(r"\s*(server|pool|peer)\s+(.*)") _OPENNTPD_SOURCE = re.compile(r"\s*(servers?)\s+(\S+)") @@ -197,19 +207,47 @@ def _source_name(rest: str) -> str | None: return next((word for word in rest.split() if not word.startswith("-")), None) -def chrony_servers(files: list[ConfigFile]) -> list[str]: - """chrony's sources in the order it reads them: each file in place of the line naming it.""" +def in_dhcp_dir(f: ConfigFile, dhcp_dirs: tuple[str, ...]) -> bool: + """Whether *f* is a sources file a DHCP client wrote to one of *dhcp_dirs*.""" + if f.kind != "sourcedir": + return False + directory = posixpath.normpath(posixpath.dirname(f.path)) + return directory in {posixpath.normpath(d) for d in dhcp_dirs} + + +def _named_on(files: list[ConfigFile], number: int) -> list[ConfigFile]: + """The files the main configuration's line *number* reads.""" + return [f for f in files if f.at == number and f.kind != "main"] + + +def _read_order(files: list[ConfigFile], dhcp_dirs: tuple[str, ...]) -> list[tuple[bool, str]]: + """Every line chrony reads, in its order -- each file in place of the line naming + it -- and whether a DHCP client wrote it.""" main = next((f for f in files if f.kind == "main"), None) if main is None: return [] - found: list[str] = [] + found: list[tuple[bool, str]] = [] for number, line in enumerate(main.lines, start=1): - found.extend(_sources([line])) - for included in (f for f in files if f.at == number and f.kind != "main"): - found.extend(_sources(included.lines)) + found.append((False, line)) + for included in _named_on(files, number): + dhcp = in_dhcp_dir(included, dhcp_dirs) + found.extend((dhcp, text) for text in included.lines) return found +def chrony_servers(files: list[ConfigFile], dhcp_dirs: tuple[str, ...] = ()) -> list[str]: + """chrony's configured sources in the order it reads them; not those in *dhcp_dirs*.""" + return _sources([line for dhcp, line in _read_order(files, dhcp_dirs) if not dhcp]) + + +def chrony_dhcp_servers(files: list[ConfigFile], dhcp_dirs: tuple[str, ...]) -> list[str]: + """The sources chrony reads from the DHCP client's files in *dhcp_dirs*, in its order. + + A ``sourcedir`` chrony does not read (commented out) prints no files: nothing then. + """ + return _sources([line for dhcp, line in _read_order(files, dhcp_dirs) if dhcp]) + + def _sources(lines: list[str]) -> list[str]: names = [] for line in lines: @@ -229,14 +267,30 @@ def openntpd_servers(lines: list[str]) -> list[str]: return [m[2] for line in lines if (m := _OPENNTPD_SOURCE.match(line))] -def timesyncd_servers(values: dict[str, str]) -> list[str]: - """systemd-timesyncd's servers in the order it tries them; the fallback only alone.""" +def _listed(values: dict[str, str], *keys: str) -> list[str]: found: list[str] = [] - for key in ("RuntimeNTPServers", "SystemNTPServers", "LinkNTPServers"): + for key in keys: for server in values.get(key, "").split(): if server not in found: found.append(server) - return found or values.get("FallbackNTPServers", "").split() + return found + + +def timesyncd_servers(values: dict[str, str]) -> list[str]: + """systemd-timesyncd's configured servers, runtime then system; the fallback only + while it has no other server, a link's included. A link's servers are not among + them: :func:`timesyncd_link_servers`.""" + configured = _listed(values, "RuntimeNTPServers", "SystemNTPServers") + if configured or timesyncd_link_servers(values): + return configured + return _listed(values, "FallbackNTPServers") + + +def timesyncd_link_servers(values: dict[str, str]) -> list[str]: + """The servers network links gave systemd-timesyncd: systemd-networkd's, from a DHCP + lease (option 42) or a ``.network`` file's ``NTP=`` -- the reading cannot tell those + apart and counts them as DHCP's.""" + return _listed(values, "LinkNTPServers") def chrony_synchronized(sources: str) -> bool | None: @@ -263,9 +317,9 @@ def _time_zone(reading: Reading) -> str | None: return next((z for line in reading.zone_files if (z := _zone_name(line))), None) -def _servers(reading: Reading) -> list[str]: +def _servers(reading: Reading, dhcp_dirs: tuple[str, ...]) -> list[str]: if reading.daemon == "chrony": - return chrony_servers(reading.chrony) + return chrony_servers(reading.chrony, dhcp_dirs) if reading.daemon == "systemd-timesyncd": return timesyncd_servers(reading.timesync) if reading.daemon == "ntpd" and reading.ntpd is not None: @@ -275,6 +329,18 @@ def _servers(reading: Reading) -> list[str]: return [] +def _dhcp_servers(reading: Reading, dhcp_dirs: tuple[str, ...]) -> list[str] | None: + """What DHCP brought: chrony's and timesyncd's; None where ntpd or OpenNTPD runs, + whose DHCP hooks keep a configuration of their own that is not read.""" + if reading.daemon == "chrony": + return chrony_dhcp_servers(reading.chrony, dhcp_dirs) + if reading.daemon == "systemd-timesyncd": + return timesyncd_link_servers(reading.timesync) + if reading.daemon is None: + return [] + return None + + def _synchronized(reading: Reading) -> bool | None: if reading.daemon == "chrony": chrony = chrony_synchronized(reading.chronyc) @@ -283,19 +349,21 @@ def _synchronized(reading: Reading) -> bool | None: return {"yes": True, "no": False}.get(reading.timedatectl.get("NTPSynchronized", "")) -def time_sync_of(reading: Reading) -> TimeSyncDict: - """What a reading says, as ``get_time_sync`` returns it.""" +def time_sync_of(reading: Reading, dhcp_dirs: tuple[str, ...] = CHRONY_DHCP_DIRS) -> TimeSyncDict: + """What a reading says, as ``get_time_sync`` returns it; *dhcp_dirs* are the DHCP + client's ``sourcedir`` of chrony.""" return { - "ntp_servers": _servers(reading), + "ntp_servers": _servers(reading, dhcp_dirs), "timezone": _time_zone(reading), "synchronized": _synchronized(reading), "daemon": reading.daemon, + "dhcp_ntp_servers": _dhcp_servers(reading, dhcp_dirs), } -def parse_time_sync(text: str) -> TimeSyncDict: +def parse_time_sync(text: str, dhcp_dirs: tuple[str, ...] = CHRONY_DHCP_DIRS) -> TimeSyncDict: """The reading's output as ``get_time_sync`` returns it. :raises ValueError: for a reading cut short. """ - return time_sync_of(parse_reading(text)) + return time_sync_of(parse_reading(text), dhcp_dirs) diff --git a/napalm_device_types/time_sync.py b/napalm_device_types/time_sync.py index a37a3ad..d53b80b 100644 --- a/napalm_device_types/time_sync.py +++ b/napalm_device_types/time_sync.py @@ -7,7 +7,7 @@ device that differs. :class:`TimeSyncMixin` is the contract for that: "get_time_sync", None))`` is the truthful answer to "can this driver tell"; * ``configure_time_sync(ntp_servers=None, timezone=None)`` -- a fix template (:mod:`napalm_device_types.fixes`): ``None`` leaves that value as it is, and the - device ends up with exactly the servers given, in their order. A driver + device ends up configured with exactly the servers given, in their order. A driver implements the steps; one whose device takes the change in a single call overrides the method; * ``time_sync_writes`` -- which of the two values the driver can write. A BMC that @@ -17,16 +17,24 @@ device that differs. :class:`TimeSyncMixin` is the contract for that: A driver that inherits the mixin but cannot run it sets ``get_time_sync`` (and ``configure_time_sync``) to ``None``. +**Servers from DHCP count** (NetOrk/netork#2380). A device that takes its time +servers from a DHCP lease (option 42) gets them from whoever serves the subnet -- +usually the site's time giver. ``ntp_servers`` are only the servers configured on +the device; ``dhcp_ntp_servers`` are those the device got by DHCP and uses. A write +replaces the configured servers and leaves DHCP's alone: it never switches the use of +DHCP-provided servers off, and the ``verify`` step does not count them. + A zone is an IANA name on the wire. A device that wants a POSIX rule or an offset with a summer-time rule gets it from :mod:`napalm_device_types.posix_tz`. """ -from __future__ import annotations +# No ``from __future__ import annotations`` here: TypedDict tells a NotRequired key +# only from an evaluated annotation (``TimeSyncDict.__optional_keys__``). import ipaddress import re from collections.abc import Sequence -from typing import TYPE_CHECKING, ClassVar, TypedDict +from typing import TYPE_CHECKING, ClassVar, NotRequired, TypedDict from napalm_device_types.fixes import FixStep, run_fix_steps from napalm_device_types.models import FixResultDict, FixStepOutcomeDict @@ -48,6 +56,9 @@ class TimeSyncDict(TypedDict): timezone: str | None # IANA name ("Europe/Berlin"); None = not readable or no named zone synchronized: bool | None # the clock is synchronised to a source right now; None = unknown daemon: str | None # "chrony", "systemd-timesyncd", "ntpd", "openntpd", ...; None = own client + # The servers the device got by DHCP (option 42) and uses, in its order; never in + # ntp_servers. [] = none; absent or None = the driver cannot tell. + dhcp_ntp_servers: NotRequired[list[str] | None] def _is_server(name: str) -> bool: @@ -94,7 +105,9 @@ class TimeSyncMixin: """How the device keeps its clock now. ``ntp_servers`` are the sources its configuration names, in its order - (a pool by its name, not the addresses it resolved to). ``timezone`` + (a pool by its name, not the addresses it resolved to); + ``dhcp_ntp_servers`` those a DHCP lease gave it and it uses, apart from + them -- left out where the driver cannot tell. ``timezone`` is an IANA name, or None where the device keeps an offset and a rule instead of a name. ``daemon`` names the client that keeps the clock on a host that has a choice; None for a device's own. @@ -106,6 +119,7 @@ class TimeSyncMixin: "timezone": "Europe/Berlin", "synchronized": True, "daemon": "chrony", + "dhcp_ntp_servers": ["192.168.1.1"], } :raises Exception: when the device could not be read. @@ -115,8 +129,9 @@ class TimeSyncMixin: # The steps a driver implements: def _write_ntp_servers(self, servers: list[str]) -> FixStepOutcomeDict: - """Leave the device with exactly *servers*, in this order: sources it - had configured elsewhere stop counting (commented out, replaced).""" + """Leave the device configured with exactly *servers*, in this order: + sources it had configured elsewhere stop counting (commented out, + replaced). Servers it gets by DHCP stay, and so does its use of them.""" ... def _write_time_zone(self, zone: str) -> FixStepOutcomeDict: @@ -128,6 +143,8 @@ class TimeSyncMixin: ) -> FixResultDict: """Give the device exactly *ntp_servers*, in order, and *timezone*; None leaves one alone. + What the device gets by DHCP is not touched: it keeps using those servers too. + The steps: ``ntp_servers``, ``timezone``, then ``verify``, which reads the device again. @@ -157,8 +174,8 @@ class TimeSyncMixin: def _verify_time_sync(self, servers: list[str] | None, zone: str | None) -> FixStepOutcomeDict: """Read the device again: does it now have what was written? - Servers compare without case. A zone is compared where the device reads - one back by name. + Servers compare without case; the servers DHCP brought are not among + them. A zone is compared where the device reads one back by name. """ now = self.get_time_sync() wrong: list[str] = [] diff --git a/napalm_device_types/time_sync_posix.py b/napalm_device_types/time_sync_posix.py index f89539c..8ae0161 100644 --- a/napalm_device_types/time_sync_posix.py +++ b/napalm_device_types/time_sync_posix.py @@ -13,17 +13,22 @@ reads them, ``timedatectl show-timesync`` for systemd-timesyncd, ``ntp.conf``, OpenNTPD's ``ntpd.conf``. Synchronised is chronyd's own word where it runs (a selected source in ``chronyc -n sources``), else the kernel's (``NTPSynchronized``). +What DHCP brought (option 42) is read apart, as ``dhcp_ntp_servers``, and never as a +configured server: chrony's sources from the DHCP client's ``sourcedir`` +(:attr:`~PosixTimeSyncMixin.CHRONY_DHCP_DIRS`, the files as chronyd reads them), +systemd-timesyncd's ``LinkNTPServers``. Where ntpd or OpenNTPD runs it is unknown. + **Writing** runs as root through ``run_command(privileged=True)``; root never reads stdin -- a file is staged by the login user and installed by root. * The zone: ``timedatectl set-timezone``. -* chrony: the servers go to a file of their own and every other source is commented - out (:mod:`napalm_device_types._chrony`), then ``chronyc reload sources``, or a - restart of chronyd where its main configuration changed or it cannot reload. +* chrony: the servers go to a file of their own and every other configured source is + commented out (:mod:`napalm_device_types._chrony`); the DHCP client's ``sourcedir`` + stays, and one 4.35.0 commented out comes back. Then ``chronyc reload sources``, or + a restart of chronyd where its main configuration changed or it cannot reload. * systemd-timesyncd: :attr:`~PosixTimeSyncMixin.TIMESYNCD_DROPIN` resets ``NTP=``, sets the servers and empties ``FallbackNTP=``, then the service restarts. Servers a - network link brings (DHCP through systemd-networkd) are not timesyncd's to drop; - they stay, and the ``verify`` step names them. + network link brings (DHCP through systemd-networkd) stay and count. * ntpd, OpenNTPD, or no client: the servers are read, not written -- the step fails and says so. """ @@ -39,9 +44,11 @@ from napalm_device_types._chrony import ( comment_out_command, include_command, plan_chrony, + restore_command, ) from napalm_device_types._scheduled_reading import TIME_ZONE_SH from napalm_device_types._time_sync_reading import ( + CHRONY_DHCP_DIRS, TIME_SYNC_UNITS, Reading, ReadPaths, @@ -51,6 +58,7 @@ from napalm_device_types._time_sync_reading import ( parse_time_sync, reading_command, time_sync_of, + timesyncd_link_servers, timesyncd_servers, ) from napalm_device_types.models import FixStepOutcomeDict @@ -91,6 +99,9 @@ class PosixTimeSyncMixin(TimeSyncMixin): CHRONY_SOURCES_FILE: ClassVar[str] = "/etc/chrony/sources.d/netork.sources" #: The servers' file otherwise (its name also in a ``confdir``); included if need be. CHRONY_INCLUDE_FILE: ClassVar[str] = "/etc/chrony.d/netork.conf" + #: The ``sourcedir`` a DHCP client writes chrony's sources to: read as + #: ``dhcp_ntp_servers``, never commented out. + CHRONY_DHCP_DIRS: ClassVar[tuple[str, ...]] = CHRONY_DHCP_DIRS TIMESYNCD_DROPIN: ClassVar[str] = "/etc/systemd/timesyncd.conf.d/netork.conf" NTPD_CONFIGS: ClassVar[tuple[str, ...]] = ("/etc/ntpsec/ntp.conf", "/etc/ntp.conf") OPENNTPD_CONFIGS: ClassVar[tuple[str, ...]] = ("/etc/openntpd/ntpd.conf", "/etc/ntpd.conf") @@ -125,7 +136,7 @@ class PosixTimeSyncMixin(TimeSyncMixin): :raises ValueError: when the reading came back cut short. """ - return time_sync_of(self._ts_read()) + return time_sync_of(self._ts_read(), self.CHRONY_DHCP_DIRS) # -- writing --------------------------------------------------------------------------------- @@ -175,9 +186,13 @@ class PosixTimeSyncMixin(TimeSyncMixin): servers, sources_file=self.CHRONY_SOURCES_FILE, include_file=self.CHRONY_INCLUDE_FILE, + dhcp_dirs=self.CHRONY_DHCP_DIRS, ) said = [f"wrote {plan.target}"] self._ts_install(plan.target, plan.content) + for path, numbers in plan.restore.items(): + self._ts_checked(restore_command(path, numbers)) + said.append(f"gave DHCP's sourcedir back in {path}:{','.join(map(str, numbers))}") for path, numbers in plan.comment_out.items(): self._ts_checked(comment_out_command(path, numbers)) said.append(f"commented out {path}:{','.join(map(str, numbers))}") @@ -199,5 +214,6 @@ __all__ = [ "parse_key_values", "parse_time_sync", "timesyncd_dropin", + "timesyncd_link_servers", "timesyncd_servers", ] diff --git a/pyproject.toml b/pyproject.toml index 0f7fa07..5af7c2b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "napalm-device-types" -version = "4.35.0" +version = "4.36.0" description = "Abstract device-type base classes for NAPALM drivers" readme = "README.md" requires-python = ">=3.12" diff --git a/tests/test_time_sync.py b/tests/test_time_sync.py index ffeabed..8b34deb 100644 --- a/tests/test_time_sync.py +++ b/tests/test_time_sync.py @@ -34,9 +34,16 @@ def test_the_shape(): "timezone": str | None, "synchronized": bool | None, "daemon": str | None, + "dhcp_ntp_servers": list[str] | None, } +def test_the_dhcp_servers_are_optional(): + # A driver that cannot tell what DHCP brought leaves the key out (NetOrk/netork#2380). + assert TimeSyncDict.__required_keys__ == {"ntp_servers", "timezone", "synchronized", "daemon"} + assert TimeSyncDict.__optional_keys__ == {"dhcp_ntp_servers"} + + def test_the_two_values_a_driver_may_write(): assert frozenset({"ntp_servers", "timezone"}) == TIME_SYNC_VALUES @@ -190,6 +197,13 @@ class TestConfigureTimeSync: assert Lower().configure_time_sync(["NTP1.Example.org"])["success"] is True + def test_servers_from_dhcp_do_not_fail_the_check(self): + # DHCP option 42 counts: what the device got by DHCP stays and is no mistake. + device = _Device() + device.state["dhcp_ntp_servers"] = ["192.168.1.1"] + result = device.configure_time_sync(["ntp1.example.org"]) + assert result["success"] is True, result["output"] + def test_a_device_without_a_zone_name_is_not_checked_for_one(self): # A switch keeps an offset and a summer-time rule, not a name: it reads None. result = _Device(keeps_zone_name=False).configure_time_sync(timezone="Europe/Berlin") diff --git a/tests/test_time_sync_posix.py b/tests/test_time_sync_posix.py index 5d828e1..a87ec1f 100644 --- a/tests/test_time_sync_posix.py +++ b/tests/test_time_sync_posix.py @@ -4,7 +4,8 @@ The reading is run by a real ``sh`` over a directory tree that stands in for the host, with ``timedatectl``, ``systemctl`` and ``chronyc`` replaced by scripts that keep a log -- so the shell itself is tested, not a hand-written copy of its output. ``sed`` and ``install`` are the real ones, so the files the writes leave are what a -host would get (NetOrk/netork#2361). +host would get (NetOrk/netork#2361). Servers that DHCP brings are read apart and left +alone by a write (NetOrk/netork#2380). """ from __future__ import annotations @@ -20,6 +21,7 @@ from napalm_device_types.channel import CommandResult from napalm_device_types.time_sync_posix import ( chrony_synchronized, parse_key_values, + timesyncd_link_servers, timesyncd_servers, ) @@ -136,6 +138,7 @@ class Host(PosixTimeSyncMixin): self.CHRONY_CONFIGS = (str(etc / "chrony/chrony.conf"), str(etc / "chrony.conf")) # type: ignore[misc] self.CHRONY_SOURCES_FILE = str(etc / "chrony/sources.d/netork.sources") # type: ignore[misc] self.CHRONY_INCLUDE_FILE = str(etc / "chrony.d/netork.conf") # type: ignore[misc] + self.CHRONY_DHCP_DIRS = (str(root / "run/chrony-dhcp"),) # type: ignore[misc] self.TIMESYNCD_DROPIN = str(etc / "systemd/timesyncd.conf.d/netork.conf") # type: ignore[misc] self.NTPD_CONFIGS = (str(etc / "ntpsec/ntp.conf"), str(etc / "ntp.conf")) # type: ignore[misc] self.OPENNTPD_CONFIGS = (str(etc / "openntpd/ntpd.conf"),) # type: ignore[misc] @@ -223,21 +226,43 @@ class TestParsing: def test_timesyncd_uses_the_fallback_only_when_nothing_else_is_known(self): assert timesyncd_servers(parse_key_values(TIMESYNC_FALLBACK)) == ["ntp.ubuntu.com"] - # runtime, then system, then link: the order timesyncd tries them in. + # runtime, then system: the configured ones; a link's servers are DHCP's. assert timesyncd_servers(parse_key_values(TIMESYNC_CONFIGURED)) == [ "ntp1.example.org", "ntp2.example.org", - "192.168.1.1", ] assert timesyncd_servers({}) == [] + def test_timesyncd_does_not_fall_back_while_a_link_brings_servers(self): + values = {"LinkNTPServers": "192.168.1.1", "FallbackNTPServers": "ntp.ubuntu.com"} + assert timesyncd_servers(values) == [] + assert timesyncd_link_servers(values) == ["192.168.1.1"] + + def test_timesyncd_link_servers(self): + assert timesyncd_link_servers(parse_key_values(TIMESYNC_CONFIGURED)) == ["192.168.1.1"] + assert timesyncd_link_servers({"LinkNTPServers": "10.0.0.1 10.0.0.1 10.0.0.2"}) == [ + "10.0.0.1", + "10.0.0.2", + ] + assert timesyncd_link_servers(parse_key_values(TIMESYNC_FALLBACK)) == [] + def test_chrony_is_synchronised_while_it_has_selected_a_source(self): assert chrony_synchronized(CHRONYC_SYNCED) is True assert chrony_synchronized(CHRONYC_UNSYNCED) is False assert chrony_synchronized("") is None def test_chrony_without_a_main_configuration_has_no_sources(self): - assert parse_time_sync("@@ts active\nchrony chrony active\n@@ts end\n")["ntp_servers"] == [] + reading = parse_time_sync("@@ts active\nchrony chrony active\n@@ts end\n") + assert (reading["ntp_servers"], reading["dhcp_ntp_servers"]) == ([], []) + + def test_the_dhcp_directory_is_debian_s_and_red_hat_s_by_default(self): + reading = parse_time_sync( + "@@ts active\nchrony chrony active\n" + "@@ts chrony 0 main /etc/chrony/chrony.conf\nsourcedir /run/chrony-dhcp\n" + "@@ts chrony 1 sourcedir /run/chrony-dhcp/eth0.sources\nserver 10.0.0.1 iburst\n" + "@@ts end\n" + ) + assert (reading["ntp_servers"], reading["dhcp_ntp_servers"]) == ([], ["10.0.0.1"]) def test_a_reading_cut_short_raises(self): with pytest.raises(ValueError, match="cut short"): @@ -251,14 +276,35 @@ class TestReading: "ntp_servers": [ "ntp-conf.example.org", "2.debian.pool.ntp.org", - "192.168.1.1", "ntp-other.example.org", ], "timezone": "Europe/Berlin", "synchronized": True, "daemon": "chrony", + "dhcp_ntp_servers": ["192.168.1.1"], } + def test_dhcp_servers_in_the_order_chrony_reads_them(self, debian: Path): + _write(debian / "run/chrony-dhcp/wlan0.sources", "server 10.9.0.1 iburst\n") + _write(debian / "run/chrony-dhcp/eth0.sources", "server 192.168.1.1\npool p.example\n") + assert Host(debian).get_time_sync()["dhcp_ntp_servers"] == [ + "192.168.1.1", + "p.example", + "10.9.0.1", + ] + + def test_a_dhcp_directory_chrony_does_not_read_brings_nothing(self, debian: Path): + # What 4.35.0 left behind: DHCP's sourcedir commented out. + conf = debian / "etc/chrony/chrony.conf" + conf.write_text(_text(conf).replace("\nsourcedir ", "\n#napalm-time-sync: sourcedir ", 1)) + reading = Host(debian).get_time_sync() + assert reading["dhcp_ntp_servers"] == [] + assert "192.168.1.1" not in reading["ntp_servers"] + + def test_without_a_dhcp_directory_dhcp_brings_nothing(self, root: Path): + _write(root / "etc/chrony.conf", "pool 2.rhel.pool.ntp.org iburst\n") + assert Host(root, active="chronyd").get_time_sync()["dhcp_ntp_servers"] == [] + def test_the_reading_is_one_round_trip_without_root(self, debian: Path): host = Host(debian) host.get_time_sync() @@ -291,7 +337,8 @@ class TestReading: (root / "fix/timesync").write_text(TIMESYNC_CONFIGURED) reading = Host(root, active="systemd-timesyncd").get_time_sync() assert reading["daemon"] == "systemd-timesyncd" - assert reading["ntp_servers"] == ["ntp1.example.org", "ntp2.example.org", "192.168.1.1"] + assert reading["ntp_servers"] == ["ntp1.example.org", "ntp2.example.org"] + assert reading["dhcp_ntp_servers"] == ["192.168.1.1"] assert reading["synchronized"] is True def test_ntpd(self, root: Path): @@ -303,6 +350,8 @@ class TestReading: reading = Host(root, active="ntpsec").get_time_sync() assert reading["daemon"] == "ntpd" assert reading["ntp_servers"] == ["0.debian.pool.ntp.org", "ntp1.example.org"] + # Debian's DHCP hook gives ntpd a configuration of its own: not read, so unknown. + assert reading["dhcp_ntp_servers"] is None def test_openntpd(self, root: Path): _write( @@ -312,6 +361,7 @@ class TestReading: reading = Host(root, active="openntpd").get_time_sync() assert reading["daemon"] == "openntpd" assert reading["ntp_servers"] == ["pool.ntp.org", "ntp1.example.org"] + assert reading["dhcp_ntp_servers"] is None def test_no_client_runs(self, root: Path): (root / "fix/timedatectl").write_text( @@ -322,6 +372,7 @@ class TestReading: "timezone": "Europe/Berlin", "synchronized": False, "daemon": None, + "dhcp_ntp_servers": [], } def test_without_timedatectl_the_zone_comes_from_the_files(self, root: Path): @@ -352,7 +403,8 @@ class TestChronyServers: ) conf = _text(debian / "etc/chrony/chrony.conf") assert "\n#napalm-time-sync: pool 2.debian.pool.ntp.org iburst\n" in conf - assert f"\n#napalm-time-sync: sourcedir {debian}/run/chrony-dhcp\n" in conf + # DHCP option 42 counts: chrony keeps reading what DHCP brings. + assert f"\nsourcedir {debian}/run/chrony-dhcp\n" in conf assert f"\nsourcedir {debian}/etc/chrony/sources.d\n" in conf assert f"\nconfdir {debian}/etc/chrony/conf.d\n" in conf assert _text(debian / "etc/chrony/conf.d/local.conf") == ( @@ -361,15 +413,72 @@ class TestChronyServers: assert _text(debian / "etc/chrony/sources.d/other.sources") == ( "#napalm-time-sync: server ntp-other.example.org\n" ) - # DHCP's own file is left alone: it is not read any more. + # DHCP's own file is left alone: the DHCP client rewrites it on every lease. assert _text(debian / "run/chrony-dhcp/eth0.sources") == "server 192.168.1.1 iburst\n" # The main configuration changed: chronyd reads it only when it starts. assert "systemctl restart chrony.service" in host.log() - assert host.get_time_sync()["ntp_servers"] == [ - "ntp1.example.org", - "10.0.0.1", - "2.de.pool.ntp.org", - ] + reading = host.get_time_sync() + assert reading["ntp_servers"] == ["ntp1.example.org", "10.0.0.1", "2.de.pool.ntp.org"] + assert reading["dhcp_ntp_servers"] == ["192.168.1.1"] + + def test_what_4_35_0_took_from_dhcp_is_given_back(self, debian: Path): + conf = debian / "etc/chrony/chrony.conf" + Host(debian).configure_time_sync(["ntp1.example.org"]) + # A host 4.35.0 aligned: DHCP's sourcedir commented out behind the mark. + dhcp = f"sourcedir {debian}/run/chrony-dhcp" + conf.write_text(_text(conf).replace(f"\n{dhcp}\n", f"\n#napalm-time-sync: {dhcp}\n")) + assert Host(debian).get_time_sync()["dhcp_ntp_servers"] == [] + (debian / "log").unlink() + + host = Host(debian) + result = host.configure_time_sync(["ntp1.example.org"]) + + assert result["success"] is True, result["output"] + assert f"\n{dhcp}\n" in _text(conf) + assert "#napalm-time-sync: sourcedir" not in _text(conf) + # The main configuration changed again: a restart, not a reload. + assert "systemctl restart chrony.service" in host.log() + assert host.get_time_sync()["dhcp_ntp_servers"] == ["192.168.1.1"] + + def test_a_foreign_sourcedir_4_35_0_took_out_stays_out(self, debian: Path): + conf = debian / "etc/chrony/chrony.conf" + foreign = f"#napalm-time-sync: sourcedir {debian}/etc/chrony/extra.d" + conf.write_text(_text(conf) + foreign + "\n") + _write(debian / "etc/chrony/extra.d/x.sources", "server ntp-extra.example.org\n") + + assert Host(debian).configure_time_sync(["ntp1.example.org"])["success"] is True + assert f"\n{foreign}\n" in _text(conf) + + def test_a_foreign_sourcedir_stays_and_its_sources_stop_counting(self, debian: Path): + conf = debian / "etc/chrony/chrony.conf" + conf.write_text(_text(conf) + f"sourcedir {debian}/etc/chrony/extra.d\n") + _write(debian / "etc/chrony/extra.d/x.sources", "server ntp-extra.example.org\n") + + host = Host(debian) + result = host.configure_time_sync(["ntp1.example.org"]) + + assert result["success"] is True, result["output"] + assert f"\nsourcedir {debian}/etc/chrony/extra.d\n" in _text(conf) + assert _text(debian / "etc/chrony/extra.d/x.sources") == ( + "#napalm-time-sync: server ntp-extra.example.org\n" + ) + assert host.get_time_sync()["ntp_servers"] == ["ntp1.example.org"] + + def test_dhcp_is_kept_where_the_servers_go_to_a_confdir(self, root: Path): + _write( + root / "etc/chrony/chrony.conf", + f"confdir {root}/etc/chrony/conf.d\npool a.pool.ntp.org\n" + f"sourcedir {root}/run/chrony-dhcp\n", + ) + _write(root / "run/chrony-dhcp/eth0.sources", "server 192.168.1.1 iburst\n") + host = Host(root) + assert host.configure_time_sync(["ntp1.example.org"])["success"] is True + assert f"\nsourcedir {root}/run/chrony-dhcp\n" in _text(root / "etc/chrony/chrony.conf") + reading = host.get_time_sync() + assert (reading["ntp_servers"], reading["dhcp_ntp_servers"]) == ( + ["ntp1.example.org"], + ["192.168.1.1"], + ) def test_a_second_run_only_reloads_the_sources(self, debian: Path): Host(debian).configure_time_sync(["ntp1.example.org"]) @@ -480,7 +589,7 @@ class TestTimesyncdServers: assert "systemctl restart systemd-timesyncd.service" in host.log() assert host.get_time_sync()["ntp_servers"] == ["ntp1.example.org", "10.0.0.1"] - def test_servers_from_dhcp_stay_and_the_check_says_so(self, root: Path): + def test_servers_from_dhcp_stay_and_count(self, root: Path): (root / "fix/timesync").write_text(TIMESYNC_CONFIGURED) tool = (root / "bin/systemctl").read_text() (root / "bin/systemctl").write_text( @@ -488,11 +597,15 @@ class TestTimesyncdServers: "printf 'SystemNTPServers", "printf 'LinkNTPServers=192.168.1.1\\nSystemNTPServers" ) ) - result = Host(root, active="systemd-timesyncd").configure_time_sync(["ntp1.example.org"]) + host = Host(root, active="systemd-timesyncd") + result = host.configure_time_sync(["ntp1.example.org"]) - assert result["success"] is False - assert result["steps"][-1]["step"] == "verify" - assert "192.168.1.1" in result["steps"][-1]["output"] + assert result["success"] is True, result["output"] + reading = host.get_time_sync() + assert (reading["ntp_servers"], reading["dhcp_ntp_servers"]) == ( + ["ntp1.example.org"], + ["192.168.1.1"], + ) class TestOtherClients: -- 2.54.1