fix: twelve open bugs, set_vlan uplink first (#37, #30, #23, #22, #21, #20, #19, #18, #17, #15, #12, #3) #40

Merged
christianmanivong merged 13 commits from fix/bugs-2026-11 into main 2026-11-01 22:50:19 +00:00
19 changed files with 1067 additions and 145 deletions

No files matched your search

+41
View File
@@ -40,6 +40,47 @@ 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).
- `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).
- `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).
- `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/<old>` while the cluster still knew the node as `<old>`. 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
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).
- `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).
- 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).
- `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).
- 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
+22 -7
View File
@@ -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
+12 -12
View File
@@ -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]]:
+113
View File
@@ -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
+7 -3
View File
@@ -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": {
+11
View File
@@ -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]
+142 -99
View File
@@ -26,8 +26,11 @@ 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
logger = logging.getLogger(__name__)
_JsonDict = dict[str, Any]
@@ -45,6 +48,71 @@ _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"
#: 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:
"""*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.<domain>`` becomes ``new_short.<new_domain>`` (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)
#: 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:
@@ -137,36 +205,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
@@ -213,55 +253,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)
# ------------------------------------------------------------------ #
@@ -448,11 +485,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
@@ -527,8 +570,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 +606,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", [])]
@@ -582,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.
@@ -599,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/<name>/``) 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/<name>/``) 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
@@ -633,17 +686,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"
+34 -19
View File
@@ -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.
@@ -736,9 +745,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)
@@ -819,16 +828,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 +845,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.
+3 -5
View File
@@ -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,13 +34,12 @@
"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": 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,
"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": 65,
"napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin.destroy_vm": 56,
"napalm_proxmox/vm_provision_mixin.py::ProxmoxVMProvisionMixin.get_vm_status": 92
},
"mypy_relaxed": [
+34
View File
@@ -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"
+65
View File
@@ -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"
+25
View File
@@ -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 <ip>" 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")
+86
View File
@@ -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
+107
View File
@@ -0,0 +1,107 @@
"""set_hostname: what it writes to /etc/hosts, and that it leaves a clustered node alone
(napalm-proxmox#21)."""
from __future__ import annotations
import base64
import re
import pytest
from napalm.base.exceptions import CommandErrorException
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.
*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"):
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)
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] == []
+79
View File
@@ -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
+58
View File
@@ -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"}})
+29
View File
@@ -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 = (
+66
View File
@@ -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
+133
View File
@@ -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
# ---------------------------------------------------------------------------
@@ -1280,3 +1316,100 @@ 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)
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 ")