diff --git a/CHANGELOG.md b/CHANGELOG.md index 4903d06..9ca7a7f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -65,6 +65,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/` 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 + 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 diff --git a/napalm_proxmox/driver.py b/napalm_proxmox/driver.py index fc2eb27..3647fdf 100644 --- a/napalm_proxmox/driver.py +++ b/napalm_proxmox/driver.py @@ -345,17 +345,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( @@ -513,3 +513,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/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/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/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/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/napalm_proxmox/system_mixin.py b/napalm_proxmox/system_mixin.py index 0ce4cb6..2a013bf 100644 --- a/napalm_proxmox/system_mixin.py +++ b/napalm_proxmox/system_mixin.py @@ -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.`` 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) + + +#: 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//``) 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 @@ -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" diff --git a/napalm_proxmox/vm_provision_mixin.py b/napalm_proxmox/vm_provision_mixin.py index 9a2d206..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. @@ -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. diff --git a/tests/quality_baseline.json b/tests/quality_baseline.json index 75fd5b4..6c9c8d9 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,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": [ 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" 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" 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") 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 diff --git a/tests/test_set_hostname.py b/tests/test_set_hostname.py new file mode 100644 index 0000000..b5f86ab --- /dev/null +++ b/tests/test_set_hostname.py @@ -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] == [] 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 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"}}) 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 = ( 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 diff --git a/tests/test_vm_provision_mixin.py b/tests/test_vm_provision_mixin.py index d3d9f0d..d6a0235 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 # --------------------------------------------------------------------------- @@ -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 ")