"""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" RESCUE_NAME = "panel-rescue-0123456789abcdef0123456789abcdef.iso" class FakeLibvirtError(Exception): pass class FakeVolume: 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 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) 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): raise AssertionError("pool.build must not create host directories") 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) 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 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 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.started = [] self.autostart_changed = [] self.domain_autostart_changed = [] 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.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.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 @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): """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() 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") 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) with self.assertRaisesRegex(self.error_type, "UUID"): self.service.create_vm(self.spec(name="invalid-uuid", vm_uuid="not-a-uuid")) 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", "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_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) 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): created = service.create_cloud_vm( self.cloud_spec(os_name="AlmaLinux 9"), alma9_volume, ) self.assertEqual(created["os_name"], "AlmaLinux 9") self.assertEqual(self.backend.pools["images"].volumes["cloud-vm.qcow2"].cloned_from, alma9_volume) 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") self.assertEqual(self.backend.opened, self.backend.closed) 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_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 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.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): service, created, spec, domain, old_seed_name = self.cloud_vm_with_real_seed() pool = self.backend.pools["images"] 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.assertIn("旧系统盘已保留", result["warning"]) self.assertIn("cloud-vm.qcow2", pool.volumes) self.assertIn(old_seed_name, pool.volumes) self.assertNotIn("cloud-vm.qcow2", self.backend.deleted_volumes) self.assertNotEqual( domain.root.find("./devices/disk[@device='disk']/source").get("file"), pool.volumes["cloud-vm.qcow2"].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_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 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_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, ) calls = [] def get_stats(_connection, groups, flags): calls.append((groups, flags)) return [(domain, {"cpu.time": 123, "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(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()