You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3381 lines
160 KiB
Python
3381 lines
160 KiB
Python
"""Contract tests for the libvirt boundary; no hypervisor is required."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import importlib.util
|
|
import pathlib
|
|
import sys
|
|
import tempfile
|
|
import types
|
|
import unittest
|
|
import uuid
|
|
import copy
|
|
import xml.etree.ElementTree as ET
|
|
from unittest.mock import patch
|
|
|
|
|
|
SERVICE_PATH = pathlib.Path(__file__).resolve().parents[1] / "virsh_panel" / "libvirt_service.py"
|
|
TEMPLATE_NAME = "panel-template-alma10-12345678-0123456789abcdef.qcow2"
|
|
DEBIAN_12_TEMPLATE_NAME = (
|
|
"panel-template-debian12-12345678-0123456789abcdef.qcow2"
|
|
)
|
|
DEBIAN_12_TEMPLATE_REPLICA = (
|
|
"panel-template-debian12-12345678-0123456789abcdef-1111111111111111.qcow2"
|
|
)
|
|
DEBIAN_13_TEMPLATE_NAME = (
|
|
"panel-template-debian13-12345678-0123456789abcdef.qcow2"
|
|
)
|
|
TEMPLATE_REPLICA_ONE = (
|
|
"panel-template-alma10-12345678-0123456789abcdef-1111111111111111.qcow2"
|
|
)
|
|
TEMPLATE_REPLICA_TWO = (
|
|
"panel-template-alma10-12345678-0123456789abcdef-2222222222222222.qcow2"
|
|
)
|
|
RESCUE_NAME = "panel-rescue-0123456789abcdef0123456789abcdef.iso"
|
|
USER_ISO_ID = "abcdef0123456789abcdef0123456789"
|
|
USER_ISO_NAME = f"panel-user-iso-{USER_ISO_ID}.iso"
|
|
|
|
|
|
def bootable_iso_bytes():
|
|
image = bytearray(1024 * 1024)
|
|
boot = memoryview(image)[16 * 2048:17 * 2048]
|
|
boot[0] = 0
|
|
boot[1:6] = b"CD001"
|
|
boot[6] = 1
|
|
boot[7:30] = b"EL TORITO SPECIFICATION"
|
|
boot[71:75] = (20).to_bytes(4, "little")
|
|
end = memoryview(image)[17 * 2048:18 * 2048]
|
|
end[0] = 255
|
|
end[1:6] = b"CD001"
|
|
end[6] = 1
|
|
return bytes(image)
|
|
|
|
|
|
class FakeLibvirtError(Exception):
|
|
pass
|
|
|
|
|
|
class FakeVolume:
|
|
_timestamp_counter = 1_700_000_000
|
|
|
|
def __init__(self, pool, name, *, capacity=0, fmt="qcow2"):
|
|
self.pool = pool
|
|
self._name = name
|
|
self.capacity = capacity
|
|
self.format = fmt
|
|
self.contents = bytearray()
|
|
self.cloned_from = None
|
|
# libvirt exposes these output-only filesystem timestamps in volume
|
|
# XML. Every new FakeVolume instance represents a new generation even
|
|
# when a deleted volume is recreated with the same name and size.
|
|
FakeVolume._timestamp_counter += 1
|
|
generation = str(FakeVolume._timestamp_counter)
|
|
self.btime = generation
|
|
self.ctime = generation
|
|
self.mtime = generation
|
|
|
|
def name(self):
|
|
return self._name
|
|
|
|
def path(self):
|
|
return f"{self.pool.path}/{self._name}"
|
|
|
|
def info(self):
|
|
return (0, self.capacity, len(self.contents), 0)
|
|
|
|
def XMLDesc(self, flags):
|
|
assert flags == 0
|
|
root = ET.Element("volume")
|
|
ET.SubElement(root, "name").text = self._name
|
|
ET.SubElement(root, "capacity", unit="bytes").text = str(self.capacity)
|
|
target = ET.SubElement(root, "target")
|
|
ET.SubElement(target, "format", type=self.format)
|
|
timestamps = ET.SubElement(target, "timestamps")
|
|
ET.SubElement(timestamps, "atime").text = "1800000000"
|
|
ET.SubElement(timestamps, "mtime").text = self.mtime
|
|
ET.SubElement(timestamps, "ctime").text = self.ctime
|
|
ET.SubElement(timestamps, "btime").text = self.btime
|
|
return ET.tostring(root, encoding="unicode")
|
|
|
|
def resize(self, capacity, flags):
|
|
assert flags == 0
|
|
assert capacity >= self.capacity
|
|
self.capacity = capacity
|
|
|
|
def upload(self, stream, offset, length, flags):
|
|
assert offset == 0 and flags == 0
|
|
if self.pool.backend.fail_upload:
|
|
raise FakeLibvirtError("upload failed")
|
|
stream.volume = self
|
|
stream.expected_length = length
|
|
self.contents.clear()
|
|
|
|
def download(self, stream, offset, length, flags):
|
|
assert offset == 0 and flags == 0
|
|
assert 0 <= length <= max(self.capacity, len(self.contents))
|
|
stream.volume = self
|
|
stream.download_data = bytes(self.contents[:length])
|
|
stream.read_offset = 0
|
|
|
|
def delete(self, flags):
|
|
assert flags == 0
|
|
if self.pool.backend.fail_volume_delete:
|
|
raise FakeLibvirtError("volume delete failed")
|
|
self.pool.backend.deleted_volumes.append(self._name)
|
|
del self.pool.volumes[self._name]
|
|
|
|
|
|
class FakePool:
|
|
def __init__(self, backend, name, path, names=(), active=True, persistent=True,
|
|
pool_type="dir"):
|
|
self.backend = backend
|
|
self._name = name
|
|
self.path = path
|
|
self.volumes = {name: FakeVolume(self, name) for name in names}
|
|
self.external_names = set()
|
|
self.refreshes = 0
|
|
self.active = active
|
|
self.persistent = persistent
|
|
self.pool_type = pool_type
|
|
self.auto_start = False
|
|
|
|
def name(self):
|
|
return self._name
|
|
|
|
def XMLDesc(self, flags):
|
|
assert flags == 0
|
|
root = ET.Element("pool", type=self.pool_type)
|
|
ET.SubElement(root, "name").text = self._name
|
|
ET.SubElement(ET.SubElement(root, "target"), "path").text = self.path
|
|
return ET.tostring(root, encoding="unicode")
|
|
|
|
def create(self, flags):
|
|
assert flags == 0
|
|
if self.path not in self.backend.existing_dirs:
|
|
raise FakeLibvirtError("target directory missing")
|
|
self.active = True
|
|
self.backend.started.append(self._name)
|
|
|
|
def setAutostart(self, enabled):
|
|
assert enabled == 1
|
|
self.auto_start = True
|
|
self.backend.autostart_changed.append(self._name)
|
|
|
|
def autostart(self):
|
|
return self.auto_start
|
|
|
|
def isPersistent(self):
|
|
return self.persistent
|
|
|
|
def destroy(self):
|
|
self.active = False
|
|
self.backend.destroyed.append(self._name)
|
|
|
|
def undefine(self):
|
|
del self.backend.pools[self._name]
|
|
self.backend.undefined.append(self._name)
|
|
|
|
def build(self, flags):
|
|
assert flags == 0
|
|
parent = str(pathlib.PurePosixPath(self.path).parent)
|
|
name = pathlib.PurePosixPath(self.path).name
|
|
if parent not in self.backend.existing_dirs or not name.isdecimal():
|
|
raise AssertionError(
|
|
"pool.build may only create a numeric user directory below an existing root")
|
|
self.backend.existing_dirs.add(self.path)
|
|
self.backend.built.append(self.path)
|
|
|
|
def isActive(self):
|
|
return self.active
|
|
|
|
def listVolumes(self):
|
|
return list(self.volumes)
|
|
|
|
def refresh(self, flags):
|
|
assert flags == 0
|
|
if not self.active:
|
|
raise FakeLibvirtError("pool is inactive")
|
|
self.refreshes += 1
|
|
for name in self.external_names:
|
|
self.volumes.setdefault(name, FakeVolume(self, name))
|
|
|
|
def info(self):
|
|
return (2, 100 * 1024**3, 10 * 1024**3, 90 * 1024**3)
|
|
|
|
def createXML(self, xml, flags):
|
|
assert flags == 0
|
|
root = ET.fromstring(xml)
|
|
name = root.findtext("name")
|
|
fmt = root.find("./target/format").get("type")
|
|
assert fmt in ("qcow2", "raw")
|
|
if name in self.volumes or name in self.external_names:
|
|
raise FakeLibvirtError("volume exists")
|
|
capacity = int(root.findtext("capacity", "0"))
|
|
volume = FakeVolume(self, name, capacity=capacity, fmt=fmt)
|
|
self.volumes[name] = volume
|
|
return volume
|
|
|
|
def createXMLFrom(self, xml, source_volume, flags):
|
|
assert flags == 0
|
|
if self.backend.fail_clone:
|
|
raise FakeLibvirtError("clone failed")
|
|
assert source_volume.name() in self.volumes
|
|
volume = self.createXML(xml, 0)
|
|
volume.cloned_from = source_volume.name()
|
|
self.backend.clones.append((volume.name(), source_volume.name()))
|
|
return volume
|
|
|
|
def storageVolLookupByName(self, name):
|
|
return self.volumes[name]
|
|
|
|
|
|
class FakeDomain:
|
|
def __init__(self, backend, xml, *, persistent=True, running=False):
|
|
self.backend = backend
|
|
root = self._parse_xml(xml)
|
|
self._uuid = root.findtext("uuid")
|
|
self.running = running
|
|
self.persistent = persistent
|
|
self.auto_start = False
|
|
self.live_root = root if running else None
|
|
self.inactive_root = copy.deepcopy(root) if persistent else None
|
|
self.snapshots = 0
|
|
self.last_reset_flags = None
|
|
|
|
@staticmethod
|
|
def _parse_xml(xml):
|
|
root = ET.fromstring(xml)
|
|
os_node = root.find("os")
|
|
if os_node is not None and os_node.get("firmware") == "efi" \
|
|
and os_node.find("nvram") is None:
|
|
# libvirt adds an NVRAM image when it resolves firmware='efi'.
|
|
ET.SubElement(os_node, "nvram").text = (
|
|
f"/var/lib/libvirt/qemu/nvram/{root.findtext('name')}_VARS.fd")
|
|
return root
|
|
|
|
@property
|
|
def root(self):
|
|
# Compatibility for tests examining the VM's current configuration.
|
|
return self.live_root if self.running else self.inactive_root
|
|
|
|
def define(self, xml):
|
|
root = self._parse_xml(xml)
|
|
assert root.findtext("uuid") == self._uuid
|
|
self.inactive_root = root
|
|
self.persistent = True
|
|
|
|
def UUIDString(self):
|
|
return self._uuid
|
|
|
|
def name(self):
|
|
return self.root.findtext("name")
|
|
|
|
def info(self):
|
|
return (1 if self.running else 5,
|
|
int(self.root.findtext("memory")) * 1024,
|
|
int(self.root.findtext("memory")) * 1024,
|
|
int(self.root.findtext("vcpu")), 0)
|
|
|
|
def blockInfo(self, identifier, flags):
|
|
assert flags == 0
|
|
for disk in self.root.findall("./devices/disk[@device='disk']"):
|
|
source = disk.find("source")
|
|
target = disk.find("target")
|
|
path = source.get("file") if source is not None else None
|
|
if identifier not in (path, target.get("dev") if target is not None else None):
|
|
continue
|
|
for pool in self.backend.pools.values():
|
|
for volume in pool.volumes.values():
|
|
if volume.path() == path:
|
|
return (volume.capacity, len(volume.contents), volume.capacity)
|
|
raise FakeLibvirtError("block capacity unavailable")
|
|
|
|
def XMLDesc(self, flags):
|
|
assert flags in (0, 1)
|
|
if flags == 1:
|
|
if not self.persistent:
|
|
raise FakeLibvirtError("transient domain has no inactive XML")
|
|
xml_root = copy.deepcopy(self.inactive_root)
|
|
else:
|
|
xml_root = copy.deepcopy(self.root)
|
|
graphics = xml_root.find("./devices/graphics")
|
|
if graphics is not None:
|
|
graphics.set("port", "5907" if self.running and flags == 0 else "-1")
|
|
return ET.tostring(xml_root, encoding="unicode")
|
|
|
|
def autostart(self):
|
|
return int(self.auto_start)
|
|
|
|
def setAutostart(self, enabled):
|
|
assert enabled in (0, 1)
|
|
if not self.persistent or self.backend.fail_domain_autostart:
|
|
raise FakeLibvirtError("domain autostart failed")
|
|
self.auto_start = bool(enabled)
|
|
self.backend.domain_autostart_changed.append(self._uuid)
|
|
|
|
@staticmethod
|
|
def _interface_identity(interface):
|
|
mac = interface.find("mac")
|
|
target = interface.find("target")
|
|
source = interface.find("source")
|
|
return (
|
|
mac.get("address") if mac is not None else None,
|
|
target.get("dev") if target is not None else None,
|
|
tuple(sorted(source.attrib.items())) if source is not None else (),
|
|
)
|
|
|
|
def updateDeviceFlags(self, xml, flags):
|
|
assert flags in (1, 2)
|
|
replacement = self._parse_xml(xml)
|
|
roots = [self.live_root] if flags == 1 else [self.inactive_root]
|
|
identity = self._interface_identity(replacement)
|
|
for root in roots:
|
|
if root is None:
|
|
raise FakeLibvirtError("requested domain definition is unavailable")
|
|
devices = root.find("devices")
|
|
for index, interface in enumerate(devices.findall("interface")):
|
|
if self._interface_identity(interface) == identity:
|
|
devices.remove(interface)
|
|
devices.insert(index, copy.deepcopy(replacement))
|
|
state = replacement.find("link").get("state")
|
|
self.backend.device_updates.append((self._uuid, state, flags))
|
|
break
|
|
else:
|
|
raise FakeLibvirtError("interface not found")
|
|
|
|
def isActive(self):
|
|
return self.running
|
|
|
|
def isPersistent(self):
|
|
return self.persistent
|
|
|
|
def create(self):
|
|
if not self.persistent:
|
|
raise FakeLibvirtError("cannot start a stopped transient domain")
|
|
if self.backend.fail_domain_create:
|
|
raise FakeLibvirtError("domain create failed")
|
|
interface = self.inactive_root.find("./devices/interface")
|
|
if (interface is not None and interface.get("type") == "bridge"
|
|
and not self.backend.bridge_active):
|
|
raise FakeLibvirtError("bridge does not exist")
|
|
self.live_root = copy.deepcopy(self.inactive_root)
|
|
self.running = True
|
|
self.backend.domain_starts += 1
|
|
if self.backend.fail_domain_create_after_start:
|
|
raise FakeLibvirtError("transport failed after domain started")
|
|
|
|
def guest_reboot(self):
|
|
"""Simulate a reboot initiated by an installer inside the guest."""
|
|
assert self.running
|
|
if self.live_root.findtext("on_reboot") == "destroy":
|
|
self.running = False
|
|
self.live_root = None
|
|
if not self.persistent:
|
|
self.backend.domains.remove(self)
|
|
|
|
def shutdown(self):
|
|
self.backend.shutdown_calls += 1
|
|
if self.backend.shutdown_stalls:
|
|
return
|
|
self.running = False
|
|
self.live_root = None
|
|
if not self.persistent:
|
|
self.backend.domains.remove(self)
|
|
|
|
def reboot(self):
|
|
assert self.running
|
|
self.guest_reboot()
|
|
|
|
def destroy(self):
|
|
if self.backend.fail_destroy:
|
|
raise FakeLibvirtError("domain destroy failed")
|
|
self.backend.destroy_calls += 1
|
|
self.running = False
|
|
self.live_root = None
|
|
if not self.persistent:
|
|
self.backend.domains.remove(self)
|
|
|
|
def reset(self, flags):
|
|
self.last_reset_flags = flags
|
|
|
|
def snapshotNum(self, flags):
|
|
return self.snapshots
|
|
|
|
def hasManagedSaveImage(self, flags):
|
|
assert flags == 0
|
|
return 0
|
|
|
|
def undefineFlags(self, flags):
|
|
assert flags in (4, 8)
|
|
if self.backend.fail_undefine:
|
|
raise FakeLibvirtError("domain undefine failed")
|
|
self.backend.undefine_flags.append(flags)
|
|
self.persistent = False
|
|
self.backend.domains.remove(self)
|
|
|
|
def undefine(self):
|
|
if self.backend.fail_undefine:
|
|
raise FakeLibvirtError("domain undefine failed")
|
|
if self.root.find("./os/nvram") is not None:
|
|
raise FakeLibvirtError("UEFI domain requires an NVRAM undefine flag")
|
|
self.persistent = False
|
|
self.backend.domains.remove(self)
|
|
|
|
|
|
class FakeConnection:
|
|
def __init__(self, backend):
|
|
self.backend = backend
|
|
|
|
def close(self):
|
|
self.backend.closed += 1
|
|
|
|
def listAllDomains(self, flags):
|
|
assert flags == 0
|
|
return list(self.backend.domains)
|
|
|
|
def lookupByUUIDString(self, vm_uuid):
|
|
for domain in self.backend.domains:
|
|
if domain.UUIDString() == vm_uuid:
|
|
return domain
|
|
raise FakeLibvirtError("domain not found")
|
|
|
|
def getInfo(self):
|
|
return self.backend.node_info
|
|
|
|
def storagePoolLookupByName(self, name):
|
|
try:
|
|
return self.backend.pools[name]
|
|
except KeyError as exc:
|
|
raise FakeLibvirtError("pool not found") from exc
|
|
|
|
def listAllStoragePools(self, flags):
|
|
assert flags == 0
|
|
return list(self.backend.pools.values())
|
|
|
|
def storagePoolDefineXML(self, xml, flags):
|
|
assert flags == 0
|
|
root = ET.fromstring(xml)
|
|
assert root.get("type") == "dir"
|
|
name = root.findtext("name")
|
|
path = root.findtext("./target/path")
|
|
if name in self.backend.pools:
|
|
raise FakeLibvirtError("pool name already exists")
|
|
pool = FakePool(self.backend, name, path, active=False)
|
|
self.backend.pools[name] = pool
|
|
self.backend.defined.append((name, path))
|
|
return pool
|
|
|
|
def networkLookupByName(self, name):
|
|
assert name == self.backend.network_name
|
|
self.backend.network_lookups.append(name)
|
|
return types.SimpleNamespace(isActive=lambda: self.backend.network_active)
|
|
|
|
def nwfilterLookupByName(self, name):
|
|
if name not in self.backend.nwfilters:
|
|
raise FakeLibvirtError("network filter not found")
|
|
return types.SimpleNamespace(name=lambda: name)
|
|
|
|
def defineXML(self, xml):
|
|
if self.backend.fail_define:
|
|
raise FakeLibvirtError("define failed")
|
|
root = ET.fromstring(xml)
|
|
self.backend.define_xmls.append(root)
|
|
vm_uuid = root.findtext("uuid")
|
|
for domain in self.backend.domains:
|
|
if domain.UUIDString() == vm_uuid:
|
|
domain.define(xml)
|
|
return domain
|
|
domain = FakeDomain(self.backend, xml)
|
|
self.backend.domains.append(domain)
|
|
return domain
|
|
|
|
def createXML(self, xml, flags):
|
|
assert flags == 0
|
|
if self.backend.fail_create:
|
|
raise FakeLibvirtError("createXML failed")
|
|
root = ET.fromstring(xml)
|
|
self.backend.create_xmls.append(root)
|
|
interface = root.find("./devices/interface")
|
|
if (interface is not None and interface.get("type") == "bridge"
|
|
and not self.backend.bridge_active):
|
|
raise FakeLibvirtError("bridge does not exist")
|
|
domain = FakeDomain(self.backend, xml, persistent=False, running=True)
|
|
self.backend.domains.append(domain)
|
|
return domain
|
|
|
|
def newStream(self, flags):
|
|
assert flags == 0
|
|
stream = FakeStream(self.backend)
|
|
self.backend.streams.append(stream)
|
|
return stream
|
|
|
|
|
|
class FakeStream:
|
|
def __init__(self, backend):
|
|
self.backend = backend
|
|
self.volume = None
|
|
self.expected_length = None
|
|
self.finished = False
|
|
self.aborted = False
|
|
self.download_data = None
|
|
self.read_offset = 0
|
|
|
|
def send(self, data):
|
|
if self.backend.fail_send:
|
|
raise FakeLibvirtError("stream send failed")
|
|
assert self.volume is not None
|
|
self.volume.contents.extend(data)
|
|
return len(data)
|
|
|
|
def finish(self):
|
|
assert self.volume is not None
|
|
if self.download_data is None:
|
|
assert len(self.volume.contents) == self.expected_length
|
|
else:
|
|
assert self.read_offset == len(self.download_data)
|
|
self.finished = True
|
|
|
|
def recv(self, length):
|
|
assert self.download_data is not None
|
|
assert length > 0
|
|
chunk = self.download_data[self.read_offset:self.read_offset + length]
|
|
self.read_offset += len(chunk)
|
|
return chunk
|
|
|
|
def abort(self):
|
|
self.aborted = True
|
|
|
|
|
|
class FakeBackend:
|
|
def __init__(self):
|
|
self.domains = []
|
|
self.existing_dirs = {
|
|
"/var/lib/libvirt/images", "/var/lib/libvirt/iso",
|
|
"/home/kvm", "/home/iso", "/home/rescue",
|
|
}
|
|
self.pools = {
|
|
"images": FakePool(self, "images", "/var/lib/libvirt/images"),
|
|
"iso": FakePool(self, "iso", "/var/lib/libvirt/iso",
|
|
("AlmaLinux-10.iso", "notes.txt")),
|
|
}
|
|
self.defined = []
|
|
self.built = []
|
|
self.started = []
|
|
self.autostart_changed = []
|
|
self.domain_autostart_changed = []
|
|
self.device_updates = []
|
|
self.destroyed = []
|
|
self.undefined = []
|
|
self.undefine_flags = []
|
|
self.create_xmls = []
|
|
self.define_xmls = []
|
|
self.clones = []
|
|
self.deleted_volumes = []
|
|
self.domain_starts = 0
|
|
self.shutdown_calls = 0
|
|
self.destroy_calls = 0
|
|
self.shutdown_stalls = False
|
|
self.streams = []
|
|
self.network_active = True
|
|
self.network_name = "default"
|
|
self.network_lookups = []
|
|
self.nwfilters = {"clean-traffic"}
|
|
self.node_info = ("x86_64", 0, 0, 0, 0, 0, 0, 0)
|
|
self.bridge_active = True
|
|
self.fail_define = False
|
|
self.fail_create = False
|
|
self.fail_domain_create = False
|
|
self.fail_domain_create_after_start = False
|
|
self.fail_domain_autostart = False
|
|
self.fail_destroy = False
|
|
self.fail_undefine = False
|
|
self.fail_volume_delete = False
|
|
self.fail_clone = False
|
|
self.fail_upload = False
|
|
self.fail_send = False
|
|
self.opened = 0
|
|
self.closed = 0
|
|
|
|
def open(self, uri):
|
|
assert uri == "qemu+ssh://panel@hypervisor/system"
|
|
self.opened += 1
|
|
return FakeConnection(self)
|
|
|
|
|
|
class VMServiceTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.backend = FakeBackend()
|
|
fake_libvirt = types.ModuleType("libvirt")
|
|
fake_libvirt.libvirtError = FakeLibvirtError
|
|
fake_libvirt.VIR_DOMAIN_UNDEFINE_NVRAM = 4
|
|
fake_libvirt.VIR_DOMAIN_UNDEFINE_KEEP_NVRAM = 8
|
|
fake_libvirt.VIR_DOMAIN_XML_INACTIVE = 1
|
|
fake_libvirt.VIR_DOMAIN_AFFECT_LIVE = 1
|
|
fake_libvirt.VIR_DOMAIN_AFFECT_CONFIG = 2
|
|
fake_libvirt.open = self.backend.open
|
|
module_spec = importlib.util.spec_from_file_location("service_under_test", SERVICE_PATH)
|
|
self.assertIsNotNone(module_spec)
|
|
module = importlib.util.module_from_spec(module_spec)
|
|
with patch.dict(sys.modules, {"libvirt": fake_libvirt}):
|
|
module_spec.loader.exec_module(module)
|
|
self.service_module = module
|
|
self.service = module.VMService(
|
|
"qemu+ssh://panel@hypervisor/system", "images", "iso", "default",
|
|
rescue_iso_pool="/home/rescue")
|
|
self.error_type = module.VMError
|
|
|
|
@staticmethod
|
|
def spec(**changes):
|
|
data = {
|
|
"name": "alma-test",
|
|
"vcpu": 2,
|
|
"memory_mib": 2048,
|
|
"disk_gib": 20,
|
|
"network": "default",
|
|
"iso": "AlmaLinux-10.iso",
|
|
}
|
|
data.update(changes)
|
|
return data
|
|
|
|
def test_package_bandwidth_is_enforced_both_directions(self):
|
|
spec = self.service._validate_create(self.spec(bandwidth_mbps=100))
|
|
xml = self.service._domain_xml(spec, "00000000-0000-4000-8000-000000000001",
|
|
"alma-test.qcow2", ("file", {"file": "/home/kvm/alma-test.qcow2"}),
|
|
("file", {"file": "/home/iso/AlmaLinux-10.iso"}), install_phase=True)
|
|
root = ET.fromstring(xml)
|
|
for direction in ("inbound", "outbound"):
|
|
limiter = root.find(f"./devices/interface/bandwidth/{direction}")
|
|
self.assertEqual(limiter.get("average"), "12208")
|
|
self.assertEqual(limiter.get("peak"), "12208")
|
|
cloud_xml = self.service._cloud_domain_xml(spec, "00000000-0000-4000-8000-000000000001",
|
|
"alma-test.qcow2", ("file", {"file": "/home/kvm/alma-test.qcow2"}),
|
|
"panel-seed.iso", ("file", {"file": "/home/kvm/panel-seed.iso"}),
|
|
"52:54:00:12:34:56", "8.8.8.18/24")
|
|
self.assertIsNotNone(ET.fromstring(cloud_xml).find("./devices/interface/bandwidth"))
|
|
|
|
def test_bridge_cloud_xml_binds_clean_traffic_to_public_ip(self):
|
|
service = self.cloud_service()
|
|
xml = service._cloud_domain_xml(
|
|
self.cloud_spec(), "00000000-0000-4000-8000-000000000001",
|
|
"cloud-vm.qcow2", ("file", {"file": "/home/kvm/cloud-vm.qcow2"}),
|
|
"panel-seed.iso", ("file", {"file": "/home/kvm/panel-seed.iso"}),
|
|
"52:54:00:12:34:56", "8.8.8.18/24",
|
|
)
|
|
root = ET.fromstring(xml)
|
|
filterref = root.find("./devices/interface/filterref")
|
|
self.assertIsNotNone(filterref)
|
|
self.assertEqual(filterref.get("filter"), "clean-traffic")
|
|
parameter = filterref.find("parameter")
|
|
self.assertIsNotNone(parameter)
|
|
self.assertEqual(parameter.get("name"), "IP")
|
|
self.assertEqual(parameter.get("value"), "8.8.8.18")
|
|
|
|
def test_cloud_create_stops_before_storage_when_clean_traffic_is_missing(self):
|
|
service = self.cloud_service()
|
|
self.backend.nwfilters.clear()
|
|
image_names = set(self.backend.pools["images"].volumes)
|
|
|
|
with self.assertRaises(self.error_type) as raised:
|
|
self.create_cloud_vm(service, self.cloud_spec())
|
|
|
|
self.assertEqual(raised.exception.status, 502)
|
|
self.assertIn("clean-traffic", str(raised.exception))
|
|
self.assertEqual(set(self.backend.pools["images"].volumes), image_names)
|
|
self.assertEqual(self.backend.clones, [])
|
|
self.assertEqual(self.backend.domains, [])
|
|
|
|
def test_cloud_network_change_restarts_guest_and_updates_seed_and_filter(self):
|
|
service = self.cloud_service()
|
|
spec = self.cloud_spec()
|
|
created = self.create_cloud_vm(service, spec)
|
|
domain = self.backend.domains[0]
|
|
old_seed = domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed").get("seed-volume")
|
|
mac = domain.root.find("./devices/interface/mac").get("address")
|
|
network = {
|
|
"source_public_pool_key": "a" * 32,
|
|
"public_pool_key": "a" * 32,
|
|
"public_ip_cidr": "8.8.8.19/24",
|
|
"gateway": "8.8.8.1",
|
|
"dns_servers": ["1.1.1.1", "8.8.8.8"],
|
|
}
|
|
with patch.object(self.service_module, "read_seed_network", return_value={
|
|
"public_ip_cidr": "8.8.8.18/24", "gateway": "8.8.8.1",
|
|
"dns_servers": ["1.1.1.1", "8.8.8.8"],
|
|
"mac": mac,
|
|
}), patch.object(self.service_module, "replace_seed_network",
|
|
return_value=b"NEW-SEED"):
|
|
result = service.change_cloud_vm_network(
|
|
created["uuid"], network, confirm_restart=True)
|
|
|
|
self.assertTrue(result["network_changed"])
|
|
self.assertEqual(result["public_ip_cidr"], "8.8.8.19/24")
|
|
self.assertEqual(result["vm"]["state"], "running")
|
|
self.assertEqual(self.backend.shutdown_calls, 1)
|
|
managed = domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
|
|
self.assertEqual(managed.get("public-ip-cidr"), "8.8.8.19/24")
|
|
self.assertEqual(managed.get("public-pool-key"), "a" * 32)
|
|
filterref = domain.root.find("./devices/interface/filterref")
|
|
self.assertEqual(filterref.get("filter"), "clean-traffic")
|
|
self.assertEqual(filterref.find("parameter").get("value"), "8.8.8.19")
|
|
self.assertEqual(
|
|
bytes(self.backend.pools["images"].volumes[old_seed].contents),
|
|
b"NEW-SEED",
|
|
)
|
|
|
|
def test_cloud_network_change_rejects_unconfirmed_restart_without_touching_vm(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
domain = self.backend.domains[0]
|
|
before = ET.tostring(domain.root)
|
|
with self.assertRaises(self.error_type) as raised:
|
|
service.change_cloud_vm_network(
|
|
created["uuid"], {
|
|
"public_ip_cidr": "8.8.8.19/24",
|
|
"gateway": "8.8.8.1",
|
|
"dns_servers": ["1.1.1.1"],
|
|
}, confirm_restart=False)
|
|
self.assertEqual(raised.exception.status, 422)
|
|
self.assertEqual(ET.tostring(domain.root), before)
|
|
self.assertEqual(self.backend.shutdown_calls, 0)
|
|
|
|
def test_cloud_settings_change_restarts_and_returns_no_credentials(self):
|
|
service = self.cloud_service()
|
|
spec = self.cloud_spec()
|
|
created = self.create_cloud_vm(service, spec)
|
|
domain = self.backend.domains[0]
|
|
seed_name = domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed").get("seed-volume")
|
|
with patch.object(self.service_module, "replace_seed_settings",
|
|
return_value=b"NEW-SETTINGS-SEED"), \
|
|
patch.object(self.service_module, "read_seed_network", return_value={
|
|
"public_ip_cidr": spec["public_ip_cidr"],
|
|
"gateway": spec["gateway"],
|
|
"dns_servers": spec["dns_servers"],
|
|
"mac": domain.root.find("./devices/interface/mac").get("address"),
|
|
}):
|
|
result = service.change_cloud_vm_settings(
|
|
created["uuid"], hostname="node.example",
|
|
root_password_hash="$6$rounds=100000$abcdefghijklmnop$" + "a" * 86,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
confirm_restart=True,
|
|
)
|
|
|
|
self.assertTrue(result["settings_changed"])
|
|
self.assertEqual(result["hostname"], "node.example")
|
|
self.assertEqual(result["vm"]["state"], "running")
|
|
self.assertNotIn("root_password", result)
|
|
self.assertNotIn("ssh_public_key", result)
|
|
self.assertEqual(self.backend.shutdown_calls, 1)
|
|
managed = domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
|
|
self.assertEqual(managed.get("guest-hostname"), "node.example")
|
|
self.assertEqual(
|
|
bytes(self.backend.pools["images"].volumes[seed_name].contents),
|
|
b"NEW-SETTINGS-SEED",
|
|
)
|
|
|
|
def test_cloud_settings_change_requires_restart_confirmation(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
domain = self.backend.domains[0]
|
|
before = ET.tostring(domain.root)
|
|
with patch.object(self.service_module, "replace_seed_settings",
|
|
side_effect=AssertionError("must validate confirmation first")), \
|
|
self.assertRaises(self.error_type) as raised:
|
|
service.change_cloud_vm_settings(
|
|
created["uuid"], hostname="node.example", confirm_restart=False,
|
|
)
|
|
self.assertEqual(raised.exception.status, 422)
|
|
self.assertEqual(ET.tostring(domain.root), before)
|
|
self.assertEqual(self.backend.shutdown_calls, 0)
|
|
|
|
def test_cloud_network_change_rejects_gateway_or_dns_drift(self):
|
|
service = self.cloud_service()
|
|
spec = self.cloud_spec()
|
|
created = self.create_cloud_vm(service, spec)
|
|
domain = self.backend.domains[0]
|
|
mac = domain.root.find("./devices/interface/mac").get("address")
|
|
before = ET.tostring(domain.root)
|
|
network = {
|
|
"source_public_pool_key": "a" * 32,
|
|
"public_pool_key": "a" * 32,
|
|
"public_ip_cidr": "8.8.8.19/24",
|
|
"gateway": "8.8.8.2",
|
|
"dns_servers": ["9.9.9.9"],
|
|
}
|
|
with patch.object(self.service_module, "read_seed_network", return_value={
|
|
"public_ip_cidr": "8.8.8.18/24", "gateway": "8.8.8.1",
|
|
"dns_servers": ["1.1.1.1", "8.8.8.8"],
|
|
"mac": mac,
|
|
}), patch.object(self.service_module, "replace_seed_network",
|
|
side_effect=AssertionError("seed must not be rewritten")):
|
|
with self.assertRaises(self.error_type) as raised:
|
|
service.change_cloud_vm_network(
|
|
created["uuid"], network, confirm_restart=True)
|
|
|
|
self.assertEqual(raised.exception.status, 409)
|
|
self.assertIn("网关或 DNS", str(raised.exception))
|
|
self.assertEqual(ET.tostring(domain.root), before)
|
|
self.assertEqual(self.backend.shutdown_calls, 0)
|
|
|
|
def test_cloud_network_change_allows_same_selector_cross_pool_tuple(self):
|
|
service = self.cloud_service()
|
|
spec = self.cloud_spec()
|
|
created = self.create_cloud_vm(service, spec)
|
|
domain = self.backend.domains[0]
|
|
mac = domain.root.find("./devices/interface/mac").get("address")
|
|
network = {
|
|
"source_public_pool_key": "a" * 32,
|
|
"public_pool_key": "b" * 32,
|
|
"public_ip_cidr": "9.9.9.3/29",
|
|
"gateway": "9.9.9.1",
|
|
"dns_servers": ["9.9.9.9"],
|
|
}
|
|
with patch.object(self.service_module, "read_seed_network", return_value={
|
|
"public_ip_cidr": "8.8.8.18/24", "gateway": "8.8.8.1",
|
|
"dns_servers": ["1.1.1.1", "8.8.8.8"],
|
|
"mac": mac,
|
|
}), patch.object(self.service_module, "replace_seed_network",
|
|
return_value=b"CROSS-POOL-SEED"):
|
|
result = service.change_cloud_vm_network(
|
|
created["uuid"], network, confirm_restart=True)
|
|
|
|
self.assertTrue(result["network_changed"])
|
|
self.assertEqual(result["public_pool_key"], "b" * 32)
|
|
self.assertEqual(result["public_ip_cidr"], "9.9.9.3/29")
|
|
managed = domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
|
|
self.assertEqual(managed.get("public-pool-key"), "b" * 32)
|
|
self.assertEqual(managed.get("public-ip-cidr"), "9.9.9.3/29")
|
|
|
|
def test_user_iso_isolated_directory_import_create_and_delete(self):
|
|
service = self.service.__class__(
|
|
self.service.uri, "images", "/home/iso", "default")
|
|
service.ensure_storage_pools()
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "installer.iso"
|
|
image.write_bytes(bootable_iso_bytes())
|
|
imported = service.import_user_iso(image, 41, USER_ISO_NAME)
|
|
self.assertEqual(imported["volume_name"], USER_ISO_NAME)
|
|
child = next(pool for pool in self.backend.pools.values()
|
|
if pool.path == "/home/iso/41")
|
|
self.assertIn("/home/iso/41", self.backend.built)
|
|
self.assertEqual(child.volumes[USER_ISO_NAME].path(),
|
|
f"/home/iso/41/{USER_ISO_NAME}")
|
|
|
|
spec = self.spec(name="user-installer")
|
|
spec.pop("iso")
|
|
created = service.create_user_iso_vm(
|
|
spec, 41, USER_ISO_NAME, USER_ISO_ID, "My Installer")
|
|
self.assertEqual(created["os_source"], "iso")
|
|
live = self.backend.domains[0].live_root
|
|
source = live.find("./devices/disk[@device='cdrom']/source")
|
|
self.assertEqual(source.get("file"), f"/home/iso/41/{USER_ISO_NAME}")
|
|
managed = live.find(f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
|
|
self.assertEqual(managed.get("install-iso-id"), USER_ISO_ID)
|
|
self.assertEqual(managed.get("install-iso"), "My Installer")
|
|
|
|
with self.assertRaises(self.error_type) as in_use:
|
|
service.delete_user_iso(41, USER_ISO_NAME)
|
|
self.assertEqual(in_use.exception.status, 409)
|
|
self.backend.domains[0].guest_reboot()
|
|
self.assertTrue(service.delete_user_iso(41, USER_ISO_NAME)["deleted"])
|
|
with self.assertRaises(self.error_type) as missing:
|
|
service.delete_user_iso(41, USER_ISO_NAME)
|
|
self.assertEqual(missing.exception.status, 404)
|
|
self.assertEqual(
|
|
missing.exception.error_code, "user_iso_volume_not_found")
|
|
|
|
def test_user_iso_cache_replaces_same_size_volume_without_ready_marker(self):
|
|
service = self.service.__class__(
|
|
self.service.uri, "images", "/home/iso", "default")
|
|
service.ensure_storage_pools()
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "installer.iso"
|
|
content = bootable_iso_bytes()
|
|
image.write_bytes(content)
|
|
first = service.cache_user_iso(
|
|
image, 41, USER_ISO_NAME, {USER_ISO_NAME},
|
|
trusted_existing=False)
|
|
child = next(pool for pool in self.backend.pools.values()
|
|
if pool.path == "/home/iso/41")
|
|
original = child.volumes[USER_ISO_NAME]
|
|
original.contents[:] = b"z" * len(content)
|
|
|
|
trusted = service.cache_user_iso(
|
|
image, 41, USER_ISO_NAME, {USER_ISO_NAME},
|
|
trusted_existing=True)
|
|
self.assertTrue(trusted["already_cached"])
|
|
self.assertIs(child.volumes[USER_ISO_NAME], original)
|
|
|
|
replaced = service.cache_user_iso(
|
|
image, 41, USER_ISO_NAME, {USER_ISO_NAME},
|
|
trusted_existing=False)
|
|
self.assertFalse(first["already_cached"])
|
|
self.assertFalse(replaced["already_cached"])
|
|
self.assertIsNot(child.volumes[USER_ISO_NAME], original)
|
|
self.assertEqual(bytes(child.volumes[USER_ISO_NAME].contents), content)
|
|
self.assertIn(USER_ISO_NAME, self.backend.deleted_volumes)
|
|
|
|
def test_user_iso_cannot_cross_owner_or_use_non_directory_root(self):
|
|
service = self.service.__class__(
|
|
self.service.uri, "images", "/home/iso", "default")
|
|
service.ensure_storage_pools()
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "installer.iso"
|
|
image.write_bytes(bootable_iso_bytes())
|
|
service.import_user_iso(image, 41, USER_ISO_NAME)
|
|
with self.assertRaises(self.error_type) as missing:
|
|
service.delete_user_iso(42, USER_ISO_NAME)
|
|
self.assertEqual(missing.exception.status, 404)
|
|
self.assertEqual(
|
|
missing.exception.error_code, "user_iso_volume_not_found")
|
|
self.assertIn(USER_ISO_NAME, next(
|
|
pool for pool in self.backend.pools.values()
|
|
if pool.path == "/home/iso/41").volumes)
|
|
|
|
missing_root = self.service.__class__(
|
|
self.service.uri, "images", "missing-iso-pool", "default")
|
|
with self.assertRaises(self.error_type) as root_missing:
|
|
missing_root.delete_user_iso(41, USER_ISO_NAME)
|
|
self.assertEqual(root_missing.exception.status, 404)
|
|
self.assertEqual(root_missing.exception.error_code, "")
|
|
|
|
self.backend.pools["iso"].pool_type = "fs"
|
|
non_directory = self.service.__class__(
|
|
self.service.uri, "images", "iso", "default")
|
|
with self.assertRaises(self.error_type) as invalid:
|
|
non_directory.create_user_iso_vm(
|
|
{key: value for key, value in self.spec().items() if key != "iso"},
|
|
41, USER_ISO_NAME, USER_ISO_ID, "Installer")
|
|
self.assertEqual(invalid.exception.status, 409)
|
|
|
|
def test_user_iso_cache_storage_preflight_requires_directory_pool(self):
|
|
service = self.service.__class__(
|
|
self.service.uri, "images", "/home/iso", "default")
|
|
service.ensure_storage_pools()
|
|
checked = service.check_user_iso_storage(41)
|
|
self.assertGreaterEqual(checked["available_bytes"], 1024 * 1024)
|
|
self.assertIn("/home/iso/41", self.backend.built)
|
|
|
|
self.backend.pools["iso"].pool_type = "fs"
|
|
non_directory = self.service.__class__(
|
|
self.service.uri, "images", "iso", "default")
|
|
with self.assertRaises(self.error_type) as invalid:
|
|
non_directory.check_user_iso_storage(42)
|
|
self.assertEqual(invalid.exception.status, 409)
|
|
|
|
def test_invalid_package_bandwidth_is_rejected(self):
|
|
for value in (0, -1, 100001, True, "100"):
|
|
with self.subTest(value=value), self.assertRaises(self.error_type):
|
|
self.service._validate_create(self.spec(bandwidth_mbps=value))
|
|
|
|
def test_only_debian_12_seed_uses_cloud_init_network_fix(self):
|
|
for template_name in (
|
|
DEBIAN_12_TEMPLATE_NAME,
|
|
DEBIAN_12_TEMPLATE_REPLICA,
|
|
):
|
|
with self.subTest(template_name=template_name):
|
|
self.assertTrue(
|
|
self.service._cloud_seed_needs_debian12_network_fix(template_name)
|
|
)
|
|
for template_name in (
|
|
TEMPLATE_NAME,
|
|
DEBIAN_13_TEMPLATE_NAME,
|
|
"panel-template-debian12-not-a-valid-volume.qcow2",
|
|
):
|
|
with self.subTest(template_name=template_name):
|
|
self.assertFalse(
|
|
self.service._cloud_seed_needs_debian12_network_fix(template_name)
|
|
)
|
|
|
|
@staticmethod
|
|
def cloud_spec(**changes):
|
|
# Public examples are used only as parser fixtures; these addresses
|
|
# must never be assumed to belong to a real panel deployment.
|
|
data = {
|
|
"source": "cloud",
|
|
"name": "cloud-vm",
|
|
"vcpu": 4,
|
|
"memory_mib": 4096,
|
|
"disk_gib": 20,
|
|
"network": "bridge:br0",
|
|
"public_pool_key": "a" * 32,
|
|
"public_ip_cidr": "8.8.8.18/24",
|
|
"gateway": "8.8.8.1",
|
|
"dns_servers": ["1.1.1.1", "8.8.8.8"],
|
|
"guest_ssh_public_key": "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIF7mFh4aYz3lRzNqjoFQasAQLpm7BdSULhe1iWuvj3y5 panel-test",
|
|
}
|
|
data.update(changes)
|
|
return data
|
|
|
|
def cloud_service(self):
|
|
self.backend.pools["images"].volumes[TEMPLATE_NAME] = FakeVolume(
|
|
self.backend.pools["images"], TEMPLATE_NAME,
|
|
capacity=2 * 1024**3,
|
|
)
|
|
return self.service.__class__(
|
|
self.service.uri, "images", "iso", "bridge:br0",
|
|
rescue_iso_pool="/home/rescue",
|
|
)
|
|
|
|
def create_cloud_vm(self, service, spec):
|
|
# Exercise the remote libvirt orchestration without requiring the
|
|
# optional ISO writer on test hosts. test_cloud_init.py checks the
|
|
# real generated ISO separately when pycdlib is available.
|
|
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED", create=True):
|
|
return service.create_cloud_vm(spec, TEMPLATE_NAME)
|
|
|
|
def cloud_vm_with_real_seed(self, **changes):
|
|
"""Create a cloud VM and replace its stub seed with real NoCloud data."""
|
|
if importlib.util.find_spec("pycdlib") is None:
|
|
self.skipTest("pycdlib is not installed")
|
|
from virsh_panel.cloud_init import build_seed_iso, validate_cloud_network
|
|
|
|
service = self.cloud_service()
|
|
spec = self.cloud_spec(**changes)
|
|
created = self.create_cloud_vm(service, spec)
|
|
domain = self.backend.domains[0]
|
|
root = domain.root
|
|
metadata = root.find(f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
|
|
seed_name = metadata.get("seed-volume")
|
|
mac = root.find("./devices/interface/mac").get("address")
|
|
network = validate_cloud_network(
|
|
spec["public_ip_cidr"], spec["gateway"], spec["dns_servers"],
|
|
spec["guest_ssh_public_key"],
|
|
)
|
|
seed_data = build_seed_iso(created["uuid"], spec["name"], mac, network)
|
|
seed = self.backend.pools["images"].volumes[seed_name]
|
|
seed.contents = bytearray(seed_data)
|
|
seed.capacity = len(seed_data)
|
|
return service, created, spec, domain, seed_name
|
|
|
|
def test_create_list_resources_and_console(self):
|
|
resources = self.service.resources()
|
|
self.assertEqual(resources["networks"], ["default"])
|
|
self.assertEqual(resources["isos"], ["AlmaLinux-10.iso"])
|
|
vm = self.service.create_vm(self.spec())
|
|
self.assertEqual(vm["state"], "running")
|
|
self.assertTrue(vm["autostart"])
|
|
self.assertEqual(self.backend.domain_autostart_changed, [vm["uuid"]])
|
|
self.assertEqual(vm["vcpu"], 2)
|
|
self.assertEqual(vm["memory_mib"], 2048)
|
|
self.assertRegex(vm["created_at"], r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$")
|
|
self.assertEqual(len(vm["disks"]), 1)
|
|
self.assertEqual(vm["disks"][0]["source"],
|
|
"/var/lib/libvirt/images/alma-test.qcow2")
|
|
self.assertEqual(vm["disks"][0]["capacity_gib"], 20)
|
|
self.assertTrue(vm["managed"])
|
|
self.assertEqual(vm["console_port"], 5907)
|
|
self.assertEqual(self.service.console_port(vm["uuid"]), 5907)
|
|
self.assertEqual(self.service.list_vms()[0]["uuid"], vm["uuid"])
|
|
self.assertEqual(self.service.get_vm(vm["uuid"])["name"], "alma-test")
|
|
self.assertEqual(self.service.list_vm_states(), [{
|
|
"uuid": vm["uuid"], "name": "alma-test", "state": "running",
|
|
}])
|
|
self.assertEqual(self.service.get_vm_state(vm["uuid"]), {
|
|
"uuid": vm["uuid"], "name": "alma-test", "state": "running",
|
|
})
|
|
|
|
metadata = self.service.list_vm_metadata([vm["uuid"]])
|
|
self.assertEqual(len(metadata), 1)
|
|
self.assertEqual(metadata[0]["uuid"], vm["uuid"])
|
|
self.assertEqual(metadata[0]["os_source"], "iso")
|
|
self.assertEqual(metadata[0]["install_iso"], "AlmaLinux-10.iso")
|
|
self.assertIsNone(metadata[0]["login_name"])
|
|
self.assertEqual(metadata[0]["disk_gib"], 20)
|
|
self.assertEqual(metadata[0]["disks"], [{"capacity_gib": 20}])
|
|
self.assertNotIn("source", metadata[0]["disks"][0])
|
|
self.assertNotIn("state", metadata[0])
|
|
self.assertNotIn("console_port", metadata[0])
|
|
self.assertNotIn("credential_generation", metadata[0])
|
|
with self.assertRaises(self.service_module.VMError) as empty:
|
|
self.service.list_vm_metadata([])
|
|
self.assertEqual(empty.exception.status, 400)
|
|
with self.assertRaises(self.service_module.VMError) as excessive:
|
|
self.service.list_vm_metadata([vm["uuid"]] * 101)
|
|
self.assertEqual(excessive.exception.status, 400)
|
|
missing_id = str(uuid.uuid4())
|
|
self.assertEqual(self.service.list_vm_metadata([missing_id]), [])
|
|
self.assertEqual(
|
|
self.service.list_vm_metadata([missing_id, vm["uuid"]]),
|
|
metadata,
|
|
)
|
|
disk_name = "alma-test.qcow2"
|
|
self.assertIn(disk_name, self.backend.pools["images"].volumes)
|
|
root = self.backend.domains[0].root
|
|
self.assertEqual(root.find("./devices/disk[@device='disk']").get("type"), "file")
|
|
self.assertEqual(root.find("./devices/disk[@device='cdrom']").get("type"), "file")
|
|
self.assertEqual(root.find("./devices/graphics").get("listen"), "127.0.0.1")
|
|
self.assertEqual(
|
|
[boot.get("dev") for boot in root.findall("./os/boot")],
|
|
["cdrom", "hd"],
|
|
)
|
|
self.assertEqual(root.findtext("on_reboot"), "destroy")
|
|
final_root = self.backend.domains[0].inactive_root
|
|
self.assertEqual(root.find("./metadata/{urn:virsh-panel:1}managed").get("created-at"),
|
|
vm["created_at"])
|
|
self.assertEqual(final_root.find("./metadata/{urn:virsh-panel:1}managed").get("created-at"),
|
|
vm["created_at"])
|
|
self.assertEqual([boot.get("dev") for boot in final_root.findall("./os/boot")],
|
|
["hd"])
|
|
self.assertIsNone(final_root.find("./devices/disk[@device='cdrom']/source"))
|
|
self.assertEqual(len(self.backend.create_xmls), 1)
|
|
self.assertEqual(len(self.backend.define_xmls), 1)
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_host_capacity_counts_all_domains_and_preserves_storage_bytes(self):
|
|
self.backend.node_info = (
|
|
"x86_64", 64 * 1024, 16, 3000, 1, 1, 8, 2,
|
|
)
|
|
self.service.create_vm(self.spec(vcpu=4, memory_mib=8192))
|
|
|
|
capacity = self.service.host_capacity()
|
|
|
|
self.assertEqual(capacity["instances"], {"total": 1, "running": 1})
|
|
self.assertEqual(capacity["cpu"], {
|
|
"total": 16, "allocated": 4, "available": 12,
|
|
})
|
|
self.assertEqual(capacity["memory_mib"], {
|
|
"total": 65536, "allocated": 8192, "available": 57344,
|
|
})
|
|
self.assertEqual(capacity["storage_bytes"], {
|
|
"total": 100 * 1024**3,
|
|
"allocated": 10 * 1024**3,
|
|
"available": 90 * 1024**3,
|
|
})
|
|
|
|
def test_iso_create_accepts_preassigned_uuid_for_user_ownership(self):
|
|
requested_uuid = "14d9bb2f-65cd-4406-a377-90685c0690e4"
|
|
created = self.service.create_vm(self.spec(vm_uuid=requested_uuid))
|
|
self.assertEqual(created["uuid"], requested_uuid)
|
|
self.assertEqual(self.backend.domains[0].root.findtext("uuid"), requested_uuid)
|
|
resource_name = "vc-14d9bb2f65cd4406"
|
|
self.assertEqual(self.backend.domains[0].name(), resource_name)
|
|
self.assertIn(f"{resource_name}.qcow2", self.backend.pools["images"].volumes)
|
|
managed = self.backend.domains[0].root.find(
|
|
"./metadata/{urn:virsh-panel:1}managed")
|
|
self.assertEqual(managed.get("display-name"), "alma-test")
|
|
self.assertEqual(created["name"], "alma-test")
|
|
self.assertEqual(
|
|
self.service.list_vm_metadata([requested_uuid])[0]["name"], "alma-test")
|
|
self.assertEqual(
|
|
self.service.get_vm_state(requested_uuid)["name"], resource_name)
|
|
with self.assertRaisesRegex(self.error_type, "UUID"):
|
|
self.service.create_vm(self.spec(name="invalid-uuid", vm_uuid="not-a-uuid"))
|
|
|
|
def test_internal_resource_name_extends_past_domain_or_disk_collision(self):
|
|
vm_uuid = "14d9bb2f-65cd-4406-a377-90685c0690e4"
|
|
|
|
class NamedDomain:
|
|
def __init__(self, value):
|
|
self.value = value
|
|
|
|
def name(self):
|
|
return self.value
|
|
|
|
selected = self.service._select_internal_resource_name(
|
|
vm_uuid,
|
|
[NamedDomain("vc-14d9bb2f65cd4406")],
|
|
{"vc-14d9bb2f65cd4406a377.qcow2"},
|
|
)
|
|
|
|
self.assertEqual(selected, "vc-14d9bb2f65cd4406a3779068")
|
|
|
|
def test_legacy_name_collision_can_be_reconciled_without_own_artifacts(self):
|
|
self.service.create_vm(self.spec())
|
|
reserved_uuid = "14d9bb2f-65cd-4406-a377-90685c0690e4"
|
|
|
|
self.assertFalse(self.service.provisioning_absent(
|
|
reserved_uuid, "alma-test"))
|
|
self.assertTrue(self.service.provisioning_absent(
|
|
reserved_uuid, "alma-test", legacy_name_collision=True))
|
|
|
|
def test_uuid_resource_absence_checks_every_candidate_and_seed(self):
|
|
reserved_uuid = "14d9bb2f-65cd-4406-a377-90685c0690e4"
|
|
pool = self.backend.pools["images"]
|
|
candidate_disk = "vc-14d9bb2f65cd4406a377.qcow2"
|
|
pool.volumes[candidate_disk] = FakeVolume(pool, candidate_disk)
|
|
|
|
self.assertFalse(self.service.provisioning_absent(
|
|
reserved_uuid, "customer-label", uuid_resources=True))
|
|
del pool.volumes[candidate_disk]
|
|
self.assertTrue(self.service.provisioning_absent(
|
|
reserved_uuid, "customer-label", uuid_resources=True))
|
|
|
|
def test_unmanaged_vm_does_not_claim_an_os_or_ip(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
domain = self.backend.domains[0]
|
|
for root in (domain.live_root, domain.inactive_root):
|
|
root.remove(root.find("metadata"))
|
|
listed = self.service.get_vm(vm["uuid"])
|
|
self.assertFalse(listed["managed"])
|
|
self.assertIsNone(listed["os_name"])
|
|
self.assertEqual(listed["os_source"], "unknown")
|
|
self.assertIsNone(listed["install_iso"])
|
|
self.assertIsNone(listed["public_ip_cidr"])
|
|
self.assertIsNone(listed["created_at"])
|
|
|
|
def test_older_panel_vm_without_creation_marker_has_unknown_time(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
domain = self.backend.domains[0]
|
|
for root in (domain.live_root, domain.inactive_root):
|
|
root.find("./metadata/{urn:virsh-panel:1}managed").attrib.pop("created-at")
|
|
self.assertIsNone(self.service.get_vm(vm["uuid"])["created_at"])
|
|
|
|
def test_installer_reboot_stops_guest_and_next_start_uses_unmounted_iso(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
domain = self.backend.domains[0]
|
|
self.assertTrue(domain.autostart())
|
|
install_root = ET.fromstring(domain.XMLDesc(0))
|
|
final_root = ET.fromstring(domain.XMLDesc(1))
|
|
self.assertEqual(install_root.findtext("on_reboot"), "destroy")
|
|
self.assertIsNotNone(install_root.find("./devices/disk[@device='cdrom']/source"))
|
|
self.assertIsNone(final_root.find("./devices/disk[@device='cdrom']/source"))
|
|
self.assertEqual(domain.UUIDString(), vm["uuid"])
|
|
self.assertEqual(install_root.findtext("./os/nvram"),
|
|
final_root.findtext("./os/nvram"))
|
|
|
|
domain.guest_reboot()
|
|
self.assertFalse(domain.isActive())
|
|
self.assertTrue(domain.autostart())
|
|
self.assertTrue(domain.isPersistent())
|
|
self.assertEqual(len(self.backend.domains), 1)
|
|
self.assertEqual(self.service.get_vm(vm["uuid"])["state"], "shutoff")
|
|
self.assertEqual(self.service.action(vm["uuid"], "start")["state"], "running")
|
|
booted_root = ET.fromstring(domain.XMLDesc(0))
|
|
self.assertEqual([boot.get("dev") for boot in booted_root.findall("./os/boot")],
|
|
["hd"])
|
|
self.assertIsNone(booted_root.find("./devices/disk[@device='cdrom']/source"))
|
|
self.assertIsNone(booted_root.find("on_reboot"))
|
|
self.assertEqual(booted_root.findtext("uuid"), vm["uuid"])
|
|
self.assertEqual(booted_root.findtext("./os/nvram"),
|
|
install_root.findtext("./os/nvram"))
|
|
self.assertEqual(self.service.console_port(vm["uuid"]), 5907)
|
|
|
|
def test_create_matches_original_virt_install_with_configured_directories(self):
|
|
disk_pool = self.backend.pools["images"]
|
|
iso_pool = self.backend.pools["iso"]
|
|
disk_pool.path = "/home/kvm"
|
|
iso_pool.path = "/home/iso"
|
|
iso_name = "AlmaLinux-10.1-x86_64-minimal.iso"
|
|
iso_pool.volumes[iso_name] = FakeVolume(iso_pool, iso_name)
|
|
service = self.service.__class__(
|
|
self.service.uri, "/home/kvm", "/home/iso", "bridge:br0")
|
|
self.assertEqual(service.ensure_storage_pools(),
|
|
{"storage_pool": "images", "iso_pool": "iso"})
|
|
spec = self.spec(name="web", memory_mib=2042, vcpu=8, disk_gib=100,
|
|
network="bridge:br0", iso=iso_name)
|
|
with patch.object(disk_pool, "info", return_value=(
|
|
2, 200 * 1024**3, 10 * 1024**3, 190 * 1024**3)):
|
|
vm = service.create_vm(spec)
|
|
|
|
root = self.backend.domains[0].root
|
|
self.assertEqual(vm["state"], "running")
|
|
self.assertEqual(root.findtext("name"), "web")
|
|
self.assertEqual(root.find("memory").attrib, {"unit": "MiB"})
|
|
self.assertEqual(root.findtext("memory"), "2042")
|
|
self.assertEqual(root.findtext("vcpu"), "8")
|
|
self.assertEqual(root.find("cpu").get("mode"), "host-passthrough")
|
|
self.assertEqual(root.find("os").get("firmware"), "efi")
|
|
self.assertEqual(root.findtext("./os/type"), "hvm")
|
|
self.assertEqual(root.find("./os/type").get("machine"), "q35")
|
|
self.assertIsNotNone(root.find("./features/acpi"))
|
|
self.assertIsNotNone(root.find("./features/apic"))
|
|
self.assertEqual([node.get("dev") for node in root.findall("./os/boot")],
|
|
["cdrom", "hd"])
|
|
self.assertEqual(root.findtext("on_reboot"), "destroy")
|
|
final_root = self.backend.domains[0].inactive_root
|
|
self.assertEqual([node.get("dev") for node in final_root.findall("./os/boot")],
|
|
["hd"])
|
|
self.assertIsNone(final_root.find("./devices/disk[@device='cdrom']/source"))
|
|
self.assertEqual(final_root.findtext("./os/nvram"), root.findtext("./os/nvram"))
|
|
self.assertEqual(final_root.findtext("uuid"), root.findtext("uuid"))
|
|
self.assertEqual(final_root.find("./devices/disk[@device='disk']/source").attrib,
|
|
root.find("./devices/disk[@device='disk']/source").attrib)
|
|
|
|
disk = root.find("./devices/disk[@device='disk']")
|
|
self.assertEqual(disk.get("type"), "file")
|
|
self.assertEqual(disk.find("driver").attrib, {
|
|
"name": "qemu", "type": "qcow2", "cache": "none", "discard": "unmap",
|
|
})
|
|
self.assertEqual(disk.find("source").attrib,
|
|
{"file": "/home/kvm/web.qcow2"})
|
|
self.assertEqual(disk.find("target").attrib,
|
|
{"dev": "vda", "bus": "virtio"})
|
|
cdrom = root.find("./devices/disk[@device='cdrom']")
|
|
self.assertEqual(cdrom.get("type"), "file")
|
|
self.assertEqual(cdrom.find("source").attrib,
|
|
{"file": f"/home/iso/{iso_name}"})
|
|
self.assertIsNotNone(cdrom.find("readonly"))
|
|
|
|
interface = root.find("./devices/interface")
|
|
self.assertEqual(interface.get("type"), "bridge")
|
|
self.assertEqual(interface.find("source").attrib, {"bridge": "br0"})
|
|
self.assertEqual(interface.find("model").attrib, {"type": "virtio"})
|
|
self.assertEqual(interface.find("driver").attrib, {"queues": "8"})
|
|
graphics = root.find("./devices/graphics")
|
|
self.assertEqual(graphics.get("type"), "vnc")
|
|
self.assertEqual(graphics.get("listen"), "127.0.0.1")
|
|
self.assertEqual(graphics.get("port"), "-1")
|
|
self.assertEqual(graphics.get("autoport"), "yes")
|
|
self.assertEqual(graphics.find("listen").attrib,
|
|
{"type": "address", "address": "127.0.0.1"})
|
|
self.assertNotIn("passwd", graphics.attrib)
|
|
|
|
channel = root.find("./devices/channel/target[@name='org.qemu.guest_agent.0']")
|
|
self.assertIsNotNone(channel)
|
|
self.assertEqual(channel.get("type"), "virtio")
|
|
balloon = root.find("./devices/memballoon")
|
|
self.assertEqual(balloon.get("model"), "virtio")
|
|
self.assertEqual(balloon.get("freePageReporting"), "on")
|
|
self.assertGreater(int(balloon.find("stats").get("period")), 0)
|
|
self.assertEqual(root.find("./metadata/{urn:virsh-panel:1}managed").attrib,
|
|
{"version": "2", "disk-volume": "web.qcow2",
|
|
"display-name": "web",
|
|
"os-source": "iso", "install-iso": iso_name,
|
|
"created-at": vm["created_at"]})
|
|
self.assertIsNone(vm["os_name"])
|
|
self.assertEqual(vm["os_source"], "iso")
|
|
self.assertEqual(vm["install_iso"], iso_name)
|
|
|
|
service.action(vm["uuid"], "shutdown")
|
|
self.assertEqual(service.delete_vm(vm["uuid"], True)["deleted_disks"],
|
|
["web.qcow2"])
|
|
self.assertEqual(self.backend.undefine_flags, [4])
|
|
self.assertNotIn("web.qcow2", disk_pool.volumes)
|
|
|
|
def test_linux_bridge_uses_host_bridge_xml_not_libvirt_network(self):
|
|
service = self.service.__class__(self.service.uri, "images", "iso", "bridge:br0")
|
|
self.assertEqual(service.resources()["networks"], ["bridge:br0"])
|
|
self.assertEqual(self.backend.network_lookups, [])
|
|
vm = service.create_vm(self.spec(network="bridge:br0"))
|
|
self.assertEqual(vm["state"], "running")
|
|
interface = self.backend.domains[0].root.find("./devices/interface")
|
|
self.assertEqual(interface.get("type"), "bridge")
|
|
self.assertEqual(interface.find("source").attrib, {"bridge": "br0"})
|
|
self.assertEqual(self.backend.network_lookups, [])
|
|
|
|
def test_bare_br0_remains_a_libvirt_virtual_network_name(self):
|
|
self.backend.network_name = "br0"
|
|
service = self.service.__class__(self.service.uri, "images", "iso", "br0")
|
|
self.assertEqual(service.resources()["networks"], ["br0"])
|
|
service.create_vm(self.spec(network="br0"))
|
|
interface = self.backend.domains[0].root.find("./devices/interface")
|
|
self.assertEqual(interface.get("type"), "network")
|
|
self.assertEqual(interface.find("source").attrib, {"network": "br0"})
|
|
self.assertEqual(self.backend.network_lookups, ["br0", "br0"])
|
|
|
|
def test_virtio_net_queues_follow_vcpu_up_to_sixteen_for_both_network_modes(self):
|
|
for network in ("default", "bridge:br0"):
|
|
service = self.service.__class__(self.service.uri, "images", "iso", network)
|
|
for vcpu, expected_queues in ((1, 1), (8, 8), (32, 16)):
|
|
with self.subTest(network=network, vcpu=vcpu):
|
|
service.create_vm(self.spec(
|
|
name=f"alma-{network.replace(':', '-')}-{vcpu}",
|
|
network=network, vcpu=vcpu,
|
|
))
|
|
interface = self.backend.domains[-1].root.find("./devices/interface")
|
|
self.assertEqual(interface.find("model").attrib, {"type": "virtio"})
|
|
self.assertEqual(interface.find("driver").attrib, {
|
|
"queues": str(expected_queues),
|
|
})
|
|
|
|
def test_missing_host_bridge_rolls_back_domain_and_disk(self):
|
|
self.backend.bridge_active = False
|
|
service = self.service.__class__(self.service.uri, "images", "iso", "bridge:br0")
|
|
with self.assertRaises(self.error_type) as error:
|
|
service.create_vm(self.spec(network="bridge:br0"))
|
|
self.assertEqual(error.exception.status, 409)
|
|
self.assertIn("br0", str(error.exception))
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertFalse(self.backend.pools["images"].volumes)
|
|
self.assertEqual(self.backend.undefine_flags, [])
|
|
|
|
def test_invalid_bridge_selector_rejected_before_connection(self):
|
|
for selector in ("bridge:", "bridge:br/0", "bridge:br 0",
|
|
"bridge:" + "a" * 16, "bridge:-br0"):
|
|
with self.subTest(selector=selector), self.assertRaises(ValueError):
|
|
self.service.__class__(self.service.uri, "images", "iso", selector)
|
|
self.assertEqual(self.backend.opened, 0)
|
|
|
|
def test_directory_paths_reuse_existing_pools_and_domain_uses_files(self):
|
|
self.backend.pools["images"].path = "/home/kvm"
|
|
self.backend.pools["iso"].path = "/home/iso"
|
|
service = self.service.__class__(self.service.uri, "/home/kvm", "/home/iso", "default")
|
|
self.assertEqual(service.ensure_storage_pools(),
|
|
{"storage_pool": "images", "iso_pool": "iso"})
|
|
self.assertEqual(self.backend.defined, [])
|
|
self.assertEqual(service.resources()["isos"], ["AlmaLinux-10.iso"])
|
|
vm = service.create_vm(self.spec())
|
|
disk = self.backend.domains[0].root.find("./devices/disk[@device='disk']/source")
|
|
cdrom = self.backend.domains[0].root.find("./devices/disk[@device='cdrom']/source")
|
|
self.assertEqual(disk.attrib, {"file": "/home/kvm/alma-test.qcow2"})
|
|
self.assertEqual(cdrom.attrib, {"file": "/home/iso/AlmaLinux-10.iso"})
|
|
service.action(vm["uuid"], "shutdown")
|
|
self.assertEqual(len(service.delete_vm(vm["uuid"], True)["deleted_disks"]), 1)
|
|
|
|
def test_directory_paths_are_defined_only_by_explicit_ensure(self):
|
|
service = self.service.__class__(self.service.uri, "/home/kvm", "/home/iso", "default")
|
|
with self.assertRaises(self.error_type) as missing:
|
|
service.resources()
|
|
self.assertEqual(missing.exception.status, 409)
|
|
self.assertEqual(self.backend.defined, [])
|
|
|
|
names = service.ensure_storage_pools()
|
|
self.assertEqual([path for _, path in self.backend.defined],
|
|
["/home/kvm", "/home/iso"])
|
|
self.assertTrue(names["storage_pool"].startswith("panel-dir-"))
|
|
self.assertNotEqual(names["storage_pool"], names["iso_pool"])
|
|
self.assertTrue(self.backend.pools[names["storage_pool"]].autostart())
|
|
self.assertTrue(self.backend.pools[names["iso_pool"]].autostart())
|
|
self.assertEqual(service.ensure_storage_pools(), names)
|
|
self.assertEqual(len(self.backend.defined), 2)
|
|
self.assertEqual(len(self.backend.autostart_changed), 2)
|
|
|
|
iso_pool = self.backend.pools[names["iso_pool"]]
|
|
iso_pool.volumes["AlmaLinux-10.iso"] = FakeVolume(iso_pool, "AlmaLinux-10.iso")
|
|
vm = service.create_vm(self.spec())
|
|
disk = self.backend.domains[0].root.find("./devices/disk[@device='disk']/source")
|
|
cdrom = self.backend.domains[0].root.find("./devices/disk[@device='cdrom']/source")
|
|
self.assertEqual(disk.attrib, {"file": "/home/kvm/alma-test.qcow2"})
|
|
self.assertEqual(cdrom.attrib, {"file": "/home/iso/AlmaLinux-10.iso"})
|
|
service.action(vm["uuid"], "shutdown")
|
|
self.assertEqual(len(service.delete_vm(vm["uuid"], True)["deleted_disks"]), 1)
|
|
|
|
def test_missing_directory_does_not_leave_a_pool_definition(self):
|
|
service = self.service.__class__(self.service.uri, "/home/missing", "iso", "default")
|
|
with self.assertRaises(self.error_type) as missing:
|
|
service.ensure_storage_pools()
|
|
self.assertEqual(missing.exception.status, 409)
|
|
self.assertIn("/home/missing", str(missing.exception))
|
|
self.assertEqual(self.backend.defined[0][1], "/home/missing")
|
|
self.assertEqual(set(self.backend.pools), {"images", "iso"})
|
|
|
|
def test_iso_failure_rolls_back_new_disk_pool_but_not_host_directories(self):
|
|
original_directories = set(self.backend.existing_dirs)
|
|
service = self.service.__class__(
|
|
self.service.uri, "/home/kvm", "/home/missing-iso", "default")
|
|
with self.assertRaises(self.error_type) as missing:
|
|
service.ensure_storage_pools()
|
|
self.assertEqual(missing.exception.status, 409)
|
|
self.assertIn("/home/missing-iso", str(missing.exception))
|
|
self.assertEqual(set(self.backend.pools), {"images", "iso"})
|
|
self.assertEqual(self.backend.existing_dirs, original_directories)
|
|
self.assertEqual(len(self.backend.defined), 2)
|
|
self.assertEqual(set(self.backend.undefined),
|
|
{name for name, _ in self.backend.defined})
|
|
self.assertEqual(self.backend.destroyed, [self.backend.defined[0][0]])
|
|
|
|
def test_iso_failure_does_not_undefine_preexisting_disk_pool(self):
|
|
self.backend.pools["images"].path = "/home/kvm"
|
|
service = self.service.__class__(
|
|
self.service.uri, "/home/kvm", "/home/missing-iso", "default")
|
|
with self.assertRaises(self.error_type):
|
|
service.ensure_storage_pools()
|
|
self.assertIn("images", self.backend.pools)
|
|
self.assertEqual(self.backend.pools["images"].path, "/home/kvm")
|
|
self.assertNotIn("images", self.backend.undefined)
|
|
self.assertNotIn("images", self.backend.destroyed)
|
|
|
|
def test_directory_pool_validation_and_existing_inactive_pool(self):
|
|
for invalid in ("/", "/home/../etc", "//home/kvm", "/home/./kvm"):
|
|
with self.subTest(invalid=invalid), self.assertRaises(self.error_type):
|
|
self.service.__class__(self.service.uri, invalid, "iso", "default").ensure_storage_pools()
|
|
self.backend.pools["images"].path = "/home/kvm"
|
|
self.backend.pools["images"].active = False
|
|
service = self.service.__class__(self.service.uri, "/home/kvm/", "iso", "default")
|
|
self.assertEqual(service.ensure_storage_pools()["storage_pool"], "images")
|
|
self.assertIn("images", self.backend.started)
|
|
self.assertTrue(self.backend.pools["images"].autostart())
|
|
self.assertEqual(self.backend.autostart_changed, ["images", "iso"])
|
|
self.assertEqual(service.ensure_storage_pools()["storage_pool"], "images")
|
|
self.assertEqual(self.backend.started, ["images"])
|
|
self.assertEqual(self.backend.autostart_changed, ["images", "iso"])
|
|
|
|
def test_transient_existing_pool_rejected_without_changes(self):
|
|
self.backend.pools["images"].path = "/home/kvm"
|
|
self.backend.pools["images"].persistent = False
|
|
service = self.service.__class__(self.service.uri, "/home/kvm", "iso", "default")
|
|
with self.assertRaises(self.error_type) as transient:
|
|
service.ensure_storage_pools()
|
|
self.assertEqual(transient.exception.status, 409)
|
|
self.assertEqual(self.backend.defined, [])
|
|
self.assertEqual(self.backend.started, [])
|
|
self.assertEqual(self.backend.autostart_changed, [])
|
|
|
|
def test_directory_pool_name_collision_is_not_overwritten(self):
|
|
service = self.service.__class__(self.service.uri, "/home/kvm", "iso", "default")
|
|
generated_name = "panel-dir-" + hashlib.sha256(b"/home/kvm").hexdigest()[:48]
|
|
self.backend.pools[generated_name] = FakePool(
|
|
self.backend, generated_name, "/home/somewhere-else")
|
|
with self.assertRaises(self.error_type) as collision:
|
|
service.ensure_storage_pools()
|
|
self.assertEqual(collision.exception.status, 409)
|
|
self.assertEqual(self.backend.defined, [])
|
|
self.assertEqual(self.backend.pools[generated_name].path, "/home/somewhere-else")
|
|
|
|
def test_console_requires_loopback_vnc_listener(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
graphics = self.backend.domains[0].root.find("./devices/graphics")
|
|
graphics.set("listen", "0.0.0.0")
|
|
with self.assertRaises(self.error_type) as exposed:
|
|
self.service.console_port(vm["uuid"])
|
|
self.assertEqual(exposed.exception.status, 409)
|
|
|
|
def test_validation_happens_before_creating_resources(self):
|
|
for spec in (self.spec(name="../../escape"), self.spec(vcpu=True),
|
|
self.spec(memory_mib=128), self.spec(network="other"),
|
|
self.spec(iso="../bad.iso")):
|
|
with self.subTest(spec=spec), self.assertRaises(self.error_type):
|
|
self.service.create_vm(spec)
|
|
self.assertFalse(self.backend.pools["images"].volumes)
|
|
|
|
def test_unavailable_iso_and_define_failure_leave_no_disk(self):
|
|
with self.assertRaises(self.error_type) as missing:
|
|
self.service.create_vm(self.spec(iso="missing.iso"))
|
|
self.assertEqual(missing.exception.status, 404)
|
|
self.backend.fail_define = True
|
|
with self.assertRaises(self.error_type) as define_error:
|
|
self.service.create_vm(self.spec())
|
|
self.assertEqual(define_error.exception.status, 502)
|
|
self.assertIn("卸载 ISO 后的配置", str(define_error.exception))
|
|
self.assertFalse(self.backend.pools["images"].volumes)
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_create_xml_failure_leaves_no_domain_or_disk(self):
|
|
self.backend.fail_create = True
|
|
with self.assertRaises(self.error_type) as start_error:
|
|
self.service.create_vm(self.spec())
|
|
self.assertEqual(start_error.exception.status, 409)
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertFalse(self.backend.pools["images"].volumes)
|
|
self.assertEqual(self.backend.create_xmls, [])
|
|
self.assertEqual(self.backend.define_xmls, [])
|
|
self.assertEqual(self.backend.undefine_flags, [])
|
|
|
|
def test_final_define_failure_destroys_transient_guest_and_disk(self):
|
|
self.backend.fail_define = True
|
|
with self.assertRaises(self.error_type):
|
|
self.service.create_vm(self.spec())
|
|
self.assertEqual(len(self.backend.create_xmls), 1)
|
|
self.assertEqual(self.backend.define_xmls, [])
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertFalse(self.backend.pools["images"].volumes)
|
|
self.assertEqual(self.backend.undefine_flags, [])
|
|
|
|
def test_iso_vm_autostart_failure_rolls_back_new_vm_and_disk(self):
|
|
self.backend.fail_domain_autostart = True
|
|
with self.assertRaises(self.error_type) as failure:
|
|
self.service.create_vm(self.spec())
|
|
self.assertEqual(failure.exception.status, 502)
|
|
self.assertIn("开机自启", str(failure.exception))
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertFalse(self.backend.pools["images"].volumes)
|
|
self.assertEqual(self.backend.domain_autostart_changed, [])
|
|
|
|
def test_final_define_failure_preserves_disk_referenced_by_other_live_vm(self):
|
|
other = self.service.create_vm(self.spec(name="other-vm"))
|
|
other_domain = self.backend.domains[0]
|
|
new_disk_path = "/var/lib/libvirt/images/alma-test.qcow2"
|
|
|
|
def fail_after_external_attach(conn, xml):
|
|
other_domain.live_root.find("./devices/disk[@device='disk']/source").attrib = {
|
|
"file": new_disk_path,
|
|
}
|
|
raise FakeLibvirtError("define failed after external disk attach")
|
|
|
|
with patch.object(FakeConnection, "defineXML", fail_after_external_attach):
|
|
with self.assertRaises(self.error_type) as incomplete:
|
|
self.service.create_vm(self.spec())
|
|
|
|
self.assertEqual(incomplete.exception.status, 502)
|
|
self.assertEqual(len(self.backend.domains), 1)
|
|
self.assertEqual(self.backend.domains[0].UUIDString(), other["uuid"])
|
|
self.assertTrue(other_domain.isActive())
|
|
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
|
|
|
|
def test_final_define_failure_preserves_disk_referenced_only_by_inactive_xml(self):
|
|
other = self.service.create_vm(self.spec(name="other-vm"))
|
|
other_domain = self.backend.domains[0]
|
|
original_live_source = other_domain.live_root.find(
|
|
"./devices/disk[@device='disk']/source").get("file")
|
|
new_disk_path = "/var/lib/libvirt/images/alma-test.qcow2"
|
|
|
|
def fail_after_external_config_change(conn, xml):
|
|
other_domain.inactive_root.find(
|
|
"./devices/disk[@device='disk']/source").attrib = {
|
|
"file": new_disk_path,
|
|
}
|
|
raise FakeLibvirtError("define failed after external config change")
|
|
|
|
with patch.object(FakeConnection, "defineXML", fail_after_external_config_change):
|
|
with self.assertRaises(self.error_type) as incomplete:
|
|
self.service.create_vm(self.spec())
|
|
|
|
self.assertEqual(incomplete.exception.status, 502)
|
|
self.assertEqual(len(self.backend.domains), 1)
|
|
self.assertEqual(self.backend.domains[0].UUIDString(), other["uuid"])
|
|
self.assertEqual(other_domain.live_root.find(
|
|
"./devices/disk[@device='disk']/source").get("file"), original_live_source)
|
|
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
|
|
|
|
def test_failed_transient_cleanup_preserves_disk_for_manual_recovery(self):
|
|
self.backend.fail_define = True
|
|
self.backend.fail_destroy = True
|
|
with self.assertRaises(self.error_type) as incomplete:
|
|
self.service.create_vm(self.spec())
|
|
self.assertEqual(incomplete.exception.status, 502)
|
|
self.assertEqual(len(self.backend.domains), 1)
|
|
self.assertTrue(self.backend.domains[0].isActive())
|
|
self.assertFalse(self.backend.domains[0].isPersistent())
|
|
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
|
|
|
|
def test_failed_volume_cleanup_reports_residual_disk(self):
|
|
self.backend.fail_create = True
|
|
self.backend.fail_volume_delete = True
|
|
with self.assertRaises(self.error_type) as incomplete:
|
|
self.service.create_vm(self.spec())
|
|
self.assertEqual(incomplete.exception.status, 502)
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
|
|
|
|
def test_resources_refreshes_directory_pool_for_externally_added_iso(self):
|
|
iso_pool = self.backend.pools["iso"]
|
|
iso_pool.external_names.add("new-upload.iso")
|
|
self.assertNotIn("new-upload.iso", iso_pool.listVolumes())
|
|
resources = self.service.resources()
|
|
self.assertIn("new-upload.iso", resources["isos"])
|
|
self.assertEqual(iso_pool.refreshes, 1)
|
|
|
|
def test_create_refreshes_directory_pool_for_externally_added_iso(self):
|
|
iso_pool = self.backend.pools["iso"]
|
|
iso_pool.external_names.add("new-upload.iso")
|
|
self.assertNotIn("new-upload.iso", iso_pool.listVolumes())
|
|
vm = self.service.create_vm(self.spec(iso="new-upload.iso"))
|
|
self.assertEqual(vm["state"], "running")
|
|
cdrom = self.backend.domains[0].root.find(
|
|
"./devices/disk[@device='cdrom']/source")
|
|
self.assertEqual(cdrom.get("file"),
|
|
"/var/lib/libvirt/iso/new-upload.iso")
|
|
self.assertEqual(iso_pool.refreshes, 1)
|
|
|
|
def test_existing_disk_name_is_never_overwritten(self):
|
|
pool = self.backend.pools["images"]
|
|
existing = FakeVolume(pool, "alma-test.qcow2")
|
|
pool.volumes[existing.name()] = existing
|
|
with self.assertRaises(self.error_type) as collision:
|
|
self.service.create_vm(self.spec())
|
|
self.assertEqual(collision.exception.status, 409)
|
|
self.assertIs(pool.volumes[existing.name()], existing)
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_external_same_name_disk_is_detected_after_pool_refresh(self):
|
|
disk_pool = self.backend.pools["images"]
|
|
disk_pool.external_names.add("alma-test.qcow2")
|
|
self.assertNotIn("alma-test.qcow2", disk_pool.listVolumes())
|
|
with self.assertRaises(self.error_type) as collision:
|
|
self.service.create_vm(self.spec())
|
|
self.assertEqual(collision.exception.status, 409)
|
|
self.assertIn("alma-test.qcow2", disk_pool.volumes)
|
|
self.assertEqual(disk_pool.refreshes, 1)
|
|
self.assertFalse(self.backend.domains)
|
|
|
|
def test_create_rejects_disk_larger_than_available_pool_space(self):
|
|
with self.assertRaises(self.error_type) as insufficient:
|
|
self.service.create_vm(self.spec(disk_gib=100))
|
|
self.assertEqual(insufficient.exception.status, 409)
|
|
self.assertFalse(self.backend.pools["images"].volumes)
|
|
|
|
def test_actions_and_safe_deletion(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
vm_uuid = vm["uuid"]
|
|
with self.assertRaises(self.error_type) as running:
|
|
self.service.delete_vm(vm_uuid, True)
|
|
self.assertEqual(running.exception.status, 409)
|
|
self.assertEqual(self.service.action(vm_uuid, "reset")["state"], "running")
|
|
self.assertEqual(self.backend.domains[0].last_reset_flags, 0)
|
|
self.assertEqual(self.service.action(vm_uuid, "reboot")["state"], "shutoff")
|
|
self.assertEqual(self.service.action(vm_uuid, "start")["state"], "running")
|
|
self.assertEqual(self.service.action(vm_uuid, "shutdown")["state"], "shutoff")
|
|
with self.assertRaises(self.error_type):
|
|
self.service.console_port(vm_uuid)
|
|
self.assertEqual(self.service.action(vm_uuid, "start")["state"], "running")
|
|
self.assertEqual(self.service.action(vm_uuid, "poweroff")["state"], "shutoff")
|
|
result = self.service.delete_vm(vm_uuid, True)
|
|
self.assertEqual(result["deleted_disks"], ["alma-test.qcow2"])
|
|
self.assertFalse(self.backend.pools["images"].volumes)
|
|
self.assertFalse(self.backend.domains)
|
|
|
|
def test_service_suspend_and_resume_are_idempotent_target_states(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
domain = self.backend.domains[0]
|
|
self.assertTrue(domain.autostart())
|
|
|
|
suspended = self.service.service_suspend(vm["uuid"])
|
|
self.assertEqual(suspended["state"], "shutoff")
|
|
self.assertFalse(suspended["autostart"])
|
|
self.assertTrue(suspended["service_was_running"])
|
|
self.assertEqual(self.backend.shutdown_calls, 1)
|
|
self.assertEqual(self.backend.destroy_calls, 0)
|
|
|
|
repeated = self.service.service_suspend(vm["uuid"])
|
|
self.assertEqual(repeated["state"], "shutoff")
|
|
self.assertFalse(repeated["service_was_running"])
|
|
self.assertEqual(self.backend.shutdown_calls, 1)
|
|
self.assertEqual(self.backend.destroy_calls, 0)
|
|
|
|
resumed = self.service.service_resume(vm["uuid"])
|
|
self.assertEqual(resumed["state"], "shutoff")
|
|
self.assertTrue(resumed["autostart"])
|
|
self.service.service_resume(vm["uuid"])
|
|
self.assertEqual(self.backend.domain_starts, 0)
|
|
# Creation, suspension and resumption each change autostart once;
|
|
# target-state retries do not issue duplicate writes.
|
|
self.assertEqual(self.backend.domain_autostart_changed,
|
|
[vm["uuid"], vm["uuid"], vm["uuid"]])
|
|
|
|
def test_service_resume_starts_only_when_expiry_policy_stopped_running_vm(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
domain = self.backend.domains[0]
|
|
self.service.service_suspend(vm["uuid"])
|
|
|
|
resumed = self.service.service_resume(
|
|
vm["uuid"], start_if_suspended=True)
|
|
self.assertEqual(resumed["state"], "running")
|
|
self.assertTrue(resumed["autostart"])
|
|
self.assertEqual(self.backend.domain_starts, 1)
|
|
|
|
# Replaying the same target state after a lost response is idempotent.
|
|
self.service.service_resume(vm["uuid"], start_if_suspended=True)
|
|
self.assertEqual(self.backend.domain_starts, 1)
|
|
|
|
self.service.service_suspend(vm["uuid"])
|
|
self.service.service_resume(vm["uuid"], start_if_suspended=False)
|
|
self.assertFalse(domain.isActive())
|
|
self.assertEqual(self.backend.domain_starts, 1)
|
|
|
|
def test_service_suspend_forces_stop_after_graceful_timeout(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
self.backend.shutdown_stalls = True
|
|
with patch.object(self.service_module, "SERVICE_SUSPEND_SHUTDOWN_TIMEOUT", 0):
|
|
suspended = self.service.service_suspend(vm["uuid"])
|
|
self.assertEqual(suspended["state"], "shutoff")
|
|
self.assertEqual(self.backend.shutdown_calls, 1)
|
|
self.assertEqual(self.backend.destroy_calls, 1)
|
|
self.assertFalse(self.backend.domains[0].autostart())
|
|
|
|
def test_service_suspend_rejects_transient_vm_before_stopping_it(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
domain = self.backend.domains[0]
|
|
domain.persistent = False
|
|
with self.assertRaises(self.error_type) as error:
|
|
self.service.service_suspend(vm["uuid"])
|
|
self.assertEqual(error.exception.status, 409)
|
|
self.assertTrue(domain.isActive())
|
|
self.assertEqual(self.backend.shutdown_calls, 0)
|
|
|
|
def test_network_target_states_cover_all_nics_live_and_persistent(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
domain = self.backend.domains[0]
|
|
for root in (domain.live_root, domain.inactive_root):
|
|
first = root.find("./devices/interface")
|
|
first.insert(0, ET.Element("mac", address="52:54:00:00:00:01"))
|
|
second = copy.deepcopy(first)
|
|
second.find("mac").set("address", "52:54:00:00:00:02")
|
|
root.find("devices").append(second)
|
|
autostart_changes = list(self.backend.domain_autostart_changed)
|
|
|
|
suspended = self.service.network_suspend(vm["uuid"])
|
|
self.assertTrue(domain.isActive())
|
|
self.assertTrue(suspended["network_suspended"])
|
|
for root in (domain.live_root, domain.inactive_root):
|
|
self.assertEqual(
|
|
[node.find("link").get("state")
|
|
for node in root.findall("./devices/interface")],
|
|
["down", "down"],
|
|
)
|
|
self.assertEqual(len(self.backend.device_updates), 4)
|
|
self.service.network_suspend(vm["uuid"])
|
|
self.assertEqual(len(self.backend.device_updates), 4)
|
|
|
|
resumed = self.service.network_resume(vm["uuid"])
|
|
self.assertTrue(domain.isActive())
|
|
self.assertFalse(resumed["network_suspended"])
|
|
for root in (domain.live_root, domain.inactive_root):
|
|
self.assertEqual(
|
|
[node.find("link").get("state")
|
|
for node in root.findall("./devices/interface")],
|
|
["up", "up"],
|
|
)
|
|
self.service.network_resume(vm["uuid"])
|
|
self.assertEqual(len(self.backend.device_updates), 8)
|
|
self.assertEqual(self.backend.domain_autostart_changed, autostart_changes)
|
|
|
|
def test_network_target_state_on_stopped_vm_changes_config_only(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
self.service.action(vm["uuid"], "shutdown")
|
|
domain = self.backend.domains[0]
|
|
self.assertFalse(domain.isActive())
|
|
|
|
suspended = self.service.network_suspend(vm["uuid"])
|
|
self.assertEqual(suspended["state"], "shutoff")
|
|
self.assertEqual(self.backend.device_updates[-1][1:], ("down", 2))
|
|
self.assertEqual(len(self.backend.device_updates), 1)
|
|
|
|
resumed = self.service.network_resume(vm["uuid"])
|
|
self.assertEqual(resumed["state"], "shutoff")
|
|
self.assertEqual(self.backend.device_updates[-1][1:], ("up", 2))
|
|
self.assertEqual(len(self.backend.device_updates), 2)
|
|
|
|
def test_legacy_panel_uuid_disk_can_still_be_deleted(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
self.service.action(vm["uuid"], "shutdown")
|
|
old_name = f"panel-{vm['uuid']}.qcow2"
|
|
pool = self.backend.pools["images"]
|
|
del pool.volumes["alma-test.qcow2"]
|
|
pool.volumes[old_name] = FakeVolume(pool, old_name)
|
|
root = self.backend.domains[0].root
|
|
os_node = root.find("os")
|
|
os_node.attrib.pop("firmware", None)
|
|
nvram = os_node.find("nvram")
|
|
if nvram is not None:
|
|
os_node.remove(nvram)
|
|
marker = root.find("./metadata/{urn:virsh-panel:1}managed")
|
|
marker.attrib = {"version": "1"}
|
|
disk = root.find("./devices/disk[@device='disk']")
|
|
disk.set("type", "volume")
|
|
disk.find("source").attrib = {"pool": "images", "volume": old_name}
|
|
self.assertEqual(self.service.delete_vm(vm["uuid"], True)["deleted_disks"],
|
|
[old_name])
|
|
self.assertNotIn(old_name, pool.volumes)
|
|
|
|
def test_disk_deletion_rejects_other_domain_reference(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
self.service.action(vm["uuid"], "shutdown")
|
|
original = self.backend.domains[0]
|
|
other_xml = ET.fromstring(original.XMLDesc(0))
|
|
other_xml.find("uuid").text = str(uuid.uuid4())
|
|
other_xml.find("name").text = "other-vm"
|
|
self.backend.domains.append(FakeDomain(self.backend, ET.tostring(other_xml)))
|
|
with self.assertRaises(self.error_type) as shared:
|
|
self.service.delete_vm(vm["uuid"], True)
|
|
self.assertEqual(shared.exception.status, 409)
|
|
self.assertEqual(len(self.backend.domains), 2)
|
|
|
|
def test_definition_only_delete_keeps_volume_and_nvram(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
self.service.action(vm["uuid"], "shutdown")
|
|
result = self.service.delete_vm(vm["uuid"], False)
|
|
self.assertEqual(result["deleted_disks"], [])
|
|
self.assertEqual(self.backend.undefine_flags, [8])
|
|
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
|
|
self.assertFalse(self.backend.domains)
|
|
|
|
def test_disk_deletion_rejects_backing_image_reference(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
self.service.action(vm["uuid"], "shutdown")
|
|
other_xml = ET.fromstring(self.backend.domains[0].XMLDesc(0))
|
|
other_xml.find("uuid").text = str(uuid.uuid4())
|
|
other_xml.find("name").text = "clone-vm"
|
|
disk = other_xml.find("./devices/disk[@device='disk']")
|
|
disk.set("type", "volume")
|
|
disk.find("source").attrib = {"pool": "images", "volume": "independent.qcow2"}
|
|
backing = ET.SubElement(disk, "backingStore", type="volume")
|
|
ET.SubElement(backing, "source", pool="images",
|
|
volume="alma-test.qcow2")
|
|
self.backend.domains.append(FakeDomain(self.backend, ET.tostring(other_xml)))
|
|
with self.assertRaises(self.error_type) as shared:
|
|
self.service.delete_vm(vm["uuid"], True)
|
|
self.assertEqual(shared.exception.status, 409)
|
|
|
|
def test_disk_deletion_rejects_nested_data_store_reference(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
self.service.action(vm["uuid"], "shutdown")
|
|
other_xml = ET.fromstring(self.backend.domains[0].XMLDesc(0))
|
|
other_xml.find("uuid").text = str(uuid.uuid4())
|
|
other_xml.find("name").text = "data-store-vm"
|
|
source = other_xml.find("./devices/disk[@device='disk']/source")
|
|
source.attrib = {"file": "/var/lib/libvirt/images/independent.qcow2"}
|
|
data_store = ET.SubElement(source, "dataStore", type="file")
|
|
ET.SubElement(data_store, "source",
|
|
file="/var/lib/libvirt/images/alma-test.qcow2")
|
|
self.backend.domains.append(FakeDomain(self.backend, ET.tostring(other_xml)))
|
|
with self.assertRaises(self.error_type) as shared:
|
|
self.service.delete_vm(vm["uuid"], True)
|
|
self.assertEqual(shared.exception.status, 409)
|
|
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
|
|
self.assertEqual(len(self.backend.domains), 2)
|
|
|
|
def test_disk_deletion_rejects_nested_mirror_reference(self):
|
|
vm = self.service.create_vm(self.spec())
|
|
self.service.action(vm["uuid"], "shutdown")
|
|
other_xml = ET.fromstring(self.backend.domains[0].XMLDesc(0))
|
|
other_xml.find("uuid").text = str(uuid.uuid4())
|
|
other_xml.find("name").text = "mirror-vm"
|
|
source = other_xml.find("./devices/disk[@device='disk']/source")
|
|
source.attrib = {"file": "/var/lib/libvirt/images/independent.qcow2"}
|
|
mirror = ET.SubElement(other_xml.find("./devices/disk[@device='disk']"),
|
|
"mirror", type="file")
|
|
ET.SubElement(mirror, "source",
|
|
file="/var/lib/libvirt/images/alma-test.qcow2")
|
|
self.backend.domains.append(FakeDomain(self.backend, ET.tostring(other_xml)))
|
|
with self.assertRaises(self.error_type) as shared:
|
|
self.service.delete_vm(vm["uuid"], True)
|
|
self.assertEqual(shared.exception.status, 409)
|
|
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
|
|
self.assertEqual(len(self.backend.domains), 2)
|
|
|
|
def test_cloud_vm_uses_panel_reserved_uuid_for_credential_binding(self):
|
|
service = self.cloud_service()
|
|
reserved_uuid = str(uuid.uuid4())
|
|
created = self.create_cloud_vm(service, self.cloud_spec(vm_uuid=reserved_uuid))
|
|
self.assertEqual(created["uuid"], reserved_uuid)
|
|
self.assertEqual(created["credential_generation"],
|
|
f"panel-seed-{reserved_uuid}.iso")
|
|
self.assertEqual(created["disks"][0]["capacity_gib"], 20)
|
|
resource_name = f"vc-{uuid.UUID(reserved_uuid).hex[:16]}"
|
|
self.assertEqual(self.backend.domains[0].name(), resource_name)
|
|
self.assertIn(f"{resource_name}.qcow2", self.backend.pools["images"].volumes)
|
|
self.assertEqual(created["name"], "cloud-vm")
|
|
|
|
def test_uuid_backed_cloud_vms_can_share_a_display_name(self):
|
|
service = self.cloud_service()
|
|
first_uuid = "14d9bb2f-65cd-4406-a377-90685c0690e4"
|
|
second_uuid = "24d9bb2f-65cd-4406-a377-90685c0690e4"
|
|
|
|
first = self.create_cloud_vm(
|
|
service, self.cloud_spec(vm_uuid=first_uuid))
|
|
second = self.create_cloud_vm(service, self.cloud_spec(
|
|
vm_uuid=second_uuid,
|
|
public_ip_cidr="8.8.8.19/24",
|
|
))
|
|
|
|
self.assertEqual(first["name"], "cloud-vm")
|
|
self.assertEqual(second["name"], "cloud-vm")
|
|
resource_names = {domain.name() for domain in self.backend.domains}
|
|
self.assertEqual(resource_names, {
|
|
"vc-14d9bb2f65cd4406",
|
|
"vc-24d9bb2f65cd4406",
|
|
})
|
|
pool_names = set(self.backend.pools["images"].volumes)
|
|
self.assertIn("vc-14d9bb2f65cd4406.qcow2", pool_names)
|
|
self.assertIn("vc-24d9bb2f65cd4406.qcow2", pool_names)
|
|
|
|
def test_cloud_vm_accepts_almalinux_9_panel_template_volume(self):
|
|
service = self.cloud_service()
|
|
alma9_volume = "panel-template-alma9-12345678-0123456789abcdef.qcow2"
|
|
self.backend.pools["images"].volumes[alma9_volume] = FakeVolume(
|
|
self.backend.pools["images"], alma9_volume, capacity=2 * 1024**3,
|
|
)
|
|
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED",
|
|
create=True) as seed_builder:
|
|
created = service.create_cloud_vm(
|
|
self.cloud_spec(os_name="AlmaLinux 9"), alma9_volume,
|
|
)
|
|
self.assertFalse(seed_builder.call_args.kwargs["debian12_network_fix"])
|
|
self.assertEqual(created["os_name"], "AlmaLinux 9")
|
|
self.assertEqual(self.backend.pools["images"].volumes["cloud-vm.qcow2"].cloned_from,
|
|
alma9_volume)
|
|
|
|
def test_debian_12_cloud_vm_seed_uses_cloud_init_network_fix(self):
|
|
service = self.cloud_service()
|
|
self.backend.pools["images"].volumes[DEBIAN_12_TEMPLATE_NAME] = FakeVolume(
|
|
self.backend.pools["images"], DEBIAN_12_TEMPLATE_NAME,
|
|
capacity=2 * 1024**3,
|
|
)
|
|
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED",
|
|
create=True) as seed_builder:
|
|
service.create_cloud_vm(
|
|
self.cloud_spec(os_name="Debian 12"), DEBIAN_12_TEMPLATE_NAME,
|
|
)
|
|
|
|
self.assertTrue(seed_builder.call_args.kwargs["debian12_network_fix"])
|
|
|
|
def test_cloud_vm_accepts_generated_template_replica_volume(self):
|
|
service = self.cloud_service()
|
|
self.backend.pools["images"].volumes[TEMPLATE_REPLICA_ONE] = FakeVolume(
|
|
self.backend.pools["images"], TEMPLATE_REPLICA_ONE,
|
|
capacity=2 * 1024**3,
|
|
)
|
|
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED",
|
|
create=True):
|
|
service.create_cloud_vm(self.cloud_spec(), TEMPLATE_REPLICA_ONE)
|
|
self.assertEqual(
|
|
self.backend.pools["images"].volumes["cloud-vm.qcow2"].cloned_from,
|
|
TEMPLATE_REPLICA_ONE,
|
|
)
|
|
|
|
def test_cloud_vm_clones_template_and_uses_nonboot_seed_iso(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec(os_name="AlmaLinux 10"))
|
|
|
|
self.assertEqual(created["state"], "running")
|
|
self.assertEqual(created["name"], "cloud-vm")
|
|
self.assertTrue(created["autostart"])
|
|
self.assertEqual(self.backend.domain_autostart_changed, [created["uuid"]])
|
|
pool = self.backend.pools["images"]
|
|
self.assertIn(TEMPLATE_NAME, pool.volumes)
|
|
self.assertEqual(pool.volumes["cloud-vm.qcow2"].cloned_from,
|
|
TEMPLATE_NAME)
|
|
self.assertEqual(pool.volumes["cloud-vm.qcow2"].capacity, 20 * 1024**3)
|
|
root = self.backend.domains[0].root
|
|
self.assertEqual([node.get("dev") for node in root.findall("./os/boot")],
|
|
["hd"])
|
|
self.assertIsNone(root.find("on_reboot"))
|
|
self.assertEqual(root.find("./devices/interface").get("type"), "bridge")
|
|
self.assertEqual(root.find("./devices/interface/source").get("bridge"), "br0")
|
|
self.assertEqual(root.find("./devices/interface/driver").get("queues"), "4")
|
|
mac = root.find("./devices/interface/mac").get("address")
|
|
self.assertRegex(mac, r"^([0-9a-f]{2}:){5}[0-9a-f]{2}$")
|
|
self.assertEqual(root.find("./devices/interface")[0].tag, "mac")
|
|
|
|
cdroms = root.findall("./devices/disk[@device='cdrom']")
|
|
self.assertEqual(len(cdroms), 1)
|
|
self.assertIsNotNone(cdroms[0].find("readonly"))
|
|
seed_path = cdroms[0].find("source").get("file")
|
|
self.assertTrue(seed_path.startswith("/var/lib/libvirt/images/"))
|
|
self.assertTrue(seed_path.endswith(".iso"))
|
|
seed_name = seed_path.rsplit("/", 1)[-1]
|
|
self.assertIn(seed_name, pool.volumes)
|
|
self.assertGreater(len(pool.volumes[seed_name].contents), 0)
|
|
self.assertTrue(self.backend.streams[-1].finished)
|
|
|
|
managed = root.find("./metadata/{urn:virsh-panel:1}managed")
|
|
self.assertEqual(managed.get("disk-volume"), "cloud-vm.qcow2")
|
|
self.assertEqual(managed.get("seed-volume"), seed_name)
|
|
self.assertEqual(managed.get("public-ip-cidr"), "8.8.8.18/24")
|
|
self.assertEqual(managed.get("public-pool-key"), "a" * 32)
|
|
self.assertEqual(created["public_ip_cidr"], "8.8.8.18/24")
|
|
self.assertEqual(created["public_pool_key"], "a" * 32)
|
|
self.assertEqual(managed.get("os-source"), "cloud_template")
|
|
self.assertEqual(managed.get("os-name"), "AlmaLinux 10")
|
|
self.assertEqual(managed.get("created-at"), created["created_at"])
|
|
self.assertRegex(created["created_at"], r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$")
|
|
self.assertEqual(created["os_name"], "AlmaLinux 10")
|
|
self.assertEqual(created["os_source"], "cloud_template")
|
|
metadata = service.list_vm_metadata([created["uuid"]])[0]
|
|
self.assertEqual(metadata["public_ip_cidr"], "8.8.8.18/24")
|
|
self.assertEqual(metadata["public_pool_key"], "a" * 32)
|
|
self.assertEqual(metadata["os_name"], "AlmaLinux 10")
|
|
self.assertEqual(metadata["os_source"], "cloud_template")
|
|
self.assertEqual(metadata["login_name"], "root")
|
|
self.assertEqual(metadata["disks"], [{"capacity_gib": 20}])
|
|
self.assertNotIn("source", metadata["disks"][0])
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_reinstall_to_debian_12_seed_uses_cloud_init_network_fix(self):
|
|
(service, created, spec, _domain,
|
|
_old_seed_name) = self.cloud_vm_with_real_seed()
|
|
pool = self.backend.pools["images"]
|
|
pool.volumes[DEBIAN_12_TEMPLATE_NAME] = FakeVolume(
|
|
pool, DEBIAN_12_TEMPLATE_NAME, capacity=2 * 1024**3,
|
|
)
|
|
|
|
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED",
|
|
create=True) as seed_builder:
|
|
service.reinstall_cloud_vm(
|
|
created["uuid"], DEBIAN_12_TEMPLATE_NAME,
|
|
os_name="Debian 12",
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
|
|
self.assertTrue(seed_builder.call_args.kwargs["debian12_network_fix"])
|
|
|
|
def test_cloud_vm_delete_disks_removes_clone_and_seed_but_keeps_template(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
root = self.backend.domains[0].root
|
|
seed_name = root.find("./metadata/{urn:virsh-panel:1}managed").get("seed-volume")
|
|
service.action(created["uuid"], "shutdown")
|
|
|
|
deleted = service.delete_vm(created["uuid"], True)
|
|
self.assertEqual(set(deleted["deleted_disks"]), {"cloud-vm.qcow2", seed_name})
|
|
self.assertEqual(set(self.backend.pools["images"].volumes),
|
|
{TEMPLATE_NAME})
|
|
|
|
def test_stopped_rescue_cloud_vm_delete_keeps_shared_rescue_iso(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
service.action(created["uuid"], "shutdown")
|
|
|
|
rescue_root = self.backend.domains[0].root
|
|
other_root = copy.deepcopy(rescue_root)
|
|
other_root.find("uuid").text = str(uuid.uuid4())
|
|
other_root.find("name").text = "other-rescue-vm"
|
|
other_root.find("./devices/disk[@device='disk']/source").set(
|
|
"file", "/var/lib/libvirt/images/other.qcow2",
|
|
)
|
|
cdroms = other_root.findall("./devices/disk[@device='cdrom']")
|
|
cdroms[0].find("source").set(
|
|
"file", "/var/lib/libvirt/images/other-seed.iso",
|
|
)
|
|
self.backend.domains.append(FakeDomain(
|
|
self.backend, ET.tostring(other_root, encoding="unicode"),
|
|
))
|
|
|
|
deleted = service.delete_vm(created["uuid"], True)
|
|
|
|
self.assertEqual(
|
|
set(deleted["deleted_disks"]),
|
|
{"cloud-vm.qcow2", f"panel-seed-{created['uuid']}.iso"},
|
|
)
|
|
self.assertEqual(set(self.backend.pools["images"].volumes), {TEMPLATE_NAME})
|
|
self.assertIn(RESCUE_NAME, self.backend.pools["rescue"].volumes)
|
|
with self.assertRaises(self.error_type) as shared:
|
|
service.delete_rescue_iso(RESCUE_NAME)
|
|
self.assertEqual(shared.exception.status, 409)
|
|
|
|
def test_stopped_premounted_rescue_cloud_vm_delete_finds_seed_cdrom(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
self.backend.shutdown_stalls = True
|
|
with patch.object(self.service_module, "REINSTALL_SHUTDOWN_TIMEOUT", 0):
|
|
staged = service.enter_rescue_vm(
|
|
created["uuid"], RESCUE_NAME, original_xml,
|
|
)
|
|
self.assertTrue(staged["pending_manual_restart"])
|
|
service.action(created["uuid"], "poweroff")
|
|
|
|
deleted = service.delete_vm(created["uuid"], True)
|
|
|
|
self.assertEqual(
|
|
set(deleted["deleted_disks"]),
|
|
{"cloud-vm.qcow2", f"panel-seed-{created['uuid']}.iso"},
|
|
)
|
|
self.assertEqual(set(self.backend.pools["images"].volumes), {TEMPLATE_NAME})
|
|
self.assertIn(RESCUE_NAME, self.backend.pools["rescue"].volumes)
|
|
|
|
def test_cloud_vm_definition_only_delete_keeps_clone_seed_and_template(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
volumes_before = set(self.backend.pools["images"].volumes)
|
|
service.action(created["uuid"], "shutdown")
|
|
|
|
deleted = service.delete_vm(created["uuid"], False)
|
|
self.assertEqual(deleted["deleted_disks"], [])
|
|
self.assertEqual(set(self.backend.pools["images"].volumes), volumes_before)
|
|
|
|
def test_cloud_vm_seed_shared_with_other_vm_blocks_disk_deletion(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
service.action(created["uuid"], "shutdown")
|
|
original = self.backend.domains[0]
|
|
copied_xml = ET.fromstring(original.XMLDesc(0))
|
|
copied_xml.find("uuid").text = str(uuid.uuid4())
|
|
copied_xml.find("name").text = "other-vm"
|
|
copied_xml.find("./devices/disk[@device='disk']/source").set(
|
|
"file", "/var/lib/libvirt/images/independent.qcow2",
|
|
)
|
|
self.backend.domains.append(FakeDomain(self.backend, ET.tostring(copied_xml)))
|
|
volumes_before = set(self.backend.pools["images"].volumes)
|
|
|
|
with self.assertRaises(self.error_type) as shared:
|
|
service.delete_vm(created["uuid"], True)
|
|
self.assertEqual(shared.exception.status, 409)
|
|
self.assertEqual(set(self.backend.pools["images"].volumes), volumes_before)
|
|
self.assertEqual(len(self.backend.domains), 2)
|
|
|
|
def test_cloud_vm_invalid_public_network_is_rejected_before_volume_creation(self):
|
|
service = self.cloud_service()
|
|
bad_specs = [
|
|
self.cloud_spec(public_ip_cidr="192.168.1.18/24"),
|
|
self.cloud_spec(public_ip_cidr="8.8.8.18/28", gateway="8.8.8.1"),
|
|
self.cloud_spec(public_ip_cidr="8.8.8.0/24"),
|
|
self.cloud_spec(public_ip_cidr="8.8.8.255/24"),
|
|
self.cloud_spec(dns_servers=["not-an-ip"]),
|
|
self.cloud_spec(guest_ssh_public_key="not-a-key"),
|
|
]
|
|
for spec in bad_specs:
|
|
with self.subTest(spec=spec), self.assertRaises(self.error_type):
|
|
self.create_cloud_vm(service, spec)
|
|
self.assertEqual(set(self.backend.pools["images"].volumes),
|
|
{TEMPLATE_NAME})
|
|
self.assertFalse(self.backend.domains)
|
|
|
|
def test_cloud_vm_rejects_duplicate_public_ip_on_same_host(self):
|
|
service = self.cloud_service()
|
|
first = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.assertEqual(first["state"], "running")
|
|
volumes_before = set(self.backend.pools["images"].volumes)
|
|
|
|
with self.assertRaises(self.error_type) as duplicate:
|
|
self.create_cloud_vm(service, self.cloud_spec(
|
|
name="cloud-vm-two", public_ip_cidr="8.8.8.18/28",
|
|
gateway="8.8.8.17",
|
|
))
|
|
self.assertEqual(duplicate.exception.status, 409)
|
|
self.assertEqual(set(self.backend.pools["images"].volumes), volumes_before)
|
|
self.assertEqual(len(self.backend.domains), 1)
|
|
|
|
def test_cloud_vm_clone_failure_keeps_template_and_no_partial_vm(self):
|
|
service = self.cloud_service()
|
|
self.backend.fail_clone = True
|
|
with self.assertRaises(self.error_type):
|
|
self.create_cloud_vm(service, self.cloud_spec())
|
|
self.assertEqual(set(self.backend.pools["images"].volumes),
|
|
{TEMPLATE_NAME})
|
|
self.assertFalse(self.backend.domains)
|
|
|
|
def test_cloud_vm_seed_upload_failure_cleans_only_new_volumes(self):
|
|
service = self.cloud_service()
|
|
self.backend.fail_send = True
|
|
with self.assertRaises(self.error_type):
|
|
self.create_cloud_vm(service, self.cloud_spec())
|
|
self.assertEqual(set(self.backend.pools["images"].volumes),
|
|
{TEMPLATE_NAME})
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertTrue(self.backend.streams[-1].aborted)
|
|
|
|
def test_cloud_vm_start_failure_undefines_domain_and_removes_new_volumes(self):
|
|
service = self.cloud_service()
|
|
self.backend.bridge_active = False
|
|
reserved_uuid = "14d9bb2f-65cd-4406-a377-90685c0690e4"
|
|
with self.assertRaises(self.error_type):
|
|
self.create_cloud_vm(
|
|
service, self.cloud_spec(vm_uuid=reserved_uuid))
|
|
self.assertEqual(set(self.backend.pools["images"].volumes),
|
|
{TEMPLATE_NAME})
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertEqual(self.backend.undefine_flags, [4])
|
|
|
|
def test_cloud_vm_autostart_failure_rolls_back_new_vm_and_volumes(self):
|
|
service = self.cloud_service()
|
|
self.backend.fail_domain_autostart = True
|
|
with self.assertRaises(self.error_type) as failure:
|
|
self.create_cloud_vm(service, self.cloud_spec())
|
|
self.assertEqual(failure.exception.status, 502)
|
|
self.assertIn("开机自启", str(failure.exception))
|
|
self.assertEqual(set(self.backend.pools["images"].volumes), {TEMPLATE_NAME})
|
|
self.assertFalse(self.backend.domains)
|
|
self.assertEqual(self.backend.domain_starts, 0)
|
|
self.assertEqual(self.backend.domain_autostart_changed, [])
|
|
|
|
def test_reinstall_keeps_original_public_network_and_deletes_old_disk_only_after_start(self):
|
|
from virsh_panel.cloud_init import read_seed_network
|
|
|
|
service, created, spec, domain, old_seed_name = self.cloud_vm_with_real_seed()
|
|
pool = self.backend.pools["images"]
|
|
old_disk = pool.volumes["cloud-vm.qcow2"]
|
|
original_mac = domain.root.find("./devices/interface/mac").get("address")
|
|
old_delete = old_disk.delete
|
|
|
|
def delete_after_new_start(flags):
|
|
self.assertTrue(domain.isActive())
|
|
source = domain.root.find("./devices/disk[@device='disk']/source")
|
|
self.assertNotEqual(source.get("file"), old_disk.path())
|
|
return old_delete(flags)
|
|
|
|
old_disk.delete = delete_after_new_start
|
|
result = service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
os_name="AlmaLinux 10.2",
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
|
|
self.assertEqual(result["vm"]["uuid"], created["uuid"])
|
|
self.assertEqual(result["vm"]["state"], "running")
|
|
self.assertEqual(result["vm"]["public_ip_cidr"], spec["public_ip_cidr"])
|
|
self.assertEqual(result["vm"]["os_name"], "AlmaLinux 10.2")
|
|
self.assertFalse(result.get("warning"))
|
|
self.assertEqual(self.backend.shutdown_calls, 1)
|
|
self.assertNotIn("cloud-vm.qcow2", pool.volumes)
|
|
self.assertNotIn(old_seed_name, pool.volumes)
|
|
self.assertIn(TEMPLATE_NAME, pool.volumes)
|
|
self.assertIn("cloud-vm.qcow2", self.backend.deleted_volumes)
|
|
self.assertIn(old_seed_name, self.backend.deleted_volumes)
|
|
root = domain.root
|
|
self.assertEqual(root.find("./devices/interface/mac").get("address"), original_mac)
|
|
new_seed_name = root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed").get("seed-volume")
|
|
self.assertNotEqual(new_seed_name, old_seed_name)
|
|
network = read_seed_network(bytes(pool.volumes[new_seed_name].contents))
|
|
self.assertEqual(network, {
|
|
"public_ip_cidr": spec["public_ip_cidr"],
|
|
"gateway": spec["gateway"],
|
|
"dns_servers": spec["dns_servers"],
|
|
"mac": original_mac,
|
|
})
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_reinstall_waits_for_graceful_shutdown_and_times_out_without_touching_disks(self):
|
|
service, created, spec, domain, _seed_name = self.cloud_vm_with_real_seed()
|
|
pool = self.backend.pools["images"]
|
|
before = set(pool.volumes)
|
|
self.backend.shutdown_stalls = True
|
|
|
|
with patch.object(self.service_module, "REINSTALL_SHUTDOWN_TIMEOUT", 0), \
|
|
patch.object(self.service_module, "REINSTALL_SHUTDOWN_POLL_INTERVAL", 0):
|
|
with self.assertRaises(self.error_type) as raised:
|
|
service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
|
|
self.assertEqual(raised.exception.status, 409)
|
|
self.assertTrue(domain.isActive())
|
|
self.assertEqual(self.backend.shutdown_calls, 1)
|
|
self.assertEqual(set(pool.volumes), before)
|
|
self.assertEqual(self.backend.deleted_volumes, [])
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_reinstall_define_failure_preserves_original_definition_and_volumes(self):
|
|
service, created, spec, domain, _seed_name = self.cloud_vm_with_real_seed()
|
|
pool = self.backend.pools["images"]
|
|
before = set(pool.volumes)
|
|
original_disk = domain.root.find("./devices/disk[@device='disk']/source").get("file")
|
|
self.backend.fail_define = True
|
|
|
|
with self.assertRaises(self.error_type):
|
|
service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
|
|
self.assertEqual(set(pool.volumes), before)
|
|
self.assertEqual(domain.root.find("./devices/disk[@device='disk']/source").get("file"),
|
|
original_disk)
|
|
self.assertIn("cloud-vm.qcow2", pool.volumes)
|
|
self.assertNotIn("cloud-vm.qcow2", self.backend.deleted_volumes)
|
|
|
|
def test_reinstall_start_failure_rolls_back_definition_and_keeps_old_disk(self):
|
|
service, created, spec, domain, old_seed_name = self.cloud_vm_with_real_seed()
|
|
pool = self.backend.pools["images"]
|
|
before = set(pool.volumes)
|
|
original_disk = domain.root.find("./devices/disk[@device='disk']/source").get("file")
|
|
self.backend.fail_domain_create = True
|
|
|
|
with self.assertRaises(self.error_type):
|
|
service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
|
|
self.assertEqual(set(pool.volumes), before)
|
|
self.assertEqual(domain.root.find("./devices/disk[@device='disk']/source").get("file"),
|
|
original_disk)
|
|
self.assertIn("cloud-vm.qcow2", pool.volumes)
|
|
self.assertIn(old_seed_name, pool.volumes)
|
|
self.assertNotIn("cloud-vm.qcow2", self.backend.deleted_volumes)
|
|
|
|
def test_reinstall_transport_error_after_start_preserves_both_disks(self):
|
|
reserved_uuid = "14d9bb2f-65cd-4406-a377-90685c0690e4"
|
|
service, created, spec, domain, old_seed_name = self.cloud_vm_with_real_seed(
|
|
vm_uuid=reserved_uuid)
|
|
pool = self.backend.pools["images"]
|
|
old_disk_name = domain.root.find(
|
|
"./metadata/{urn:virsh-panel:1}managed").get("disk-volume")
|
|
self.backend.fail_domain_create_after_start = True
|
|
|
|
result = service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
|
|
self.assertTrue(domain.isActive())
|
|
self.assertEqual(domain.name(), "vc-14d9bb2f65cd4406")
|
|
self.assertEqual(result["vm"]["name"], "cloud-vm")
|
|
self.assertIn("旧系统盘已保留", result["warning"])
|
|
self.assertIn(old_disk_name, pool.volumes)
|
|
self.assertIn(old_seed_name, pool.volumes)
|
|
self.assertNotIn(old_disk_name, self.backend.deleted_volumes)
|
|
self.assertNotEqual(
|
|
domain.root.find("./devices/disk[@device='disk']/source").get("file"),
|
|
pool.volumes[old_disk_name].path(),
|
|
)
|
|
|
|
def test_reinstall_old_disk_delete_failure_reports_warning_and_keeps_new_vm(self):
|
|
service, created, spec, domain, old_seed_name = self.cloud_vm_with_real_seed()
|
|
pool = self.backend.pools["images"]
|
|
self.backend.fail_volume_delete = True
|
|
|
|
result = service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
|
|
self.assertEqual(result["vm"]["state"], "running")
|
|
self.assertTrue(result.get("warning"))
|
|
self.assertTrue(domain.isActive())
|
|
self.assertIn("cloud-vm.qcow2", pool.volumes)
|
|
self.assertIn(old_seed_name, pool.volumes)
|
|
new_disk_name = domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed").get("disk-volume")
|
|
self.assertNotEqual(new_disk_name, "cloud-vm.qcow2")
|
|
self.assertIn(new_disk_name, pool.volumes)
|
|
self.assertIn(TEMPLATE_NAME, pool.volumes)
|
|
|
|
def test_reinstall_password_mode_writes_only_hash_to_new_seed(self):
|
|
from virsh_panel.cloud_init import hash_root_password
|
|
|
|
service, created, _spec, domain, _seed_name = self.cloud_vm_with_real_seed()
|
|
password = "Another-strong-guest-password-2026"
|
|
password_hash = hash_root_password(password)
|
|
result = service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
root_password_hash=password_hash,
|
|
)
|
|
|
|
self.assertEqual(result["vm"]["state"], "running")
|
|
new_seed_name = domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed").get("seed-volume")
|
|
seed = bytes(self.backend.pools["images"].volumes[new_seed_name].contents)
|
|
self.assertIn(password_hash.encode(), seed)
|
|
self.assertNotIn(password.encode(), seed)
|
|
|
|
def test_cloud_vm_can_be_reinstalled_more_than_once(self):
|
|
service, created, spec, domain, original_seed = self.cloud_vm_with_real_seed()
|
|
pool = self.backend.pools["images"]
|
|
|
|
service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
first_managed = domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
|
|
first_disk = first_managed.get("disk-volume")
|
|
first_seed = first_managed.get("seed-volume")
|
|
self.assertNotEqual(first_seed, original_seed)
|
|
|
|
second = service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
second_managed = domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
|
|
second_disk = second_managed.get("disk-volume")
|
|
second_seed = second_managed.get("seed-volume")
|
|
|
|
self.assertEqual(second["vm"]["state"], "running")
|
|
self.assertEqual(second["vm"]["created_at"], created["created_at"])
|
|
self.assertNotEqual(first_disk, second_disk)
|
|
self.assertNotEqual(first_seed, second_seed)
|
|
self.assertNotIn(first_disk, pool.volumes)
|
|
self.assertNotIn(first_seed, pool.volumes)
|
|
self.assertEqual(set(pool.volumes), {TEMPLATE_NAME, second_disk, second_seed})
|
|
self.assertEqual(self.backend.shutdown_calls, 2)
|
|
|
|
def test_reinstall_refuses_iso_or_snapshotted_vm_without_shutdown(self):
|
|
service, created, spec, domain, _seed_name = self.cloud_vm_with_real_seed()
|
|
domain.snapshots = 1
|
|
before = set(self.backend.pools["images"].volumes)
|
|
|
|
with self.assertRaises(self.error_type) as raised:
|
|
service.reinstall_cloud_vm(
|
|
created["uuid"], TEMPLATE_NAME,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
self.assertEqual(raised.exception.status, 409)
|
|
self.assertEqual(self.backend.shutdown_calls, 0)
|
|
self.assertEqual(set(self.backend.pools["images"].volumes), before)
|
|
|
|
iso_vm = self.service.create_vm(self.spec(name="iso-vm"))
|
|
with self.assertRaises(self.error_type):
|
|
service.reinstall_cloud_vm(
|
|
iso_vm["uuid"], TEMPLATE_NAME,
|
|
ssh_public_key=spec["guest_ssh_public_key"],
|
|
)
|
|
|
|
def test_template_import_uploads_new_qcow2_volume_without_overwrite(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "verified.qcow2"
|
|
payload = b"QFI\xfb" + b"verified cloud image fixture"
|
|
image.write_bytes(payload)
|
|
result = self.service.import_template(image, TEMPLATE_NAME, 2 * 1024**3)
|
|
|
|
self.assertEqual(result["volume_name"], TEMPLATE_NAME)
|
|
self.assertEqual(result["image_bytes"], len(payload))
|
|
self.assertEqual(bytes(self.backend.pools["images"].volumes[TEMPLATE_NAME].contents),
|
|
payload)
|
|
self.assertEqual(self.backend.pools["images"].volumes[TEMPLATE_NAME].capacity,
|
|
2 * 1024**3)
|
|
self.assertTrue(self.backend.streams[-1].finished)
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_template_volume_allowlist_supports_each_official_os_family(self):
|
|
valid = (
|
|
"panel-template-alma8-12345678-0123456789abcdef.qcow2",
|
|
"panel-template-debian12-12345678-0123456789abcdef.qcow2",
|
|
"panel-template-ubuntu2404-12345678-0123456789abcdef.qcow2",
|
|
"panel-template-centosstream9-12345678-0123456789abcdef.qcow2",
|
|
"panel-template-centosstream10-12345678-0123456789abcdef-"
|
|
"1111111111111111.qcow2",
|
|
)
|
|
for volume_name in valid:
|
|
with self.subTest(volume_name=volume_name):
|
|
self.assertIsNotNone(
|
|
self.service_module.TEMPLATE_VOLUME_RE.fullmatch(volume_name)
|
|
)
|
|
for volume_name in (
|
|
"panel-template-ubuntu-arm64-12345678-0123456789abcdef.qcow2",
|
|
"panel-template-centos8-12345678-0123456789abcdef.qcow2",
|
|
"../panel-template-debian12-12345678-0123456789abcdef.qcow2",
|
|
):
|
|
with self.subTest(volume_name=volume_name):
|
|
self.assertIsNone(
|
|
self.service_module.TEMPLATE_VOLUME_RE.fullmatch(volume_name)
|
|
)
|
|
|
|
def test_template_import_stream_failure_deletes_only_new_volume(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "verified.qcow2"
|
|
image.write_bytes(b"QFI\xfbverified cloud image fixture")
|
|
self.backend.fail_send = True
|
|
with self.assertRaises(self.error_type):
|
|
self.service.import_template(image, TEMPLATE_NAME, 2 * 1024**3)
|
|
|
|
self.assertNotIn(TEMPLATE_NAME, self.backend.pools["images"].volumes)
|
|
self.assertTrue(self.backend.streams[-1].aborted)
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_template_import_rejects_wrong_remote_capacity_and_cleans_volume(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "verified.qcow2"
|
|
image.write_bytes(b"QFI\xfbverified cloud image fixture")
|
|
with patch.object(FakeVolume, "info", return_value=(0, 1024**3, 100, 0)):
|
|
with self.assertRaises(self.error_type) as raised:
|
|
self.service.import_template(image, TEMPLATE_NAME, 2 * 1024**3)
|
|
|
|
self.assertEqual(raised.exception.status, 502)
|
|
self.assertNotIn(TEMPLATE_NAME, self.backend.pools["images"].volumes)
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_template_cache_reuses_only_a_trusted_complete_replica(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "global-template.qcow2"
|
|
payload = b"QFI\xfb" + b"global cloud image fixture"
|
|
image.write_bytes(payload)
|
|
first = self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
|
|
)
|
|
pool = self.backend.pools["images"]
|
|
original = pool.volumes[TEMPLATE_REPLICA_ONE]
|
|
|
|
trusted = self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_TWO, 2 * 1024**3,
|
|
trusted_replica_volume_name=TEMPLATE_REPLICA_ONE,
|
|
trusted_replica_identity=first["replica_identity"],
|
|
)
|
|
self.assertTrue(trusted["already_cached"])
|
|
self.assertEqual(trusted["volume_name"], TEMPLATE_REPLICA_ONE)
|
|
self.assertIs(pool.volumes[TEMPLATE_REPLICA_ONE], original)
|
|
self.assertNotIn(TEMPLATE_REPLICA_TWO, pool.volumes)
|
|
|
|
replaced = self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_TWO, 2 * 1024**3,
|
|
)
|
|
|
|
self.assertFalse(first["already_cached"])
|
|
self.assertFalse(replaced["already_cached"])
|
|
self.assertEqual(replaced["volume_name"], TEMPLATE_REPLICA_TWO)
|
|
self.assertIs(pool.volumes[TEMPLATE_REPLICA_ONE], original)
|
|
self.assertEqual(bytes(pool.volumes[TEMPLATE_REPLICA_TWO].contents), payload)
|
|
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
|
|
|
|
def test_template_cache_uses_fresh_generation_when_pool_identity_changes(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "global-template.qcow2"
|
|
payload = b"QFI\xfb" + b"global cloud image fixture"
|
|
image.write_bytes(payload)
|
|
first = self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3)
|
|
pool = self.backend.pools["images"]
|
|
original = pool.volumes[TEMPLATE_REPLICA_ONE]
|
|
pool.path = "/srv/redefined-images"
|
|
self.backend.existing_dirs.add(pool.path)
|
|
|
|
replaced = self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_TWO, 2 * 1024**3,
|
|
trusted_replica_volume_name=TEMPLATE_REPLICA_ONE,
|
|
trusted_replica_identity=first["replica_identity"],
|
|
)
|
|
|
|
self.assertFalse(replaced["already_cached"])
|
|
self.assertEqual(replaced["volume_name"], TEMPLATE_REPLICA_TWO)
|
|
self.assertNotEqual(
|
|
replaced["replica_identity"], first["replica_identity"])
|
|
self.assertIs(pool.volumes[TEMPLATE_REPLICA_ONE], original)
|
|
self.assertIn(TEMPLATE_REPLICA_TWO, pool.volumes)
|
|
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
|
|
|
|
def test_template_cache_rejects_a_recreated_same_name_volume(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "global-template.qcow2"
|
|
payload = b"QFI\xfb" + b"global cloud image fixture"
|
|
image.write_bytes(payload)
|
|
first = self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3)
|
|
pool = self.backend.pools["images"]
|
|
original = pool.volumes[TEMPLATE_REPLICA_ONE]
|
|
|
|
# Recreate the same visible libvirt identity and allocation with
|
|
# different bytes. Name/path/capacity/allocation alone must not
|
|
# make this new volume generation trusted.
|
|
recreated = FakeVolume(
|
|
pool, TEMPLATE_REPLICA_ONE,
|
|
capacity=original.capacity, fmt=original.format,
|
|
)
|
|
recreated.contents[:] = b"x" * len(payload)
|
|
pool.volumes[TEMPLATE_REPLICA_ONE] = recreated
|
|
|
|
replaced = self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_TWO, 2 * 1024**3,
|
|
trusted_replica_volume_name=TEMPLATE_REPLICA_ONE,
|
|
trusted_replica_identity=first["replica_identity"],
|
|
)
|
|
|
|
self.assertFalse(replaced["already_cached"])
|
|
self.assertEqual(replaced["volume_name"], TEMPLATE_REPLICA_TWO)
|
|
self.assertIs(pool.volumes[TEMPLATE_REPLICA_ONE], recreated)
|
|
self.assertEqual(len(recreated.contents), len(payload))
|
|
self.assertNotEqual(bytes(recreated.contents), payload)
|
|
self.assertEqual(bytes(pool.volumes[TEMPLATE_REPLICA_TWO].contents), payload)
|
|
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
|
|
|
|
def test_template_cache_reuploads_an_interrupted_desired_generation(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "global-template.qcow2"
|
|
payload = b"QFI\xfb" + b"global cloud image fixture"
|
|
image.write_bytes(payload)
|
|
self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
|
|
)
|
|
pool = self.backend.pools["images"]
|
|
interrupted = pool.volumes[TEMPLATE_REPLICA_ONE]
|
|
interrupted.contents[:] = b"partial"
|
|
|
|
recovered = self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
|
|
)
|
|
|
|
self.assertFalse(recovered["already_cached"])
|
|
self.assertIsNot(pool.volumes[TEMPLATE_REPLICA_ONE], interrupted)
|
|
self.assertEqual(bytes(pool.volumes[TEMPLATE_REPLICA_ONE].contents), payload)
|
|
self.assertIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
|
|
|
|
def test_template_cache_refuses_to_overwrite_its_trusted_generation(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "global-template.qcow2"
|
|
image.write_bytes(b"QFI\xfbglobal cloud image fixture")
|
|
first = self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
|
|
)
|
|
original = self.backend.pools["images"].volumes[TEMPLATE_REPLICA_ONE]
|
|
|
|
with self.assertRaises(self.error_type) as raised:
|
|
self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
|
|
trusted_replica_volume_name=TEMPLATE_REPLICA_ONE,
|
|
trusted_replica_identity=first["replica_identity"],
|
|
)
|
|
|
|
self.assertEqual(raised.exception.status, 400)
|
|
self.assertIs(
|
|
self.backend.pools["images"].volumes[TEMPLATE_REPLICA_ONE], original)
|
|
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
|
|
|
|
def test_template_cache_does_not_replace_an_untrusted_referenced_volume(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "global-template.qcow2"
|
|
image.write_bytes(b"QFI\xfbglobal cloud image fixture")
|
|
self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
|
|
)
|
|
# A disk source referencing the desired replica generation is
|
|
# enough to make replacement unsafe, even if that definition was
|
|
# created outside the panel.
|
|
domain = FakeDomain(self.backend, f"""
|
|
<domain><name>external-template-user</name>
|
|
<uuid>00000000-0000-4000-8000-000000000099</uuid>
|
|
<devices><disk device="disk" type="volume">
|
|
<source pool="images" volume="{TEMPLATE_REPLICA_ONE}"/>
|
|
</disk></devices></domain>
|
|
""", running=True)
|
|
self.backend.domains.append(domain)
|
|
|
|
with self.assertRaises(self.error_type) as raised:
|
|
self.service.cache_template(
|
|
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
|
|
)
|
|
|
|
self.assertEqual(raised.exception.status, 409)
|
|
self.assertIn(TEMPLATE_REPLICA_ONE, self.backend.pools["images"].volumes)
|
|
|
|
def test_template_delete_removes_source_and_every_replica_generation(self):
|
|
pool = self.backend.pools["images"]
|
|
unrelated = "panel-template-alma10-87654321-fedcba9876543210.qcow2"
|
|
for name in (TEMPLATE_NAME, TEMPLATE_REPLICA_ONE,
|
|
TEMPLATE_REPLICA_TWO, unrelated):
|
|
pool.volumes[name] = FakeVolume(pool, name, capacity=2 * 1024**3)
|
|
|
|
result = self.service.delete_cloud_template_replicas(TEMPLATE_NAME)
|
|
|
|
self.assertTrue(result["deleted"])
|
|
self.assertEqual(
|
|
result["deleted_volumes"],
|
|
[TEMPLATE_REPLICA_ONE, TEMPLATE_REPLICA_TWO, TEMPLATE_NAME],
|
|
)
|
|
self.assertEqual(set(pool.volumes), {unrelated})
|
|
|
|
def test_missing_template_cache_has_precise_idempotency_code(self):
|
|
with self.assertRaises(self.error_type) as missing:
|
|
self.service.delete_cloud_template_replicas(TEMPLATE_NAME)
|
|
self.assertEqual(missing.exception.status, 404)
|
|
self.assertEqual(
|
|
missing.exception.error_code,
|
|
"cloud_template_cache_not_found",
|
|
)
|
|
|
|
service = self.service.__class__(
|
|
self.service.uri, "missing-images-pool", "iso", "default")
|
|
with self.assertRaises(self.error_type) as pool_missing:
|
|
service.delete_cloud_template_replicas(TEMPLATE_NAME)
|
|
self.assertEqual(pool_missing.exception.status, 404)
|
|
self.assertEqual(pool_missing.exception.error_code, "")
|
|
|
|
def test_template_delete_is_all_or_nothing_when_a_replica_is_referenced(self):
|
|
pool = self.backend.pools["images"]
|
|
for name in (TEMPLATE_REPLICA_ONE, TEMPLATE_REPLICA_TWO):
|
|
pool.volumes[name] = FakeVolume(pool, name, capacity=2 * 1024**3)
|
|
self.backend.domains.append(FakeDomain(self.backend, f"""
|
|
<domain><name>external-template-user</name>
|
|
<uuid>00000000-0000-4000-8000-000000000099</uuid>
|
|
<devices><disk device="disk" type="volume">
|
|
<source pool="images" volume="{TEMPLATE_REPLICA_TWO}"/>
|
|
</disk></devices></domain>
|
|
""", running=True))
|
|
|
|
with self.assertRaises(self.error_type) as raised:
|
|
self.service.delete_cloud_template_replicas(TEMPLATE_NAME)
|
|
|
|
self.assertEqual(raised.exception.status, 409)
|
|
self.assertIn(TEMPLATE_REPLICA_ONE, pool.volumes)
|
|
self.assertIn(TEMPLATE_REPLICA_TWO, pool.volumes)
|
|
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
|
|
|
|
def rescue_pool(self):
|
|
pool = self.backend.pools.get("rescue")
|
|
if pool is None:
|
|
pool = FakePool(self.backend, "rescue", "/home/rescue")
|
|
self.backend.pools["rescue"] = pool
|
|
return pool
|
|
|
|
def rescue_volume(self):
|
|
pool = self.rescue_pool()
|
|
pool.volumes[RESCUE_NAME] = FakeVolume(pool, RESCUE_NAME,
|
|
capacity=1024 * 1024, fmt="raw")
|
|
return pool.volumes[RESCUE_NAME]
|
|
|
|
def test_rescue_directory_is_registered_as_a_separate_persistent_pool(self):
|
|
configured = self.service.ensure_storage_pools()
|
|
self.assertEqual(configured, {
|
|
"storage_pool": "images", "iso_pool": "iso",
|
|
"rescue_iso_pool": self.backend.defined[-1][0],
|
|
})
|
|
self.assertEqual(self.backend.defined[-1][1], "/home/rescue")
|
|
self.assertTrue(self.backend.pools[configured["rescue_iso_pool"]].autostart())
|
|
self.assertEqual(self.backend.existing_dirs.intersection({"/home/rescue"}),
|
|
{"/home/rescue"})
|
|
|
|
def test_rescue_iso_is_separate_from_install_iso_list_and_creation(self):
|
|
self.rescue_volume()
|
|
self.assertEqual(self.service.resources()["isos"], ["AlmaLinux-10.iso"])
|
|
self.assertEqual(self.service.create_vm(self.spec())["state"], "running")
|
|
with self.assertRaises(self.error_type) as missing:
|
|
self.service.create_vm(self.spec(name="rescue-as-installer",
|
|
iso="another-rescue.iso"))
|
|
self.assertEqual(missing.exception.status, 404)
|
|
# Even if somebody places a panel-named rescue ISO into the ordinary
|
|
# pool by hand, it must not become a selectable installation source.
|
|
normal_pool = self.backend.pools["iso"]
|
|
normal_pool.volumes[RESCUE_NAME] = FakeVolume(normal_pool, RESCUE_NAME)
|
|
self.assertNotIn(RESCUE_NAME, self.service.resources()["isos"])
|
|
with self.assertRaises(self.error_type) as blocked:
|
|
self.service.create_vm(self.spec(name="rescue-as-installer",
|
|
iso=RESCUE_NAME))
|
|
self.assertEqual(blocked.exception.status, 409)
|
|
|
|
def test_rescue_operations_never_fall_back_to_normal_iso_pool(self):
|
|
ordinary = self.backend.pools["iso"]
|
|
ordinary.volumes[RESCUE_NAME] = FakeVolume(ordinary, RESCUE_NAME,
|
|
capacity=1024 * 1024, fmt="raw")
|
|
unconfigured = self.service.__class__(
|
|
self.service.uri, "images", "iso", "default")
|
|
with self.assertRaises(self.error_type) as missing:
|
|
unconfigured.delete_rescue_iso(RESCUE_NAME)
|
|
self.assertEqual(missing.exception.status, 409)
|
|
self.assertIn("配置救援 ISO", str(missing.exception))
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "rescue.iso"
|
|
payload = bytearray(1024 * 1024)
|
|
payload[32769:32774] = b"CD001"
|
|
image.write_bytes(payload)
|
|
with self.assertRaises(self.error_type) as missing_upload:
|
|
unconfigured.import_rescue_iso(image, RESCUE_NAME)
|
|
self.assertEqual(missing_upload.exception.status, 409)
|
|
self.assertIn(RESCUE_NAME, ordinary.volumes)
|
|
|
|
def test_rescue_pool_alias_of_install_iso_pool_is_rejected(self):
|
|
normal_pool = self.backend.pools["iso"]
|
|
alias = FakePool(self.backend, "rescue-alias", normal_pool.path)
|
|
self.backend.pools["rescue-alias"] = alias
|
|
service = self.service.__class__(
|
|
self.service.uri, "images", "iso", "default",
|
|
rescue_iso_pool="rescue-alias")
|
|
with self.assertRaises(self.error_type) as invalid:
|
|
service.ensure_storage_pools()
|
|
self.assertEqual(invalid.exception.status, 409)
|
|
with self.assertRaises(self.error_type) as invalid_lookup:
|
|
service.delete_rescue_iso(RESCUE_NAME)
|
|
self.assertEqual(invalid_lookup.exception.status, 409)
|
|
self.assertFalse(alias.volumes)
|
|
|
|
def test_rescue_pool_alias_with_mixed_file_pool_types_is_rejected(self):
|
|
normal_pool = self.backend.pools["iso"]
|
|
alias = FakePool(self.backend, "rescue-fs-alias", normal_pool.path,
|
|
pool_type="fs")
|
|
self.backend.pools["rescue-fs-alias"] = alias
|
|
service = self.service.__class__(
|
|
self.service.uri, "images", "iso", "default",
|
|
rescue_iso_pool="rescue-fs-alias")
|
|
with self.assertRaises(self.error_type) as invalid:
|
|
service.ensure_storage_pools()
|
|
self.assertEqual(invalid.exception.status, 409)
|
|
with self.assertRaises(self.error_type) as invalid_lookup:
|
|
service.delete_rescue_iso(RESCUE_NAME)
|
|
self.assertEqual(invalid_lookup.exception.status, 409)
|
|
|
|
def test_rescue_iso_import_rejects_invalid_file_and_never_overwrites(self):
|
|
self.rescue_pool()
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "rescue.iso"
|
|
image.write_bytes(b"not an ISO" * 10000)
|
|
with self.assertRaises(self.error_type) as invalid:
|
|
self.service.import_rescue_iso(image, RESCUE_NAME)
|
|
self.assertEqual(invalid.exception.status, 422)
|
|
self.assertNotIn(RESCUE_NAME, self.backend.pools["rescue"].volumes)
|
|
|
|
payload = bytearray(1024 * 1024)
|
|
payload[32769:32774] = b"CD001"
|
|
image.write_bytes(payload)
|
|
imported = self.service.import_rescue_iso(image, RESCUE_NAME)
|
|
self.assertEqual(imported, {"volume_name": RESCUE_NAME,
|
|
"image_bytes": len(payload)})
|
|
self.assertEqual(bytes(self.backend.pools["rescue"].volumes[RESCUE_NAME].contents),
|
|
payload)
|
|
with self.assertRaises(self.error_type) as exists:
|
|
self.service.import_rescue_iso(image, RESCUE_NAME)
|
|
self.assertEqual(exists.exception.status, 409)
|
|
|
|
def test_rescue_iso_import_stream_failure_removes_only_new_volume(self):
|
|
self.rescue_pool()
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
image = pathlib.Path(directory) / "rescue.iso"
|
|
payload = bytearray(1024 * 1024)
|
|
payload[32769:32774] = b"CD001"
|
|
image.write_bytes(payload)
|
|
self.backend.fail_send = True
|
|
with self.assertRaises(self.error_type):
|
|
self.service.import_rescue_iso(image, RESCUE_NAME)
|
|
self.assertNotIn(RESCUE_NAME, self.backend.pools["rescue"].volumes)
|
|
self.assertTrue(self.backend.streams[-1].aborted)
|
|
|
|
def test_missing_rescue_volume_has_precise_idempotency_code(self):
|
|
self.rescue_pool()
|
|
with self.assertRaises(self.error_type) as missing:
|
|
self.service.delete_rescue_iso(RESCUE_NAME)
|
|
self.assertEqual(missing.exception.status, 404)
|
|
self.assertEqual(
|
|
missing.exception.error_code, "rescue_volume_not_found")
|
|
|
|
service = self.service.__class__(
|
|
self.service.uri, "images", "iso", "default",
|
|
rescue_iso_pool="missing-rescue-pool")
|
|
with self.assertRaises(self.error_type) as pool_missing:
|
|
service.delete_rescue_iso(RESCUE_NAME)
|
|
self.assertEqual(pool_missing.exception.status, 404)
|
|
self.assertEqual(pool_missing.exception.error_code, "")
|
|
|
|
def test_rescue_iso_delete_can_clean_corrupt_unreferenced_managed_volume(self):
|
|
pool = self.rescue_pool()
|
|
pool.volumes[RESCUE_NAME] = FakeVolume(pool, RESCUE_NAME,
|
|
capacity=1024, fmt="qcow2")
|
|
self.assertTrue(self.service.delete_rescue_iso(RESCUE_NAME)["deleted"])
|
|
self.assertNotIn(RESCUE_NAME, pool.volumes)
|
|
|
|
def test_rescue_boot_preserves_seed_cdrom_and_exit_restores_original_xml(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
original_disk_names = set(self.backend.pools["images"].volumes)
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
|
|
entered = service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertTrue(entered["vm"]["rescue_mode"])
|
|
self.assertFalse(entered["vm"]["rescue_staged"])
|
|
self.assertEqual(entered["vm"]["rescue_volume_name"], RESCUE_NAME)
|
|
self.assertTrue(self.backend.domains[0].autostart())
|
|
rescue_root = self.backend.domains[0].root
|
|
self.assertEqual(len(rescue_root.findall("./devices/disk[@device='cdrom']")), 2)
|
|
self.assertIsNone(rescue_root.find("./os/boot"))
|
|
seed = rescue_root.findall("./devices/disk[@device='cdrom']")[0]
|
|
rescue = rescue_root.findall("./devices/disk[@device='cdrom']")[1]
|
|
self.assertIn("panel-seed-", seed.find("source").get("file"))
|
|
self.assertEqual(rescue.find("source").get("file"),
|
|
self.backend.pools["rescue"].volumes[RESCUE_NAME].path())
|
|
self.assertEqual(rescue.find("boot").get("order"), "1")
|
|
self.assertEqual(rescue_root.find("./devices/disk[@device='disk']/boot").get("order"),
|
|
"2")
|
|
with self.assertRaises(self.error_type) as in_use:
|
|
service.delete_rescue_iso(RESCUE_NAME)
|
|
self.assertEqual(in_use.exception.status, 409)
|
|
|
|
exited = service.exit_rescue_vm(created["uuid"], original_xml)
|
|
self.assertFalse(exited["vm"]["rescue_mode"])
|
|
self.assertTrue(self.backend.domains[0].autostart())
|
|
self.assertEqual(len(self.backend.domains[0].root.findall(
|
|
"./devices/disk[@device='cdrom']")), 1)
|
|
self.assertEqual(set(self.backend.pools["images"].volumes), original_disk_names)
|
|
self.assertEqual(self.backend.shutdown_calls, 2)
|
|
self.assertEqual(self.backend.destroyed, [])
|
|
self.assertTrue(service.delete_rescue_iso(RESCUE_NAME)["deleted"])
|
|
|
|
def test_traffic_suspension_survives_rescue_exit_until_network_resume(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
|
|
service.network_suspend(created["uuid"])
|
|
exited = service.exit_rescue_vm(
|
|
created["uuid"], original_xml, network_suspended=True)
|
|
self.assertFalse(exited["vm"]["rescue_mode"])
|
|
domain = self.backend.domains[0]
|
|
inactive = ET.fromstring(domain.XMLDesc(
|
|
self.service_module.libvirt.VIR_DOMAIN_XML_INACTIVE))
|
|
live = ET.fromstring(domain.XMLDesc(0))
|
|
self.assertTrue(service._interface_links_match(inactive, "down"))
|
|
self.assertTrue(service._interface_links_match(live, "down"))
|
|
|
|
service.network_resume(created["uuid"])
|
|
inactive = ET.fromstring(domain.XMLDesc(
|
|
self.service_module.libvirt.VIR_DOMAIN_XML_INACTIVE))
|
|
live = ET.fromstring(domain.XMLDesc(0))
|
|
self.assertTrue(service._interface_links_match(inactive, "up"))
|
|
self.assertTrue(service._interface_links_match(live, "up"))
|
|
|
|
def test_stopped_vm_can_start_directly_in_rescue_mode(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
domain = self.backend.domains[0]
|
|
domain.shutdown()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
before = self.backend.shutdown_calls
|
|
result = service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertTrue(result["vm"]["rescue_mode"])
|
|
self.assertEqual(self.backend.shutdown_calls, before)
|
|
self.assertEqual(self.backend.destroyed, [])
|
|
|
|
def test_rescue_entry_rejects_changed_xml_before_shutdown(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
changed = ET.fromstring(original_xml)
|
|
changed.find("./memory").text = "8192"
|
|
self.backend.domains[0].define(ET.tostring(changed, encoding="unicode"))
|
|
with self.assertRaises(self.error_type) as mismatch:
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertEqual(mismatch.exception.status, 409)
|
|
self.assertEqual(self.backend.shutdown_calls, 0)
|
|
|
|
def test_rescue_rejects_ambiguous_multi_disk_boot_before_shutdown(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
domain = self.backend.domains[0]
|
|
original = ET.fromstring(domain.XMLDesc(1))
|
|
disk = original.find("./devices/disk[@device='disk']")
|
|
disk.find("target").set("dev", "vdb")
|
|
extra = copy.deepcopy(disk)
|
|
extra.find("target").set("dev", "vdc")
|
|
original.find("devices").append(extra)
|
|
domain.define(ET.tostring(original, encoding="unicode"))
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
with self.assertRaises(self.error_type) as ambiguous:
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertEqual(ambiguous.exception.status, 409)
|
|
self.assertEqual(self.backend.shutdown_calls, 0)
|
|
|
|
def test_rescue_honors_explicit_boot_disk_in_multi_disk_vm(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
domain = self.backend.domains[0]
|
|
original = ET.fromstring(domain.XMLDesc(1))
|
|
os_node = original.find("os")
|
|
for boot in list(os_node.findall("boot")):
|
|
os_node.remove(boot)
|
|
disk = original.find("./devices/disk[@device='disk']")
|
|
ET.SubElement(disk, "boot", order="2")
|
|
extra = copy.deepcopy(disk)
|
|
extra.find("target").set("dev", "vdb")
|
|
extra.find("boot").set("order", "1")
|
|
original.find("devices").append(extra)
|
|
domain.define(ET.tostring(original, encoding="unicode"))
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
booted_disks = [node.find("target").get("dev") for node in
|
|
domain.root.findall("./devices/disk[@device='disk']")
|
|
if node.find("boot") is not None]
|
|
self.assertEqual(booted_disks, ["vdb"])
|
|
|
|
def test_rescue_shutdown_timeout_never_forces_poweroff(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
self.backend.shutdown_stalls = True
|
|
with patch.object(self.service_module, "REINSTALL_SHUTDOWN_TIMEOUT", 0):
|
|
result = service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertTrue(result["pending_manual_restart"])
|
|
self.assertIn("正常关机超时", result["warning"])
|
|
self.assertIn("强制重启进入救援", result["warning"])
|
|
self.assertIn("强制断电", result["warning"])
|
|
self.assertIn("强制重置", result["warning"])
|
|
self.assertNotIn("联系客服", result["warning"])
|
|
self.assertTrue(self.backend.domains[0].running)
|
|
self.assertEqual(self.backend.destroyed, [])
|
|
domain = self.backend.domains[0]
|
|
self.assertFalse(result["vm"]["rescue_mode"])
|
|
self.assertTrue(result["vm"]["rescue_staged"])
|
|
self.assertEqual(result["vm"]["rescue_volume_name"], RESCUE_NAME)
|
|
self.assertIsNone(domain.root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}rescue"))
|
|
self.assertIsNotNone(domain.inactive_root.find(
|
|
f"./metadata/{{{self.service_module.PANEL_NS}}}rescue"))
|
|
|
|
# A QEMU reset uses its live configuration; a cold power cycle reads
|
|
# the durable rescue definition saved before the failed shutdown.
|
|
service.action(created["uuid"], "reset")
|
|
self.assertTrue(service.get_vm(created["uuid"])["rescue_staged"])
|
|
before_starts = self.backend.domain_starts
|
|
forced = service.force_start_staged_rescue_vm(created["uuid"], original_xml)
|
|
self.assertEqual(self.backend.destroy_calls, 1)
|
|
self.assertEqual(self.backend.domain_starts, before_starts + 1)
|
|
self.assertTrue(forced["vm"]["rescue_mode"])
|
|
self.assertTrue(service.get_vm(created["uuid"])["rescue_mode"])
|
|
self.assertFalse(service.get_vm(created["uuid"])["rescue_staged"])
|
|
self.backend.shutdown_stalls = False
|
|
service.exit_rescue_vm(created["uuid"], original_xml)
|
|
self.assertFalse(service.get_vm(created["uuid"])["rescue_mode"])
|
|
|
|
def test_rescue_shutdown_request_failure_instructs_manual_poweroff(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
domain = self.backend.domains[0]
|
|
with patch.object(domain, "shutdown", side_effect=FakeLibvirtError("ACPI unavailable")):
|
|
result = service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertTrue(result["pending_manual_restart"])
|
|
self.assertIn("无法请求虚拟机正常关机", result["warning"])
|
|
self.assertIn("强制重启进入救援", result["warning"])
|
|
self.assertNotIn("联系客服", result["warning"])
|
|
self.assertTrue(domain.running)
|
|
self.assertEqual(self.backend.destroyed, [])
|
|
self.assertFalse(service.get_vm(created["uuid"])["rescue_mode"])
|
|
self.assertTrue(service.get_vm(created["uuid"])["rescue_staged"])
|
|
|
|
def test_rescue_shutdown_error_after_external_cold_start_reports_active(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
domain = self.backend.domains[0]
|
|
|
|
def cold_start_then_error():
|
|
domain.running = False
|
|
domain.live_root = None
|
|
domain.create()
|
|
raise FakeLibvirtError("shutdown result lost")
|
|
|
|
with patch.object(domain, "shutdown", side_effect=cold_start_then_error):
|
|
result = service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertNotIn("pending_manual_restart", result)
|
|
self.assertTrue(result["vm"]["rescue_mode"])
|
|
self.assertFalse(result["vm"]["rescue_staged"])
|
|
self.assertIn("VNC", result["warning"])
|
|
|
|
def test_rescue_staged_exit_cancels_boot_without_stopping_running_vm(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
domain = self.backend.domains[0]
|
|
self.backend.shutdown_stalls = True
|
|
with patch.object(self.service_module, "REINSTALL_SHUTDOWN_TIMEOUT", 0):
|
|
result = service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertTrue(result["pending_manual_restart"])
|
|
before_shutdowns = self.backend.shutdown_calls
|
|
before_starts = self.backend.domain_starts
|
|
exited = service.exit_rescue_vm(created["uuid"], original_xml)
|
|
self.assertFalse(exited["vm"]["rescue_mode"])
|
|
self.assertFalse(exited["vm"]["rescue_staged"])
|
|
self.assertTrue(domain.running)
|
|
self.assertEqual(self.backend.shutdown_calls, before_shutdowns)
|
|
self.assertEqual(self.backend.domain_starts, before_starts)
|
|
self.assertTrue(service.delete_rescue_iso(RESCUE_NAME)["deleted"])
|
|
|
|
def test_force_staged_rescue_rejects_wrong_backup_without_poweroff(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
self.backend.shutdown_stalls = True
|
|
with patch.object(self.service_module, "REINSTALL_SHUTDOWN_TIMEOUT", 0):
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
tampered = original_xml.replace("cloud-vm", "other-vm")
|
|
with self.assertRaises(self.error_type) as error:
|
|
service.force_start_staged_rescue_vm(created["uuid"], tampered)
|
|
self.assertEqual(error.exception.status, 409)
|
|
self.assertEqual(self.backend.destroy_calls, 0)
|
|
self.assertTrue(self.backend.domains[0].running)
|
|
|
|
def test_force_staged_rescue_start_failure_keeps_iso_for_retry(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
self.backend.shutdown_stalls = True
|
|
with patch.object(self.service_module, "REINSTALL_SHUTDOWN_TIMEOUT", 0):
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.backend.fail_domain_create = True
|
|
with self.assertRaises(self.error_type) as error:
|
|
service.force_start_staged_rescue_vm(created["uuid"], original_xml)
|
|
self.assertEqual(error.exception.status, 502)
|
|
self.assertEqual(self.backend.destroy_calls, 1)
|
|
self.assertFalse(self.backend.domains[0].running)
|
|
self.assertTrue(service.get_vm(created["uuid"])["rescue_staged"])
|
|
self.backend.fail_domain_create = False
|
|
retried = service.force_start_staged_rescue_vm(created["uuid"], original_xml)
|
|
self.assertTrue(retried["vm"]["rescue_mode"])
|
|
self.assertFalse(retried["vm"]["rescue_staged"])
|
|
self.assertEqual(self.backend.destroy_calls, 1)
|
|
|
|
def test_force_staged_rescue_poweroff_failure_keeps_original_running(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
self.backend.shutdown_stalls = True
|
|
with patch.object(self.service_module, "REINSTALL_SHUTDOWN_TIMEOUT", 0):
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
before_starts = self.backend.domain_starts
|
|
self.backend.fail_destroy = True
|
|
with self.assertRaises(self.error_type) as error:
|
|
service.force_start_staged_rescue_vm(created["uuid"], original_xml)
|
|
self.assertEqual(error.exception.status, 502)
|
|
self.assertEqual(self.backend.domain_starts, before_starts)
|
|
self.assertTrue(self.backend.domains[0].running)
|
|
self.assertTrue(service.get_vm(created["uuid"])["rescue_staged"])
|
|
|
|
def test_rescue_staged_exit_after_manual_poweroff_starts_original_system(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
self.backend.shutdown_stalls = True
|
|
with patch.object(self.service_module, "REINSTALL_SHUTDOWN_TIMEOUT", 0):
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
service.action(created["uuid"], "poweroff")
|
|
self.assertTrue(service.get_vm(created["uuid"])["rescue_staged"])
|
|
exited = service.exit_rescue_vm(created["uuid"], original_xml)
|
|
self.assertEqual(exited["vm"]["state"], "running")
|
|
self.assertFalse(exited["vm"]["rescue_mode"])
|
|
self.assertFalse(exited["vm"]["rescue_staged"])
|
|
|
|
def test_rescue_start_failure_restores_original_vm(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
self.backend.fail_define = True
|
|
with self.assertRaises(self.error_type) as failure:
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertEqual(failure.exception.status, 502)
|
|
self.assertTrue(self.backend.domains[0].running)
|
|
self.assertFalse(service.get_vm(created["uuid"])["rescue_mode"])
|
|
self.assertEqual(self.backend.destroyed, [])
|
|
|
|
def test_rescue_guest_start_failure_restores_original_vm(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
original_create = FakeDomain.create
|
|
namespace = self.service_module.PANEL_NS
|
|
|
|
def fail_rescue_start(self):
|
|
if self.inactive_root.find(
|
|
f"./metadata/{{{namespace}}}rescue") is not None:
|
|
raise FakeLibvirtError("rescue start failed")
|
|
return original_create(self)
|
|
|
|
with patch.object(FakeDomain, "create", fail_rescue_start):
|
|
with self.assertRaises(self.error_type) as failure:
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertEqual(failure.exception.status, 502)
|
|
self.assertTrue(self.backend.domains[0].running)
|
|
self.assertFalse(service.get_vm(created["uuid"])["rescue_mode"])
|
|
|
|
def test_rescue_start_transport_error_after_boot_keeps_rescue_config(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
self.backend.fail_domain_create_after_start = True
|
|
result = service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertIn("warning", result)
|
|
self.assertTrue(result["vm"]["rescue_mode"])
|
|
self.assertTrue(self.backend.domains[0].running)
|
|
|
|
def test_rescue_exit_rejects_wrong_backup_without_shutdown(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
tampered = original_xml.replace("cloud-vm", "other-vm")
|
|
before = self.backend.shutdown_calls
|
|
with self.assertRaises(self.error_type) as failure:
|
|
service.exit_rescue_vm(created["uuid"], tampered)
|
|
self.assertEqual(failure.exception.status, 409)
|
|
self.assertEqual(self.backend.shutdown_calls, before)
|
|
|
|
def test_rescue_exit_start_failure_restores_rescue_vm(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
original_create = FakeDomain.create
|
|
namespace = self.service_module.PANEL_NS
|
|
|
|
def fail_normal_start(self):
|
|
if self.inactive_root.find(f"./metadata/{{{namespace}}}rescue") is None:
|
|
raise FakeLibvirtError("normal system start failed")
|
|
return original_create(self)
|
|
|
|
with patch.object(FakeDomain, "create", fail_normal_start):
|
|
with self.assertRaises(self.error_type) as failure:
|
|
service.exit_rescue_vm(created["uuid"], original_xml)
|
|
self.assertEqual(failure.exception.status, 502)
|
|
self.assertTrue(self.backend.domains[0].running)
|
|
self.assertTrue(service.get_vm(created["uuid"])["rescue_mode"])
|
|
self.assertEqual(self.backend.destroyed, [])
|
|
|
|
def test_rescue_redefinition_restores_original_autostart_setting(self):
|
|
service = self.cloud_service()
|
|
created = self.create_cloud_vm(service, self.cloud_spec())
|
|
self.rescue_volume()
|
|
domain = self.backend.domains[0]
|
|
domain.setAutostart(0)
|
|
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
|
|
original_define = FakeDomain.define
|
|
|
|
def resetting_define(self, xml):
|
|
original_define(self, xml)
|
|
self.auto_start = True
|
|
|
|
with patch.object(FakeDomain, "define", resetting_define):
|
|
service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
|
|
self.assertFalse(domain.autostart())
|
|
service.exit_rescue_vm(created["uuid"], original_xml)
|
|
self.assertFalse(domain.autostart())
|
|
|
|
def test_metric_counters_use_bulk_libvirt_stats_for_running_domains(self):
|
|
constants = {
|
|
"VIR_DOMAIN_STATS_CPU_TOTAL": 2,
|
|
"VIR_DOMAIN_STATS_BALLOON": 4,
|
|
"VIR_DOMAIN_STATS_BLOCK": 8,
|
|
"VIR_DOMAIN_STATS_INTERFACE": 16,
|
|
"VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING": 32,
|
|
}
|
|
for name, value in constants.items():
|
|
setattr(self.service_module.libvirt, name, value)
|
|
domain = types.SimpleNamespace(
|
|
UUIDString=lambda: "00000000-0000-4000-8000-000000000001",
|
|
info=lambda: (1, 2048 * 1024, 2048 * 1024, 2, 0),
|
|
ID=lambda: 7,
|
|
XMLDesc=lambda _flags: ("<domain><devices><interface>"
|
|
"<mac address='52:54:00:12:34:56'/>"
|
|
"<target dev='vnet9'/>"
|
|
"</interface></devices></domain>"),
|
|
)
|
|
calls = []
|
|
|
|
def get_stats(_connection, groups, flags):
|
|
calls.append((groups, flags))
|
|
return [(domain, {"cpu.time": 123, "net.count": 1,
|
|
"net.0.name": "vnet9", "net.0.rx.bytes": 456})]
|
|
|
|
with patch.object(FakeConnection, "getAllDomainStats", get_stats, create=True):
|
|
result = self.service.metric_counters()
|
|
self.assertEqual(calls, [(2 | 4 | 8 | 16, 32)])
|
|
self.assertEqual(len(result), 1)
|
|
self.assertEqual(result[0].generation, 7)
|
|
self.assertEqual(result[0].vcpus, 2)
|
|
self.assertEqual(result[0].values["net.0.rx.bytes"], 456)
|
|
self.assertEqual(result[0].values["net.0.identity"],
|
|
"mac:52:54:00:12:34:56")
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
def test_metric_counters_skip_vm_disappearing_after_bulk_read(self):
|
|
constants = {
|
|
"VIR_DOMAIN_STATS_CPU_TOTAL": 2,
|
|
"VIR_DOMAIN_STATS_BALLOON": 4,
|
|
"VIR_DOMAIN_STATS_BLOCK": 8,
|
|
"VIR_DOMAIN_STATS_INTERFACE": 16,
|
|
"VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING": 32,
|
|
}
|
|
for name, value in constants.items():
|
|
setattr(self.service_module.libvirt, name, value)
|
|
|
|
def gone():
|
|
raise FakeLibvirtError("domain vanished")
|
|
|
|
disappearing = types.SimpleNamespace(info=gone)
|
|
healthy = types.SimpleNamespace(
|
|
UUIDString=lambda: "00000000-0000-4000-8000-000000000002",
|
|
info=lambda: (1, 2048 * 1024, 2048 * 1024, 2, 0),
|
|
ID=lambda: 8,
|
|
)
|
|
with patch.object(
|
|
FakeConnection, "getAllDomainStats",
|
|
lambda _connection, _groups, _flags: [
|
|
(disappearing, {"cpu.time": 1}),
|
|
(healthy, {"cpu.time": 2}),
|
|
], create=True,
|
|
):
|
|
result = self.service.metric_counters()
|
|
self.assertEqual(len(result), 1)
|
|
self.assertEqual(result[0].vm_id, "00000000-0000-4000-8000-000000000002")
|
|
self.assertEqual(self.backend.opened, self.backend.closed)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|