Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b4929990f1 | ||
|
|
3db6c6385c | ||
|
|
c5154d954b | ||
|
|
211d0c02eb | ||
|
|
74d2f42b0e | ||
|
|
c25f39768f | ||
|
|
9ecc6823c8 | ||
|
|
2080ccbfd7 | ||
|
|
ce1fe18405 | ||
|
|
e43926f1d5 | ||
|
|
43e0210ff6 | ||
|
|
241acef6c1 | ||
|
|
4c0ba5b2c0 | ||
|
|
e9da399568 | ||
|
|
8673d1eda1 | ||
|
|
46d7125aa6 | ||
|
|
8e43fe2ed9 | ||
|
|
679584766f | ||
|
|
1b04818982 | ||
|
|
65991d0930 | ||
|
|
9dfb5596bc | ||
|
|
b4cdcfd347 | ||
|
|
5258a43dc9 | ||
|
|
f3cb3601a8 | ||
|
|
a8fedf299a | ||
|
|
c736fb30d0 | ||
|
|
cf555d006d | ||
|
|
4e79cd1fc8 | ||
|
|
304f404567 | ||
|
|
aaa9f0504a | ||
|
|
bc47220318 | ||
|
|
08a62838f7 | ||
|
|
ac38c68feb | ||
|
|
8516f2a1ee | ||
|
|
c74173523a |
No files matched your search
+116
@@ -7,6 +7,122 @@ recorded here; their history is the git log.
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
## [4.39.0] - 2026-11-14
|
||||
|
||||
### Added
|
||||
- `PackageIndexMissing` (a `RuntimeError`): what `get_available_updates()` raises when
|
||||
the host holds no package index to read from -- OpenWrt's, which lives in RAM, after
|
||||
every reboot. `refresh_available_updates()` loads it again, so a caller can tell this
|
||||
from a failed read and refresh instead of reporting an error (NetOrk/netork#2527).
|
||||
|
||||
## [4.38.0] - 2026-11-13
|
||||
|
||||
### Added
|
||||
- `get_system_identity()` also reads the host's system firmware (BIOS or UEFI) from the
|
||||
same SMBIOS tables in the same round trip: `bios_vendor`, `bios_version` and
|
||||
`bios_date` (ISO 8601, from sysfs's `MM/DD/YYYY`; anything else reads as empty). Only
|
||||
the vendors' text defaults (`To be filled by O.E.M.`, `Default string`) are
|
||||
placeholders there -- a version of `1` is a version. Output of the three identity
|
||||
fields alone still parses, with the firmware empty (NetOrk/netork#2518).
|
||||
- `ConfigRevisionsMixin`: a device's own configuration history (NetOrk/netork#2511).
|
||||
`get_config_revisions()` (newest first, the first in place now, as
|
||||
`ConfigRevisionDict`: id, UTC time, description, user, size) and
|
||||
`get_config_revision(revision_id)` are declared. `revert_config_revision(revision_id)`
|
||||
is a template over the driver's `_revert_to_config_revision`: it refuses an id that is
|
||||
not in the history (`UnknownConfigRevision`), and after the revert checks that the
|
||||
newest revision holds the revision's configuration, else `ConfigRevertFailed`; it
|
||||
returns that revision. `config_revision_content(text)` leaves out what a device stamps
|
||||
into every save, so an application can compare revisions with a configuration it has.
|
||||
- `add_service_account(..., replaces=[...])`: netOrk's keys the new one takes the place of
|
||||
go from its account once the new key is in it (step `old keys`), never the new key
|
||||
itself; while the new key could not be added they stay, so netOrk keeps its way in.
|
||||
netOrk calls it through a login with the new key, after trying that login, to move a
|
||||
host from its installation-wide key to its site's (NetOrk/netork#2462).
|
||||
- Each forwarding rule of `LogForwardingDict` names its `template`: the one the rule
|
||||
gives (`@host;RSYSLOG_SyslogProtocol23Format`, `action(… template="…")`), else the
|
||||
default set before it (`$ActionForwardDefaultTemplate`, or
|
||||
`module(load="builtin:omfwd" template="…")` for omfwd actions), else None -- rsyslog's
|
||||
own default, RFC 3164, which sends the host's local time without a time zone. A
|
||||
reader can tell a rule whose timestamps a collector files shifted (NetOrk/netork#493).
|
||||
|
||||
### Fixed
|
||||
- `apply_dhcp_reservationset` writes its changes so an address is released before it is
|
||||
taken: an update that moves a reservation off its address goes before the change that
|
||||
takes that address (along a chain, from its free end), and adds come after every
|
||||
update. A server that keeps addresses unique at each write, such as Kea, no longer
|
||||
refuses the second reservation as a duplicate when an address moves from one to
|
||||
another. A swap -- reservations trading addresses, or a longer rotation -- has no such
|
||||
order: its changes are still tried, and where the server refuses them the `[failed]`
|
||||
line says it was a swap and with which reservations. Everything else is still written
|
||||
and committed, and `DhcpApplyError` follows (#106).
|
||||
- `apply_dhcp_subnetset` no longer stops at the first subnet the device refuses. As
|
||||
`apply_dhcp_reservationset` has since 4.35.1, a refused subnet gets a `[failed]` line,
|
||||
the others are still written, any non-empty diff is committed -- even one whose every
|
||||
write was refused -- and `DhcpApplyError` follows. Before, the subnets written ahead of
|
||||
the refused one stayed saved but inactive, and since the device reports them as
|
||||
configured, no later apply committed them. `DhcpApplyError` takes an optional `kind`
|
||||
(`"reservation"` by default, `"subnet"` here) that its message names (#113).
|
||||
|
||||
## [4.37.0] - 2026-11-12
|
||||
|
||||
### Added
|
||||
- `UpdateMixin.get_installed_advisory_cves()` (declared): the CVEs a host's installed
|
||||
security advisories close, per package. With `DNF_INSTALLED_CVES_COMMAND` (dnf 4,
|
||||
read from the cache) and `parse_dnf_installed_cves()`, the parser every dnf driver
|
||||
shares. netOrk reads it where its knowledge base holds no records of the host's
|
||||
release, as the distribution's word that a backport is in (netOrk #2394).
|
||||
|
||||
## [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
|
||||
|
||||
@@ -286,6 +286,9 @@ O.E.M.`, `Default string`, all-zero or the common `03000200-…-000700080009` UU
|
||||
empty: matching on them would join unrelated machines. `is_placeholder_identity` is the
|
||||
same filter for a BMC driver's side. `product_uuid` and `product_serial` are root's, so a
|
||||
driver supplies `_run_system_identity_command(command, privileged=)`.
|
||||
The same round trip reads the host's system firmware (BIOS or UEFI): `bios_vendor`,
|
||||
`bios_version` and `bios_date` (`YYYY-MM-DD`, from sysfs's `MM/DD/YYYY`). Only the vendors'
|
||||
text defaults read as empty there; a short version such as `1` is a version.
|
||||
|
||||
`OpenSshServerMixin` (`harden_ssh_server`, `get_ssh_server_algorithms`) takes algorithms
|
||||
out of what an OpenSSH server offers -- the ones ssh-audit flags. It reads the lists sshd
|
||||
@@ -348,10 +351,13 @@ cron expressions, gives their next runs and writes them as `OnCalendar` lines.
|
||||
|
||||
`TimeSyncMixin` (`get_time_sync`, `configure_time_sync`) is how a device keeps its clock:
|
||||
the NTP servers it is configured with, in its order, its time zone as an IANA name, whether
|
||||
it is synchronised now and which client does it (`TimeSyncDict`). `get_time_sync` is
|
||||
declared only; `configure_time_sync(ntp_servers=None, timezone=None)` is a fix template --
|
||||
`None` leaves a value alone, the device ends up with exactly the servers given, in that
|
||||
order, and a `verify` step reads it back. A zone that is not in the IANA database, a
|
||||
it is synchronised now and which client does it (`TimeSyncDict`). The servers it got by
|
||||
DHCP (option 42) and uses are apart, in `dhcp_ntp_servers` (`[]` for none, left out where
|
||||
the driver cannot tell): DHCP counts, a device that gets the site's time giver that way is
|
||||
aligned. `get_time_sync` is declared only; `configure_time_sync(ntp_servers=None,
|
||||
timezone=None)` is a fix template -- `None` leaves a value alone, the device ends up
|
||||
configured with exactly the servers given, in that order, its DHCP-provided servers left
|
||||
alone, and a `verify` step reads it back. A zone that is not in the IANA database, a
|
||||
malformed server, an empty list or a value outside the driver's `time_sync_writes` is
|
||||
refused before anything is written. A driver states in `time_sync_writes` which of
|
||||
`ntp_servers` and `timezone` it can write (a BMC that runs on UTC only: `ntp_servers`).
|
||||
@@ -362,11 +368,31 @@ login user (`timedatectl show`, the active client: chrony's configuration and `c
|
||||
sources`, `timedatectl show-timesync`, `ntp.conf`, OpenNTPD's `ntpd.conf`); the zone by
|
||||
`timedatectl set-timezone`; chrony's servers in a file of their own --
|
||||
`/etc/chrony/sources.d/netork.sources` where chrony reads that directory, else a `confdir`
|
||||
or an included `/etc/chrony.d/netork.conf` -- with every other `server`, `pool`, `peer` and
|
||||
foreign `sourcedir` line commented out behind `#napalm-time-sync: `, then `chronyc reload
|
||||
sources` or a restart; systemd-timesyncd's in `/etc/systemd/timesyncd.conf.d/netork.conf`
|
||||
(`NTP=` reset, `FallbackNTP=` emptied), then a restart. ntpd and OpenNTPD are read, not
|
||||
written.
|
||||
or an included `/etc/chrony.d/netork.conf` -- with every other `server`, `pool` and `peer`
|
||||
line commented out behind `#napalm-time-sync: `, then `chronyc reload sources` or a
|
||||
restart; systemd-timesyncd's in `/etc/systemd/timesyncd.conf.d/netork.conf` (`NTP=` reset,
|
||||
`FallbackNTP=` emptied), then a restart. What DHCP brings is read apart and kept: chrony's
|
||||
DHCP `sourcedir` (`CHRONY_DHCP_DIRS`, `/run/chrony-dhcp`) is never commented out -- one
|
||||
that 4.35.0 commented out comes back on the next write -- and systemd-timesyncd's
|
||||
`LinkNTPServers` stay. ntpd and OpenNTPD are read, not written; what DHCP gives them is
|
||||
unknown.
|
||||
|
||||
`ConfigRevisionsMixin` (`get_config_revisions`, `get_config_revision`,
|
||||
`revert_config_revision`) is a device's own configuration history: a copy of the
|
||||
configuration for every save, which the device can go back to. An application restores a
|
||||
configuration there by reverting to the revision that holds it -- on OPNsense the only way,
|
||||
since its API takes no uploaded config.xml (NetOrk/netork#2511). Listing (newest first, the
|
||||
first in place now: id, UTC time, description, user, size as `ConfigRevisionDict`) and
|
||||
reading one revision are declared only. `revert_config_revision(revision_id)` is a
|
||||
template: it refuses an id that is not in the history (`UnknownConfigRevision`, a
|
||||
`ValueError`) before anything changes, reads the revision -- before the revert, which may
|
||||
rotate it out -- lets the driver revert (`_revert_to_config_revision`), and checks that the
|
||||
newest revision afterwards holds the revision's configuration (`ConfigRevertFailed`
|
||||
otherwise: a device may say it reverted when it did not). It returns that newest revision.
|
||||
`config_revision_content(text)` is what of a revision is its configuration; a driver whose
|
||||
device stamps every save (who, when) strips the stamp there, and an application that looks
|
||||
for the revision holding a configuration compares through it too. A driver that can list
|
||||
but not revert sets `revert_config_revision = None`.
|
||||
|
||||
### Access channels: why there is no container model here
|
||||
|
||||
@@ -487,7 +513,10 @@ The same split applies to `DhcpServerMixin`: `get_dhcp_reservations`/
|
||||
`apply_dhcp_reservation`/`commit_dhcp_reservations` are abstract (Kea REST on
|
||||
OPNsense, dnsmasq/odhcpd UCI on OpenWrt), while `diff_dhcp_reservations` and
|
||||
`apply_dhcp_reservationset` are concrete — matching by normalised MAC and the
|
||||
apply-then-commit orchestration are identical for every DHCP server.
|
||||
apply-then-commit orchestration are identical for every DHCP server. The apply writes
|
||||
its changes so an address is released before another reservation takes it (an update
|
||||
that frees an address first, adds last); a swap of addresses has no such order and is
|
||||
reported as one where the server refuses it.
|
||||
|
||||
A new driver (FortiGate, pfSense, …) gets `diff_firewall_rules`/
|
||||
`apply_firewall_ruleset` for free the moment it implements the three abstract
|
||||
|
||||
+1
-1
@@ -39,7 +39,7 @@ application SNMP polling, ping sweeps, discovery scoring, guest
|
||||
| **Capability** | Declares only. | `packages`, `services`, `updates`, `nat_vpn`, `mac_acl`, `config_lifecycle`, `interface_filter`, `host_reboot` |
|
||||
| **Template** | A concrete method that runs a fixed sequence of abstract steps. A driver implements the steps, or overrides the whole method when its device does it in one go. All values come from the caller. | the fix routines below |
|
||||
| **Contract types** | Interfaces and data shapes other packages implement or fill. | `CommandChannelMixin`, `CommandResult`, `ByteStream`; the declaration of `ContainerEngineMixin`; the reader mixins' public method declarations; the SNMP profile type; `models` |
|
||||
| **Reconciler** | Concrete and vendor-neutral, without I/O of its own. | `firewall_rules` and `dhcp` diff/apply, `_matching`, `lag` |
|
||||
| **Reconciler** | Concrete and vendor-neutral, without I/O of its own. | `firewall_rules` and `dhcp` diff/apply, `_matching`, `_dhcp_order`, `lag` |
|
||||
| **Introspection** | Concrete, without I/O. | `roles`; `base` (`FingerprintRule`, `PortSpec`, the fingerprint attributes) |
|
||||
| **Driver facts** | Class attributes that describe the device or how it is reached, not what an application does with it. | `USES_SSH`, `FULL_UPGRADE`, `platform`, `SNMP_HEALTH_PROFILE` |
|
||||
|
||||
|
||||
@@ -38,6 +38,7 @@ instead of being restated on every role that happens to need it:
|
||||
|
||||
* :class:`~napalm_device_types.channel.CommandChannelMixin`
|
||||
* :class:`~napalm_device_types.config_lifecycle.ConfigLifecycleMixin`
|
||||
* :class:`~napalm_device_types.config_revisions.ConfigRevisionsMixin`
|
||||
* :class:`~napalm_device_types.config_sync.ConfigSyncMixin`
|
||||
* :class:`~napalm_device_types.container_engine.ContainerEngineMixin`
|
||||
* :class:`~napalm_device_types.dhcp.DhcpServerMixin`
|
||||
@@ -121,13 +122,19 @@ from napalm_device_types.clusters import (
|
||||
HAResourceDict,
|
||||
)
|
||||
from napalm_device_types.config_lifecycle import ConfigLifecycleMixin
|
||||
from napalm_device_types.config_revisions import (
|
||||
ConfigRevertFailed,
|
||||
ConfigRevisionDict,
|
||||
ConfigRevisionsMixin,
|
||||
UnknownConfigRevision,
|
||||
)
|
||||
from napalm_device_types.config_sync import ConfigSyncMixin
|
||||
from napalm_device_types.container_engine import (
|
||||
ContainerEngineConnection,
|
||||
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
|
||||
@@ -217,8 +224,10 @@ from napalm_device_types.os import OSDriver
|
||||
from napalm_device_types.ospf import OspfMixin
|
||||
from napalm_device_types.package_updates import (
|
||||
APT_UPGRADABLE_COMMAND,
|
||||
DNF_INSTALLED_CVES_COMMAND,
|
||||
DNF_SECURITY_COMMAND,
|
||||
parse_apt_upgradable,
|
||||
parse_dnf_installed_cves,
|
||||
parse_dnf_security,
|
||||
)
|
||||
from napalm_device_types.packages import PackageManagementMixin
|
||||
@@ -326,7 +335,7 @@ from napalm_device_types.time_sync import (
|
||||
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.updates import PackageIndexMissing, UpdateMixin
|
||||
from napalm_device_types.virtual_ips import (
|
||||
VIRTUAL_IPS_COMMAND,
|
||||
VirtualIpsMixin,
|
||||
@@ -399,11 +408,16 @@ __all__ = [
|
||||
"open_stream_on_transport",
|
||||
"run_on_transport",
|
||||
"ConfigLifecycleMixin",
|
||||
"ConfigRevisionsMixin",
|
||||
"ConfigRevisionDict",
|
||||
"ConfigRevertFailed",
|
||||
"UnknownConfigRevision",
|
||||
"ConfigSyncDict",
|
||||
"ConfigSyncMixin",
|
||||
"DhcpHaDict",
|
||||
"DhcpHaPeerDict",
|
||||
"DeviceTypeDriver",
|
||||
"DhcpApplyError",
|
||||
"DhcpServerMixin",
|
||||
"FingerprintRule",
|
||||
"rules_max_weight",
|
||||
@@ -431,8 +445,10 @@ __all__ = [
|
||||
"OSDriver",
|
||||
"PackageManagementMixin",
|
||||
"APT_UPGRADABLE_COMMAND",
|
||||
"DNF_INSTALLED_CVES_COMMAND",
|
||||
"DNF_SECURITY_COMMAND",
|
||||
"parse_apt_upgradable",
|
||||
"parse_dnf_installed_cves",
|
||||
"parse_dnf_security",
|
||||
"parse_host_status",
|
||||
"strip_terminal_codes",
|
||||
@@ -489,6 +505,7 @@ __all__ = [
|
||||
"SystemdServicesMixin",
|
||||
"SystemdUnavailable",
|
||||
"parse_systemd_services",
|
||||
"PackageIndexMissing",
|
||||
"UpdateMixin",
|
||||
"VIRTUAL_IPS_COMMAND",
|
||||
"VirtualIpsMixin",
|
||||
|
||||
@@ -10,10 +10,17 @@ The sources go to one file of their own (:func:`plan_chrony` picks it):
|
||||
4. else the include file, with an ``include`` line appended to the main configuration
|
||||
(RHEL's ``/etc/chrony.conf``).
|
||||
|
||||
Every other source stops counting: a ``server``, ``pool`` or ``peer`` line in any
|
||||
other file chrony reads is commented out behind :data:`COMMENT_MARK`, and so is a
|
||||
``sourcedir`` line other than the one the sources file is in -- the DHCP client's
|
||||
``/run/chrony-dhcp``, whose files are rewritten on every lease and so are left alone.
|
||||
Every other configured source stops counting: a ``server``, ``pool`` or ``peer``
|
||||
line in any other file chrony reads is commented out behind :data:`COMMENT_MARK`.
|
||||
``sourcedir`` lines stay. The DHCP client's directory (``/run/chrony-dhcp``) and its
|
||||
files are left alone: DHCP option 42 counts (NetOrk/netork#2380), and the client
|
||||
rewrites those files on every lease anyway.
|
||||
|
||||
4.35.0 commented out every ``sourcedir`` other than the sources file's, the DHCP
|
||||
client's among them, which left a host deaf to DHCP. A write gives a DHCP client's
|
||||
``sourcedir`` back where it finds one behind :data:`COMMENT_MARK`; any other one it
|
||||
took out stays out, its sources would be commented out now anyway.
|
||||
|
||||
chronyd reads its main configuration only when it starts: a change there means a
|
||||
restart.
|
||||
"""
|
||||
@@ -26,7 +33,12 @@ import shlex
|
||||
from dataclasses import dataclass, field
|
||||
from fnmatch import fnmatchcase
|
||||
|
||||
from napalm_device_types._time_sync_reading import SOURCE_LINE, ConfigFile
|
||||
from napalm_device_types._time_sync_reading import (
|
||||
CHRONY_DHCP_DIRS,
|
||||
SOURCE_LINE,
|
||||
ConfigFile,
|
||||
in_dhcp_dir,
|
||||
)
|
||||
|
||||
#: What a source line taken out of chrony's configuration starts with.
|
||||
COMMENT_MARK = "#napalm-time-sync: "
|
||||
@@ -34,6 +46,8 @@ COMMENT_MARK = "#napalm-time-sync: "
|
||||
INCLUDE_COMMENT = "# napalm-time-sync: the time sources"
|
||||
|
||||
_DIRECTORY_LINE = re.compile(r"\s*(sourcedir|confdir|include)\s+(.+?)\s*$")
|
||||
#: A ``sourcedir`` line 4.35.0 commented out.
|
||||
_MARKED_SOURCEDIR = re.compile(rf"{re.escape(COMMENT_MARK)}sourcedir\s+(.+?)\s*$")
|
||||
|
||||
|
||||
@dataclass
|
||||
@@ -43,6 +57,7 @@ class ChronyPlan:
|
||||
target: str # the file the sources go to
|
||||
content: str
|
||||
comment_out: dict[str, list[int]] = field(default_factory=dict) # path: line numbers
|
||||
restore: dict[str, list[int]] = field(default_factory=dict) # path: marked sourcedir lines
|
||||
include_in: str | None = None # the main configuration an include of target is appended to
|
||||
reload: bool = False # True: ``chronyc reload sources`` takes the change
|
||||
|
||||
@@ -80,27 +95,27 @@ def _target(main: ConfigFile, sources_file: str, include_file: str) -> tuple[str
|
||||
return include_file, main.path, False
|
||||
|
||||
|
||||
def _dropped_sourcedirs(main: ConfigFile, kept: str | None) -> set[int]:
|
||||
"""The ``sourcedir`` lines of *main* that do not name the directory *kept*."""
|
||||
return {
|
||||
number
|
||||
for number, kind, args in _directives(main)
|
||||
if kind == "sourcedir" and (kept is None or kept not in args)
|
||||
}
|
||||
|
||||
|
||||
def _lines_to_comment(f: ConfigFile, dropped: set[int]) -> list[int]:
|
||||
def _dhcp_sourcedirs_to_restore(main: ConfigFile, dhcp_dirs: tuple[str, ...]) -> list[int]:
|
||||
"""The lines of *main* where 4.35.0 commented out a DHCP client's ``sourcedir``."""
|
||||
dhcp = {posixpath.normpath(d) for d in dhcp_dirs}
|
||||
return [
|
||||
number
|
||||
for number, line in enumerate(f.lines, start=1)
|
||||
if SOURCE_LINE.match(line) or (f.kind == "main" and number in dropped)
|
||||
for number, line in enumerate(main.lines, start=1)
|
||||
if (marked := _MARKED_SOURCEDIR.match(line))
|
||||
and all(posixpath.normpath(arg) in dhcp for arg in marked[1].split())
|
||||
]
|
||||
|
||||
|
||||
def plan_chrony(
|
||||
files: list[ConfigFile], servers: list[str], *, sources_file: str, include_file: str
|
||||
files: list[ConfigFile],
|
||||
servers: list[str],
|
||||
*,
|
||||
sources_file: str,
|
||||
include_file: str,
|
||||
dhcp_dirs: tuple[str, ...] = CHRONY_DHCP_DIRS,
|
||||
) -> ChronyPlan:
|
||||
"""Where *servers* go and what else is commented out.
|
||||
"""Where *servers* go, what else is commented out, and which DHCP ``sourcedir``
|
||||
(one of *dhcp_dirs*) comes back.
|
||||
|
||||
:raises RuntimeError: when the reading found no chrony configuration.
|
||||
"""
|
||||
@@ -108,14 +123,20 @@ def plan_chrony(
|
||||
if main is None:
|
||||
raise RuntimeError("chrony runs, but no chrony configuration was found to write to")
|
||||
target, include_in, is_sources = _target(main, sources_file, include_file)
|
||||
dropped = _dropped_sourcedirs(main, posixpath.dirname(target) if is_sources else None)
|
||||
comment_out = _comment_out(files, target, dropped)
|
||||
comment_out = _comment_out(files, target, dhcp_dirs)
|
||||
restore = _dhcp_sourcedirs_to_restore(main, dhcp_dirs)
|
||||
return ChronyPlan(
|
||||
target=target,
|
||||
content="".join(f"{source_line(s)}\n" for s in servers),
|
||||
comment_out=comment_out,
|
||||
restore={main.path: restore} if restore else {},
|
||||
include_in=include_in,
|
||||
reload=is_sources and include_in is None and _only_sources_files(files, comment_out),
|
||||
reload=(
|
||||
is_sources
|
||||
and include_in is None
|
||||
and not restore
|
||||
and _only_sources_files(files, comment_out)
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
@@ -124,25 +145,36 @@ def _only_sources_files(files: list[ConfigFile], changed: dict[str, list[int]])
|
||||
return all(f.kind == "sourcedir" for f in files if f.path in changed)
|
||||
|
||||
|
||||
def _comment_out(files: list[ConfigFile], target: str, dropped: set[int]) -> dict[str, list[int]]:
|
||||
"""Per file, the lines that take a source; a dropped ``sourcedir``'s files are not read."""
|
||||
def _comment_out(
|
||||
files: list[ConfigFile], target: str, dhcp_dirs: tuple[str, ...]
|
||||
) -> dict[str, list[int]]:
|
||||
"""Per file, the lines that take a source; the DHCP client's files are left alone."""
|
||||
found: dict[str, list[int]] = {}
|
||||
for f in files:
|
||||
if f.path == target or (f.kind == "sourcedir" and f.at in dropped):
|
||||
if f.path == target or in_dhcp_dir(f, dhcp_dirs):
|
||||
continue
|
||||
numbers = _lines_to_comment(f, dropped)
|
||||
numbers = [n for n, line in enumerate(f.lines, start=1) if SOURCE_LINE.match(line)]
|
||||
if numbers:
|
||||
found[f.path] = numbers
|
||||
return found
|
||||
|
||||
|
||||
def comment_out_command(path: str, numbers: list[int]) -> str:
|
||||
"""``sed`` that comments out those lines of *path* that still hold a source or a sourcedir."""
|
||||
"""``sed`` that comments out those lines of *path* that still hold a source."""
|
||||
edits = " ".join(
|
||||
"-e "
|
||||
+ shlex.quote(
|
||||
f"{n}{{/^[[:space:]]*(server|pool|peer|sourcedir)[[:space:]]/s/^/{COMMENT_MARK}/;}}"
|
||||
)
|
||||
+ shlex.quote(f"{n}{{/^[[:space:]]*(server|pool|peer)[[:space:]]/s/^/{COMMENT_MARK}/;}}")
|
||||
for n in numbers
|
||||
)
|
||||
return f"sed -i -E {edits} {shlex.quote(path)}"
|
||||
|
||||
|
||||
def restore_command(path: str, numbers: list[int]) -> str:
|
||||
"""``sed`` that takes :data:`COMMENT_MARK` off those lines of *path* that are still a
|
||||
``sourcedir`` behind it. The mark holds nothing a regular expression or ``sed``'s
|
||||
``s///`` would read as special."""
|
||||
edits = " ".join(
|
||||
"-e " + shlex.quote(f"{n}{{s/^{COMMENT_MARK}(sourcedir[[:space:]])/\\1/;}}")
|
||||
for n in numbers
|
||||
)
|
||||
return f"sed -i -E {edits} {shlex.quote(path)}"
|
||||
|
||||
@@ -0,0 +1,116 @@
|
||||
"""The order an applied reservation set is written in (#106).
|
||||
|
||||
A DHCP server such as Kea keeps every address unique at each write, not only at the
|
||||
commit: a reservation that takes an address another one still holds is refused as a
|
||||
duplicate. So the changes are ordered for an address to be released before it is taken:
|
||||
|
||||
* An update that moves a reservation off its address goes before the change that takes
|
||||
that address -- along a chain, from its free end.
|
||||
* Adds come after every update: they release nothing, and an update may free their
|
||||
address.
|
||||
|
||||
A *swap* -- two reservations trading addresses, or a longer rotation -- has no such
|
||||
order. Its changes are still tried, in the order of the desired set: a server that checks
|
||||
only at the commit takes them. A server that refuses them refuses each with its own
|
||||
message, and the progress line says it was a swap. Nothing is moved to a temporary
|
||||
address: the contract knows no free one (pools, leases and reservations nobody manages
|
||||
all hold addresses), and a second write that failed would leave the reservation on it.
|
||||
|
||||
Without I/O: a reconciler's part, see ``docs/STRUCTURE.md``.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import ipaddress
|
||||
from dataclasses import dataclass
|
||||
|
||||
from napalm_device_types.models import DhcpReservationDict, DhcpReservationDiffDict
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ReservationChange:
|
||||
"""One write of an applied set, in the order it is made."""
|
||||
|
||||
reservation: DhcpReservationDict
|
||||
#: The live reservation's id for an update, None for an add.
|
||||
uuid: str | None
|
||||
#: The changed fields of an update (``"ip, hostname"``), empty for an add.
|
||||
fields: str = ""
|
||||
#: The other reservations' MACs of the swap this change is part of, if any.
|
||||
swap: tuple[str, ...] = ()
|
||||
|
||||
|
||||
def _address(ip: str | None) -> str:
|
||||
"""*ip* in one spelling, so ``192.0.2.010``-style differences cannot hide a match."""
|
||||
text = (ip or "").strip()
|
||||
try:
|
||||
return str(ipaddress.ip_address(text))
|
||||
except ValueError:
|
||||
return text.lower()
|
||||
|
||||
|
||||
def _waits_on(updates: list[tuple[str, str]]) -> list[int | None]:
|
||||
"""For each ``(old, new)`` address pair, the update whose release it waits for."""
|
||||
released = {old: i for i, (old, new) in enumerate(updates) if old and old != new}
|
||||
return [released.get(new) if new != old else None for old, new in updates]
|
||||
|
||||
|
||||
def _cycles(waits_on: list[int | None]) -> dict[int, list[int]]:
|
||||
"""Each update that is part of a cycle, with the cycle's members in order."""
|
||||
members: dict[int, list[int]] = {}
|
||||
for start in range(len(waits_on)):
|
||||
path: list[int] = []
|
||||
node: int | None = start
|
||||
while node is not None and node not in path and node not in members:
|
||||
path.append(node)
|
||||
node = waits_on[node]
|
||||
if node is not None and node in path:
|
||||
cycle = sorted(path[path.index(node) :])
|
||||
members.update(dict.fromkeys(cycle, cycle))
|
||||
return members
|
||||
|
||||
|
||||
def _update_order(waits_on: list[int | None], cycles: dict[int, list[int]]) -> list[int]:
|
||||
"""Every update after the one it waits on; stable otherwise. Where only cycles are
|
||||
left, the first of them goes as it is, and so on."""
|
||||
order: list[int] = []
|
||||
done: set[int] = set()
|
||||
pending = list(range(len(waits_on)))
|
||||
while pending:
|
||||
ready = [i for i in pending if waits_on[i] is None or waits_on[i] in done]
|
||||
if not ready:
|
||||
ready = [next(i for i in pending if i in cycles)]
|
||||
order += ready
|
||||
done.update(ready)
|
||||
pending = [i for i in pending if i not in done]
|
||||
return order
|
||||
|
||||
|
||||
def order_reservation_changes(
|
||||
diff: DhcpReservationDiffDict, live: list[DhcpReservationDict]
|
||||
) -> list[ReservationChange]:
|
||||
"""The changes of *diff* in the order they are written; see the module.
|
||||
|
||||
:param diff: What ``diff_dhcp_reservations`` found.
|
||||
:param live: The reservations it compared against, for the addresses updates release.
|
||||
"""
|
||||
held = {r.get("uuid"): _address(r.get("ip")) for r in live if r.get("uuid")}
|
||||
updates = diff["update"]
|
||||
waits_on = _waits_on(
|
||||
[(held.get(e["uuid"], ""), _address(e["reservation"].get("ip"))) for e in updates]
|
||||
)
|
||||
cycles = _cycles(waits_on)
|
||||
|
||||
def swap(i: int) -> tuple[str, ...]:
|
||||
return tuple(updates[j]["reservation"]["mac"] for j in cycles.get(i, []) if j != i)
|
||||
|
||||
ordered = [
|
||||
ReservationChange(
|
||||
updates[i]["reservation"],
|
||||
updates[i]["uuid"],
|
||||
", ".join(updates[i]["changed_fields"]),
|
||||
swap(i),
|
||||
)
|
||||
for i in _update_order(waits_on, cycles)
|
||||
]
|
||||
return ordered + [ReservationChange(r, None) for r in diff["add"]]
|
||||
@@ -14,10 +14,15 @@ One command, as the login user, prints framed sections (``@@ts <name> ...``):
|
||||
line of it reads;
|
||||
* ``ntpd <path>``, ``openntpd <path>`` -- their configuration;
|
||||
* ``end`` -- the reading is complete.
|
||||
|
||||
What DHCP brought is read apart from the configured servers: chrony's files in a
|
||||
DHCP client's ``sourcedir`` (:data:`CHRONY_DHCP_DIRS`), systemd-timesyncd's
|
||||
``LinkNTPServers``.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import posixpath
|
||||
import re
|
||||
import shlex
|
||||
from dataclasses import dataclass, field
|
||||
@@ -37,6 +42,11 @@ TIME_SYNC_UNITS: tuple[tuple[str, str], ...] = (
|
||||
("openntpd", "openntpd"),
|
||||
)
|
||||
|
||||
#: The ``sourcedir`` a DHCP client writes chrony's sources to, one file per interface
|
||||
#: and lease: the NetworkManager dispatcher and dhclient hook of Debian, Ubuntu and
|
||||
#: Red Hat. What chrony reads from there is DHCP's (option 42), not configuration.
|
||||
CHRONY_DHCP_DIRS: tuple[str, ...] = ("/run/chrony-dhcp", "/var/run/chrony-dhcp")
|
||||
|
||||
#: A source line of chrony's or ntpd's configuration: the directive and what follows.
|
||||
SOURCE_LINE = re.compile(r"\s*(server|pool|peer)\s+(.*)")
|
||||
_OPENNTPD_SOURCE = re.compile(r"\s*(servers?)\s+(\S+)")
|
||||
@@ -197,19 +207,47 @@ def _source_name(rest: str) -> str | None:
|
||||
return next((word for word in rest.split() if not word.startswith("-")), None)
|
||||
|
||||
|
||||
def chrony_servers(files: list[ConfigFile]) -> list[str]:
|
||||
"""chrony's sources in the order it reads them: each file in place of the line naming it."""
|
||||
def in_dhcp_dir(f: ConfigFile, dhcp_dirs: tuple[str, ...]) -> bool:
|
||||
"""Whether *f* is a sources file a DHCP client wrote to one of *dhcp_dirs*."""
|
||||
if f.kind != "sourcedir":
|
||||
return False
|
||||
directory = posixpath.normpath(posixpath.dirname(f.path))
|
||||
return directory in {posixpath.normpath(d) for d in dhcp_dirs}
|
||||
|
||||
|
||||
def _named_on(files: list[ConfigFile], number: int) -> list[ConfigFile]:
|
||||
"""The files the main configuration's line *number* reads."""
|
||||
return [f for f in files if f.at == number and f.kind != "main"]
|
||||
|
||||
|
||||
def _read_order(files: list[ConfigFile], dhcp_dirs: tuple[str, ...]) -> list[tuple[bool, str]]:
|
||||
"""Every line chrony reads, in its order -- each file in place of the line naming
|
||||
it -- and whether a DHCP client wrote it."""
|
||||
main = next((f for f in files if f.kind == "main"), None)
|
||||
if main is None:
|
||||
return []
|
||||
found: list[str] = []
|
||||
found: list[tuple[bool, str]] = []
|
||||
for number, line in enumerate(main.lines, start=1):
|
||||
found.extend(_sources([line]))
|
||||
for included in (f for f in files if f.at == number and f.kind != "main"):
|
||||
found.extend(_sources(included.lines))
|
||||
found.append((False, line))
|
||||
for included in _named_on(files, number):
|
||||
dhcp = in_dhcp_dir(included, dhcp_dirs)
|
||||
found.extend((dhcp, text) for text in included.lines)
|
||||
return found
|
||||
|
||||
|
||||
def chrony_servers(files: list[ConfigFile], dhcp_dirs: tuple[str, ...] = ()) -> list[str]:
|
||||
"""chrony's configured sources in the order it reads them; not those in *dhcp_dirs*."""
|
||||
return _sources([line for dhcp, line in _read_order(files, dhcp_dirs) if not dhcp])
|
||||
|
||||
|
||||
def chrony_dhcp_servers(files: list[ConfigFile], dhcp_dirs: tuple[str, ...]) -> list[str]:
|
||||
"""The sources chrony reads from the DHCP client's files in *dhcp_dirs*, in its order.
|
||||
|
||||
A ``sourcedir`` chrony does not read (commented out) prints no files: nothing then.
|
||||
"""
|
||||
return _sources([line for dhcp, line in _read_order(files, dhcp_dirs) if dhcp])
|
||||
|
||||
|
||||
def _sources(lines: list[str]) -> list[str]:
|
||||
names = []
|
||||
for line in lines:
|
||||
@@ -229,14 +267,30 @@ def openntpd_servers(lines: list[str]) -> list[str]:
|
||||
return [m[2] for line in lines if (m := _OPENNTPD_SOURCE.match(line))]
|
||||
|
||||
|
||||
def timesyncd_servers(values: dict[str, str]) -> list[str]:
|
||||
"""systemd-timesyncd's servers in the order it tries them; the fallback only alone."""
|
||||
def _listed(values: dict[str, str], *keys: str) -> list[str]:
|
||||
found: list[str] = []
|
||||
for key in ("RuntimeNTPServers", "SystemNTPServers", "LinkNTPServers"):
|
||||
for key in keys:
|
||||
for server in values.get(key, "").split():
|
||||
if server not in found:
|
||||
found.append(server)
|
||||
return found or values.get("FallbackNTPServers", "").split()
|
||||
return found
|
||||
|
||||
|
||||
def timesyncd_servers(values: dict[str, str]) -> list[str]:
|
||||
"""systemd-timesyncd's configured servers, runtime then system; the fallback only
|
||||
while it has no other server, a link's included. A link's servers are not among
|
||||
them: :func:`timesyncd_link_servers`."""
|
||||
configured = _listed(values, "RuntimeNTPServers", "SystemNTPServers")
|
||||
if configured or timesyncd_link_servers(values):
|
||||
return configured
|
||||
return _listed(values, "FallbackNTPServers")
|
||||
|
||||
|
||||
def timesyncd_link_servers(values: dict[str, str]) -> list[str]:
|
||||
"""The servers network links gave systemd-timesyncd: systemd-networkd's, from a DHCP
|
||||
lease (option 42) or a ``.network`` file's ``NTP=`` -- the reading cannot tell those
|
||||
apart and counts them as DHCP's."""
|
||||
return _listed(values, "LinkNTPServers")
|
||||
|
||||
|
||||
def chrony_synchronized(sources: str) -> bool | None:
|
||||
@@ -263,9 +317,9 @@ def _time_zone(reading: Reading) -> str | None:
|
||||
return next((z for line in reading.zone_files if (z := _zone_name(line))), None)
|
||||
|
||||
|
||||
def _servers(reading: Reading) -> list[str]:
|
||||
def _servers(reading: Reading, dhcp_dirs: tuple[str, ...]) -> list[str]:
|
||||
if reading.daemon == "chrony":
|
||||
return chrony_servers(reading.chrony)
|
||||
return chrony_servers(reading.chrony, dhcp_dirs)
|
||||
if reading.daemon == "systemd-timesyncd":
|
||||
return timesyncd_servers(reading.timesync)
|
||||
if reading.daemon == "ntpd" and reading.ntpd is not None:
|
||||
@@ -275,6 +329,18 @@ def _servers(reading: Reading) -> list[str]:
|
||||
return []
|
||||
|
||||
|
||||
def _dhcp_servers(reading: Reading, dhcp_dirs: tuple[str, ...]) -> list[str] | None:
|
||||
"""What DHCP brought: chrony's and timesyncd's; None where ntpd or OpenNTPD runs,
|
||||
whose DHCP hooks keep a configuration of their own that is not read."""
|
||||
if reading.daemon == "chrony":
|
||||
return chrony_dhcp_servers(reading.chrony, dhcp_dirs)
|
||||
if reading.daemon == "systemd-timesyncd":
|
||||
return timesyncd_link_servers(reading.timesync)
|
||||
if reading.daemon is None:
|
||||
return []
|
||||
return None
|
||||
|
||||
|
||||
def _synchronized(reading: Reading) -> bool | None:
|
||||
if reading.daemon == "chrony":
|
||||
chrony = chrony_synchronized(reading.chronyc)
|
||||
@@ -283,19 +349,21 @@ def _synchronized(reading: Reading) -> bool | None:
|
||||
return {"yes": True, "no": False}.get(reading.timedatectl.get("NTPSynchronized", ""))
|
||||
|
||||
|
||||
def time_sync_of(reading: Reading) -> TimeSyncDict:
|
||||
"""What a reading says, as ``get_time_sync`` returns it."""
|
||||
def time_sync_of(reading: Reading, dhcp_dirs: tuple[str, ...] = CHRONY_DHCP_DIRS) -> TimeSyncDict:
|
||||
"""What a reading says, as ``get_time_sync`` returns it; *dhcp_dirs* are the DHCP
|
||||
client's ``sourcedir`` of chrony."""
|
||||
return {
|
||||
"ntp_servers": _servers(reading),
|
||||
"ntp_servers": _servers(reading, dhcp_dirs),
|
||||
"timezone": _time_zone(reading),
|
||||
"synchronized": _synchronized(reading),
|
||||
"daemon": reading.daemon,
|
||||
"dhcp_ntp_servers": _dhcp_servers(reading, dhcp_dirs),
|
||||
}
|
||||
|
||||
|
||||
def parse_time_sync(text: str) -> TimeSyncDict:
|
||||
def parse_time_sync(text: str, dhcp_dirs: tuple[str, ...] = CHRONY_DHCP_DIRS) -> TimeSyncDict:
|
||||
"""The reading's output as ``get_time_sync`` returns it.
|
||||
|
||||
:raises ValueError: for a reading cut short.
|
||||
"""
|
||||
return time_sync_of(parse_reading(text))
|
||||
return time_sync_of(parse_reading(text), dhcp_dirs)
|
||||
@@ -0,0 +1,140 @@
|
||||
"""A device's own configuration history: list it, read a revision, revert to one.
|
||||
|
||||
Some devices keep their earlier configurations themselves: a copy of the
|
||||
configuration for every save, which the device can go back to. An application
|
||||
restores a configuration there by reverting to the revision that holds it -- on a
|
||||
device whose API takes no uploaded configuration (OPNsense), the only way
|
||||
(NetOrk/netork#2511). :class:`ConfigRevisionsMixin` is the contract:
|
||||
|
||||
* ``get_config_revisions()`` and ``get_config_revision(revision_id)`` -- declared
|
||||
only, so ``callable(getattr(driver, "get_config_revisions", None))`` is the
|
||||
truthful answer to "does this device keep a history";
|
||||
* ``revert_config_revision(revision_id)`` -- a template: it refuses an id that is not
|
||||
in the history, reads the revision, lets the driver revert
|
||||
(``_revert_to_config_revision``), and reads the configuration in place afterwards
|
||||
to check that it holds the revision's. A device may answer that it reverted when it
|
||||
did not; the check does not take its word;
|
||||
* ``config_revision_content(text)`` -- what of a revision is its configuration. Every
|
||||
save may stamp a revision anew (OPNsense writes who saved it and when into
|
||||
config.xml), so two revisions with the same configuration differ as text. A driver
|
||||
whose device does that strips the stamp here; by default the whole text counts. An
|
||||
application that looks for the revision holding a configuration compares through
|
||||
it too.
|
||||
|
||||
A driver mixes it in when its device keeps a history; no role base carries it. One
|
||||
that can list the history but not revert to it sets ``revert_config_revision`` to
|
||||
``None``.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import TYPE_CHECKING, TypedDict
|
||||
|
||||
|
||||
class ConfigRevisionDict(TypedDict):
|
||||
"""One revision of the device's configuration (``get_config_revisions``)."""
|
||||
|
||||
id: str # what get_config_revision and revert_config_revision take, as the device names it
|
||||
time: str | None # when it was saved, UTC ISO 8601; None when the device does not say
|
||||
description: str | None # what made the change, as the device records it; None: none
|
||||
user: str | None # who saved it, as the device names them; None when it names nobody
|
||||
size: int | None # its size in bytes; None when not given
|
||||
|
||||
|
||||
class UnknownConfigRevision(ValueError):
|
||||
"""The device's configuration history has no revision of that id."""
|
||||
|
||||
def __init__(self, revision_id: object) -> None:
|
||||
super().__init__(f"no configuration revision {revision_id!r} in the device's history")
|
||||
|
||||
|
||||
class ConfigRevertFailed(RuntimeError):
|
||||
"""The device refused the revert, or its configuration afterwards is not the revision's."""
|
||||
|
||||
|
||||
class ConfigRevisionsMixin:
|
||||
"""List, read and revert to the device's configuration revisions; see the module."""
|
||||
|
||||
if TYPE_CHECKING: # pragma: no cover - declared for type checkers only
|
||||
|
||||
def get_config_revisions(self) -> list[ConfigRevisionDict]:
|
||||
"""The device's configuration history, newest first.
|
||||
|
||||
The first revision is the configuration in place now.
|
||||
|
||||
Example::
|
||||
|
||||
[
|
||||
{
|
||||
"id": "config-1794603885.1239.xml",
|
||||
"time": "2026-11-13T21:04:45+00:00",
|
||||
"description": "/api/firewall/filter/apply made changes",
|
||||
"user": "apiuser@192.0.2.10",
|
||||
"size": 58213,
|
||||
},
|
||||
]
|
||||
|
||||
:raises Exception: when the history could not be read; never an empty
|
||||
list for a failed read.
|
||||
"""
|
||||
...
|
||||
|
||||
def get_config_revision(self, revision_id: str) -> str:
|
||||
"""The configuration of revision *revision_id*, as the device keeps it.
|
||||
|
||||
:raises UnknownConfigRevision: for an id that is not in the history.
|
||||
:raises Exception: when the device could not be read.
|
||||
"""
|
||||
...
|
||||
|
||||
# The step a driver implements:
|
||||
|
||||
def _revert_to_config_revision(self, revision_id: str) -> None:
|
||||
"""Make revision *revision_id* the device's configuration; return once it is
|
||||
in place, as the newest revision of the history.
|
||||
|
||||
:raises UnknownConfigRevision: when the device no longer has it.
|
||||
:raises ConfigRevertFailed: when the device refuses.
|
||||
"""
|
||||
...
|
||||
|
||||
def config_revision_content(self, text: str) -> str:
|
||||
"""What of a revision's *text* is its configuration: the whole text by default.
|
||||
|
||||
A driver whose device stamps every save into the configuration (who, when)
|
||||
returns the text without that stamp, so that two revisions with the same
|
||||
configuration compare equal.
|
||||
"""
|
||||
return text
|
||||
|
||||
def revert_config_revision(self, revision_id: str) -> ConfigRevisionDict:
|
||||
"""Make revision *revision_id* the device's configuration again.
|
||||
|
||||
Returns the revision in place afterwards: the newest of the history, which
|
||||
holds the configuration of *revision_id* (on most devices a new revision the
|
||||
revert saved). What the device does beyond that -- reload its services,
|
||||
restart, nothing -- is the driver's to document.
|
||||
|
||||
:raises UnknownConfigRevision: for an id that is not in the history now;
|
||||
nothing has changed then.
|
||||
:raises ConfigRevertFailed: when the device refuses, or when the configuration
|
||||
in place afterwards is not the revision's.
|
||||
:raises Exception: when the device could not be reached.
|
||||
"""
|
||||
if revision_id not in {r["id"] for r in self.get_config_revisions()}:
|
||||
raise UnknownConfigRevision(revision_id)
|
||||
# Read before the revert: saving it may rotate the revision out of the history.
|
||||
wanted = self.config_revision_content(self.get_config_revision(revision_id))
|
||||
self._revert_to_config_revision(revision_id)
|
||||
revisions = self.get_config_revisions()
|
||||
if not revisions:
|
||||
raise ConfigRevertFailed(
|
||||
f"the device has no configuration after reverting to {revision_id!r}"
|
||||
)
|
||||
now = revisions[0]
|
||||
if self.config_revision_content(self.get_config_revision(now["id"])) != wanted:
|
||||
raise ConfigRevertFailed(
|
||||
f"the configuration in place ({now['id']!r}) is not revision {revision_id!r}"
|
||||
" after the revert"
|
||||
)
|
||||
return now
|
||||
+156
-61
@@ -26,6 +26,7 @@ import re
|
||||
from collections.abc import Iterator
|
||||
from typing import TYPE_CHECKING, Any
|
||||
|
||||
from napalm_device_types._dhcp_order import ReservationChange, order_reservation_changes
|
||||
from napalm_device_types._matching import check_desired, index_live
|
||||
from napalm_device_types.models import (
|
||||
DhcpHaDict,
|
||||
@@ -57,6 +58,27 @@ _DHCP_SUBNET_COMPARE_FIELDS = (
|
||||
|
||||
_HEX_ONLY = re.compile(r"[^0-9a-f]")
|
||||
|
||||
#: Added to a refused change that is part of an address swap (#106).
|
||||
_SWAP_NOTE = (
|
||||
"an address swap with {}: no order frees an address first; "
|
||||
"move one of them to a free address in a run of its own"
|
||||
)
|
||||
|
||||
|
||||
class DhcpApplyError(RuntimeError):
|
||||
"""Some changes of an applied reservation or subnet 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.
|
||||
``kind`` is what was applied: ``"reservation"`` or ``"subnet"``.
|
||||
"""
|
||||
|
||||
def __init__(self, failed: int, attempted: int, kind: str = "reservation") -> None:
|
||||
self.failed = failed
|
||||
self.attempted = attempted
|
||||
self.kind = kind
|
||||
super().__init__(f"{failed} of {attempted} DHCP {kind} change(s) were refused")
|
||||
|
||||
|
||||
def normalize_mac(mac: str | None) -> str:
|
||||
"""Reduces a MAC address to lowercase colon-separated form.
|
||||
@@ -106,6 +128,43 @@ def _subnet_field_differs(field: str, live: DhcpSubnetDict, desired: DhcpSubnetD
|
||||
return any(live_options.get(option) != value for option, value in desired_options.items())
|
||||
|
||||
|
||||
def _reservation_key(reservation: DhcpReservationDict) -> str:
|
||||
return normalize_mac(reservation.get("mac"))
|
||||
|
||||
|
||||
def _diff_reservations(
|
||||
live: list[DhcpReservationDict], desired: list[DhcpReservationDict]
|
||||
) -> DhcpReservationDiffDict:
|
||||
"""``diff_dhcp_reservations`` against reservations already read."""
|
||||
live_by_mac, shared = index_live(live, _reservation_key)
|
||||
check_desired(desired, _reservation_key, shared, "MAC")
|
||||
|
||||
add: list[DhcpReservationDict] = []
|
||||
update: list[DhcpReservationUpdateDict] = []
|
||||
|
||||
for desired_reservation in desired:
|
||||
current = live_by_mac.get(_reservation_key(desired_reservation))
|
||||
if current is None:
|
||||
add.append(desired_reservation)
|
||||
continue
|
||||
|
||||
changed_fields = [
|
||||
field
|
||||
for field in _DHCP_RESERVATION_COMPARE_FIELDS
|
||||
if current.get(field) != desired_reservation.get(field)
|
||||
]
|
||||
if changed_fields:
|
||||
update.append(
|
||||
{
|
||||
"uuid": current["uuid"],
|
||||
"reservation": desired_reservation,
|
||||
"changed_fields": changed_fields,
|
||||
}
|
||||
)
|
||||
|
||||
return {"add": add, "update": update}
|
||||
|
||||
|
||||
class DhcpServerMixin:
|
||||
"""Mixin providing DHCP reservation and subnet read/diff/apply.
|
||||
|
||||
@@ -258,36 +317,7 @@ class DhcpServerMixin:
|
||||
:raises ValueError: When a desired reservation cannot name a single live one.
|
||||
"""
|
||||
|
||||
def key(reservation: DhcpReservationDict) -> str:
|
||||
return normalize_mac(reservation.get("mac"))
|
||||
|
||||
live_by_mac, shared = index_live(self.get_dhcp_reservations(), key)
|
||||
check_desired(desired, key, shared, "MAC")
|
||||
|
||||
add: list[DhcpReservationDict] = []
|
||||
update: list[DhcpReservationUpdateDict] = []
|
||||
|
||||
for desired_reservation in desired:
|
||||
live = live_by_mac.get(key(desired_reservation))
|
||||
if live is None:
|
||||
add.append(desired_reservation)
|
||||
continue
|
||||
|
||||
changed_fields = [
|
||||
field
|
||||
for field in _DHCP_RESERVATION_COMPARE_FIELDS
|
||||
if live.get(field) != desired_reservation.get(field)
|
||||
]
|
||||
if changed_fields:
|
||||
update.append(
|
||||
{
|
||||
"uuid": live["uuid"],
|
||||
"reservation": desired_reservation,
|
||||
"changed_fields": changed_fields,
|
||||
}
|
||||
)
|
||||
|
||||
return {"add": add, "update": update}
|
||||
return _diff_reservations(self.get_dhcp_reservations(), desired)
|
||||
|
||||
def apply_dhcp_reservationset(self, desired: list[DhcpReservationDict]) -> Iterator[str]:
|
||||
"""
|
||||
@@ -298,29 +328,65 @@ class DhcpServerMixin:
|
||||
committing reloads the DHCP daemon and drops in-flight requests, which
|
||||
is too high a price for a no-op run.
|
||||
|
||||
The changes are written so an address is released before it is taken; a
|
||||
swap of addresses has no such order and is reported as one (``_dhcp_order``).
|
||||
|
||||
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"]:
|
||||
live = self.get_dhcp_reservations()
|
||||
diff = _diff_reservations(live, desired)
|
||||
attempted = len(diff["add"]) + len(diff["update"])
|
||||
if not attempted:
|
||||
yield "[commit] no changes"
|
||||
return
|
||||
|
||||
added = updated = refused = 0
|
||||
|
||||
for change in order_reservation_changes(diff, live):
|
||||
line, ok = self._write_change(change)
|
||||
refused += not ok
|
||||
added += ok and change.uuid is None
|
||||
updated += ok and change.uuid is not None
|
||||
yield 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_change(self, change: ReservationChange) -> tuple[str, bool]:
|
||||
"""Write one change of an ordered set; its progress line, and whether it went in."""
|
||||
tag = "[add]" if change.uuid is None else "[update]"
|
||||
line, ok = self._write_reservation(change.reservation, change.uuid, tag)
|
||||
if ok and change.fields:
|
||||
line = f"{line} ({change.fields})"
|
||||
elif not ok and change.swap:
|
||||
line = f"{line} -- {_SWAP_NOTE.format(', '.join(change.swap))}"
|
||||
return line, ok
|
||||
|
||||
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:
|
||||
"""
|
||||
@@ -391,24 +457,53 @@ class DhcpServerMixin:
|
||||
As with ``apply_dhcp_reservationset``, an empty diff does **not**
|
||||
commit: reconfiguring the DHCP daemon is too expensive for a no-op.
|
||||
|
||||
A subnet the device refuses (say, one that overlaps a subnet it serves)
|
||||
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 (#113).
|
||||
|
||||
:param desired: The complete desired subnet 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_subnets(desired)
|
||||
|
||||
for subnet in diff["add"]:
|
||||
self.apply_dhcp_subnet(subnet)
|
||||
yield f"[add] {subnet['subnet']}"
|
||||
|
||||
for entry in diff["update"]:
|
||||
self.apply_dhcp_subnet(entry["subnet"], uuid=entry["uuid"])
|
||||
fields = ", ".join(entry["changed_fields"])
|
||||
yield f"[update] {entry['subnet']['subnet']} ({fields})"
|
||||
|
||||
if not diff["add"] and not diff["update"]:
|
||||
attempted = len(diff["add"]) + len(diff["update"])
|
||||
if not attempted:
|
||||
yield "[commit] no changes"
|
||||
return
|
||||
|
||||
changes: list[tuple[DhcpSubnetDict, str | None, str]] = [
|
||||
(subnet, None, "") for subnet in diff["add"]
|
||||
]
|
||||
changes += [
|
||||
(e["subnet"], e["uuid"], ", ".join(e["changed_fields"])) for e in diff["update"]
|
||||
]
|
||||
added = updated = refused = 0
|
||||
|
||||
for subnet, uuid, fields in changes:
|
||||
line, ok = self._write_subnet(subnet, uuid, fields)
|
||||
refused += not ok
|
||||
added += ok and uuid is None
|
||||
updated += ok and uuid is not None
|
||||
yield line
|
||||
|
||||
# Committed even when every write was refused; see apply_dhcp_reservationset.
|
||||
self.commit_dhcp_subnets()
|
||||
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, "subnet")
|
||||
|
||||
def _write_subnet(
|
||||
self, subnet: DhcpSubnetDict, uuid: str | None, fields: str
|
||||
) -> tuple[str, bool]:
|
||||
"""Write one subnet; its progress line, and whether the device took it."""
|
||||
try:
|
||||
self.apply_dhcp_subnet(subnet, uuid=uuid)
|
||||
except Exception as exc:
|
||||
return f"[failed] {subnet['subnet']}: {exc}", False
|
||||
if uuid is None:
|
||||
return f"[add] {subnet['subnet']}", True
|
||||
return f"[update] {subnet['subnet']} ({fields})", True
|
||||
@@ -60,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 (
|
||||
@@ -171,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:
|
||||
@@ -188,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
|
||||
|
||||
|
||||
@@ -481,7 +481,12 @@ class LocalAccountsMixin:
|
||||
return self._accounts_result(name, parts)
|
||||
|
||||
def add_service_account(
|
||||
self, name: str, public_key: str, *, uid: int | None = None
|
||||
self,
|
||||
name: str,
|
||||
public_key: str,
|
||||
*,
|
||||
uid: int | None = None,
|
||||
replaces: Sequence[str] = (),
|
||||
) -> LocalAccountChangeDict:
|
||||
"""Make *name* netOrk's own account: it logs in with *public_key*, and gains
|
||||
root without a password.
|
||||
@@ -495,36 +500,59 @@ class LocalAccountsMixin:
|
||||
once no other account has it; an account that is there keeps its own,
|
||||
as a uid is never changed under files that carry it.
|
||||
|
||||
*replaces* are netOrk's keys *public_key* takes the place of: they go
|
||||
from the account once *public_key* is in it, matched as in
|
||||
:meth:`add_local_account`, and never *public_key* itself. Call it so
|
||||
through a login with *public_key*, tried before: netOrk keeps its way
|
||||
in (NetOrk/netork#2462).
|
||||
|
||||
Steps as in :meth:`add_local_account`: ``account``, then ``sudo`` and
|
||||
``keys``. The new login itself is for the caller to try.
|
||||
``keys``, and ``old keys`` with *replaces* when ``keys`` went. The new
|
||||
login itself is for the caller to try.
|
||||
|
||||
An account that is there and cannot log in (``nologin``, ``false``) is
|
||||
another service's -- a satellite's ``netork``, say -- and is left alone.
|
||||
|
||||
:raises ValueError: for a name or key no host takes, root, a uid of 0 or
|
||||
less, or another service's account.
|
||||
:raises ValueError: for a name or key no host takes, a replaced key that
|
||||
is none, root, a uid of 0 or less, or another service's account.
|
||||
:raises RuntimeError: when the login user cannot be told.
|
||||
"""
|
||||
check_public_key(public_key)
|
||||
old = [key for key in _checked_keys(replaces) if _key_blob(key) != _key_blob(public_key)]
|
||||
login, existing = self._accounts_service_target(name, uid)
|
||||
first = self._accounts_service_account_step(name, login, existing, uid)
|
||||
parts = [first]
|
||||
if first["success"]:
|
||||
parts += self._accounts_service_keys(name, public_key, old)
|
||||
return self._accounts_result(name, parts)
|
||||
|
||||
def _accounts_service_account_step(
|
||||
self, name: str, login: str, existing: list[str] | None, uid: int | None
|
||||
) -> FixResultDict:
|
||||
"""The ``account`` step of netOrk's own account; nothing to do when the driver
|
||||
logs in as *name* already."""
|
||||
if name == login:
|
||||
step: FixStepDict = {
|
||||
"step": "account",
|
||||
"ok": True,
|
||||
"output": f"this driver logs in as {name} already",
|
||||
}
|
||||
first: FixResultDict = _joined([step])
|
||||
else:
|
||||
first = run_fix_steps(
|
||||
[("account", lambda: self._accounts_service_account(name, existing, uid))]
|
||||
)
|
||||
parts = [first]
|
||||
if first["success"]:
|
||||
parts += [
|
||||
run_fix_steps([("sudo", lambda: self._accounts_grant_service_sudo(name))]),
|
||||
run_fix_steps([("keys", lambda: self._accounts_add_key(name, public_key))]),
|
||||
]
|
||||
return self._accounts_result(name, parts)
|
||||
return _joined([step])
|
||||
return run_fix_steps(
|
||||
[("account", lambda: self._accounts_service_account(name, existing, uid))]
|
||||
)
|
||||
|
||||
def _accounts_service_keys(
|
||||
self, name: str, public_key: str, old: list[str]
|
||||
) -> list[FixResultDict]:
|
||||
"""``sudo`` and ``keys`` of netOrk's own account, then ``old keys`` once the key is in."""
|
||||
parts = [
|
||||
run_fix_steps([("sudo", lambda: self._accounts_grant_service_sudo(name))]),
|
||||
run_fix_steps([("keys", lambda: self._accounts_add_key(name, public_key))]),
|
||||
]
|
||||
if old and parts[-1]["success"]:
|
||||
parts.append(run_fix_steps([("old keys", lambda: self._accounts_drop_keys(name, old))]))
|
||||
return parts
|
||||
|
||||
def _accounts_service_target(self, name: str, uid: int | None) -> tuple[str, list[str] | None]:
|
||||
"""The login user and *name*'s passwd line, once *name* may become netOrk's.
|
||||
|
||||
@@ -35,6 +35,9 @@ class ForwardRuleDict(TypedDict):
|
||||
selector: str # "*.*", "authpriv.*", or the condition around it
|
||||
complete: bool # every message of its ruleset goes
|
||||
ruleset: str | None # None: the default ruleset, which gets the journal and syslog
|
||||
#: The template its messages are sent in; None: rsyslog's default, RFC 3164,
|
||||
#: which carries the sender's local time without a zone (NetOrk/netork#493).
|
||||
template: str | None
|
||||
|
||||
|
||||
class FileInputDict(TypedDict):
|
||||
@@ -165,6 +168,10 @@ class _Reader:
|
||||
self.pending: tuple[str, str | None] | None = None
|
||||
self.legacy_ruleset: str | None = None
|
||||
self.last_selector = "*.*"
|
||||
#: ``$ActionForwardDefaultTemplate``, for the legacy rules after it.
|
||||
self.legacy_template: str | None = None
|
||||
#: ``module(load="builtin:omfwd" template=…)``, for every omfwd action.
|
||||
self.module_template: str | None = None
|
||||
|
||||
def ruleset(self) -> str | None:
|
||||
names = [value for kind, value in self.stack if kind == "ruleset"]
|
||||
@@ -175,7 +182,13 @@ class _Reader:
|
||||
return once or (conditions[-1] if conditions else None)
|
||||
|
||||
def forward(
|
||||
self, protocol: str, target: str, port: int | None, selector: str, once: str | None
|
||||
self,
|
||||
protocol: str,
|
||||
target: str,
|
||||
port: int | None,
|
||||
selector: str,
|
||||
once: str | None,
|
||||
template: str | None,
|
||||
) -> None:
|
||||
condition = self.condition(once)
|
||||
self.parsed["rules"].append(
|
||||
@@ -186,6 +199,7 @@ class _Reader:
|
||||
"selector": condition or selector,
|
||||
"complete": condition is None and selector in _EVERYTHING,
|
||||
"ruleset": self.ruleset(),
|
||||
"template": template,
|
||||
}
|
||||
)
|
||||
|
||||
@@ -225,6 +239,8 @@ class _Reader:
|
||||
def call(self, name: str, params: dict[str, str], before: str, once: str | None) -> None:
|
||||
if name == "module":
|
||||
self.module(params.get("load", ""))
|
||||
if params.get("load", "").removeprefix("builtin:") == "omfwd":
|
||||
self.module_template = params.get("template") or self.module_template
|
||||
elif name == "ruleset":
|
||||
self.pending = ("ruleset", params.get("name"))
|
||||
elif name == "input" and params.get("type") == "imfile" and params.get("file"):
|
||||
@@ -240,7 +256,10 @@ class _Reader:
|
||||
kind = params.get("type", "")
|
||||
if kind in _FORWARD_TYPES and params.get("target"):
|
||||
protocol = "relp" if kind == "omrelp" else params.get("protocol", "udp").lower()
|
||||
self.forward(protocol, params["target"], _port(params.get("port")), selector, once)
|
||||
template = params.get("template") or (self.module_template if kind == "omfwd" else None)
|
||||
self.forward(
|
||||
protocol, params["target"], _port(params.get("port")), selector, once, template
|
||||
)
|
||||
|
||||
def module(self, name: str) -> None:
|
||||
if name == "imjournal":
|
||||
@@ -257,6 +276,8 @@ class _Reader:
|
||||
self.parsed["file_inputs"].append({"path": value, "ruleset": self.legacy_ruleset})
|
||||
elif name == "$ruleset":
|
||||
self.legacy_ruleset = None if value == "RSYSLOG_DefaultRuleset" else value
|
||||
elif name == "$actionforwarddefaulttemplate":
|
||||
self.legacy_template = value or None
|
||||
|
||||
def legacy(self, text: str, once: str | None) -> None:
|
||||
match = _PROPERTY_RE.match(text) or _LEGACY_RE.match(text)
|
||||
@@ -264,13 +285,27 @@ class _Reader:
|
||||
return
|
||||
selector = self.last_selector if match["sel"] == "&" else match["sel"]
|
||||
self.last_selector = selector
|
||||
forward = _FORWARD_RE.match(match["action"].strip())
|
||||
action = match["action"].strip()
|
||||
forward = _FORWARD_RE.match(action)
|
||||
if forward:
|
||||
protocol = {"@": "udp", "@@": "tcp"}.get(forward["at"] or "", "relp")
|
||||
self.forward(
|
||||
protocol, forward["v6"] or forward["host"], _port(forward["port"]), selector, once
|
||||
protocol,
|
||||
forward["v6"] or forward["host"],
|
||||
_port(forward["port"]),
|
||||
selector,
|
||||
once,
|
||||
self.legacy_template_of(action[forward.end() :], protocol),
|
||||
)
|
||||
|
||||
def legacy_template_of(self, rest: str, protocol: str) -> str | None:
|
||||
"""The template after a legacy rule's target (``;Name``), else the default
|
||||
set before it; RELP takes no forwarding default."""
|
||||
_, semicolon, named = rest.partition(";")
|
||||
if semicolon and named.strip():
|
||||
return named.strip()
|
||||
return self.legacy_template if protocol != "relp" else None
|
||||
|
||||
|
||||
def parse_rsyslog(text: str) -> RsyslogDict:
|
||||
"""rsyslog's configuration -- ``rsyslog.conf`` and ``rsyslog.d`` as one text --
|
||||
|
||||
@@ -1440,15 +1440,3 @@ class ManagementProtocolsDict(TypedDict):
|
||||
snmp: ProtocolStateDict
|
||||
kvm: ProtocolStateDict
|
||||
virtual_media: ProtocolStateDict
|
||||
|
||||
|
||||
class SystemIdentityDict(TypedDict):
|
||||
"""A host's SMBIOS identity, what ties it to its BMC.
|
||||
|
||||
See :mod:`napalm_device_types.system_identity`.
|
||||
|
||||
Each value is empty when unknown or a vendor placeholder."""
|
||||
|
||||
system_uuid: str # lowercase
|
||||
product_serial: str
|
||||
board_serial: str
|
||||
@@ -13,9 +13,13 @@ 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. 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;
|
||||
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
|
||||
@@ -81,6 +85,13 @@ _DNF_HISTORY_PY = (
|
||||
"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 '"
|
||||
@@ -90,7 +101,10 @@ _RUNNING_PART = (
|
||||
_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; "
|
||||
@@ -98,9 +112,8 @@ _RPM_PART = (
|
||||
"| 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]'; for py in /usr/libexec/platform-python python3; do "
|
||||
f'if command -v $py >/dev/null 2>&1; then $py -c "{_DNF_HISTORY_PY}" 2>/dev/null; '
|
||||
"break; fi; done; fi; "
|
||||
"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]'; "
|
||||
|
||||
@@ -36,11 +36,24 @@ DNF_SECURITY_COMMAND = (
|
||||
" echo __DNF_RC=$?; } | cat"
|
||||
)
|
||||
|
||||
#: Read-only. Every advisory whose fix the installed packages carry, one line per
|
||||
#: CVE it names (``CVE SEVERITY/Sec. NEVRA``): the distribution's own word that a
|
||||
#: backport is in, where netOrk's knowledge base holds no records of the release
|
||||
#: (netOrk #2394). dnf 4 only: dnf 5 reads ``--with-cve`` as a filter, and
|
||||
#: Fedora's advisories reference bugs rather than CVEs. From the cache, as
|
||||
#: :data:`DNF_SECURITY_COMMAND` reads it; the output is long (90 000 lines on an
|
||||
#: Oracle Linux 9 host), so a caller reads it seldom.
|
||||
DNF_INSTALLED_CVES_COMMAND = (
|
||||
"{ LC_ALL=C dnf --cacheonly updateinfo list --installed --with-cve --quiet 2>/dev/null;"
|
||||
" echo __DNF_RC=$?; } | cat"
|
||||
)
|
||||
|
||||
# openssl/noble-updates,noble-security 3.0.13-0ubuntu3.6 amd64 [upgradable from: 3.0.13-0ubuntu3.5]
|
||||
_APT_LINE = re.compile(r"^(\S+)/(\S+)\s+(\S+)\s+\S+\s+\[upgradable from:\s+(\S+)\]")
|
||||
_SECURITY_SUITE = "-security"
|
||||
_APT_STATUS = re.compile(r"^__APT_RC=(\d+)\s*$", re.MULTILINE)
|
||||
_DNF_STATUS = re.compile(r"^__DNF_RC=(\d+)\s*$", re.MULTILINE)
|
||||
_CVE_ID = re.compile(r"^CVE-\d{4}-\d{4,}$")
|
||||
|
||||
|
||||
def _joined_lines(output: str) -> list[str]:
|
||||
@@ -118,3 +131,21 @@ def parse_dnf_security(output: str) -> set[str]:
|
||||
if len(parts) >= 3 and parts[1].endswith("/Sec."):
|
||||
names.add(nevra_name(parts[-1]))
|
||||
return names
|
||||
|
||||
|
||||
def parse_dnf_installed_cves(output: str) -> dict[str, list[str]]:
|
||||
"""The CVEs the installed advisories close, per package name, each once and sorted.
|
||||
|
||||
Parses :data:`DNF_INSTALLED_CVES_COMMAND`'s ``CVE SEVERITY/Sec. NEVRA`` lines;
|
||||
a line that names no CVE (a key prompt, an advisory id) is no statement.
|
||||
|
||||
:raises ValueError: when dnf failed or its exit status never arrived -- "could
|
||||
not read" must not look like "no advisory installed".
|
||||
"""
|
||||
by_name: dict[str, set[str]] = {}
|
||||
listing = _listing(output, _DNF_STATUS, "dnf updateinfo list --installed --with-cve")
|
||||
for line in listing.splitlines():
|
||||
parts = line.split()
|
||||
if len(parts) >= 3 and _CVE_ID.match(parts[0]):
|
||||
by_name.setdefault(nevra_name(parts[-1]), set()).add(parts[0])
|
||||
return {name: sorted(cves) for name, cves in by_name.items()}
|
||||
@@ -1,6 +1,7 @@
|
||||
"""The SMBIOS identity of a host: system UUID, product serial, board serial.
|
||||
"""The SMBIOS identity of a host: system UUID, product serial, board serial -- and
|
||||
its system firmware (BIOS or UEFI): vendor, version, release date.
|
||||
|
||||
What ties a server to its BMC. The BMC reports the server's serial number and
|
||||
The identity is what ties a server to its BMC. The BMC reports the server's serial number and
|
||||
system UUID; the host reads the same values from its firmware tables. Both sides
|
||||
read them the same way on every Linux host, so the command, its parse and the
|
||||
placeholder filter live here once, and a driver only carries the command across.
|
||||
@@ -13,27 +14,54 @@ Matching on those would join unrelated machines, so they read as empty.
|
||||
|
||||
**Root.** ``product_uuid`` and ``product_serial`` are readable by root only; without
|
||||
it they come back empty, which is "not known", not a mismatch.
|
||||
|
||||
**The firmware** comes from the same tables in the same round trip, so a driver that
|
||||
reads the identity reads it too. It is a fact about the host, not part of its identity:
|
||||
its placeholders are the vendors' text defaults, never a short value (a version of
|
||||
``1`` is a version), and sysfs's ``MM/DD/YYYY`` release date is given as ISO 8601.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from typing import TYPE_CHECKING
|
||||
from datetime import date
|
||||
from typing import TYPE_CHECKING, TypedDict
|
||||
|
||||
from napalm_device_types.models import SystemIdentityDict
|
||||
from napalm_device_types.terminal import strip_terminal_codes
|
||||
|
||||
|
||||
class SystemIdentityDict(TypedDict):
|
||||
"""A host's SMBIOS identity, what ties it to its BMC, and its system firmware.
|
||||
|
||||
Each value is empty when unknown or a vendor placeholder."""
|
||||
|
||||
system_uuid: str # lowercase
|
||||
product_serial: str
|
||||
board_serial: str
|
||||
bios_vendor: str # the system firmware (BIOS or UEFI): its vendor,
|
||||
bios_version: str # its version,
|
||||
bios_date: str # its release date, YYYY-MM-DD
|
||||
|
||||
|
||||
_BEGIN = "IDBEGIN"
|
||||
_END = "IDEND"
|
||||
_DMI = "/sys/class/dmi/id"
|
||||
|
||||
#: Reads the three files in one round trip, framed so a banner or prompt around the
|
||||
#: output cannot shift a field.
|
||||
SYSTEM_IDENTITY_COMMAND = (
|
||||
f"printf '{_BEGIN}\\n%s\\n%s\\n%s\\n{_END}\\n' "
|
||||
f'"$(cat {_DMI}/product_uuid 2>/dev/null)" '
|
||||
f'"$(cat {_DMI}/product_serial 2>/dev/null)" '
|
||||
f'"$(cat {_DMI}/board_serial 2>/dev/null)"'
|
||||
#: The files read, in the order the output carries them.
|
||||
_FILES = (
|
||||
"product_uuid",
|
||||
"product_serial",
|
||||
"board_serial",
|
||||
"bios_vendor",
|
||||
"bios_version",
|
||||
"bios_date",
|
||||
)
|
||||
|
||||
#: Reads the files in one round trip, framed so a banner or prompt around the output
|
||||
#: cannot shift a field.
|
||||
_FIELDS = "%s\\n" * len(_FILES)
|
||||
SYSTEM_IDENTITY_COMMAND = f"printf '{_BEGIN}\\n{_FIELDS}{_END}\\n' " + " ".join(
|
||||
f'"$(cat {_DMI}/{name} 2>/dev/null)"' for name in _FILES
|
||||
)
|
||||
|
||||
#: Lowercased defaults board vendors leave in place.
|
||||
@@ -80,6 +108,22 @@ def _clean(value: str) -> str:
|
||||
return "" if is_placeholder_identity(value) else value
|
||||
|
||||
|
||||
def _clean_text(value: str) -> str:
|
||||
"""A firmware text, empty for a vendor's text default; a short value stays."""
|
||||
value = value.strip()
|
||||
return "" if value.lower() in _PLACEHOLDERS else value
|
||||
|
||||
|
||||
def _iso_date(value: str) -> str:
|
||||
"""sysfs's ``MM/DD/YYYY`` as ``YYYY-MM-DD``; anything else is no date."""
|
||||
month, _, rest = value.strip().partition("/")
|
||||
day, _, year = rest.partition("/")
|
||||
try:
|
||||
return date(int(year), int(month), int(day)).isoformat()
|
||||
except ValueError:
|
||||
return ""
|
||||
|
||||
|
||||
def parse_system_identity(output: str) -> SystemIdentityDict:
|
||||
"""The identity from :data:`SYSTEM_IDENTITY_COMMAND`'s output, placeholders empty.
|
||||
|
||||
@@ -91,12 +135,16 @@ def parse_system_identity(output: str) -> SystemIdentityDict:
|
||||
end = lines.index(_END, start)
|
||||
except ValueError:
|
||||
raise ValueError("system identity: no intact IDBEGIN/IDEND frame") from None
|
||||
fields = (lines[start:end] + ["", "", ""])[:3]
|
||||
uuid, product_serial, board_serial = (_clean(f) for f in fields)
|
||||
fields = (lines[start:end] + [""] * len(_FILES))[: len(_FILES)]
|
||||
uuid, product_serial, board_serial = (_clean(f) for f in fields[:3])
|
||||
bios_vendor, bios_version, bios_date = fields[3:]
|
||||
return {
|
||||
"system_uuid": uuid.lower(),
|
||||
"product_serial": product_serial,
|
||||
"board_serial": board_serial,
|
||||
"bios_vendor": _clean_text(bios_vendor),
|
||||
"bios_version": _clean_text(bios_version),
|
||||
"bios_date": _iso_date(bios_date),
|
||||
}
|
||||
|
||||
|
||||
@@ -119,12 +167,15 @@ class SystemIdentityMixin:
|
||||
|
||||
def get_system_identity(self) -> SystemIdentityDict:
|
||||
"""
|
||||
Returns the host's SMBIOS identity, each value empty when unknown or a vendor
|
||||
placeholder:
|
||||
Returns the host's SMBIOS identity and system firmware, each value empty when
|
||||
unknown or a vendor placeholder:
|
||||
|
||||
* system_uuid (str) - lowercase
|
||||
* product_serial (str)
|
||||
* board_serial (str)
|
||||
* bios_vendor (str) - the system firmware's vendor
|
||||
* bios_version (str)
|
||||
* bios_date (str) - its release date, ``YYYY-MM-DD``
|
||||
|
||||
:raises ValueError: if the output carried no intact reading.
|
||||
"""
|
||||
|
||||
@@ -7,7 +7,7 @@ device that differs. :class:`TimeSyncMixin` is the contract for that:
|
||||
"get_time_sync", None))`` is the truthful answer to "can this driver tell";
|
||||
* ``configure_time_sync(ntp_servers=None, timezone=None)`` -- a fix template
|
||||
(:mod:`napalm_device_types.fixes`): ``None`` leaves that value as it is, and the
|
||||
device ends up with exactly the servers given, in their order. A driver
|
||||
device ends up configured with exactly the servers given, in their order. A driver
|
||||
implements the steps; one whose device takes the change in a single call
|
||||
overrides the method;
|
||||
* ``time_sync_writes`` -- which of the two values the driver can write. A BMC that
|
||||
@@ -17,16 +17,24 @@ device that differs. :class:`TimeSyncMixin` is the contract for that:
|
||||
A driver that inherits the mixin but cannot run it sets ``get_time_sync`` (and
|
||||
``configure_time_sync``) to ``None``.
|
||||
|
||||
**Servers from DHCP count** (NetOrk/netork#2380). A device that takes its time
|
||||
servers from a DHCP lease (option 42) gets them from whoever serves the subnet --
|
||||
usually the site's time giver. ``ntp_servers`` are only the servers configured on
|
||||
the device; ``dhcp_ntp_servers`` are those the device got by DHCP and uses. A write
|
||||
replaces the configured servers and leaves DHCP's alone: it never switches the use of
|
||||
DHCP-provided servers off, and the ``verify`` step does not count them.
|
||||
|
||||
A zone is an IANA name on the wire. A device that wants a POSIX rule or an offset
|
||||
with a summer-time rule gets it from :mod:`napalm_device_types.posix_tz`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
# No ``from __future__ import annotations`` here: TypedDict tells a NotRequired key
|
||||
# only from an evaluated annotation (``TimeSyncDict.__optional_keys__``).
|
||||
|
||||
import ipaddress
|
||||
import re
|
||||
from collections.abc import Sequence
|
||||
from typing import TYPE_CHECKING, ClassVar, TypedDict
|
||||
from typing import TYPE_CHECKING, ClassVar, NotRequired, TypedDict
|
||||
|
||||
from napalm_device_types.fixes import FixStep, run_fix_steps
|
||||
from napalm_device_types.models import FixResultDict, FixStepOutcomeDict
|
||||
@@ -48,6 +56,9 @@ class TimeSyncDict(TypedDict):
|
||||
timezone: str | None # IANA name ("Europe/Berlin"); None = not readable or no named zone
|
||||
synchronized: bool | None # the clock is synchronised to a source right now; None = unknown
|
||||
daemon: str | None # "chrony", "systemd-timesyncd", "ntpd", "openntpd", ...; None = own client
|
||||
# The servers the device got by DHCP (option 42) and uses, in its order; never in
|
||||
# ntp_servers. [] = none; absent or None = the driver cannot tell.
|
||||
dhcp_ntp_servers: NotRequired[list[str] | None]
|
||||
|
||||
|
||||
def _is_server(name: str) -> bool:
|
||||
@@ -94,7 +105,9 @@ class TimeSyncMixin:
|
||||
"""How the device keeps its clock now.
|
||||
|
||||
``ntp_servers`` are the sources its configuration names, in its order
|
||||
(a pool by its name, not the addresses it resolved to). ``timezone``
|
||||
(a pool by its name, not the addresses it resolved to);
|
||||
``dhcp_ntp_servers`` those a DHCP lease gave it and it uses, apart from
|
||||
them -- left out where the driver cannot tell. ``timezone``
|
||||
is an IANA name, or None where the device keeps an offset and a rule
|
||||
instead of a name. ``daemon`` names the client that keeps the clock on
|
||||
a host that has a choice; None for a device's own.
|
||||
@@ -106,6 +119,7 @@ class TimeSyncMixin:
|
||||
"timezone": "Europe/Berlin",
|
||||
"synchronized": True,
|
||||
"daemon": "chrony",
|
||||
"dhcp_ntp_servers": ["192.168.1.1"],
|
||||
}
|
||||
|
||||
:raises Exception: when the device could not be read.
|
||||
@@ -115,8 +129,9 @@ class TimeSyncMixin:
|
||||
# The steps a driver implements:
|
||||
|
||||
def _write_ntp_servers(self, servers: list[str]) -> FixStepOutcomeDict:
|
||||
"""Leave the device with exactly *servers*, in this order: sources it
|
||||
had configured elsewhere stop counting (commented out, replaced)."""
|
||||
"""Leave the device configured with exactly *servers*, in this order:
|
||||
sources it had configured elsewhere stop counting (commented out,
|
||||
replaced). Servers it gets by DHCP stay, and so does its use of them."""
|
||||
...
|
||||
|
||||
def _write_time_zone(self, zone: str) -> FixStepOutcomeDict:
|
||||
@@ -128,6 +143,8 @@ class TimeSyncMixin:
|
||||
) -> FixResultDict:
|
||||
"""Give the device exactly *ntp_servers*, in order, and *timezone*; None leaves one alone.
|
||||
|
||||
What the device gets by DHCP is not touched: it keeps using those servers too.
|
||||
|
||||
The steps: ``ntp_servers``, ``timezone``, then ``verify``, which reads the
|
||||
device again.
|
||||
|
||||
@@ -157,8 +174,8 @@ class TimeSyncMixin:
|
||||
def _verify_time_sync(self, servers: list[str] | None, zone: str | None) -> FixStepOutcomeDict:
|
||||
"""Read the device again: does it now have what was written?
|
||||
|
||||
Servers compare without case. A zone is compared where the device reads
|
||||
one back by name.
|
||||
Servers compare without case; the servers DHCP brought are not among
|
||||
them. A zone is compared where the device reads one back by name.
|
||||
"""
|
||||
now = self.get_time_sync()
|
||||
wrong: list[str] = []
|
||||
|
||||
@@ -13,17 +13,22 @@ reads them, ``timedatectl show-timesync`` for systemd-timesyncd, ``ntp.conf``,
|
||||
OpenNTPD's ``ntpd.conf``. Synchronised is chronyd's own word where it runs (a
|
||||
selected source in ``chronyc -n sources``), else the kernel's (``NTPSynchronized``).
|
||||
|
||||
What DHCP brought (option 42) is read apart, as ``dhcp_ntp_servers``, and never as a
|
||||
configured server: chrony's sources from the DHCP client's ``sourcedir``
|
||||
(:attr:`~PosixTimeSyncMixin.CHRONY_DHCP_DIRS`, the files as chronyd reads them),
|
||||
systemd-timesyncd's ``LinkNTPServers``. Where ntpd or OpenNTPD runs it is unknown.
|
||||
|
||||
**Writing** runs as root through ``run_command(privileged=True)``; root never reads
|
||||
stdin -- a file is staged by the login user and installed by root.
|
||||
|
||||
* The zone: ``timedatectl set-timezone``.
|
||||
* chrony: the servers go to a file of their own and every other source is commented
|
||||
out (:mod:`napalm_device_types._chrony`), then ``chronyc reload sources``, or a
|
||||
restart of chronyd where its main configuration changed or it cannot reload.
|
||||
* chrony: the servers go to a file of their own and every other configured source is
|
||||
commented out (:mod:`napalm_device_types._chrony`); the DHCP client's ``sourcedir``
|
||||
stays, and one 4.35.0 commented out comes back. Then ``chronyc reload sources``, or
|
||||
a restart of chronyd where its main configuration changed or it cannot reload.
|
||||
* systemd-timesyncd: :attr:`~PosixTimeSyncMixin.TIMESYNCD_DROPIN` resets ``NTP=``,
|
||||
sets the servers and empties ``FallbackNTP=``, then the service restarts. Servers a
|
||||
network link brings (DHCP through systemd-networkd) are not timesyncd's to drop;
|
||||
they stay, and the ``verify`` step names them.
|
||||
network link brings (DHCP through systemd-networkd) stay and count.
|
||||
* ntpd, OpenNTPD, or no client: the servers are read, not written -- the step fails
|
||||
and says so.
|
||||
"""
|
||||
@@ -39,9 +44,11 @@ from napalm_device_types._chrony import (
|
||||
comment_out_command,
|
||||
include_command,
|
||||
plan_chrony,
|
||||
restore_command,
|
||||
)
|
||||
from napalm_device_types._scheduled_reading import TIME_ZONE_SH
|
||||
from napalm_device_types._time_sync_reading import (
|
||||
CHRONY_DHCP_DIRS,
|
||||
TIME_SYNC_UNITS,
|
||||
Reading,
|
||||
ReadPaths,
|
||||
@@ -51,6 +58,7 @@ from napalm_device_types._time_sync_reading import (
|
||||
parse_time_sync,
|
||||
reading_command,
|
||||
time_sync_of,
|
||||
timesyncd_link_servers,
|
||||
timesyncd_servers,
|
||||
)
|
||||
from napalm_device_types.models import FixStepOutcomeDict
|
||||
@@ -91,6 +99,9 @@ class PosixTimeSyncMixin(TimeSyncMixin):
|
||||
CHRONY_SOURCES_FILE: ClassVar[str] = "/etc/chrony/sources.d/netork.sources"
|
||||
#: The servers' file otherwise (its name also in a ``confdir``); included if need be.
|
||||
CHRONY_INCLUDE_FILE: ClassVar[str] = "/etc/chrony.d/netork.conf"
|
||||
#: The ``sourcedir`` a DHCP client writes chrony's sources to: read as
|
||||
#: ``dhcp_ntp_servers``, never commented out.
|
||||
CHRONY_DHCP_DIRS: ClassVar[tuple[str, ...]] = CHRONY_DHCP_DIRS
|
||||
TIMESYNCD_DROPIN: ClassVar[str] = "/etc/systemd/timesyncd.conf.d/netork.conf"
|
||||
NTPD_CONFIGS: ClassVar[tuple[str, ...]] = ("/etc/ntpsec/ntp.conf", "/etc/ntp.conf")
|
||||
OPENNTPD_CONFIGS: ClassVar[tuple[str, ...]] = ("/etc/openntpd/ntpd.conf", "/etc/ntpd.conf")
|
||||
@@ -125,7 +136,7 @@ class PosixTimeSyncMixin(TimeSyncMixin):
|
||||
|
||||
:raises ValueError: when the reading came back cut short.
|
||||
"""
|
||||
return time_sync_of(self._ts_read())
|
||||
return time_sync_of(self._ts_read(), self.CHRONY_DHCP_DIRS)
|
||||
|
||||
# -- writing ---------------------------------------------------------------------------------
|
||||
|
||||
@@ -175,9 +186,13 @@ class PosixTimeSyncMixin(TimeSyncMixin):
|
||||
servers,
|
||||
sources_file=self.CHRONY_SOURCES_FILE,
|
||||
include_file=self.CHRONY_INCLUDE_FILE,
|
||||
dhcp_dirs=self.CHRONY_DHCP_DIRS,
|
||||
)
|
||||
said = [f"wrote {plan.target}"]
|
||||
self._ts_install(plan.target, plan.content)
|
||||
for path, numbers in plan.restore.items():
|
||||
self._ts_checked(restore_command(path, numbers))
|
||||
said.append(f"gave DHCP's sourcedir back in {path}:{','.join(map(str, numbers))}")
|
||||
for path, numbers in plan.comment_out.items():
|
||||
self._ts_checked(comment_out_command(path, numbers))
|
||||
said.append(f"commented out {path}:{','.join(map(str, numbers))}")
|
||||
@@ -199,5 +214,6 @@ __all__ = [
|
||||
"parse_key_values",
|
||||
"parse_time_sync",
|
||||
"timesyncd_dropin",
|
||||
"timesyncd_link_servers",
|
||||
"timesyncd_servers",
|
||||
]
|
||||
@@ -17,6 +17,15 @@ from typing import TYPE_CHECKING, Any
|
||||
from napalm_device_types.models import ApplyUpdatesResultDict, UpdateDict, UpdateProgressDict
|
||||
|
||||
|
||||
class PackageIndexMissing(RuntimeError):
|
||||
"""The host holds no package index to read pending updates from.
|
||||
|
||||
Not a fault: OpenWrt keeps its index in RAM and loses it on every reboot.
|
||||
:meth:`UpdateMixin.refresh_available_updates` loads it again, so a caller
|
||||
that sees this can refresh instead of reporting a failed read.
|
||||
"""
|
||||
|
||||
|
||||
class UpdateMixin:
|
||||
if TYPE_CHECKING:
|
||||
|
||||
@@ -37,6 +46,8 @@ class UpdateMixin:
|
||||
read -- no package index yet, an API that did not answer -- raises
|
||||
instead: netOrk keeps "pending since" per package, and an empty
|
||||
list for "don't know" would reset every one of those clocks.
|
||||
Without a package index it raises :exc:`PackageIndexMissing`, which
|
||||
:meth:`refresh_available_updates` cures.
|
||||
|
||||
Example::
|
||||
|
||||
@@ -50,6 +61,28 @@ class UpdateMixin:
|
||||
"""
|
||||
...
|
||||
|
||||
def get_installed_advisory_cves(self) -> dict[str, list[str]]:
|
||||
"""
|
||||
The CVEs the host's installed security advisories close, per package
|
||||
name: the distribution's own word that a fix is in the installed build,
|
||||
although its upstream version did not move (a backport).
|
||||
|
||||
netOrk asks for it only where its knowledge base holds no records of
|
||||
the host's release (netOrk #2394), since the answer can be long. A
|
||||
package manager whose advisories name no CVEs has nothing to say here.
|
||||
|
||||
**An empty dict means no installed advisory names a CVE.** A reader
|
||||
that cannot read raises, as :meth:`get_available_updates` does.
|
||||
``NotImplementedError`` where the host's package manager keeps no such
|
||||
advisories (:data:`~napalm_device_types.package_updates.DNF_INSTALLED_CVES_COMMAND`
|
||||
is dnf 4's).
|
||||
|
||||
Example::
|
||||
|
||||
{"glibc-common": ["CVE-2023-4911"], "curl": ["CVE-2023-38545"]}
|
||||
"""
|
||||
...
|
||||
|
||||
def refresh_available_updates(self) -> dict[str, Any]:
|
||||
"""
|
||||
Refreshes the host's package index, so that :meth:`get_available_updates`
|
||||
|
||||
+1
-1
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
|
||||
|
||||
[project]
|
||||
name = "napalm-device-types"
|
||||
version = "4.35.0"
|
||||
version = "4.39.0"
|
||||
description = "Abstract device-type base classes for NAPALM drivers"
|
||||
readme = "README.md"
|
||||
requires-python = ">=3.12"
|
||||
|
||||
@@ -20,7 +20,6 @@
|
||||
},
|
||||
"function_lines": {
|
||||
"napalm_device_types/_ucd_metrics.py::collect_ucd_metrics": 119,
|
||||
"napalm_device_types/dhcp.py::DhcpServerMixin.diff_dhcp_reservations": 54,
|
||||
"napalm_device_types/dhcp.py::DhcpServerMixin.diff_dhcp_subnets": 60,
|
||||
"napalm_device_types/firewall_rules.py::FirewallRuleMixin.diff_firewall_rules": 56,
|
||||
"napalm_device_types/hypervisor.py::HypervisorDriver.create_vm_from_cloud_init": 84,
|
||||
@@ -32,7 +31,7 @@
|
||||
},
|
||||
"mypy_relaxed": [],
|
||||
"python_file_lines": {
|
||||
"napalm_device_types/models.py": 1454
|
||||
"napalm_device_types/models.py": 1442
|
||||
},
|
||||
"untyped_public": []
|
||||
}
|
||||
@@ -0,0 +1,172 @@
|
||||
"""ConfigRevisionsMixin: a device's own configuration history (NetOrk/netork#2511).
|
||||
|
||||
Some devices keep their earlier configurations themselves. An application restores a
|
||||
configuration there by reverting to the revision that holds it -- on OPNsense the only
|
||||
way, since no API takes an uploaded config.xml. Listing and reading are declared only,
|
||||
so ``callable(getattr(driver, "get_config_revisions", None))`` is the truthful answer;
|
||||
``revert_config_revision`` is a template: it refuses an id that is not in the history,
|
||||
lets the driver revert, and checks that the configuration in place now is the
|
||||
revision's.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import inspect
|
||||
from typing import get_type_hints
|
||||
|
||||
import pytest
|
||||
|
||||
from napalm_device_types import (
|
||||
ConfigRevertFailed,
|
||||
ConfigRevisionDict,
|
||||
ConfigRevisionsMixin,
|
||||
DeviceTypeDriver,
|
||||
FirewallDriver,
|
||||
OSDriver,
|
||||
SwitchDriver,
|
||||
UnknownConfigRevision,
|
||||
)
|
||||
|
||||
|
||||
def test_the_shape():
|
||||
assert get_type_hints(ConfigRevisionDict) == {
|
||||
"id": str,
|
||||
"time": str | None,
|
||||
"description": str | None,
|
||||
"user": str | None,
|
||||
"size": int | None,
|
||||
}
|
||||
|
||||
|
||||
def test_no_role_demands_it():
|
||||
for role in (FirewallDriver, OSDriver, SwitchDriver, DeviceTypeDriver):
|
||||
assert not issubclass(role, ConfigRevisionsMixin)
|
||||
|
||||
|
||||
def test_listing_and_reading_are_declared_not_implemented():
|
||||
assert not hasattr(ConfigRevisionsMixin, "get_config_revisions")
|
||||
assert not hasattr(ConfigRevisionsMixin, "get_config_revision")
|
||||
source = inspect.getsource(ConfigRevisionsMixin)
|
||||
assert "def get_config_revisions(self) -> list[ConfigRevisionDict]" in source
|
||||
assert "def get_config_revision(self, revision_id: str) -> str" in source
|
||||
assert "def _revert_to_config_revision(self, revision_id: str) -> None" in source
|
||||
|
||||
|
||||
def test_an_unknown_revision_is_a_value_error_that_names_it():
|
||||
error = UnknownConfigRevision("r9")
|
||||
|
||||
assert isinstance(error, ValueError)
|
||||
assert "'r9'" in str(error)
|
||||
|
||||
|
||||
def test_a_failed_revert_is_a_runtime_error():
|
||||
assert issubclass(ConfigRevertFailed, RuntimeError)
|
||||
|
||||
|
||||
def _revision(revision_id: str, time: str) -> ConfigRevisionDict:
|
||||
return {"id": revision_id, "time": time, "description": None, "user": None, "size": None}
|
||||
|
||||
|
||||
class _Device(ConfigRevisionsMixin):
|
||||
"""A device that keeps its history in memory, newest first, and saves a revert as a
|
||||
new newest revision with a stamp of its own on the first line."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.history = [
|
||||
(_revision("r3", "2026-11-13T21:00:00+00:00"), "#saved 3\nb\n"),
|
||||
(_revision("r2", "2026-11-12T21:00:00+00:00"), "#saved 2\na\n"),
|
||||
(_revision("r1", "2026-11-11T21:00:00+00:00"), "#saved 1\na\n"),
|
||||
]
|
||||
self.calls: list[str] = []
|
||||
|
||||
def get_config_revisions(self) -> list[ConfigRevisionDict]:
|
||||
self.calls.append("list")
|
||||
return [revision for revision, _ in self.history]
|
||||
|
||||
def get_config_revision(self, revision_id: str) -> str:
|
||||
self.calls.append(f"read {revision_id}")
|
||||
for revision, text in self.history:
|
||||
if revision["id"] == revision_id:
|
||||
return text
|
||||
raise UnknownConfigRevision(revision_id)
|
||||
|
||||
def _revert_to_config_revision(self, revision_id: str) -> None:
|
||||
self.calls.append(f"revert {revision_id}")
|
||||
body = self.get_config_revision(revision_id).split("\n", 1)[1]
|
||||
self.history.insert(0, (_revision("r4", "2026-11-14T08:00:00+00:00"), f"#saved 4\n{body}"))
|
||||
|
||||
def config_revision_content(self, text: str) -> str:
|
||||
return text.split("\n", 1)[1]
|
||||
|
||||
|
||||
class TestRevertConfigRevision:
|
||||
def test_reverts_and_answers_with_the_revision_now_in_place(self):
|
||||
device = _Device()
|
||||
|
||||
now = device.revert_config_revision("r1")
|
||||
|
||||
assert now["id"] == "r4"
|
||||
assert device.calls == ["list", "read r1", "revert r1", "read r1", "list", "read r4"]
|
||||
|
||||
def test_the_revision_is_read_before_the_revert_which_may_rotate_it_out(self):
|
||||
class Rotating(_Device):
|
||||
def _revert_to_config_revision(self, revision_id: str) -> None:
|
||||
super()._revert_to_config_revision(revision_id)
|
||||
self.history.pop() # the oldest, r1, drops out
|
||||
|
||||
assert Rotating().revert_config_revision("r1")["id"] == "r4"
|
||||
|
||||
def test_a_revision_not_in_the_history_is_refused_before_anything_changes(self):
|
||||
device = _Device()
|
||||
|
||||
with pytest.raises(UnknownConfigRevision, match="r9"):
|
||||
device.revert_config_revision("r9")
|
||||
|
||||
assert device.calls == ["list"]
|
||||
|
||||
def test_a_revert_the_device_did_not_take_fails(self):
|
||||
# OPNsense answers "reverted" even when it fell back to the previous file.
|
||||
class Deaf(_Device):
|
||||
def _revert_to_config_revision(self, revision_id: str) -> None:
|
||||
self.calls.append(f"revert {revision_id}")
|
||||
|
||||
with pytest.raises(ConfigRevertFailed, match="r1"):
|
||||
Deaf().revert_config_revision("r1")
|
||||
|
||||
def test_a_history_that_is_empty_afterwards_fails(self):
|
||||
class Forgetful(_Device):
|
||||
def _revert_to_config_revision(self, revision_id: str) -> None:
|
||||
self.history.clear()
|
||||
|
||||
with pytest.raises(ConfigRevertFailed):
|
||||
Forgetful().revert_config_revision("r1")
|
||||
|
||||
def test_what_a_save_stamps_anew_does_not_count(self):
|
||||
# r2 and r1 differ only in their stamp: reverting to r2 leaves r1's content.
|
||||
device = _Device()
|
||||
|
||||
assert device.revert_config_revision("r2")["id"] == "r4"
|
||||
|
||||
def test_a_refusal_of_the_device_reaches_the_caller(self):
|
||||
class Refusing(_Device):
|
||||
def _revert_to_config_revision(self, revision_id: str) -> None:
|
||||
raise ConfigRevertFailed("read-only user")
|
||||
|
||||
with pytest.raises(ConfigRevertFailed, match="read-only"):
|
||||
Refusing().revert_config_revision("r1")
|
||||
|
||||
|
||||
class TestConfigRevisionContent:
|
||||
def test_by_default_the_whole_text(self):
|
||||
class Plain(ConfigRevisionsMixin):
|
||||
pass
|
||||
|
||||
assert Plain().config_revision_content("a\nb\n") == "a\nb\n"
|
||||
|
||||
def test_without_a_stamp_every_save_differs(self):
|
||||
class Plain(_Device):
|
||||
def config_revision_content(self, text: str) -> str:
|
||||
return ConfigRevisionsMixin.config_revision_content(self, text)
|
||||
|
||||
with pytest.raises(ConfigRevertFailed):
|
||||
Plain().revert_config_revision("r1")
|
||||
@@ -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,245 @@ 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)
|
||||
|
||||
|
||||
#: What Kea answers through OPNsense's API for an address another reservation holds.
|
||||
_KEA_DUPLICATE = (
|
||||
"{'result': 'failed', 'validations': {'reservation.ip_address': 'Duplicate entry exists.'}}"
|
||||
)
|
||||
|
||||
|
||||
class _KeaLikeServer(_FakeDhcpServer):
|
||||
"""A server that keeps each address unique at every write, as Kea does: a write
|
||||
taking an address another reservation still holds is refused."""
|
||||
|
||||
def apply_dhcp_reservation(
|
||||
self, reservation: DhcpReservationDict, *, uuid: str | None = None
|
||||
) -> dict[str, Any]:
|
||||
if any(r["ip"] == reservation["ip"] and r["uuid"] != uuid for r in self.live):
|
||||
raise RuntimeError(_KEA_DUPLICATE)
|
||||
stored = {**reservation, "uuid": uuid or f"new-{len(self.live)}"}
|
||||
self.live = [r for r in self.live if r["uuid"] != uuid] + [stored] # type: ignore[list-item]
|
||||
return super().apply_dhcp_reservation(reservation, uuid=uuid)
|
||||
|
||||
def ip_of(self, mac: str) -> str:
|
||||
return next(r["ip"] for r in self.live if r["mac"] == mac)
|
||||
|
||||
|
||||
_A, _B, _C, _N = (f"02:00:00:00:00:0{i}" for i in "abcd")
|
||||
|
||||
|
||||
def _at(mac: str, ip: str, uuid: str = "") -> DhcpReservationDict:
|
||||
return _reservation(mac=mac, ip=ip, uuid=uuid, subnet="192.0.2.0/24")
|
||||
|
||||
|
||||
class TestApplyOrderReleasesBeforeTaking:
|
||||
"""An address is released before another change takes it (#106)."""
|
||||
|
||||
def test_an_update_that_frees_an_address_goes_first(self):
|
||||
# The issue: B takes A's address, A moves on; desired lists B first.
|
||||
driver = _KeaLikeServer([_at(_A, "192.0.2.10", "ua"), _at(_B, "192.0.2.11", "ub")])
|
||||
|
||||
lines = list(
|
||||
driver.apply_dhcp_reservationset([_at(_B, "192.0.2.10"), _at(_A, "192.0.2.20")])
|
||||
)
|
||||
|
||||
assert driver.ip_of(_A) == "192.0.2.20"
|
||||
assert driver.ip_of(_B) == "192.0.2.10"
|
||||
assert lines == [
|
||||
f"[update] {_A} -> 192.0.2.20 (ip)",
|
||||
f"[update] {_B} -> 192.0.2.10 (ip)",
|
||||
"[commit] applied 0 add(s), 2 update(s)",
|
||||
]
|
||||
|
||||
def test_a_chain_is_written_from_its_free_end(self):
|
||||
live = [
|
||||
_at(_A, "192.0.2.10", "ua"),
|
||||
_at(_B, "192.0.2.11", "ub"),
|
||||
_at(_C, "192.0.2.12", "uc"),
|
||||
]
|
||||
driver = _KeaLikeServer(live)
|
||||
|
||||
list(
|
||||
driver.apply_dhcp_reservationset(
|
||||
[_at(_A, "192.0.2.11"), _at(_B, "192.0.2.12"), _at(_C, "192.0.2.13")]
|
||||
)
|
||||
)
|
||||
|
||||
assert [e["reservation"]["mac"] for e in driver.applied] == [_C, _B, _A]
|
||||
assert [driver.ip_of(m) for m in (_A, _B, _C)] == ["192.0.2.11", "192.0.2.12", "192.0.2.13"]
|
||||
|
||||
def test_an_add_comes_after_the_update_that_frees_its_address(self):
|
||||
driver = _KeaLikeServer([_at(_A, "192.0.2.10", "ua")])
|
||||
|
||||
lines = list(
|
||||
driver.apply_dhcp_reservationset([_at(_N, "192.0.2.10"), _at(_A, "192.0.2.20")])
|
||||
)
|
||||
|
||||
assert driver.ip_of(_N) == "192.0.2.10"
|
||||
assert driver.ip_of(_A) == "192.0.2.20"
|
||||
assert lines[-1] == "[commit] applied 1 add(s), 1 update(s)"
|
||||
|
||||
def test_addresses_match_however_they_are_spelled(self):
|
||||
driver = _FakeDhcpServer([_at(_A, "2001:DB8::10", "ua"), _at(_B, "2001:DB8::11", "ub")])
|
||||
|
||||
list(driver.apply_dhcp_reservationset([_at(_B, "2001:db8::10"), _at(_A, "2001:db8::20")]))
|
||||
|
||||
assert [e["reservation"]["mac"] for e in driver.applied] == [_A, _B]
|
||||
|
||||
def test_an_update_that_keeps_its_address_frees_nothing(self):
|
||||
# A hostname change is no release: the add for A's address stays refused.
|
||||
driver = _KeaLikeServer([_at(_A, "192.0.2.10", "ua")])
|
||||
|
||||
with pytest.raises(DhcpApplyError, match="1 of 2"):
|
||||
list(
|
||||
driver.apply_dhcp_reservationset(
|
||||
[_at(_N, "192.0.2.10"), {**_at(_A, "192.0.2.10"), "hostname": "renamed"}]
|
||||
)
|
||||
)
|
||||
|
||||
assert driver.ip_of(_A) == "192.0.2.10"
|
||||
|
||||
|
||||
class TestApplyOrderWithASwap:
|
||||
"""Two reservations trading addresses: no order frees one first. Each is still
|
||||
tried -- a server that checks only at the commit takes them -- and a refusal says it
|
||||
was a swap. Nothing is moved to a temporary address: the contract has no way to know
|
||||
a free one, and a second write that failed would leave the reservation there."""
|
||||
|
||||
def _swap(self) -> list[DhcpReservationDict]:
|
||||
return [_at(_A, "192.0.2.11"), _at(_B, "192.0.2.10"), _at(_N, "192.0.2.30")]
|
||||
|
||||
def _live(self) -> list[DhcpReservationDict]:
|
||||
return [_at(_A, "192.0.2.10", "ua"), _at(_B, "192.0.2.11", "ub")]
|
||||
|
||||
def test_a_refused_swap_is_reported_as_one_and_the_rest_is_written(self):
|
||||
driver = _KeaLikeServer(self._live())
|
||||
lines: list[str] = []
|
||||
|
||||
with pytest.raises(DhcpApplyError, match="2 of 3"):
|
||||
for line in driver.apply_dhcp_reservationset(self._swap()):
|
||||
lines.append(line)
|
||||
|
||||
failed = [line for line in lines if line.startswith("[failed]")]
|
||||
assert len(failed) == 2
|
||||
assert all("Duplicate entry exists" in line for line in failed)
|
||||
assert f"swap with {_B}" in failed[0] and f"swap with {_A}" in failed[1]
|
||||
assert driver.ip_of(_A) == "192.0.2.10" and driver.ip_of(_B) == "192.0.2.11"
|
||||
assert driver.ip_of(_N) == "192.0.2.30"
|
||||
assert driver.commits == 1
|
||||
|
||||
def test_a_server_that_takes_the_swap_gets_it(self):
|
||||
driver = _FakeDhcpServer(self._live())
|
||||
|
||||
lines = list(driver.apply_dhcp_reservationset(self._swap()))
|
||||
|
||||
assert len(driver.applied) == 3
|
||||
assert not any("swap" in line for line in lines)
|
||||
|
||||
def test_a_rotation_of_three_is_a_swap_too(self):
|
||||
driver = _KeaLikeServer([*self._live(), _at(_C, "192.0.2.12", "uc")])
|
||||
lines: list[str] = []
|
||||
|
||||
with pytest.raises(DhcpApplyError, match="3 of 3"):
|
||||
for line in driver.apply_dhcp_reservationset(
|
||||
[_at(_A, "192.0.2.11"), _at(_B, "192.0.2.12"), _at(_C, "192.0.2.10")]
|
||||
):
|
||||
lines.append(line)
|
||||
|
||||
by_mac = {line.split()[1]: line for line in lines if line.startswith("[failed]")}
|
||||
assert f"swap with {_B}, {_C}" in by_mac[_A]
|
||||
assert f"swap with {_A}, {_C}" in by_mac[_B]
|
||||
assert f"swap with {_A}, {_B}" in by_mac[_C]
|
||||
|
||||
|
||||
class TestKeysThatCannotNameOneReservation:
|
||||
def test_a_live_reservation_without_mac_is_never_matched(self):
|
||||
driver = _FakeDhcpServer([_reservation(uuid="b", mac="")])
|
||||
|
||||
@@ -16,6 +16,7 @@ from typing import Any
|
||||
import pytest
|
||||
|
||||
from napalm_device_types import DhcpServerMixin
|
||||
from napalm_device_types.dhcp import DhcpApplyError
|
||||
from napalm_device_types.models import DhcpSubnetDict
|
||||
|
||||
|
||||
@@ -235,3 +236,92 @@ def test_calling_a_missing_device_method_fails_loudly() -> None:
|
||||
def test_a_subnet_that_cannot_name_one_raises(desired):
|
||||
with pytest.raises(ValueError):
|
||||
_FakeDhcpServer([]).diff_dhcp_subnets(desired)
|
||||
|
||||
|
||||
# ── apply: a refused subnet does not hold back the others (#113) ──────────────
|
||||
|
||||
|
||||
class _RefusingDhcpServer(_FakeDhcpServer):
|
||||
"""A server that refuses the subnets in *refused*, as Kea refuses one that
|
||||
overlaps a subnet it already serves."""
|
||||
|
||||
def __init__(self, live: list[DhcpSubnetDict] | None = None, *, refused: set[str]) -> None:
|
||||
super().__init__(live)
|
||||
self.refused = refused
|
||||
|
||||
def apply_dhcp_subnet(
|
||||
self, subnet: DhcpSubnetDict, *, uuid: str | None = None
|
||||
) -> dict[str, Any]:
|
||||
if subnet["subnet"] in self.refused:
|
||||
raise RuntimeError(f"{subnet['subnet']} overlaps a subnet the server has")
|
||||
return super().apply_dhcp_subnet(subnet, uuid=uuid)
|
||||
|
||||
|
||||
def _three_subnets() -> list[DhcpSubnetDict]:
|
||||
return [
|
||||
_subnet(subnet="192.0.2.0/26"),
|
||||
_subnet(subnet="192.0.2.64/26"),
|
||||
_subnet(subnet="192.0.2.128/26"),
|
||||
]
|
||||
|
||||
|
||||
def test_a_refused_subnet_does_not_stop_the_others() -> None:
|
||||
fake = _RefusingDhcpServer(refused={"192.0.2.64/26"})
|
||||
|
||||
with pytest.raises(DhcpApplyError):
|
||||
list(fake.apply_dhcp_subnetset(_three_subnets()))
|
||||
|
||||
assert [e["subnet"]["subnet"] for e in fake.applied] == ["192.0.2.0/26", "192.0.2.128/26"]
|
||||
|
||||
|
||||
def test_what_was_written_is_committed() -> None:
|
||||
fake = _RefusingDhcpServer(refused={"192.0.2.64/26"})
|
||||
|
||||
with pytest.raises(DhcpApplyError):
|
||||
list(fake.apply_dhcp_subnetset(_three_subnets()))
|
||||
|
||||
assert fake.commits == 1
|
||||
|
||||
|
||||
def test_a_set_whose_every_write_is_refused_still_commits() -> None:
|
||||
# A run that stopped before its commit left saved writes behind, which the device
|
||||
# reports as configured: no later diff would commit them.
|
||||
fake = _RefusingDhcpServer(refused={"192.0.2.64/26"})
|
||||
|
||||
with pytest.raises(DhcpApplyError):
|
||||
list(fake.apply_dhcp_subnetset([_three_subnets()[1]]))
|
||||
|
||||
assert fake.commits == 1
|
||||
|
||||
|
||||
def test_progress_names_the_refused_subnet_and_why() -> None:
|
||||
fake = _RefusingDhcpServer(
|
||||
[_subnet(uuid="dev-1", subnet="192.0.2.128/26")], refused={"192.0.2.64/26"}
|
||||
)
|
||||
lines: list[str] = []
|
||||
|
||||
with pytest.raises(DhcpApplyError) as raised:
|
||||
for line in fake.apply_dhcp_subnetset(
|
||||
[*_three_subnets()[:2], _subnet(subnet="192.0.2.128/26", description="Office")]
|
||||
):
|
||||
lines.append(line)
|
||||
|
||||
assert lines == [
|
||||
"[add] 192.0.2.0/26",
|
||||
"[failed] 192.0.2.64/26: 192.0.2.64/26 overlaps a subnet the server has",
|
||||
"[update] 192.0.2.128/26 (description)",
|
||||
"[commit] applied 1 add(s), 1 update(s)",
|
||||
]
|
||||
assert (raised.value.failed, raised.value.attempted) == (1, 3)
|
||||
assert str(raised.value) == "1 of 3 DHCP subnet change(s) were refused"
|
||||
|
||||
|
||||
def test_a_refused_update_is_counted_like_an_add() -> None:
|
||||
live = _subnet(uuid="dev-1", subnet="192.0.2.0/24")
|
||||
fake = _RefusingDhcpServer([live], refused={"192.0.2.0/24"})
|
||||
|
||||
with pytest.raises(DhcpApplyError, match="1 of 1"):
|
||||
list(fake.apply_dhcp_subnetset([_subnet(subnet="192.0.2.0/24", description="Office")]))
|
||||
|
||||
assert fake.applied == []
|
||||
assert fake.commits == 1
|
||||
@@ -154,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):
|
||||
@@ -598,8 +616,8 @@ class TestInterruptedRpm:
|
||||
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 -- and still have to be checked against a
|
||||
real Oracle Linux 9 host.
|
||||
``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")
|
||||
@@ -804,6 +822,29 @@ case "$*" in
|
||||
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
|
||||
@@ -886,6 +927,23 @@ class TestThePackageManagerCommandOnARealShell:
|
||||
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"
|
||||
|
||||
@@ -37,9 +37,40 @@ class TestRules:
|
||||
"selector": "*.*",
|
||||
"complete": True,
|
||||
"ruleset": None,
|
||||
"template": "RSYSLOG_SyslogProtocol23Format",
|
||||
},
|
||||
]
|
||||
|
||||
def test_a_rule_without_a_template_sends_rsyslogs_default(self):
|
||||
"""None: RFC 3164, the sender's local time without a zone (NetOrk/netork#493)."""
|
||||
(rule,) = _rules("*.* @graylog.example.net:514\n")
|
||||
assert rule["template"] is None
|
||||
|
||||
def test_an_actions_template_parameter(self):
|
||||
(rule,) = _rules(
|
||||
'action(type="omfwd" target="10.0.0.7" Template="RSYSLOG_ForwardFormat")\n'
|
||||
)
|
||||
assert rule["template"] == "RSYSLOG_ForwardFormat"
|
||||
|
||||
def test_the_legacy_default_template_holds_for_the_rules_after_it(self):
|
||||
rules = _rules(
|
||||
"*.* @a\n$ActionForwardDefaultTemplate RSYSLOG_SyslogProtocol23Format\n"
|
||||
"*.* @@b:514\n*.* @c;RSYSLOG_TraditionalForwardFormat\n"
|
||||
)
|
||||
assert [(r["target"], r["template"]) for r in rules] == [
|
||||
("a", None),
|
||||
("b", "RSYSLOG_SyslogProtocol23Format"),
|
||||
("c", "RSYSLOG_TraditionalForwardFormat"),
|
||||
]
|
||||
|
||||
def test_the_forward_modules_template_holds_for_its_actions(self):
|
||||
text = (
|
||||
'module(load="builtin:omfwd" template="RSYSLOG_SyslogProtocol23Format")\n'
|
||||
'action(type="omfwd" target="10.0.0.7")\n'
|
||||
)
|
||||
(rule,) = _rules(text)
|
||||
assert rule["template"] == "RSYSLOG_SyslogProtocol23Format"
|
||||
|
||||
def test_two_ats_are_tcp_and_a_missing_port_stays_unknown(self):
|
||||
(rule,) = _rules("*.* @@logs.lan\n")
|
||||
assert (rule["protocol"], rule["target"], rule["port"]) == ("tcp", "logs.lan", None)
|
||||
|
||||
@@ -18,9 +18,11 @@ import pytest
|
||||
|
||||
from napalm_device_types.package_updates import (
|
||||
APT_UPGRADABLE_COMMAND,
|
||||
DNF_INSTALLED_CVES_COMMAND,
|
||||
DNF_SECURITY_COMMAND,
|
||||
nevra_name,
|
||||
parse_apt_upgradable,
|
||||
parse_dnf_installed_cves,
|
||||
parse_dnf_security,
|
||||
)
|
||||
|
||||
@@ -198,3 +200,75 @@ __DNF_RC=0
|
||||
)
|
||||
def test_the_name_of_a_nevra(self, nevra, name):
|
||||
assert nevra_name(nevra) == name
|
||||
|
||||
|
||||
class TestDnfInstalledCves:
|
||||
"""The CVEs the host's installed advisories close, per package (netOrk #2394).
|
||||
|
||||
Where netOrk's knowledge base holds no records of a release, the host's own
|
||||
advisories are the distribution's word that a backport is in. Lines from real
|
||||
hosts: Oracle Linux 9.8 (dnf 4.14, aarch64) and Amazon Linux 2023 (dnf 4.14).
|
||||
"""
|
||||
|
||||
ORACLE = """\
|
||||
CVE-2024-6501 Low/Sec. NetworkManager-1:1.48.10-2.0.1.el9_5.aarch64
|
||||
CVE-2024-3661 Moderate/Sec. NetworkManager-1:1.48.10-5.0.1.el9_5.aarch64
|
||||
CVE-2023-38545 Important/Sec. curl-7.76.1-23.el9_2.4.aarch64
|
||||
CVE-2023-38545 Important/Sec. curl-7.76.1-26.el9_3.2.aarch64
|
||||
CVE-2023-4911 Important/Sec. glibc-common-2.34-60.0.3.el9.aarch64
|
||||
CVE-2023-4911 Important/Sec. glibc-common-2.34-60.0.3.el9_2.7.aarch64
|
||||
__DNF_RC=0
|
||||
"""
|
||||
|
||||
AMAZON = """\
|
||||
CVE-2022-3715 Medium/Sec. bash-5.2.15-1.amzn2023.0.2.x86_64
|
||||
CVE-2022-23491 Important/Sec. ca-certificates-2021.2.50-1.0.amzn2023.0.6.noarch
|
||||
CVE-2023-32803 Important/Sec. ca-certificates-2023.2.60-1.0.amzn2023.0.2.noarch
|
||||
__DNF_RC=0
|
||||
"""
|
||||
|
||||
def test_cves_per_package_once_each_and_sorted(self):
|
||||
assert parse_dnf_installed_cves(self.ORACLE) == {
|
||||
"NetworkManager": ["CVE-2024-3661", "CVE-2024-6501"],
|
||||
"curl": ["CVE-2023-38545"],
|
||||
"glibc-common": ["CVE-2023-4911"],
|
||||
}
|
||||
|
||||
def test_amazon_linux(self):
|
||||
assert parse_dnf_installed_cves(self.AMAZON) == {
|
||||
"bash": ["CVE-2022-3715"],
|
||||
"ca-certificates": ["CVE-2022-23491", "CVE-2023-32803"],
|
||||
}
|
||||
|
||||
def test_lines_that_name_no_cve_are_left_out(self):
|
||||
"""A GPG prompt a repository without its key prints, an advisory id."""
|
||||
out = (
|
||||
"Importing GPG key 0x6E93CD0C:\n"
|
||||
' Userid : "https://packagecloud.io/crowdsec/crowdsec"\n'
|
||||
"ELSA-2023-5453 Important/Sec. glibc-2.34-60.0.3.el9_2.7.aarch64\n"
|
||||
"__DNF_RC=0\n"
|
||||
)
|
||||
assert parse_dnf_installed_cves(out) == {}
|
||||
|
||||
def test_a_failed_dnf_raises_instead_of_reading_as_no_advisories(self):
|
||||
with pytest.raises(ValueError, match="exit status 1"):
|
||||
parse_dnf_installed_cves("__DNF_RC=1\n")
|
||||
|
||||
def test_output_cut_short_raises(self):
|
||||
with pytest.raises(ValueError, match="no exit status"):
|
||||
parse_dnf_installed_cves(self.ORACLE.replace("__DNF_RC=0\n", ""))
|
||||
|
||||
def test_the_command_lists_installed_advisories_with_their_cves_from_the_cache(self, tmp_path):
|
||||
args = tmp_path / "args"
|
||||
dnf = tmp_path / "dnf"
|
||||
dnf.write_text(f"#!/bin/sh\nprintf '%s\\n' \"$@\" > {args}\n")
|
||||
dnf.chmod(0o755)
|
||||
env = {"PATH": f"{tmp_path}:{os.environ.get('PATH', '/usr/bin:/bin')}"}
|
||||
out = subprocess.run(
|
||||
["sh", "-c", DNF_INSTALLED_CVES_COMMAND], capture_output=True, text=True, env=env
|
||||
).stdout
|
||||
|
||||
assert {"--cacheonly", "updateinfo", "list", "--installed", "--with-cve"} <= set(
|
||||
args.read_text().split()
|
||||
)
|
||||
assert out == "__DNF_RC=0\n"
|
||||
@@ -299,3 +299,52 @@ def test_an_account_that_cannot_log_in_is_another_services_and_left_alone(
|
||||
driver.add_service_account("netork", NETORK_KEY)
|
||||
assert not _root_commands(host)
|
||||
assert service_sudoers_rule_path(_Driver.SUDOERS_DIR, "netork") not in host.files
|
||||
|
||||
|
||||
OLD_KEY = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOldNetork netork@central"
|
||||
|
||||
|
||||
def test_a_replaced_key_goes_once_the_new_one_is_in(host: _ServiceHost, driver: _Driver) -> None:
|
||||
host.login = "netork"
|
||||
host.accounts["netork"] = _Account(900, "/home/netork", groups=["netork"])
|
||||
host.files["/home/netork/.ssh/authorized_keys"] = f"{OWN_KEY}\n{OLD_KEY}\n"
|
||||
|
||||
result = driver.add_service_account("netork", NETORK_KEY, replaces=[OLD_KEY])
|
||||
|
||||
assert result["success"], result["output"]
|
||||
assert [s["step"] for s in result["steps"]] == ["account", "sudo", "keys", "old keys"]
|
||||
assert host.files["/home/netork/.ssh/authorized_keys"] == f"{OWN_KEY}\n{NETORK_KEY}\n"
|
||||
|
||||
|
||||
def test_the_new_key_is_never_one_that_goes(host: _ServiceHost, driver: _Driver) -> None:
|
||||
host.login = "netork"
|
||||
host.accounts["netork"] = _Account(900, "/home/netork", groups=["netork"])
|
||||
host.files["/home/netork/.ssh/authorized_keys"] = f"{NETORK_KEY}\n"
|
||||
|
||||
result = driver.add_service_account(
|
||||
"netork", NETORK_KEY, replaces=[f"{NETORK_KEY.split()[0]} {NETORK_KEY.split()[1]}"]
|
||||
)
|
||||
|
||||
assert result["success"], result["output"]
|
||||
assert [s["step"] for s in result["steps"]] == ["account", "sudo", "keys"]
|
||||
assert host.files["/home/netork/.ssh/authorized_keys"] == f"{NETORK_KEY}\n"
|
||||
|
||||
|
||||
def test_a_replaced_key_stays_while_the_new_one_is_not_in(
|
||||
host: _ServiceHost, driver: _Driver
|
||||
) -> None:
|
||||
host.login = "netork"
|
||||
host.accounts["netork"] = _Account(900, "/home/netork", groups=["netork"])
|
||||
host.files["/home/netork/.ssh/authorized_keys"] = f"{OLD_KEY}\n"
|
||||
host.failing.add("as install")
|
||||
|
||||
result = driver.add_service_account("netork", NETORK_KEY, replaces=[OLD_KEY])
|
||||
|
||||
assert not result["success"]
|
||||
assert "old keys" not in [s["step"] for s in result["steps"]]
|
||||
assert host.files["/home/netork/.ssh/authorized_keys"] == f"{OLD_KEY}\n"
|
||||
|
||||
|
||||
def test_replaced_keys_are_a_list_not_one_string(driver: _Driver) -> None:
|
||||
with pytest.raises(ValueError, match="list"):
|
||||
driver.add_service_account("netork", NETORK_KEY, replaces=OLD_KEY)
|
||||
@@ -14,8 +14,19 @@ from napalm_device_types import (
|
||||
UUID = "31303043-534D-C40C-7A72-6F1300000000"
|
||||
|
||||
|
||||
def _out(uuid: str, product_serial: str, board_serial: str) -> str:
|
||||
return f"IDBEGIN\n{uuid}\n{product_serial}\n{board_serial}\nIDEND\n"
|
||||
def _out(
|
||||
uuid: str,
|
||||
product_serial: str,
|
||||
board_serial: str,
|
||||
bios: tuple[str, str, str] = ("", "", ""),
|
||||
) -> str:
|
||||
vendor, version, date = bios
|
||||
return (
|
||||
f"IDBEGIN\n{uuid}\n{product_serial}\n{board_serial}\n{vendor}\n{version}\n{date}\nIDEND\n"
|
||||
)
|
||||
|
||||
|
||||
_NO_FIRMWARE = {"bios_vendor": "", "bios_version": "", "bios_date": ""}
|
||||
|
||||
|
||||
# ── parsing ───────────────────────────────────────────────────────────────────
|
||||
@@ -26,6 +37,7 @@ def test_reads_uuid_and_both_serials():
|
||||
"system_uuid": "31303043-534d-c40c-7a72-6f1300000000",
|
||||
"product_serial": "S123",
|
||||
"board_serial": "ZM155S026022",
|
||||
**_NO_FIRMWARE,
|
||||
}
|
||||
|
||||
|
||||
@@ -81,9 +93,57 @@ def test_unreadable_files_read_as_empty():
|
||||
"system_uuid": "",
|
||||
"product_serial": "",
|
||||
"board_serial": "BS1",
|
||||
**_NO_FIRMWARE,
|
||||
}
|
||||
|
||||
|
||||
# ── the system firmware ───────────────────────────────────────────────────────
|
||||
|
||||
|
||||
def test_reads_the_system_firmware():
|
||||
# pve-dual, a Supermicro X10DRL-i
|
||||
out = _out(UUID, "", "ZM155S026022", ("American Megatrends Inc.", "3.4", "11/22/2021"))
|
||||
identity = parse_system_identity(out)
|
||||
assert identity["bios_vendor"] == "American Megatrends Inc."
|
||||
assert identity["bios_version"] == "3.4"
|
||||
assert identity["bios_date"] == "2021-11-22"
|
||||
|
||||
|
||||
def test_a_virtual_machines_firmware_is_read_like_any_other():
|
||||
out = _out(UUID, "", "", ("EDK II", "4.2023.08-4", "02/15/2024"))
|
||||
assert parse_system_identity(out)["bios_version"] == "4.2023.08-4"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("version", ["1", "0", "1.0", "A"])
|
||||
def test_a_short_firmware_version_is_no_placeholder(version):
|
||||
# Serials of one repeated character are placeholders, versions are not.
|
||||
out = _out(UUID, "", "", ("Vendor", version, ""))
|
||||
assert parse_system_identity(out)["bios_version"] == version
|
||||
|
||||
|
||||
@pytest.mark.parametrize("value", ["", "To be filled by O.E.M.", "Default string", "Not Specified"])
|
||||
def test_a_placeholder_firmware_version_reads_as_empty(value):
|
||||
out = _out(UUID, "", "", (value, value, ""))
|
||||
identity = parse_system_identity(out)
|
||||
assert identity["bios_vendor"] == ""
|
||||
assert identity["bios_version"] == ""
|
||||
|
||||
|
||||
@pytest.mark.parametrize("date", ["", "not a date", "13/45/2021", "2021-11-22"])
|
||||
def test_a_firmware_date_that_is_no_smbios_date_reads_as_empty(date):
|
||||
# sysfs writes the SMBIOS date as MM/DD/YYYY; anything else is no reading of it.
|
||||
out = _out(UUID, "", "", ("Vendor", "1.2", date))
|
||||
assert parse_system_identity(out)["bios_date"] == ""
|
||||
|
||||
|
||||
def test_output_of_the_identity_alone_has_no_firmware():
|
||||
# What a host answered before the firmware was read with it: three fields.
|
||||
old = f"IDBEGIN\n{UUID}\nS1\nB1\nIDEND\n"
|
||||
identity = parse_system_identity(old)
|
||||
assert identity["board_serial"] == "B1"
|
||||
assert {k: identity[k] for k in _NO_FIRMWARE} == _NO_FIRMWARE
|
||||
|
||||
|
||||
def test_output_without_its_frame_is_not_a_reading():
|
||||
with pytest.raises(ValueError):
|
||||
parse_system_identity("sudo: a password is required\n")
|
||||
@@ -115,6 +175,13 @@ def test_the_driver_only_carries_the_command_across():
|
||||
assert privileged is True
|
||||
|
||||
|
||||
def test_the_command_reads_the_three_dmi_files():
|
||||
for name in ("product_uuid", "product_serial", "board_serial"):
|
||||
def test_the_command_reads_the_dmi_files():
|
||||
for name in (
|
||||
"product_uuid",
|
||||
"product_serial",
|
||||
"board_serial",
|
||||
"bios_vendor",
|
||||
"bios_version",
|
||||
"bios_date",
|
||||
):
|
||||
assert f"/sys/class/dmi/id/{name}" in SYSTEM_IDENTITY_COMMAND
|
||||
@@ -34,9 +34,16 @@ def test_the_shape():
|
||||
"timezone": str | None,
|
||||
"synchronized": bool | None,
|
||||
"daemon": str | None,
|
||||
"dhcp_ntp_servers": list[str] | None,
|
||||
}
|
||||
|
||||
|
||||
def test_the_dhcp_servers_are_optional():
|
||||
# A driver that cannot tell what DHCP brought leaves the key out (NetOrk/netork#2380).
|
||||
assert TimeSyncDict.__required_keys__ == {"ntp_servers", "timezone", "synchronized", "daemon"}
|
||||
assert TimeSyncDict.__optional_keys__ == {"dhcp_ntp_servers"}
|
||||
|
||||
|
||||
def test_the_two_values_a_driver_may_write():
|
||||
assert frozenset({"ntp_servers", "timezone"}) == TIME_SYNC_VALUES
|
||||
|
||||
@@ -190,6 +197,13 @@ class TestConfigureTimeSync:
|
||||
|
||||
assert Lower().configure_time_sync(["NTP1.Example.org"])["success"] is True
|
||||
|
||||
def test_servers_from_dhcp_do_not_fail_the_check(self):
|
||||
# DHCP option 42 counts: what the device got by DHCP stays and is no mistake.
|
||||
device = _Device()
|
||||
device.state["dhcp_ntp_servers"] = ["192.168.1.1"]
|
||||
result = device.configure_time_sync(["ntp1.example.org"])
|
||||
assert result["success"] is True, result["output"]
|
||||
|
||||
def test_a_device_without_a_zone_name_is_not_checked_for_one(self):
|
||||
# A switch keeps an offset and a summer-time rule, not a name: it reads None.
|
||||
result = _Device(keeps_zone_name=False).configure_time_sync(timezone="Europe/Berlin")
|
||||
|
||||
+131
-18
@@ -4,7 +4,8 @@ The reading is run by a real ``sh`` over a directory tree that stands in for the
|
||||
host, with ``timedatectl``, ``systemctl`` and ``chronyc`` replaced by scripts that
|
||||
keep a log -- so the shell itself is tested, not a hand-written copy of its output.
|
||||
``sed`` and ``install`` are the real ones, so the files the writes leave are what a
|
||||
host would get (NetOrk/netork#2361).
|
||||
host would get (NetOrk/netork#2361). Servers that DHCP brings are read apart and left
|
||||
alone by a write (NetOrk/netork#2380).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -20,6 +21,7 @@ from napalm_device_types.channel import CommandResult
|
||||
from napalm_device_types.time_sync_posix import (
|
||||
chrony_synchronized,
|
||||
parse_key_values,
|
||||
timesyncd_link_servers,
|
||||
timesyncd_servers,
|
||||
)
|
||||
|
||||
@@ -136,6 +138,7 @@ class Host(PosixTimeSyncMixin):
|
||||
self.CHRONY_CONFIGS = (str(etc / "chrony/chrony.conf"), str(etc / "chrony.conf")) # type: ignore[misc]
|
||||
self.CHRONY_SOURCES_FILE = str(etc / "chrony/sources.d/netork.sources") # type: ignore[misc]
|
||||
self.CHRONY_INCLUDE_FILE = str(etc / "chrony.d/netork.conf") # type: ignore[misc]
|
||||
self.CHRONY_DHCP_DIRS = (str(root / "run/chrony-dhcp"),) # type: ignore[misc]
|
||||
self.TIMESYNCD_DROPIN = str(etc / "systemd/timesyncd.conf.d/netork.conf") # type: ignore[misc]
|
||||
self.NTPD_CONFIGS = (str(etc / "ntpsec/ntp.conf"), str(etc / "ntp.conf")) # type: ignore[misc]
|
||||
self.OPENNTPD_CONFIGS = (str(etc / "openntpd/ntpd.conf"),) # type: ignore[misc]
|
||||
@@ -223,21 +226,43 @@ class TestParsing:
|
||||
|
||||
def test_timesyncd_uses_the_fallback_only_when_nothing_else_is_known(self):
|
||||
assert timesyncd_servers(parse_key_values(TIMESYNC_FALLBACK)) == ["ntp.ubuntu.com"]
|
||||
# runtime, then system, then link: the order timesyncd tries them in.
|
||||
# runtime, then system: the configured ones; a link's servers are DHCP's.
|
||||
assert timesyncd_servers(parse_key_values(TIMESYNC_CONFIGURED)) == [
|
||||
"ntp1.example.org",
|
||||
"ntp2.example.org",
|
||||
"192.168.1.1",
|
||||
]
|
||||
assert timesyncd_servers({}) == []
|
||||
|
||||
def test_timesyncd_does_not_fall_back_while_a_link_brings_servers(self):
|
||||
values = {"LinkNTPServers": "192.168.1.1", "FallbackNTPServers": "ntp.ubuntu.com"}
|
||||
assert timesyncd_servers(values) == []
|
||||
assert timesyncd_link_servers(values) == ["192.168.1.1"]
|
||||
|
||||
def test_timesyncd_link_servers(self):
|
||||
assert timesyncd_link_servers(parse_key_values(TIMESYNC_CONFIGURED)) == ["192.168.1.1"]
|
||||
assert timesyncd_link_servers({"LinkNTPServers": "10.0.0.1 10.0.0.1 10.0.0.2"}) == [
|
||||
"10.0.0.1",
|
||||
"10.0.0.2",
|
||||
]
|
||||
assert timesyncd_link_servers(parse_key_values(TIMESYNC_FALLBACK)) == []
|
||||
|
||||
def test_chrony_is_synchronised_while_it_has_selected_a_source(self):
|
||||
assert chrony_synchronized(CHRONYC_SYNCED) is True
|
||||
assert chrony_synchronized(CHRONYC_UNSYNCED) is False
|
||||
assert chrony_synchronized("") is None
|
||||
|
||||
def test_chrony_without_a_main_configuration_has_no_sources(self):
|
||||
assert parse_time_sync("@@ts active\nchrony chrony active\n@@ts end\n")["ntp_servers"] == []
|
||||
reading = parse_time_sync("@@ts active\nchrony chrony active\n@@ts end\n")
|
||||
assert (reading["ntp_servers"], reading["dhcp_ntp_servers"]) == ([], [])
|
||||
|
||||
def test_the_dhcp_directory_is_debian_s_and_red_hat_s_by_default(self):
|
||||
reading = parse_time_sync(
|
||||
"@@ts active\nchrony chrony active\n"
|
||||
"@@ts chrony 0 main /etc/chrony/chrony.conf\nsourcedir /run/chrony-dhcp\n"
|
||||
"@@ts chrony 1 sourcedir /run/chrony-dhcp/eth0.sources\nserver 10.0.0.1 iburst\n"
|
||||
"@@ts end\n"
|
||||
)
|
||||
assert (reading["ntp_servers"], reading["dhcp_ntp_servers"]) == ([], ["10.0.0.1"])
|
||||
|
||||
def test_a_reading_cut_short_raises(self):
|
||||
with pytest.raises(ValueError, match="cut short"):
|
||||
@@ -251,14 +276,35 @@ class TestReading:
|
||||
"ntp_servers": [
|
||||
"ntp-conf.example.org",
|
||||
"2.debian.pool.ntp.org",
|
||||
"192.168.1.1",
|
||||
"ntp-other.example.org",
|
||||
],
|
||||
"timezone": "Europe/Berlin",
|
||||
"synchronized": True,
|
||||
"daemon": "chrony",
|
||||
"dhcp_ntp_servers": ["192.168.1.1"],
|
||||
}
|
||||
|
||||
def test_dhcp_servers_in_the_order_chrony_reads_them(self, debian: Path):
|
||||
_write(debian / "run/chrony-dhcp/wlan0.sources", "server 10.9.0.1 iburst\n")
|
||||
_write(debian / "run/chrony-dhcp/eth0.sources", "server 192.168.1.1\npool p.example\n")
|
||||
assert Host(debian).get_time_sync()["dhcp_ntp_servers"] == [
|
||||
"192.168.1.1",
|
||||
"p.example",
|
||||
"10.9.0.1",
|
||||
]
|
||||
|
||||
def test_a_dhcp_directory_chrony_does_not_read_brings_nothing(self, debian: Path):
|
||||
# What 4.35.0 left behind: DHCP's sourcedir commented out.
|
||||
conf = debian / "etc/chrony/chrony.conf"
|
||||
conf.write_text(_text(conf).replace("\nsourcedir ", "\n#napalm-time-sync: sourcedir ", 1))
|
||||
reading = Host(debian).get_time_sync()
|
||||
assert reading["dhcp_ntp_servers"] == []
|
||||
assert "192.168.1.1" not in reading["ntp_servers"]
|
||||
|
||||
def test_without_a_dhcp_directory_dhcp_brings_nothing(self, root: Path):
|
||||
_write(root / "etc/chrony.conf", "pool 2.rhel.pool.ntp.org iburst\n")
|
||||
assert Host(root, active="chronyd").get_time_sync()["dhcp_ntp_servers"] == []
|
||||
|
||||
def test_the_reading_is_one_round_trip_without_root(self, debian: Path):
|
||||
host = Host(debian)
|
||||
host.get_time_sync()
|
||||
@@ -291,7 +337,8 @@ class TestReading:
|
||||
(root / "fix/timesync").write_text(TIMESYNC_CONFIGURED)
|
||||
reading = Host(root, active="systemd-timesyncd").get_time_sync()
|
||||
assert reading["daemon"] == "systemd-timesyncd"
|
||||
assert reading["ntp_servers"] == ["ntp1.example.org", "ntp2.example.org", "192.168.1.1"]
|
||||
assert reading["ntp_servers"] == ["ntp1.example.org", "ntp2.example.org"]
|
||||
assert reading["dhcp_ntp_servers"] == ["192.168.1.1"]
|
||||
assert reading["synchronized"] is True
|
||||
|
||||
def test_ntpd(self, root: Path):
|
||||
@@ -303,6 +350,8 @@ class TestReading:
|
||||
reading = Host(root, active="ntpsec").get_time_sync()
|
||||
assert reading["daemon"] == "ntpd"
|
||||
assert reading["ntp_servers"] == ["0.debian.pool.ntp.org", "ntp1.example.org"]
|
||||
# Debian's DHCP hook gives ntpd a configuration of its own: not read, so unknown.
|
||||
assert reading["dhcp_ntp_servers"] is None
|
||||
|
||||
def test_openntpd(self, root: Path):
|
||||
_write(
|
||||
@@ -312,6 +361,7 @@ class TestReading:
|
||||
reading = Host(root, active="openntpd").get_time_sync()
|
||||
assert reading["daemon"] == "openntpd"
|
||||
assert reading["ntp_servers"] == ["pool.ntp.org", "ntp1.example.org"]
|
||||
assert reading["dhcp_ntp_servers"] is None
|
||||
|
||||
def test_no_client_runs(self, root: Path):
|
||||
(root / "fix/timedatectl").write_text(
|
||||
@@ -322,6 +372,7 @@ class TestReading:
|
||||
"timezone": "Europe/Berlin",
|
||||
"synchronized": False,
|
||||
"daemon": None,
|
||||
"dhcp_ntp_servers": [],
|
||||
}
|
||||
|
||||
def test_without_timedatectl_the_zone_comes_from_the_files(self, root: Path):
|
||||
@@ -352,7 +403,8 @@ class TestChronyServers:
|
||||
)
|
||||
conf = _text(debian / "etc/chrony/chrony.conf")
|
||||
assert "\n#napalm-time-sync: pool 2.debian.pool.ntp.org iburst\n" in conf
|
||||
assert f"\n#napalm-time-sync: sourcedir {debian}/run/chrony-dhcp\n" in conf
|
||||
# DHCP option 42 counts: chrony keeps reading what DHCP brings.
|
||||
assert f"\nsourcedir {debian}/run/chrony-dhcp\n" in conf
|
||||
assert f"\nsourcedir {debian}/etc/chrony/sources.d\n" in conf
|
||||
assert f"\nconfdir {debian}/etc/chrony/conf.d\n" in conf
|
||||
assert _text(debian / "etc/chrony/conf.d/local.conf") == (
|
||||
@@ -361,15 +413,72 @@ class TestChronyServers:
|
||||
assert _text(debian / "etc/chrony/sources.d/other.sources") == (
|
||||
"#napalm-time-sync: server ntp-other.example.org\n"
|
||||
)
|
||||
# DHCP's own file is left alone: it is not read any more.
|
||||
# DHCP's own file is left alone: the DHCP client rewrites it on every lease.
|
||||
assert _text(debian / "run/chrony-dhcp/eth0.sources") == "server 192.168.1.1 iburst\n"
|
||||
# The main configuration changed: chronyd reads it only when it starts.
|
||||
assert "systemctl restart chrony.service" in host.log()
|
||||
assert host.get_time_sync()["ntp_servers"] == [
|
||||
"ntp1.example.org",
|
||||
"10.0.0.1",
|
||||
"2.de.pool.ntp.org",
|
||||
]
|
||||
reading = host.get_time_sync()
|
||||
assert reading["ntp_servers"] == ["ntp1.example.org", "10.0.0.1", "2.de.pool.ntp.org"]
|
||||
assert reading["dhcp_ntp_servers"] == ["192.168.1.1"]
|
||||
|
||||
def test_what_4_35_0_took_from_dhcp_is_given_back(self, debian: Path):
|
||||
conf = debian / "etc/chrony/chrony.conf"
|
||||
Host(debian).configure_time_sync(["ntp1.example.org"])
|
||||
# A host 4.35.0 aligned: DHCP's sourcedir commented out behind the mark.
|
||||
dhcp = f"sourcedir {debian}/run/chrony-dhcp"
|
||||
conf.write_text(_text(conf).replace(f"\n{dhcp}\n", f"\n#napalm-time-sync: {dhcp}\n"))
|
||||
assert Host(debian).get_time_sync()["dhcp_ntp_servers"] == []
|
||||
(debian / "log").unlink()
|
||||
|
||||
host = Host(debian)
|
||||
result = host.configure_time_sync(["ntp1.example.org"])
|
||||
|
||||
assert result["success"] is True, result["output"]
|
||||
assert f"\n{dhcp}\n" in _text(conf)
|
||||
assert "#napalm-time-sync: sourcedir" not in _text(conf)
|
||||
# The main configuration changed again: a restart, not a reload.
|
||||
assert "systemctl restart chrony.service" in host.log()
|
||||
assert host.get_time_sync()["dhcp_ntp_servers"] == ["192.168.1.1"]
|
||||
|
||||
def test_a_foreign_sourcedir_4_35_0_took_out_stays_out(self, debian: Path):
|
||||
conf = debian / "etc/chrony/chrony.conf"
|
||||
foreign = f"#napalm-time-sync: sourcedir {debian}/etc/chrony/extra.d"
|
||||
conf.write_text(_text(conf) + foreign + "\n")
|
||||
_write(debian / "etc/chrony/extra.d/x.sources", "server ntp-extra.example.org\n")
|
||||
|
||||
assert Host(debian).configure_time_sync(["ntp1.example.org"])["success"] is True
|
||||
assert f"\n{foreign}\n" in _text(conf)
|
||||
|
||||
def test_a_foreign_sourcedir_stays_and_its_sources_stop_counting(self, debian: Path):
|
||||
conf = debian / "etc/chrony/chrony.conf"
|
||||
conf.write_text(_text(conf) + f"sourcedir {debian}/etc/chrony/extra.d\n")
|
||||
_write(debian / "etc/chrony/extra.d/x.sources", "server ntp-extra.example.org\n")
|
||||
|
||||
host = Host(debian)
|
||||
result = host.configure_time_sync(["ntp1.example.org"])
|
||||
|
||||
assert result["success"] is True, result["output"]
|
||||
assert f"\nsourcedir {debian}/etc/chrony/extra.d\n" in _text(conf)
|
||||
assert _text(debian / "etc/chrony/extra.d/x.sources") == (
|
||||
"#napalm-time-sync: server ntp-extra.example.org\n"
|
||||
)
|
||||
assert host.get_time_sync()["ntp_servers"] == ["ntp1.example.org"]
|
||||
|
||||
def test_dhcp_is_kept_where_the_servers_go_to_a_confdir(self, root: Path):
|
||||
_write(
|
||||
root / "etc/chrony/chrony.conf",
|
||||
f"confdir {root}/etc/chrony/conf.d\npool a.pool.ntp.org\n"
|
||||
f"sourcedir {root}/run/chrony-dhcp\n",
|
||||
)
|
||||
_write(root / "run/chrony-dhcp/eth0.sources", "server 192.168.1.1 iburst\n")
|
||||
host = Host(root)
|
||||
assert host.configure_time_sync(["ntp1.example.org"])["success"] is True
|
||||
assert f"\nsourcedir {root}/run/chrony-dhcp\n" in _text(root / "etc/chrony/chrony.conf")
|
||||
reading = host.get_time_sync()
|
||||
assert (reading["ntp_servers"], reading["dhcp_ntp_servers"]) == (
|
||||
["ntp1.example.org"],
|
||||
["192.168.1.1"],
|
||||
)
|
||||
|
||||
def test_a_second_run_only_reloads_the_sources(self, debian: Path):
|
||||
Host(debian).configure_time_sync(["ntp1.example.org"])
|
||||
@@ -480,7 +589,7 @@ class TestTimesyncdServers:
|
||||
assert "systemctl restart systemd-timesyncd.service" in host.log()
|
||||
assert host.get_time_sync()["ntp_servers"] == ["ntp1.example.org", "10.0.0.1"]
|
||||
|
||||
def test_servers_from_dhcp_stay_and_the_check_says_so(self, root: Path):
|
||||
def test_servers_from_dhcp_stay_and_count(self, root: Path):
|
||||
(root / "fix/timesync").write_text(TIMESYNC_CONFIGURED)
|
||||
tool = (root / "bin/systemctl").read_text()
|
||||
(root / "bin/systemctl").write_text(
|
||||
@@ -488,11 +597,15 @@ class TestTimesyncdServers:
|
||||
"printf 'SystemNTPServers", "printf 'LinkNTPServers=192.168.1.1\\nSystemNTPServers"
|
||||
)
|
||||
)
|
||||
result = Host(root, active="systemd-timesyncd").configure_time_sync(["ntp1.example.org"])
|
||||
host = Host(root, active="systemd-timesyncd")
|
||||
result = host.configure_time_sync(["ntp1.example.org"])
|
||||
|
||||
assert result["success"] is False
|
||||
assert result["steps"][-1]["step"] == "verify"
|
||||
assert "192.168.1.1" in result["steps"][-1]["output"]
|
||||
assert result["success"] is True, result["output"]
|
||||
reading = host.get_time_sync()
|
||||
assert (reading["ntp_servers"], reading["dhcp_ntp_servers"]) == (
|
||||
["ntp1.example.org"],
|
||||
["192.168.1.1"],
|
||||
)
|
||||
|
||||
|
||||
class TestOtherClients:
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
"""The contract of :class:`~napalm_device_types.updates.UpdateMixin`."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import napalm_device_types
|
||||
from napalm_device_types.updates import PackageIndexMissing
|
||||
|
||||
|
||||
def test_a_missing_index_is_its_own_failure():
|
||||
"""A reader can tell "no index to read from" from any other failure, and a
|
||||
caller that only knows failures still catches it as one."""
|
||||
exc = PackageIndexMissing("The package index is not loaded (run apk update first)")
|
||||
|
||||
assert isinstance(exc, RuntimeError)
|
||||
assert str(exc) == "The package index is not loaded (run apk update first)"
|
||||
|
||||
|
||||
def test_it_is_exported_from_the_package():
|
||||
assert napalm_device_types.PackageIndexMissing is PackageIndexMissing
|
||||
assert "PackageIndexMissing" in napalm_device_types.__all__
|
||||
Reference in new issue
Block a user