driver / standard (pull_request) Successful in 16s
driver / lint (pull_request) Successful in 13s
driver / types (pull_request) Failing after 1m2s
driver / test (3.12) (pull_request) Successful in 1m9s
driver / test (3.13) (pull_request) Successful in 57s
driver / lowest (pull_request) Successful in 31s
driver / build (pull_request) Successful in 28s
driver / security (pull_request) Successful in 1m3s
CI / driver (pull_request) Failing after 2m42s
driver / publish (pull_request) Skipped
Every PVE node can read its whole cluster, so get_clusters() reports the one it belongs to: name and quorum from /cluster/status, every member (offline ones as offline, without capacity), CPU and memory from /cluster/resources and each online node's cpuinfo, maintenance from the HA manager where it can be read, storages grouped by name with the nodes they are available on, and bridges and vnets with the nodes that carry them. A standalone node is a cluster of one. The bridge part of get_network_targets() moved to network_targets.py so both use it. create_vm_from_cloud_init() takes node= and refuses any node but its own before creating anything. Refs NetOrk/netork#484, NetOrk/netork#1822
494 lines
17 KiB
Python
494 lines
17 KiB
Python
"""get_clusters(): the cluster a node belongs to, its nodes, storages and networks.
|
|
|
|
A Proxmox node can read its whole cluster: ``/cluster/status`` names the members
|
|
and the quorum, ``/cluster/resources`` their capacity and every storage per
|
|
node, ``/nodes/{node}/status`` the CPU, ``/nodes/{node}/network`` the bridges.
|
|
netOrk uses it to tell where a new VM may go (NetOrk/netork#484, #1822). The
|
|
payloads below follow PVE 8.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
from napalm_proxmox.driver import ProxmoxDriver
|
|
from tests.conftest import _build_mock_api
|
|
|
|
GIB = 1024**3
|
|
|
|
CLUSTER_STATUS = [
|
|
{"type": "cluster", "id": "cluster", "name": "lab", "nodes": 3, "quorate": 1, "version": 7},
|
|
{
|
|
"type": "node",
|
|
"id": "node/pve1",
|
|
"name": "pve1",
|
|
"nodeid": 1,
|
|
"ip": "10.0.0.1",
|
|
"local": 1,
|
|
"online": 1,
|
|
"level": "",
|
|
},
|
|
{
|
|
"type": "node",
|
|
"id": "node/pve2",
|
|
"name": "pve2",
|
|
"nodeid": 2,
|
|
"ip": "10.0.0.2",
|
|
"local": 0,
|
|
"online": 1,
|
|
"level": "",
|
|
},
|
|
{
|
|
"type": "node",
|
|
"id": "node/pve3",
|
|
"name": "pve3",
|
|
"nodeid": 3,
|
|
"ip": "10.0.0.3",
|
|
"local": 0,
|
|
"online": 0,
|
|
"level": "",
|
|
},
|
|
]
|
|
|
|
|
|
def _node_row(node: str, maxcpu: int, cpu: float, maxmem: int, mem: int) -> dict[str, Any]:
|
|
return {
|
|
"id": f"node/{node}",
|
|
"type": "node",
|
|
"node": node,
|
|
"status": "online",
|
|
"cpu": cpu,
|
|
"maxcpu": maxcpu,
|
|
"mem": mem,
|
|
"maxmem": maxmem,
|
|
"disk": 5 * GIB,
|
|
"maxdisk": 100 * GIB,
|
|
"uptime": 86400,
|
|
"level": "",
|
|
"cgroup-mode": 2,
|
|
}
|
|
|
|
|
|
def _storage_row(
|
|
node: str,
|
|
storage: str,
|
|
plugintype: str,
|
|
shared: int,
|
|
content: str,
|
|
maxdisk: int,
|
|
disk: int,
|
|
status: str = "available",
|
|
) -> dict[str, Any]:
|
|
return {
|
|
"id": f"storage/{node}/{storage}",
|
|
"type": "storage",
|
|
"node": node,
|
|
"storage": storage,
|
|
"plugintype": plugintype,
|
|
"shared": shared,
|
|
"content": content,
|
|
"maxdisk": maxdisk,
|
|
"disk": disk,
|
|
"status": status,
|
|
}
|
|
|
|
|
|
CLUSTER_RESOURCES = [
|
|
_node_row("pve1", 32, 0.25, 128 * GIB, 64 * GIB),
|
|
_node_row("pve2", 16, 0.5, 64 * GIB, 16 * GIB),
|
|
# An offline node keeps a row, with what PVE last knew of it.
|
|
{"id": "node/pve3", "type": "node", "node": "pve3", "status": "offline", "maxcpu": 8},
|
|
_storage_row("pve1", "local-lvm", "lvmthin", 0, "rootdir,images", 400 * GIB, 100 * GIB),
|
|
_storage_row("pve2", "local-lvm", "lvmthin", 0, "rootdir,images", 200 * GIB, 50 * GIB),
|
|
_storage_row("pve3", "local-lvm", "lvmthin", 0, "rootdir,images", 0, 0, status="unknown"),
|
|
_storage_row("pve1", "ceph-vm", "rbd", 1, "images,rootdir", 3000 * GIB, 1000 * GIB),
|
|
_storage_row("pve2", "ceph-vm", "rbd", 1, "images,rootdir", 3000 * GIB, 1000 * GIB),
|
|
_storage_row("pve1", "nfs-iso", "nfs", 1, "iso,vztmpl,snippets", 1000 * GIB, 10 * GIB),
|
|
# The NFS server cannot be reached from pve2.
|
|
_storage_row("pve2", "nfs-iso", "nfs", 1, "iso,vztmpl,snippets", 0, 0, status="unavailable"),
|
|
{"id": "qemu/100", "type": "qemu", "vmid": 100, "node": "pve1", "status": "running"},
|
|
{"id": "sdn/pve1/localnetwork", "type": "sdn", "sdn": "localnetwork", "node": "pve1"},
|
|
]
|
|
|
|
|
|
def _cpuinfo(cores: int, sockets: int, model: str, flags: str) -> dict[str, Any]:
|
|
return {
|
|
"cpuinfo": {
|
|
"cores": cores,
|
|
"sockets": sockets,
|
|
"cpus": cores * sockets * 2,
|
|
"model": model,
|
|
"flags": flags,
|
|
"mhz": "2100.000",
|
|
"hvm": "1",
|
|
"user_hz": 100,
|
|
},
|
|
"memory": {"total": 128 * GIB, "used": 64 * GIB, "free": 64 * GIB},
|
|
"uptime": 86400,
|
|
"pveversion": "pve-manager/8.2.4/faa83925c9641325",
|
|
}
|
|
|
|
|
|
NODE_STATUS = {
|
|
"pve1": _cpuinfo(8, 2, "Intel(R) Xeon(R) Silver 4110 CPU @ 2.10GHz", "fpu vme sse4_2 avx2"),
|
|
"pve2": _cpuinfo(8, 1, "AMD EPYC 7302P 16-Core Processor", "fpu vme sse4_2"),
|
|
}
|
|
|
|
NODE_NETWORK = {
|
|
"pve1": [
|
|
{"iface": "eno1", "type": "eth", "active": 1},
|
|
{
|
|
"iface": "vmbr0",
|
|
"type": "bridge",
|
|
"active": 1,
|
|
"bridge_ports": "eno1",
|
|
"bridge_vlan_aware": 1,
|
|
},
|
|
{"iface": "vmbr9", "type": "bridge", "active": 1, "bridge_ports": "none"},
|
|
],
|
|
"pve2": [
|
|
{"iface": "eno1", "type": "eth", "active": 1},
|
|
# Same name, but not VLAN aware on this node.
|
|
{"iface": "vmbr0", "type": "bridge", "active": 1, "bridge_ports": "eno1"},
|
|
{"iface": "vmbr1", "type": "OVSBridge", "active": 1, "ovs_ports": ""},
|
|
],
|
|
}
|
|
|
|
SDN_ZONES = [
|
|
{"zone": "edge", "type": "vlan", "bridge": "vmbr0", "nodes": "pve2", "digest": "x"},
|
|
{"zone": "fabric", "type": "vxlan", "peers": "10.0.0.1,10.0.0.2", "digest": "x"},
|
|
]
|
|
|
|
SDN_VNETS = [
|
|
{"vnet": "dmz", "zone": "edge", "tag": 30, "type": "vnet", "digest": "x"},
|
|
{"vnet": "overlay", "zone": "fabric", "tag": 100000, "type": "vnet", "digest": "x"},
|
|
]
|
|
|
|
HA_MANAGER_STATUS = {
|
|
"manager_status": {
|
|
"master_node": "pve1",
|
|
"node_status": {"pve1": "online", "pve2": "maintenance", "pve3": "unknown"},
|
|
"service_status": {},
|
|
"timestamp": 1730000000,
|
|
},
|
|
"quorum": {"node": "pve1", "quorate": "1"},
|
|
}
|
|
|
|
|
|
def _api(
|
|
cluster_status: list[dict[str, Any]] | None = None,
|
|
resources: list[dict[str, Any]] | None = None,
|
|
node_status: dict[str, Any] | None = None,
|
|
node_network: dict[str, Any] | None = None,
|
|
zones: list[dict[str, Any]] | None = None,
|
|
vnets: list[dict[str, Any]] | None = None,
|
|
ha: dict[str, Any] | Exception | None = None,
|
|
) -> MagicMock:
|
|
api = _build_mock_api(cluster_status=cluster_status or CLUSTER_STATUS)
|
|
statuses = NODE_STATUS if node_status is None else node_status
|
|
networks = NODE_NETWORK if node_network is None else node_network
|
|
nodes: dict[str, MagicMock] = {}
|
|
|
|
def node_res(name: str) -> MagicMock:
|
|
if name not in nodes:
|
|
res = MagicMock()
|
|
if name in statuses:
|
|
res.status.get.return_value = statuses[name]
|
|
else:
|
|
res.status.get.side_effect = ConnectionError(f"{name} unreachable")
|
|
res.network.get.return_value = networks.get(name, [])
|
|
nodes[name] = res
|
|
return nodes[name]
|
|
|
|
api.nodes.side_effect = node_res
|
|
api.nodes.return_value = None
|
|
api.cluster.resources.get.return_value = CLUSTER_RESOURCES if resources is None else resources
|
|
api.cluster.sdn.zones.get.return_value = SDN_ZONES if zones is None else zones
|
|
api.cluster.sdn.vnets.get.return_value = SDN_VNETS if vnets is None else vnets
|
|
manager = api.cluster.ha.status.manager_status.get
|
|
if isinstance(ha, Exception):
|
|
manager.side_effect = ha
|
|
else:
|
|
manager.return_value = HA_MANAGER_STATUS if ha is None else ha
|
|
return api
|
|
|
|
|
|
def _driver(api: MagicMock, node: str = "pve1") -> ProxmoxDriver:
|
|
drv = ProxmoxDriver(
|
|
hostname=f"{node}.example.com",
|
|
username="root",
|
|
password="secret",
|
|
optional_args={"verify_ssl": False, "node": node},
|
|
)
|
|
with patch("napalm_proxmox.driver.ProxmoxAPI", return_value=api):
|
|
drv.open()
|
|
return drv
|
|
|
|
|
|
def _cluster(**kwargs: Any) -> dict[str, Any]:
|
|
clusters = _driver(_api(**kwargs)).get_clusters()
|
|
assert len(clusters) == 1
|
|
return dict(clusters[0])
|
|
|
|
|
|
def _by_name(items: list[Any]) -> dict[str, Any]:
|
|
return {item["name"]: item for item in items}
|
|
|
|
|
|
class TestCluster:
|
|
def test_name_and_quorum(self):
|
|
cluster = _cluster()
|
|
assert cluster["id"] is None
|
|
assert cluster["name"] == "lab"
|
|
assert cluster["quorate"] is True
|
|
|
|
def test_lost_quorum(self):
|
|
status = [dict(CLUSTER_STATUS[0], quorate=0), *CLUSTER_STATUS[1:]]
|
|
assert _cluster(cluster_status=status)["quorate"] is False
|
|
|
|
def test_every_member_listed_in_cluster_order(self):
|
|
assert [n["name"] for n in _cluster()["nodes"]] == ["pve1", "pve2", "pve3"]
|
|
|
|
|
|
class TestNodes:
|
|
def test_online_node(self):
|
|
pve1 = _by_name(_cluster()["nodes"])["pve1"]
|
|
assert pve1 == {
|
|
"name": "pve1",
|
|
"status": "online",
|
|
"local": True,
|
|
"maintenance": False,
|
|
"cpu_threads": 32,
|
|
"cpu_cores": 16,
|
|
"cpu_model": "Intel(R) Xeon(R) Silver 4110 CPU @ 2.10GHz",
|
|
"cpu_flags": ["fpu", "vme", "sse4_2", "avx2"],
|
|
"cpu_usage": 0.25,
|
|
"memory_total": 128 * GIB,
|
|
"memory_used": 64 * GIB,
|
|
}
|
|
|
|
def test_other_member_is_not_local(self):
|
|
pve2 = _by_name(_cluster()["nodes"])["pve2"]
|
|
assert pve2["local"] is False
|
|
assert pve2["cpu_cores"] == 8
|
|
assert pve2["cpu_threads"] == 16
|
|
|
|
def test_offline_node_is_listed_without_capacity(self):
|
|
api = _api()
|
|
pve3 = _by_name(_driver(api).get_clusters()[0]["nodes"])["pve3"]
|
|
assert pve3["status"] == "offline"
|
|
assert pve3["local"] is False
|
|
for key in (
|
|
"cpu_threads",
|
|
"cpu_cores",
|
|
"cpu_model",
|
|
"cpu_flags",
|
|
"cpu_usage",
|
|
"memory_total",
|
|
"memory_used",
|
|
):
|
|
assert pve3[key] is None, key
|
|
# An offline node is not asked: the request would only time out.
|
|
assert all(call.args != ("pve3",) for call in api.nodes.call_args_list)
|
|
|
|
def test_local_falls_back_to_the_resolved_node(self):
|
|
status = [dict(s, local=0) if s["type"] == "node" else s for s in CLUSTER_STATUS]
|
|
nodes = _by_name(
|
|
_driver(_api(cluster_status=status), node="pve2").get_clusters()[0]["nodes"]
|
|
)
|
|
assert nodes["pve2"]["local"] is True
|
|
assert nodes["pve1"]["local"] is False
|
|
|
|
|
|
class TestStandalone:
|
|
STATUS = [
|
|
{
|
|
"type": "node",
|
|
"id": "node/pve1",
|
|
"name": "pve1",
|
|
"nodeid": 0,
|
|
"ip": "10.0.0.1",
|
|
"local": 1,
|
|
"online": 1,
|
|
"level": "",
|
|
}
|
|
]
|
|
RESOURCES = [
|
|
_node_row("pve1", 32, 0.25, 128 * GIB, 64 * GIB),
|
|
_storage_row("pve1", "local", "dir", 0, "iso,vztmpl,backup", 100 * GIB, 5 * GIB),
|
|
]
|
|
|
|
def test_a_cluster_of_one_without_name(self):
|
|
cluster = _cluster(cluster_status=self.STATUS, resources=self.RESOURCES, ha=RuntimeError())
|
|
assert cluster["id"] is None
|
|
assert cluster["name"] is None
|
|
assert cluster["quorate"] is None
|
|
[node] = cluster["nodes"]
|
|
assert node["name"] == "pve1"
|
|
assert node["status"] == "online"
|
|
assert node["local"] is True
|
|
assert node["cpu_cores"] == 16
|
|
assert node["memory_total"] == 128 * GIB
|
|
assert _by_name(cluster["storages"])["local"]["nodes"] == ["pve1"]
|
|
|
|
|
|
class TestStorages:
|
|
def test_local_storage_grouped_over_its_nodes(self):
|
|
lvm = _by_name(_cluster()["storages"])["local-lvm"]
|
|
assert lvm == {
|
|
"name": "local-lvm",
|
|
"type": "lvmthin",
|
|
"shared": False,
|
|
"content": ["rootdir", "images"],
|
|
# pve3 is offline: its storage is "unknown", not available.
|
|
"nodes": ["pve1", "pve2"],
|
|
# Separate disks on each node: their sizes add up.
|
|
"total": 600 * GIB,
|
|
"used": 150 * GIB,
|
|
}
|
|
|
|
def test_shared_storage_counted_once(self):
|
|
ceph = _by_name(_cluster()["storages"])["ceph-vm"]
|
|
assert ceph["shared"] is True
|
|
assert ceph["type"] == "rbd"
|
|
assert ceph["nodes"] == ["pve1", "pve2"]
|
|
assert ceph["total"] == 3000 * GIB
|
|
assert ceph["used"] == 1000 * GIB
|
|
|
|
def test_storage_unavailable_on_a_node_leaves_it_out(self):
|
|
nfs = _by_name(_cluster()["storages"])["nfs-iso"]
|
|
assert nfs["nodes"] == ["pve1"]
|
|
assert nfs["content"] == ["iso", "vztmpl", "snippets"]
|
|
assert nfs["total"] == 1000 * GIB
|
|
|
|
def test_storage_available_nowhere_has_no_size(self):
|
|
resources = [
|
|
*CLUSTER_RESOURCES[:3],
|
|
_storage_row("pve1", "nas", "cifs", 1, "backup", 0, 0, status="unavailable"),
|
|
]
|
|
nas = _by_name(_cluster(resources=resources)["storages"])["nas"]
|
|
assert nas["nodes"] == []
|
|
assert nas["total"] is None
|
|
assert nas["used"] is None
|
|
|
|
|
|
class TestNetworks:
|
|
def test_bridge_merged_across_nodes_vlan_aware_only_if_everywhere(self):
|
|
vmbr0 = _by_name(_cluster()["networks"])["vmbr0"]
|
|
assert vmbr0 == {
|
|
"name": "vmbr0",
|
|
"kind": "bridge",
|
|
"vlan_aware": False,
|
|
"nodes": ["pve1", "pve2"],
|
|
}
|
|
|
|
def test_bridge_on_one_node(self):
|
|
networks = _by_name(_cluster()["networks"])
|
|
assert networks["vmbr9"]["nodes"] == ["pve1"]
|
|
assert networks["vmbr1"] == {
|
|
"name": "vmbr1",
|
|
"kind": "bridge",
|
|
"vlan_aware": True,
|
|
"nodes": ["pve2"],
|
|
}
|
|
|
|
def test_vlan_aware_on_every_node(self):
|
|
network = {
|
|
n: [dict(i, bridge_vlan_aware=1) for i in NODE_NETWORK["pve1"]] for n in NODE_NETWORK
|
|
}
|
|
assert _by_name(_cluster(node_network=network)["networks"])["vmbr0"]["vlan_aware"] is True
|
|
|
|
def test_vnet_on_its_zones_nodes(self):
|
|
dmz = _by_name(_cluster()["networks"])["dmz"]
|
|
assert dmz == {
|
|
"name": "dmz",
|
|
"kind": "vnet",
|
|
"vlan_aware": False,
|
|
"fixed_vlan_tag": 30,
|
|
"nodes": ["pve2"],
|
|
}
|
|
|
|
def test_vnet_of_a_zone_without_nodes_is_everywhere(self):
|
|
overlay = _by_name(_cluster()["networks"])["overlay"]
|
|
assert overlay["nodes"] == ["pve1", "pve2", "pve3"]
|
|
assert overlay["fixed_vlan_tag"] == 100000
|
|
|
|
def test_get_network_targets_unchanged_for_the_own_node(self):
|
|
targets = _by_name(_driver(_api()).get_network_targets())
|
|
assert targets["vmbr0"] == {
|
|
"name": "vmbr0",
|
|
"kind": "bridge",
|
|
"vlan_aware": True,
|
|
"uplinks": [["eno1"]],
|
|
}
|
|
assert targets["dmz"]["fixed_vlan_tag"] == 30
|
|
|
|
|
|
class TestMaintenance:
|
|
def test_ha_reports_maintenance(self):
|
|
nodes = _by_name(_cluster()["nodes"])
|
|
assert nodes["pve1"]["maintenance"] is False
|
|
assert nodes["pve2"]["maintenance"] is True
|
|
|
|
def test_ha_unreadable_leaves_maintenance_unknown(self):
|
|
nodes = _cluster(ha=RuntimeError("403 Forbidden: Permission check failed"))["nodes"]
|
|
assert [n["maintenance"] for n in nodes] == [None, None, None]
|
|
|
|
def test_node_the_ha_manager_does_not_track_is_unknown(self):
|
|
ha = {"manager_status": {"node_status": {"pve1": "online"}}, "quorum": {}}
|
|
nodes = _by_name(_cluster(ha=ha)["nodes"])
|
|
assert nodes["pve1"]["maintenance"] is False
|
|
assert nodes["pve2"]["maintenance"] is None
|
|
|
|
|
|
class TestReadFailures:
|
|
def test_cluster_resources_unreadable_raises(self):
|
|
api = _api()
|
|
api.cluster.resources.get.side_effect = ConnectionError("pveproxy down")
|
|
with pytest.raises(ConnectionError):
|
|
_driver(api).get_clusters()
|
|
|
|
def test_cluster_status_unreadable_raises(self):
|
|
api = _api()
|
|
drv = _driver(api)
|
|
api.cluster.status.get.side_effect = ConnectionError("pveproxy down")
|
|
with pytest.raises(ConnectionError):
|
|
drv.get_clusters()
|
|
|
|
def test_own_node_status_unreadable_raises(self):
|
|
status = {"pve2": NODE_STATUS["pve2"]}
|
|
with pytest.raises(ConnectionError):
|
|
_driver(_api(node_status=status)).get_clusters()
|
|
|
|
def test_other_node_status_unreadable_leaves_its_cpu_unknown(self):
|
|
status = {"pve1": NODE_STATUS["pve1"]}
|
|
pve2 = _by_name(_cluster(node_status=status)["nodes"])["pve2"]
|
|
assert pve2["status"] == "online"
|
|
assert pve2["cpu_cores"] is None
|
|
assert pve2["cpu_model"] is None
|
|
assert pve2["cpu_flags"] is None
|
|
# What /cluster/resources says still stands.
|
|
assert pve2["cpu_threads"] == 16
|
|
|
|
|
|
class TestCreateOnAnotherNode:
|
|
def test_other_node_raises_before_anything_is_created(self):
|
|
api = _api()
|
|
drv = _driver(api)
|
|
with pytest.raises(ValueError, match="pve2"):
|
|
drv.create_vm_from_cloud_init(
|
|
"vm1",
|
|
image_url="https://cloud.debian.org/images/cloud/trixie/latest/debian-13-genericcloud-amd64.qcow2",
|
|
cpu=2,
|
|
memory=2048,
|
|
nics=[{"bridge": "vmbr0"}],
|
|
cloud_init_config={},
|
|
node="pve2",
|
|
)
|
|
api.cluster.nextid.get.assert_not_called()
|
|
for res in [api.nodes(n) for n in ("pve1", "pve2")]:
|
|
assert not [c for c in res.mock_calls if "post" in c[0]]
|