Compare commits

...
21 Commits
Author SHA1 Message Date
christianmanivong a8fedf299a Merge pull request 'fix(host-status): kernel releases compare the way rpm does (4.36.2)' (#110) from fix/rpm-kernel-version-order into main
driver / types (push) Successful in 1m4s
driver / standard (push) Successful in 15s
driver / lint (push) Successful in 14s
driver / test (3.12) (push) Successful in 1m20s
driver / test (3.13) (push) Successful in 1m13s
driver / lowest (push) Successful in 46s
driver / build (push) Successful in 40s
driver / security (push) Successful in 1m16s
driver / publish (push) Successful in 30s
CI / driver (push) Successful in 3m36s
2026-11-12 10:08:48 +00:00
christianmanivong c736fb30d0 refactor(host-status): compare one version segment in a helper of its own
driver / standard (pull_request) Successful in 15s
driver / lint (pull_request) Successful in 14s
driver / types (pull_request) Successful in 56s
driver / test (3.12) (pull_request) Successful in 1m8s
driver / test (3.13) (pull_request) Successful in 1m8s
driver / lowest (pull_request) Successful in 40s
driver / build (pull_request) Successful in 26s
driver / security (pull_request) Successful in 57s
CI / driver (pull_request) Successful in 2m30s
driver / publish (pull_request) Skipped
The quality ratchet refused _version_cmp at complexity 12. Comparing one
segment moves to _segment_cmp, which also takes 01 and 1 as equal, as
rpm does.
2026-11-12 11:05:49 +01:00
christianmanivong cf555d006d fix(host-status): kernel releases compare the way rpm does (4.36.2)
driver / lint (pull_request) Successful in 13s
driver / standard (pull_request) Failing after 15s
driver / types (pull_request) Successful in 1m5s
driver / test (3.13) (pull_request) Successful in 1m14s
driver / test (3.12) (pull_request) Successful in 1m19s
driver / lowest (pull_request) Successful in 42s
driver / build (pull_request) Successful in 28s
driver / security (pull_request) Successful in 1m3s
CI / driver (pull_request) Failing after 2m32s
driver / publish (pull_request) Skipped
_version_key compared the text between numbers as plain strings, so
'.el' outranked '.' and 6.12.0-208.112.5.el9uek counted as newer than
the running 6.12.0-208.112.5.1.el9uek: an Oracle Linux host asked to
reboot into an older kernel, and a reboot never cleared it. The
releases now compare like rpmvercmp: separators only separate, a
number is newer than letters in its place, and '~' comes before
anything. Checked against rpm.labelCompare on Oracle Linux 9.

Closes #109
2026-11-12 11:03:46 +01:00
christianmanivong 4e79cd1fc8 Merge pull request 'fix(host-status): an Oracle Linux host's UEK kernels are not an interrupted dnf (4.36.1)' (#108) from fix/dnf-installonly-defaults into main
driver / types (push) Successful in 1m0s
driver / standard (push) Successful in 16s
driver / lint (push) Successful in 13s
driver / test (3.12) (push) Successful in 1m17s
driver / test (3.13) (push) Successful in 1m12s
driver / lowest (push) Successful in 41s
driver / build (push) Successful in 30s
driver / security (push) Successful in 1m3s
driver / publish (push) Successful in 30s
CI / driver (push) Successful in 3m21s
2026-11-12 09:37:34 +00:00
christianmanivong 304f404567 fix(host-status): an Oracle Linux host's UEK kernels are not an interrupted dnf (4.36.1)
driver / lint (pull_request) Successful in 16s
driver / standard (pull_request) Successful in 18s
driver / types (pull_request) Successful in 59s
driver / test (3.13) (pull_request) Successful in 1m12s
driver / test (3.12) (pull_request) Successful in 1m17s
driver / lowest (pull_request) Successful in 41s
driver / build (pull_request) Successful in 30s
driver / security (pull_request) Successful in 56s
CI / driver (pull_request) Successful in 2m26s
driver / publish (pull_request) Skipped
The installonly packages were dnf's upstream defaults plus dnf.conf's.
Oracle builds kernel-uek and its parts into libdnf's defaults, and the
UEK packages provide nothing of upstream's list, so every host with more
than one UEK kernel was reported as left halfway. The defaults are now
also asked of the host's libdnf through its Python binding; upstream's
list stays the floor for dnf 5 and yum.

Closes #107
2026-11-12 10:30:48 +01:00
christianmanivong aaa9f0504a Merge pull request 'feat(time-sync): DHCP-provided NTP servers count and are read apart (4.36.0)' (#105) from feat/time-sync-dhcp-ntp-2380 into main
driver / types (push) Successful in 59s
driver / standard (push) Successful in 18s
driver / lint (push) Successful in 15s
driver / test (3.12) (push) Successful in 1m16s
driver / lowest (push) Successful in 42s
driver / test (3.13) (push) Successful in 1m11s
driver / build (push) Successful in 31s
driver / security (push) Successful in 1m2s
driver / publish (push) Successful in 31s
CI / driver (push) Successful in 3m17s
2026-11-11 21:25:27 +00:00
christianmanivong bc47220318 Merge remote-tracking branch 'origin/main' into feat/time-sync-dhcp-ntp-2380
driver / lint (pull_request) Successful in 15s
driver / standard (pull_request) Successful in 19s
driver / types (pull_request) Successful in 1m34s
driver / test (3.13) (pull_request) Successful in 1m32s
driver / test (3.12) (pull_request) Successful in 1m52s
driver / lowest (pull_request) Successful in 1m3s
driver / build (pull_request) Successful in 48s
driver / security (pull_request) Successful in 1m26s
CI / driver (pull_request) Successful in 3m17s
driver / publish (pull_request) Skipped
# Conflicts:
#	CHANGELOG.md
#	pyproject.toml
2026-11-11 22:21:34 +01:00
christianmanivong 08a62838f7 Merge pull request 'fix(dhcp): one refused reservation no longer stops the apply' (#104) from fix/dhcp-reservations-partial-apply into main
driver / standard (push) Successful in 18s
driver / lint (push) Successful in 14s
driver / types (push) Successful in 1m4s
driver / test (3.13) (push) Successful in 1m9s
driver / test (3.12) (push) Successful in 1m18s
driver / lowest (push) Successful in 41s
driver / build (push) Successful in 33s
driver / security (push) Successful in 1m7s
driver / publish (push) Successful in 32s
CI / driver (push) Successful in 3m29s
2026-11-11 21:12:31 +00:00
christianmanivong ac38c68feb 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.
2026-11-11 22:08:52 +01:00
christianmanivong 8516f2a1ee refactor(dhcp): one reservation's write in a helper of its own
driver / standard (pull_request) Successful in 17s
driver / lint (pull_request) Successful in 15s
driver / types (pull_request) Successful in 1m6s
driver / test (3.12) (pull_request) Successful in 1m19s
driver / test (3.13) (pull_request) Successful in 1m10s
driver / lowest (pull_request) Successful in 42s
driver / build (pull_request) Successful in 37s
driver / security (pull_request) Successful in 1m9s
CI / driver (pull_request) Successful in 3m0s
driver / publish (pull_request) Skipped
apply_dhcp_reservationset grew to 59 lines with the per-write handling;
the quality ratchet allows no new function that long.

Refs NetOrk/netork#2381
2026-11-11 22:08:50 +01:00
christianmanivong c74173523a 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
2026-11-11 22:03:52 +01:00
christianmanivong 6c7f164004 Merge pull request 'feat(time-sync): TimeSyncMixin, PosixTimeSyncMixin and the posix_tz helpers' (#103) from feature/time-sync-2361 into main
driver / types (push) Successful in 59s
driver / standard (push) Successful in 16s
driver / lint (push) Successful in 14s
driver / test (3.12) (push) Successful in 1m12s
driver / test (3.13) (push) Successful in 1m7s
driver / lowest (push) Successful in 38s
driver / build (push) Successful in 26s
driver / security (push) Successful in 54s
driver / publish (push) Successful in 27s
CI / driver (push) Successful in 3m3s
2026-11-11 14:05:02 +00:00
christianmanivong 073087da69 feat(time-sync): TimeSyncMixin, PosixTimeSyncMixin and the posix_tz helpers
driver / standard (pull_request) Successful in 19s
driver / lint (pull_request) Successful in 19s
driver / types (pull_request) Successful in 57s
driver / test (3.13) (pull_request) Successful in 1m4s
driver / test (3.12) (pull_request) Successful in 1m14s
driver / lowest (pull_request) Successful in 38s
driver / build (pull_request) Successful in 26s
driver / security (pull_request) Successful in 1m0s
CI / driver (pull_request) Successful in 2m23s
driver / publish (pull_request) Skipped
netOrk gets one list of NTP servers and a time zone per site and aligns
every device that differs (NetOrk/netork#2360). The contract comes first,
so the drivers can be built against it at the same time (#2361):

TimeSyncMixin declares get_time_sync() -> TimeSyncDict (servers in the
device's order, the zone as an IANA name, synchronised, the client) and
carries configure_time_sync(ntp_servers=None, timezone=None) as a fix
template: None leaves a value alone, the device ends up with exactly the
servers given, and a verify step reads it back. time_sync_writes says
which of the two values a driver writes; anything else, an unknown zone,
a malformed server or an empty list is refused before anything is
written.

PosixTimeSyncMixin implements it over run_command for Linux-like hosts:
one reading as the login user (timedatectl, chrony's configuration and
chronyc, timedatectl show-timesync, ntpd and OpenNTPD), the zone through
timedatectl set-timezone, chrony's servers in a file of their own with
every other source commented out, systemd-timesyncd's in a drop-in that
resets NTP= and empties FallbackNTP=. ntpd and OpenNTPD are read only.

posix_tz moves here from netOrk, so OpenWrt can write the POSIX rule and
a switch the UTC offset and summer-time rule (parse_posix_tz). It reads
the tzdata package, now a dependency.

Release 4.35.0: the drivers that implement it need it on PyPI.
2026-11-11 14:30:36 +01:00
christianmanivong 278a707157 Merge pull request 'feat(running-backups): the backups running on a device right now' (#102) from feature/running-backups-2318 into main
driver / lint (push) Successful in 13s
driver / standard (push) Successful in 14s
driver / types (push) Successful in 59s
driver / test (3.13) (push) Successful in 58s
driver / test (3.12) (push) Successful in 1m13s
driver / lowest (push) Successful in 35s
driver / build (push) Successful in 26s
driver / security (push) Successful in 56s
driver / publish (push) Successful in 26s
CI / driver (push) Successful in 2m36s
2026-11-11 07:22:54 +00:00
christianmanivong 56e5e82a59 feat(running-backups): the backups running on a device right now
driver / lint (pull_request) Successful in 17s
driver / standard (pull_request) Successful in 19s
driver / types (pull_request) Successful in 1m2s
driver / test (3.13) (pull_request) Successful in 1m5s
driver / test (3.12) (pull_request) Successful in 1m15s
driver / lowest (pull_request) Successful in 37s
driver / build (pull_request) Successful in 29s
driver / security (pull_request) Successful in 59s
CI / driver (pull_request) Successful in 2m24s
driver / publish (pull_request) Skipped
A restart aborts every backup that runs on the device it restarts, and a
guest's restart breaks the backup its hypervisor is taking of it. netOrk
asks right before it restarts a host after patching (NetOrk/netork#2318),
so the reading belongs in the contract first: RunningBackupsMixin declares
get_running_backups(), opt-in like VmStopRequestMixin, so hasattr tells a
caller whether the driver can tell at all.

Release 4.34.0: the drivers that implement it need it on PyPI.
2026-11-10 23:39:17 +01:00
christianmanivong e6f145d4a3 Merge pull request 'chore(release): 4.33.0' (#101) from chore/release-4.33.0 into main
driver / types (push) Successful in 1m0s
driver / standard (push) Successful in 16s
driver / lint (push) Successful in 16s
driver / test (3.12) (push) Successful in 1m16s
driver / test (3.13) (push) Successful in 1m10s
driver / lowest (push) Successful in 54s
driver / build (push) Successful in 32s
driver / security (push) Successful in 1m5s
driver / publish (push) Successful in 33s
CI / driver (push) Successful in 3m28s
2026-11-07 19:23:16 +00:00
christianmanivong 66037e878e chore(release): 4.33.0
driver / standard (pull_request) Successful in 19s
driver / lint (pull_request) Successful in 14s
driver / types (pull_request) Successful in 1m7s
driver / test (3.12) (pull_request) Successful in 1m15s
driver / lowest (pull_request) Successful in 39s
driver / test (3.13) (pull_request) Successful in 1m22s
driver / build (pull_request) Successful in 44s
driver / security (pull_request) Successful in 1m9s
CI / driver (pull_request) Successful in 2m57s
driver / publish (pull_request) Skipped
2026-11-07 20:18:14 +01:00
christianmanivong afffd0915c Merge pull request 'feat(host-status): tell an interrupted dnf, yum, apk or opkg' (#98) from feat/interrupted-pm-851 into main
driver / standard (push) Successful in 17s
driver / lint (push) Successful in 16s
driver / types (push) Successful in 1m7s
driver / test (3.13) (push) Successful in 1m9s
driver / test (3.12) (push) Successful in 1m17s
driver / lowest (push) Successful in 41s
driver / build (push) Successful in 35s
driver / security (push) Successful in 1m7s
CI / driver (push) Successful in 2m34s
driver / publish (push) Skipped
2026-11-07 19:18:08 +00:00
christianmanivong 92891473be fix(host-status): keep models.py at its recorded size, one literal for the dnf query
driver / standard (pull_request) Successful in 14s
driver / lint (pull_request) Successful in 13s
driver / types (pull_request) Successful in 58s
driver / test (3.12) (pull_request) Successful in 1m11s
driver / test (3.13) (pull_request) Successful in 1m5s
driver / lowest (pull_request) Successful in 40s
driver / build (pull_request) Successful in 36s
driver / security (pull_request) Successful in 1m6s
CI / driver (pull_request) Successful in 2m38s
driver / publish (pull_request) Skipped
The quality ratchet records models.py at 1454 lines and the new comments
had made it 1460. bandit read the dnf history query, built with an
f-string for its path, as SQL put together from strings (B608); it is a
fixed query, now one literal with the path spelt out, and a test holds
it to DNF_HISTORY.

Refs NetOrk/netork#851
2026-11-07 20:14:11 +01:00
christianmanivong 658f1c8ab2 Merge remote-tracking branch 'origin/main' into feat/interrupted-pm-851
# Conflicts:
#	CHANGELOG.md
2026-11-07 20:14:11 +01:00
christianmanivong 58ed0f0a94 feat(host-status): tell an interrupted dnf, yum, apk or opkg
driver / standard (pull_request) Failing after 18s
driver / lint (pull_request) Successful in 17s
driver / types (pull_request) Successful in 1m9s
driver / test (3.12) (pull_request) Successful in 1m22s
driver / lowest (pull_request) Successful in 39s
driver / build (pull_request) Successful in 36s
driver / test (3.13) (pull_request) Successful in 2m14s
driver / security (pull_request) Failing after 1m1s
CI / driver (pull_request) Failing after 2m42s
driver / publish (pull_request) Skipped
get_host_status() read only dpkg's state. It now also reads the rpm
database and dnf's history (or yum's journal), apk's installed database
and opkg's status file, without root, and names the manager it read in
the new package_manager field. While one of them runs, the answer is
unknown, as for dpkg.

Refs NetOrk/netork#851
2026-11-07 14:44:55 +01:00
21 changed files with 3370 additions and 41 deletions

No files matched your search

+101
View File
@@ -7,6 +7,107 @@ recorded here; their history is the git log.
## [Unreleased]
## [4.36.2] - 2026-11-12
### Fixed
- `kernel_reboot_pending` compares kernel releases the way rpm does (`rpmvercmp`). A
number is newer than letters in the same place, so an Oracle Linux host running
`6.12.0-208.112.5.1.el9uek` no longer asks to reboot into the older
`6.12.0-208.112.5.el9uek`. A `~` (release candidate) comes before its release (#109).
## [4.36.1] - 2026-11-12
### Fixed
- The host status no longer reports an Oracle Linux host's UEK kernels as an interrupted
dnf transaction. The installonly packages are now also the ones the host's libdnf was
built with, read from its Python binding: Oracle adds `kernel-uek` and its parts there,
and their packages provide nothing of upstream's defaults (#107).
## [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.1] - 2026-11-11
### Fixed
- `apply_dhcp_reservationset()` no longer stops at the first reservation the device refuses.
One refused write (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, where the next diff found them configured and never committed them. A
refused change now gets a `[failed] <mac> -> <ip>: <reason>` line, the others are written,
any non-empty diff commits, and `DhcpApplyError` (a `RuntimeError`, exported) is raised
after the commit with how many of how many were refused (NetOrk/netork#2381).
## [4.35.0] - 2026-11-11
### Added
- `TimeSyncMixin`: a device's time sources and time zone. `get_time_sync()` (declared only)
returns `TimeSyncDict` -- the configured NTP servers in the device's order, the zone as an
IANA name (None where the device keeps no name), whether the clock is synchronised now,
and the client (`chrony`, `systemd-timesyncd`, `ntpd`, `openntpd`; None for the device's
own). `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 order, and a
`verify` step reads it back. An unknown zone, a malformed server, an empty list or a value
outside the driver's `time_sync_writes` is refused before anything is written.
`TIME_SYNC_VALUES` and `check_ntp_servers` are public (NetOrk/netork#2361).
- `PosixTimeSyncMixin` implements it over `run_command`: read in one round trip as the login
user (`timedatectl`, chrony's configuration and `chronyc -n sources`, `timedatectl
show-timesync`, ntpd's and OpenNTPD's configuration); the zone by `timedatectl
set-timezone`; chrony's servers in a file of their own (`sources.d`, else a `confdir` or
an included file) with every other source commented out, then `chronyc reload sources` or
a restart; systemd-timesyncd's in a drop-in that resets `NTP=` and empties `FallbackNTP=`.
ntpd and OpenNTPD are read, not written. `parse_time_sync` is public.
- `napalm_device_types.posix_tz` (from netOrk): `posix_tz`, `is_iana_zone`, `is_posix_tz` and
`UnknownTimezone`, and `parse_posix_tz`, which takes a POSIX rule apart into the UTC
offset and the summer-time transitions a switch wants (`PosixTzDict`,
`DstTransitionDict`).
### Changed
- Needs `tzdata` (2024.1 or later): the zones' rules come from its TZif files.
## [4.34.0] - 2026-11-10
### Added
- `RunningBackupsMixin.get_running_backups()`: the backups running on a device right now --
a hypervisor's backup of its guests (with the guests it is taking now), a backup server's
backup, sync, verify, garbage collection, prune or tape run, a host's own file-level backup.
Declared only; a driver mixes it in when it can tell, and a driver without it cannot tell.
`RunningBackupDict`, `RunningBackupKind` and `RUNNING_BACKUP_KINDS` are public. An
application asks right before it restarts a device (NetOrk/netork#2318).
## [4.33.0] - 2026-11-07
### Added
- `get_host_status()` tells an interrupted package manager on hosts without dpkg too, and
says which one it read in the new `package_manager` field (`dpkg`, `dnf`, `yum`, `apk`,
`opkg`, or None). dnf and yum: a package installed in two versions (not the kernels and
other packages dnf keeps side by side) as state `duplicate`, or a transaction that never
ended (dnf 4's history, yum's `transaction-all` journal). apk: a package apk marked with
broken files or a broken script (`broken-files`, `broken-script`), the ones `apk fix` would
take. opkg: a package left `unpacked`, `half-configured` or `half-installed`, or flagged for
reinstallation. All read without root; while one of them runs the answer is unknown
(NetOrk/netork#851).
## [4.32.0] - 2026-11-07
### Added
+36 -4
View File
@@ -124,7 +124,8 @@ application wants made on a device runs as fixed steps the driver implements, wi
the caller supplies: `SnmpAgentMixin.configure_snmp_agent(settings)` (install, configure,
firewall, start), `LldpAgentMixin.configure_lldp_agent(interfaces)` (install, write the
interfaces, enable and restart; the driver writes only the interfaces),
`EnsurePackageMixin.ensure_package(name)`, `PackageProxyMixin.configure_package_proxy(url)` and
`EnsurePackageMixin.ensure_package(name)`, `PackageProxyMixin.configure_package_proxy(url)`,
`TimeSyncMixin.configure_time_sync(ntp_servers, timezone)` and
`ContainerEngineMixin.grant_container_engine_access(user)`. A driver whose device takes the
change in one call overrides the template method. A driver mixes in the fixes its device
can take; none is on a role base. They replace `run_device_action`, which is deprecated.
@@ -174,9 +175,12 @@ A driver supplies `_run_apt_command`, `_run_apt_root_command` and `_write_apt_fi
`HostStatusMixin` (`get_host_status`) is mixed in the same way: whether a Linux host needs
a reboot to finish an update (`/var/run/reboot-required`, `needs-restarting -r`, or a newer
kernel of the running flavour installed), whether it patches itself (unattended-upgrades,
dnf-automatic) and when that last succeeded (apt's `upgrade-stamp`), and whether dpkg was
left halfway (a journal in `/var/lib/dpkg/updates` or a half-configured package; unknown
while a package manager is running), and how full `/`, `/boot` and `/var` are (`df -Pk`,
dnf-automatic) and when that last succeeded (apt's `upgrade-stamp`), and whether its package
manager was left halfway (unknown while one is running): dpkg (a journal in
`/var/lib/dpkg/updates` or a half-configured package), dnf or yum (two versions of a package
in the rpm database, a transaction that never ended), apk (a package marked with broken files
or a broken script) or opkg (a package left `unpacked`), with `package_manager` naming which,
and how full `/`, `/boot` and `/var` are (`df -Pk`,
each filesystem once, in bytes; how full is too full is the caller's decision). `package_updates` holds the shared apt and dnf parsers: apt's suites become
an update's `origin`, a `-security` suite makes it a security update, and dnf's security
advisories do the same.
@@ -342,6 +346,34 @@ application's job as a timer where systemd runs, else in `/etc/cron.d` or the us
crontab. A driver sets the paths its host keeps jobs in. `napalm_device_types.cron` parses
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`). 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`).
`napalm_device_types.posix_tz` turns an IANA name into the POSIX rule libc wants in `TZ`
(OpenWrt) and that rule into a UTC offset and summer-time transitions (a switch), from the
`tzdata` package. `PosixTimeSyncMixin` implements it over `run_command`: one reading as the
login user (`timedatectl show`, the active client: chrony's configuration and `chronyc -n
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` 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
`CommandChannelMixin` declares a driver's public channel to its host:
+1
View File
@@ -151,6 +151,7 @@ the driver.
| Module | Knows |
|---|---|
| `host_status` | apt, dnf, dpkg, systemd timers, `df` |
| `package_managers` | rpm, dnf and yum history, apk's and opkg's databases, `/proc/<pid>/comm` |
| `kernel` | `/proc`, `/lib/modules`, gzip, base64 |
| `listening` | `ss`, `netstat`, `/proc/<pid>/cgroup` |
| `systemd` | `systemctl` |
+44 -1
View File
@@ -56,6 +56,7 @@ instead of being restated on every role that happens to need it:
* :class:`~napalm_device_types.nat_vpn.NatVpnMixin`
* :class:`~napalm_device_types.packages.PackageManagementMixin`
* :class:`~napalm_device_types.ping_sweep.PingSweepMixin`
* :class:`~napalm_device_types.running_backups.RunningBackupsMixin`
* :class:`~napalm_device_types.service_clusters.ServiceClustersMixin`
* :class:`~napalm_device_types.service_packages.ServicePackagesMixin`
* :class:`~napalm_device_types.ssh_server_auth.SshServerAuthMixin`
@@ -64,6 +65,8 @@ instead of being restated on every role that happens to need it:
* :class:`~napalm_device_types.scheduled_jobs_posix.PosixScheduledJobsMixin`
* :class:`~napalm_device_types.services.ServiceControlMixin`
* :class:`~napalm_device_types.systemd.SystemdServicesMixin`
* :class:`~napalm_device_types.time_sync.TimeSyncMixin`
* :class:`~napalm_device_types.time_sync_posix.PosixTimeSyncMixin`
* :class:`~napalm_device_types.updates.UpdateMixin`
* :class:`~napalm_device_types.virtual_ips.VirtualIpsMixin`
* :class:`~napalm_device_types.vm_stop_request.VmStopRequestMixin`
@@ -124,7 +127,7 @@ from napalm_device_types.container_engine import (
ContainerEngineMixin,
ContainerEngineUnavailable,
)
from napalm_device_types.dhcp import DhcpServerMixin, normalize_cidr, normalize_mac
from napalm_device_types.dhcp import DhcpApplyError, DhcpServerMixin, normalize_cidr, normalize_mac
from napalm_device_types.dns_forward import DnsForwardMixin
from napalm_device_types.firewall import FirewallDriver
from napalm_device_types.firewall_rules import FirewallRuleMixin
@@ -221,9 +224,24 @@ from napalm_device_types.package_updates import (
from napalm_device_types.packages import PackageManagementMixin
from napalm_device_types.phone import PhoneDriver
from napalm_device_types.ping_sweep import PingSweepMixin, driver_supports_ping
from napalm_device_types.posix_tz import (
DstTransitionDict,
PosixTzDict,
UnknownTimezone,
is_iana_zone,
is_posix_tz,
parse_posix_tz,
posix_tz,
)
from napalm_device_types.provisioning import VMProvisionIncomplete
from napalm_device_types.residential_gateway import ResidentialGatewayDriver
from napalm_device_types.roles import primary_role_of, role_keys_of, roles_of
from napalm_device_types.running_backups import (
RUNNING_BACKUP_KINDS,
RunningBackupDict,
RunningBackupKind,
RunningBackupsMixin,
)
from napalm_device_types.scheduled_jobs import (
ScheduledJobChanged,
ScheduledJobDict,
@@ -301,6 +319,13 @@ from napalm_device_types.systemd import (
parse_systemd_services,
)
from napalm_device_types.terminal import strip_terminal_codes
from napalm_device_types.time_sync import (
TIME_SYNC_VALUES,
TimeSyncDict,
TimeSyncMixin,
check_ntp_servers,
)
from napalm_device_types.time_sync_posix import PosixTimeSyncMixin, parse_time_sync
from napalm_device_types.updates import UpdateMixin
from napalm_device_types.virtual_ips import (
VIRTUAL_IPS_COMMAND,
@@ -379,6 +404,7 @@ __all__ = [
"DhcpHaDict",
"DhcpHaPeerDict",
"DeviceTypeDriver",
"DhcpApplyError",
"DhcpServerMixin",
"FingerprintRule",
"rules_max_weight",
@@ -468,6 +494,23 @@ __all__ = [
"VIRTUAL_IPS_COMMAND",
"VirtualIpsMixin",
"VmStopRequestMixin",
"RUNNING_BACKUP_KINDS",
"RunningBackupDict",
"RunningBackupKind",
"RunningBackupsMixin",
"TIME_SYNC_VALUES",
"TimeSyncDict",
"TimeSyncMixin",
"check_ntp_servers",
"PosixTimeSyncMixin",
"parse_time_sync",
"DstTransitionDict",
"PosixTzDict",
"UnknownTimezone",
"is_iana_zone",
"is_posix_tz",
"parse_posix_tz",
"posix_tz",
"VMProvisionIncomplete",
"SERVICE_CLUSTERS_COMMAND",
"ServiceClustersMixin",
+189
View File
@@ -0,0 +1,189 @@
"""How chrony is given exactly the time sources a caller names.
The sources go to one file of their own (:func:`plan_chrony` picks it):
1. the sources file in a ``sourcedir`` the main configuration reads (Debian's
``/etc/chrony/sources.d``): ``chronyc reload sources`` takes it without a restart;
2. else ``netork.conf`` -- the include file's name -- in the first ``confdir``;
3. else the include file, where an ``include`` pattern already takes it (SUSE's
``/etc/chrony.d/*.conf``);
4. else the include file, with an ``include`` line appended to the main configuration
(RHEL's ``/etc/chrony.conf``).
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.
"""
from __future__ import annotations
import posixpath
import re
import shlex
from dataclasses import dataclass, field
from fnmatch import fnmatchcase
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: "
#: The comment above an ``include`` line appended to the main configuration.
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
class ChronyPlan:
"""What :func:`plan_chrony` decided."""
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
def source_line(server: str) -> str:
"""The line a server is written as: a pool's name as a ``pool``, anything else a ``server``."""
directive = "pool" if ".pool." in f".{server.lower()}." else "server"
return f"{directive} {server} iburst"
def _directives(main: ConfigFile) -> list[tuple[int, str, list[str]]]:
found = []
for number, line in enumerate(main.lines, start=1):
match = _DIRECTORY_LINE.match(line)
if match:
found.append((number, match[1], match[2].split()))
return found
def _arguments(directives: list[tuple[int, str, list[str]]], kind: str) -> list[str]:
return [arg for _, k, args in directives if k == kind for arg in args]
def _target(main: ConfigFile, sources_file: str, include_file: str) -> tuple[str, str | None, bool]:
"""The file the sources go to, the main configuration to include it from, and
whether it is a sources file."""
directives = _directives(main)
if posixpath.dirname(sources_file) in _arguments(directives, "sourcedir"):
return sources_file, None, True
confdirs = _arguments(directives, "confdir")
if confdirs:
return posixpath.join(confdirs[0], posixpath.basename(include_file)), None, False
if any(fnmatchcase(include_file, p) for p in _arguments(directives, "include")):
return include_file, None, False
return include_file, main.path, False
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(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,
dhcp_dirs: tuple[str, ...] = CHRONY_DHCP_DIRS,
) -> ChronyPlan:
"""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.
"""
main = next((f for f in files if f.kind == "main"), None)
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)
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 not restore
and _only_sources_files(files, comment_out)
),
)
def _only_sources_files(files: list[ConfigFile], changed: dict[str, list[int]]) -> bool:
"""Whether every file that changes is one ``chronyc reload sources`` reads again."""
return all(f.kind == "sourcedir" for f in files if f.path in changed)
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 in_dhcp_dir(f, dhcp_dirs):
continue
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."""
edits = " ".join(
"-e "
+ 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)}"
def include_command(main: str, target: str) -> str:
"""Append an ``include`` of *target* to *main*, on a line of its own."""
lines = " ".join(shlex.quote(line) for line in (INCLUDE_COMMENT, f"include {target}"))
return (
f'{{ [ -z "$(tail -c 1 -- {shlex.quote(main)})" ] || echo; '
f"printf '%s\\n' {lines}; }} >> {shlex.quote(main)}"
)
+369
View File
@@ -0,0 +1,369 @@
"""The reading behind :class:`~napalm_device_types.time_sync_posix.PosixTimeSyncMixin`.
One command, as the login user, prints framed sections (``@@ts <name> ...``):
* ``timedatectl`` -- ``timedatectl show``: the zone, and whether the kernel clock is
synchronised;
* ``zone`` -- ``/etc/timezone`` or the target of ``/etc/localtime``, for a host
without timedatectl;
* ``active`` -- one ``<unit> <daemon> <state>`` line per time sync service;
* ``timesync`` -- ``timedatectl show-timesync``: systemd-timesyncd's servers;
* ``chronyc`` -- ``chronyc -n sources``: whether chronyd has selected a source;
* ``chrony <line> <kind> <path>`` -- chrony's main configuration (line 0, kind
``main``), then each file an ``include``, ``confdir`` or ``sourcedir`` on that
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
from napalm_device_types.time_sync import TimeSyncDict
_MARK = "@@ts "
#: ``<unit> <daemon>``: the services that keep a host's clock; the first active one counts.
TIME_SYNC_UNITS: tuple[tuple[str, str], ...] = (
("chrony", "chrony"),
("chronyd", "chrony"),
("systemd-timesyncd", "systemd-timesyncd"),
("ntpsec", "ntpd"),
("ntp", "ntpd"),
("ntpd", "ntpd"),
("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+)")
_ZONE_NAME = re.compile(r"[A-Za-z0-9_+-]+(?:/[A-Za-z0-9_+-]+)*")
#: ntpd's reference clocks are addresses in 127.127.0.0/16, not servers.
_REFCLOCK = "127.127."
# The files a chrony configuration reads, each after a marker with the line that names it.
_CHRONY_FOLLOW = """\
awk '$1=="include"||$1=="confdir"||$1=="sourcedir"{for(i=2;i<=NF;i++)print NR, $1, $i}' "$c" |
while read -r n k p; do
case $k in include) set -- $p ;; confdir) set -- "$p"/*.conf ;; *) set -- "$p"/*.sources ;; esac
for f in "$@"; do
[ -f "$f" ] && { printf '@@ts chrony %s %s %s\\n' "$n" "$k" "$f"; cat -- "$f"; echo; }
done
done"""
@dataclass(frozen=True)
class ReadPaths:
"""Where a host keeps what the reading reads."""
units: tuple[tuple[str, str], ...]
chrony_configs: tuple[str, ...]
ntpd_configs: tuple[str, ...]
openntpd_configs: tuple[str, ...]
time_zone_sh: str
@dataclass
class ConfigFile:
"""One configuration file as the reading printed it."""
path: str
kind: str # "main", "include", "confdir", "sourcedir"; "ntpd", "openntpd"
at: int # the line of the main configuration that names it; 0 for that file itself
lines: list[str] = field(default_factory=list)
@dataclass
class Reading:
"""Everything one reading said."""
timedatectl: dict[str, str] = field(default_factory=dict)
zone_files: list[str] = field(default_factory=list)
active: list[tuple[str, str]] = field(default_factory=list) # (unit, daemon), active ones
timesync: dict[str, str] = field(default_factory=dict)
chronyc: str = ""
chrony: list[ConfigFile] = field(default_factory=list)
ntpd: ConfigFile | None = None
openntpd: ConfigFile | None = None
@property
def daemon(self) -> str | None:
return self.active[0][1] if self.active else None
@property
def unit(self) -> str | None:
return self.active[0][0] if self.active else None
def _first_file(kind: str, paths: tuple[str, ...]) -> str:
candidates = " ".join(shlex.quote(p) for p in paths)
return (
f'for c in {candidates}; do [ -f "$c" ] && '
f'{{ printf \'@@ts {kind} %s\\n\' "$c"; cat -- "$c"; echo; break; }}; done'
)
def reading_command(paths: ReadPaths) -> str:
"""The command that prints the reading; ``sh`` runs it, whatever the login shell."""
active = "\n".join(
f"printf '%s %s %s\\n' {shlex.quote(unit)} {shlex.quote(daemon)} "
f'"$(systemctl is-active {shlex.quote(unit + ".service")} 2>/dev/null)"'
for unit, daemon in paths.units
)
chrony = " ".join(shlex.quote(p) for p in paths.chrony_configs)
script = "\n".join(
[
"echo '@@ts timedatectl'",
"timedatectl show 2>/dev/null",
"echo '@@ts zone'",
f"{{ {paths.time_zone_sh}; }}",
"echo '@@ts active'",
active,
"echo '@@ts timesync'",
"timedatectl show-timesync 2>/dev/null",
"echo '@@ts chronyc'",
"chronyc -n sources 2>/dev/null",
f'for c in {chrony}; do [ -f "$c" ] || continue',
'printf \'@@ts chrony 0 main %s\\n\' "$c"; cat -- "$c"; echo',
_CHRONY_FOLLOW,
"break; done",
_first_file("ntpd", paths.ntpd_configs),
_first_file("openntpd", paths.openntpd_configs),
"echo '@@ts end'",
]
)
return f"sh -c {shlex.quote(script)}"
def parse_key_values(text: str) -> dict[str, str]:
"""``Key=value`` lines (``timedatectl show``, ``show-timesync``)."""
values: dict[str, str] = {}
for line in text.splitlines():
key, sep, value = line.partition("=")
if sep and key.strip():
values[key.strip()] = value.strip()
return values
def _sections(text: str) -> list[tuple[list[str], list[str]]]:
sections: list[tuple[list[str], list[str]]] = []
for line in text.splitlines():
if line.startswith(_MARK):
sections.append((line[len(_MARK) :].split(maxsplit=3), []))
elif sections:
sections[-1][1].append(line)
return sections
def _active(lines: list[str]) -> list[tuple[str, str]]:
rows = [line.split() for line in lines]
return [(r[0], r[1]) for r in rows if len(r) == 3 and r[2] == "active"]
def _take(reading: Reading, header: list[str], lines: list[str]) -> None:
name, text = header[0], "\n".join(lines)
if name == "chrony" and len(header) == 4:
reading.chrony.append(ConfigFile(header[3], header[2], int(header[1]), lines))
elif name in ("ntpd", "openntpd") and len(header) == 2:
setattr(reading, name, ConfigFile(header[1], name, 0, lines))
else:
simple = {
"timedatectl": ("timedatectl", parse_key_values(text)),
"zone": ("zone_files", lines),
"active": ("active", _active(lines)),
"timesync": ("timesync", parse_key_values(text)),
"chronyc": ("chronyc", text),
}
if name in simple:
setattr(reading, *simple[name])
def parse_reading(text: str) -> Reading:
"""The reading's sections. :raises ValueError: for a reading cut short."""
sections = _sections(text)
if not sections or sections[-1][0] != ["end"]:
raise ValueError("the time sync reading was cut short")
reading = Reading()
for header, lines in sections:
_take(reading, header, lines)
return reading
def _source_name(rest: str) -> str | None:
"""The server in what follows ``server``/``pool``/``peer``: ntpd puts ``-4`` first."""
return next((word for word in rest.split() if not word.startswith("-")), None)
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[tuple[bool, str]] = []
for number, line in enumerate(main.lines, start=1):
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:
match = SOURCE_LINE.match(line)
if match and (name := _source_name(match[2])):
names.append(name)
return names
def ntpd_servers(lines: list[str]) -> list[str]:
"""ntpd's servers, pools and peers; reference clocks are not servers."""
return [name for name in _sources(lines) if not name.startswith(_REFCLOCK)]
def openntpd_servers(lines: list[str]) -> list[str]:
"""OpenNTPD's ``server`` and ``servers``; ``constraint`` and ``sensor`` are no sources."""
return [m[2] for line in lines if (m := _OPENNTPD_SOURCE.match(line))]
def _listed(values: dict[str, str], *keys: str) -> list[str]:
found: list[str] = []
for key in keys:
for server in values.get(key, "").split():
if server not in found:
found.append(server)
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:
"""Whether chronyd has selected a source (``^*``); None for no answer from chronyc."""
rows = [line for line in sources.splitlines() if line[:1] in ("^", "=", "#")]
if not rows:
return None
return any(line[1:2] == "*" for line in rows)
def _zone_name(value: str) -> str | None:
value = value.strip()
if "zoneinfo/" in value:
value = value.split("zoneinfo/", 1)[1]
for prefix in ("posix/", "right/"):
value = value.removeprefix(prefix)
return value if _ZONE_NAME.fullmatch(value) else None
def _time_zone(reading: Reading) -> str | None:
named = reading.timedatectl.get("Timezone", "")
if named and named != "n/a":
return _zone_name(named)
return next((z for line in reading.zone_files if (z := _zone_name(line))), None)
def _servers(reading: Reading, dhcp_dirs: tuple[str, ...]) -> list[str]:
if reading.daemon == "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:
return ntpd_servers(reading.ntpd.lines)
if reading.daemon == "openntpd" and reading.openntpd is not None:
return openntpd_servers(reading.openntpd.lines)
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)
if chrony is not None:
return chrony
return {"yes": True, "no": False}.get(reading.timedatectl.get("NTPSynchronized", ""))
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, 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, 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), dhcp_dirs)
+55 -16
View File
@@ -58,6 +58,19 @@ _DHCP_SUBNET_COMPARE_FIELDS = (
_HEX_ONLY = re.compile(r"[^0-9a-f]")
class DhcpApplyError(RuntimeError):
"""Some reservations of an applied set were refused by the device.
Raised after the rest were written and committed: ``failed`` of ``attempted``
changes did not go through, and each was named in a ``[failed]`` progress line.
"""
def __init__(self, failed: int, attempted: int) -> None:
self.failed = failed
self.attempted = attempted
super().__init__(f"{failed} of {attempted} DHCP reservation change(s) were refused")
def normalize_mac(mac: str | None) -> str:
"""Reduces a MAC address to lowercase colon-separated form.
@@ -298,29 +311,55 @@ class DhcpServerMixin:
committing reloads the DHCP daemon and drops in-flight requests, which
is too high a price for a no-op run.
A change the device refuses (say, an address in a subnet its DHCP server
does not manage) does not stop the others: it gets a ``[failed]`` line,
the rest are written and committed, and ``DhcpApplyError`` is raised at
the end. Any non-empty diff commits, even one whose every write was
refused, so that writes an earlier, interrupted run saved take effect.
:param desired: The complete desired reservation set.
:yields: Progress lines, one per applied add/update, plus a final
commit line.
:yields: Progress lines, one per applied, updated or refused change,
plus a final commit line.
:raises DhcpApplyError: after the commit, when a change was refused.
"""
diff = self.diff_dhcp_reservations(desired)
for reservation in diff["add"]:
self.apply_dhcp_reservation(reservation)
yield f"[add] {reservation['mac']} -> {reservation['ip']}"
for entry in diff["update"]:
self.apply_dhcp_reservation(entry["reservation"], uuid=entry["uuid"])
fields = ", ".join(entry["changed_fields"])
yield (
f"[update] {entry['reservation']['mac']} -> {entry['reservation']['ip']} ({fields})"
)
if not diff["add"] and not diff["update"]:
attempted = len(diff["add"]) + len(diff["update"])
if not attempted:
yield "[commit] no changes"
return
added = updated = refused = 0
for reservation in diff["add"]:
line, ok = self._write_reservation(reservation, None, "[add]")
added, refused = added + ok, refused + (not ok)
yield line
for entry in diff["update"]:
fields = ", ".join(entry["changed_fields"])
line, ok = self._write_reservation(entry["reservation"], entry["uuid"], "[update]")
updated, refused = updated + ok, refused + (not ok)
yield f"{line} ({fields})" if ok else line
# Committed even when every write was refused: a run that stopped before its
# commit left saved writes behind, which the device reports as configured, so
# no later diff would ever commit them.
self.commit_dhcp_reservations()
yield (f"[commit] applied {len(diff['add'])} add(s), {len(diff['update'])} update(s)")
yield f"[commit] applied {added} add(s), {updated} update(s)"
if refused:
raise DhcpApplyError(refused, attempted)
def _write_reservation(
self, reservation: DhcpReservationDict, uuid: str | None, tag: str
) -> tuple[str, bool]:
"""Write one reservation; its progress line, and whether the device took it."""
target = f"{reservation['mac']} -> {reservation['ip']}"
try:
self.apply_dhcp_reservation(reservation, uuid=uuid)
except Exception as exc:
return f"[failed] {target}: {exc}", False
return f"{tag} {target}", True
def diff_dhcp_subnets(self, desired: list[DhcpSubnetDict]) -> DhcpSubnetDiffDict:
"""
+67 -13
View File
@@ -43,7 +43,9 @@ exits quietly every day (NetOrk/netork#738). While dpkg, apt, aptitude or
unattended-upgrade is running, packages are halfway on purpose -- also between
two of apt's dpkg calls -- so the answer is then ``None``, as on a host without
dpkg. unattended-upgrade is told from Ubuntu's idle shutdown helper by its
command line (:data:`BUSY_CHECK`).
command line (:data:`BUSY_CHECK`). On a host without dpkg, dnf or yum, apk and opkg
are read the same way (:mod:`napalm_device_types.package_managers`,
NetOrk/netork#851), and ``package_manager`` names the one the answer is about.
**Filesystems** are how full ``/``, ``/boot`` and ``/var`` are, from POSIX
``df -Pk``: where an upgrade unpacks a kernel, builds its initrd and keeps the
@@ -58,6 +60,7 @@ too full is not decided here.
from __future__ import annotations
import re
from functools import cmp_to_key
from typing import TYPE_CHECKING
from napalm_device_types.models import (
@@ -65,6 +68,11 @@ from napalm_device_types.models import (
HostStatusDict,
InterruptedPackageDict,
)
from napalm_device_types.package_managers import (
PACKAGE_MANAGERS_COMMAND,
PackageManagerReading,
parse_package_managers,
)
from napalm_device_types.terminal import strip_terminal_codes
_BEGIN = "HSTAT_BEGIN"
@@ -117,6 +125,7 @@ HOST_STATUS_COMMAND = (
f"echo '[dpkg-journal]'; ls -1 {_DPKG_JOURNAL} 2>/dev/null | head -n 20; "
"echo '[dpkg-audit]'; dpkg-query -W -f='${db:Status-Abbrev} ${Package}\\n' 2>/dev/null "
"| awk 'substr($0, 2, 1) ~ /[HUFWt]/ || substr($0, 3, 1) == \"R\"' | head -n 50; fi; "
f"{PACKAGE_MANAGERS_COMMAND}"
f"echo '[filesystems]'; df -Pk {_FILESYSTEMS}; "
f"echo '[timers]'; for u in {_APT_TIMER} {' '.join(_DNF_TIMERS)}; do "
'printf \'%s %s\\n\' "$u" "$(systemctl is-enabled "$u" 2>/dev/null)"; done; '
@@ -163,9 +172,39 @@ def _sections(output: str) -> dict[str, list[str]]:
return sections
def _version_key(version: str) -> tuple[object, ...]:
"""Natural order: 6.8.0-142 after 6.8.0-87, 7.0.14 after 7.0.2."""
return tuple(int(part) if part.isdigit() else part for part in re.split(r"(\d+)", version))
#: A version's segments as rpm compares them: runs of digits, runs of letters, and
#: ``~``; whatever else stands between them only separates.
_VERSION_SEGMENT = re.compile(r"~|\d+|[A-Za-z]+")
def _segment_cmp(x: str, y: str) -> int:
"""One segment against another, as :func:`_version_cmp` takes them; 0 when equal."""
if "~" in (x, y):
return (y == "~") - (x == "~")
if x.isdigit() and y.isdigit():
return (int(x) > int(y)) - (int(x) < int(y))
if x.isdigit() or y.isdigit():
return 1 if x.isdigit() else -1
return (x > y) - (x < y)
def _version_cmp(a: str, b: str) -> int:
"""rpm's ``rpmvercmp``: below 0 when ``a`` is older, above when newer.
Numbers compare as numbers (6.8.0-142 after 6.8.0-87), letters as text, and a
number is newer than letters in its place: ``112.5.1.el9uek`` after
``112.5.el9uek`` (#109). A version that has more segments where the other
ends is the newer one, unless its next is ``~``, which comes before anything:
``6.13~rc5`` before ``6.13``, as dpkg sorts it too.
"""
left, right = _VERSION_SEGMENT.findall(a), _VERSION_SEGMENT.findall(b)
for x, y in zip(left, right, strict=False):
if order := _segment_cmp(x, y):
return order
if len(left) == len(right):
return 0
longer, sign = (left, 1) if len(left) > len(right) else (right, -1)
return -sign if longer[min(len(left), len(right))] == "~" else sign
def kernel_reboot_pending(running: str, installed: list[str]) -> str | None:
@@ -180,8 +219,9 @@ def kernel_reboot_pending(running: str, installed: list[str]) -> str | None:
same = [k for k in installed if _kernel_flavour(k)[1] == flavour]
if not same:
return None
newest = max(same, key=lambda k: _version_key(_kernel_flavour(k)[0]))
if _version_key(_kernel_flavour(newest)[0]) > _version_key(version):
order = cmp_to_key(_version_cmp)
newest = max(same, key=lambda k: order(_kernel_flavour(k)[0]))
if order(_kernel_flavour(newest)[0]) > order(version):
return newest
return None
@@ -287,12 +327,24 @@ def _halfway(line: str) -> InterruptedPackageDict | None:
return {"name": name, "state": state} if name and state else None
def _dpkg(sections: dict[str, list[str]]) -> tuple[bool | None, list[InterruptedPackageDict]]:
if "dpkg-audit" not in sections or "dpkg-busy" in sections:
return None, []
def _dpkg(sections: dict[str, list[str]]) -> PackageManagerReading | None:
if "dpkg-audit" not in sections:
return None
if "dpkg-busy" in sections:
return PackageManagerReading("dpkg", None, [])
packages = [p for p in map(_halfway, sections["dpkg-audit"]) if p is not None]
journal = any(_JOURNAL_ENTRY.fullmatch(f) for f in sections.get("dpkg-journal") or [])
return bool(packages) or journal, packages
return PackageManagerReading("dpkg", bool(packages) or journal, packages)
def _package_manager(sections: dict[str, list[str]]) -> PackageManagerReading:
"""The reading that says most: one left halfway, then one that is not, then a busy one."""
readings = [r for r in (_dpkg(sections), *parse_package_managers(sections)) if r is not None]
for interrupted in (True, False):
found = next((r for r in readings if r.interrupted is interrupted), None)
if found is not None:
return found
return readings[0] if readings else PackageManagerReading(None, None, [])
def _filesystems(sections: dict[str, list[str]]) -> list[FilesystemUsageDict] | None:
@@ -318,15 +370,16 @@ def parse_host_status(output: str) -> HostStatusDict:
"""
sections = _sections(output)
required, reason = _reboot(sections)
interrupted, packages = _dpkg(sections)
manager = _package_manager(sections)
return {
"reboot_required": required,
"reboot_reason": reason,
"auto_updates": _auto_updates(sections),
"auto_updates_last_success": _last_success(sections),
"auto_updates_interval": _interval(sections),
"package_manager_interrupted": interrupted,
"interrupted_packages": packages,
"package_manager": manager.manager,
"package_manager_interrupted": manager.interrupted,
"interrupted_packages": manager.packages,
"filesystems": _filesystems(sections),
}
@@ -356,6 +409,7 @@ class HostStatusMixin:
* auto_updates (bool or None)
* auto_updates_last_success (Unix time or None)
* auto_updates_interval (seconds or None)
* package_manager (dpkg, dnf, yum, apk, opkg, or None)
* package_manager_interrupted (bool or None)
* interrupted_packages (list of {name, state})
* filesystems (list of {mountpoint, total, used, available} in bytes, or None)
+5 -5
View File
@@ -85,8 +85,8 @@ class InterruptedPackageDict(TypedDict):
"""A package an interrupted package manager run left halfway."""
name: str
#: dpkg's word for it: "half-installed", "unpacked", "half-configured",
#: "triggers-awaited", "triggers-pending", or "reinstall-required".
#: The manager's word for it: dpkg's and opkg's ("unpacked", "half-configured", ...),
#: rpm's "duplicate", apk's "broken-files" and "broken-script" (``package_managers``).
state: str
@@ -111,9 +111,9 @@ class HostStatusDict(TypedDict):
reboot_reason: str | None
#: True when the host installs updates on its own (unattended-upgrades, dnf-automatic).
auto_updates: bool | None
#: True when a package manager run was cut off and has to be finished
#: (``dpkg --configure -a``) before anything else installs; None when it
#: cannot tell, or a package manager is running right now.
#: The package manager read (dpkg, dnf, yum, apk, opkg; None: none) and whether a run
#: of it was cut off, left halfway (None: cannot tell, or one is running right now).
package_manager: NotRequired[str | None]
package_manager_interrupted: NotRequired[bool | None]
#: The packages that run left halfway; empty when only its journal says so.
interrupted_packages: NotRequired[list[InterruptedPackageDict]]
+207
View File
@@ -0,0 +1,207 @@
"""Whether dnf or yum, apk or opkg was left halfway: the host status's answer for
a host without dpkg (NetOrk/netork#851).
Read the same way as dpkg's state (:mod:`napalm_device_types.host_status`): in the
one host status command, without root, and changing nothing. Each manager is asked
only where it exists, and while one of its processes runs -- from
``/proc/<pid>/comm``, which every Linux has and BusyBox's ``ps`` cannot narrow to --
its packages are halfway on purpose and the answer is unknown.
**dnf and yum** (rpm). A transaction cut off after rpm installed the new version
of a package and before it erased the old one leaves both in the rpm database:
what ``dnf check --duplicates`` and ``package-cleanup --dupes`` report. Packages
dnf installs side by side on purpose do not count: its default ``installonlypkgs``
(``kernel``, ``installonlypkg(kernel)`` and the rest), plus any the host adds in
``dnf.conf``, asked of rpm by what they provide; and ``gpg-pubkey``, one entry
per imported key. The defaults are the ones the host's libdnf was built with, asked
of its Python binding, as a distribution may add its own: Oracle Linux adds
``kernel-uek`` and its parts, whose packages provide nothing of upstream's list.
Upstream's list is the floor where libdnf cannot be asked (dnf 5, yum). Also
interrupted is a transaction that never ended: dnf 4's history (libdnf's ``trans``
table) holds its row with ``state`` 0 until ``finish()`` writes 1 (done) or 2
(error), so the newest row at 0 is one cut off;
yum leaves a ``transaction-all.*`` journal in ``/var/lib/yum``, which
``yum-complete-transaction`` reads (one renamed ``.disabled`` is given up). The
history is read with Python's sqlite3 module in read-only mode, as a stock EL host
has no ``sqlite3`` program and a ``dnf`` command loads every plugin and may reach
for its repositories. dnf 5's history lives elsewhere and is not read; its
duplicates are.
**apk** (Alpine, OpenWrt from 25.12). apk marks an installed package whose files
or scripts failed with ``f:`` in ``/lib/apk/db/installed`` -- ``f`` broken files,
``s`` a broken script; ``x`` (xattrs) and ``S`` (the checksum kind) are no fault --
and those are exactly the packages ``apk fix`` without arguments picks. A run
killed outright leaves no such mark; its next run usually repeats what it left.
**opkg** (OpenWrt before 25.12). ``/usr/lib/opkg/status`` holds
``Status: <want> <flags> <state>`` per package. A run cut off, or a postinst that
failed, leaves ``unpacked`` (or ``half-configured``, ``half-installed``), and the
``reinstreq`` flag asks for a reinstall; ``opkg configure`` finishes every unpacked
package.
What to do about it is not decided here.
"""
from __future__ import annotations
from typing import NamedTuple
from napalm_device_types.models import InterruptedPackageDict
#: dnf's default ``installonlypkgs``: names and what such packages provide.
_INSTALLONLY = (
"kernel",
"kernel-PAE",
"installonlypkg(kernel)",
"installonlypkg(kernel-module)",
"installonlypkg(vm)",
"multiversion(kernel)",
)
#: Where a host adds its own installonly packages, dnf's then yum's.
_DNF_CONF = "/etc/dnf/dnf.conf /etc/yum.conf"
DNF_HISTORY = "/var/lib/dnf/history.sqlite"
YUM_DIR = "/var/lib/yum"
APK_INSTALLED = "/lib/apk/db/installed"
OPKG_STATUS = "/usr/lib/opkg/status"
#: manager -> the process names that leave its packages halfway while they run.
_RUNNING = {
"rpm": frozenset({"rpm", "dnf", "dnf5", "yum", "dnf-automatic", "packagekitd"}),
"apk": frozenset({"apk"}),
"opkg": frozenset({"opkg"}),
}
_UNFINISHED = "0"
_YUM_JOURNAL = "transaction-all."
_YUM_GIVEN_UP = ".disabled"
_APK_FLAGS = (("f", "broken-files"), ("s", "broken-script"))
_OPKG_HALFWAY = frozenset({"unpacked", "half-configured", "half-installed"})
_OPKG_REINSTALL = "reinstreq"
#: The newest transaction in dnf's history as ``<id> <state>``; nothing when unreadable.
#: One literal, with :data:`DNF_HISTORY` spelt out: a fixed query, nothing put into it.
_DNF_HISTORY_PY = (
"import sqlite3; "
"c = sqlite3.connect('file:/var/lib/dnf/history.sqlite?mode=ro', uri=True); "
"r = c.execute('SELECT id, state FROM trans ORDER BY id DESC LIMIT 1').fetchone(); "
"r and print(*r)"
)
#: The ``installonlypkgs`` the host's libdnf (dnf 4) was built with, space-separated;
#: nothing where there is no libdnf. ``ConfigMain`` is held in a name: an option
#: taken from a temporary one outlives it, and reading it then crashes Python.
_LIBDNF_INSTALLONLY_PY = (
"import libdnf.conf; c = libdnf.conf.ConfigMain(); "
"print(c.installonlypkgs().getValueString().replace(',', ' '))"
)
_RUNNING_PART = (
"echo '[pm-running]'; cat /proc/[0-9]*/comm 2>/dev/null | grep -xE '"
+ "|".join(sorted(set().union(*_RUNNING.values())))
+ "' | sort -u; "
)
_RPM_PART = (
"if command -v rpm >/dev/null 2>&1 && { command -v dnf || command -v yum; } >/dev/null 2>&1; "
"then echo '[rpm-frontend]'; { command -v dnf || command -v yum; } | sed 's#.*/##'; "
"rpmpy=; for p in /usr/libexec/platform-python python3; do "
"if command -v $p >/dev/null 2>&1; then rpmpy=$p; break; fi; done; "
f"echo '[rpm-installonly]'; io=\"{' '.join(_INSTALLONLY)} "
f'$([ -n "$rpmpy" ] && $rpmpy -c "{_LIBDNF_INSTALLONLY_PY}" 2>/dev/null) '
f"$(sed -n 's/^[[:space:]]*installonlypkgs[[:space:]]*=//p' {_DNF_CONF} 2>/dev/null "
"| tr ',' ' ')\"; rpm -q --whatprovides $io --qf '%{NAME}\\n' 2>/dev/null "
"| grep -v ' ' | sort -u; "
"echo '[rpm-dupes]'; rpm -qa --qf '%{NAME} %{ARCH}\\n' 2>/dev/null "
"| grep -v '^gpg-pubkey ' | sort | uniq -d | head -n 50; "
f"echo '[yum-journal]'; ls -1 {YUM_DIR} 2>/dev/null | grep '^transaction-all\\.' "
"| head -n 20; "
"echo '[dnf-history]'; "
f'[ -n "$rpmpy" ] && $rpmpy -c "{_DNF_HISTORY_PY}" 2>/dev/null; fi; '
)
_APK_PART = (
f"if command -v apk >/dev/null 2>&1 && [ -r {APK_INSTALLED} ]; then echo '[apk-audit]'; "
"awk '/^P:/ {p = substr($0, 3)} /^f:/ {f = substr($0, 3)} "
'/^$/ {if (f ~ /[fs]/) print f, p; p = ""; f = ""} END {if (f ~ /[fs]/) print f, p}\' '
f"{APK_INSTALLED} | head -n 50; fi; "
)
_OPKG_PART = (
f"if command -v opkg >/dev/null 2>&1 && [ -r {OPKG_STATUS} ]; then echo '[opkg-audit]'; "
"awk '/^Package:/ {p = $2} /^Status:/ && "
"($4 ~ /^(unpacked|half-configured|half-installed)$/ || $3 ~ /reinstreq/) "
f"{{print $3, $4, p}}' {OPKG_STATUS} | head -n 50; fi; "
)
#: The part of the host status command that reads them; POSIX ``sh``, BusyBox too.
PACKAGE_MANAGERS_COMMAND = _RUNNING_PART + _RPM_PART + _APK_PART + _OPKG_PART
class PackageManagerReading(NamedTuple):
"""One package manager's state: halfway or not, None while it is running."""
manager: str | None
interrupted: bool | None
packages: list[InterruptedPackageDict]
def _unfinished_transaction(sections: dict[str, list[str]]) -> bool:
newest = (sections.get("dnf-history") or [""])[0].split()
if len(newest) == 2 and newest[1] == _UNFINISHED:
return True
return any(
name.startswith(_YUM_JOURNAL) and not name.endswith(_YUM_GIVEN_UP)
for name in sections.get("yum-journal") or []
)
def _rpm(sections: dict[str, list[str]], running: set[str]) -> PackageManagerReading | None:
if "rpm-dupes" not in sections:
return None
manager = (sections.get("rpm-frontend") or ["dnf"])[0]
if running & _RUNNING["rpm"]:
return PackageManagerReading(manager, None, [])
installonly = set(sections.get("rpm-installonly") or [])
names = dict.fromkeys(line.split()[0] for line in sections["rpm-dupes"])
packages: list[InterruptedPackageDict] = [
{"name": name, "state": "duplicate"} for name in names if name not in installonly
]
return PackageManagerReading(
manager, bool(packages) or _unfinished_transaction(sections), packages
)
def _apk(sections: dict[str, list[str]], running: set[str]) -> PackageManagerReading | None:
if "apk-audit" not in sections:
return None
if running & _RUNNING["apk"]:
return PackageManagerReading("apk", None, [])
packages: list[InterruptedPackageDict] = []
for line in sections["apk-audit"]:
flags, _, name = line.partition(" ")
name = name.strip()
packages += [
{"name": name, "state": state} for flag, state in _APK_FLAGS if name and flag in flags
]
return PackageManagerReading("apk", bool(packages), packages)
def _opkg_package(line: str) -> InterruptedPackageDict | None:
parts = line.split()
if len(parts) != 3:
return None
flags, state, name = parts
if _OPKG_REINSTALL in flags.split(","):
return {"name": name, "state": "reinstall-required"}
return {"name": name, "state": state} if state in _OPKG_HALFWAY else None
def _opkg(sections: dict[str, list[str]], running: set[str]) -> PackageManagerReading | None:
if "opkg-audit" not in sections:
return None
if running & _RUNNING["opkg"]:
return PackageManagerReading("opkg", None, [])
packages = [p for p in map(_opkg_package, sections["opkg-audit"]) if p is not None]
return PackageManagerReading("opkg", bool(packages), packages)
def parse_package_managers(sections: dict[str, list[str]]) -> list[PackageManagerReading]:
"""What :data:`PACKAGE_MANAGERS_COMMAND` found, one reading per manager it asked."""
running = set(sections.get("pm-running") or [])
readings = (read(sections, running) for read in (_rpm, _apk, _opkg))
return [reading for reading in readings if reading is not None]
+176
View File
@@ -0,0 +1,176 @@
"""A time zone as a device takes it: an IANA name, a POSIX TZ rule, or the rule's parts.
An application names a zone the IANA way (``Europe/Berlin``). Not every device
can: OpenWrt hands ``system.timezone`` to libc as ``TZ``, which wants the rule
itself (``CET-1CEST,M3.5.0,M10.5.0/3``), and a switch wants a UTC offset and the
summer-time rule. A driver translates with these helpers.
The rule is the footer of the zone's TZif file (version 2 and later): the line
after the last transition that says how the zone goes on. OpenWrt's LuCI table is
built from the same footers. The files come from the ``tzdata`` package, a
declared dependency, so every driver reads the same database whatever its host
ships.
"""
from __future__ import annotations
import re
from functools import lru_cache
from importlib.resources import files
from typing import TypedDict
#: An IANA name: letters, digits, ``_+-`` in ``/``-separated parts. No dots, so
#: nothing reaches outside the database.
_ZONE_NAME = re.compile(r"[A-Za-z0-9_+-]+(?:/[A-Za-z0-9_+-]+)*")
_ABBR = r"(?:[A-Za-z]{3,}|<[A-Za-z0-9+-]{3,}>)"
_OFFSET = r"[+-]?\d{1,2}(?::\d{1,2}){0,2}"
_DATE = r"(?:J\d{1,3}|\d{1,3}|M\d{1,2}\.\d\.\d)(?:/[+-]?\d{1,3}(?::\d{1,2}){0,2})?"
#: ``std offset [dst [offset] [,start,end]]`` (POSIX.1, 8.3), and a bare ``UTC`` or
#: ``GMT``, which OpenWrt itself writes by default.
_POSIX_TZ = re.compile(
rf"(?:UTC|GMT)|{_ABBR}{_OFFSET}(?:{_ABBR}(?:{_OFFSET})?(?:,{_DATE},{_DATE})?)?"
)
_PARTS = re.compile(
rf"(?P<std>{_ABBR})(?P<offset>{_OFFSET})"
rf"(?:(?P<dst>{_ABBR})(?P<dst_offset>{_OFFSET})?"
r"(?:,(?P<start>[^,]+),(?P<end>[^,]+))?)?"
)
_TRANSITION = re.compile(r"M(\d{1,2})\.([1-5])\.([0-6])(?:/([+-]?\d{1,3}(?::\d{1,2}){0,2}))?")
#: When a rule names no time of day for a transition: 02:00 local time.
_DEFAULT_TRANSITION_TIME = 7200
class DstTransitionDict(TypedDict):
"""When summer time starts or ends: a weekday of a week of a month, and a time."""
month: int # 1-12
week: int # 1-5; 5 is the month's last such weekday
weekday: int # 0 = Sunday ... 6 = Saturday
time: int # seconds after local midnight, in the time then in force; may be < 0 or > 24h
class PosixTzDict(TypedDict):
"""A POSIX TZ rule in parts (:func:`parse_posix_tz`)."""
std_name: str # "CET"; a quoted name without its <> ("-03")
utc_offset: int # seconds east of UTC in standard time: CET 3600, EST -18000
dst_name: str | None # "CEST"; None for a zone without summer time
dst_offset: int | None # seconds east of UTC in summer time; None without it
dst_start: DstTransitionDict | None # None without summer time or without a rule for it
dst_end: DstTransitionDict | None
class UnknownTimezone(ValueError):
"""A zone that is not in the zone database (nor, where one is taken, a POSIX TZ rule)."""
def __init__(self, zone: str) -> None:
super().__init__(zone)
self.zone = zone
def __str__(self) -> str:
return (
f"unknown time zone {self.zone!r}: not a name of the IANA time zone database"
" such as Europe/Berlin"
)
def is_posix_tz(value: str) -> bool:
"""Whether *value* reads as a POSIX TZ string -- the form libc takes in ``TZ``."""
return bool(_POSIX_TZ.fullmatch(value))
@lru_cache(maxsize=512)
def _footer(zone: str) -> str | None:
"""The POSIX rule at the end of *zone*'s TZif file; None for no such zone."""
if not _ZONE_NAME.fullmatch(zone):
return None
tzfile = files("tzdata").joinpath("zoneinfo", *zone.split("/"))
if not tzfile.is_file():
return None
data = tzfile.read_bytes()
if not data.startswith(b"TZif") or data[4:5] not in (b"2", b"3", b"4") or data[-1:] != b"\n":
return None
footer = data[:-1].rsplit(b"\n", 1)[-1].decode("ascii", "replace")
return footer if is_posix_tz(footer) else None
def is_iana_zone(zone: str) -> bool:
"""Whether *zone* names a zone of the database (``Europe/Berlin``, ``UTC``)."""
return _footer(zone) is not None
def posix_tz(zone: str) -> str | None:
"""The POSIX TZ string for *zone*: an IANA name's rule, a POSIX string as it is.
None when *zone* is neither -- a device given it would run on UTC.
"""
return _footer(zone) or (zone if is_posix_tz(zone) else None)
def _seconds(value: str) -> int:
"""``[+-]hh[:mm[:ss]]`` in seconds."""
sign = -1 if value.startswith("-") else 1
parts = [int(p) for p in value.lstrip("+-").split(":")]
hours, minutes, seconds = (parts + [0, 0])[:3]
return sign * (hours * 3600 + minutes * 60 + seconds)
def _transition(value: str) -> DstTransitionDict | None:
match = _TRANSITION.fullmatch(value)
if match is None:
return None
month, week, weekday, time = match.groups()
return {
"month": int(month),
"week": int(week),
"weekday": int(weekday),
"time": _DEFAULT_TRANSITION_TIME if time is None else _seconds(time),
}
def parse_posix_tz(rule: str) -> PosixTzDict | None:
"""*rule* in parts; None for what is not a rule, or one with Julian-day transitions.
POSIX counts offsets west of UTC (``CET-1``); the parts count them east, as a
device's "UTC+01:00" does. Summer time without an offset of its own is one hour
ahead of standard time.
"""
if rule in ("UTC", "GMT"):
rule += "0"
match = _PARTS.fullmatch(rule)
if match is None or not is_posix_tz(rule):
return None
utc_offset = -_seconds(match["offset"])
parts: PosixTzDict = {
"std_name": match["std"].strip("<>"),
"utc_offset": utc_offset,
"dst_name": None,
"dst_offset": None,
"dst_start": None,
"dst_end": None,
}
if match["dst"] is None:
return parts
parts["dst_name"] = match["dst"].strip("<>")
parts["dst_offset"] = (
utc_offset + 3600 if match["dst_offset"] is None else -_seconds(match["dst_offset"])
)
if match["start"] is not None:
start, end = _transition(match["start"]), _transition(match["end"])
if start is None or end is None:
return None
parts["dst_start"], parts["dst_end"] = start, end
return parts
__all__ = [
"DstTransitionDict",
"PosixTzDict",
"UnknownTimezone",
"is_iana_zone",
"is_posix_tz",
"parse_posix_tz",
"posix_tz",
]
+69
View File
@@ -0,0 +1,69 @@
"""The backups running on a device right now.
A restart aborts every backup that runs on the device it restarts: a
hypervisor's backup of its guests, a backup server's backup, sync, verify or
garbage collection, a host's own file-level backup (restic, borg and the like).
A guest's restart breaks the backup its hypervisor is taking of it. So an
application that restarts a device asks first, right before the restart.
Declared under ``if TYPE_CHECKING``: a driver mixes this in when it can tell;
``hasattr`` tells a caller whether it did. No role base carries it, and a driver
without it cannot tell -- which is not the same as "nothing runs".
"""
from __future__ import annotations
from typing import TYPE_CHECKING, Literal, TypedDict, get_args
#: What a running backup does: the backup itself, or one of a backup server's
#: jobs (``napalm_device_types.backups.BackupJobKind``).
RunningBackupKind = Literal["backup", "sync", "verify", "gc", "prune", "tape"]
RUNNING_BACKUP_KINDS: tuple[str, ...] = get_args(RunningBackupKind)
class RunningBackupDict(TypedDict):
"""One backup running on the device (``get_running_backups``)."""
kind: RunningBackupKind
job: str | None # the job it runs for, as the platform names it; None: started by hand
task: str | None # this run's id on the platform: a task id, a unit, a process id
guests: list[str] # the guests (get_vms' ids) it is backing up now; [] for the host's own
since: int | None # unix seconds it started; None when the platform does not say
class RunningBackupsMixin:
if TYPE_CHECKING:
def get_running_backups(self) -> list[RunningBackupDict]:
"""
Returns the backups running on the device now; ``[]`` when none is.
Every entry runs on this device: restarting the device aborts it.
A hypervisor names in ``guests`` the guests a backup is taking right
now -- a guest that is locked for its backup counts, with or without
a task the platform still shows -- so the application can tell a
guest's own restart not to break it.
Example::
[
{
"kind": "backup",
"job": "backup-3f2a9c1e-77d1",
"task": "UPID:pve1:0001F2A3:00C4B1D2:6731A0C0:vzdump::root@pam:",
"guests": ["101"],
"since": 1793660400,
},
{
"kind": "gc",
"job": "store1",
"task": "UPID:localhost:000004D2:...:garbage_collection:store1:root@pam:",
"guests": [],
"since": 1793664000,
},
]
:raises Exception: when the device could not be read; never an
empty list for a failed read.
"""
...
+193
View File
@@ -0,0 +1,193 @@
"""A device's time sources and time zone: read them, and set them to what the caller says.
An application keeps one list of NTP servers and a time zone per site, and aligns a
device that differs. :class:`TimeSyncMixin` is the contract for that:
* ``get_time_sync()`` -- declared only, so ``callable(getattr(driver,
"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 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
runs on UTC only writes ``{"ntp_servers"}``; the application never asks it for a
zone.
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`.
"""
# 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, NotRequired, TypedDict
from napalm_device_types.fixes import FixStep, run_fix_steps
from napalm_device_types.models import FixResultDict, FixStepOutcomeDict
from napalm_device_types.posix_tz import UnknownTimezone, is_iana_zone
#: The values a driver can write; ``time_sync_writes`` is a subset.
TIME_SYNC_VALUES: frozenset[str] = frozenset({"ntp_servers", "timezone"})
_HOST_NAME = re.compile(
r"(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?"
r"(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*\.?"
)
class TimeSyncDict(TypedDict):
"""How a device keeps its clock (``get_time_sync``)."""
ntp_servers: list[str] # configured time sources, in the device's order; [] = none configured
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:
try:
ipaddress.ip_address(name)
except ValueError:
return bool(_HOST_NAME.fullmatch(name))
return True
def check_ntp_servers(servers: Sequence[str]) -> list[str]:
"""*servers* as a driver writes them: stripped, in their order, each once.
:raises ValueError: for no server at all, or one that is not a host name or
an IP address -- before anything reaches a configuration file.
:raises TypeError: for a single string instead of a list of them.
"""
if isinstance(servers, str):
raise TypeError("ntp_servers is a list of servers, not one string")
kept: list[str] = []
for server in (str(s).strip() for s in servers):
if not server:
continue
if not _is_server(server):
raise ValueError(f"{server!r} is not a host name or address of an NTP server")
if server.lower() not in (k.lower() for k in kept):
kept.append(server)
if not kept:
raise ValueError("name at least one NTP server; None leaves the servers as they are")
return kept
class TimeSyncMixin:
"""Read and set a device's time sources and time zone; see the module."""
#: Which of the two values this driver can write: a subset of {"ntp_servers", "timezone"}.
#: A BMC that only runs on UTC writes {"ntp_servers"}; an application never asks it for a
#: zone. Declared only: a driver that names nothing writes nothing.
time_sync_writes: ClassVar[frozenset[str]]
if TYPE_CHECKING: # pragma: no cover - declared for type checkers only
def get_time_sync(self) -> TimeSyncDict:
"""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);
``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.
Example::
{
"ntp_servers": ["ntp1.example.org", "10.0.0.1"],
"timezone": "Europe/Berlin",
"synchronized": True,
"daemon": "chrony",
"dhcp_ntp_servers": ["192.168.1.1"],
}
:raises Exception: when the device could not be read.
"""
...
# The steps a driver implements:
def _write_ntp_servers(self, servers: list[str]) -> FixStepOutcomeDict:
"""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:
"""Set the device's zone to *zone*, an IANA name of the database."""
...
def configure_time_sync(
self, ntp_servers: Sequence[str] | None = None, timezone: str | None = None
) -> 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.
:raises UnknownTimezone: for a *timezone* that is not an IANA name of the
database, before anything is written.
:raises ValueError: for a value this driver does not write
(:attr:`time_sync_writes`), for no server or a malformed one, or for
nothing asked -- before anything is written.
"""
servers = None if ntp_servers is None else check_ntp_servers(ntp_servers)
if timezone is not None and not is_iana_zone(timezone):
raise UnknownTimezone(timezone)
asked = {name for name, v in (("ntp_servers", servers), ("timezone", timezone)) if v}
if not asked:
raise ValueError("nothing to configure: name ntp_servers, timezone or both")
refused = asked - getattr(self, "time_sync_writes", frozenset())
if refused:
raise ValueError(f"this driver does not write {', '.join(sorted(refused))}")
steps: list[FixStep] = []
if servers is not None:
steps.append(("ntp_servers", lambda: self._write_ntp_servers(servers)))
if timezone is not None:
steps.append(("timezone", lambda: self._write_time_zone(timezone)))
steps.append(("verify", lambda: self._verify_time_sync(servers, timezone)))
return run_fix_steps(steps)
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; 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] = []
if servers is not None and [s.lower() for s in now["ntp_servers"]] != [
s.lower() for s in servers
]:
wrong.append(f"the device has the servers {', '.join(now['ntp_servers']) or 'none'}")
if zone is not None and now["timezone"] is not None and now["timezone"] != zone:
wrong.append(f"the device is in the time zone {now['timezone']}")
if wrong:
return {"ok": False, "output": "; ".join(wrong)}
return {"ok": True, "output": "the device reads back what was written"}
__all__ = ["TIME_SYNC_VALUES", "TimeSyncDict", "TimeSyncMixin", "check_ntp_servers"]
+219
View File
@@ -0,0 +1,219 @@
"""Time sync on a POSIX host, over the command channel: chrony, systemd-timesyncd, timedatectl.
:class:`PosixTimeSyncMixin` implements
:class:`~napalm_device_types.time_sync.TimeSyncMixin` for a driver that has
:meth:`~napalm_device_types.channel.CommandChannelMixin.run_command`. The defaults
are Debian's paths; a driver sets its host's.
**Reading** is one round trip as the login user
(:mod:`napalm_device_types._time_sync_reading`): ``timedatectl show`` for the zone
(``/etc/timezone`` or ``/etc/localtime``'s target without it), which time sync
service is active, and that client's configuration -- chrony's files as chronyd
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 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) stay and count.
* ntpd, OpenNTPD, or no client: the servers are read, not written -- the step fails
and says so.
"""
from __future__ import annotations
import shlex
from collections.abc import Sequence
from typing import TYPE_CHECKING, ClassVar
from napalm_device_types._chrony import (
COMMENT_MARK,
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,
chrony_synchronized,
parse_key_values,
parse_reading,
parse_time_sync,
reading_command,
time_sync_of,
timesyncd_link_servers,
timesyncd_servers,
)
from napalm_device_types.models import FixStepOutcomeDict
from napalm_device_types.time_sync import TIME_SYNC_VALUES, TimeSyncDict, TimeSyncMixin
if TYPE_CHECKING:
from napalm_device_types.channel import CommandResult
_STAGE = 't=$(mktemp) && chmod 644 "$t" && cat > "$t" && printf %s "$t"'
_WRITERS = "chrony and systemd-timesyncd"
#: The head of the systemd-timesyncd drop-in.
TIMESYNCD_HEADER = (
"# The time sources, exactly these: written by napalm-device-types'\n"
"# PosixTimeSyncMixin and replaced on every change.\n"
)
def _said(result: CommandResult) -> str:
return "\n".join(p for p in (result.stdout.strip(), result.stderr.strip()) if p)
def timesyncd_dropin(servers: Sequence[str]) -> str:
"""The drop-in that leaves systemd-timesyncd with exactly *servers*."""
return f"{TIMESYNCD_HEADER}[Time]\nNTP=\nNTP={' '.join(servers)}\nFallbackNTP=\n"
class PosixTimeSyncMixin(TimeSyncMixin):
"""Time sync of a host reached through ``run_command``; the paths are the driver's."""
time_sync_writes: ClassVar[frozenset[str]] = TIME_SYNC_VALUES
#: ``(unit, daemon)``: the services that keep the clock; the first active one counts.
TIME_SYNC_UNITS: ClassVar[tuple[tuple[str, str], ...]] = TIME_SYNC_UNITS
#: chrony's main configuration: the first that exists.
CHRONY_CONFIGS: ClassVar[tuple[str, ...]] = ("/etc/chrony/chrony.conf", "/etc/chrony.conf")
#: The servers' file where the main configuration has a ``sourcedir`` of its directory.
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")
#: ``sh`` that prints the zone without timedatectl: a name, or a path ending in it.
TIME_ZONE_SH: ClassVar[str] = TIME_ZONE_SH
if TYPE_CHECKING: # pragma: no cover - declared for type checkers only
def run_command(
self,
command: str,
*,
privileged: bool = False,
timeout: float = 60,
stdin: bytes | None = None,
) -> CommandResult: ...
# -- reading ---------------------------------------------------------------------------------
def _ts_read(self) -> Reading:
paths = ReadPaths(
units=self.TIME_SYNC_UNITS,
chrony_configs=self.CHRONY_CONFIGS,
ntpd_configs=self.NTPD_CONFIGS,
openntpd_configs=self.OPENNTPD_CONFIGS,
time_zone_sh=self.TIME_ZONE_SH,
)
return parse_reading(self.run_command(reading_command(paths), timeout=60).stdout)
def get_time_sync(self) -> TimeSyncDict:
"""The host's time sources, zone and client, in one round trip as the login user.
:raises ValueError: when the reading came back cut short.
"""
return time_sync_of(self._ts_read(), self.CHRONY_DHCP_DIRS)
# -- writing ---------------------------------------------------------------------------------
def _ts_root(self, command: str) -> CommandResult:
return self.run_command(command, privileged=True, timeout=60)
def _ts_checked(self, command: str) -> str:
result = self._ts_root(command)
if result.exit_code != 0:
raise RuntimeError(f"{command}: {_said(result) or f'exit {result.exit_code}'}")
return _said(result)
def _ts_install(self, path: str, content: str) -> None:
"""*content* to *path* as root, staged by the login user: root reads no stdin."""
staged = self.run_command(_STAGE, timeout=30, stdin=content.encode())
tmp = (staged.stdout.strip().splitlines() or [""])[-1]
if staged.exit_code != 0 or not tmp.startswith("/"):
raise RuntimeError(f"cannot stage {path}: {_said(staged)}")
try:
self._ts_checked(shlex.join(["install", "-D", "-m", "644", "--", tmp, path]))
finally:
self.run_command(shlex.join(["rm", "-f", "--", tmp]), timeout=30)
def _write_time_zone(self, zone: str) -> FixStepOutcomeDict:
result = self._ts_root(shlex.join(["timedatectl", "set-timezone", zone]))
if result.exit_code != 0:
return {"ok": False, "output": _said(result) or f"exit {result.exit_code}"}
return {"ok": True, "output": f"time zone set to {zone}"}
def _write_ntp_servers(self, servers: list[str]) -> FixStepOutcomeDict:
reading = self._ts_read()
if reading.daemon == "chrony":
return self._ts_chrony(reading, servers)
if reading.daemon == "systemd-timesyncd":
return self._ts_timesyncd(servers)
runs = f"this host runs {reading.daemon}" if reading.daemon else "none runs here"
return {"ok": False, "output": f"time sources are written for {_WRITERS}; {runs}"}
def _ts_timesyncd(self, servers: list[str]) -> FixStepOutcomeDict:
self._ts_install(self.TIMESYNCD_DROPIN, timesyncd_dropin(servers))
self._ts_checked("systemctl restart systemd-timesyncd.service")
return {"ok": True, "output": f"wrote {self.TIMESYNCD_DROPIN}; restarted systemd-timesyncd"}
def _ts_chrony(self, reading: Reading, servers: list[str]) -> FixStepOutcomeDict:
plan = plan_chrony(
reading.chrony,
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))}")
if plan.include_in is not None:
self._ts_checked(include_command(plan.include_in, plan.target))
said.append(f"included it from {plan.include_in}")
if not (plan.reload and self._ts_root("chronyc reload sources").exit_code == 0):
self._ts_checked(shlex.join(["systemctl", "restart", f"{reading.unit}.service"]))
said.append(f"restarted {reading.unit}")
else:
said.append("reloaded the sources")
return {"ok": True, "output": "; ".join(said)}
__all__ = [
"COMMENT_MARK",
"PosixTimeSyncMixin",
"chrony_synchronized",
"parse_key_values",
"parse_time_sync",
"timesyncd_dropin",
"timesyncd_link_servers",
"timesyncd_servers",
]
+2 -1
View File
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
[project]
name = "napalm-device-types"
version = "4.32.0"
version = "4.36.2"
description = "Abstract device-type base classes for NAPALM drivers"
readme = "README.md"
requires-python = ">=3.12"
@@ -40,6 +40,7 @@ dependencies = [
"napalm>=5.1", # older releases import pkg_resources, which a 3.12 venv lacks
"requests>=2.25.0",
"typing-extensions>=4.0",
"tzdata>=2024.1", # posix_tz reads the zones' TZif files from it
]
[project.urls]
+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="")])
+434
View File
@@ -13,6 +13,8 @@ from __future__ import annotations
import os
import re
import shutil
import sqlite3
import subprocess
import pytest
@@ -25,6 +27,12 @@ from napalm_device_types.host_status import (
kernel_reboot_pending,
parse_host_status,
)
from napalm_device_types.package_managers import (
APK_INSTALLED,
DNF_HISTORY,
OPKG_STATUS,
PACKAGE_MANAGERS_COMMAND,
)
def _wire(
@@ -146,6 +154,24 @@ class TestKernelRebootPending:
"5.14.0-503.11.1.el9_5.x86_64",
),
("6.9.7-200.fc40.x86_64", ["6.9.7-200.fc40.x86_64"], None),
# Oracle UEK: 112.5.1 is newer than 112.5, as rpm counts -- a number after
# 5 beats the letters ``el`` (#109, build-arm-01).
(
"6.12.0-208.112.5.1.el9uek.aarch64",
[
"6.12.0-207.111.5.6.el9uek.aarch64",
"6.12.0-208.112.5.el9uek.aarch64",
"6.12.0-208.112.5.1.el9uek.aarch64",
],
None,
),
(
"6.12.0-208.112.5.el9uek.aarch64",
["6.12.0-208.112.5.el9uek.aarch64", "6.12.0-208.112.5.1.el9uek.aarch64"],
"6.12.0-208.112.5.1.el9uek.aarch64",
),
# A release candidate (``~``) comes before its release, in rpm and in dpkg.
("6.13~rc5-1-amd64", ["6.13~rc5-1-amd64", "6.13-1-amd64"], "6.13-1-amd64"),
],
)
def test_the_newer_kernel_of_the_running_flavour(self, running, installed, newer):
@@ -570,3 +596,411 @@ class TestFilesystems:
mountpoints = [fs["mountpoint"] for fs in parse_host_status(out.stdout)["filesystems"]]
assert "/" in mountpoints
def _other(*sections: tuple[str, tuple[str, ...]], running: tuple[str, ...] = ()) -> str:
"""A report from a host without dpkg: the given sections before ``[timers]``."""
lines = ["[pm-running]", *running]
for name, body in sections:
lines += [f"[{name}]", *body]
return _wire().replace("[timers]", "\n".join([*lines, "[timers]"]))
class TestInterruptedRpm:
"""dnf and yum hosts: a transaction rpm was cut off in leaves the old and the
new version of a package both installed (``dnf check --duplicates``,
``package-cleanup --dupes``), and dnf's history records a transaction that
never ended. netOrk only reports it: there is no one repair that is safe on
every host (NetOrk/netork#851, decided 2026-11-07).
The outputs are shaped after the documented formats -- ``rpm -qa --qf``,
libdnf's ``trans`` table (``state`` 0 = UNKNOWN until ``finish()`` sets DONE
1 or ERROR 2), yum's ``transaction-all.*`` journal that
``yum-complete-transaction`` reads. Checked against Oracle Linux 9 (build-arm-01,
2026-11-12): its UEK kernels are installonly only by libdnf's built-in defaults.
"""
INSTALLONLY = ("kernel-core", "kernel-modules", "kernel-uek-core")
#: An upgrade of glibc and openssl-libs cut off after the new versions were in.
CUT_OFF = ("glibc x86_64", "kernel-uek-core x86_64", "openssl-libs x86_64")
def _rpm(self, dupes=(), history=("42 1",), journal=(), frontend="dnf", running=()):
return _other(
("rpm-frontend", (frontend,)),
("rpm-installonly", self.INSTALLONLY),
("rpm-dupes", dupes),
("yum-journal", journal),
("dnf-history", history),
running=running,
)
def test_a_clean_rpm_database_is_not_interrupted(self):
status = parse_host_status(self._rpm())
assert status["package_manager_interrupted"] is False
assert status["interrupted_packages"] == []
assert status["package_manager"] == "dnf"
def test_two_versions_of_a_package_left_by_a_cut_off_transaction(self):
status = parse_host_status(self._rpm(dupes=self.CUT_OFF))
assert status["package_manager_interrupted"] is True
assert status["interrupted_packages"] == [
{"name": "glibc", "state": "duplicate"},
{"name": "openssl-libs", "state": "duplicate"},
]
def test_kernels_are_installed_side_by_side_on_purpose(self):
"""dnf's installonly packages: several versions are the rule, not a fault."""
status = parse_host_status(self._rpm(dupes=("kernel-uek-core x86_64",)))
assert status["package_manager_interrupted"] is False
def test_a_package_duplicated_in_two_arches_is_named_once(self):
status = parse_host_status(self._rpm(dupes=("glibc i686", "glibc x86_64")))
assert status["interrupted_packages"] == [{"name": "glibc", "state": "duplicate"}]
def test_the_last_transaction_never_finished(self):
status = parse_host_status(self._rpm(history=("43 0",)))
assert status["package_manager_interrupted"] is True
assert status["interrupted_packages"] == []
@pytest.mark.parametrize("history", [("44 1",), ("45 2",), ()])
def test_a_finished_or_unreadable_history_says_nothing(self, history):
"""A failed transaction (ERROR) did end; an unreadable history is no answer."""
assert parse_host_status(self._rpm(history=history))["package_manager_interrupted"] is False
def test_yum_left_its_transaction_journal(self):
journal = ("transaction-all.2026-11-01.10:12.33", "transaction-done.2026-11-01.10:12.33")
status = parse_host_status(self._rpm(frontend="yum", history=(), journal=journal))
assert status["package_manager_interrupted"] is True
assert status["package_manager"] == "yum"
def test_a_journal_yum_gave_up_on_is_none(self):
"""yum-complete-transaction skips a journal it renamed ``.disabled``."""
journal = ("transaction-all.2026-11-01.10:12.33.disabled",)
status = parse_host_status(self._rpm(frontend="yum", history=(), journal=journal))
assert status["package_manager_interrupted"] is False
@pytest.mark.parametrize("name", ["rpm", "dnf", "dnf5", "yum", "dnf-automatic", "packagekitd"])
def test_a_running_transaction_makes_it_unknown(self, name):
status = parse_host_status(self._rpm(dupes=self.CUT_OFF, running=(name,)))
assert status["package_manager_interrupted"] is None
assert status["interrupted_packages"] == []
assert status["package_manager"] == "dnf"
def test_another_managers_run_does_not(self):
status = parse_host_status(self._rpm(dupes=self.CUT_OFF, running=("opkg",)))
assert status["package_manager_interrupted"] is True
def test_the_command_asks_rpm_only_where_dnf_or_yum_exists(self):
assert "command -v rpm" in HOST_STATUS_COMMAND
assert "rpm -qa --qf" in HOST_STATUS_COMMAND
assert f"file:{DNF_HISTORY}?mode=ro" in HOST_STATUS_COMMAND
def test_it_never_repairs(self):
for word in ("distro-sync", "--cleandupes", "remove", "yum-complete-transaction", "rpm -e"):
assert word not in HOST_STATUS_COMMAND
class TestInterruptedApk:
"""Alpine and OpenWrt 25.12: apk marks a package whose files or scripts failed
in ``/lib/apk/db/installed`` (``f:`` with ``f`` broken files, ``s`` a broken
script; ``x`` xattrs and ``S`` the checksum kind are no fault), and ``apk fix``
with no arguments is what picks exactly those (apk-tools ``app_fix.c``).
netOrk only reports it (NetOrk/netork#851). Shaped after apk-tools'
``database.c``; to be checked against a real OpenWrt 25.12 host."""
def _apk(self, audit=(), running=()):
return _other(("apk-audit", audit), running=running)
def test_a_clean_database_is_not_interrupted(self):
status = parse_host_status(self._apk())
assert status["package_manager_interrupted"] is False
assert status["package_manager"] == "apk"
@pytest.mark.parametrize(
("flags", "states"),
[
("s", ["broken-script"]),
("f", ["broken-files"]),
("fsS", ["broken-files", "broken-script"]),
],
)
def test_a_package_apk_marked_broken(self, flags, states):
status = parse_host_status(self._apk(audit=(f"{flags} busybox",)))
assert status["package_manager_interrupted"] is True
assert status["interrupted_packages"] == [
{"name": "busybox", "state": state} for state in states
]
def test_a_running_apk_makes_it_unknown(self):
status = parse_host_status(self._apk(audit=("s busybox",), running=("apk",)))
assert status["package_manager_interrupted"] is None
def test_the_command_reads_the_installed_database(self):
assert "/lib/apk/db/installed" in HOST_STATUS_COMMAND
assert "apk fix" not in HOST_STATUS_COMMAND
class TestInterruptedOpkg:
"""OpenWrt before 25.12: opkg writes ``Status: <want> <flags> <state>`` per
package to ``/usr/lib/opkg/status``; a package whose run was cut off or whose
postinst failed stays ``unpacked``, and ``opkg configure`` finishes every
unpacked package (opkg-lede ``opkg_cmd.c``, ``pkg.c``). netOrk's update run
does that first (NetOrk/netork#851). To be checked against a real router."""
def _opkg(self, audit=(), running=()):
return _other(("opkg-audit", audit), running=running)
def test_a_clean_status_file_is_not_interrupted(self):
status = parse_host_status(self._opkg())
assert status["package_manager_interrupted"] is False
assert status["package_manager"] == "opkg"
@pytest.mark.parametrize(
("line", "state"),
[
("user unpacked luci-app-sqm", "unpacked"),
("ok half-configured luci-app-sqm", "half-configured"),
("ok half-installed luci-app-sqm", "half-installed"),
("reinstreq,user installed luci-app-sqm", "reinstall-required"),
],
)
def test_every_state_an_interrupted_run_leaves(self, line, state):
status = parse_host_status(self._opkg(audit=(line,)))
assert status["package_manager_interrupted"] is True
assert status["interrupted_packages"] == [{"name": "luci-app-sqm", "state": state}]
def test_a_running_opkg_makes_it_unknown(self):
status = parse_host_status(self._opkg(audit=("ok unpacked x",), running=("opkg",)))
assert status["package_manager_interrupted"] is None
def test_the_command_reads_the_status_file_and_never_configures(self):
assert "/usr/lib/opkg/status" in HOST_STATUS_COMMAND
assert "opkg configure" not in HOST_STATUS_COMMAND
class TestPackageManager:
def test_dpkg_says_so(self):
assert parse_host_status(_wire(dpkg=()))["package_manager"] == "dpkg"
def test_a_busy_dpkg_still_says_which(self):
status = parse_host_status(_wire(dpkg=(), busy=True))
assert (status["package_manager"], status["package_manager_interrupted"]) == (
"dpkg",
None,
)
def test_no_package_manager_read_is_none(self):
status = parse_host_status(_wire())
assert status["package_manager"] is None
assert status["package_manager_interrupted"] is None
#: An rpm that answers the two queries the command asks, as on an EL host whose
#: glibc upgrade was cut off; and a dnf that only has to exist.
_RPM_STUB = """#!/bin/sh
case "$*" in
*--whatprovides*) printf '%s\\n' kernel-core kernel-core 'no package provides kernel-PAE' ;;
-qa*) printf '%s\\n' 'glibc x86_64' 'kernel-core x86_64' 'gpg-pubkey (none)' \\
'glibc x86_64' 'kernel-core x86_64' 'gpg-pubkey (none)' 'bash x86_64' ;;
esac
"""
#: An rpm on an Oracle Linux host: its UEK kernel ``vendor-kernel`` provides nothing
#: of dnf's upstream defaults and sits in the database three times, like glibc twice.
_RPM_VENDOR_KERNEL_STUB = """#!/bin/sh
case "$*" in
*--whatprovides*) for a; do [ "$a" = vendor-kernel ] && echo vendor-kernel; done
echo 'no package provides kernel-PAE' ;;
-qa*) printf '%s\\n' 'vendor-kernel aarch64' 'vendor-kernel aarch64' 'vendor-kernel aarch64' \\
'glibc aarch64' 'glibc aarch64' ;;
esac
"""
#: libdnf's Python binding, as far as the command asks it: the installonlypkgs a
#: distribution built into its libdnf -- here one more than upstream's.
_LIBDNF_CONF = """class _Option:
def getValueString(self):
return "kernel, installonlypkg(kernel), vendor-kernel"
class ConfigMain:
def installonlypkgs(self):
return _Option()
"""
#: /lib/apk/db/installed shaped after apk-tools' database.c: busybox's script failed.
_APK_DB = """C:Q1abc=
P:alpine-baselayout
V:3.6.8-r1
A:x86_64
F:etc
R:fstab
C:Q1def=
P:busybox
V:1.37.0-r12
A:x86_64
f:s
F:bin
R:busybox
C:Q1ghi=
P:musl
V:1.2.5-r9
f:S
"""
#: /usr/lib/opkg/status as opkg writes it: luci-app-sqm's postinst never ran.
_OPKG_STATUS = """Package: libc
Version: 1.2.4-4
Depends: libgcc1
Status: install hold installed
Architecture: mipsel_24kc
Installed-Time: 1717000000
Package: luci-app-sqm
Version: 1.5.3-r1
Depends: libc, sqm-scripts
Status: install user unpacked
Architecture: all
Installed-Time: 1730000000
"""
def _stubs(tmp_path, *names: str, rpm: bool = False) -> dict:
bin_dir = tmp_path / "bin"
bin_dir.mkdir()
for name in names:
stub = bin_dir / name
stub.write_text(_RPM_STUB if name == "rpm" else "#!/bin/sh\nexit 0\n")
stub.chmod(0o755)
return {**os.environ, "PATH": f"{bin_dir}:/usr/bin:/bin"}
def _run(command: str, env: dict, shell: tuple[str, ...]) -> str:
report = f"printf '%s%s\\n' HSTAT_ BEGIN; {command} printf '%s%s\\n' HSTAT_ END"
program = shutil.which(shell[0]) or shell[0]
return subprocess.run(
[program, *shell[1:], report], capture_output=True, text=True, env=env, timeout=30
).stdout
_SHELLS = [("sh", "-c")] + ([("busybox", "sh", "-c")] if shutil.which("busybox") else [])
def _skip_busybox_rpm(shell: tuple[str, ...]) -> None:
"""A BusyBox built with its own ``rpm`` applet runs that before any stand-in."""
if shell[0] == "busybox":
applets = subprocess.run(["busybox", "--list"], capture_output=True, text=True).stdout
if "rpm" in applets.split():
pytest.skip("this busybox has an rpm applet of its own")
@pytest.mark.parametrize("shell", _SHELLS)
class TestThePackageManagerCommandOnARealShell:
"""The command part run for real, with stand-in programs and files."""
def test_rpm_duplicates_without_the_kernel_and_the_keys(self, tmp_path, shell):
_skip_busybox_rpm(shell)
env = _stubs(tmp_path, "rpm", "dnf")
out = _run(PACKAGE_MANAGERS_COMMAND, env, shell)
status = parse_host_status(out)
assert status["package_manager"] == "dnf"
assert status["interrupted_packages"] == [{"name": "glibc", "state": "duplicate"}]
def test_the_installonly_packages_libdnf_was_built_with(self, tmp_path, shell):
"""Oracle builds kernel-uek into libdnf's defaults; its UEK packages provide
nothing of upstream's, so only libdnf itself tells (#107)."""
_skip_busybox_rpm(shell)
env = _stubs(tmp_path, "rpm", "dnf")
(tmp_path / "bin" / "rpm").write_text(_RPM_VENDOR_KERNEL_STUB)
libdnf = tmp_path / "py" / "libdnf"
libdnf.mkdir(parents=True)
(libdnf / "__init__.py").write_text("")
(libdnf / "conf.py").write_text(_LIBDNF_CONF)
env["PYTHONPATH"] = str(tmp_path / "py")
out = _run(PACKAGE_MANAGERS_COMMAND, env, shell)
status = parse_host_status(out)
assert status["interrupted_packages"] == [{"name": "glibc", "state": "duplicate"}]
def test_dnfs_last_transaction_that_never_ended(self, tmp_path, shell):
_skip_busybox_rpm(shell)
history = tmp_path / "history.sqlite"
with sqlite3.connect(history) as db:
db.execute("CREATE TABLE trans (id INTEGER PRIMARY KEY, state INTEGER NOT NULL)")
db.executemany("INSERT INTO trans VALUES (?, ?)", [(41, 1), (42, 0)])
env = _stubs(tmp_path, "rpm", "dnf")
out = _run(PACKAGE_MANAGERS_COMMAND.replace(DNF_HISTORY, str(history)), env, shell)
assert "[dnf-history]\n42 0\n" in out
def test_apk_names_the_package_it_marked(self, tmp_path, shell):
installed = tmp_path / "installed"
installed.write_text(_APK_DB)
env = _stubs(tmp_path, "apk")
out = _run(PACKAGE_MANAGERS_COMMAND.replace(APK_INSTALLED, str(installed)), env, shell)
status = parse_host_status(out)
assert status["package_manager"] == "apk"
assert status["interrupted_packages"] == [{"name": "busybox", "state": "broken-script"}]
def test_opkg_names_the_unpacked_package(self, tmp_path, shell):
status_file = tmp_path / "status"
status_file.write_text(_OPKG_STATUS)
env = _stubs(tmp_path, "opkg")
out = _run(PACKAGE_MANAGERS_COMMAND.replace(OPKG_STATUS, str(status_file)), env, shell)
status = parse_host_status(out)
assert status["package_manager"] == "opkg"
assert status["interrupted_packages"] == [{"name": "luci-app-sqm", "state": "unpacked"}]
def test_a_host_with_none_of_them_reads_none(self, tmp_path, shell):
env = _stubs(tmp_path)
env["PATH"] = str(tmp_path / "bin")
out = _run(PACKAGE_MANAGERS_COMMAND, env, shell)
assert parse_host_status(out)["package_manager"] is None
def test_the_running_processes_come_from_proc(self, tmp_path, shell):
"""The test runner's own process is there under its own name; no manager is."""
out = _run(PACKAGE_MANAGERS_COMMAND, _stubs(tmp_path), shell)
assert "[pm-running]\n" in out
class TestTheWholeCommand:
def test_it_runs_on_busybox(self):
"""OpenWrt's and Alpine's shell: still one intact report."""
if not shutil.which("busybox"):
pytest.skip("no busybox here")
out = subprocess.run(
["busybox", "sh", "-c", HOST_STATUS_COMMAND], capture_output=True, text=True, timeout=30
).stdout
assert parse_host_status(out)["filesystems"]
def test_the_package_managers_are_part_of_it(self):
assert PACKAGE_MANAGERS_COMMAND in HOST_STATUS_COMMAND
+161
View File
@@ -0,0 +1,161 @@
"""A time zone as a device takes it: an IANA name, a POSIX TZ rule, or its parts.
The wire carries IANA names (``Europe/Berlin``). OpenWrt hands ``TZ`` to libc and
wants the rule itself (``CET-1CEST,M3.5.0,M10.5.0/3``); a switch wants a UTC
offset and the summer-time rule. The rule is the footer of the zone's TZif file
from the ``tzdata`` package (moved here from netOrk's ``core/posix_tz.py`` for
NetOrk/netork#2361).
"""
from __future__ import annotations
from importlib.resources import files
import pytest
from napalm_device_types import (
PosixTzDict,
UnknownTimezone,
is_iana_zone,
is_posix_tz,
parse_posix_tz,
posix_tz,
)
BERLIN = "CET-1CEST,M3.5.0,M10.5.0/3"
def _zones() -> list[str]:
return files("tzdata").joinpath("zones").read_text().split()
@pytest.mark.parametrize(
("zone", "rule"),
[
("Europe/Berlin", BERLIN),
("America/New_York", "EST5EDT,M3.2.0,M11.1.0"),
("America/Sao_Paulo", "<-03>3"),
("Australia/Lord_Howe", "<+1030>-10:30<+11>-11,M10.1.0,M4.1.0"),
("Asia/Kolkata", "IST-5:30"),
("UTC", "UTC0"),
],
)
def test_an_iana_name_becomes_its_posix_rule(zone, rule):
assert posix_tz(zone) == rule
assert is_iana_zone(zone)
@pytest.mark.parametrize("rule", [BERLIN, "<+03>-3", "EST5EDT,M3.2.0/2,M11.1.0/2", "UTC0"])
def test_a_posix_string_is_taken_as_it_is(rule):
assert posix_tz(rule) == rule
assert not is_iana_zone(rule)
@pytest.mark.parametrize(
"value",
["Mars/Olympus_Mons", "Europe", "../../etc/passwd", "/etc/localtime", "Europe/../UTC", ""],
)
def test_neither_a_zone_nor_a_rule_has_none(value):
assert posix_tz(value) is None
assert not is_iana_zone(value)
@pytest.mark.parametrize("value", ["UTC", "GMT0", BERLIN, "<-03>3", "IST-5:30"])
def test_posix_strings(value):
assert is_posix_tz(value)
@pytest.mark.parametrize("value", ["Europe/Berlin", "America/Argentina/Buenos_Aires", "", "CET-"])
def test_not_posix_strings(value):
assert not is_posix_tz(value)
def test_every_zone_of_the_database_has_a_rule_the_check_accepts():
# A caller tells an IANA name from a rule with is_posix_tz; it must never
# take the database's own rule for a name.
zones = _zones()
missing = [z for z in zones if not is_posix_tz(posix_tz(z) or "")]
assert len(zones) > 500
assert missing == []
def test_the_refusal_names_the_zone_in_plain_english():
exc = UnknownTimezone("Mars/Olympus_Mons")
assert isinstance(exc, ValueError)
assert exc.zone == "Mars/Olympus_Mons"
assert "Mars/Olympus_Mons" in str(exc)
assert "Europe/Berlin" in str(exc)
class TestTheRuleInParts:
"""What a switch takes: the standard offset and, where there is one, the summer-time rule."""
def test_berlin(self):
assert parse_posix_tz(BERLIN) == PosixTzDict(
std_name="CET",
utc_offset=3600,
dst_name="CEST",
dst_offset=7200,
dst_start={"month": 3, "week": 5, "weekday": 0, "time": 7200},
dst_end={"month": 10, "week": 5, "weekday": 0, "time": 10800},
)
def test_utc_has_no_summer_time(self):
assert parse_posix_tz("UTC0") == {
"std_name": "UTC",
"utc_offset": 0,
"dst_name": None,
"dst_offset": None,
"dst_start": None,
"dst_end": None,
}
@pytest.mark.parametrize("bare", ["UTC", "GMT"])
def test_the_bare_names_openwrt_writes(self, bare):
parts = parse_posix_tz(bare)
assert parts is not None
assert (parts["std_name"], parts["utc_offset"], parts["dst_name"]) == (bare, 0, None)
def test_sao_paulo_has_given_up_summer_time(self):
parts = parse_posix_tz(posix_tz("America/Sao_Paulo") or "")
assert parts is not None
assert (parts["std_name"], parts["utc_offset"], parts["dst_offset"]) == (
"-03",
-10800,
None,
)
def test_lord_howe_moves_by_half_an_hour(self):
parts = parse_posix_tz(posix_tz("Australia/Lord_Howe") or "")
assert parts is not None
assert (parts["utc_offset"], parts["dst_offset"]) == (37800, 39600)
assert parts["dst_start"] == {"month": 10, "week": 1, "weekday": 0, "time": 7200}
assert parts["dst_end"] == {"month": 4, "week": 1, "weekday": 0, "time": 7200}
def test_new_york_is_west_of_utc_and_gains_an_hour_by_default(self):
parts = parse_posix_tz("EST5EDT,M3.2.0,M11.1.0")
assert parts is not None
assert (parts["utc_offset"], parts["dst_offset"]) == (-18000, -14400)
def test_a_transition_time_may_lie_outside_the_day(self):
# Greenland's rule: a day's -1:00 and 0:00 (RFC 8536 3.3.1 allows -167..167 hours).
parts = parse_posix_tz("<-02>2<-01>,M3.5.0/-1,M10.5.0/0")
assert parts is not None
assert parts["dst_start"] == {"month": 3, "week": 5, "weekday": 0, "time": -3600}
assert parts["dst_end"] == {"month": 10, "week": 5, "weekday": 0, "time": 0}
def test_offsets_with_minutes_and_seconds(self):
parts = parse_posix_tz("<+1245>-12:45<+1345>,M9.5.0/2:45,M4.1.0/3:45")
assert parts is not None
assert (parts["utc_offset"], parts["dst_offset"]) == (45900, 49500)
assert parts["dst_start"] == {"month": 9, "week": 5, "weekday": 0, "time": 9900}
@pytest.mark.parametrize("rule", ["Europe/Berlin", "", "CET-", "CET-1CEST,J60,J300"])
def test_what_it_cannot_take_apart_is_none(self, rule):
# Julian-day rules are POSIX, but no zone of the database uses them.
assert parse_posix_tz(rule) is None
def test_every_zone_of_the_database_comes_apart(self):
broken = [z for z in _zones() if parse_posix_tz(posix_tz(z) or "") is None]
assert broken == []
+51
View File
@@ -0,0 +1,51 @@
"""get_running_backups: the backups running on a device right now.
An application that restarts a device asks first, right before the restart: a
restart aborts a backup that runs on the device -- a hypervisor's vzdump, a
backup server's backup, sync, verify or garbage collection, a host's own restic
or borg run -- and a guest's restart breaks the backup its hypervisor is taking
of it (NetOrk/netork#2318). A driver mixes it in when it can tell; no role
demands it, and a driver without it cannot tell.
"""
from __future__ import annotations
import inspect
from typing import get_type_hints
from napalm_device_types import (
RUNNING_BACKUP_KINDS,
BackupServerDriver,
DeviceTypeDriver,
HypervisorDriver,
OSDriver,
RunningBackupDict,
RunningBackupsMixin,
)
def test_no_role_demands_it():
for role in (BackupServerDriver, HypervisorDriver, OSDriver, DeviceTypeDriver):
assert not issubclass(role, RunningBackupsMixin)
def test_declared_not_implemented():
"""hasattr is the caller's probe: only a driver that can tell answers True."""
assert not hasattr(RunningBackupsMixin, "get_running_backups")
def test_declaration_documents_the_contract():
source = inspect.getsource(RunningBackupsMixin)
assert "def get_running_backups(self) -> list[RunningBackupDict]" in source
assert "empty list for a failed read" in source
def test_the_kinds_cover_a_backup_servers_jobs_and_the_backup_itself():
assert set(RUNNING_BACKUP_KINDS) == {"backup", "sync", "verify", "gc", "prune", "tape"}
def test_the_shape():
hints = get_type_hints(RunningBackupDict)
assert set(hints) == {"kind", "job", "task", "guests", "since"}
assert hints["guests"] == list[str]
assert hints["since"] == int | None
+245
View File
@@ -0,0 +1,245 @@
"""TimeSyncMixin: a device's time sources and time zone, read and set (NetOrk/netork#2361).
The application keeps one list of NTP servers and a zone per site, and aligns a
device that differs. ``get_time_sync`` is declared only, so ``callable(getattr(
driver, "get_time_sync", None))`` is the truthful answer; ``configure_time_sync``
is a template of steps like every fix, and an API driver overrides it whole.
"""
from __future__ import annotations
import inspect
from typing import ClassVar, get_type_hints
import pytest
from napalm_device_types import (
TIME_SYNC_VALUES,
AccessPointDriver,
DeviceTypeDriver,
FirewallDriver,
OSDriver,
SwitchDriver,
TimeSyncDict,
TimeSyncMixin,
UnknownTimezone,
check_ntp_servers,
)
def test_the_shape():
hints = get_type_hints(TimeSyncDict)
assert hints == {
"ntp_servers": list[str],
"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
def test_no_role_demands_it():
for role in (AccessPointDriver, FirewallDriver, OSDriver, SwitchDriver, DeviceTypeDriver):
assert not issubclass(role, TimeSyncMixin)
def test_the_reading_is_declared_not_implemented():
assert not hasattr(TimeSyncMixin, "get_time_sync")
source = inspect.getsource(TimeSyncMixin)
assert "def get_time_sync(self) -> TimeSyncDict" in source
assert "time_sync_writes: ClassVar[frozenset[str]]" in source
def test_the_template_takes_both_values_or_none_of_them():
signature = inspect.signature(TimeSyncMixin.configure_time_sync)
assert list(signature.parameters) == ["self", "ntp_servers", "timezone"]
assert signature.parameters["ntp_servers"].default is None
assert signature.parameters["timezone"].default is None
class _Device(TimeSyncMixin):
"""A device that keeps its values in memory and reads back what it was given."""
time_sync_writes: ClassVar[frozenset[str]] = frozenset({"ntp_servers", "timezone"})
def __init__(self, *, keeps_zone_name: bool = True, fail: str = "") -> None:
self.state: TimeSyncDict = {
"ntp_servers": ["0.pool.ntp.org"],
"timezone": "UTC",
"synchronized": True,
"daemon": None,
}
self.keeps_zone_name = keeps_zone_name
self.fail = fail
self.calls: list[tuple[str, object]] = []
def get_time_sync(self) -> TimeSyncDict:
state = dict(self.state)
if not self.keeps_zone_name:
state["timezone"] = None
return state # type: ignore[return-value]
def _write_ntp_servers(self, servers):
self.calls.append(("ntp_servers", servers))
if self.fail == "ntp_servers":
return {"ok": False, "output": "refused"}
self.state["ntp_servers"] = list(servers)
return {"ok": True, "output": "written"}
def _write_time_zone(self, zone):
self.calls.append(("timezone", zone))
self.state["timezone"] = zone
return {"ok": True, "output": f"zone {zone}"}
class TestConfigureTimeSync:
def test_both_values_then_a_check(self):
device = _Device()
result = device.configure_time_sync(["ntp1.example.org", "10.0.0.1"], "Europe/Berlin")
assert result["success"] is True
assert [s["step"] for s in result["steps"]] == ["ntp_servers", "timezone", "verify"]
assert device.calls == [
("ntp_servers", ["ntp1.example.org", "10.0.0.1"]),
("timezone", "Europe/Berlin"),
]
def test_none_leaves_a_value_alone(self):
device = _Device()
result = device.configure_time_sync(timezone="Europe/Berlin")
assert result["success"] is True
assert device.calls == [("timezone", "Europe/Berlin")]
assert device.state["ntp_servers"] == ["0.pool.ntp.org"]
def test_servers_alone(self):
device = _Device()
assert device.configure_time_sync(["ntp1.example.org"])["success"] is True
assert device.calls == [("ntp_servers", ["ntp1.example.org"])]
def test_an_unknown_zone_is_refused_before_anything_is_written(self):
device = _Device()
with pytest.raises(UnknownTimezone, match="Mars/Olympus_Mons"):
device.configure_time_sync(["ntp1.example.org"], "Mars/Olympus_Mons")
assert device.calls == []
def test_a_posix_rule_is_not_a_zone_on_the_wire(self):
with pytest.raises(UnknownTimezone):
_Device().configure_time_sync(timezone="CET-1CEST,M3.5.0,M10.5.0/3")
def test_a_value_the_driver_cannot_write_is_refused_before_anything_is_written(self):
class Bmc(_Device):
time_sync_writes = frozenset({"ntp_servers"})
device = Bmc()
with pytest.raises(ValueError, match="timezone"):
device.configure_time_sync(["ntp1.example.org"], "Europe/Berlin")
assert device.calls == []
def test_a_driver_that_names_nothing_it_writes_writes_nothing(self):
class Silent(TimeSyncMixin):
"""Mixes the contract in and never says what it writes."""
with pytest.raises(ValueError, match="ntp_servers"):
Silent().configure_time_sync(["ntp1.example.org"])
def test_nothing_asked_is_a_mistake(self):
with pytest.raises(ValueError, match="nothing"):
_Device().configure_time_sync()
def test_a_failed_step_stops_the_rest(self):
device = _Device(fail="ntp_servers")
result = device.configure_time_sync(["ntp1.example.org"], "Europe/Berlin")
assert result["success"] is False
assert [s["step"] for s in result["steps"]] == ["ntp_servers"]
assert device.calls == [("ntp_servers", ["ntp1.example.org"])]
def test_the_check_reads_back_what_was_written(self):
class Stubborn(_Device):
def _write_ntp_servers(self, servers):
self.calls.append(("ntp_servers", servers))
return {"ok": True, "output": "written"} # and nothing changed
result = Stubborn().configure_time_sync(["ntp1.example.org"])
assert result["success"] is False
verify = result["steps"][-1]
assert verify["step"] == "verify"
assert "0.pool.ntp.org" in verify["output"]
def test_the_check_names_the_zone_the_device_kept(self):
class Elsewhere(_Device):
def _write_time_zone(self, zone):
return {"ok": True, "output": "set"} # and the device stayed on UTC
result = Elsewhere().configure_time_sync(timezone="Europe/Berlin")
assert result["success"] is False
assert result["steps"][-1]["output"] == "the device is in the time zone UTC"
def test_servers_compare_without_case(self):
class Lower(_Device):
def get_time_sync(self):
state = super().get_time_sync()
state["ntp_servers"] = [s.lower() for s in state["ntp_servers"]]
return state
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")
assert result["success"] is True
class TestCheckNtpServers:
def test_in_order_stripped_each_once(self):
assert check_ntp_servers([" ntp1.example.org", "10.0.0.1", "NTP1.example.org", "::1"]) == [
"ntp1.example.org",
"10.0.0.1",
"::1",
]
def test_none_at_all_is_refused(self):
# A device without a source drifts; leaving the value alone is None, not [].
with pytest.raises(ValueError, match="at least one"):
check_ntp_servers([])
with pytest.raises(ValueError, match="at least one"):
check_ntp_servers([" "])
@pytest.mark.parametrize(
"bad",
[
"ntp1.example.org iburst",
"-ntp.example.org",
"ntp1.example.org\nserver evil",
"ntp;reboot",
"$(id)",
"a" * 254,
],
)
def test_only_a_host_name_or_an_address(self, bad):
with pytest.raises(ValueError, match="not a host name or address"):
check_ntp_servers([bad])
def test_a_string_is_not_a_list_of_servers(self):
with pytest.raises(TypeError):
check_ntp_servers("ntp1.example.org") # type: ignore[arg-type]
+656
View File
@@ -0,0 +1,656 @@
"""Time sync on a POSIX host, over the command channel: chrony, systemd-timesyncd, timedatectl.
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). Servers that DHCP brings are read apart and left
alone by a write (NetOrk/netork#2380).
"""
from __future__ import annotations
import os
import subprocess
from pathlib import Path
import pytest
from napalm_device_types import PosixTimeSyncMixin, UnknownTimezone, parse_time_sync
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,
)
# What the tools print, as recorded.
TIMEDATECTL = """\
Timezone=Europe/Berlin
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
"""
#: Ubuntu 24.04 without any server configured: only the compiled-in fallback.
TIMESYNC_FALLBACK = """\
FallbackNTPServers=ntp.ubuntu.com
ServerName=ntp.ubuntu.com
ServerAddress=91.189.91.157
RootDistanceMaxUSec=5s
PollIntervalMinUSec=32s
PollIntervalMaxUSec=34min 8s
PollIntervalUSec=34min 8s
NTPMessage={ Leap=0, Version=4, Mode=4, Stratum=2, Precision=-24, RootDelay=42.190ms, RootDispersion=1.190ms, Reference=84A36001, Ignored=no, PacketCount=119, Jitter=7.481ms }
Frequency=455471
"""
TIMESYNC_CONFIGURED = """\
LinkNTPServers=192.168.1.1
SystemNTPServers=ntp1.example.org ntp2.example.org
FallbackNTPServers=0.debian.pool.ntp.org 1.debian.pool.ntp.org
ServerName=ntp1.example.org
"""
CHRONYC_SYNCED = """\
MS Name/IP address Stratum Poll Reach LastRx Last sample
===============================================================================
^- 162.159.200.123 3 6 377 41 +814us[ +814us] +/- 14ms
^* 192.168.1.1 2 6 377 40 -45us[ -63us] +/- 10ms
"""
CHRONYC_UNSYNCED = """\
MS Name/IP address Stratum Poll Reach LastRx Last sample
===============================================================================
^? 162.159.200.123 0 6 0 - +0ns[ +0ns] +/- 0ns
"""
#: Debian 12's chrony.conf, comments shortened, its directories under the test's root.
DEBIAN_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 {root}/etc/chrony/conf.d
# Use Debian vendor zone.
pool 2.debian.pool.ntp.org iburst
# Use time sources from DHCP.
sourcedir {root}/run/chrony-dhcp
# Use NTP sources found in /etc/chrony/sources.d.
sourcedir {root}/etc/chrony/sources.d
keyfile /etc/chrony/chrony.keys
driftfile /var/lib/chrony/chrony.drift
rtcsync
makestep 1 3
leapsectz right/UTC
"""
TIMEDATECTL_TOOL = """#!/bin/sh
echo "timedatectl $*" >> "$LOG"
case "$1" in
show) cat "$FIX/timedatectl" ;;
show-timesync) [ -f "$FIX/timesync" ] && cat "$FIX/timesync" ;;
set-timezone)
[ "$2" = "$REFUSE_ZONE" ] && { echo "Failed to set time zone: Invalid or not installed time zone '$2'" >&2; exit 1; }
sed -i "s#^Timezone=.*#Timezone=$2#" "$FIX/timedatectl" ;;
esac
"""
SYSTEMCTL_TOOL = """#!/bin/sh
echo "systemctl $*" >> "$LOG"
case "$1" in
is-active)
u=${2%.service}
case " $ACTIVE " in *" $u "*) echo active ;; *) echo inactive; exit 3 ;; esac ;;
restart)
[ -n "$FAIL_RESTART" ] && { echo "Job for $2 failed." >&2; exit 1; }
if [ "$2" = systemd-timesyncd.service ]; then
servers=$(sed -n 's/^NTP=\\(..*\\)$/\\1/p' "$DROPIN")
printf 'SystemNTPServers=%s\\n' "$servers" > "$FIX/timesync"
fi ;;
esac
"""
CHRONYC_TOOL = """#!/bin/sh
echo "chronyc $*" >> "$LOG"
case "$*" in
"-n sources") [ -f "$FIX/chronyc" ] && cat "$FIX/chronyc" ;;
"reload sources") exit "${RELOAD_EXIT:-0}" ;;
esac
"""
class Host(PosixTimeSyncMixin):
"""A host in a directory; every command is run by sh, root or not."""
def __init__(self, root: Path, *, active: str = "chrony") -> None:
self.root = root
etc = root / "etc"
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]
self.TIME_ZONE_SH = ( # type: ignore[misc]
f"cat {etc}/timezone 2>/dev/null || readlink {etc}/localtime 2>/dev/null"
)
self.env = {
"PATH": f"{root / 'bin'}:{os.environ['PATH']}",
"LOG": str(root / "log"),
"FIX": str(root / "fix"),
"ACTIVE": active,
"DROPIN": self.TIMESYNCD_DROPIN,
}
self.commands: list[tuple[str, bool]] = []
def run_command(self, command, *, privileged=False, timeout=60, stdin=None): # type: ignore[no-untyped-def]
self.commands.append((command, privileged))
done = subprocess.run(
["sh", "-c", command],
input=stdin,
capture_output=True,
env={**os.environ, **self.env},
timeout=30,
)
return CommandResult(done.stdout.decode(), done.stderr.decode(), done.returncode)
def log(self) -> list[str]:
log = self.root / "log"
return log.read_text().splitlines() if log.exists() else []
def privileged(self) -> list[str]:
return [c for c, p in self.commands if p]
def _tool(root: Path, name: str, body: str) -> None:
path = root / "bin" / name
path.write_text(body)
path.chmod(0o755)
def _write(path: Path, text: str) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text)
@pytest.fixture
def root(tmp_path: Path) -> Path:
for d in ("bin", "fix", "etc"):
(tmp_path / d).mkdir()
(tmp_path / "fix/timedatectl").write_text(TIMEDATECTL)
for name, body in (
("timedatectl", TIMEDATECTL_TOOL),
("systemctl", SYSTEMCTL_TOOL),
("chronyc", CHRONYC_TOOL),
):
_tool(tmp_path, name, body)
return tmp_path
@pytest.fixture
def debian(root: Path) -> Path:
"""chrony as Debian 12 ships it, with a source in each place it reads."""
_write(root / "etc/chrony/chrony.conf", DEBIAN_CHRONY_CONF.format(root=root))
_write(root / "etc/chrony/conf.d/local.conf", "server ntp-conf.example.org iburst\n")
_write(root / "run/chrony-dhcp/eth0.sources", "server 192.168.1.1 iburst\n")
_write(root / "etc/chrony/sources.d/other.sources", "server ntp-other.example.org\n")
(root / "fix/chronyc").write_text(CHRONYC_SYNCED)
return root
def _no_timedatectl(root: Path) -> None:
"""A host without systemd: the command is not there (the build host's must not answer)."""
_tool(root, "timedatectl", '#!/bin/sh\necho "sh: timedatectl: not found" >&2\nexit 127\n')
def _text(path: Path) -> str:
return path.read_text()
class TestParsing:
def test_key_values(self):
values = parse_key_values(TIMEDATECTL)
assert values["Timezone"] == "Europe/Berlin"
assert values["NTPSynchronized"] == "yes"
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: the configured ones; a link's servers are DHCP's.
assert timesyncd_servers(parse_key_values(TIMESYNC_CONFIGURED)) == [
"ntp1.example.org",
"ntp2.example.org",
]
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):
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"):
parse_time_sync("@@ts timedatectl\nTimezone=UTC\n")
class TestReading:
def test_chrony_names_its_sources_in_the_order_it_reads_them(self, debian: Path):
host = Host(debian)
assert host.get_time_sync() == {
"ntp_servers": [
"ntp-conf.example.org",
"2.debian.pool.ntp.org",
"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()
assert [p for _, p in host.commands] == [False]
def test_chrony_says_whether_it_is_synchronised_not_the_kernel(self, debian: Path):
(debian / "fix/chronyc").write_text(CHRONYC_UNSYNCED)
assert Host(debian).get_time_sync()["synchronized"] is False
def test_without_an_answer_from_chronyc_the_kernel_says(self, debian: Path):
(debian / "fix/chronyc").unlink()
assert Host(debian).get_time_sync()["synchronized"] is True
def test_commented_and_other_directives_are_no_sources(self, root: Path):
_write(
root / "etc/chrony.conf",
"#pool 2.rhel.pool.ntp.org iburst\n! server old.example.org\n"
" server ntp1.example.org iburst\nrefclock PPS /dev/pps0\npeer peer.example.org\n",
)
reading = Host(root, active="chronyd").get_time_sync()
assert reading["ntp_servers"] == ["ntp1.example.org", "peer.example.org"]
assert reading["daemon"] == "chrony"
def test_an_include_pattern_is_followed(self, root: Path):
_write(root / "etc/chrony.conf", f"include {root}/etc/chrony.d/*.conf\nmakestep 1 3\n")
_write(root / "etc/chrony.d/pool.conf", "pool suse.pool.ntp.org iburst\n")
assert Host(root).get_time_sync()["ntp_servers"] == ["suse.pool.ntp.org"]
def test_timesyncd(self, root: Path):
(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"]
assert reading["dhcp_ntp_servers"] == ["192.168.1.1"]
assert reading["synchronized"] is True
def test_ntpd(self, root: Path):
_write(
root / "etc/ntpsec/ntp.conf",
"driftfile /var/lib/ntpsec/ntp.drift\npool 0.debian.pool.ntp.org iburst\n"
"server 127.127.1.0\nserver ntp1.example.org iburst\nrestrict default kod\n",
)
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(
root / "etc/openntpd/ntpd.conf",
'servers pool.ntp.org\nserver ntp1.example.org\nconstraints from "https://www.google.com"\n',
)
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(
TIMEDATECTL.replace("NTPSynchronized=yes", "NTPSynchronized=no")
)
assert Host(root, active="").get_time_sync() == {
"ntp_servers": [],
"timezone": "Europe/Berlin",
"synchronized": False,
"daemon": None,
"dhcp_ntp_servers": [],
}
def test_without_timedatectl_the_zone_comes_from_the_files(self, root: Path):
_no_timedatectl(root)
(root / "etc/localtime").symlink_to("/usr/share/zoneinfo/America/Sao_Paulo")
reading = Host(root, active="").get_time_sync()
assert reading["timezone"] == "America/Sao_Paulo"
assert reading["synchronized"] is None
def test_etc_timezone_wins_over_the_link(self, root: Path):
_no_timedatectl(root)
(root / "etc/timezone").write_text("Australia/Lord_Howe\n")
assert Host(root, active="").get_time_sync()["timezone"] == "Australia/Lord_Howe"
def test_a_copied_localtime_has_no_name(self, root: Path):
_no_timedatectl(root)
assert Host(root, active="").get_time_sync()["timezone"] is None
class TestChronyServers:
def test_exactly_these_servers(self, debian: Path):
host = Host(debian)
result = host.configure_time_sync(["ntp1.example.org", "10.0.0.1", "2.de.pool.ntp.org"])
assert result["success"] is True, result["output"]
assert _text(debian / "etc/chrony/sources.d/netork.sources") == (
"server ntp1.example.org iburst\nserver 10.0.0.1 iburst\npool 2.de.pool.ntp.org iburst\n"
)
conf = _text(debian / "etc/chrony/chrony.conf")
assert "\n#napalm-time-sync: pool 2.debian.pool.ntp.org iburst\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") == (
"#napalm-time-sync: server ntp-conf.example.org iburst\n"
)
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: 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()
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"])
conf = _text(debian / "etc/chrony/chrony.conf")
(debian / "log").unlink()
host = Host(debian)
result = host.configure_time_sync(["ntp2.example.org", "ntp1.example.org"])
assert result["success"] is True, result["output"]
assert _text(debian / "etc/chrony/chrony.conf") == conf
assert "chronyc reload sources" in host.log()
assert not any(line.startswith("systemctl restart") for line in host.log())
assert _text(debian / "etc/chrony/sources.d/netork.sources") == (
"server ntp2.example.org iburst\nserver ntp1.example.org iburst\n"
)
def test_a_chronyd_that_cannot_reload_sources_is_restarted(self, debian: Path):
Host(debian).configure_time_sync(["ntp1.example.org"])
host = Host(debian)
host.env["RELOAD_EXIT"] = "1"
assert host.configure_time_sync(["ntp2.example.org"])["success"] is True
log = host.log()
reload = log.index("chronyc reload sources")
assert log[reload + 1] == "systemctl restart chrony.service"
def test_writes_are_root_s_and_root_reads_no_stdin(self, debian: Path):
host = Host(debian)
host.configure_time_sync(["ntp1.example.org"])
staged = [c for c, p in host.commands if not p and "mktemp" in c]
assert len(staged) == 1
assert host.privileged()
assert all("mktemp" not in c for c in host.privileged())
def test_rhel_without_a_directory_gets_an_include(self, root: Path):
_write(
root / "etc/chrony.conf",
"pool 2.rhel.pool.ntp.org iburst\ndriftfile /var/lib/chrony/drift\n",
)
host = Host(root, active="chronyd")
result = host.configure_time_sync(["ntp1.example.org"])
assert result["success"] is True, result["output"]
include = root / "etc/chrony.d/netork.conf"
assert _text(include) == "server ntp1.example.org iburst\n"
assert _text(root / "etc/chrony.conf") == (
"#napalm-time-sync: pool 2.rhel.pool.ntp.org iburst\n"
"driftfile /var/lib/chrony/drift\n"
f"# napalm-time-sync: the time sources\ninclude {include}\n"
)
assert "systemctl restart chronyd.service" in host.log()
def test_an_include_that_already_takes_the_file_is_used(self, root: Path):
_write(root / "etc/chrony.conf", f"include {root}/etc/chrony.d/*.conf\n")
_write(root / "etc/chrony.d/pool.conf", "pool suse.pool.ntp.org iburst\n")
host = Host(root)
assert host.configure_time_sync(["ntp1.example.org"])["success"] is True
assert _text(root / "etc/chrony.conf") == f"include {root}/etc/chrony.d/*.conf\n"
assert (
_text(root / "etc/chrony.d/pool.conf")
== "#napalm-time-sync: pool suse.pool.ntp.org iburst\n"
)
assert _text(root / "etc/chrony.d/netork.conf") == "server ntp1.example.org iburst\n"
def test_a_confdir_takes_the_file_where_sources_d_is_not_read(self, root: Path):
_write(
root / "etc/chrony/chrony.conf",
f"confdir {root}/etc/chrony/conf.d\npool a.pool.ntp.org\n",
)
host = Host(root)
assert host.configure_time_sync(["ntp1.example.org"])["success"] is True
assert _text(root / "etc/chrony/conf.d/netork.conf") == "server ntp1.example.org iburst\n"
assert not (root / "etc/chrony/sources.d/netork.sources").exists()
def test_a_failed_restart_fails_the_step(self, debian: Path):
host = Host(debian)
host.env["FAIL_RESTART"] = "1"
result = host.configure_time_sync(["ntp1.example.org"])
assert result["success"] is False
assert "Job for chrony.service failed." in result["steps"][0]["output"]
def test_a_file_that_cannot_be_staged_is_not_installed(self, debian: Path):
_tool(debian, "mktemp", "#!/bin/sh\necho 'mktemp: failed' >&2\nexit 1\n")
host = Host(debian)
result = host.configure_time_sync(["ntp1.example.org"])
assert result["success"] is False
assert "cannot stage" in result["steps"][0]["output"]
assert host.privileged() == []
def test_no_configuration_is_a_failed_step(self, root: Path):
result = Host(root).configure_time_sync(["ntp1.example.org"])
assert result["success"] is False
assert "chrony" in result["steps"][0]["output"]
class TestTimesyncdServers:
def test_a_drop_in_with_exactly_these_servers(self, root: Path):
(root / "fix/timesync").write_text(TIMESYNC_FALLBACK)
host = Host(root, active="systemd-timesyncd")
result = host.configure_time_sync(["ntp1.example.org", "10.0.0.1"])
assert result["success"] is True, result["output"]
assert _text(root / "etc/systemd/timesyncd.conf.d/netork.conf").endswith(
"[Time]\nNTP=\nNTP=ntp1.example.org 10.0.0.1\nFallbackNTP=\n"
)
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_count(self, root: Path):
(root / "fix/timesync").write_text(TIMESYNC_CONFIGURED)
tool = (root / "bin/systemctl").read_text()
(root / "bin/systemctl").write_text(
tool.replace(
"printf 'SystemNTPServers", "printf 'LinkNTPServers=192.168.1.1\\nSystemNTPServers"
)
)
host = Host(root, active="systemd-timesyncd")
result = host.configure_time_sync(["ntp1.example.org"])
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:
@pytest.mark.parametrize("active", ["ntpsec", "openntpd", ""])
def test_only_chrony_and_timesyncd_are_written(self, root: Path, active: str):
host = Host(root, active=active)
result = host.configure_time_sync(["ntp1.example.org"])
assert result["success"] is False
assert "chrony and systemd-timesyncd" in result["steps"][0]["output"]
assert host.privileged() == []
class TestTimeZone:
def test_timedatectl_sets_it(self, root: Path):
host = Host(root, active="")
result = host.configure_time_sync(timezone="America/Sao_Paulo")
assert result["success"] is True, result["output"]
assert host.privileged() == ["timedatectl set-timezone America/Sao_Paulo"]
assert host.get_time_sync()["timezone"] == "America/Sao_Paulo"
def test_a_zone_the_host_does_not_know_fails_the_step(self, root: Path):
host = Host(root, active="")
host.env["REFUSE_ZONE"] = "Europe/Kyiv"
result = host.configure_time_sync(timezone="Europe/Kyiv")
assert result["success"] is False
assert "Invalid or not installed time zone" in result["steps"][0]["output"]
def test_an_unknown_zone_is_refused_before_anything_is_written(self, debian: Path):
host = Host(debian)
with pytest.raises(UnknownTimezone):
host.configure_time_sync(["ntp1.example.org"], "Mars/Olympus_Mons")
assert host.commands == []
def test_both_at_once(self, debian: Path):
host = Host(debian)
result = host.configure_time_sync(["ntp1.example.org"], "UTC")
assert result["success"] is True, result["output"]
assert [s["step"] for s in result["steps"]] == ["ntp_servers", "timezone", "verify"]
reading = host.get_time_sync()
assert (reading["ntp_servers"], reading["timezone"]) == (["ntp1.example.org"], "UTC")
def test_it_writes_both_values():
assert frozenset({"ntp_servers", "timezone"}) == PosixTimeSyncMixin.time_sync_writes