From d142db73e544b7d405217d65df7371259032dda6 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:43:09 +0100 Subject: [PATCH 01/13] fix(sdn): restore the virtual interface prefixes for set_vlan b1ba991 removed _VIRTUAL_IFACE_PREFIXES while _is_physical_uplink still read it. The AttributeError was swallowed by _find_switch_uplink, so set_vlan never found an uplink on any node. Restore the constant and cover both helpers with tests. Closes #37 --- CHANGELOG.md | 2 ++ napalm_proxmox/sdn_mixin.py | 11 +++++++ tests/test_switch_uplink.py | 58 +++++++++++++++++++++++++++++++++++++ 3 files changed, 71 insertions(+) create mode 100644 tests/test_switch_uplink.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 63ff980..0fd0382 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -40,6 +40,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `get_ipv6_neighbors_table()` reports an unknown age as `-1.0`, as `get_arp_table()` already did (napalm-device-types' `ARP_AGE_UNKNOWN`), instead of `0.0`, which means "confirmed just now" (NetOrk/netork#1327). +- `set_vlan()` finds the node's switch uplink again. Since 0.8.0 every call failed + with "no LLDP-detected switch uplink found", whatever LLDP reported (#37). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/sdn_mixin.py b/napalm_proxmox/sdn_mixin.py index 80bd327..7568528 100644 --- a/napalm_proxmox/sdn_mixin.py +++ b/napalm_proxmox/sdn_mixin.py @@ -33,6 +33,17 @@ _JsonDict = dict[str, Any] class ProxmoxSDNMixin: """Mixin providing SDN, VLAN and network-instance NAPALM methods.""" + #: Name prefixes of Proxmox-internal and runtime virtual interfaces, never a switch uplink. + _VIRTUAL_IFACE_PREFIXES: tuple[str, ...] = ( + "fwpr", # Proxmox firewall proxy veth + "fwln", # Proxmox firewall link veth + "tap", # VM tap devices + "veth", # generic veth pairs (containers) + "virbr", # libvirt bridges + "docker", # Docker virtual interfaces + "lxcbr", # LXC bridges + ) + def _get_sdn_zones(self) -> list[_JsonDict]: try: return self._api.cluster.sdn.zones.get() or [] # type: ignore[union-attr] diff --git a/tests/test_switch_uplink.py b/tests/test_switch_uplink.py new file mode 100644 index 0000000..d33a68d --- /dev/null +++ b/tests/test_switch_uplink.py @@ -0,0 +1,58 @@ +"""The physical port set_vlan configures: _find_switch_uplink / _is_physical_uplink.""" + +from __future__ import annotations + +from unittest.mock import MagicMock + +from napalm_proxmox.sdn_mixin import ProxmoxSDNMixin + +NETWORK = [ + {"iface": "eno1", "type": "eth"}, + {"iface": "vmbr0", "type": "bridge", "bridge_ports": "eno1"}, +] + + +def _mixin(detail: dict, basic: dict) -> ProxmoxSDNMixin: + m = ProxmoxSDNMixin() + m._get_node_network = MagicMock(return_value=NETWORK) + m.get_lldp_neighbors_detail = MagicMock(return_value=detail) + m.get_lldp_neighbors = MagicMock(return_value=basic) + return m + + +class TestFindSwitchUplink: + def test_physical_port_with_a_bridge_neighbour_is_the_uplink(self): + m = _mixin( + detail={ + "tap100i0": [{"remote_system_capab": ["bridge"]}], + "eno1": [{"remote_system_capab": ["bridge", "router"]}], + }, + basic={}, + ) + assert m._find_switch_uplink() == "eno1" + + def test_basic_lldp_fallback_skips_a_virtual_port(self): + m = _mixin( + detail={}, + basic={"fwpr100p0": [{"hostname": "sw"}], "eno1": [{"hostname": "sw"}]}, + ) + assert m._find_switch_uplink() == "eno1" + + def test_no_physical_neighbour_is_none(self): + m = _mixin(detail={"tap100i0": [{"remote_system_capab": ["bridge"]}]}, basic={}) + assert m._find_switch_uplink() is None + + +class TestIsPhysicalUplink: + def test_eth_in_the_network_config_is_physical(self): + assert ProxmoxSDNMixin()._is_physical_uplink("eno1", {"eno1": {"type": "eth"}}) + + def test_virtual_prefix_is_never_physical(self): + network = {"tap100i0": {"type": ""}} + assert not ProxmoxSDNMixin()._is_physical_uplink("tap100i0", network) + + def test_port_missing_from_the_network_config_is_not_physical(self): + assert not ProxmoxSDNMixin()._is_physical_uplink("eno9", {}) + + def test_bridge_is_not_physical(self): + assert not ProxmoxSDNMixin()._is_physical_uplink("vmbr0", {"vmbr0": {"type": "bridge"}}) From 52d63eb68951391c50d21d81ece747fa6238160d Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:44:23 +0100 Subject: [PATCH 02/13] fix(snmp): let the snmpd.conf write report its exit status The write ended in `exit $s`, which ends the shell inside the braces _rc wraps around every command, so __PVE_RC was never printed and the step always failed. The write now shares the apt file writer, which ends in a test instead of exit. Closes #30 --- CHANGELOG.md | 3 +++ napalm_proxmox/system_mixin.py | 16 ++++++++-------- tests/test_fix_templates.py | 34 ++++++++++++++++++++++++++++++++++ 3 files changed, 45 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0fd0382..b6d37d0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -42,6 +42,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 means "confirmed just now" (NetOrk/netork#1327). - `set_vlan()` finds the node's switch uplink again. Since 0.8.0 every call failed with "no LLDP-detected switch uplink found", whatever LLDP reported (#37). +- `configure_snmp_agent()` completes: its "configure" step reported a failure + with empty output although `/etc/snmp/snmpd.conf` was written, so the firewall + and start steps never ran (#30). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/system_mixin.py b/napalm_proxmox/system_mixin.py index 0ce4cb6..fa8e74e 100644 --- a/napalm_proxmox/system_mixin.py +++ b/napalm_proxmox/system_mixin.py @@ -45,6 +45,8 @@ _SUBSCRIPTION_STATUS = { _PACKAGE_NAME = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_.+:~-]*$") #: What may stand in an snmpd.conf value: no whitespace, no quote, no comment. _SNMP_WORD = re.compile(r'^[^\s"#]+$') +#: The net-snmp agent's configuration file. +_SNMPD_CONF = "/etc/snmp/snmpd.conf" def _net(value: str) -> str: @@ -527,8 +529,12 @@ class ProxmoxSystemMixin: return self._step(command, done) def _write_apt_file(self, path: str, content: str) -> dict: + return self._write_root_file(path, content) + + def _write_root_file(self, path: str, content: str) -> dict: + """Write *content* to *path* as root, mode 644, through a temporary file.""" encoded = base64.b64encode(content.encode()).decode() - # No ``exit`` here: ``_rc`` reads the status after the command's braces. + # No ``exit`` here: it would end the shell before ``_rc`` reads the status. return self._step( f'umask 077 && t=$(mktemp) && echo {encoded} | base64 -d > "$t" && ' f'install -m 644 -o root -g root "$t" {shlex.quote(path)}; ' @@ -559,13 +565,7 @@ class ProxmoxSystemMixin: ) def _write_snmp_agent_config(self, settings: dict) -> dict: - encoded = base64.b64encode(render_snmpd_conf(settings).encode()).decode() - return self._step( - f'umask 077 && t=$(mktemp) && echo {encoded} | base64 -d > "$t" && ' - f'install -m 644 -o root -g root "$t" /etc/snmp/snmpd.conf; ' - 's=$?; rm -f "$t"; exit $s', - "wrote /etc/snmp/snmpd.conf", - ) + return self._write_root_file(_SNMPD_CONF, render_snmpd_conf(settings)) def _allow_snmp_sources(self, settings: dict) -> dict: sources = [_net(s) for s in settings.get("allowed_sources", [])] diff --git a/tests/test_fix_templates.py b/tests/test_fix_templates.py index f72021f..09511d5 100644 --- a/tests/test_fix_templates.py +++ b/tests/test_fix_templates.py @@ -10,6 +10,7 @@ contract's ``install_package``. Every step reads its exit status. from __future__ import annotations import re +import subprocess import pytest @@ -36,6 +37,18 @@ class _Node: return f"{out}\n__PVE_RC={rc}" if "__PVE_RC" in command else out +def _shell_driver(prelude: str) -> ProxmoxDriver: + """A driver whose node shell is a real local ``sh``, *prelude* run first.""" + + def shell(command: str) -> str: + run = subprocess.run(["sh", "-c", prelude + command], capture_output=True, text=True) + return run.stdout + + d = ProxmoxDriver("pve", "root@pam", "pw") + d._exec_ssh_command = shell + return d + + @pytest.fixture def node(): return _Node() @@ -87,6 +100,27 @@ class TestSnmpAgent: assert result["success"] is False assert not any("/etc/snmp/snmpd.conf" in c for c in node.ran) + def test_the_written_config_reports_success_through_a_real_shell(self, tmp_path): + """The configure step's own exit status must reach ``_rc`` (#30). + + ``_Node`` answers ``__PVE_RC=0`` on its own; a real ``sh`` shows whether the + wrapped command still prints it. ``install`` is a function writing to tmp_path. + """ + target = tmp_path / "snmpd.conf" + d = _shell_driver(f'install() {{ cat "$7" > {target}; }}; ') + + step = d._write_snmp_agent_config(SETTINGS) + + assert step == {"ok": True, "output": "wrote /etc/snmp/snmpd.conf"} + assert "rocommunity c0mm 10.7.224.20/32" in target.read_text() + + def test_a_refused_write_reports_failure_through_a_real_shell(self): + d = _shell_driver('install() { echo "install: read-only file system"; return 1; }; ') + + step = d._write_snmp_agent_config(SETTINGS) + + assert step == {"ok": False, "output": "install: read-only file system"} + def test_the_management_peer(self, driver): assert driver.get_management_peer() == "10.7.224.20" From 07796953496e0dfa5a3faa8f8daf5e7f6dd132e1 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:45:49 +0100 Subject: [PATCH 03/13] fix(vm-provision): pass every SSH key, one per line Proxmox's sshkeys holds one OpenSSH key per line, URL-encoded. The keys were joined with ";", so only the first one worked, and quote() kept "/" unescaped, which Proxmox's urlencoded format refuses. Closes #23 --- CHANGELOG.md | 3 ++ napalm_proxmox/vm_provision_mixin.py | 6 ++-- tests/test_vm_provision_mixin.py | 48 ++++++++++++++++++++++++++++ 3 files changed, 54 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b6d37d0..96c89c7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -45,6 +45,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `configure_snmp_agent()` completes: its "configure" step reported a failure with empty output although `/etc/snmp/snmpd.conf` was written, so the firewall and start steps never ran (#30). +- `create_vm_from_cloud_init(ssh_public_keys=...)` installs every key, one per + line, instead of only the first; a key containing `/` or `+` is no longer + refused by Proxmox (#23). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/vm_provision_mixin.py b/napalm_proxmox/vm_provision_mixin.py index 9a2d206..0d7577d 100644 --- a/napalm_proxmox/vm_provision_mixin.py +++ b/napalm_proxmox/vm_provision_mixin.py @@ -736,9 +736,9 @@ class ProxmoxVMProvisionMixin: cloud_init_args[f"ipconfig{i}"] = "ip=dhcp" if ssh_public_keys: - # URL-encode SSH keys for Proxmox API - sshkeys = ";".join(ssh_public_keys) - cloud_init_args["sshkeys"] = quote(sshkeys) + # One key per line, URL-encoded without exception: Proxmox's + # "urlencoded" format refuses an unescaped "/" or "+". + cloud_init_args["sshkeys"] = quote("\n".join(ssh_public_keys), safe="") self._node_api().qemu(vmid).config.post(**cloud_init_args) diff --git a/tests/test_vm_provision_mixin.py b/tests/test_vm_provision_mixin.py index d3d9f0d..06fbe36 100644 --- a/tests/test_vm_provision_mixin.py +++ b/tests/test_vm_provision_mixin.py @@ -1280,3 +1280,51 @@ def test_create_vm_cloudinit_drive_uses_image_storage_not_snippet_storage(): cloud_init_call = next(c for c in mock_vm.config.post.call_args_list if "ide2" in c[1]) assert cloud_init_call[1]["ide2"] == "local-zfs:cloudinit" assert cloud_init_call[1]["cicustom"].startswith("user=local:snippets/") + + +def test_create_vm_passes_every_ssh_key_one_per_line(): + """Proxmox's sshkeys is one key per line, URL-encoded (napalm-proxmox#23). + + Joined with ";", only the first key worked. Base64 keys carry "/" and "+", + which Proxmox's urlencoded format refuses unescaped. + """ + import re + from urllib.parse import unquote + + mixin = ProxmoxVMProvisionMixin() + mixin._node_name = "pve1" + mock_api = MagicMock() + mock_api.cluster.nextid.get.return_value = 110 + mock_api.storage.return_value.get.return_value = {"path": "/var/lib/vz"} + mock_node = MagicMock() + mock_node.storage.get.return_value = [ + {"storage": "local", "type": "dir", "content": "images,snippets", "enabled": 1}, + ] + mixin._api = mock_api + mixin._node_api = MagicMock(return_value=mock_node) + mixin._download_cloud_image = MagicMock(return_value="/var/lib/vz/x.qcow2") + mixin._run_node_command = MagicMock(return_value="") + mock_vm = mock_node.qemu.return_value + mock_vm.config.get.return_value = {"unused0": "local:vm-110-disk-0"} + mock_vm.status.start.post.return_value = "UPID:pve1:136:start" + mock_node.tasks.return_value.status.get.return_value = {"status": "stopped", "exitstatus": "OK"} + keys = [ + "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI/+k1 alice@example", + "ssh-rsa AAAAB3NzaC1yc2EAAAADAQAB/+k2 bob@example", + ] + + with patch("time.sleep"): + mixin.create_vm_from_cloud_init( + name="keys-vm", + image_url="https://cloud.debian.org/images/cloud/bookworm/latest/debian-12-genericcloud-amd64.qcow2", + cpu=1, + memory=512, + nics=[{"bridge": "vmbr0"}], + cloud_init_config={}, + ssh_public_keys=keys, + ) + + call = next(c for c in mock_vm.config.post.call_args_list if "sshkeys" in c[1]) + sshkeys = call[1]["sshkeys"] + assert unquote(sshkeys) == "\n".join(keys) + assert re.fullmatch(r"[-%a-zA-Z0-9_.!~*'()]*", sshkeys) From 89c70d85be165b79ee33b20c2deb5e26368f5e18 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:46:51 +0100 Subject: [PATCH 04/13] fix(lldp): keep every neighbour of a port apart lldpcli prints one Interface block per neighbour. The summary parser reused the port's last entry, so a second neighbour overwrote the first, and a neighbour without SysName was dropped. Each block now starts an entry of its own. Closes #22 --- CHANGELOG.md | 3 ++ napalm_proxmox/lldp_mixin.py | 24 ++++++------- tests/test_lldp.py | 65 ++++++++++++++++++++++++++++++++++++ 3 files changed, 80 insertions(+), 12 deletions(-) create mode 100644 tests/test_lldp.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 96c89c7..a640423 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -48,6 +48,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `create_vm_from_cloud_init(ssh_public_keys=...)` installs every key, one per line, instead of only the first; a key containing `/` or `+` is no longer refused by Proxmox (#23). +- `get_lldp_neighbors()` lists every neighbour of a port: a second neighbour on + the same port no longer overwrites the first, and a neighbour that sends no + system name is listed with an empty `hostname` instead of being dropped (#22). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/lldp_mixin.py b/napalm_proxmox/lldp_mixin.py index cd10613..c8eae80 100644 --- a/napalm_proxmox/lldp_mixin.py +++ b/napalm_proxmox/lldp_mixin.py @@ -26,26 +26,26 @@ class ProxmoxLLDPMixin: """Mixin providing LLDP NAPALM methods.""" def get_lldp_neighbors(self) -> dict[str, list[_JsonDict]]: - """Return LLDP neighbours (requires lldpd on the Proxmox node).""" + """Return LLDP neighbours (requires lldpd on the Proxmox node). + + lldpcli prints one ``Interface:`` block per neighbour, so a port with + several neighbours appears once for each of them. + """ result: dict[str, list[_JsonDict]] = {} raw = self._exec_ssh_command("lldpcli show neighbors summary 2>/dev/null || true") - current_iface = "" + current: _JsonDict | None = None for line in raw.splitlines(): m_iface = re.match(r"^\s*Interface:\s+(\S+?),?\s", line) if m_iface: - current_iface = m_iface.group(1) - result.setdefault(current_iface, []) + current = {"hostname": "", "port": ""} + result.setdefault(m_iface.group(1), []).append(current) continue m_sys = re.match(r"^\s*SysName:\s+(.+)", line) m_port = re.match(r"^\s*PortID:\s+\S+\s+(.+)", line) - if m_sys and current_iface: - hostname = m_sys.group(1).strip() - if result[current_iface]: - result[current_iface][-1]["hostname"] = hostname - else: - result[current_iface].append({"hostname": hostname, "port": ""}) - if m_port and current_iface and result[current_iface]: - result[current_iface][-1]["port"] = m_port.group(1).strip() + if m_sys and current is not None: + current["hostname"] = m_sys.group(1).strip() + if m_port and current is not None: + current["port"] = m_port.group(1).strip() return result def get_lldp_neighbors_detail(self, interface: str = "") -> dict[str, list[_JsonDict]]: diff --git a/tests/test_lldp.py b/tests/test_lldp.py new file mode 100644 index 0000000..f48ab62 --- /dev/null +++ b/tests/test_lldp.py @@ -0,0 +1,65 @@ +"""LLDP neighbours read from lldpd's ``lldpcli show neighbors``.""" + +from __future__ import annotations + +from napalm_proxmox import ProxmoxDriver + +# lldpd 1.0 output: one "Interface:" block per neighbour, so a port with two +# neighbours (a switch and a phone behind it) appears twice. The phone sends +# no SysName. +TWO_NEIGHBOURS_ON_ONE_PORT = """\ +------------------------------------------------------------------------------- +LLDP neighbors: +------------------------------------------------------------------------------- +Interface: eno1, via: LLDP, RID: 1, Time: 0 day, 00:10:12 + Chassis: + ChassisID: mac 00:11:22:33:44:55 + SysName: sw1 + Port: + PortID: ifname gi1/0/1 + PortDescr: GigabitEthernet1/0/1 +------------------------------------------------------------------------------- +Interface: eno1, via: LLDP, RID: 2, Time: 0 day, 00:01:02 + Chassis: + ChassisID: mac aa:bb:cc:dd:ee:ff + Port: + PortID: mac aa:bb:cc:dd:ee:ff +------------------------------------------------------------------------------- +Interface: eno2, via: LLDP, RID: 3, Time: 0 day, 00:10:12 + Chassis: + ChassisID: mac 00:11:22:33:44:66 + SysName: sw2 + Port: + PortID: ifname gi1/0/2 +------------------------------------------------------------------------------- +""" + + +def _driver(output: str) -> ProxmoxDriver: + d = ProxmoxDriver("pve", "root@pam", "pw") + d._exec_ssh_command = lambda command: output + return d + + +class TestGetLldpNeighbors: + def test_every_neighbour_on_a_port_is_its_own_entry(self): + result = _driver(TWO_NEIGHBOURS_ON_ONE_PORT).get_lldp_neighbors() + + assert result == { + "eno1": [ + {"hostname": "sw1", "port": "gi1/0/1"}, + {"hostname": "", "port": "aa:bb:cc:dd:ee:ff"}, + ], + "eno2": [{"hostname": "sw2", "port": "gi1/0/2"}], + } + + def test_no_lldpd_output_is_no_neighbour(self): + assert _driver("").get_lldp_neighbors() == {} + + +class TestGetLldpNeighborsDetail: + def test_every_neighbour_on_a_port_is_its_own_entry(self): + result = _driver(TWO_NEIGHBOURS_ON_ONE_PORT).get_lldp_neighbors_detail() + + assert [e["remote_system_name"] for e in result["eno1"]] == ["sw1", ""] + assert result["eno1"][1]["remote_chassis_id"] == "aa:bb:cc:dd:ee:ff" From 8f10bef7c5599ed810b39411a384c9a62e3d1344 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:47:59 +0100 Subject: [PATCH 05/13] fix(hostname): rename only the node's own names in /etc/hosts The rename replaced \b\b, which also matches before "." and "-": "pve.old.lan pve" became "new.dom.old.lan new.dom" and "pve-backup" became "new-backup". Whole whitespace-separated names are renamed now, comments left alone. The live move of /etc/pve/nodes/ the issue also asks about is not changed here; it needs a decision on clustered nodes. Refs #21 --- CHANGELOG.md | 3 ++ napalm_proxmox/system_mixin.py | 36 +++++++++++------ tests/quality_baseline.json | 2 +- tests/test_set_hostname.py | 72 ++++++++++++++++++++++++++++++++++ 4 files changed, 101 insertions(+), 12 deletions(-) create mode 100644 tests/test_set_hostname.py diff --git a/CHANGELOG.md b/CHANGELOG.md index a640423..cd9e856 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -51,6 +51,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `get_lldp_neighbors()` lists every neighbour of a port: a second neighbour on the same port no longer overwrites the first, and a neighbour that sends no system name is listed with an empty `hostname` instead of being dropped (#22). +- `set_hostname()` renames only the node's own names in `/etc/hosts`: other + hosts whose names start with the old one (`pve-backup`) and comments stay as + they are, and the old FQDN becomes the new one instead of a mix of both (#21). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/system_mixin.py b/napalm_proxmox/system_mixin.py index fa8e74e..7f63931 100644 --- a/napalm_proxmox/system_mixin.py +++ b/napalm_proxmox/system_mixin.py @@ -49,6 +49,30 @@ _SNMP_WORD = re.compile(r'^[^\s"#]+$') _SNMPD_CONF = "/etc/snmp/snmpd.conf" +def _rename_in_hosts(hosts: str, old_short: str, new_short: str, new_domain: str | None) -> str: + """*hosts* (an /etc/hosts) with the node's names renamed from *old_short*. + + Only whole names change: ``old_short`` becomes ``new_short``, and + ``old_short.`` becomes ``new_short.`` (the old domain + kept when *new_domain* is None). Other names that merely start with the + old name (``pve-backup``) and comments stay as they are. + """ + + def rename(match: re.Match[str]) -> str: + name = match.group(0) + if name == old_short: + return new_short + if name.startswith(f"{old_short}."): + return f"{new_short}.{new_domain or name[len(old_short) + 1 :]}" + return name + + lines = [] + for line in hosts.splitlines(keepends=True): + entry, hash_, comment = line.partition("#") + lines.append(re.sub(r"\S+", rename, entry) + hash_ + comment) + return "".join(lines) + + def _net(value: str) -> str: return str(ipaddress.ip_network(value.strip(), strict=False)) @@ -633,17 +657,7 @@ class ProxmoxSystemMixin: # write back via base64 to avoid shell-escaping issues. if old_short and old_short != short_hostname: hosts_raw = self._exec_ssh_command("cat /etc/hosts 2>/dev/null") - # Replace whole-word occurrences of the old short hostname. - # Both "hostname" and "hostname.domain" forms are covered because - # the new value is the full fqdn when a domain was given. - import re as _re - - new_replace = fqdn if domain else short_hostname - hosts_new = _re.sub( - r"\b" + _re.escape(old_short) + r"\b", - new_replace, - hosts_raw, - ) + hosts_new = _rename_in_hosts(hosts_raw, old_short, short_hostname, domain) hosts_b64 = _b64.b64encode(hosts_new.encode()).decode() self._exec_ssh_command( f"echo {hosts_b64} | base64 -d > /tmp/_netork_hosts" diff --git a/tests/quality_baseline.json b/tests/quality_baseline.json index 75fd5b4..17d19e2 100644 --- a/tests/quality_baseline.json +++ b/tests/quality_baseline.json @@ -36,7 +36,7 @@ "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.get_disk_smart": 74, "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.get_packages": 66, "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.get_users": 51, - "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.set_hostname": 124, + "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.set_hostname": 114, "napalm_proxmox/vm_mixin.py::ProxmoxVMMixin.get_vm_interfaces": 179, "napalm_proxmox/vm_mixin.py::ProxmoxVMMixin.get_vms": 114, "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin._download_cloud_image": 61, diff --git a/tests/test_set_hostname.py b/tests/test_set_hostname.py new file mode 100644 index 0000000..cc59e31 --- /dev/null +++ b/tests/test_set_hostname.py @@ -0,0 +1,72 @@ +"""set_hostname: what it writes to /etc/hosts (napalm-proxmox#21).""" + +from __future__ import annotations + +import base64 +import re + +import pytest + +from napalm_proxmox import ProxmoxDriver + +HOSTS = """\ +127.0.0.1 localhost.localdomain localhost +# pve is the node; pve-backup its backup target +10.0.0.1 pve.old.lan pve +10.0.0.2 pve-backup.old.lan pve-backup +""" + + +class _Node: + """The node's shell: /etc/hostname reads "pve", /etc/hosts reads HOSTS.""" + + def __init__(self) -> None: + self.ran: list[str] = [] + + def __call__(self, command: str) -> str: + self.ran.append(command) + if command.startswith("cat /etc/hostname"): + return "pve\n" + if command.startswith("cat /etc/hosts"): + return HOSTS + return "" + + def written_hosts(self) -> str: + write = next(c for c in self.ran if c.rstrip().endswith("chmod 644 /etc/hosts")) + return base64.b64decode(re.match(r"echo (\S+) \| base64 -d", write).group(1)).decode() + + +@pytest.fixture +def node() -> _Node: + return _Node() + + +@pytest.fixture +def driver(node: _Node) -> ProxmoxDriver: + d = ProxmoxDriver("pve", "root@pam", "pw") + d._exec_ssh_command = node + return d + + +def test_an_fqdn_renames_the_nodes_names_and_nothing_else(driver, node): + driver.set_hostname("new.dom.lan") + + assert node.written_hosts() == ( + "127.0.0.1 localhost.localdomain localhost\n" + "# pve is the node; pve-backup its backup target\n" + "10.0.0.1 new.dom.lan new\n" + "10.0.0.2 pve-backup.old.lan pve-backup\n" + ) + + +def test_a_short_name_keeps_the_old_domain(driver, node): + driver.set_hostname("new") + + assert "10.0.0.1 new.old.lan new\n" in node.written_hosts() + assert "10.0.0.2 pve-backup.old.lan pve-backup\n" in node.written_hosts() + + +def test_the_same_name_leaves_hosts_alone(driver, node): + driver.set_hostname("pve") + + assert not any("/etc/hosts" in c and "base64 -d" in c for c in node.ran) From 037a725b746c04730a410a81c808010605bc0e72 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:48:48 +0100 Subject: [PATCH 06/13] fix(updates): report a failed apply_updates as a failure apt-get ran with "|| true" and the result was always success, so a failed upgrade read as done. The exit status is read now and a failure names it. Closes #20 --- CHANGELOG.md | 2 ++ napalm_proxmox/system_mixin.py | 14 ++++++++++---- tests/test_updates.py | 29 +++++++++++++++++++++++++++++ 3 files changed, 41 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cd9e856..b40655f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -54,6 +54,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `set_hostname()` renames only the node's own names in `/etc/hosts`: other hosts whose names start with the old one (`pve-backup`) and comments stay as they are, and the old FQDN becomes the new one instead of a mix of both (#21). +- `apply_updates()` reports a failed upgrade as `success: False`, with apt-get's + exit status in `error`; it reported success whatever apt-get did (#20). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/system_mixin.py b/napalm_proxmox/system_mixin.py index 7f63931..53ea748 100644 --- a/napalm_proxmox/system_mixin.py +++ b/napalm_proxmox/system_mixin.py @@ -474,11 +474,17 @@ class ProxmoxSystemMixin: if not re.match(r"^[a-zA-Z0-9_\-\+\.]+$", pkg): raise ValueError(f"Invalid package name: {pkg!r}") pkg_args = " ".join(packages) - output = self._exec_ssh_command( - "DEBIAN_FRONTEND=noninteractive apt-get install --only-upgrade -y " - f"{pkg_args} 2>&1 || true" + output, status = self._rc( + f"DEBIAN_FRONTEND=noninteractive apt-get install --only-upgrade -y {pkg_args}" ) - return {"success": True, "output": output} + if status == 0: + return {"success": True, "output": output} + error = ( + f"apt-get exited with status {status}" + if status >= 0 + else "apt-get's exit status could not be read" + ) + return {"success": False, "output": output, "error": error} # ------------------------------------------------------------------ # # SNMP / Health diff --git a/tests/test_updates.py b/tests/test_updates.py index 1ca67d5..41cac64 100644 --- a/tests/test_updates.py +++ b/tests/test_updates.py @@ -104,6 +104,35 @@ class TestRefresh: assert result == {"success": False, "output": "403 Permission check failed"} +class TestApplyUpdates: + def test_a_clean_upgrade_succeeds(self, driver): + with patch.object(driver, "_exec_ssh_command", return_value="Done.\n__PVE_RC=0") as exec_: + result = driver.apply_updates(["curl"]) + + assert "apt-get install --only-upgrade -y curl" in exec_.call_args[0][0] + assert result == {"success": True, "output": "Done."} + + def test_a_failed_upgrade_is_a_failure(self, driver): + out = "E: Could not get lock /var/lib/dpkg/lock-frontend\n__PVE_RC=100" + with patch.object(driver, "_exec_ssh_command", return_value=out): + result = driver.apply_updates(["curl"]) + + assert result["success"] is False + assert result["output"] == "E: Could not get lock /var/lib/dpkg/lock-frontend" + assert result["error"] == "apt-get exited with status 100" + + def test_an_unread_exit_status_is_no_success(self, driver): + with patch.object(driver, "_exec_ssh_command", return_value=""): + result = driver.apply_updates(["curl"]) + + assert result["success"] is False + assert result["error"] == "apt-get's exit status could not be read" + + def test_a_name_that_is_no_package_name_is_refused(self, driver): + with pytest.raises(ValueError): + driver.apply_updates(["curl;reboot"]) + + class TestHostStatus: def test_the_node_is_read_over_the_exec_path(self, driver): report = ( From 4ee74e4b3d904e0a549dee31854e351dfdfac183 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:50:16 +0100 Subject: [PATCH 07/13] fix(users): list real login accounts and read admins from the ACL The passwd filter's precedence was inverted: it listed uid < 1000 (daemon, bin, ...) and skipped regular users. The level check looked for "Administrator" in the user record, which never names roles. The level now comes from /access/acl (Administrator on /, by user or group), root@pam always 15. Closes #19 --- CHANGELOG.md | 5 ++ napalm_proxmox/system_mixin.py | 111 +++++++++++++++++++++------------ tests/quality_baseline.json | 2 - tests/test_users.py | 66 ++++++++++++++++++++ 4 files changed, 142 insertions(+), 42 deletions(-) create mode 100644 tests/test_users.py diff --git a/CHANGELOG.md b/CHANGELOG.md index b40655f..ca4f96b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -56,6 +56,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 they are, and the old FQDN becomes the new one instead of a mix of both (#21). - `apply_updates()` reports a failed upgrade as `success: False`, with apt-get's exit status in `error`; it reported success whatever apt-get did (#20). +- `get_users()` lists the node's root and regular login accounts (uid 1000 and + up) instead of its system accounts (`daemon`, `bin`, …), and gives a Proxmox + user level 15 when the ACL grants it the Administrator role on `/`, directly + or through a group; `root@pam` is always 15. Before, practically every + Proxmox user was level 1 (#19). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/system_mixin.py b/napalm_proxmox/system_mixin.py index 53ea748..a1903ba 100644 --- a/napalm_proxmox/system_mixin.py +++ b/napalm_proxmox/system_mixin.py @@ -73,6 +73,40 @@ def _rename_in_hosts(hosts: str, old_short: str, new_short: str, new_domain: str return "".join(lines) +#: Proxmox's superuser, whatever the ACL says. +_PVE_SUPERUSER = "root@pam" +#: The role that makes a Proxmox user an administrator of the node. +_PVE_ADMIN_ROLE = "Administrator" +#: Regular login accounts: Debian gives them uids from 1000 up; 65534 is nobody. +_FIRST_REGULAR_UID = 1000 +_NOBODY_UID = 65534 + + +def _words(value: Any, sep: str | None = None) -> list[str]: + return [w.strip() for w in str(value or "").split(sep) if w.strip()] + + +def _user_entry(level: int) -> _JsonDict: + # NAPALM's get_users shape; the password is never read. + return {"level": level, "password": "", "sshkeys": []} # nosec B105 + + +def _login_accounts(passwd: str) -> list[tuple[str, int]]: + """``(name, uid)`` of root and every regular account in *passwd*.""" + accounts = [] + for line in passwd.splitlines(): + parts = line.split(":") + if len(parts) < 7: + continue + try: + uid = int(parts[2]) + except ValueError: + continue + if uid == 0 or _FIRST_REGULAR_UID <= uid < _NOBODY_UID: + accounts.append((parts[0], uid)) + return accounts + + def _net(value: str) -> str: return str(ipaddress.ip_network(value.strip(), strict=False)) @@ -239,55 +273,52 @@ class ProxmoxSystemMixin: def get_users(self) -> dict[str, _JsonDict]: """Return users configured on the Proxmox node. - Reads from both the Proxmox access/users API and local /etc/passwd. + Proxmox's own users (``/access/users``) at level 15 when they hold the + Administrator role on the whole datacenter (``/``), directly or through + a group, 1 otherwise; ``root@pam`` is always 15. Then the node's login + accounts from the passwd database: root (15) and regular users + (uid 1000 and up, without ``nobody``) at 0; system accounts are left out. """ result: dict[str, _JsonDict] = {} - try: - pve_users = self._api.access.users.get() or [] # type: ignore[union-attr] - except Exception as exc: - logger.debug("Failed to fetch Proxmox users: %s", exc) - pve_users = [] - - for user in pve_users: + admins, admin_groups = self._pve_administrators() + for user in self._pve_users(): uid = user.get("userid", "") if not uid: continue - # Proxmox roles: Administrator -> 15, otherwise 1 - level = 1 - try: - roles = self._api.access.users(uid).get() or {} # type: ignore[union-attr] - if "Administrator" in str(roles): - level = 15 - except Exception as exc: - logger.debug("Failed to fetch roles for user %s: %s", uid, exc) - result[uid] = { - "level": level, - # NAPALM's get_users shape; the password is never read. - "password": "", # nosec B105 - "sshkeys": [], - } + groups = set(_words(user.get("groups"), sep=",")) + is_admin = uid == _PVE_SUPERUSER or uid in admins or bool(groups & admin_groups) + result[uid] = _user_entry(15 if is_admin else 1) - # Merge local OS users from /etc/passwd raw = self._exec_ssh_command("getent passwd 2>/dev/null || cat /etc/passwd") - for line in raw.splitlines(): - parts = line.split(":") - if len(parts) < 7: - continue - uname, _, uid_str, *_ = parts - try: - uid_int = int(uid_str) - except ValueError: - continue - if uname not in result and uid_int < 1000 or uid_int == 0: - result[uname] = { - "level": 15 if uid_int == 0 else 0, - # NAPALM's get_users shape; the password is never read. - "password": "", # nosec B105 - "sshkeys": [], - } - + for uname, uid_int in _login_accounts(raw): + result.setdefault(uname, _user_entry(15 if uid_int == 0 else 0)) return result + def _pve_users(self) -> list[_JsonDict]: + try: + return self._api.access.users.get() or [] # type: ignore[union-attr] + except Exception as exc: + logger.debug("Failed to fetch Proxmox users: %s", exc) + return [] + + def _pve_administrators(self) -> tuple[set[str], set[str]]: + """Users and groups holding the Administrator role on ``/`` (``/access/acl``).""" + try: + acl = self._api.access.acl.get() or [] # type: ignore[union-attr] + except Exception as exc: + logger.debug("Failed to fetch the Proxmox ACL: %s", exc) + acl = [] + users: set[str] = set() + groups: set[str] = set() + for entry in acl: + if entry.get("path") != "/" or entry.get("roleid") != _PVE_ADMIN_ROLE: + continue + if entry.get("type") == "user": + users.add(entry.get("ugid", "")) + elif entry.get("type") == "group": + groups.add(entry.get("ugid", "")) + return users, groups + # ------------------------------------------------------------------ # # Kernel facts (KernelFactsMixin supplies get_kernel_facts) # ------------------------------------------------------------------ # diff --git a/tests/quality_baseline.json b/tests/quality_baseline.json index 17d19e2..ef77295 100644 --- a/tests/quality_baseline.json +++ b/tests/quality_baseline.json @@ -16,7 +16,6 @@ "napalm_proxmox/sdn_mixin.py::ProxmoxSDNMixin.set_vlan": 13, "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.get_disk_smart": 22, "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.get_packages": 16, - "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.get_users": 15, "napalm_proxmox/utils.py::addresses_from_node_network": 15, "napalm_proxmox/vm_contract_mixin.py::parse_vm_config": 16, "napalm_proxmox/vm_mixin.py::ProxmoxVMMixin._get_vm_disk_and_boot": 16, @@ -35,7 +34,6 @@ "napalm_proxmox/sdn_mixin.py::ProxmoxSDNMixin.set_vlan": 70, "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.get_disk_smart": 74, "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.get_packages": 66, - "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.get_users": 51, "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.set_hostname": 114, "napalm_proxmox/vm_mixin.py::ProxmoxVMMixin.get_vm_interfaces": 179, "napalm_proxmox/vm_mixin.py::ProxmoxVMMixin.get_vms": 114, diff --git a/tests/test_users.py b/tests/test_users.py new file mode 100644 index 0000000..c178fd7 --- /dev/null +++ b/tests/test_users.py @@ -0,0 +1,66 @@ +"""get_users: Proxmox users with their level, and the node's login accounts (#19).""" + +from __future__ import annotations + +from unittest.mock import patch + +PASSWD = """\ +root:x:0:0:root:/root:/bin/bash +daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin +bin:x:2:2:bin:/bin:/usr/sbin/nologin +www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin +alice:x:1000:1000:Alice:/home/alice:/bin/bash +nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin +""" + +# GET /access/acl: who holds which role where. +ACL = [ + {"path": "/", "roleid": "Administrator", "type": "user", "ugid": "admin@pve", "propagate": 1}, + {"path": "/", "roleid": "Administrator", "type": "group", "ugid": "ops", "propagate": 1}, + {"path": "/vms/100", "roleid": "Administrator", "type": "user", "ugid": "vm@pve"}, + {"path": "/", "roleid": "PVEAuditor", "type": "user", "ugid": "audit@pve", "propagate": 1}, +] + +USERS = [ + {"userid": "root@pam", "groups": ""}, + {"userid": "admin@pve", "groups": ""}, + {"userid": "bob@pve", "groups": "ops,dev"}, + {"userid": "vm@pve", "groups": ""}, + {"userid": "audit@pve", "groups": ""}, +] + + +def _users(driver, passwd=PASSWD): + driver._api.access.users.get.return_value = USERS + driver._api.access.acl.get.return_value = ACL + with patch.object(driver, "_exec_ssh_command", return_value=passwd): + return driver.get_users() + + +class TestLocalAccounts: + def test_root_and_real_users_not_system_accounts(self, driver): + result = _users(driver) + + assert result["root"]["level"] == 15 + assert "alice" in result + for system in ("daemon", "bin", "www-data", "nobody"): + assert system not in result + + +class TestProxmoxUsers: + def test_administrator_on_the_whole_datacenter_is_level_15(self, driver): + result = _users(driver) + + assert result["admin@pve"]["level"] == 15 + + def test_administrator_through_a_group_is_level_15(self, driver): + assert _users(driver)["bob@pve"]["level"] == 15 + + def test_root_at_pam_is_always_level_15(self, driver): + assert _users(driver)["root@pam"]["level"] == 15 + + def test_another_role_or_a_narrower_path_is_level_1(self, driver): + result = _users(driver) + + assert result["audit@pve"]["level"] == 1 + assert result["vm@pve"]["level"] == 1 From 5195cebfcabd0a4b8ee7a1f07b997e690bd5bb61 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:52:03 +0100 Subject: [PATCH 08/13] fix(ntp): read chrony's sources in get_ntp_stats The getter ran "chronyc tracking || ntpq -pn" and parsed ntpq's format. Proxmox VE ships chrony, so ntpq never ran and nothing matched. chrony is now read in CSV mode (sources plus sourcestats); ntpq stays the fallback and keeps peers without a tally mark. Closes #18 --- CHANGELOG.md | 4 ++ napalm_proxmox/ntp.py | 113 +++++++++++++++++++++++++++++++++ napalm_proxmox/system_mixin.py | 34 ++-------- tests/test_ntp_stats.py | 86 +++++++++++++++++++++++++ 4 files changed, 207 insertions(+), 30 deletions(-) create mode 100644 napalm_proxmox/ntp.py create mode 100644 tests/test_ntp_stats.py diff --git a/CHANGELOG.md b/CHANGELOG.md index ca4f96b..e3845bf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -61,6 +61,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 user level 15 when the ACL grants it the Administrator role on `/`, directly or through a group; `root@pam` is always 15. Before, practically every Proxmox user was level 1 (#19). +- `get_ntp_stats()` reports chrony's sources, Proxmox VE's default, instead of + always returning an empty list: offset in ms, the poll interval in seconds, + the offset's standard deviation as `jitter`; chrony reports no delay, so + `delay` is 0.0. On ntpd, a peer without tally mark is no longer dropped (#18). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/ntp.py b/napalm_proxmox/ntp.py new file mode 100644 index 0000000..c795dd8 --- /dev/null +++ b/napalm_proxmox/ntp.py @@ -0,0 +1,113 @@ +"""NTP statistics (``get_ntp_stats``) from chrony or ntpd, in NAPALM's NTPStats shape. + +Proxmox VE ships chrony; ntpd is read only where chrony is not installed. +chrony is read in its CSV mode (``chronyc -c``): ``sources`` names each source +with its state, ``sourcestats`` adds the spread of its offset, reported as +jitter. chrony reports no delay per source, so ``delay`` is 0.0. Times are in +milliseconds and the poll interval in seconds, as ``ntpq -pn`` gives them. +""" + +from __future__ import annotations + +import re +from typing import Any + +CHRONY_SOURCES_MARK = "CHRONY_SOURCES" +CHRONY_SOURCESTATS_MARK = "CHRONY_SOURCESTATS" + +#: chrony when it is installed, ntpd's ntpq otherwise. +NTP_STATS_COMMAND = ( + "if command -v chronyc >/dev/null 2>&1; then " + f"echo {CHRONY_SOURCES_MARK}; chronyc -n -c sources; " + f"echo {CHRONY_SOURCESTATS_MARK}; chronyc -n -c sourcestats; " + "else ntpq -pn; fi 2>/dev/null" +) + +#: chrony's source mode as ntpq's type: server (unicast), peer (symmetric), refclock (local). +_CHRONY_TYPES = {"^": "u", "=": "s", "#": "l"} +_MS_PER_S = 1000.0 + +#: ``*192.168.1.1 10.0.0.1 4 u 12 64 377 1.234 0.567 0.123``; the first +#: column is the tally mark, a space for a peer without one. +_NTPQ_LINE = re.compile( + r"^([ *+#ox.-])(\S+)\s+(\S+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(\d+)\s+(\d+)" + r"\s+([-\d.]+)\s+([-\d.]+)\s+([-\d.]+)" +) + + +def parse_ntp_stats(output: str) -> list[dict[str, Any]]: + """The NTPStats list in the output of :data:`NTP_STATS_COMMAND`.""" + if output.lstrip().startswith(CHRONY_SOURCES_MARK): + return parse_chrony(output) + return parse_ntpq(output) + + +def parse_chrony(output: str) -> list[dict[str, Any]]: + """Sources and their statistics from ``chronyc -n -c sources`` / ``sourcestats``.""" + sources, _, sourcestats = output.partition(CHRONY_SOURCESTATS_MARK) + jitter = _chrony_jitter(sourcestats) + stats = [] + for line in sources.splitlines(): + fields = line.strip().split(",") + if len(fields) < 10: + continue + mode, state, name, stratum, poll, reach, last_rx, _, offset, _ = fields[:10] + try: + stats.append( + { + "remote": name, + "referenceid": "", + "synchronized": state == "*", + "stratum": int(stratum), + "type": _CHRONY_TYPES.get(mode, ""), + "when": last_rx, + "hostpoll": 2 ** int(poll), + "reachability": int(reach), + "delay": 0.0, + "offset": float(offset) * _MS_PER_S, + "jitter": jitter.get(name, 0.0), + } + ) + except ValueError: + continue + return stats + + +def _chrony_jitter(sourcestats: str) -> dict[str, float]: + """Each source's offset standard deviation in ms (``sourcestats``' last column).""" + jitter = {} + for line in sourcestats.splitlines(): + fields = line.strip().split(",") + if len(fields) < 8: + continue + try: + jitter[fields[0]] = float(fields[7]) * _MS_PER_S + except ValueError: + continue + return jitter + + +def parse_ntpq(output: str) -> list[dict[str, Any]]: + """Peers from ``ntpq -pn``.""" + stats = [] + for line in output.splitlines(): + m = _NTPQ_LINE.match(line) + if not m: + continue + tally, remote, refid, stratum, kind, when, poll, reach, delay, offset, jitter = m.groups() + stats.append( + { + "remote": remote, + "referenceid": refid, + "synchronized": tally == "*", + "stratum": int(stratum), + "type": kind, + "when": when, + "hostpoll": int(poll), + "reachability": int(reach), + "delay": float(delay), + "offset": float(offset), + "jitter": float(jitter), + } + ) + return stats diff --git a/napalm_proxmox/system_mixin.py b/napalm_proxmox/system_mixin.py index a1903ba..669f078 100644 --- a/napalm_proxmox/system_mixin.py +++ b/napalm_proxmox/system_mixin.py @@ -28,6 +28,8 @@ from typing import Any from napalm_device_types import APT_UPGRADABLE_COMMAND, parse_apt_upgradable +from napalm_proxmox.ntp import NTP_STATS_COMMAND, parse_ntp_stats + logger = logging.getLogger(__name__) _JsonDict = dict[str, Any] @@ -197,36 +199,8 @@ class ProxmoxSystemMixin: return servers def get_ntp_stats(self) -> list[_JsonDict]: - """Return NTP synchronisation statistics from chronyc/ntpq output.""" - raw = self._exec_ssh_command( - "chronyc -n tracking 2>/dev/null || ntpq -pn 2>/dev/null || true" - ) - stats: list[_JsonDict] = [] - for line in raw.splitlines(): - line = line.strip() - # ntpq -pn format: *remote refid st t when poll reach delay offset jitter - m = re.match( - r"^([\*\+\-\s])([\d.]+)\s+([\d.]+)\s+(\d+)\s+\S+\s+(\S+)\s+(\d+)\s+(\d+)\s+([\d.]+)\s+([-\d.]+)\s+([\d.]+)", - line, - ) - if m: - synced = m.group(1).strip() == "*" - stats.append( - { - "remote": m.group(2), - "referenceid": m.group(3), - "synchronized": synced, - "stratum": int(m.group(4)), - "type": "", - "when": m.group(5), - "hostpoll": int(m.group(6)), - "reachability": int(m.group(7)), - "delay": float(m.group(8)), - "offset": float(m.group(9)), - "jitter": float(m.group(10)), - } - ) - return stats + """Return NTP synchronisation statistics from chrony, or ntpd where chrony is missing.""" + return parse_ntp_stats(self._exec_ssh_command(NTP_STATS_COMMAND)) # ------------------------------------------------------------------ # # get_snmp_information diff --git a/tests/test_ntp_stats.py b/tests/test_ntp_stats.py new file mode 100644 index 0000000..6f41a28 --- /dev/null +++ b/tests/test_ntp_stats.py @@ -0,0 +1,86 @@ +"""get_ntp_stats on chrony (Proxmox VE's default) and on ntpd (#18).""" + +from __future__ import annotations + +from unittest.mock import patch + +import pytest + +# chrony 4.x, ``chronyc -n -c sources`` then ``chronyc -n -c sourcestats``, +# behind the markers the driver's command prints. +CHRONY = """\ +CHRONY_SOURCES +^,*,192.168.1.1,2,6,377,8,-0.000012345,-0.000013000,0.012345678 +^,+,10.0.0.2,3,10,17,301,0.000250000,0.000251000,0.020000000 +^,?,10.0.0.3,0,6,0,-,0.000000000,0.000000000,0.000000000 +CHRONY_SOURCESTATS +192.168.1.1,10,6,320,-0.012,0.150,-0.000001234,0.000045678 +10.0.0.2,6,4,1200,0.003,0.400,0.000200000,0.000500000 +""" + +# ntpd's ``ntpq -pn``: a candidate without tally mark keeps its leading space. +NTPQ = """\ + remote refid st t when poll reach delay offset jitter +============================================================================== +*192.168.1.1 10.0.0.1 4 u 12 64 377 1.234 0.567 0.123 + 192.168.1.5 10.0.0.1 3 u 40 64 377 2.000 0.100 0.050 +""" + + +def _stats(driver, output): + with patch.object(driver, "_exec_ssh_command", return_value=output): + return driver.get_ntp_stats() + + +class TestChrony: + def test_every_source_is_reported(self, driver): + assert [s["remote"] for s in _stats(driver, CHRONY)] == [ + "192.168.1.1", + "10.0.0.2", + "10.0.0.3", + ] + + def test_the_selected_source_is_synchronized(self, driver): + stats = _stats(driver, CHRONY) + + assert [s["synchronized"] for s in stats] == [True, False, False] + + def test_fields_in_ntpq_units(self, driver): + first = _stats(driver, CHRONY)[0] + + assert first == { + "remote": "192.168.1.1", + "referenceid": "", + "synchronized": True, + "stratum": 2, + "type": "u", + "when": "8", + "hostpoll": 64, + "reachability": 377, + "delay": 0.0, + "offset": pytest.approx(-0.013), + "jitter": pytest.approx(0.045678), + } + + def test_a_source_without_statistics_has_no_jitter(self, driver): + last = _stats(driver, CHRONY)[2] + + assert last["jitter"] == 0.0 + assert last["when"] == "-" + assert last["reachability"] == 0 + + def test_the_command_asks_chrony_first(self, driver): + with patch.object(driver, "_exec_ssh_command", return_value="") as exec_: + driver.get_ntp_stats() + + assert "chronyc -n -c sources" in exec_.call_args[0][0] + assert "ntpq -pn" in exec_.call_args[0][0] + + +class TestNtpd: + def test_a_peer_without_tally_mark_is_kept(self, driver): + stats = _stats(driver, NTPQ) + + assert [s["remote"] for s in stats] == ["192.168.1.1", "192.168.1.5"] + assert [s["synchronized"] for s in stats] == [True, False] + assert stats[1]["stratum"] == 3 From f491f9f9ec7d9b79763dc9794b146327696dd026 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:53:47 +0100 Subject: [PATCH 09/13] fix(ssh): log in with any key type, the key before the password Only RSA keys were read, and a key was used only when no password was set; with the API password always present it never was. The key is now read as Ed25519, ECDSA or RSA and offered first, the password second. The rest of the issue (the API exec branch, errors read as empty output) belongs to the shared transport of NAPALM/napalm-device-types#35. Refs #17 --- CHANGELOG.md | 4 ++ napalm_proxmox/driver.py | 29 ++++++++++---- tests/test_ssh_login_key.py | 79 +++++++++++++++++++++++++++++++++++++ 3 files changed, 105 insertions(+), 7 deletions(-) create mode 100644 tests/test_ssh_login_key.py diff --git a/CHANGELOG.md b/CHANGELOG.md index e3845bf..690e7b0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -65,6 +65,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 always returning an empty list: offset in ms, the poll interval in seconds, the offset's standard deviation as `jitter`; chrony reports no delay, so `delay` is 0.0. On ntpd, a peer without tally mark is no longer dropped (#18). +- The SSH login to the node takes an Ed25519 or ECDSA key in + `ssh_private_key_str`, not only RSA, and uses the key even when a password is + set too (the password stays the fallback). A key that cannot be read is + logged as a warning and the password used (#17). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/driver.py b/napalm_proxmox/driver.py index 8ca45dc..25305a3 100644 --- a/napalm_proxmox/driver.py +++ b/napalm_proxmox/driver.py @@ -343,17 +343,17 @@ class ProxmoxDriver( import paramiko if self._ssh_client is None: - ssh_pass = self._ssh_password or self.password + # A key is tried first; paramiko falls back to the password. connect_kwargs: _JsonDict = { "username": self._ssh_username or self.username, "timeout": self.timeout, } - if self._ssh_key and not ssh_pass: - from io import StringIO as _StringIO - - connect_kwargs["pkey"] = paramiko.RSAKey.from_private_key(_StringIO(self._ssh_key)) - else: - connect_kwargs["password"] = ssh_pass + password = self._ssh_password or self.password + if password: + connect_kwargs["password"] = password + pkey = _load_private_key(self._ssh_key) if self._ssh_key else None + if pkey is not None: + connect_kwargs["pkey"] = pkey client = paramiko.SSHClient() try: HostKeyCheck(self.optional_args, self.hostname, 22).connect( @@ -511,3 +511,18 @@ class ProxmoxDriver( def cli(self, commands: list[str], encoding: str = "text") -> dict[str, str]: """Execute a list of shell commands and return their outputs.""" return {cmd: self._exec_ssh_command(cmd) for cmd in commands} + + +def _load_private_key(text: str) -> Any: # paramiko.PKey; paramiko is imported lazily + """The SSH private key in *text*, whatever its type, or None when it cannot be read.""" + import io + + import paramiko + + for key_class in (paramiko.Ed25519Key, paramiko.ECDSAKey, paramiko.RSAKey): + try: + return key_class.from_private_key(io.StringIO(text)) + except (paramiko.SSHException, ValueError): + continue + logger.warning("The SSH private key could not be read; logging in with the password") + return None diff --git a/tests/test_ssh_login_key.py b/tests/test_ssh_login_key.py new file mode 100644 index 0000000..d9397d4 --- /dev/null +++ b/tests/test_ssh_login_key.py @@ -0,0 +1,79 @@ +"""The node's SSH login takes any key type, and a key wins over the API password (#17).""" + +from __future__ import annotations + +import io + +import paramiko +import pytest +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric import ed25519 + +from napalm_proxmox.driver import ProxmoxDriver +from tests.test_ssh_host_key import client # noqa: F401 - the fake paramiko client fixture + + +def _ed25519_pem() -> str: + key = ed25519.Ed25519PrivateKey.generate() + return key.private_bytes( + serialization.Encoding.PEM, + serialization.PrivateFormat.OpenSSH, + serialization.NoEncryption(), + ).decode() + + +def _paramiko_pem(key: paramiko.PKey) -> str: + out = io.StringIO() + key.write_private_key(out) + return out.getvalue() + + +def _driver(key: str, ssh_password: str | None = None) -> ProxmoxDriver: + args = {"ssh_private_key_str": key} + if ssh_password is not None: + args["ssh_password"] = ssh_password + return ProxmoxDriver("10.0.0.9", "root", "api-s3cret", optional_args=args) + + +@pytest.mark.parametrize( + ("pem", "kind"), + [ + (_ed25519_pem(), paramiko.Ed25519Key), + (_paramiko_pem(paramiko.ECDSAKey.generate()), paramiko.ECDSAKey), + (_paramiko_pem(paramiko.RSAKey.generate(1024)), paramiko.RSAKey), + ], +) +def test_any_key_type_logs_in_although_an_api_password_is_set(client, pem, kind): # noqa: F811 + _driver(pem)._node_ssh() + + assert isinstance(client.connected_with["pkey"], kind) + + +def test_the_password_stays_as_the_fallback(client): # noqa: F811 + _driver(_ed25519_pem(), ssh_password="ssh-pw")._node_ssh() + + assert client.connected_with["password"] == "ssh-pw" + + +def test_without_key_the_password_logs_in(client): # noqa: F811 + ProxmoxDriver("10.0.0.9", "root", "api-s3cret")._node_ssh() + + assert client.connected_with["password"] == "api-s3cret" + assert "pkey" not in client.connected_with + + +def test_a_key_that_cannot_be_read_leaves_the_password(client, caplog): # noqa: F811 + _driver("not a key")._node_ssh() + + assert "pkey" not in client.connected_with + assert client.connected_with["password"] == "api-s3cret" + assert "not a key" not in caplog.text + assert "could not be read" in caplog.text + + +def test_a_token_only_login_sends_no_empty_password(client): # noqa: F811 + ProxmoxDriver( + "10.0.0.9", "root", "", optional_args={"ssh_private_key_str": _ed25519_pem()} + )._node_ssh() + + assert "password" not in client.connected_with From 29ed59c8d1b8a4a5c47874577f05c500aff9b30e Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:54:48 +0100 Subject: [PATCH 10/13] fix(vm-provision): wait for destroy_vm's delete task DELETE /nodes/{node}/qemu/{vmid} starts a task and returns its UPID; destroy_vm ignored it and returned while the VM could still exist, and a failed delete went unnoticed. The task is now awaited. Reading the snippets before the delete, the issue's first point, was fixed in ecff2b4. Closes #15 --- CHANGELOG.md | 2 ++ napalm_proxmox/vm_provision_mixin.py | 26 ++++++++++++-------- tests/quality_baseline.json | 2 +- tests/test_vm_provision_mixin.py | 36 ++++++++++++++++++++++++++++ 4 files changed, 55 insertions(+), 11 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 690e7b0..908c05c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -69,6 +69,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 `ssh_private_key_str`, not only RSA, and uses the key even when a password is set too (the password stays the fallback). A key that cannot be read is logged as a warning and the password used (#17). +- `destroy_vm()` returns once Proxmox has deleted the VM, not as soon as the + delete was queued, and raises when the delete fails (#15). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/vm_provision_mixin.py b/napalm_proxmox/vm_provision_mixin.py index 0d7577d..bce78f5 100644 --- a/napalm_proxmox/vm_provision_mixin.py +++ b/napalm_proxmox/vm_provision_mixin.py @@ -819,16 +819,7 @@ class ProxmoxVMProvisionMixin: snippets = self._cicustom_snippets(vmid_int) # Step 2: Delete VM - # Proxmox's API parameter is hyphenated (destroy-unreferenced-disks), - # not a valid Python identifier — proxmoxer forwards kwargs to the - # request verbatim with no underscore-to-hyphen translation, so this - # must be built as a dict and unpacked rather than passed as a kwarg. - _logger.debug(f"Deleting VM {vmid} configuration and disks") - delete_params = { - "purge": 1, - "destroy-unreferenced-disks": 1 if remove_disk else 0, - } - self._node_api().qemu(vmid_int).delete(**delete_params) + self._delete_vm(vmid_int, remove_disk, timeout) # Step 3: Clean up Cloud-Init snippets # (This is best-effort; snippet files may be unreachable if storage is unavailable) @@ -845,6 +836,21 @@ class ProxmoxVMProvisionMixin: _logger.exception(f"Failed to destroy VM {vmid}: {e}") raise + def _delete_vm(self, vmid: int, remove_disk: bool, timeout: int) -> None: + """Delete the VM and wait for it to be gone: the delete is a task.""" + _logger.debug(f"Deleting VM {vmid} configuration and disks") + # Proxmox's API parameter is hyphenated (destroy-unreferenced-disks), + # not a valid Python identifier — proxmoxer forwards kwargs to the + # request verbatim with no underscore-to-hyphen translation, so this + # must be built as a dict and unpacked rather than passed as a kwarg. + delete_params = { + "purge": 1, + "destroy-unreferenced-disks": 1 if remove_disk else 0, + } + upid = self._node_api().qemu(vmid).delete(**delete_params) + if upid: + self._wait_for_task(upid, timeout=timeout) + def _cicustom_snippets(self, vmid: int) -> list[tuple[str, str]]: """``(storage, path)`` of every snippet the VM's cicustom names. diff --git a/tests/quality_baseline.json b/tests/quality_baseline.json index ef77295..fdceda3 100644 --- a/tests/quality_baseline.json +++ b/tests/quality_baseline.json @@ -39,7 +39,7 @@ "napalm_proxmox/vm_mixin.py::ProxmoxVMMixin.get_vms": 114, "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin._download_cloud_image": 61, "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin.create_vm_from_cloud_init": 232, - "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin.destroy_vm": 65, + "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin.destroy_vm": 56, "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin.get_vm_status": 92 }, "mypy_relaxed": [ diff --git a/tests/test_vm_provision_mixin.py b/tests/test_vm_provision_mixin.py index 06fbe36..e828903 100644 --- a/tests/test_vm_provision_mixin.py +++ b/tests/test_vm_provision_mixin.py @@ -484,6 +484,42 @@ def test_destroy_vm_already_stopped(): assert mock_vm.delete.called +def _destroy_mixin(delete_task: dict) -> tuple[ProxmoxVMProvisionMixin, MagicMock]: + mixin = ProxmoxVMProvisionMixin() + node = MagicMock() + mixin._node_api = MagicMock(return_value=node) + vm = node.qemu.return_value + vm.status.stop.post.return_value = "UPID:pve1:125:stop" + vm.config.get.return_value = {} + vm.delete.return_value = "UPID:pve1:126:qmdestroy" + tasks = { + "UPID:pve1:125:stop": {"status": "stopped", "exitstatus": "OK"}, + "UPID:pve1:126:qmdestroy": delete_task, + } + node.tasks.side_effect = lambda upid: MagicMock(**{"status.get.return_value": tasks[upid]}) + return mixin, node + + +def test_destroy_vm_waits_for_the_delete_task(): + """destroy_vm returns once the VM is gone, not when its delete was queued (#15).""" + mixin, node = _destroy_mixin({"status": "stopped", "exitstatus": "OK"}) + + with patch("time.sleep"): + mixin.destroy_vm("101") + + assert [c.args[0] for c in node.tasks.call_args_list] == [ + "UPID:pve1:125:stop", + "UPID:pve1:126:qmdestroy", + ] + + +def test_destroy_vm_raises_when_the_delete_task_fails(): + mixin, _ = _destroy_mixin({"status": "stopped", "exitstatus": "VM is locked (backup)"}) + + with patch("time.sleep"), pytest.raises(RuntimeError, match="VM is locked"): + mixin.destroy_vm("101") + + # --------------------------------------------------------------------------- # get_network_targets # --------------------------------------------------------------------------- From 10cf788b86f64d303b33a579f5d65f3dc1423678 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:55:32 +0100 Subject: [PATCH 11/13] fix(ping): parse each reply into results The probe pattern expected "from" after icmp_seq, but iputils prints "bytes from : icmp_seq=... time=... ms", so results was always empty. Replies by name ("from host (ip)") and over IPv6 are read too. Closes #12 --- CHANGELOG.md | 2 ++ napalm_proxmox/routing_mixin.py | 10 +++++++--- tests/test_misc.py | 25 +++++++++++++++++++++++++ 3 files changed, 34 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 908c05c..1bb4fd9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -71,6 +71,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 logged as a warning and the password used (#17). - `destroy_vm()` returns once Proxmox has deleted the VM, not as soon as the delete was queued, and raises when the delete fails (#15). +- `ping()` fills `results` with each reply's address and round-trip time; it + was always empty (#12). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/routing_mixin.py b/napalm_proxmox/routing_mixin.py index edf474e..df3ede7 100644 --- a/napalm_proxmox/routing_mixin.py +++ b/napalm_proxmox/routing_mixin.py @@ -23,6 +23,10 @@ import napalm.base.constants as C _JsonDict = dict[str, Any] +#: One reply in iputils' ping output, by address or by name with the address +#: in brackets: "64 bytes from dns.google (8.8.4.4): icmp_seq=1 ttl=118 time=10.5 ms". +_PING_REPLY = re.compile(r"bytes from (?:\S+ \()?([0-9a-fA-F.:]+)\)?: .*?time=([\d.]+) ms") + class ProxmoxRoutingMixin: """Mixin providing routing NAPALM methods (get_route_to, ping, traceroute).""" @@ -90,9 +94,9 @@ class ProxmoxRoutingMixin: rtt_std = float(m_rtt.group(4)) if m_rtt else 0.0 # Individual probe lines - probes = [] - for m_probe in re.finditer(r"icmp_seq=\d+.*?time=([\d.]+) ms.*?from ([\d.a-fA-F:]+)", raw): - probes.append({"ip_address": m_probe.group(2), "rtt": float(m_probe.group(1))}) + probes = [ + {"ip_address": m.group(1), "rtt": float(m.group(2))} for m in _PING_REPLY.finditer(raw) + ] return { "success": { diff --git a/tests/test_misc.py b/tests/test_misc.py index 42a660e..c374cac 100644 --- a/tests/test_misc.py +++ b/tests/test_misc.py @@ -175,6 +175,31 @@ class TestPing: assert result["success"]["packet_loss"] == 0 assert result["success"]["rtt_min"] == pytest.approx(10.5, abs=0.01) + def test_every_reply_is_a_result(self, driver): + """iputils puts "from " before icmp_seq (napalm-proxmox#12).""" + driver._node_api().execute.post.return_value = {"data": self.PING_SUCCESS} + result = driver.ping("8.8.8.8") + assert result["success"]["results"] == [ + {"ip_address": "8.8.8.8", "rtt": 10.5}, + {"ip_address": "8.8.8.8", "rtt": 11.2}, + ] + + def test_a_reply_by_name_and_over_ipv6(self, driver): + output = ( + "PING dns.google (8.8.4.4) 56(84) bytes of data.\n" + "64 bytes from dns.google (8.8.4.4): icmp_seq=1 ttl=118 time=123 ms\n" + "64 bytes from 2001:db8::1: icmp_seq=2 ttl=64 time=0.045 ms\n" + "--- dns.google ping statistics ---\n" + "2 packets transmitted, 2 received, 0% packet loss, time 1001ms\n" + "rtt min/avg/max/mdev = 0.045/61.5/123.0/61.4 ms\n" + ) + driver._node_api().execute.post.return_value = {"data": output} + result = driver.ping("dns.google") + assert result["success"]["results"] == [ + {"ip_address": "8.8.4.4", "rtt": 123.0}, + {"ip_address": "2001:db8::1", "rtt": 0.045}, + ] + def test_failure(self, driver): driver._node_api().execute.post.return_value = {"data": self.PING_FAIL} result = driver.ping("badhost") From 9c7b64ba6456b754225db182ec20be22b6d222d5 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 21:56:29 +0100 Subject: [PATCH 12/13] fix(vm-provision): say why a cloud-image download failed, drop its tmp wget ran with -q, so a failure carried no reason, and a failed download left its partial .tmp in the cache, taking the same space again on every retry. wget now runs with -nv and the .tmp is removed on failure, keeping wget's exit status. Closes #3 --- CHANGELOG.md | 3 ++ napalm_proxmox/vm_provision_mixin.py | 21 ++++++++---- tests/quality_baseline.json | 2 +- tests/test_vm_provision_mixin.py | 49 ++++++++++++++++++++++++++++ 4 files changed, 68 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1bb4fd9..d48777c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -73,6 +73,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 delete was queued, and raises when the delete fails (#15). - `ping()` fills `results` with each reply's address and round-trip time; it was always empty (#12). +- A failed cloud-image download in `create_vm_from_cloud_init()` says why + (wget's own message, such as "No space left on device") and removes its + partial `.tmp` file instead of leaving it to fill the node's disk (#3). ## [0.8.0] - 2026-10-23 diff --git a/napalm_proxmox/vm_provision_mixin.py b/napalm_proxmox/vm_provision_mixin.py index bce78f5..02d6194 100644 --- a/napalm_proxmox/vm_provision_mixin.py +++ b/napalm_proxmox/vm_provision_mixin.py @@ -186,12 +186,7 @@ class ProxmoxVMProvisionMixin: timeout=30, ) if "EXISTS" not in exists: - _logger.info(f"Downloading cloud image {image_url} -> {local_path}") - self._run_node_command( - f"wget -q -O {local_path}.tmp '{image_url}' " - f"&& mv {local_path}.tmp {local_path}", - timeout=timeout, - ) + self._fetch_image(image_url, local_path, timeout) if not image_checksum: return local_path @@ -216,6 +211,20 @@ class ProxmoxVMProvisionMixin: raise AssertionError("unreachable") # loop always returns or raises above + def _fetch_image(self, image_url: str, local_path: str, timeout: int) -> None: + """Download *image_url* to *local_path* on the node, through a ``.tmp``. + + wget runs with ``-nv`` so its reason ("No space left on device") + reaches the error, and a failed download leaves no partial ``.tmp``. + """ + _logger.info(f"Downloading cloud image {image_url} -> {local_path}") + tmp = f"{local_path}.tmp" + self._run_node_command( + f"wget -nv -O {tmp} '{image_url}' && mv {tmp} {local_path} " + f"|| {{ s=$?; rm -f {tmp}; exit $s; }}", + timeout=timeout, + ) + def _cloud_image_on_node(self, image_url: str, image_checksum: str | None, timeout: int) -> str: """The node path of the image, downloaded, verified and unpacked. diff --git a/tests/quality_baseline.json b/tests/quality_baseline.json index fdceda3..6c9c8d9 100644 --- a/tests/quality_baseline.json +++ b/tests/quality_baseline.json @@ -37,7 +37,7 @@ "napalm_proxmox/system_mixin.py::ProxmoxSystemMixin.set_hostname": 114, "napalm_proxmox/vm_mixin.py::ProxmoxVMMixin.get_vm_interfaces": 179, "napalm_proxmox/vm_mixin.py::ProxmoxVMMixin.get_vms": 114, - "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin._download_cloud_image": 61, + "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin._download_cloud_image": 56, "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin.create_vm_from_cloud_init": 232, "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin.destroy_vm": 56, "napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin.get_vm_status": 92 diff --git a/tests/test_vm_provision_mixin.py b/tests/test_vm_provision_mixin.py index e828903..d6a0235 100644 --- a/tests/test_vm_provision_mixin.py +++ b/tests/test_vm_provision_mixin.py @@ -1364,3 +1364,52 @@ def test_create_vm_passes_every_ssh_key_one_per_line(): sshkeys = call[1]["sshkeys"] assert unquote(sshkeys) == "\n".join(keys) assert re.fullmatch(r"[-%a-zA-Z0-9_.!~*'()]*", sshkeys) + + +class _LocalShell: + """The node's SSH session as a local ``sh``, *prelude* run before each command.""" + + def __init__(self, prelude: str) -> None: + self.prelude = prelude + + def exec_command(self, command: str, timeout: int | None = None): + import subprocess + + run = subprocess.run( + ["sh", "-c", self.prelude + command], capture_output=True, timeout=timeout + ) + return _mock_ssh_exec(run.returncode, run.stdout.decode(), run.stderr.decode()) + + +# wget as it fails on a full disk: part of the file written, the reason on stderr. +_WGET_DISK_FULL = ( + "wget() { " + 'while [ $# -gt 0 ]; do [ "$1" = -O ] && o=$2; shift; done; ' + 'echo partial > "$o"; ' + 'echo "$o: No space left on device" >&2; return 3; }; ' +) + + +def test_download_cloud_image_failure_says_why_and_leaves_no_tmp(tmp_path, monkeypatch): + """A failed download names wget's reason and removes its .tmp (napalm-proxmox#3).""" + import napalm_proxmox.vm_provision_mixin as module + + monkeypatch.setattr(module, "_IMAGE_CACHE_DIR", str(tmp_path)) + mixin = ProxmoxVMProvisionMixin() + mixin._node_ssh = MagicMock(return_value=_LocalShell(_WGET_DISK_FULL)) + + with pytest.raises(RuntimeError, match="No space left on device") as err: + mixin._download_cloud_image("https://example.org/img/debian.qcow2", None, timeout=10) + + assert "exit 3" in str(err.value) + assert list(tmp_path.iterdir()) == [] + + +def test_download_cloud_image_does_not_silence_wget(): + mixin = ProxmoxVMProvisionMixin() + mixin._run_node_command = MagicMock(side_effect=["MISSING", ""]) + + mixin._download_cloud_image("https://example.org/img/debian.qcow2", None, timeout=10) + + download = mixin._run_node_command.call_args_list[1][0][0] + assert download.startswith("wget -nv ") From 8ef880b73b8781b0e0c371c1604314d5bfa098a1 Mon Sep 17 00:00:00 2001 From: Christian Manivong Date: Sun, 1 Nov 2026 22:08:54 +0100 Subject: [PATCH 13/13] fix(hostname): refuse to rename a clustered node The rename moves /etc/pve/nodes/ while the node still runs as , which Proxmox does not support for a cluster member. set_hostname now checks for a corosync.conf first and raises before touching anything on a member, or when the check cannot be read; a single node renames as before. The check is the file, not `pvecm status`: pvecm decides membership by /etc/pve/corosync.conf itself, and its status also fails on a member whose corosync is down. /etc/corosync/corosync.conf covers a member whose /etc/pve is not mounted. Closes #21 --- CHANGELOG.md | 5 +++++ napalm_proxmox/system_mixin.py | 30 ++++++++++++++++++++------ tests/test_set_hostname.py | 39 ++++++++++++++++++++++++++++++++-- 3 files changed, 66 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d48777c..a0f4b61 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -54,6 +54,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `set_hostname()` renames only the node's own names in `/etc/hosts`: other hosts whose names start with the old one (`pve-backup`) and comments stay as they are, and the old FQDN becomes the new one instead of a mix of both (#21). +- `set_hostname()` refuses a node that is part of a cluster (a + `/etc/pve/corosync.conf` or `/etc/corosync/corosync.conf` exists) with a + `CommandErrorException`, before changing anything: it moved + `/etc/pve/nodes/` while the cluster still knew the node as ``. Also + refused when the check cannot be read. A single node renames as before (#21). - `apply_updates()` reports a failed upgrade as `success: False`, with apt-get's exit status in `error`; it reported success whatever apt-get did (#20). - `get_users()` lists the node's root and regular login accounts (uid 1000 and diff --git a/napalm_proxmox/system_mixin.py b/napalm_proxmox/system_mixin.py index 669f078..2a013bf 100644 --- a/napalm_proxmox/system_mixin.py +++ b/napalm_proxmox/system_mixin.py @@ -26,6 +26,7 @@ import re import shlex from typing import Any +from napalm.base.exceptions import CommandErrorException from napalm_device_types import APT_UPGRADABLE_COMMAND, parse_apt_upgradable from napalm_proxmox.ntp import NTP_STATS_COMMAND, parse_ntp_stats @@ -49,6 +50,11 @@ _PACKAGE_NAME = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_.+:~-]*$") _SNMP_WORD = re.compile(r'^[^\s"#]+$') #: The net-snmp agent's configuration file. _SNMPD_CONF = "/etc/snmp/snmpd.conf" +#: Exit status 0 when the node is a cluster member. pvecm itself decides +#: membership by /etc/pve/corosync.conf; /etc/corosync/corosync.conf is the +#: local copy every member keeps, there even when /etc/pve is not mounted. +#: Not ``pvecm status``: it also fails on a member whose corosync is down. +_CLUSTER_MEMBER_CHECK = "[ -e /etc/pve/corosync.conf ] || [ -e /etc/corosync/corosync.conf ]" def _rename_in_hosts(hosts: str, old_short: str, new_short: str, new_domain: str | None) -> str: @@ -617,6 +623,18 @@ class ProxmoxSystemMixin: "snmpd enabled and running", ) + def _refuse_clustered_node(self) -> None: + _, status = self._rc(_CLUSTER_MEMBER_CHECK) + if status == 0: + raise CommandErrorException( + "set_hostname refused: the node is part of a cluster; rename a cluster" + " member by Proxmox's own procedure, not in place" + ) + if status != 1: + raise CommandErrorException( + "set_hostname refused: could not tell whether the node is part of a cluster" + ) + def set_hostname(self, new_hostname: str) -> None: """Set the system hostname on the Proxmox node. @@ -634,16 +652,16 @@ class ProxmoxSystemMixin: 7. Proxmox node TLS certificate — regenerated via ``pvenode cert create --overwrite``. - **Important**: the Proxmox *node name* (shown in the web UI and stored - in ``/etc/pve/nodes//``) only changes after a full reboot. - Until then the web UI still shows the old node name, but the OS-level - hostname and the SSL certificate already reflect the new value. + The Proxmox *node name* (web UI, ``/etc/pve/nodes//``) only + changes after a reboot. Accepts a bare hostname or an FQDN. - Accepts a bare hostname (``pve-see``) or an FQDN - (``pve-see.see.local``). + Raises CommandErrorException, before changing anything, on a cluster + member (a corosync.conf exists): its rename is the cluster's procedure. """ import base64 as _b64 + self._refuse_clustered_node() + if "." in new_hostname: short_hostname, domain = new_hostname.split(".", 1) fqdn = new_hostname diff --git a/tests/test_set_hostname.py b/tests/test_set_hostname.py index cc59e31..b5f86ab 100644 --- a/tests/test_set_hostname.py +++ b/tests/test_set_hostname.py @@ -1,4 +1,5 @@ -"""set_hostname: what it writes to /etc/hosts (napalm-proxmox#21).""" +"""set_hostname: what it writes to /etc/hosts, and that it leaves a clustered node alone +(napalm-proxmox#21).""" from __future__ import annotations @@ -6,6 +7,7 @@ import base64 import re import pytest +from napalm.base.exceptions import CommandErrorException from napalm_proxmox import ProxmoxDriver @@ -18,13 +20,20 @@ HOSTS = """\ class _Node: - """The node's shell: /etc/hostname reads "pve", /etc/hosts reads HOSTS.""" + """The node's shell: /etc/hostname reads "pve", /etc/hosts reads HOSTS. + + *cluster_check* is what the test for a corosync.conf prints: exit status 1 + (no corosync.conf, a single node) unless a test says otherwise. + """ def __init__(self) -> None: self.ran: list[str] = [] + self.cluster_check = "__PVE_RC=1" def __call__(self, command: str) -> str: self.ran.append(command) + if "corosync.conf" in command: + return self.cluster_check if command.startswith("cat /etc/hostname"): return "pve\n" if command.startswith("cat /etc/hosts"): @@ -70,3 +79,29 @@ def test_the_same_name_leaves_hosts_alone(driver, node): driver.set_hostname("pve") assert not any("/etc/hosts" in c and "base64 -d" in c for c in node.ran) + + +def test_a_clustered_node_is_refused_before_anything_changes(driver, node): + node.cluster_check = "__PVE_RC=0" + + with pytest.raises(CommandErrorException, match="part of a cluster"): + driver.set_hostname("new") + + assert [c for c in node.ran if "corosync.conf" not in c] == [] + + +def test_the_cluster_check_looks_at_both_corosync_confs(driver, node): + driver.set_hostname("new") + + check = next(c for c in node.ran if "corosync.conf" in c) + assert "/etc/pve/corosync.conf" in check + assert "/etc/corosync/corosync.conf" in check + + +def test_an_unreadable_cluster_check_refuses_too(driver, node): + node.cluster_check = "" + + with pytest.raises(CommandErrorException, match="could not tell"): + driver.set_hostname("new") + + assert [c for c in node.ran if "corosync.conf" not in c] == []