driver / standard (pull_request) Successful in 14s
driver / lint (pull_request) Successful in 13s
driver / types (pull_request) Failing after 1m2s
driver / test (3.12) (pull_request) Failing after 57s
driver / test (3.13) (pull_request) Failing after 52s
driver / lowest (pull_request) Failing after 25s
driver / build (pull_request) Successful in 24s
driver / security (pull_request) Successful in 57s
CI / driver (pull_request) Failing after 2m21s
driver / publish (pull_request) Skipped
vCenter reports each cluster compute resource, and each standalone host it runs as a cluster of one, identified by "<instanceUuid>/<moref>"; an ESXi host reports itself. Nodes carry state, maintenance, CPU and memory; datastores and port groups carry the hosts that see them. create_vm_from_cloud_init(node=) places the VM on that host and refuses one that does not exist or cannot take it, before anything is created. Placement now runs before the image download, so a refused host fails at once instead of after the download. Refs NetOrk/netork#484, NetOrk/netork#1822
148 lines
5.4 KiB
Python
148 lines
5.4 KiB
Python
"""Where a new VM goes: a pure decision over plain inventory rows.
|
|
|
|
A host qualifies when it is connected, not in maintenance mode, and sees both
|
|
a usable datastore and every requested network. Among those, the pair with
|
|
the most free space wins -- or the named datastore, when one is given; a
|
|
named host narrows the choice to that host and is refused if it does not
|
|
qualify. The resource pool comes from the host's compute resource and the VM
|
|
folder from the datacenter above it; a standalone ESXi host has the same shape
|
|
(``ha-compute-res`` under ``ha-datacenter``), so one path serves both.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass, field
|
|
from typing import Any
|
|
|
|
Row = dict[str, Any]
|
|
|
|
|
|
class NodeRefused(ValueError):
|
|
"""The host named for a new VM does not exist or cannot take it."""
|
|
|
|
|
|
@dataclass
|
|
class Inventory:
|
|
hosts: list[Row]
|
|
datastores: list[Row]
|
|
networks: list[Row]
|
|
compute_resources: list[Row]
|
|
folders: list[Row] = field(default_factory=list)
|
|
datacenters: list[Row] = field(default_factory=list)
|
|
|
|
|
|
@dataclass
|
|
class Placement:
|
|
host: str
|
|
host_name: str
|
|
datastore: str
|
|
datastore_name: str
|
|
resource_pool: str
|
|
folder: str
|
|
datacenter_name: str
|
|
networks: list[str]
|
|
|
|
|
|
def _usable_datastores(inv: Inventory, storage: str | None) -> dict[str, Row]:
|
|
usable = {
|
|
ds["_moref"]: ds
|
|
for ds in inv.datastores
|
|
if (ds.get("summary") or {}).get("accessible")
|
|
and (ds.get("summary") or {}).get("maintenanceMode", "normal") == "normal"
|
|
and (storage is None or ds.get("name") == storage)
|
|
}
|
|
if storage is not None and not usable:
|
|
raise ValueError(f"There is no usable datastore named {storage!r}")
|
|
return usable
|
|
|
|
|
|
def _host_networks(
|
|
host: Row, names_by_moref: dict[str, str], wanted: list[str]
|
|
) -> list[str] | None:
|
|
"""The host's network moref for each wanted name, or None if one is missing."""
|
|
by_name = {names_by_moref.get(m): m for m in host.get("network") or []}
|
|
found = [by_name.get(name) for name in wanted]
|
|
return None if None in found else [m for m in found if m]
|
|
|
|
|
|
def _datacenter(inv: Inventory, compute_resource: str) -> Row:
|
|
parents = {row["_moref"]: row.get("parent") for row in inv.compute_resources + inv.folders}
|
|
datacenters = {dc["_moref"]: dc for dc in inv.datacenters}
|
|
node: str | None = compute_resource
|
|
while node is not None and node not in datacenters:
|
|
node = parents.get(node)
|
|
if node is None:
|
|
raise RuntimeError(f"No datacenter above {compute_resource!r}")
|
|
return datacenters[node]
|
|
|
|
|
|
def _refusal(host: Row) -> str | None:
|
|
"""Why ``host`` cannot take a new VM, or None if it can."""
|
|
if host.get("runtime.connectionState") != "connected":
|
|
return "is not connected"
|
|
if host.get("runtime.inMaintenanceMode"):
|
|
return "is in maintenance mode"
|
|
return None
|
|
|
|
|
|
def _candidates(inv: Inventory, host_name: str | None) -> list[Row]:
|
|
"""The hosts placement may choose from: every eligible one, or the named one."""
|
|
hosts = sorted(inv.hosts, key=lambda h: h.get("name", ""))
|
|
if host_name is None:
|
|
return [h for h in hosts if _refusal(h) is None]
|
|
named = [h for h in hosts if h.get("name") == host_name]
|
|
if not named:
|
|
raise NodeRefused(f"There is no host named {host_name!r}")
|
|
reason = _refusal(named[0])
|
|
if reason:
|
|
raise NodeRefused(f"Host {host_name} {reason}")
|
|
return named[:1]
|
|
|
|
|
|
def _best(
|
|
hosts: list[Row], usable: dict[str, Row], names: dict[str, str], networks: list[str]
|
|
) -> tuple[Row, Row, list[str]] | None:
|
|
"""The host/datastore pair with the most free space, and the host's networks."""
|
|
best: tuple[int, Row, Row, list[str]] | None = None
|
|
for host in hosts:
|
|
host_nets = _host_networks(host, names, networks)
|
|
if host_nets is None:
|
|
continue
|
|
for ds_ref in host.get("datastore") or []:
|
|
ds = usable.get(ds_ref)
|
|
free = int((ds or {}).get("summary", {}).get("freeSpace", 0))
|
|
if ds is not None and (best is None or free > best[0]):
|
|
best = (free, host, ds, host_nets)
|
|
return best[1:] if best else None
|
|
|
|
|
|
def choose_placement(
|
|
inv: Inventory, storage: str | None, networks: list[str], *, host_name: str | None = None
|
|
) -> Placement:
|
|
"""Where a VM on ``storage`` with ``networks`` goes; ``host_name`` pins the host.
|
|
|
|
Raises NodeRefused (a ValueError) when the named host does not exist or
|
|
cannot take the VM, and ValueError when no host can.
|
|
"""
|
|
usable = _usable_datastores(inv, storage)
|
|
names = {n["_moref"]: n.get("name", "") for n in inv.networks}
|
|
best = _best(_candidates(inv, host_name), usable, names, networks)
|
|
wanted = f"datastore {storage or '(any)'} and networks {networks}"
|
|
if best is None and host_name is not None:
|
|
raise NodeRefused(f"Host {host_name} does not see {wanted}")
|
|
if best is None:
|
|
raise ValueError(f"There is no host that sees {wanted}")
|
|
host, ds, host_nets = best
|
|
compute = next(c for c in inv.compute_resources if c["_moref"] == host.get("parent"))
|
|
dc = _datacenter(inv, compute["_moref"])
|
|
return Placement(
|
|
host=host["_moref"],
|
|
host_name=host.get("name", ""),
|
|
datastore=ds["_moref"],
|
|
datastore_name=ds.get("name", ""),
|
|
resource_pool=compute["resourcePool"],
|
|
folder=dc["vmFolder"],
|
|
datacenter_name=dc.get("name", ""),
|
|
networks=host_nets,
|
|
)
|