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.
virt/engine/tests/test_libvirt_service.py

3273 lines
155 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 ("x86_64", 0, 0, 0, 0, 0, 0, 0)
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.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 = {
"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")
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 = {
"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_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"])
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.assertIn(USER_ISO_NAME, next(
pool for pool in self.backend.pools.values()
if pool.path == "/home/iso/41").volumes)
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_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_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(created["public_ip_cidr"], "8.8.8.18/24")
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["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_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_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()