feat(time-sync): DHCP-provided NTP servers count and are read apart
driver / standard (pull_request) Successful in 17s
driver / lint (pull_request) Successful in 31s
driver / types (pull_request) Successful in 1m16s
driver / test (3.13) (pull_request) Successful in 1m29s
driver / test (3.12) (pull_request) Successful in 1m33s
driver / lowest (pull_request) Successful in 41s
driver / build (pull_request) Successful in 29s
driver / security (pull_request) Successful in 1m5s
CI / driver (pull_request) Successful in 3m22s
driver / publish (pull_request) Skipped

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.
This commit is contained in:
christianmanivong committed 2026-11-11 22:08:52 +01:00
1 parent 6c7f164004
commit ac38c68feb
9 files changed
+379 -89

No files matched your search

+62 -30
View File
@@ -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)}"
+85 -17
View File
@@ -14,10 +14,15 @@ One command, as the login user, prints framed sections (``@@ts <name> ...``):
line of it reads;
* ``ntpd <path>``, ``openntpd <path>`` -- 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)
+25 -8
View File
@@ -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] = []
+22 -6
View File
@@ -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",
]