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

8130 lines
366 KiB
Python

"""Contract tests for the libvirt boundary; no hypervisor is required."""
from __future__ import annotations
import base64
import hashlib
import importlib.util
import ipaddress
import json
import pathlib
import sys
import tempfile
import time
import types
import unittest
import uuid
import copy
import xml.etree.ElementTree as ET
from contextlib import contextmanager
from unittest.mock import Mock, 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):
NO_NWFILTER = 55
def __init__(self, message, error_code=1):
super().__init__(message)
self.error_code = error_code
def get_error_code(self):
return self.error_code
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)
self.backend.volume_create_xmls.append(copy.deepcopy(root))
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"))
allocation = int(root.findtext("allocation", "0"))
if allocation and self.backend.fail_volume_allocation:
raise FakeLibvirtError("volume allocation failed")
volume = FakeVolume(self, name, capacity=capacity, fmt=fmt)
self.volumes[name] = volume
if self.backend.fail_volume_create_after_create:
raise FakeLibvirtError("volume create response lost")
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()
volume.contents = bytearray(source_volume.contents)
self.backend.clones.append((volume.name(), source_volume.name()))
if self.backend.fail_clone_after_create:
raise FakeLibvirtError("clone response lost")
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.managed_save_image = False
self.checkpoints = 0
self.last_reset_flags = None
self.backup_terminal = 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 setMetadata(self, metadata_type, metadata, key, uri, flags):
assert metadata_type == 1
assert key == "qga-runtime"
assert uri == "urn:virsh-panel:qga-runtime:1"
assert flags == 1
if not self.running or self.live_root is None:
raise FakeLibvirtError("domain is not running")
node = ET.fromstring(metadata)
metadata_node = self.live_root.find("metadata")
if metadata_node is None:
metadata_node = ET.SubElement(self.live_root, "metadata")
for old in list(metadata_node):
if old.tag == "{urn:virsh-panel:qga-runtime:1}qga-runtime":
metadata_node.remove(old)
metadata_node.append(copy.deepcopy(node))
self.backend.metadata_updates.append((self._uuid, metadata, flags))
if self.backend.stop_during_metadata_set:
self.running = False
self.live_root = None
if self.backend.fail_metadata_after_set:
raise FakeLibvirtError("metadata response lost")
return 0
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))
link = replacement.find("link")
state = link.get("state") if link is not None else None
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 ID(self):
return self.backend.guest_domain_id if self.running else -1
def agentSetResponseTimeout(self, timeout, flags):
assert flags == 0
self.backend.guest_agent_timeout_calls.append((timeout, flags))
if (self.backend.fail_guest_agent_timeout_restore
and timeout == self.backend.guest_agent_default_timeout):
raise FakeLibvirtError("guest agent timeout restore failed")
if (self.backend.fail_guest_agent_timeout
and timeout != self.backend.guest_agent_default_timeout):
raise FakeLibvirtError("guest agent timeout unavailable")
return 0
def interfaceAddresses(self, source, flags):
assert source == self.backend.guest_agent_address_source
assert flags == 0
self.backend.guest_interface_address_calls += 1
if self.backend.fail_guest_interface_addresses:
raise FakeLibvirtError("guest agent interface query failed")
return copy.deepcopy(self.backend.guest_interfaces)
def create(self):
if not self.persistent:
raise FakeLibvirtError("cannot start a stopped transient domain")
if self.backend.domain_create_noop_once:
self.backend.domain_create_noop_once = False
return 0
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.backend.guest_exec_outputs.clear()
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
self.backend.guest_exec_outputs.clear()
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
self.backend.guest_exec_outputs.clear()
if not self.persistent:
self.backend.domains.remove(self)
def reset(self, flags):
self.last_reset_flags = flags
def fsFreeze(self, mountpoints, flags):
assert mountpoints is None and flags == 0
self.backend.freeze_calls += 1
if self.backend.fail_freeze:
raise FakeLibvirtError("guest agent unavailable")
return 1
def fsThaw(self, mountpoints, flags):
assert mountpoints is None and flags == 0
self.backend.thaw_calls += 1
if self.backend.fail_thaw:
raise FakeLibvirtError("guest thaw failed")
return 1
def backupBegin(self, backup_xml, checkpoint_xml, flags):
assert checkpoint_xml is None
assert flags == self.backend.backup_reuse_external_flag
if self.backend.fail_backup_begin:
raise FakeLibvirtError("backup begin failed")
root = ET.fromstring(backup_xml)
self.backend.backup_xmls.append(root)
target_path = root.find("./disks/disk[@name='vda']/target").get("file")
target = next(
volume
for pool in self.backend.pools.values()
for volume in pool.volumes.values()
if volume.path() == target_path
)
source_node = self.root.find(
"./devices/disk[@device='disk']/source")
source_path = source_node.get("file")
source = next(
volume
for pool in self.backend.pools.values()
for volume in pool.volumes.values()
if volume.path() == source_path
)
target.contents = bytearray(source.contents)
self.backup_terminal = self.backend.backup_terminal
if self.backend.fail_backup_begin_after_start:
raise FakeLibvirtError("backup response lost")
return 0
def jobStats(self, flags):
if flags == 0:
return {
"type": self.backend.job_none,
"operation": self.backend.job_operation_backup,
}
assert flags & self.backend.job_stats_completed_flag
result = {
"type": self.backup_terminal or self.backend.job_none,
"operation": self.backend.job_operation_backup,
}
if not flags & self.backend.job_stats_keep_completed_flag:
self.backup_terminal = None
return result
def abortJob(self):
self.backend.abort_calls += 1
self.backup_terminal = self.backend.job_cancelled
return 0
def snapshotNum(self, flags):
return self.snapshots
def hasManagedSaveImage(self, flags):
assert flags == 0
return int(self.managed_save_image)
def listAllCheckpoints(self, flags):
assert flags == 0
return [object() for _ in range(self.checkpoints)]
def undefineFlags(self, flags):
allowed = (1 | 2 | 4 | 8 | 16)
assert flags & ~allowed == 0
assert flags & (4 | 8) in (4, 8)
if self.backend.fail_undefine:
raise FakeLibvirtError("domain undefine failed")
self.backend.undefine_flags.append(flags)
self.managed_save_image = False
self.snapshots = 0
self.checkpoints = 0
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 FakeNWFilter:
def __init__(self, backend, xml):
self.backend = backend
self.xml = xml
self._name = ET.fromstring(xml).get("name")
def name(self):
return self._name
def XMLDesc(self, flags):
assert flags == 0
# Real libvirt assigns a UUID even when the define XML omitted one.
root = ET.fromstring(self.xml)
if root.find("uuid") is None:
root.insert(0, ET.Element("uuid"))
root.find("uuid").text = "11111111-1111-4111-8111-111111111111"
return ET.tostring(root, encoding="unicode")
def undefine(self):
if self.backend.fail_nwfilter_undefine:
raise FakeLibvirtError("nwfilter undefine failed")
del self.backend.nwfilters[self._name]
class FakeConnection:
def __init__(self, backend):
self.backend = backend
def close(self):
self.backend.closed += 1
def listAllDomains(self, flags):
assert flags == 0
return list(self.backend.domains)
def lookupByUUIDString(self, vm_uuid):
for domain in self.backend.domains:
if domain.UUIDString() == vm_uuid:
return domain
raise FakeLibvirtError("domain not found")
def getInfo(self):
return self.backend.node_info
def storagePoolLookupByName(self, name):
try:
return self.backend.pools[name]
except KeyError as exc:
raise FakeLibvirtError("pool not found") from exc
def listAllStoragePools(self, flags):
assert flags == 0
return list(self.backend.pools.values())
def storagePoolDefineXML(self, xml, flags):
assert flags == 0
root = ET.fromstring(xml)
assert root.get("type") == "dir"
name = root.findtext("name")
path = root.findtext("./target/path")
if name in self.backend.pools:
raise FakeLibvirtError("pool name already exists")
pool = FakePool(self.backend, name, path, active=False)
self.backend.pools[name] = pool
self.backend.defined.append((name, path))
return pool
def networkLookupByName(self, name):
assert name == self.backend.network_name
self.backend.network_lookups.append(name)
return types.SimpleNamespace(isActive=lambda: self.backend.network_active)
def nwfilterLookupByName(self, name):
if self.backend.fail_nwfilter_lookup:
raise FakeLibvirtError("nwfilter lookup transport failed")
if name not in self.backend.nwfilters:
raise FakeLibvirtError(
"network filter not found", FakeLibvirtError.NO_NWFILTER)
return self.backend.nwfilters[name]
def nwfilterDefineXML(self, xml):
if self.backend.fail_nwfilter_define:
raise FakeLibvirtError("nwfilter define failed")
root = ET.fromstring(xml)
name = root.get("name")
if not name:
raise FakeLibvirtError("nwfilter name missing")
existing = self.backend.nwfilters.get(name)
if existing is not None:
existing_uuid = ET.fromstring(
existing.XMLDesc(0)).findtext("uuid")
requested_uuid = root.findtext("uuid")
if requested_uuid != existing_uuid:
raise FakeLibvirtError(
f"filter '{name}' already exists with uuid {existing_uuid}")
network_filter = FakeNWFilter(self.backend, xml)
self.backend.nwfilters[name] = network_filter
self.backend.nwfilter_define_xmls.append(copy.deepcopy(root))
return network_filter
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": FakeNWFilter(
self, "<filter name='clean-traffic'/>")
}
self.nwfilter_define_xmls = []
self.fail_nwfilter_define = False
self.fail_nwfilter_lookup = False
self.fail_nwfilter_undefine = False
self.node_info = ("x86_64", 0, 0, 0, 0, 0, 0, 0)
self.bridge_active = True
self.fail_define = False
self.fail_create = False
self.fail_domain_create = False
self.domain_create_noop_once = 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_volume_allocation = False
self.fail_volume_create_after_create = False
self.volume_create_xmls = []
self.fail_clone = False
self.fail_clone_after_create = False
self.fail_upload = False
self.fail_send = False
self.fail_freeze = False
self.fail_thaw = False
self.fail_backup_begin = False
self.fail_backup_begin_after_start = False
self.freeze_calls = 0
self.thaw_calls = 0
self.abort_calls = 0
self.backup_xmls = []
self.backup_reuse_external_flag = 16
self.job_none = 0
self.job_completed = 3
self.job_failed = 4
self.job_cancelled = 5
self.job_stats_completed_flag = 32
self.job_stats_keep_completed_flag = 64
self.job_operation_backup = 7
self.backup_terminal = self.job_completed
self.opened = 0
self.closed = 0
self.guest_domain_id = 7
self.guest_agent_default_timeout = -1
self.guest_agent_address_source = 1
self.guest_agent_timeout_calls = []
self.guest_interface_address_calls = 0
self.guest_interfaces = {}
self.guest_links = []
self.guest_routes = []
self.guest_agent_commands = []
self.guest_exec_outputs = {}
self.guest_exec_pid = 40
self.fail_guest_agent_timeout = False
self.fail_guest_agent_timeout_restore = False
self.fail_guest_interface_addresses = False
self.fail_guest_agent_command = False
self.fail_guest_exec_status = False
self.guest_exec_status_exited = True
self.guest_exec_enabled = True
self.guest_exec_exitcode = 0
self.metadata_updates = []
self.fail_metadata_after_set = False
self.stop_during_metadata_set = False
def open(self, uri):
assert uri == "qemu+ssh://panel@hypervisor/system"
self.opened += 1
return FakeConnection(self)
def qemu_agent_command(self, domain, payload, timeout, flags):
assert isinstance(domain, FakeDomain)
assert isinstance(timeout, int) and 1 <= timeout <= 5
assert flags == 0
if self.fail_guest_agent_command:
raise FakeLibvirtError("guest agent command unavailable")
request = json.loads(payload)
self.guest_agent_commands.append(copy.deepcopy(request))
command = request.get("execute")
if command == "guest-info":
result = {"supported_commands": [
{"name": "guest-exec", "enabled": self.guest_exec_enabled},
{"name": "guest-exec-status",
"enabled": self.guest_exec_enabled},
]}
elif command == "guest-exec":
self.guest_exec_pid += 1
arguments = request.get("arguments", {}).get("arg", [])
if any("/sys/class/net/" in value for value in arguments):
link = self.guest_links[0] if self.guest_links else {}
flags = {
str(value).upper() for value in link.get("flags", [])
}
carrier = (
"1" if ("LOWER_UP" in flags
and "NO-CARRIER" not in flags) else "0")
numeric_flags = 0x1 if "UP" in flags else 0
output = (
f"{link.get('address', '')}\n"
f"{str(link.get('operstate', '')).lower()}\n"
f"{carrier}\n0x{numeric_flags:x}\n"
).encode("ascii")
elif any("/usr/sbin/ip -j -4 route" in value
for value in arguments):
interface_name = arguments[-1]
rows = [copy.deepcopy(route) for route in self.guest_routes
if route.get("dev") == interface_name]
output = json.dumps(
rows, ensure_ascii=True, separators=(",", ":"),
).encode("ascii")[:131073]
else:
output = b""
self.guest_exec_outputs[self.guest_exec_pid] = copy.deepcopy(output)
result = {"pid": self.guest_exec_pid}
elif command == "guest-exec-status":
if self.fail_guest_exec_status:
raise FakeLibvirtError("guest agent status unavailable")
pid = request.get("arguments", {}).get("pid")
if pid not in self.guest_exec_outputs:
return json.dumps({"error": {
"class": "GenericError",
"desc": f"PID {pid} does not exist",
}}, separators=(",", ":"))
output = self.guest_exec_outputs[pid]
result = {
"exited": self.guest_exec_status_exited,
"exitcode": self.guest_exec_exitcode,
"out-data": base64.b64encode(output).decode("ascii"),
}
if self.guest_exec_status_exited:
self.guest_exec_outputs.pop(pid, None)
else:
return json.dumps({"error": {"class": "CommandNotFound"}})
return json.dumps({"return": result}, separators=(",", ":"))
class VMServiceTests(unittest.TestCase):
def setUp(self):
self.backend = FakeBackend()
fake_libvirt = types.ModuleType("libvirt")
fake_libvirt.libvirtError = FakeLibvirtError
fake_libvirt.VIR_ERR_NO_DOMAIN = 42
fake_libvirt.VIR_ERR_NO_NWFILTER = FakeLibvirtError.NO_NWFILTER
fake_libvirt.VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = 1
fake_libvirt.VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = 2
fake_libvirt.VIR_DOMAIN_UNDEFINE_NVRAM = 4
fake_libvirt.VIR_DOMAIN_UNDEFINE_KEEP_NVRAM = 8
fake_libvirt.VIR_DOMAIN_UNDEFINE_CHECKPOINTS_METADATA = 16
fake_libvirt.VIR_DOMAIN_XML_INACTIVE = 1
fake_libvirt.VIR_DOMAIN_METADATA_ELEMENT = 1
fake_libvirt.VIR_DOMAIN_AFFECT_LIVE = 1
fake_libvirt.VIR_DOMAIN_AFFECT_CONFIG = 2
fake_libvirt.VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT = (
self.backend.guest_agent_address_source)
fake_libvirt.VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_DEFAULT = (
self.backend.guest_agent_default_timeout)
fake_libvirt.VIR_IP_ADDR_TYPE_IPV4 = 0
fake_libvirt.VIR_DOMAIN_BACKUP_BEGIN_REUSE_EXTERNAL = (
self.backend.backup_reuse_external_flag)
fake_libvirt.VIR_DOMAIN_JOB_NONE = self.backend.job_none
fake_libvirt.VIR_DOMAIN_JOB_COMPLETED = self.backend.job_completed
fake_libvirt.VIR_DOMAIN_JOB_FAILED = self.backend.job_failed
fake_libvirt.VIR_DOMAIN_JOB_CANCELLED = self.backend.job_cancelled
fake_libvirt.VIR_DOMAIN_JOB_STATS_COMPLETED = (
self.backend.job_stats_completed_flag)
fake_libvirt.VIR_DOMAIN_JOB_STATS_KEEP_COMPLETED = (
self.backend.job_stats_keep_completed_flag)
fake_libvirt.VIR_DOMAIN_JOB_OPERATION_BACKUP = (
self.backend.job_operation_backup)
fake_libvirt.open = self.backend.open
fake_libvirt_qemu = types.ModuleType("libvirt_qemu")
fake_libvirt_qemu.qemuAgentCommand = self.backend.qemu_agent_command
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,
"libvirt_qemu": fake_libvirt_qemu,
}):
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)
self.assertEqual(
root.find("./devices/interface/alias").get("name"), "ua-public0"
)
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")
cloud_root = ET.fromstring(cloud_xml)
self.assertIsNotNone(cloud_root.find("./devices/interface/bandwidth"))
self.assertEqual(
cloud_root.find("./devices/interface/alias").get("name"), "ua-public0"
)
self.assertEqual(cloud_root.find("./os").get("firmware"), "efi")
self.assertEqual(cloud_root.find("./os/type").get("machine"), "q35")
self.assertEqual(
cloud_root.find("./os/firmware/feature[@name='secure-boot']").get("enabled"),
"no",
)
def test_private_seed_role_requires_explicit_separate_source(self):
public = ET.fromstring(
"<interface><alias name='ua-public0'/><mac address='52:54:00:12:34:56'/>"
"<source bridge='br0'/></interface>"
)
private = ET.fromstring(
"<interface><alias name='ua-private0'/><mac address='52:54:00:12:34:57'/>"
"<source bridge='vpc0'/></interface>"
)
network = {"private_ip_cidr": "10.24.3.7/32",
"private_mac": "52:54:00:12:34:57"}
self.assertEqual(
self.service_module.VMService._assert_seed_private_network_matches_interfaces(
[public, private], network, public_bridge="br0", public_network="default",
),
network,
)
indirect = ET.fromstring(
"<interface><alias name='ua-private0'/><mac address='52:54:00:12:34:57'/>"
"<source network='private-net'/></interface>"
)
with self.assertRaises(self.service_module.VMError):
self.service_module.VMService._assert_seed_private_network_matches_interfaces(
[public, indirect], network, public_bridge="br0", public_network="default",
)
def test_bridge_cloud_xml_binds_platform_wrapper_to_public_ip(self):
service = self.cloud_service()
vm_id = "00000000-0000-4000-8000-000000000001"
xml = service._cloud_domain_xml(
self.cloud_spec(), vm_id,
"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"),
self.service_module.firewall_filter_name(vm_id),
)
parameter = filterref.find("parameter")
self.assertIsNotNone(parameter)
self.assertEqual(parameter.get("name"), "IP")
self.assertEqual(parameter.get("value"), "8.8.8.18")
def test_firewall_policy_digest_matches_php_v1_vector(self):
rules = [
{
"protocol": "icmp", "source_cidr": "0.0.0.0/0",
"port_from": None, "port_to": None,
"description": "Ping",
},
{
"protocol": "tcp", "source_cidr": "203.0.113.55/32",
"port_from": 22, "port_to": 22,
"description": "SSH",
},
]
self.assertEqual(
self.service_module.firewall_policy_digest(True, rules),
"46c4d40eef4410edaf998e17981ae91d161348e2fc6572b2bd96c8b5cbf9bfc3",
)
with self.assertRaises(self.service_module.VMError) as raised:
self.service_module.normalize_firewall_rules([{
"protocol": "tcp",
"source_cidr": "203.0.113.55/24",
"port_from": 22,
"port_to": 22,
"description": "would widen unexpectedly",
}])
self.assertEqual(raised.exception.error_code,
"firewall_rule_invalid")
def test_platform_default_policy_compiles_exact_public_port_matrix(self):
vm_id = "00000000-0000-4000-8000-000000000001"
xml, rules, _policy_digest, _filter_digest = (
self.service_module.build_firewall_filter_xml(
vm_id, False, []))
self.assertEqual(rules, [])
root = ET.fromstring(xml)
platform_drops = []
for rule in root.findall("./rule[@action='drop']"):
priority = int(rule.get("priority"))
if priority >= 90:
continue
child = next(iter(rule))
if child.tag == "all-ipv6":
continue
platform_drops.append((
child.tag,
int(child.get("dstportstart")),
int(child.get("dstportend")),
rule.get("direction"),
))
self.assertEqual(child.get("state"), "NONE")
bidirectional = [
("tcp", 17, 17), ("udp", 17, 17),
("tcp", 19, 19), ("udp", 19, 19),
("tcp", 1900, 1900), ("udp", 1900, 1900),
("udp", 11211, 11211), ("udp", 53413, 53413),
("tcp", 137, 139), ("udp", 137, 139),
("tcp", 445, 445), ("udp", 445, 445),
]
expected = {
(*identity, direction)
for identity in bidirectional
for direction in ("in", "out")
}
expected.update({
("tcp", 25, 25, "out"),
("tcp", 1688, 1688, "in"),
})
self.assertEqual(set(platform_drops), expected)
self.assertFalse(any(
protocol == "tcp" and start <= 587 <= end
for protocol, start, end, _direction in platform_drops
))
self.assertFalse(any(
start <= 52413 <= end
for _protocol, start, end, _direction in platform_drops
))
outbound_allow = root.find(
"./rule[@action='accept'][@direction='out'][@priority='90']/all")
self.assertIsNotNone(outbound_allow)
self.assertIsNotNone(root.find(
"./rule[@action='drop'][@direction='inout']"
"[@priority='80']/all-ipv6"))
policy = self.service_module.PLATFORM_DEFAULT_NETWORK_POLICY
categories = {rule.rule_id: rule.category for rule in policy.rules}
self.assertEqual(categories["smtp-25"], "default")
self.assertEqual(categories["qotd"], "permanent")
self.assertIn(
("tcp", 587),
{(item.protocol, item.port)
for item in policy.explicitly_unrestricted},
)
legacy_v2 = ET.fromstring(
self.service_module.build_firewall_filter_xml(
vm_id, False, [], compiler_version=2)[0])
self.assertFalse(any(
rule.get("action") == "drop" for rule in legacy_v2.findall("rule")))
def platform_snapshot(self, *dynamic_rules, revision=1):
baseline = self.service_module.default_platform_policy_snapshot()
document = {
"schema_version": baseline["schema_version"],
"base_policy_version": baseline["base_policy_version"],
"catalog_revision": revision,
"rules": [*baseline["rules"], *dynamic_rules],
}
encoded = json.dumps(
document, ensure_ascii=False, separators=(",", ":"),
).encode("utf-8")
return self.service_module.normalize_platform_policy_snapshot({
**document,
"digest": hashlib.sha256(encoded).hexdigest(),
})
def platform_policy_stripping_define(self, *, persistent=False):
"""Return a defineXML double that removes the platform metadata."""
original_define = FakeConnection.defineXML
stripped = {"done": False}
namespace = self.service_module.PANEL_NS
def define(connection, xml):
root = ET.fromstring(xml)
managed = root.find(
f"./metadata/{{{namespace}}}managed")
node = (managed.find(f"{{{namespace}}}platform-policy")
if managed is not None else None)
if node is not None and (persistent or not stripped["done"]):
managed.remove(node)
stripped["done"] = True
xml = ET.tostring(root, encoding="unicode")
return original_define(connection, xml)
return define
@staticmethod
def test_platform_rule(
rule_id="test-11111111111111111111111111111111",
*, protocols=None, directions=None, port_from=8080, port_to=8080,
):
return {
"id": rule_id,
"label": "Temporary web test",
"category": "test",
"protocols": protocols or ["tcp"],
"port_from": port_from,
"port_to": port_to,
"directions": directions or ["ingress"],
"reason": "Verify future-instance policy snapshots.",
}
def test_platform_test_drop_precedes_conflicting_tenant_allow(self):
vm_id = "00000000-0000-4000-8000-000000000001"
snapshot = self.platform_snapshot(self.test_platform_rule())
tenant_rule = [{
"protocol": "tcp", "source_cidr": "0.0.0.0/0",
"port_from": 8080, "port_to": 8080,
"description": "Tenant tries to allow the test-blocked port",
}]
xml = self.service_module.build_firewall_filter_xml(
vm_id, True, tenant_rule,
platform_policy_snapshot=snapshot,
)[0]
root = ET.fromstring(xml)
platform_drop = next(
rule for rule in root.findall("rule")
if rule.get("action") == "drop"
and (rule.find("tcp") is not None)
and rule.find("tcp").get("dstportstart") == "8080"
)
tenant_allow = next(
rule for rule in root.findall("rule")
if rule.get("action") == "accept"
and (rule.find("tcp") is not None)
and rule.find("tcp").get("dstportstart") == "8080"
)
self.assertEqual(platform_drop.get("direction"), "in")
self.assertLess(
int(platform_drop.get("priority")),
int(tenant_allow.get("priority")),
)
def test_platform_snapshot_digest_matches_php_for_line_terminators(self):
rule = self.test_platform_rule()
rule["label"] = "Line\u2028separator"
rule["reason"] = "Paragraph\u2029separator"
snapshot = self.platform_snapshot(rule, revision=7)
self.assertEqual(
snapshot["digest"],
"ffb4b8b3e09189d55180b280cde172e1dbbd83ef0965d27e2f8210cc6b20bb2f",
)
def test_new_vm_seals_test_snapshot_and_firewall_reuses_it(self):
service = self.cloud_service()
snapshot = self.platform_snapshot(self.test_platform_rule())
created = self.create_cloud_vm(service, self.cloud_spec(
platform_network_policy_snapshot=snapshot,
))
domain = self.backend.domains[0]
for root in (domain.inactive_root, domain.live_root):
node = root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed/"
f"{{{self.service_module.PANEL_NS}}}platform-policy"
)
self.assertIsNotNone(node)
self.assertEqual(node.get("digest"), snapshot["digest"])
self.assertEqual(json.loads(node.text), snapshot)
tenant_rule = [{
"protocol": "tcp", "source_cidr": "0.0.0.0/0",
"port_from": 8080, "port_to": 8080,
"description": "Conflicting tenant allow",
}]
applied = service.apply_firewall_policy(
created["uuid"], enabled=True, rules=tenant_rule)
self.assertEqual(applied["platform_policy_digest"], snapshot["digest"])
evidence = service.reconcile_firewall_policy(
created["uuid"], enabled=True, rules=tenant_rule)
self.assertTrue(evidence["matches"])
self.assertEqual(
evidence["platform_policy_snapshot"], snapshot,
)
def test_new_vm_rejects_stripped_platform_snapshot_metadata(self):
service = self.cloud_service()
snapshots = [
self.service_module.default_platform_policy_snapshot(),
self.platform_snapshot(self.test_platform_rule()),
]
original_define = FakeConnection.defineXML
for snapshot in snapshots:
stripped = {"done": False}
def strip_policy_once(connection, xml):
root = ET.fromstring(xml)
if not stripped["done"]:
managed = root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
node = managed.find(
f"{{{self.service_module.PANEL_NS}}}platform-policy")
managed.remove(node)
stripped["done"] = True
xml = ET.tostring(root, encoding="unicode")
return original_define(connection, xml)
with self.subTest(catalog_revision=snapshot["catalog_revision"]), \
patch.object(FakeConnection, "defineXML", strip_policy_once), \
self.assertRaises(self.service_module.VMError) as raised:
self.create_cloud_vm(service, self.cloud_spec(
platform_network_policy_snapshot=snapshot,
))
self.assertEqual(raised.exception.status, 502)
self.assertEqual(
raised.exception.error_code, "firewall_result_uncertain")
self.assertFalse(self.backend.domains)
self.assertEqual(
set(self.backend.pools["images"].volumes), {TEMPLATE_NAME})
self.assertEqual(set(self.backend.nwfilters), {"clean-traffic"})
self.assertEqual(self.backend.domain_starts, 0)
def test_firewall_rejects_inactive_live_policy_presence_drift(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
managed = domain.live_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
node = managed.find(
f"{{{self.service_module.PANEL_NS}}}platform-policy")
managed.remove(node)
with self.assertRaises(self.service_module.VMError) as raised:
service.get_firewall_policy(created["uuid"])
self.assertEqual(raised.exception.status, 409)
self.assertEqual(
raised.exception.error_code, "firewall_drift_detected")
def test_corrupt_platform_snapshot_metadata_fails_closed(self):
service = self.cloud_service()
snapshot = self.platform_snapshot(self.test_platform_rule())
created = self.create_cloud_vm(service, self.cloud_spec(
platform_network_policy_snapshot=snapshot,
))
domain = self.backend.domains[0]
node = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed/"
f"{{{self.service_module.PANEL_NS}}}platform-policy"
)
node.set("digest", "0" * 64)
with self.assertRaises(self.service_module.VMError) as raised:
service.get_firewall_policy(created["uuid"])
self.assertEqual(raised.exception.status, 409)
self.assertEqual(
raised.exception.error_code, "firewall_drift_detected")
def test_new_cloud_vm_first_boot_uses_verified_platform_wrapper(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
filter_name = self.service_module.firewall_filter_name(created["uuid"])
self.assertIn(filter_name, self.backend.nwfilters)
self.assertEqual(len(self.backend.nwfilter_define_xmls), 1)
defined = self.backend.nwfilter_define_xmls[0]
self.assertEqual(defined.get("name"), filter_name)
self.assertEqual(
defined.find("filterref").get("filter"), "clean-traffic")
domain = self.backend.domains[0]
for root in (domain.inactive_root, domain.live_root):
filterref = root.find("./devices/interface/filterref")
self.assertEqual(filterref.get("filter"), filter_name)
self.assertEqual(filterref.find("parameter").attrib, {
"name": "IP", "value": "8.8.8.18",
})
self.assertTrue(service.reconcile_firewall_policy(
created["uuid"], enabled=False, rules=[])["matches"])
def test_live_firewall_wraps_clean_traffic_and_keeps_ip_parameter(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
rules = [{
"protocol": "tcp", "source_cidr": "203.0.113.55/32",
"port_from": 22, "port_to": 22, "description": "SSH",
}]
result = service.apply_firewall_policy(
created["uuid"], enabled=True, rules=rules)
self.assertTrue(result["enabled"])
self.assertEqual(len(result["policy_digest"]), 64)
self.assertEqual(len(result["filter_digest"]), 64)
filter_root = self.backend.nwfilter_define_xmls[-1]
self.assertEqual(
filter_root.find("filterref").get("filter"), "clean-traffic")
# The final tenant rule broadly denies only IPv4. IPv6 is already
# denied by the always-on platform wrapper, while ARP/RARP remain
# governed by clean-traffic instead of a broad L2 <all/> drop.
drops = [rule for rule in filter_root.findall("rule")
if rule.get("action") == "drop"
and rule.get("priority") == "400"]
self.assertEqual([child.tag for rule in drops for child in rule],
["all"])
self.assertEqual(
[(rule.get("direction"), rule.get("priority")) for rule in drops],
[("in", "400")],
)
established = filter_root.find("./rule[@priority='100']")
self.assertIsNotNone(established.find("all"))
self.assertEqual(
established.find("all").get("state"),
"ESTABLISHED,RELATED",
)
self.assertIsNone(established.find("ip"))
outbound = filter_root.find(
"./rule[@action='accept'][@direction='out'][@priority='90']")
self.assertIsNotNone(outbound)
self.assertEqual(outbound.find("all").attrib, {"state": "NONE"})
ipv4_drop = filter_root.find(
"./rule[@action='drop'][@direction='in']/all")
self.assertIsNotNone(ipv4_drop)
self.assertEqual(ipv4_drop.attrib, {"state": "NONE"})
domain = self.backend.domains[0]
for root in (domain.inactive_root, domain.live_root):
filterref = root.find("./devices/interface/filterref")
self.assertEqual(
filterref.get("filter"),
self.service_module.firewall_filter_name(created["uuid"]),
)
self.assertEqual(filterref.find("parameter").attrib, {
"name": "IP", "value": "8.8.8.18",
})
evidence = service.reconcile_firewall_policy(
created["uuid"], enabled=True, rules=rules)
self.assertTrue(evidence["matches"])
domain.live_root.find(
"./devices/interface/filterref/parameter"
).set("value", "8.8.8.19")
domain.live_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).set("public-ip-cidr", "8.8.8.19/24")
drifted = service.reconcile_firewall_policy(
created["uuid"], enabled=True, rules=rules)
self.assertFalse(drifted["matches"])
self.assertEqual(drifted["sync_state"], "drifted")
def test_disabled_firewall_can_be_enabled_without_uuid_conflict(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
rules = [{
"protocol": "tcp", "source_cidr": "203.0.113.55/32",
"port_from": 22, "port_to": 22, "description": "SSH",
}]
disabled = service.apply_firewall_policy(
created["uuid"], enabled=False, rules=rules)
filter_name = self.service_module.firewall_filter_name(created["uuid"])
assigned_uuid = ET.fromstring(
self.backend.nwfilters[filter_name].XMLDesc(0)).findtext("uuid")
enabled = service.apply_firewall_policy(
created["uuid"], enabled=True, rules=rules)
self.assertFalse(disabled["enabled"])
self.assertTrue(enabled["enabled"])
self.assertEqual(len(self.backend.nwfilter_define_xmls), 3)
self.assertEqual(
self.backend.nwfilter_define_xmls[-1].findtext("uuid"),
assigned_uuid,
)
applied_root = ET.fromstring(
self.backend.nwfilters[filter_name].XMLDesc(0))
self.assertEqual(applied_root.findtext("uuid"), assigned_uuid)
self.assertEqual(
[child.tag for rule in applied_root.findall("rule")
if rule.get("action") == "drop"
and rule.get("priority") == "400" for child in rule],
["all"],
)
evidence = service.reconcile_firewall_policy(
created["uuid"], enabled=True, rules=rules)
self.assertTrue(evidence["matches"])
def test_public_ip_helper_updates_managed_firewall_without_adding_baseline(self):
vm_id = "00000000-0000-4000-8000-000000000001"
interface = ET.fromstring(
"<interface type='bridge'>"
"<source bridge='br0'/><filterref filter='"
+ self.service_module.firewall_filter_name(vm_id)
+ "'><parameter name='IP' value='8.8.8.18'/></filterref>"
"</interface>"
)
self.service_module.VMService._update_public_filter_ip(
interface, "8.8.8.19/24", vm_id)
refs = interface.findall("filterref")
self.assertEqual(len(refs), 1)
self.assertNotEqual(refs[0].get("filter"), "clean-traffic")
self.assertEqual(refs[0].find("parameter").get("value"), "8.8.8.19")
def test_firewall_lookup_transport_error_is_not_treated_as_absent(self):
service = self.cloud_service()
vm_id = "00000000-0000-4000-8000-000000000001"
xml, _rules, _policy_digest, _filter_digest = (
self.service_module.build_firewall_filter_xml(vm_id, True, []))
self.backend.nwfilters[
self.service_module.firewall_filter_name(vm_id)
] = FakeNWFilter(self.backend, xml)
self.backend.fail_nwfilter_lookup = True
with self.assertRaises(self.service_module.VMError) as raised:
service.delete_firewall_filter(vm_id)
self.assertEqual(raised.exception.error_code,
"firewall_result_uncertain")
self.assertIn(
self.service_module.firewall_filter_name(vm_id),
self.backend.nwfilters,
)
def test_firewall_failed_apply_with_unverified_rollback_is_uncertain(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
filter_name = self.service_module.firewall_filter_name(created["uuid"])
# Exercise the legacy clean-traffic transition. New VMs already use
# the managed wrapper, so a failed redundant live filterref update can
# still be proven successful from the shared filter evidence.
for root in (domain.inactive_root, domain.live_root):
root.find("./devices/interface/filterref").set(
"filter", "clean-traffic")
del self.backend.nwfilters[filter_name]
original_update = domain.updateDeviceFlags
calls = 0
def lose_live_then_ignore_config_rollback(xml, flags):
nonlocal calls
calls += 1
if calls == 2:
raise FakeLibvirtError("live update failed")
if calls == 3:
# Simulate a transport/API success that did not restore the
# persistent interface. Exact post-rollback evidence must win.
return None
return original_update(xml, flags)
with patch.object(
domain, "updateDeviceFlags",
side_effect=lose_live_then_ignore_config_rollback):
with self.assertRaises(self.service_module.VMError) as raised:
service.apply_firewall_policy(
created["uuid"], enabled=True, rules=[])
self.assertEqual(raised.exception.status, 503)
self.assertEqual(raised.exception.error_code,
"firewall_result_uncertain")
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_create_stops_before_storage_when_default_filter_fails(self):
service = self.cloud_service()
self.backend.fail_nwfilter_define = True
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.error_code, "firewall_apply_failed")
self.assertEqual(set(self.backend.pools["images"].volumes), image_names)
self.assertEqual(self.backend.clones, [])
self.assertEqual(self.backend.domains, [])
self.assertEqual(set(self.backend.nwfilters), {"clean-traffic"})
def test_cloud_create_reports_incomplete_filter_verification_rollback(self):
service = self.cloud_service()
original_define = FakeConnection.nwfilterDefineXML
def define_corrupt_filter(connection, xml):
network_filter = original_define(connection, xml)
root = ET.fromstring(network_filter.xml)
ET.SubElement(root, "rule", action="accept", direction="out")
network_filter.xml = ET.tostring(root, encoding="unicode")
return network_filter
image_names = set(self.backend.pools["images"].volumes)
with patch.object(
FakeConnection, "nwfilterDefineXML", define_corrupt_filter):
with self.assertRaises(self.error_type) as raised:
self.create_cloud_vm(service, self.cloud_spec())
self.assertEqual(raised.exception.error_code,
"firewall_result_uncertain")
self.assertIn("回滚不完整", str(raised.exception))
self.assertEqual(set(self.backend.pools["images"].volumes), image_names)
self.assertEqual(self.backend.clones, [])
self.assertEqual(self.backend.domains, [])
self.assertEqual(len(self.backend.nwfilters), 2)
def test_cloud_create_accepts_exact_filter_after_lost_define_response(self):
service = self.cloud_service()
original_define = FakeConnection.nwfilterDefineXML
def define_then_lose_response(connection, xml):
original_define(connection, xml)
raise FakeLibvirtError("nwfilter define response lost")
with patch.object(
FakeConnection, "nwfilterDefineXML",
define_then_lose_response):
created = self.create_cloud_vm(service, self.cloud_spec())
filter_name = self.service_module.firewall_filter_name(created["uuid"])
self.assertIn(filter_name, self.backend.nwfilters)
self.assertEqual(len(self.backend.domains), 1)
self.assertEqual(
self.backend.domains[0].root.find(
"./devices/interface/filterref").get("filter"),
filter_name,
)
def test_cloud_network_change_restarts_guest_and_updates_seed_and_filter(self):
service = self.cloud_service()
spec = self.cloud_spec()
created = self.create_cloud_vm(service, spec)
domain = self.backend.domains[0]
old_seed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed").get("seed-volume")
mac = domain.root.find("./devices/interface/mac").get("address")
network = {
"source_public_pool_key": "a" * 32,
"public_pool_key": "a" * 32,
"public_ip_cidr": "8.8.8.19/24",
"gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"],
}
with patch.object(self.service_module, "read_seed_network", return_value={
"public_ip_cidr": "8.8.8.18/24", "gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"],
"mac": mac,
}), patch.object(self.service_module, "replace_seed_network",
return_value=b"NEW-SEED"):
result = service.change_cloud_vm_network(
created["uuid"], network, confirm_restart=True)
self.assertTrue(result["network_changed"])
self.assertEqual(result["public_ip_cidr"], "8.8.8.19/24")
self.assertEqual(result["vm"]["state"], "running")
self.assertEqual(self.backend.shutdown_calls, 1)
managed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
self.assertEqual(managed.get("public-ip-cidr"), "8.8.8.19/24")
self.assertEqual(managed.get("public-pool-key"), "a" * 32)
filterref = domain.root.find("./devices/interface/filterref")
self.assertEqual(
filterref.get("filter"),
self.service_module.firewall_filter_name(created["uuid"]),
)
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_preserves_firewall_and_outbound_allow(self):
service = self.cloud_service()
platform_snapshot = self.platform_snapshot(self.test_platform_rule())
spec = self.cloud_spec(
platform_network_policy_snapshot=platform_snapshot)
created = self.create_cloud_vm(service, spec)
domain = self.backend.domains[0]
rules = [{
"protocol": "tcp", "source_cidr": "203.0.113.55/32",
"port_from": 22, "port_to": 22, "description": "SSH",
}]
service.apply_firewall_policy(
created["uuid"], enabled=True, rules=rules)
filter_name = self.service_module.firewall_filter_name(created["uuid"])
assigned_uuid = ET.fromstring(
self.backend.nwfilters[filter_name].XMLDesc(0)).findtext("uuid")
legacy_xml = self.service_module.build_firewall_filter_xml(
created["uuid"], True, rules, compiler_version=1,
)[0]
legacy_root = ET.fromstring(legacy_xml)
legacy_uuid = ET.Element("uuid")
legacy_uuid.text = assigned_uuid
legacy_root.insert(0, legacy_uuid)
FakeConnection(self.backend).nwfilterDefineXML(
ET.tostring(legacy_root, encoding="unicode"))
self.assertTrue(service.reconcile_firewall_policy(
created["uuid"], enabled=True, rules=rules,
compiler_version=1,
)["matches"])
self.assertFalse(service.reconcile_firewall_policy(
created["uuid"], enabled=True, rules=rules)["matches"])
service.apply_firewall_policy(
created["uuid"], enabled=True, rules=rules)
filter_xml_before = self.backend.nwfilters[filter_name].XMLDesc(0)
filter_definitions_before = len(self.backend.nwfilter_define_xmls)
old_seed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("seed-volume")
mac = domain.root.find("./devices/interface/mac").get("address")
network = {
"source_public_pool_key": "a" * 32,
"public_pool_key": "a" * 32,
"public_ip_cidr": "8.8.8.19/24",
"gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"],
}
with patch.object(self.service_module, "read_seed_network", return_value={
"public_ip_cidr": "8.8.8.18/24", "gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"], "mac": mac,
}), patch.object(
self.service_module, "replace_seed_network",
return_value=b"NEW-SEED",
):
result = service.change_cloud_vm_network(
created["uuid"], network, confirm_restart=True)
self.assertTrue(result["network_changed"])
self.assertEqual(
bytes(self.backend.pools["images"].volumes[old_seed].contents),
b"NEW-SEED",
)
for root in (domain.inactive_root, domain.live_root):
filterref = root.find("./devices/interface/filterref")
self.assertEqual(filterref.get("filter"), filter_name)
self.assertEqual(
filterref.find("parameter").attrib,
{"name": "IP", "value": "8.8.8.19"},
)
policy_node = root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed/"
f"{{{self.service_module.PANEL_NS}}}platform-policy"
)
self.assertEqual(
policy_node.get("digest"), platform_snapshot["digest"])
self.assertEqual(json.loads(policy_node.text), platform_snapshot)
self.assertEqual(
self.backend.nwfilters[filter_name].XMLDesc(0), filter_xml_before)
self.assertEqual(
len(self.backend.nwfilter_define_xmls), filter_definitions_before)
persisted_filter = ET.fromstring(filter_xml_before)
outbound = persisted_filter.find(
"./rule[@action='accept'][@direction='out'][@priority='90']/all")
self.assertIsNotNone(outbound)
self.assertEqual(outbound.attrib, {"state": "NONE"})
evidence = service.reconcile_firewall_policy(
created["uuid"], enabled=True, rules=rules)
self.assertTrue(evidence["matches"])
def test_cloud_network_change_rolls_back_if_policy_metadata_is_stripped(self):
service = self.cloud_service()
platform_snapshot = self.platform_snapshot(self.test_platform_rule())
created = self.create_cloud_vm(service, self.cloud_spec(
platform_network_policy_snapshot=platform_snapshot,
))
domain = self.backend.domains[0]
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
seed_name = managed.get("seed-volume")
original_seed = bytes(
self.backend.pools["images"].volumes[seed_name].contents)
mac = domain.inactive_root.find(
"./devices/interface/mac").get("address")
network = {
"source_public_pool_key": "a" * 32,
"public_pool_key": "a" * 32,
"public_ip_cidr": "8.8.8.19/24",
"gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"],
}
original_define = FakeConnection.defineXML
stripped = {"done": False}
def strip_policy_once(connection, xml):
root = ET.fromstring(xml)
if not stripped["done"]:
updated_managed = root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
node = updated_managed.find(
f"{{{self.service_module.PANEL_NS}}}platform-policy")
updated_managed.remove(node)
stripped["done"] = True
xml = ET.tostring(root, encoding="unicode")
return original_define(connection, xml)
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",
), patch.object(FakeConnection, "defineXML", strip_policy_once), \
self.assertRaises(self.service_module.VMError) as raised:
service.change_cloud_vm_network(
created["uuid"], network, confirm_restart=True)
self.assertEqual(raised.exception.status, 502)
self.assertEqual(
raised.exception.error_code, "firewall_result_uncertain")
restored = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
self.assertEqual(restored.get("public-ip-cidr"), "8.8.8.18/24")
policy_node = restored.find(
f"{{{self.service_module.PANEL_NS}}}platform-policy")
self.assertEqual(policy_node.get("digest"), platform_snapshot["digest"])
self.assertEqual(json.loads(policy_node.text), platform_snapshot)
self.assertEqual(
bytes(self.backend.pools["images"].volumes[seed_name].contents),
original_seed,
)
def test_cloud_network_change_reports_incomplete_persistent_policy_strip(self):
service = self.cloud_service()
platform_snapshot = self.platform_snapshot(self.test_platform_rule())
created = self.create_cloud_vm(service, self.cloud_spec(
platform_network_policy_snapshot=platform_snapshot,
))
domain = self.backend.domains[0]
mac = domain.inactive_root.find(
"./devices/interface/mac").get("address")
network = {
"source_public_pool_key": "a" * 32,
"public_pool_key": "a" * 32,
"public_ip_cidr": "8.8.8.19/24",
"gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"],
}
with patch.object(self.service_module, "read_seed_network", return_value={
"public_ip_cidr": "8.8.8.18/24", "gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"], "mac": mac,
}), patch.object(
self.service_module, "replace_seed_network",
return_value=b"NEW-SEED",
), patch.object(
FakeConnection, "defineXML",
self.platform_policy_stripping_define(persistent=True),
), self.assertRaises(self.service_module.VMError) as raised:
service.change_cloud_vm_network(
created["uuid"], network, confirm_restart=True)
self.assertEqual(raised.exception.status, 502)
self.assertIn("自动回滚不完整", str(raised.exception))
self.assertFalse(domain.isActive())
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
self.assertEqual(managed.get("public-ip-cidr"), "8.8.8.18/24")
self.assertIsNone(managed.find(
f"{{{self.service_module.PANEL_NS}}}platform-policy"))
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_rolls_back_if_platform_metadata_is_stripped(self):
service = self.cloud_service()
platform_snapshot = self.platform_snapshot(self.test_platform_rule())
spec = self.cloud_spec(
platform_network_policy_snapshot=platform_snapshot)
created = self.create_cloud_vm(service, spec)
domain = self.backend.domains[0]
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
seed_name = managed.get("seed-volume")
original_hostname = managed.get("guest-hostname")
original_seed = bytes(
self.backend.pools["images"].volumes[seed_name].contents)
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.inactive_root.find(
"./devices/interface/mac").get("address"),
}), patch.object(
FakeConnection, "defineXML",
self.platform_policy_stripping_define(),
), self.assertRaises(self.service_module.VMError) as raised:
service.change_cloud_vm_settings(
created["uuid"], hostname="node.example",
confirm_restart=True,
)
self.assertEqual(raised.exception.status, 502)
self.assertEqual(
raised.exception.error_code, "firewall_result_uncertain")
self.assertTrue(domain.isActive())
restored = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
self.assertEqual(restored.get("guest-hostname"), original_hostname)
policy_node = restored.find(
f"{{{self.service_module.PANEL_NS}}}platform-policy")
self.assertEqual(json.loads(policy_node.text), platform_snapshot)
self.assertEqual(
bytes(self.backend.pools["images"].volumes[seed_name].contents),
original_seed,
)
def test_cloud_settings_change_requires_restart_confirmation(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
before = ET.tostring(domain.root)
with patch.object(self.service_module, "replace_seed_settings",
side_effect=AssertionError("must validate confirmation first")), \
self.assertRaises(self.error_type) as raised:
service.change_cloud_vm_settings(
created["uuid"], hostname="node.example", confirm_restart=False,
)
self.assertEqual(raised.exception.status, 422)
self.assertEqual(ET.tostring(domain.root), before)
self.assertEqual(self.backend.shutdown_calls, 0)
def test_cloud_network_change_rejects_gateway_or_dns_drift(self):
service = self.cloud_service()
spec = self.cloud_spec()
created = self.create_cloud_vm(service, spec)
domain = self.backend.domains[0]
mac = domain.root.find("./devices/interface/mac").get("address")
before = ET.tostring(domain.root)
network = {
"source_public_pool_key": "a" * 32,
"public_pool_key": "a" * 32,
"public_ip_cidr": "8.8.8.19/24",
"gateway": "8.8.8.2",
"dns_servers": ["9.9.9.9"],
}
with patch.object(self.service_module, "read_seed_network", return_value={
"public_ip_cidr": "8.8.8.18/24", "gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"],
"mac": mac,
}), patch.object(self.service_module, "replace_seed_network",
side_effect=AssertionError("seed must not be rewritten")):
with self.assertRaises(self.error_type) as raised:
service.change_cloud_vm_network(
created["uuid"], network, confirm_restart=True)
self.assertEqual(raised.exception.status, 409)
self.assertIn("网关或 DNS", str(raised.exception))
self.assertEqual(ET.tostring(domain.root), before)
self.assertEqual(self.backend.shutdown_calls, 0)
def test_cloud_network_change_allows_same_selector_cross_pool_tuple(self):
service = self.cloud_service()
spec = self.cloud_spec()
created = self.create_cloud_vm(service, spec)
domain = self.backend.domains[0]
mac = domain.root.find("./devices/interface/mac").get("address")
network = {
"source_public_pool_key": "a" * 32,
"public_pool_key": "b" * 32,
"public_ip_cidr": "9.9.9.3/29",
"gateway": "9.9.9.1",
"dns_servers": ["9.9.9.9"],
}
with patch.object(self.service_module, "read_seed_network", return_value={
"public_ip_cidr": "8.8.8.18/24", "gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"],
"mac": mac,
}), patch.object(self.service_module, "replace_seed_network",
return_value=b"CROSS-POOL-SEED"):
result = service.change_cloud_vm_network(
created["uuid"], network, confirm_restart=True)
self.assertTrue(result["network_changed"])
self.assertEqual(result["public_pool_key"], "b" * 32)
self.assertEqual(result["public_ip_cidr"], "9.9.9.3/29")
managed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
self.assertEqual(managed.get("public-pool-key"), "b" * 32)
self.assertEqual(managed.get("public-ip-cidr"), "9.9.9.3/29")
def test_user_iso_isolated_directory_import_create_and_delete(self):
service = self.service.__class__(
self.service.uri, "images", "/home/iso", "default")
service.ensure_storage_pools()
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "installer.iso"
image.write_bytes(bootable_iso_bytes())
imported = service.import_user_iso(image, 41, USER_ISO_NAME)
self.assertEqual(imported["volume_name"], USER_ISO_NAME)
child = next(pool for pool in self.backend.pools.values()
if pool.path == "/home/iso/41")
self.assertIn("/home/iso/41", self.backend.built)
self.assertEqual(child.volumes[USER_ISO_NAME].path(),
f"/home/iso/41/{USER_ISO_NAME}")
spec = self.spec(name="user-installer")
spec.pop("iso")
created = service.create_user_iso_vm(
spec, 41, USER_ISO_NAME, USER_ISO_ID, "My Installer")
self.assertEqual(created["os_source"], "iso")
live = self.backend.domains[0].live_root
source = live.find("./devices/disk[@device='cdrom']/source")
self.assertEqual(source.get("file"), f"/home/iso/41/{USER_ISO_NAME}")
managed = live.find(f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
self.assertEqual(managed.get("install-iso-id"), USER_ISO_ID)
self.assertEqual(managed.get("install-iso"), "My Installer")
with self.assertRaises(self.error_type) as in_use:
service.delete_user_iso(41, USER_ISO_NAME)
self.assertEqual(in_use.exception.status, 409)
self.backend.domains[0].guest_reboot()
self.assertTrue(service.delete_user_iso(41, USER_ISO_NAME)["deleted"])
with self.assertRaises(self.error_type) as missing:
service.delete_user_iso(41, USER_ISO_NAME)
self.assertEqual(missing.exception.status, 404)
self.assertEqual(
missing.exception.error_code, "user_iso_volume_not_found")
def test_user_iso_cache_replaces_same_size_volume_without_ready_marker(self):
service = self.service.__class__(
self.service.uri, "images", "/home/iso", "default")
service.ensure_storage_pools()
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "installer.iso"
content = bootable_iso_bytes()
image.write_bytes(content)
first = service.cache_user_iso(
image, 41, USER_ISO_NAME, {USER_ISO_NAME},
trusted_existing=False)
child = next(pool for pool in self.backend.pools.values()
if pool.path == "/home/iso/41")
original = child.volumes[USER_ISO_NAME]
original.contents[:] = b"z" * len(content)
trusted = service.cache_user_iso(
image, 41, USER_ISO_NAME, {USER_ISO_NAME},
trusted_existing=True)
self.assertTrue(trusted["already_cached"])
self.assertIs(child.volumes[USER_ISO_NAME], original)
replaced = service.cache_user_iso(
image, 41, USER_ISO_NAME, {USER_ISO_NAME},
trusted_existing=False)
self.assertFalse(first["already_cached"])
self.assertFalse(replaced["already_cached"])
self.assertIsNot(child.volumes[USER_ISO_NAME], original)
self.assertEqual(bytes(child.volumes[USER_ISO_NAME].contents), content)
self.assertIn(USER_ISO_NAME, self.backend.deleted_volumes)
def test_user_iso_cannot_cross_owner_or_use_non_directory_root(self):
service = self.service.__class__(
self.service.uri, "images", "/home/iso", "default")
service.ensure_storage_pools()
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "installer.iso"
image.write_bytes(bootable_iso_bytes())
service.import_user_iso(image, 41, USER_ISO_NAME)
with self.assertRaises(self.error_type) as missing:
service.delete_user_iso(42, USER_ISO_NAME)
self.assertEqual(missing.exception.status, 404)
self.assertEqual(
missing.exception.error_code, "user_iso_volume_not_found")
self.assertIn(USER_ISO_NAME, next(
pool for pool in self.backend.pools.values()
if pool.path == "/home/iso/41").volumes)
missing_root = self.service.__class__(
self.service.uri, "images", "missing-iso-pool", "default")
with self.assertRaises(self.error_type) as root_missing:
missing_root.delete_user_iso(41, USER_ISO_NAME)
self.assertEqual(root_missing.exception.status, 404)
self.assertEqual(root_missing.exception.error_code, "")
self.backend.pools["iso"].pool_type = "fs"
non_directory = self.service.__class__(
self.service.uri, "images", "iso", "default")
with self.assertRaises(self.error_type) as invalid:
non_directory.create_user_iso_vm(
{key: value for key, value in self.spec().items() if key != "iso"},
41, USER_ISO_NAME, USER_ISO_ID, "Installer")
self.assertEqual(invalid.exception.status, 409)
def test_user_iso_cache_storage_preflight_requires_directory_pool(self):
service = self.service.__class__(
self.service.uri, "images", "/home/iso", "default")
service.ensure_storage_pools()
checked = service.check_user_iso_storage(41)
self.assertGreaterEqual(checked["available_bytes"], 1024 * 1024)
self.assertIn("/home/iso/41", self.backend.built)
self.backend.pools["iso"].pool_type = "fs"
non_directory = self.service.__class__(
self.service.uri, "images", "iso", "default")
with self.assertRaises(self.error_type) as invalid:
non_directory.check_user_iso_storage(42)
self.assertEqual(invalid.exception.status, 409)
def test_invalid_package_bandwidth_is_rejected(self):
for value in (0, -1, 100001, True, "100"):
with self.subTest(value=value), self.assertRaises(self.error_type):
self.service._validate_create(self.spec(bandwidth_mbps=value))
def test_only_debian_12_seed_uses_cloud_init_network_fix(self):
for template_name in (
DEBIAN_12_TEMPLATE_NAME,
DEBIAN_12_TEMPLATE_REPLICA,
):
with self.subTest(template_name=template_name):
self.assertTrue(
self.service._cloud_seed_needs_debian12_network_fix(template_name)
)
for template_name in (
TEMPLATE_NAME,
DEBIAN_13_TEMPLATE_NAME,
"panel-template-debian12-not-a-valid-volume.qcow2",
):
with self.subTest(template_name=template_name):
self.assertFalse(
self.service._cloud_seed_needs_debian12_network_fix(template_name)
)
@staticmethod
def cloud_spec(**changes):
# Public examples are used only as parser fixtures; these addresses
# must never be assumed to belong to a real panel deployment.
data = {
"source": "cloud",
"name": "cloud-vm",
"vcpu": 4,
"memory_mib": 4096,
"disk_gib": 20,
"network": "bridge:br0",
"public_pool_key": "a" * 32,
"public_ip_cidr": "8.8.8.18/24",
"gateway": "8.8.8.1",
"dns_servers": ["1.1.1.1", "8.8.8.8"],
"guest_ssh_public_key": "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIF7mFh4aYz3lRzNqjoFQasAQLpm7BdSULhe1iWuvj3y5 panel-test",
}
data.update(changes)
return data
def cloud_service(self):
self.backend.pools["images"].volumes[TEMPLATE_NAME] = FakeVolume(
self.backend.pools["images"], TEMPLATE_NAME,
capacity=2 * 1024**3,
)
return self.service.__class__(
self.service.uri, "images", "iso", "bridge:br0",
rescue_iso_pool="/home/rescue",
)
def create_cloud_vm(self, service, spec):
# Exercise the remote libvirt orchestration without requiring the
# optional ISO writer on test hosts. test_cloud_init.py checks the
# real generated ISO separately when pycdlib is available.
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED", create=True):
return service.create_cloud_vm(spec, TEMPLATE_NAME)
def test_cloud_create_supplies_catalog_script_only_to_seed(self):
service = self.cloud_service()
script = "echo first-boot\r\n"
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED") as builder:
created = service.create_cloud_vm(self.cloud_spec(startup_script=script), TEMPLATE_NAME)
self.assertEqual(builder.call_args.kwargs["startup_script"], "echo first-boot\n")
self.assertNotIn("startup_script", created)
self.assertNotIn(script, ET.tostring(self.backend.domains[0].root, encoding="unicode"))
def test_cloud_create_rejects_invalid_script_before_remote_connection(self):
service = self.cloud_service()
with patch.object(service, "_connect") as connect:
with self.assertRaises(self.service_module.VMError) as caught:
service.create_cloud_vm(self.cloud_spec(startup_script="bad\x00script"), TEMPLATE_NAME)
self.assertEqual(caught.exception.status, 422)
connect.assert_not_called()
def test_live_snapshot_filesystem_freezes_and_creates_independent_qcow2(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
managed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
source = self.backend.pools["images"].volumes[
managed.get("disk-volume")]
source.contents = bytearray(b"guest-system-disk")
result = service.create_live_snapshot(
created["uuid"], "a" * 32, consistency="filesystem")
snapshot = self.backend.pools["images"].volumes[result["volume_name"]]
self.assertTrue(result["created"])
self.assertEqual(result["consistency"], "filesystem")
self.assertEqual(bytes(snapshot.contents), b"guest-system-disk")
self.assertEqual(snapshot.capacity, source.capacity)
target_xml = next(
root for root in reversed(self.backend.volume_create_xmls)
if root.findtext("name") == result["volume_name"])
self.assertEqual(
int(target_xml.findtext("allocation")), source.capacity)
self.assertEqual(self.backend.freeze_calls, 1)
self.assertEqual(self.backend.thaw_calls, 1)
# The panel's online snapshot is an external backup volume; it does
# not create libvirt native snapshot metadata.
self.assertEqual(domain.snapshots, 0)
backup = self.backend.backup_xmls[0]
self.assertEqual(backup.get("mode"), "push")
self.assertEqual(
backup.find("./disks/disk[@name='vda']/target").get("file"),
snapshot.path(),
)
self.assertEqual(domain.backup_terminal, self.backend.job_completed)
service.release_live_snapshot_completed_evidence(created["uuid"])
self.assertIsNone(domain.backup_terminal)
def test_validate_snapshot_volume_skips_job_stats_for_stopped_vm(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
snapshot = service.create_live_snapshot(
created["uuid"], "e" * 32, consistency="crash")
service.action(created["uuid"], "shutdown")
domain = self.backend.domains[0]
def stopped_job_stats(_flags):
raise FakeLibvirtError(
"Requested operation is not valid: domain is not running")
domain.jobStats = stopped_job_stats
validated = service.validate_snapshot_volume(
created["uuid"], "e" * 32, snapshot["volume_name"])
self.assertEqual(validated, {
"snapshot_key": "e" * 32,
"deletable": True,
"already_absent": False,
})
def test_live_snapshot_release_evidence_skips_stopped_vm(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
service.create_live_snapshot(
created["uuid"], "f" * 32, consistency="crash")
service.action(created["uuid"], "shutdown")
domain = self.backend.domains[0]
calls = []
def stopped_job_stats(flags):
calls.append(flags)
raise FakeLibvirtError(
"Requested operation is not valid: domain is not running")
domain.jobStats = stopped_job_stats
service.release_live_snapshot_completed_evidence(created["uuid"])
self.assertEqual(calls, [])
self.assertEqual(domain.backup_terminal, self.backend.job_completed)
def test_live_snapshot_reconcile_stopped_vm_uses_durable_marker(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
snapshot = service.create_live_snapshot(
created["uuid"], "0" * 32, consistency="crash")
service.action(created["uuid"], "shutdown")
domain = self.backend.domains[0]
calls = []
def stopped_job_stats(flags):
calls.append(flags)
raise FakeLibvirtError(
"Requested operation is not valid: domain is not running")
domain.jobStats = stopped_job_stats
result = service.reconcile_live_snapshot_create(
created["uuid"], "0" * 32, snapshot["volume_name"],
verified_capacity=snapshot["size_bytes"],
verified_identity=snapshot["volume_identity"],
)
self.assertEqual(result["outcome"], "succeeded")
self.assertEqual(result["power_state"], "stopped")
self.assertEqual(calls, [])
def test_live_snapshot_reconcile_stopped_vm_without_marker_stays_uncertain(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
snapshot = service.create_live_snapshot(
created["uuid"], "1" * 32, consistency="crash")
service.action(created["uuid"], "shutdown")
domain = self.backend.domains[0]
calls = []
def stopped_job_stats(flags):
calls.append(flags)
raise FakeLibvirtError(
"Requested operation is not valid: domain is not running")
domain.jobStats = stopped_job_stats
with self.assertRaises(self.service_module.VMSnapshotUncertainError):
service.reconcile_live_snapshot_create(
created["uuid"], "1" * 32, snapshot["volume_name"])
self.assertEqual(calls, [])
def test_live_snapshot_allocation_failure_never_starts_backup(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
snapshot_key = "9" * 32
expected = self.service_module.snapshot_volume_name(
created["uuid"], snapshot_key)
self.backend.fail_volume_allocation = True
with self.assertRaises(self.error_type):
service.create_live_snapshot(
created["uuid"], snapshot_key, consistency="crash")
target_xml = next(
root for root in reversed(self.backend.volume_create_xmls)
if root.findtext("name") == expected)
source_name = self.backend.domains[0].root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("disk-volume")
source_capacity = self.backend.pools["images"].volumes[
source_name].capacity
self.assertEqual(
int(target_xml.findtext("allocation")), source_capacity)
self.assertNotIn(expected, self.backend.pools["images"].volumes)
self.assertEqual(self.backend.backup_xmls, [])
self.assertEqual(self.backend.freeze_calls, 0)
def test_live_snapshot_freeze_failure_thaws_and_returns_stable_code(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
self.backend.fail_freeze = True
with self.assertRaises(self.error_type) as raised:
service.create_live_snapshot(
created["uuid"], "b" * 32, consistency="filesystem")
self.assertEqual(
raised.exception.error_code,
"snapshot_guest_agent_unavailable",
)
self.assertEqual(self.backend.freeze_calls, 1)
self.assertEqual(self.backend.thaw_calls, 1)
expected = self.service_module.snapshot_volume_name(
created["uuid"], "b" * 32)
self.assertNotIn(expected, self.backend.pools["images"].volumes)
def test_live_snapshot_partial_freeze_with_unconfirmed_thaw_is_uncertain(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
self.backend.fail_freeze = True
self.backend.fail_thaw = True
with self.assertRaises(
self.service_module.VMSnapshotUncertainError) as raised:
service.create_live_snapshot(
created["uuid"], "c" * 32, consistency="filesystem")
self.assertEqual(raised.exception.error_code, "snapshot_result_uncertain")
self.assertGreaterEqual(self.backend.thaw_calls, 1)
def test_live_snapshot_lost_start_response_reconciles_completed_backup(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
self.backend.fail_backup_begin_after_start = True
result = service.create_live_snapshot(
created["uuid"], "d" * 32, consistency="crash")
self.assertTrue(result["created"])
self.assertEqual(result["consistency"], "crash")
self.assertIn(result["volume_name"], self.backend.pools["images"].volumes)
self.assertEqual(self.backend.freeze_calls, 0)
self.assertEqual(self.backend.thaw_calls, 0)
def test_live_snapshot_clears_previous_completed_evidence_before_next_start(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
first = service.create_live_snapshot(
created["uuid"], "a" * 32, consistency="crash")
self.assertIn(first["volume_name"], self.backend.pools["images"].volumes)
self.assertEqual(
self.backend.domains[0].backup_terminal,
self.backend.job_completed,
)
self.backend.fail_backup_begin = True
second_key = "b" * 32
second_name = self.service_module.snapshot_volume_name(
created["uuid"], second_key)
with self.assertRaises(self.error_type):
service.create_live_snapshot(
created["uuid"], second_key, consistency="crash")
self.assertNotIn(second_name, self.backend.pools["images"].volumes)
self.assertIn(first["volume_name"], self.backend.pools["images"].volumes)
def test_live_snapshot_lost_volume_create_response_cleans_deterministic_target(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
snapshot_key = "0" * 32
expected = self.service_module.snapshot_volume_name(
created["uuid"], snapshot_key)
self.backend.fail_volume_create_after_create = True
with self.assertRaises(self.error_type):
service.create_live_snapshot(
created["uuid"], snapshot_key, consistency="crash")
self.assertNotIn(expected, self.backend.pools["images"].volumes)
self.assertEqual(self.backend.backup_xmls, [])
def test_live_snapshot_wait_timeout_aborts_and_requires_terminal_state(self):
module = self.service_module
class SlowBackup:
def __init__(self, settles):
self.settles = settles
self.aborted = False
def jobStats(self, flags):
if flags == 0:
if self.aborted and self.settles:
return {"type": self_backend.job_none}
return {
"type": 1,
"operation": self_backend.job_operation_backup,
}
self_outer.assertTrue(
flags & self_backend.job_stats_completed_flag)
return {
"type": self_backend.job_cancelled,
"operation": self_backend.job_operation_backup,
}
def abortJob(self):
self.aborted = True
return 0
self_backend = self.backend
self_outer = self
settled = SlowBackup(True)
with (patch.object(module.time, "monotonic", side_effect=[0.0, 1.0]),
patch.object(module.time, "sleep", return_value=None)):
status = module.VMService._wait_for_snapshot_backup(
settled, timeout=1.0, abort_timeout=1.0)
self.assertEqual(status, "cancelled")
self.assertTrue(settled.aborted)
stuck = SlowBackup(False)
with (patch.object(
module.time, "monotonic", side_effect=[0.0, 1.0, 2.0]),
patch.object(module.time, "sleep", return_value=None)):
with self.assertRaises(module.VMSnapshotUncertainError):
module.VMService._wait_for_snapshot_backup(
stuck, timeout=1.0, abort_timeout=1.0)
self.assertTrue(stuck.aborted)
def test_snapshot_job_stats_matches_libvirt_python_dict_contract(self):
class Domain:
@staticmethod
def jobStats(flags):
return {"type": 3, "operation": 9, "data_total": 1024}
job_type, stats = self.service_module.VMService._snapshot_job_type(
Domain(), 0)
self.assertEqual(job_type, 3)
self.assertEqual(stats["data_total"], 1024)
Domain.jobStats = staticmethod(lambda _flags: (3, {"operation": 9}))
with self.assertRaises(self.service_module.VMSnapshotUncertainError):
self.service_module.VMService._snapshot_job_type(Domain(), 0)
def test_live_snapshot_restore_switches_disk_and_preserves_restore_point(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
managed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
old_name = managed.get("disk-volume")
old_volume = self.backend.pools["images"].volumes[old_name]
old_volume.contents = bytearray(b"snapshot-state")
snapshot = service.create_live_snapshot(
created["uuid"], "e" * 32, consistency="crash")
old_volume.contents = bytearray(b"newer-state")
result = service.restore_live_snapshot(
created["uuid"], "e" * 32, snapshot["volume_name"],
"restore-operation-0001")
restored_managed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
restored_name = restored_managed.get("disk-volume")
self.assertTrue(result["restored"])
self.assertEqual(result["power_state"], "running")
self.assertNotEqual(restored_name, old_name)
replacement_xml = next(
root for root in reversed(self.backend.volume_create_xmls)
if root.findtext("name") == restored_name)
self.assertEqual(
int(replacement_xml.findtext("allocation")), snapshot["size_bytes"])
self.assertEqual(
bytes(self.backend.pools["images"].volumes[restored_name].contents),
b"snapshot-state",
)
self.assertNotIn(old_name, self.backend.pools["images"].volumes)
self.assertIn(snapshot["volume_name"], self.backend.pools["images"].volumes)
self.assertTrue(domain.isActive())
def test_live_snapshot_restore_rolls_back_stripped_platform_metadata(self):
service = self.cloud_service()
platform_snapshot = self.platform_snapshot(self.test_platform_rule())
created = self.create_cloud_vm(service, self.cloud_spec(
platform_network_policy_snapshot=platform_snapshot,
))
domain = self.backend.domains[0]
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
old_name = managed.get("disk-volume")
snapshot_key = "4" * 32
snapshot = service.create_live_snapshot(
created["uuid"], snapshot_key, consistency="crash")
operation_id = "restore-policy-strip-once"
replacement_name = self.service_module.snapshot_restore_volume_name(
created["uuid"], operation_id)
with patch.object(
FakeConnection, "defineXML",
self.platform_policy_stripping_define()), \
self.assertRaises(self.service_module.VMError) as raised:
service.restore_live_snapshot(
created["uuid"], snapshot_key, snapshot["volume_name"],
operation_id,
)
self.assertEqual(raised.exception.status, 502)
self.assertEqual(
raised.exception.error_code, "firewall_result_uncertain")
self.assertTrue(domain.isActive())
restored = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
self.assertEqual(restored.get("disk-volume"), old_name)
policy_node = restored.find(
f"{{{self.service_module.PANEL_NS}}}platform-policy")
self.assertEqual(json.loads(policy_node.text), platform_snapshot)
self.assertIn(old_name, self.backend.pools["images"].volumes)
self.assertNotIn(replacement_name, self.backend.pools["images"].volumes)
def test_live_snapshot_restore_retains_disks_if_rollback_strips_policy(self):
service = self.cloud_service()
platform_snapshot = self.platform_snapshot(self.test_platform_rule())
created = self.create_cloud_vm(service, self.cloud_spec(
platform_network_policy_snapshot=platform_snapshot,
))
domain = self.backend.domains[0]
old_name = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("disk-volume")
snapshot_key = "5" * 32
snapshot = service.create_live_snapshot(
created["uuid"], snapshot_key, consistency="crash")
operation_id = "restore-policy-strip-persistent"
replacement_name = self.service_module.snapshot_restore_volume_name(
created["uuid"], operation_id)
with patch.object(
FakeConnection, "defineXML",
self.platform_policy_stripping_define(persistent=True)), \
self.assertRaises(
self.service_module.VMSnapshotUncertainError) as raised:
service.restore_live_snapshot(
created["uuid"], snapshot_key, snapshot["volume_name"],
operation_id,
)
self.assertEqual(raised.exception.status, 503)
self.assertIn("自动回退不完整", str(raised.exception))
self.assertFalse(domain.isActive())
self.assertIn(old_name, self.backend.pools["images"].volumes)
self.assertIn(replacement_name, self.backend.pools["images"].volumes)
self.assertIn(
snapshot["volume_name"], self.backend.pools["images"].volumes)
def test_live_snapshot_restore_allocation_failure_keeps_original_disk(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
old_name = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("disk-volume")
snapshot_key = "7" * 32
snapshot = service.create_live_snapshot(
created["uuid"], snapshot_key, consistency="crash")
operation_id = "restore-allocation-failure"
replacement_name = self.service_module.snapshot_restore_volume_name(
created["uuid"], operation_id)
self.backend.fail_volume_allocation = True
with self.assertRaises(self.error_type):
service.restore_live_snapshot(
created["uuid"], snapshot_key, snapshot["volume_name"],
operation_id)
replacement_xml = next(
root for root in reversed(self.backend.volume_create_xmls)
if root.findtext("name") == replacement_name)
self.assertEqual(
int(replacement_xml.findtext("allocation")), snapshot["size_bytes"])
self.assertNotIn(
replacement_name, self.backend.pools["images"].volumes)
self.assertEqual(
domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("disk-volume"),
old_name,
)
self.assertTrue(domain.isActive())
def test_live_snapshot_restore_requires_confirmed_replacement_start(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
old_name = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("disk-volume")
snapshot_key = "8" * 32
snapshot = service.create_live_snapshot(
created["uuid"], snapshot_key, consistency="crash")
self.backend.domain_create_noop_once = True
with self.assertRaises(self.error_type):
service.restore_live_snapshot(
created["uuid"], snapshot_key, snapshot["volume_name"],
"restore-operation-noop-start")
self.assertTrue(domain.isActive())
self.assertEqual(
domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("disk-volume"),
old_name,
)
self.assertIn(old_name, self.backend.pools["images"].volumes)
def test_live_snapshot_restore_lost_clone_response_keeps_evidence(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
original_managed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
original_name = original_managed.get("disk-volume")
snapshot = service.create_live_snapshot(
created["uuid"], "f" * 32, consistency="crash")
self.backend.fail_clone_after_create = True
operation_id = "restore-operation-0002"
with self.assertRaises(self.service_module.VMSnapshotUncertainError):
service.restore_live_snapshot(
created["uuid"], "f" * 32, snapshot["volume_name"],
operation_id)
replacement = self.service_module.snapshot_restore_volume_name(
created["uuid"], operation_id)
self.assertIn(replacement, self.backend.pools["images"].volumes)
self.assertEqual(
domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("disk-volume"),
original_name,
)
self.assertTrue(domain.isActive())
def test_live_snapshot_reconcile_create_delete_and_active_job_order(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
snapshot_key = "1" * 32
snapshot = service.create_live_snapshot(
created["uuid"], snapshot_key, consistency="crash")
confirmed = service.reconcile_live_snapshot_create(
created["uuid"], snapshot_key, snapshot["volume_name"],
verified_capacity=snapshot["size_bytes"],
verified_identity=snapshot["volume_identity"],
)
self.assertEqual(confirmed["outcome"], "succeeded")
with self.assertRaises(self.service_module.VMSnapshotUncertainError):
service.reconcile_live_snapshot_create(
created["uuid"], snapshot_key, snapshot["volume_name"],
verified_capacity=snapshot["size_bytes"],
)
domain = self.backend.domains[0]
original_job_stats = domain.jobStats
domain.jobStats = lambda flags: (
{"type": self.backend.job_none} if flags == 0
else {"type": self.backend.job_completed, "operation": 999}
)
with self.assertRaises(self.service_module.VMSnapshotUncertainError):
service.reconcile_live_snapshot_create(
created["uuid"], snapshot_key, snapshot["volume_name"])
domain.jobStats = lambda flags: (
{"type": 1, "operation": self.backend.job_operation_backup}
if flags == 0 else original_job_stats(flags)
)
self.backend.pools["images"].volumes.pop(snapshot["volume_name"])
with self.assertRaises(self.service_module.VMSnapshotUncertainError):
service.reconcile_live_snapshot_create(
created["uuid"], snapshot_key, snapshot["volume_name"])
domain.jobStats = original_job_stats
absent = service.reconcile_live_snapshot_delete(
created["uuid"], snapshot_key, snapshot["volume_name"])
self.assertEqual(absent["outcome"], "succeeded")
def test_live_snapshot_reconcile_restore_finishes_old_disk_cleanup_and_power(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
snapshot_key = "2" * 32
snapshot = service.create_live_snapshot(
created["uuid"], snapshot_key, consistency="crash")
operation_id = "restore-operation-cleanup"
plan = service.snapshot_restore_plan(created["uuid"], operation_id)
old_name = plan["old_volume_name"]
self.backend.fail_volume_delete = True
with self.assertRaises(self.service_module.VMSnapshotUncertainError):
service.restore_live_snapshot(
created["uuid"], snapshot_key, snapshot["volume_name"],
operation_id, expected_old_volume=old_name)
replacement_name = self.service_module.snapshot_restore_volume_name(
created["uuid"], operation_id)
self.assertIn(old_name, self.backend.pools["images"].volumes)
self.assertEqual(
domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("disk-volume"),
replacement_name,
)
domain.shutdown()
self.backend.fail_volume_delete = False
reconciled = service.reconcile_live_snapshot_restore(
created["uuid"], snapshot_key, snapshot["volume_name"],
operation_id, old_name, plan["was_running"])
self.assertEqual(reconciled["outcome"], "succeeded")
self.assertTrue(domain.isActive())
self.assertNotIn(old_name, self.backend.pools["images"].volumes)
self.assertIn(snapshot["volume_name"], self.backend.pools["images"].volumes)
def test_live_snapshot_reconcile_failed_restore_cleans_only_temporary_disk(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
snapshot_key = "3" * 32
snapshot = service.create_live_snapshot(
created["uuid"], snapshot_key, consistency="crash")
operation_id = "restore-operation-temp-cleanup"
plan = service.snapshot_restore_plan(created["uuid"], operation_id)
self.backend.fail_clone_after_create = True
with self.assertRaises(self.service_module.VMSnapshotUncertainError):
service.restore_live_snapshot(
created["uuid"], snapshot_key, snapshot["volume_name"],
operation_id, expected_old_volume=plan["old_volume_name"])
replacement_name = plan["replacement_volume_name"]
self.assertIn(replacement_name, self.backend.pools["images"].volumes)
snapshot_volume = self.backend.pools["images"].volumes.pop(
snapshot["volume_name"])
with self.assertRaises(self.service_module.VMSnapshotUncertainError):
service.reconcile_live_snapshot_restore(
created["uuid"], snapshot_key, snapshot["volume_name"],
operation_id, plan["old_volume_name"], plan["was_running"])
self.assertIn(replacement_name, self.backend.pools["images"].volumes)
self.backend.pools["images"].volumes[
snapshot["volume_name"]] = snapshot_volume
reconciled = service.reconcile_live_snapshot_restore(
created["uuid"], snapshot_key, snapshot["volume_name"],
operation_id, plan["old_volume_name"], plan["was_running"])
self.assertEqual(reconciled["outcome"], "failed")
self.assertNotIn(replacement_name, self.backend.pools["images"].volumes)
self.assertIn(snapshot["volume_name"], self.backend.pools["images"].volumes)
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 cloud_vm_with_private_artifacts(self, *, include_private_nic):
from virsh_panel.cloud_init import replace_seed_private_network
service, created, spec, domain, seed_name = (
self.cloud_vm_with_real_seed())
private_mac = "52:54:00:12:34:57"
private_ip_cidr = "10.20.0.10/32"
bridge = "vcbr-private"
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
managed.attrib.update({
"private-vpc-id": "vpc-delete-test",
"private-member-id": "member-delete-test",
"private-ip-cidr": private_ip_cidr,
"private-network-bridge": bridge,
"private-network-verified": "true",
"private-dataplane-owner": "virt-cloud-vpc-dataplane-v1",
"private-network-revision": "1",
"private-network-digest": "a" * 64,
})
if include_private_nic:
domain.inactive_root.find("./devices").append(ET.fromstring(
"<interface type='bridge'>"
f"<mac address='{private_mac}'/>"
f"<source bridge='{bridge}'/>"
"<model type='virtio'/><alias name='ua-private0'/>"
"</interface>"
))
seed = self.backend.pools["images"].volumes[seed_name]
replacement = replace_seed_private_network(
bytes(seed.contents), private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=["10.20.0.0/24"],
)
seed.contents = bytearray(replacement)
seed.capacity = len(replacement)
domain.running = False
domain.live_root = None
resources = types.SimpleNamespace(bridge=bridge)
return (service, created, domain, seed, resources,
private_mac, private_ip_cidr)
def private_seed_readback_fixture(self):
from virsh_panel.vpc import VpcMember
from virsh_panel.vpc_dataplane import (
private_guest_network_generation,
)
(service, created, domain, seed, _resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
routes = ["10.20.0.0/24"]
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
generation = private_guest_network_generation(member, routes)
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
managed.set("private-guest-network-generation", generation)
identity = {
"vpc_id": "vpc-delete-test",
"member_id": "member-delete-test",
"desired_revision": 1,
"desired_digest": "a" * 64,
"guest_network_generation": generation,
}
kwargs = {
"private_mac": private_mac,
"private_ip_cidr": private_ip_cidr,
"private_routes": routes,
"private_seed_identity": identity,
}
return service, created, domain, seed, kwargs
def test_unclaimed_private_configuration_rejects_saved_restore_state(self):
service, created, domain, _seed, kwargs = (
self.private_seed_readback_fixture())
domain.managed_save_image = True
with self.assertRaises(self.error_type) as managed_save:
service.read_private_configuration_unclaimed(
created["uuid"], **kwargs)
self.assertEqual(
managed_save.exception.error_code,
"vpc_vm_managed_save_present",
)
domain.managed_save_image = False
for reader in (
None,
Mock(side_effect=FakeLibvirtError("managed save unavailable")),
):
with self.subTest(managed_save_reader=reader), patch.object(
domain, "hasManagedSaveImage", reader), \
self.assertRaises(self.error_type) as unavailable:
service.read_private_configuration_unclaimed(
created["uuid"], **kwargs)
self.assertEqual(
unavailable.exception.error_code,
"vpc_member_power_unavailable",
)
domain.snapshots = 1
with self.assertRaises(self.error_type) as native_snapshot:
service.read_private_configuration_unclaimed(
created["uuid"], **kwargs)
self.assertEqual(
native_snapshot.exception.error_code,
"vpc_vm_native_snapshot_present",
)
domain.snapshots = 0
with patch.object(
domain, "snapshotNum",
Mock(side_effect=FakeLibvirtError("snapshot state unavailable"))), \
self.assertRaises(self.error_type) as snapshot_unavailable:
service.read_private_configuration_unclaimed(
created["uuid"], **kwargs)
self.assertEqual(
snapshot_unavailable.exception.error_code,
"vpc_vm_native_snapshot_state_unknown",
)
def test_unclaimed_private_absence_rejects_saved_restore_state(self):
created = self.service.create_vm(self.spec(name="absence-guard"))
domain = self.backend.domains[0]
domain.running = False
domain.live_root = None
domain.managed_save_image = True
with self.assertRaises(self.error_type) as managed_save:
self.service.read_private_absence_unclaimed(created["uuid"])
self.assertEqual(
managed_save.exception.error_code,
"vpc_private_remove_unsafe",
)
domain.managed_save_image = False
for reader in (
None,
Mock(side_effect=FakeLibvirtError("managed save unavailable")),
):
with self.subTest(managed_save_reader=reader), patch.object(
domain, "hasManagedSaveImage", reader), \
self.assertRaises(self.error_type) as unavailable:
self.service.read_private_absence_unclaimed(created["uuid"])
self.assertEqual(
unavailable.exception.error_code,
"vpc_member_power_unavailable",
)
domain.snapshots = 1
with self.assertRaises(self.error_type) as native_snapshot:
self.service.read_private_absence_unclaimed(created["uuid"])
self.assertEqual(
native_snapshot.exception.error_code,
"vpc_private_remove_unsafe",
)
domain.snapshots = 0
with patch.object(
domain, "snapshotNum",
Mock(side_effect=FakeLibvirtError("snapshot state unavailable"))), \
self.assertRaises(self.error_type) as snapshot_unavailable:
self.service.read_private_absence_unclaimed(created["uuid"])
self.assertEqual(
snapshot_unavailable.exception.error_code,
"vpc_vm_native_snapshot_state_unknown",
)
def test_private_seed_readback_is_exact_and_read_only(self):
service, created, _domain, _seed, kwargs = (
self.private_seed_readback_fixture())
with patch.object(service, "_upload_volume") as upload, patch.object(
FakeConnection, "defineXML", autospec=True) as define:
pair = service.read_private_domain_pair(
created["uuid"], **kwargs)
self.assertTrue(pair["seed_verified"])
upload.assert_not_called()
define.assert_not_called()
def test_private_seed_readback_accepts_legacy_missing_public_ip_metadata(self):
service, created, domain, _seed, kwargs = (
self.private_seed_readback_fixture())
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
managed.attrib.pop("public-ip-cidr")
pair = service.read_private_domain_pair(created["uuid"], **kwargs)
self.assertTrue(pair["seed_verified"])
def test_private_seed_readback_rejects_missing_invalid_and_drift(self):
from virsh_panel.cloud_init import (
replace_seed_network,
replace_seed_private_network,
)
service, created, domain, seed, kwargs = (
self.private_seed_readback_fixture())
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
original_seed = bytes(seed.contents)
original_capacity = seed.capacity
seed_name = managed.get("seed-volume")
cases = {
"missing": None,
"invalid": b"not-an-iso",
"private-drift": replace_seed_private_network(
original_seed,
private_mac=kwargs["private_mac"],
private_ip_cidr=kwargs["private_ip_cidr"],
private_routes=["10.20.0.0/23"],
),
"public-drift": replace_seed_network(
original_seed, "8.8.8.19/24", "8.8.8.1",
["1.1.1.1", "8.8.8.8"],
),
}
with patch.object(service, "_upload_volume") as upload, patch.object(
FakeConnection, "defineXML", autospec=True) as define:
for case, seed_bytes in cases.items():
with self.subTest(case=case):
managed.set("seed-volume", seed_name)
seed.contents = bytearray(original_seed)
seed.capacity = original_capacity
if seed_bytes is None:
managed.attrib.pop("seed-volume")
else:
seed.contents = bytearray(seed_bytes)
seed.capacity = len(seed_bytes)
pair = service.read_private_domain_pair(
created["uuid"], **kwargs)
self.assertFalse(pair["seed_verified"])
upload.assert_not_called()
define.assert_not_called()
def test_private_seed_readback_rejects_stale_identity_without_writes(self):
service, created, _domain, _seed, kwargs = (
self.private_seed_readback_fixture())
identity = kwargs["private_seed_identity"]
changes = {
"vpc_id": "vpc-other",
"member_id": "member-other",
"desired_revision": 2,
"desired_digest": "b" * 64,
"guest_network_generation": "c" * 64,
}
with patch.object(service, "_upload_volume") as upload, patch.object(
FakeConnection, "defineXML", autospec=True) as define:
for field, value in changes.items():
with self.subTest(field=field):
stale = dict(identity, **{field: value})
pair = service.read_private_domain_pair(
created["uuid"], **dict(
kwargs, private_seed_identity=stale))
self.assertFalse(pair["seed_verified"])
upload.assert_not_called()
define.assert_not_called()
def test_private_seed_readback_rejects_missing_volume_and_bad_capacity(self):
service, created, _domain, seed, kwargs = (
self.private_seed_readback_fixture())
pool = seed.pool
with patch.object(
pool, "storageVolLookupByName",
side_effect=FakeLibvirtError("storage volume not found")):
missing = service.read_private_domain_pair(
created["uuid"], **kwargs)
self.assertFalse(missing["seed_verified"])
original_capacity = seed.capacity
for capacity in (0, 1024 * 1024 + 1):
with self.subTest(capacity=capacity):
seed.capacity = capacity
invalid = service.read_private_domain_pair(
created["uuid"], **kwargs)
self.assertFalse(invalid["seed_verified"])
seed.capacity = original_capacity
seed.capacity = 0
with self.assertRaises(self.error_type) as default_error:
service._download_seed_volume(FakeConnection(self.backend), seed)
self.assertEqual(default_error.exception.error_code, "")
seed.capacity = original_capacity
def test_private_seed_readback_short_read_is_deterministic_drift(self):
service, created, _domain, seed, kwargs = (
self.private_seed_readback_fixture())
with patch.object(FakeStream, "recv", return_value=b""):
pair = service.read_private_domain_pair(
created["uuid"], **kwargs)
self.assertFalse(pair["seed_verified"])
connection = FakeConnection(self.backend)
with patch.object(FakeStream, "recv", return_value=b""):
with self.assertRaises(self.error_type) as default_error:
service._download_seed_volume(connection, seed)
self.assertEqual(default_error.exception.error_code, "")
def test_private_seed_readback_download_error_remains_unknown(self):
service, created, _domain, _seed, kwargs = (
self.private_seed_readback_fixture())
with patch.object(
service, "_operation_guard",
wraps=service._operation_guard) as guard, patch.object(
service, "_download_seed_volume",
side_effect=FakeLibvirtError("seed download failed")), \
patch.object(service, "_upload_volume") as upload, \
patch.object(FakeConnection, "defineXML",
autospec=True) as define:
with self.assertRaises(self.error_type):
service.read_private_domain_pair(created["uuid"], **kwargs)
self.assertNotIn("storage", guard.call_args.kwargs)
self.assertTrue(guard.call_args.kwargs["tracked_mutations"])
self.assertEqual(self.service_module.RESOURCE_LOCKS.entry_count(), 0)
upload.assert_not_called()
define.assert_not_called()
@staticmethod
def _seed_readback_coordinator():
from virsh_panel.coordination import DurableCoordinator
class Store:
def __init__(self):
self.value = None
def get(self, _kind, _key):
return self.value
def insert(self, _kind, _key, value):
if self.value is not None:
return False
self.value = value
return True
def compare_and_set(self, _kind, _key, expected, value):
if self.value != expected:
return False
self.value = value
return True
return DurableCoordinator(Store())
def test_private_seed_transport_failure_releases_nested_durable_vm_claim(self):
from virsh_panel.coordination import execution_context
service, created, _domain, _seed, kwargs = (
self.private_seed_readback_fixture())
coordinator = self._seed_readback_coordinator()
parent = coordinator.claim(
operation_id="vpc-seed-readback-parent",
resources=("vpc:host-a:readback",),
)
with execution_context(
coordinator, parent, tracked_mutations=False):
# A sibling member may already have started QGA work in this VPC
# execution. Its shared marker must not contaminate this VM's
# still-read-only seed failure.
from virsh_panel.coordination import mark_remote_write_started
mark_remote_write_started()
with patch.object(
service, "_download_seed_volume",
side_effect=FakeLibvirtError("seed download failed")):
with self.assertRaises(self.error_type):
service.read_private_domain_pair(
created["uuid"], **kwargs)
snapshot = coordinator.snapshot()
self.assertEqual(set(snapshot), {parent.token})
self.assertEqual(
snapshot[parent.token]["resources"],
["vpc:host-a:readback"],
)
self.assertEqual(
self.service_module.RESOURCE_LOCKS.entry_count(), 0)
self.assertTrue(coordinator.release(parent))
self.assertEqual(coordinator.snapshot(), {})
def test_qga_write_failure_retains_nested_durable_vm_claim(self):
from virsh_panel.coordination import (
execution_context,
mark_remote_write_started,
)
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
coordinator = self._seed_readback_coordinator()
parent = coordinator.claim(
operation_id="vpc-qga-readback-parent",
resources=("vpc:host-a:readback",),
)
def qga_reply_lost(*_args, **_kwargs):
mark_remote_write_started()
raise self.error_type("QGA 写入结果未确认", 502)
with execution_context(
coordinator, parent, tracked_mutations=False):
with patch.object(
self.service, "_ensure_qga_runtime_token",
side_effect=qga_reply_lost):
with self.assertRaises(self.error_type):
self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)
snapshot = coordinator.snapshot()
nested = {
token: row for token, row in snapshot.items()
if token != parent.token
}
self.assertEqual(len(nested), 1)
self.assertEqual(
next(iter(nested.values()))["state"], "uncertain")
self.assertFalse(any(
resource.startswith("storage:")
for row in nested.values()
for resource in row["resources"]
))
self.assertTrue(coordinator.release(parent))
self.assertEqual(
[row["state"] for row in coordinator.snapshot().values()],
["uncertain"],
)
def test_private_seed_readback_honors_near_deadline_before_connect(self):
service, created, _domain, _seed, kwargs = (
self.private_seed_readback_fixture())
with patch.object(service, "_connect") as connect:
with self.assertRaises(self.error_type) as expired:
service.read_private_domain_pair(
created["uuid"], **kwargs,
guest_probe_deadline=time.monotonic() + 0.1)
self.assertEqual(
expired.exception.error_code,
"vpc_private_guest_probe_deadline_exceeded",
)
connect.assert_not_called()
def test_private_seed_readback_caps_guard_and_connection_to_deadline(self):
service, created, _domain, _seed, kwargs = (
self.private_seed_readback_fixture())
original_guard = service._operation_guard
original_connect = service._connect
waits = []
connects = []
@contextmanager
def guard(*args, **options):
waits.append(options.get("wait_timeout"))
with original_guard(*args, **options):
yield
@contextmanager
def connect(*, timeout):
connects.append(timeout)
with original_connect(timeout=timeout) as connection:
yield connection
deadline = time.monotonic() + 3
with patch.object(service, "_operation_guard", guard), patch.object(
service, "_connect", connect):
pair = service.read_private_domain_pair(
created["uuid"], **kwargs,
guest_probe_deadline=deadline)
self.assertTrue(pair["seed_verified"])
self.assertEqual(len(waits), 1)
self.assertGreater(waits[0], 0)
self.assertLessEqual(waits[0], 3)
self.assertEqual(len(connects), 1)
self.assertGreater(connects[0], 0)
self.assertLessEqual(connects[0], 3)
def private_guest_probe_domain(self, *, running=True):
vm_uuid = "33333333-3333-4333-8333-333333333333"
private_mac = "52:54:00:12:34:57"
private_ip_cidr = "10.20.0.10/32"
private_routes = ["10.20.0.0/24"]
domain = FakeDomain(self.backend, f"""
<domain type='kvm'>
<name>guest-proof</name><uuid>{vm_uuid}</uuid>
<memory>1048576</memory><vcpu>1</vcpu>
<metadata><managed xmlns='urn:virsh-panel:1'
private-guest-network-generation='generation-1'/></metadata>
<devices>
<interface type='bridge'>
<mac address='52:54:00:12:34:56'/>
<source bridge='br0'/><alias name='ua-public0'/>
</interface>
<interface type='bridge'>
<mac address='{private_mac}'/>
<source bridge='vcbr-private'/><alias name='ua-private0'/>
</interface>
</devices>
</domain>
""", running=running)
self.backend.domains.append(domain)
# The Python binding returns a mapping keyed by the guest interface
# name. Deliberately omit any duplicate name field in the value so a
# test cannot accidentally pass by reading the wrong shape.
self.backend.guest_interfaces = {
"ens7": {
"hwaddr": private_mac,
"addrs": [{
"type": 0, "addr": "10.20.0.10", "prefix": 32,
}],
},
}
self.backend.guest_links = [{
"ifindex": 7,
"ifname": "ens7",
"flags": ["BROADCAST", "MULTICAST", "UP", "LOWER_UP"],
"address": private_mac,
"operstate": "UP",
}]
self.backend.guest_routes = [
{"dst": route, "dev": "ens7", "scope": "link",
"protocol": "static"}
for route in private_routes
]
return domain, private_mac, private_ip_cidr, private_routes
def test_private_guest_probe_uses_binding_key_and_exact_qga_commands(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
pair = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)
evidence = pair["guest_network"]
self.assertTrue(evidence["verified"])
self.assertEqual(evidence["state"], "confirmed")
self.assertEqual(evidence["source"], "qemu_guest_agent")
self.assertEqual(evidence["private_mac"], private_mac)
self.assertEqual(evidence["private_ip_cidr"], private_ip_cidr)
self.assertEqual(evidence["link_state"], "up")
self.assertEqual(evidence["routes"], sorted(private_routes))
self.assertEqual(
self.backend.guest_agent_timeout_calls,
[(2, 0), (-1, 0), (2, 0), (-1, 0)],
)
self.assertEqual(
[item["execute"] for item in self.backend.guest_agent_commands],
["guest-info", "guest-exec", "guest-exec-status",
"guest-exec", "guest-exec-status"],
)
link_execution = self.backend.guest_agent_commands[1]["arguments"]
self.assertEqual(link_execution["path"], "/usr/bin/timeout")
self.assertEqual(
link_execution["arg"],
["--signal=KILL", "1", "/usr/bin/head", "-q", "-c",
"4097", "/sys/class/net/ens7/address",
"/sys/class/net/ens7/operstate",
"/sys/class/net/ens7/carrier",
"/sys/class/net/ens7/flags"],
)
route_execution = self.backend.guest_agent_commands[3]["arguments"]
self.assertEqual(route_execution["path"], "/usr/bin/timeout")
self.assertEqual(
route_execution["arg"],
["--signal=KILL", "1", "/bin/sh", "-c",
self.service_module.VPC_GUEST_ROUTE_SCRIPT,
"vpc-route-probe", "ens7"],
)
self.assertTrue(link_execution["capture-output"])
self.assertTrue(route_execution["capture-output"])
def test_private_guest_probe_rejects_down_link_with_retained_state(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.guest_links[0]["flags"] = [
"BROADCAST", "MULTICAST", "UP", "NO-CARRIER",
]
self.backend.guest_links[0]["operstate"] = "DOWN"
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "mismatch")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_link_mismatch",
)
def test_private_guest_probe_rejects_linkdown_route_flag(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.guest_routes[0]["flags"] = ["linkdown"]
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "mismatch")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_route_mismatch",
)
def test_private_guest_probe_rejects_missing_vpc_scope_route(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.guest_routes = []
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "mismatch")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_route_mismatch",
)
def test_private_guest_probe_rejects_address_mismatch(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.guest_interfaces["ens7"]["addrs"][0]["addr"] = (
"10.20.0.99")
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "mismatch")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_address_mismatch",
)
self.assertEqual(self.backend.guest_agent_commands, [])
def test_private_guest_probe_scopes_route_read_to_private_interface(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.guest_routes.append({
"dst": private_routes[0], "dev": "ens3", "scope": "link",
"protocol": "static",
})
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertTrue(evidence["verified"])
self.assertEqual(evidence["state"], "confirmed")
def test_private_guest_probe_restores_timeout_when_agent_is_unavailable(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.fail_guest_interface_addresses = True
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "unavailable")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_agent_unavailable",
)
self.assertEqual(
self.backend.guest_agent_timeout_calls,
[(2, 0), (-1, 0)],
)
def test_private_guest_probe_fails_closed_when_timeout_restore_fails(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.fail_guest_agent_timeout_restore = True
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "uncertain")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_probe_uncertain",
)
self.assertEqual(
self.backend.guest_agent_timeout_calls,
[(2, 0), (-1, 0)],
)
def test_private_guest_route_permission_denial_stays_unverified(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
original = self.service_module.libvirt_qemu.qemuAgentCommand
cases = [
(b"vpc-route-probe: line 1: /usr/sbin/ip: Permission denied\n", 0, {},
"vpc_private_guest_probe_permission_denied"),
(b"vpc-route-probe: line 1: /usr/sbin/ip: Permission denied\n"
b"vpc-route-probe: line 1: exec: /usr/sbin/ip: cannot execute: Permission denied\n",
0, {}, "vpc_private_guest_probe_permission_denied"),
(b"vpc-route-probe: line 1: /usr/sbin/ip: Permission denied\n"
b"unreviewed trailing diagnostic\n",
0, {}, "vpc_private_guest_probe_uncertain"),
(b"/usr/sbin/ip: Permission denied\n" * 3, 0, {},
"vpc_private_guest_probe_uncertain"),
(b"vpc-route-probe: 1: exec: /usr/sbin/ip: Permission denied\n", 126, {},
"vpc_private_guest_probe_permission_denied"),
(b"/usr/sbin/ip: Permission denied\n", 0, {},
"vpc_private_guest_probe_permission_denied"),
(b"/some/other/path: Permission denied\n", 0, {},
"vpc_private_guest_probe_uncertain"),
(b"/usr/sbin/ip: Permission denied\n", 0, {"err-truncated": True},
"vpc_private_guest_probe_uncertain"),
(b"/usr/sbin/ip: Permission denied\n", 0, {"signal": 9},
"vpc_private_guest_probe_uncertain"),
(b"/usr/sbin/ip: Permission denied\n", 2, {},
"vpc_private_guest_probe_uncertain"),
(b"other unreviewed guest diagnostic\n", 0, {},
"vpc_private_guest_probe_uncertain"),
]
cases.extend(
(b"/usr/sbin/ip: Permission denied\n", malformed, {},
"vpc_private_guest_probe_uncertain")
for malformed in (None, True, 0.0, "0", [], {})
)
for stderr, exitcode, extra, reason in cases:
with self.subTest(stderr=stderr, exitcode=exitcode, extra=extra):
route_pids = set()
def deny_route(target, payload, timeout, flags):
request = json.loads(payload)
reply = json.loads(original(target, payload, timeout, flags))
if request.get("execute") == "guest-exec":
args = request.get("arguments", {}).get("arg", [])
if any("/usr/sbin/ip -j -4 route" in arg for arg in args):
route_pids.add(reply["return"]["pid"])
elif (request.get("execute") == "guest-exec-status"
and request.get("arguments", {}).get("pid") in route_pids):
reply["return"].update({
"err-data": base64.b64encode(stderr).decode("ascii"),
"exitcode": exitcode, **extra,
})
return json.dumps(reply)
self.service_module.libvirt_qemu.qemuAgentCommand = deny_route
try:
evidence = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
finally:
self.service_module.libvirt_qemu.qemuAgentCommand = original
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["reason_code"], reason)
self.assertNotIn("Permission denied", json.dumps(evidence))
self.assertEqual(self.backend.guest_exec_outputs, {},
"A completed denied probe must still be reaped.")
def test_private_guest_probe_reports_disabled_exec_as_unsupported(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.guest_exec_enabled = False
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "unsupported")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_probe_unsupported",
)
self.assertEqual(
[item["execute"] for item in self.backend.guest_agent_commands],
["guest-info"],
)
def test_private_guest_probe_skips_qga_for_stale_live_generation(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
managed = domain.live_root.find(
"./metadata/{urn:virsh-panel:1}managed")
managed.set("private-guest-network-generation", "old-generation")
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "pending_restart")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_restart_required",
)
self.assertEqual(self.backend.guest_agent_commands, [])
def test_private_guest_probe_reports_stopped_without_contacting_agent(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain(running=False))
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "stopped")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_stopped",
)
self.assertEqual(self.backend.guest_interface_address_calls, 0)
self.assertEqual(self.backend.guest_agent_commands, [])
def test_private_guest_probe_deadline_fails_closed_before_qga(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
evidence = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
guest_probe_deadline=time.monotonic() + 0.5,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "deadline_exceeded")
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_probe_deadline_exceeded",
)
self.assertEqual(self.backend.guest_interface_address_calls, 0)
self.assertEqual(self.backend.guest_agent_commands, [])
def test_private_guest_probe_persists_pid_and_blocks_cross_request_status(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
durable = {}
writes = []
def persist(value):
durable.clear()
durable.update(copy.deepcopy(value))
writes.append(copy.deepcopy(value))
def clear():
durable.clear()
self.backend.fail_guest_exec_status = True
first_state = {}
first = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
guest_exec_state=first_state,
guest_exec_persist=persist,
guest_exec_clear=clear,
)["guest_network"]
self.assertFalse(first["verified"])
self.assertEqual(first["state"], "unavailable")
self.assertEqual(durable.get("phase"), "pending")
self.assertEqual(durable.get("pid"), 41)
self.assertEqual(writes[0]["phase"], "launch_intent")
self.assertEqual(writes[1]["phase"], "pending")
self.assertEqual(
[item["execute"] for item in self.backend.guest_agent_commands]
.count("guest-exec"),
1,
)
self.backend.fail_guest_exec_status = False
self.backend.guest_agent_commands.clear()
second_state = copy.deepcopy(durable)
second = self.service.read_private_domain_pair(
domain.UUIDString(),
private_mac=private_mac,
private_ip_cidr=private_ip_cidr,
private_routes=private_routes,
guest_exec_state=second_state,
guest_exec_persist=persist,
guest_exec_clear=clear,
)["guest_network"]
self.assertFalse(second["verified"])
self.assertEqual(
second["reason_code"],
"vpc_private_guest_probe_reap_required",
)
commands = [
item["execute"] for item in self.backend.guest_agent_commands
]
self.assertEqual(commands, [])
self.assertEqual(durable.get("pid"), 41)
# An observed stop proves that the old QEMU/QGA process ledger cannot
# survive. The later start gets a new LIVE token and may launch.
old_token = durable["qemu_runtime_token"]
domain.shutdown()
stopped = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state=copy.deepcopy(durable),
guest_exec_persist=persist, guest_exec_clear=clear,
)["guest_network"]
self.assertEqual(stopped["state"], "stopped")
self.assertEqual(durable, {})
domain.create()
self.backend.guest_agent_commands.clear()
third = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state={},
guest_exec_persist=persist, guest_exec_clear=clear,
)["guest_network"]
self.assertTrue(third["verified"])
runtime_node = domain.live_root.find(
"./metadata/{urn:virsh-panel:qga-runtime:1}qga-runtime")
self.assertIsNotNone(runtime_node)
self.assertNotEqual(runtime_node.get("token"), old_token)
self.assertNotEqual(
self.backend.guest_agent_commands[0]["execute"],
"guest-exec-status",
)
self.assertEqual(durable, {})
def test_private_guest_probe_launch_intent_blocks_until_stopped(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
durable = {}
def persist(value):
durable.clear()
durable.update(copy.deepcopy(value))
def clear():
durable.clear()
original = self.service_module.libvirt_qemu.qemuAgentCommand
def lose_exec_reply(target, payload, timeout, flags):
if json.loads(payload).get("execute") == "guest-exec":
raise FakeLibvirtError("transport response lost")
return original(target, payload, timeout, flags)
self.service_module.libvirt_qemu.qemuAgentCommand = lose_exec_reply
state = {}
first = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state=state, guest_exec_persist=persist,
guest_exec_clear=clear,
)["guest_network"]
self.assertFalse(first["verified"])
self.assertEqual(durable.get("phase"), "launch_intent")
self.service_module.libvirt_qemu.qemuAgentCommand = original
self.backend.guest_agent_commands.clear()
second_state = copy.deepcopy(durable)
second = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state=second_state, guest_exec_persist=persist,
guest_exec_clear=clear,
)["guest_network"]
self.assertEqual(second["state"], "uncertain")
self.assertEqual(
second["reason_code"],
"vpc_private_guest_probe_reap_required")
self.assertEqual(self.backend.guest_agent_commands, [])
domain.running = False
stopped_state = copy.deepcopy(durable)
stopped = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state=stopped_state, guest_exec_persist=persist,
guest_exec_clear=clear,
)["guest_network"]
self.assertEqual(stopped["state"], "stopped")
self.assertEqual(durable, {})
def test_private_guest_probe_agent_restart_never_statuses_old_pid(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
durable = {}
def persist(value):
durable.clear()
durable.update(copy.deepcopy(value))
def clear():
durable.clear()
self.backend.fail_guest_exec_status = True
state = {}
self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state=state, guest_exec_persist=persist,
guest_exec_clear=clear,
)
self.assertEqual(durable.get("phase"), "pending")
self.backend.fail_guest_exec_status = False
self.backend.guest_exec_outputs.clear()
self.backend.guest_agent_commands.clear()
recovered = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state=copy.deepcopy(durable),
guest_exec_persist=persist, guest_exec_clear=clear,
)["guest_network"]
self.assertFalse(recovered["verified"])
self.assertEqual(
recovered["reason_code"],
"vpc_private_guest_probe_reap_required",
)
self.assertEqual(self.backend.guest_agent_commands, [])
self.assertEqual(durable.get("phase"), "pending")
def test_private_guest_probe_rejects_truncated_route_table(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.guest_routes.extend({
"dst": f"10.{index // 256}.{index % 256}.1/32",
"dev": "ens7", "scope": "link", "protocol": "static",
} for index in range(4096))
evidence = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "uncertain")
self.assertEqual(
evidence["reason_code"], "vpc_private_guest_probe_uncertain")
def test_private_guest_probe_suspended_skips_guest_exec(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
ET.SubElement(
domain.live_root.find("./devices/interface[2]"),
"link", {"state": "down"},
)
evidence = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "suspended")
self.assertEqual(
evidence["reason_code"], "vpc_private_network_suspended")
self.assertEqual(self.backend.guest_agent_commands, [])
def test_private_guest_probe_runtime_token_response_loss_uses_readback(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.fail_metadata_after_set = True
pair = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
)
self.assertTrue(pair["guest_network"]["verified"])
self.assertEqual(len(self.backend.metadata_updates), 1)
runtime = domain.live_root.find(
"./metadata/{urn:virsh-panel:qga-runtime:1}qga-runtime")
self.assertIsNotNone(runtime)
self.assertEqual(runtime.get("domain-uuid"), domain.UUIDString())
self.assertRegex(runtime.get("token"), r"^[0-9a-f]{32}$")
self.assertNotIn("qga-runtime", pair["live"])
self.assertNotIn("qga-runtime", pair["inactive"])
self.assertIsNone(domain.inactive_root.find(
"./metadata/{urn:virsh-panel:qga-runtime:1}qga-runtime"))
def test_private_guest_probe_runtime_token_stop_race_fails_closed(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
self.backend.stop_during_metadata_set = True
evidence = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "unavailable")
self.assertEqual(self.backend.guest_agent_commands, [])
self.assertIsNone(domain.inactive_root.find(
"./metadata/{urn:virsh-panel:qga-runtime:1}qga-runtime"))
def test_private_guest_probe_runtime_token_is_bound_to_domain_uuid(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
metadata = domain.live_root.find("metadata")
ET.SubElement(
metadata,
"{urn:virsh-panel:qga-runtime:1}qga-runtime",
{"domain-uuid": "44444444-4444-4444-8444-444444444444",
"token": "a" * 32},
)
evidence = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
)["guest_network"]
self.assertFalse(evidence["verified"])
self.assertEqual(evidence["state"], "unavailable")
self.assertEqual(self.backend.guest_agent_commands, [])
def test_private_guest_probe_guest_reboot_keeps_old_pid_blocked(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
durable = {}
def persist(value):
durable.clear()
durable.update(copy.deepcopy(value))
def clear():
durable.clear()
self.backend.fail_guest_exec_status = True
self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state={}, guest_exec_persist=persist,
guest_exec_clear=clear,
)
token = durable["qemu_runtime_token"]
domain.guest_reboot()
self.backend.guest_exec_outputs.clear()
self.backend.fail_guest_exec_status = False
self.backend.guest_agent_commands.clear()
evidence = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state=copy.deepcopy(durable),
guest_exec_persist=persist, guest_exec_clear=clear,
)["guest_network"]
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_probe_reap_required",
)
self.assertEqual(durable["qemu_runtime_token"], token)
self.assertEqual(self.backend.guest_agent_commands, [])
def test_private_guest_probe_changed_live_token_cannot_clear_ledger(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
durable = {}
clear_calls = 0
def persist(value):
durable.clear()
durable.update(copy.deepcopy(value))
def clear():
nonlocal clear_calls
clear_calls += 1
durable.clear()
self.backend.fail_guest_exec_status = True
self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state={}, guest_exec_persist=persist,
guest_exec_clear=clear,
)
old_token = durable["qemu_runtime_token"]
runtime = domain.live_root.find(
"./metadata/{urn:virsh-panel:qga-runtime:1}qga-runtime")
replacement = "f" * 32 if old_token != "f" * 32 else "e" * 32
runtime.set("token", replacement)
self.backend.fail_guest_exec_status = False
self.backend.guest_agent_commands.clear()
evidence = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state=copy.deepcopy(durable),
guest_exec_persist=persist, guest_exec_clear=clear,
)["guest_network"]
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_probe_reap_required",
)
self.assertEqual(clear_calls, 0)
self.assertEqual(durable["qemu_runtime_token"], old_token)
self.assertEqual(durable.get("phase"), "pending")
self.assertEqual(self.backend.guest_agent_commands, [])
def test_private_guest_probe_missing_live_token_cannot_clear_ledger(self):
domain, private_mac, private_ip_cidr, private_routes = (
self.private_guest_probe_domain())
durable = {}
def persist(value):
durable.clear()
durable.update(copy.deepcopy(value))
self.backend.fail_guest_exec_status = True
self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state={}, guest_exec_persist=persist,
guest_exec_clear=lambda: durable.clear(),
)
metadata = domain.live_root.find("metadata")
runtime = metadata.find(
"{urn:virsh-panel:qga-runtime:1}qga-runtime")
metadata.remove(runtime)
update_count = len(self.backend.metadata_updates)
self.backend.fail_guest_exec_status = False
self.backend.guest_agent_commands.clear()
evidence = self.service.read_private_domain_pair(
domain.UUIDString(), private_mac=private_mac,
private_ip_cidr=private_ip_cidr, private_routes=private_routes,
guest_exec_state=copy.deepcopy(durable),
guest_exec_persist=persist,
guest_exec_clear=lambda: durable.clear(),
)["guest_network"]
self.assertEqual(
evidence["reason_code"],
"vpc_private_guest_probe_reap_required",
)
self.assertEqual(len(self.backend.metadata_updates), update_count)
self.assertEqual(self.backend.guest_agent_commands, [])
self.assertEqual(durable.get("phase"), "pending")
def test_running_private_network_waits_for_stop_before_staging(self):
from virsh_panel.vpc import VpcMember
service = self.cloud_service()
spec = self.cloud_spec()
created = self.create_cloud_vm(service, spec)
domain = self.backend.domains[0]
managed_before = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
seed_name = managed_before.get("seed-volume")
member = VpcMember(
"member-stage-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", "52:54:00:12:34:57",
)
resources = types.SimpleNamespace(bridge="vcbr-private")
seed = self.backend.pools["images"].volumes[seed_name]
initial_inactive = domain.XMLDesc(1)
initial_live = domain.XMLDesc(0)
initial_seed = bytes(seed.contents)
initial_defines = len(self.backend.define_xmls)
private_seed = b"SEED-WITH-PRIVATE-NETWORK"
updated_private_seed = b"SEED-WITH-UPDATED-PRIVATE-ROUTES"
def read_network(contents):
result = {
"mac": domain.inactive_root.find(
"./devices/interface/mac").get("address"),
"public_ip_cidr": spec["public_ip_cidr"],
}
if contents in {private_seed, updated_private_seed}:
result.update({
"private_mac": member.private_mac,
"private_ip_cidr": f"{member.private_ip}/32",
"private_routes": (["10.20.0.0/24"]
if contents == private_seed else
["10.20.0.0/23"]),
"roles": ["public0", "private0"],
})
return result
def replace_network(contents, **changes):
desired = (updated_private_seed
if changes.get("private_routes") == [
"10.20.0.0/23"]
else private_seed)
return contents if contents == desired else desired
patches = (
patch.object(self.service_module, "read_seed_network",
side_effect=read_network),
patch.object(self.service_module, "replace_seed_private_network",
side_effect=replace_network),
)
with patches[0], patches[1]:
staged = service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-stage-test", desired_revision=1,
desired_digest="a" * 64,
private_routes=["10.20.0.0/24"],
)
self.assertEqual(staged["readback"], "pending_restart")
self.assertTrue(staged["restart_required"])
self.assertFalse(staged["seed_updated"])
self.assertEqual(
ET.canonicalize(staged["xml"], rewrite_prefixes=True),
ET.canonicalize(initial_inactive, rewrite_prefixes=True),
)
self.assertEqual(
ET.canonicalize(staged["live"], rewrite_prefixes=True),
ET.canonicalize(initial_live, rewrite_prefixes=True),
)
self.assertEqual(bytes(seed.contents), initial_seed)
self.assertEqual(
ET.canonicalize(domain.XMLDesc(1), rewrite_prefixes=True),
ET.canonicalize(initial_inactive, rewrite_prefixes=True),
)
self.assertEqual(len(self.backend.define_xmls), initial_defines)
live_before = ET.fromstring(initial_live)
live_after_stage = ET.fromstring(domain.XMLDesc(0))
self.assertIsNone(live_before.find(
"./devices/interface/alias[@name='ua-private0']"))
self.assertIsNone(live_after_stage.find(
"./devices/interface/alias[@name='ua-private0']"))
self.assertIsNone(live_after_stage.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
).get("private-guest-network-generation"))
self.assertEqual(self.backend.device_updates, [])
retried = service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-stage-test", desired_revision=1,
desired_digest="a" * 64,
private_routes=["10.20.0.0/24"],
)
self.assertEqual(retried["readback"], "pending_restart")
self.assertFalse(retried["seed_updated"])
self.assertEqual(bytes(seed.contents), initial_seed)
self.assertEqual(
ET.canonicalize(domain.XMLDesc(1), rewrite_prefixes=True),
ET.canonicalize(initial_inactive, rewrite_prefixes=True),
)
self.assertEqual(len(self.backend.define_xmls), initial_defines)
domain.shutdown()
stopped_stage = service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-stage-test", desired_revision=1,
desired_digest="a" * 64,
private_routes=["10.20.0.0/24"],
)
self.assertEqual(stopped_stage["readback"], "confirmed")
self.assertTrue(stopped_stage["seed_updated"])
self.assertFalse(stopped_stage["restart_required"])
self.assertIsNone(stopped_stage["live"])
inactive = ET.fromstring(domain.XMLDesc(1))
managed = inactive.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
generation = managed.get("private-guest-network-generation")
self.assertRegex(generation, r"^[0-9a-f]{64}$")
self.assertIsNotNone(
inactive.find("./devices/interface/alias[@name='ua-private0']"))
self.assertEqual(bytes(seed.contents), private_seed)
self.assertEqual(len(self.backend.define_xmls),
initial_defines + 1)
stopped_guest = service.read_private_domain_pair(
created["uuid"], private_mac=member.private_mac,
private_ip_cidr=f"{member.private_ip}/32",
private_routes=["10.20.0.0/24"],
)["guest_network"]
self.assertFalse(stopped_guest["verified"])
self.assertEqual(stopped_guest["state"], "stopped")
self.backend.guest_interfaces = {
"ens7": {
"hwaddr": member.private_mac,
"addrs": [{
"type": 0,
"addr": member.private_ip,
"prefix": 32,
}],
},
}
self.backend.guest_links = [{
"ifindex": 7,
"ifname": "ens7",
"flags": ["BROADCAST", "MULTICAST", "UP", "LOWER_UP"],
"address": member.private_mac,
"operstate": "UP",
}]
self.backend.guest_routes = [{
"dst": "10.20.0.0/24",
"dev": "ens7",
"scope": "link",
"protocol": "static",
}]
domain.create()
confirmed = service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-stage-test", desired_revision=1,
desired_digest="a" * 64,
private_routes=["10.20.0.0/24"],
)
self.assertEqual(confirmed["readback"], "confirmed")
self.assertFalse(confirmed["restart_required"])
live = ET.fromstring(domain.XMLDesc(0))
live_managed = live.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
self.assertEqual(
live_managed.get("private-guest-network-generation"),
generation)
guest_ready = service.read_private_domain_pair(
created["uuid"], private_mac=member.private_mac,
private_ip_cidr=f"{member.private_ip}/32",
private_routes=["10.20.0.0/24"],
)["guest_network"]
self.assertTrue(guest_ready["verified"])
self.assertEqual(guest_ready["state"], "confirmed")
device_updates = len(self.backend.device_updates)
acl_only = service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-stage-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/24"],
)
self.assertEqual(acl_only["readback"], "confirmed")
self.assertFalse(acl_only["seed_updated"])
self.assertFalse(acl_only["restart_required"])
self.assertEqual(len(self.backend.device_updates), device_updates)
route_change_inactive = domain.XMLDesc(1)
route_change_live = domain.XMLDesc(0)
route_change_seed = bytes(seed.contents)
route_change_defines = len(self.backend.define_xmls)
route_change = service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-stage-test", desired_revision=3,
desired_digest="c" * 64,
private_routes=["10.20.0.0/23"],
)
self.assertEqual(route_change["readback"], "pending_restart")
self.assertFalse(route_change["seed_updated"])
self.assertTrue(route_change["restart_required"])
self.assertEqual(
ET.canonicalize(route_change["xml"], rewrite_prefixes=True),
ET.canonicalize(route_change_inactive, rewrite_prefixes=True),
)
self.assertEqual(
ET.canonicalize(route_change["live"], rewrite_prefixes=True),
ET.canonicalize(route_change_live, rewrite_prefixes=True),
)
self.assertEqual(bytes(seed.contents), route_change_seed)
self.assertEqual(
ET.canonicalize(domain.XMLDesc(1), rewrite_prefixes=True),
ET.canonicalize(route_change_inactive, rewrite_prefixes=True),
)
self.assertEqual(len(self.backend.define_xmls),
route_change_defines)
self.assertEqual(len(self.backend.device_updates), device_updates)
domain.shutdown()
route_staged = service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-stage-test", desired_revision=3,
desired_digest="c" * 64,
private_routes=["10.20.0.0/23"],
)
self.assertEqual(route_staged["readback"], "confirmed")
self.assertTrue(route_staged["seed_updated"])
self.assertEqual(bytes(seed.contents), updated_private_seed)
self.assertEqual(len(self.backend.define_xmls),
route_change_defines + 1)
domain.create()
self.backend.guest_routes[0]["dst"] = "10.20.0.0/23"
updated_guest = service.read_private_domain_pair(
created["uuid"], private_mac=member.private_mac,
private_ip_cidr=f"{member.private_ip}/32",
private_routes=["10.20.0.0/23"],
)["guest_network"]
self.assertTrue(updated_guest["verified"])
self.assertEqual(updated_guest["state"], "confirmed")
def test_private_seed_upload_is_read_back_before_domain_define(self):
from virsh_panel.vpc import VpcMember
(service, created, domain, seed, resources,
private_mac, _private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
old_xml = domain.XMLDesc(1)
old_seed = bytes(seed.contents)
define_count = len(self.backend.define_xmls)
original_download = service._download_seed_volume
downloads = 0
def corrupt_first_uploaded_readback(connection, volume):
nonlocal downloads
downloads += 1
if downloads == 2:
return b"not-a-seed"
return original_download(connection, volume)
with patch.object(
service, "_download_seed_volume",
side_effect=corrupt_first_uploaded_readback):
with self.assertRaises(self.error_type) as mismatch:
service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-delete-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/23"],
)
self.assertEqual(
mismatch.exception.error_code,
"vpc_seed_readback_mismatch",
)
self.assertEqual(downloads, 2)
self.assertEqual(len(self.backend.define_xmls), define_count)
self.assertEqual(
ET.canonicalize(domain.XMLDesc(1), rewrite_prefixes=True),
ET.canonicalize(old_xml, rewrite_prefixes=True),
)
self.assertEqual(bytes(seed.contents), old_seed)
def test_private_seed_rollback_failure_is_uncertain(self):
from virsh_panel.vpc import VpcMember
(service, created, _domain, seed, resources,
private_mac, _private_ip_cidr) = (
self.cloud_vm_with_private_artifacts(include_private_nic=True))
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
old_seed = bytes(seed.contents)
original_download = service._download_seed_volume
original_upload = service._upload_volume
downloads = 0
uploads = 0
def corrupt_uploaded_readback(connection, volume):
nonlocal downloads
downloads += 1
if downloads == 2:
return b"not-a-seed"
return original_download(connection, volume)
def fail_restore_upload(connection, volume, chunks, size):
nonlocal uploads
uploads += 1
if uploads == 2:
raise FakeLibvirtError("rollback seed upload failed")
return original_upload(connection, volume, chunks, size)
with patch.object(
service, "_download_seed_volume",
side_effect=corrupt_uploaded_readback), patch.object(
service, "_upload_volume",
side_effect=fail_restore_upload):
with self.assertRaises(self.error_type) as uncertain:
service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-delete-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/23"],
)
self.assertEqual(
uncertain.exception.error_code,
"vpc_private_result_uncertain",
)
self.assertEqual(uploads, 2)
self.assertNotEqual(bytes(seed.contents), old_seed)
def test_private_xml_rollback_failure_is_uncertain(self):
from virsh_panel.vpc import VpcMember
(service, created, domain, seed, resources,
private_mac, _private_ip_cidr) = (
self.cloud_vm_with_private_artifacts(include_private_nic=True))
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
old_xml = domain.XMLDesc(1)
old_seed = bytes(seed.contents)
original_define = FakeConnection.defineXML
defines = 0
def fail_rollback_define(connection, xml):
nonlocal defines
defines += 1
if defines == 1:
return original_define(connection, xml)
raise FakeLibvirtError("rollback define failed")
readback_error = self.error_type(
"forced readback mismatch", 502,
error_code="vpc_private_xml_readback_mismatch",
)
with patch.object(
FakeConnection, "defineXML",
new=fail_rollback_define), patch.object(
service, "read_private_domain_pair",
side_effect=readback_error):
with self.assertRaises(self.error_type) as uncertain:
service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-delete-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/23"],
)
self.assertEqual(
uncertain.exception.error_code,
"vpc_private_result_uncertain",
)
self.assertEqual(defines, 2)
self.assertNotEqual(domain.XMLDesc(1), old_xml)
self.assertNotEqual(bytes(seed.contents), old_seed)
def test_private_xml_rollback_none_is_uncertain(self):
from virsh_panel.vpc import VpcMember
(service, created, domain, seed, resources,
private_mac, _private_ip_cidr) = (
self.cloud_vm_with_private_artifacts(include_private_nic=True))
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
old_xml = domain.XMLDesc(1)
old_seed = bytes(seed.contents)
original_define = FakeConnection.defineXML
original_upload = service._upload_volume
defines = 0
uploads = 0
def none_rollback_define(connection, xml):
nonlocal defines
defines += 1
if defines == 1:
return original_define(connection, xml)
return None
def track_upload(connection, volume, chunks, size):
nonlocal uploads
uploads += 1
return original_upload(connection, volume, chunks, size)
readback_error = self.error_type(
"forced readback mismatch", 502,
error_code="vpc_private_xml_readback_mismatch",
)
with patch.object(
FakeConnection, "defineXML",
new=none_rollback_define), patch.object(
service, "_upload_volume",
side_effect=track_upload), patch.object(
service, "read_private_domain_pair",
side_effect=readback_error):
with self.assertRaises(self.error_type) as uncertain:
service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-delete-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/23"],
)
self.assertEqual(
uncertain.exception.error_code,
"vpc_private_result_uncertain",
)
self.assertEqual(defines, 2)
# A failed XML inverse must stop the rollback chain before the seed
# is restored, otherwise the stopped definition and next-boot media
# would describe different network generations.
self.assertEqual(uploads, 1)
self.assertNotEqual(domain.XMLDesc(1), old_xml)
self.assertNotEqual(bytes(seed.contents), old_seed)
def test_stopped_private_apply_start_after_seed_fails_uncertain(self):
from virsh_panel.vpc import VpcMember
(service, created, domain, seed, resources,
private_mac, _private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
original_upload = service._upload_volume
uploads = 0
def upload_then_start(connection, volume, chunks, size):
nonlocal uploads
original_upload(connection, volume, chunks, size)
uploads += 1
if uploads == 1:
domain.live_root = copy.deepcopy(domain.inactive_root)
domain.running = True
define_count = len(self.backend.define_xmls)
with patch.object(service, "_upload_volume",
side_effect=upload_then_start):
with self.assertRaises(self.error_type) as uncertain:
service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-delete-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/23"],
)
self.assertEqual(
uncertain.exception.error_code, "vpc_private_result_uncertain")
self.assertTrue(domain.running)
self.assertEqual(len(self.backend.define_xmls), define_count)
# The seed may have committed before the start race, but rollback must
# not rewrite media now attached to a running guest.
self.assertNotEqual(bytes(seed.contents), b"")
def test_stopped_private_apply_upload_error_after_start_skips_rollback(self):
from virsh_panel.vpc import VpcMember
(service, created, domain, _seed, resources,
private_mac, _private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
original_upload = service._upload_volume
uploads = 0
def upload_then_start_and_fail(connection, volume, chunks, size):
nonlocal uploads
uploads += 1
original_upload(connection, volume, chunks, size)
domain.live_root = copy.deepcopy(domain.inactive_root)
domain.running = True
raise FakeLibvirtError("seed upload response lost after start")
define_count = len(self.backend.define_xmls)
with patch.object(service, "_upload_volume",
side_effect=upload_then_start_and_fail):
with self.assertRaises(self.error_type) as uncertain:
service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-delete-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/23"],
)
self.assertEqual(
uncertain.exception.error_code, "vpc_private_result_uncertain")
self.assertTrue(domain.running)
self.assertEqual(uploads, 1)
self.assertEqual(len(self.backend.define_xmls), define_count)
def test_stopped_private_apply_rollback_probe_failure_is_uncertain(self):
from virsh_panel.vpc import VpcMember
(service, created, domain, _seed, resources,
private_mac, _private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
original_is_active = domain.isActive
original_upload = service._upload_volume
fail_probe = False
uploads = 0
def is_active_or_fail():
if fail_probe:
raise FakeLibvirtError("domain state unavailable")
return original_is_active()
def upload_then_lose_state(connection, volume, chunks, size):
nonlocal fail_probe, uploads
uploads += 1
original_upload(connection, volume, chunks, size)
fail_probe = True
raise FakeLibvirtError("seed upload response lost")
define_count = len(self.backend.define_xmls)
with patch.object(domain, "isActive", side_effect=is_active_or_fail), \
patch.object(service, "_upload_volume",
side_effect=upload_then_lose_state):
with self.assertRaises(self.error_type) as uncertain:
service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-delete-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/23"],
)
self.assertEqual(
uncertain.exception.error_code, "vpc_private_result_uncertain")
self.assertEqual(uploads, 1)
self.assertEqual(len(self.backend.define_xmls), define_count)
def test_stopped_private_apply_start_after_define_fails_uncertain(self):
from virsh_panel.vpc import VpcMember
(service, created, domain, _seed, resources,
private_mac, _private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
original_define = FakeConnection.defineXML
started = False
def define_then_start(connection, xml):
nonlocal started
result = original_define(connection, xml)
if not started:
started = True
domain.live_root = copy.deepcopy(domain.inactive_root)
domain.running = True
return result
with patch.object(FakeConnection, "defineXML",
new=define_then_start):
with self.assertRaises(self.error_type) as uncertain:
service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-delete-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/24"],
)
self.assertEqual(
uncertain.exception.error_code, "vpc_private_result_uncertain")
self.assertTrue(domain.running)
self.assertTrue(started)
def test_stopped_private_apply_start_after_readback_fails_uncertain(self):
from virsh_panel.vpc import VpcMember
(service, created, domain, _seed, resources,
private_mac, _private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
member = VpcMember(
"member-delete-test", created["uuid"], "host-a",
"10.20.0.10", "subnet-a", private_mac,
)
original_read = service.read_private_domain_pair
def read_then_start(*args, **kwargs):
result = original_read(*args, **kwargs)
domain.live_root = copy.deepcopy(domain.inactive_root)
domain.running = True
return result
with patch.object(service, "read_private_domain_pair",
side_effect=read_then_start):
with self.assertRaises(self.error_type) as uncertain:
service.ensure_private_interface(
created["uuid"], member=member, resources=resources,
vpc_id="vpc-delete-test", desired_revision=2,
desired_digest="b" * 64,
private_routes=["10.20.0.0/24"],
)
self.assertEqual(
uncertain.exception.error_code, "vpc_private_result_uncertain")
self.assertTrue(domain.running)
def test_remove_private_interface_repairs_absent_nic_stale_metadata_and_seed(self):
from virsh_panel.cloud_init import read_seed_network
(service, created, domain, seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=False)
result = service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertTrue(result["removed"])
self.assertFalse(result["already_absent"])
self.assertEqual(result["readback"], "confirmed")
self.assertIsNone(self.service._private_interface_from_root(
domain.inactive_root))
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
self.assertFalse(any(
key.startswith("private-") for key in managed.attrib))
observed_seed = read_seed_network(bytes(seed.contents))
self.assertNotIn("private_ip_cidr", observed_seed)
self.assertNotIn("private_mac", observed_seed)
self.assertNotIn("private_routes", observed_seed)
def test_remove_private_interface_start_during_seed_write_is_uncertain(self):
(service, created, domain, seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
original_upload = service._upload_volume
uploads = 0
def upload_then_start(connection, volume, chunks, size):
nonlocal uploads
original_upload(connection, volume, chunks, size)
uploads += 1
if uploads == 1:
domain.live_root = copy.deepcopy(domain.inactive_root)
domain.running = True
with patch.object(service, "_upload_volume",
side_effect=upload_then_start):
with self.assertRaises(self.error_type) as uncertain:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertEqual(
uncertain.exception.error_code,
"vpc_private_remove_uncertain",
)
self.assertTrue(domain.running)
self.assertEqual(uploads, 1)
# Do not report removal or roll back persistent/seed state while the
# guest may already be consuming the crossed configuration.
self.assertIsNone(self.service._private_interface_from_root(
domain.inactive_root))
self.assertGreater(len(seed.contents), 0)
def test_remove_upload_error_after_start_skips_rollback_mutations(self):
(service, created, domain, _seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
original_upload = service._upload_volume
uploads = 0
def upload_then_start_and_fail(connection, volume, chunks, size):
nonlocal uploads
uploads += 1
original_upload(connection, volume, chunks, size)
domain.live_root = copy.deepcopy(domain.inactive_root)
domain.running = True
raise FakeLibvirtError("seed upload response lost after start")
define_count = len(self.backend.define_xmls)
with patch.object(service, "_upload_volume",
side_effect=upload_then_start_and_fail):
with self.assertRaises(self.error_type) as uncertain:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertEqual(
uncertain.exception.error_code,
"vpc_private_remove_uncertain",
)
self.assertTrue(domain.running)
self.assertEqual(uploads, 1)
# The one forward define committed before the upload. A rollback must
# not issue a second define after the guest has started.
self.assertEqual(len(self.backend.define_xmls), define_count + 1)
def test_remove_private_interface_retries_define_committed_seed_stale(self):
from virsh_panel.cloud_init import read_seed_network
(service, created, domain, seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
original_define = FakeConnection.defineXML
def commit_then_lose_response(connection, xml):
original_define(connection, xml)
raise FakeLibvirtError("define response lost")
with patch.object(
FakeConnection, "defineXML", commit_then_lose_response):
with self.assertRaises(self.error_type) as uncertain:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertEqual(
uncertain.exception.error_code, "vpc_private_remove_uncertain")
self.assertIsNone(self.service._private_interface_from_root(
domain.inactive_root))
self.assertIn(
"private_ip_cidr", read_seed_network(bytes(seed.contents)))
result = service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertTrue(result["removed"])
self.assertFalse(result["already_absent"])
self.assertNotIn(
"private_ip_cidr", read_seed_network(bytes(seed.contents)))
def test_remove_private_interface_rejects_unowned_stale_seed_identity(self):
from virsh_panel.cloud_init import read_seed_network
(service, created, domain, seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=False)
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
for key in tuple(managed.attrib):
if key.startswith("private-"):
managed.attrib.pop(key)
with self.assertRaises(self.error_type) as conflict:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr="10.20.0.99/32",
)
self.assertEqual(
conflict.exception.error_code, "vpc_private_interface_conflict")
self.assertEqual(
read_seed_network(bytes(seed.contents))["private_ip_cidr"],
private_ip_cidr,
)
def test_remove_legacy_seed_policy_is_stable_conflict_without_mutation(self):
from virsh_panel.cloud_init import _build_seed_iso, _read_seed_files
(service, created, domain, seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
files = _read_seed_files(bytes(seed.contents))
prefix = b"#cloud-config\n"
user_data = json.loads(files["user-data"][len(prefix):])
user_data.pop("updates", None)
metadata = json.loads(files["meta-data"])
metadata.pop("virt-cloud-network-policy", None)
legacy_seed = _build_seed_iso((
("/USERDATA.;1", "user-data", "/user-data",
prefix + json.dumps(user_data, ensure_ascii=True).encode("ascii")
+ b"\n"),
("/METADATA.;1", "meta-data", "/meta-data",
json.dumps(metadata, ensure_ascii=True).encode("ascii") + b"\n"),
("/NETWORK.;1", "network-config", "/network-config",
files["network-config"]),
))
seed.contents = bytearray(legacy_seed)
seed.capacity = len(legacy_seed)
old_xml = domain.XMLDesc(1)
define_count = len(self.backend.define_xmls)
with patch.object(
service, "_upload_volume",
wraps=service._upload_volume) as upload:
with self.assertRaises(self.error_type) as migration:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertEqual(migration.exception.status, 409)
self.assertEqual(
migration.exception.error_code,
"vpc_seed_network_policy_migration_required",
)
self.assertEqual(domain.XMLDesc(1), old_xml)
self.assertEqual(bytes(seed.contents), legacy_seed)
self.assertEqual(len(self.backend.define_xmls), define_count)
upload.assert_not_called()
def test_remove_private_interface_rejects_nic_owner_or_mac_mismatch(self):
(service, created, domain, seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
private = self.service._private_interface_from_root(
domain.inactive_root)
old_seed = bytes(seed.contents)
managed.set("private-vpc-id", "vpc-foreign")
with self.assertRaises(self.error_type) as wrong_owner:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertEqual(
wrong_owner.exception.error_code,
"vpc_private_interface_conflict",
)
managed.set("private-vpc-id", "vpc-delete-test")
private.find("mac").set("address", "52:54:00:12:34:59")
with self.assertRaises(self.error_type) as wrong_mac:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertEqual(
wrong_mac.exception.error_code,
"vpc_private_interface_conflict",
)
self.assertEqual(bytes(seed.contents), old_seed)
def test_remove_private_interface_confirms_all_layers_already_absent(self):
service, created, _spec, domain, _seed_name = (
self.cloud_vm_with_real_seed())
domain.running = False
domain.live_root = None
resources = types.SimpleNamespace(bridge="vcbr-private")
with patch.object(
service, "_download_seed_volume",
wraps=service._download_seed_volume) as download:
result = service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac="52:54:00:12:34:57",
expected_private_ip_cidr="10.20.0.10/32",
)
self.assertTrue(result["removed"])
self.assertTrue(result["already_absent"])
self.assertEqual(result["readback"], "confirmed")
# One preflight read plus one post-operation exact absence readback.
self.assertEqual(download.call_count, 2)
def test_remove_private_interface_accepts_missing_owned_seed_only_when_xml_clean(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
domain.running = False
domain.live_root = None
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
managed.attrib.pop("seed-volume")
devices = domain.inactive_root.find("./devices")
for cdrom in tuple(
devices.findall("./disk[@device='cdrom']")):
devices.remove(cdrom)
result = service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=types.SimpleNamespace(bridge="vcbr-private"),
desired_revision=2, desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac="52:54:00:12:34:57",
expected_private_ip_cidr="10.20.0.10/32",
)
self.assertTrue(result["removed"])
self.assertTrue(result["already_absent"])
self.assertEqual(result["readback"], "confirmed")
def test_remove_private_interface_rejects_unowned_cdrom_as_absence_proof(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
domain.running = False
domain.live_root = None
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
managed.attrib.pop("seed-volume")
with self.assertRaises(self.error_type) as missing:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=types.SimpleNamespace(bridge="vcbr-private"),
desired_revision=2, desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac="52:54:00:12:34:57",
expected_private_ip_cidr="10.20.0.10/32",
)
self.assertEqual(missing.exception.error_code, "vpc_seed_missing")
def test_remove_private_interface_rolls_back_define_when_seed_upload_fails(self):
(service, created, domain, seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
old_xml = domain.XMLDesc(1)
old_seed = bytes(seed.contents)
original_upload = service._upload_volume
attempts = 0
def fail_first_upload(connection, volume, chunks, size):
nonlocal attempts
attempts += 1
if attempts == 1:
volume.contents = bytearray(b"partial-seed-write")
raise FakeLibvirtError("seed upload failed")
return original_upload(connection, volume, chunks, size)
with patch.object(
service, "_upload_volume",
side_effect=fail_first_upload):
with self.assertRaises(self.error_type) as uncertain:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertEqual(
uncertain.exception.error_code,
"vpc_private_remove_uncertain",
)
self.assertEqual(attempts, 2)
self.assertEqual(domain.XMLDesc(1), old_xml)
self.assertEqual(bytes(seed.contents), old_seed)
def test_remove_private_interface_rollback_define_none_is_uncertain(self):
(service, created, domain, seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
old_xml = domain.XMLDesc(1)
old_seed = bytes(seed.contents)
original_define = FakeConnection.defineXML
defines = 0
uploads = 0
def none_rollback_define(connection, xml):
nonlocal defines
defines += 1
if defines == 1:
return original_define(connection, xml)
return None
def fail_forward_upload(_connection, volume, _chunks, _size):
nonlocal uploads
uploads += 1
volume.contents = bytearray(b"partial-seed-write")
raise FakeLibvirtError("seed upload failed")
with patch.object(
FakeConnection, "defineXML",
new=none_rollback_define), patch.object(
service, "_upload_volume",
side_effect=fail_forward_upload):
with self.assertRaises(self.error_type) as uncertain:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertEqual(
uncertain.exception.error_code,
"vpc_private_remove_uncertain",
)
self.assertEqual(defines, 2)
self.assertEqual(uploads, 1)
self.assertNotEqual(domain.XMLDesc(1), old_xml)
self.assertNotEqual(bytes(seed.contents), old_seed)
def test_remove_private_interface_rollback_seed_failure_is_uncertain(self):
(service, created, domain, seed, resources,
private_mac, private_ip_cidr) = self.cloud_vm_with_private_artifacts(
include_private_nic=True)
old_xml = domain.XMLDesc(1)
old_seed = bytes(seed.contents)
original_upload = service._upload_volume
uploads = 0
def fail_forward_and_restore_upload(
connection, volume, chunks, size,
):
nonlocal uploads
uploads += 1
if uploads == 1:
volume.contents = bytearray(b"partial-seed-write")
raise FakeLibvirtError("seed upload failed")
if uploads == 2:
raise FakeLibvirtError("rollback seed upload failed")
return original_upload(connection, volume, chunks, size)
with patch.object(
service, "_upload_volume",
side_effect=fail_forward_and_restore_upload):
with self.assertRaises(self.error_type) as uncertain:
service.remove_private_interface(
created["uuid"], vpc_id="vpc-delete-test",
resources=resources, desired_revision=2,
desired_digest="b" * 64,
expected_member_id="member-delete-test",
expected_private_mac=private_mac,
expected_private_ip_cidr=private_ip_cidr,
)
self.assertEqual(
uncertain.exception.error_code,
"vpc_private_remove_uncertain",
)
self.assertEqual(uploads, 2)
self.assertEqual(domain.XMLDesc(1), old_xml)
self.assertNotEqual(bytes(seed.contents), old_seed)
def test_vpc_member_stop_proof_rejects_running_and_managed_save(self):
vm = self.service.create_vm(self.spec())
domain = self.backend.domains[0]
with self.assertRaises(self.error_type) as running:
self.service.require_vpc_members_stopped([vm["uuid"]])
self.assertEqual(
running.exception.error_code, "vpc_member_requires_stopped")
domain.running = False
domain.live_root = None
self.service.require_vpc_members_stopped([vm["uuid"]])
domain.managed_save_image = True
with self.assertRaises(self.error_type) as managed_save:
self.service.require_vpc_members_stopped([vm["uuid"]])
self.assertEqual(
managed_save.exception.error_code, "vpc_member_requires_stopped")
def test_vpc_member_stop_proof_fails_closed_on_managed_save_read_error(self):
vm = self.service.create_vm(self.spec())
domain = self.backend.domains[0]
domain.running = False
domain.live_root = None
for managed_save_reader in (
None,
Mock(side_effect=FakeLibvirtError("managed save unavailable")),
):
with self.subTest(reader=managed_save_reader), patch.object(
domain, "hasManagedSaveImage", managed_save_reader), \
self.assertRaises(self.error_type) as unavailable:
self.service.require_vpc_members_stopped([vm["uuid"]])
self.assertEqual(
unavailable.exception.error_code,
"vpc_member_power_unavailable",
)
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.list_vm_states([vm["uuid"]]), [{
"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_list_vms_skips_domain_removed_after_enumeration(self):
self.service.create_vm(self.spec(name="first-vm"))
self.service.create_vm(self.spec(name="second-vm"))
disappearing = self.backend.domains[0]
def disappear():
self.backend.domains.remove(disappearing)
raise FakeLibvirtError("domain disappeared", 42)
disappearing.info = disappear
rows = self.service.list_vms()
self.assertEqual([row["name"] for row in rows], ["second-vm"])
self.assertEqual(len(self.backend.domains), 1)
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.assertTrue(self.service.action(vm["uuid"], "start")["command_accepted"])
self.assertEqual(self.service.get_vm(vm["uuid"])["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.assertEqual(
root.find("./os/firmware/feature[@name='secure-boot']").get("enabled"),
"no",
)
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(
final_root.find("./os/firmware/feature[@name='secure-boot']").get("enabled"),
"no",
)
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"])
metadata_flags = (
self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_MANAGED_SAVE
| self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA
| self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_CHECKPOINTS_METADATA
)
self.assertEqual(
self.backend.undefine_flags,
[metadata_flags
| self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_NVRAM],
)
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"), {
"uuid": vm_uuid, "action": "reset", "command_accepted": True,
})
self.assertEqual(self.service.get_vm(vm_uuid)["state"], "running")
self.assertEqual(self.backend.domains[0].last_reset_flags, 0)
self.assertEqual(self.service.action(vm_uuid, "reboot"), {
"uuid": vm_uuid, "action": "reboot", "command_accepted": True,
})
self.assertEqual(self.service.get_vm(vm_uuid)["state"], "shutoff")
self.assertEqual(self.service.action(vm_uuid, "start"), {
"uuid": vm_uuid, "action": "start", "command_accepted": True,
})
self.assertEqual(self.service.get_vm(vm_uuid)["state"], "running")
self.assertEqual(self.service.action(vm_uuid, "shutdown"), {
"uuid": vm_uuid, "action": "shutdown", "command_accepted": True,
})
self.assertEqual(self.service.get_vm(vm_uuid)["state"], "shutoff")
with self.assertRaises(self.error_type):
self.service.console_port(vm_uuid)
self.assertEqual(self.service.action(vm_uuid, "start"), {
"uuid": vm_uuid, "action": "start", "command_accepted": True,
})
self.assertEqual(self.service.get_vm(vm_uuid)["state"], "running")
self.assertEqual(self.service.action(vm_uuid, "poweroff"), {
"uuid": vm_uuid, "action": "poweroff", "command_accepted": True,
})
self.assertEqual(self.service.get_vm(vm_uuid)["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_shutdown_receipt_does_not_require_shutoff_and_allows_forceoff(self):
vm = self.service.create_vm(self.spec())
self.backend.shutdown_stalls = True
result = self.service.action(vm["uuid"], "shutdown")
self.assertEqual(result, {
"uuid": vm["uuid"], "action": "shutdown", "command_accepted": True,
})
self.assertTrue(self.backend.domains[0].isActive())
self.assertEqual(self.backend.shutdown_calls, 1)
# A graceful request is not sufficient proof for destructive cleanup.
with self.assertRaises(self.error_type) as deletion:
self.service.delete_vm(vm["uuid"], True)
self.assertEqual(deletion.exception.status, 409)
self.assertTrue(self.backend.pools["images"].volumes)
forced = self.service.action(vm["uuid"], "poweroff")
self.assertTrue(forced["command_accepted"])
self.assertFalse(self.backend.domains[0].isActive())
self.assertEqual(self.backend.destroy_calls, 1)
def test_power_receipts_do_not_depend_on_postreads_or_guest_agent(self):
for action in ("start", "shutdown", "reboot", "poweroff", "reset"):
with self.subTest(action=action):
service = self.service.__class__(
self.service.uri, "images", "iso", "default")
vm = service.create_vm(self.spec(name=f"receipt-{action}"))
domain = self.backend.domains[-1]
if action == "start":
domain.shutdown()
method = {"start": "create", "poweroff": "destroy"}.get(action, action)
original = getattr(domain, method)
invoked = False
original_active = domain.isActive
def preflight_active_only():
if invoked:
raise FakeLibvirtError("post-command state unavailable")
return original_active()
def issue_command(*args):
nonlocal invoked
original(*args)
invoked = True
with (
patch.object(domain, method, side_effect=issue_command) as command,
patch.object(domain, "isActive", side_effect=preflight_active_only),
patch.object(domain, "info", side_effect=FakeLibvirtError(
"domain status unavailable")) as info,
patch.object(domain, "XMLDesc", side_effect=FakeLibvirtError(
"domain XML unavailable")) as xml,
patch.object(domain, "interfaceAddresses", side_effect=FakeLibvirtError(
"guest agent unavailable")) as guest_addresses,
patch.object(self.service_module.libvirt_qemu,
"qemuAgentCommand", side_effect=FakeLibvirtError(
"guest agent unavailable")) as guest_exec,
):
result = service.action(vm["uuid"], action)
self.assertEqual(result, {
"uuid": vm["uuid"], "action": action, "command_accepted": True,
})
command.assert_called_once_with(*((0,) if action == "reset" else ()))
info.assert_not_called()
xml.assert_not_called()
guest_addresses.assert_not_called()
guest_exec.assert_not_called()
def test_power_action_does_not_infer_lost_receipt_from_current_state(self):
for action in ("start", "shutdown", "reboot", "poweroff", "reset"):
with self.subTest(action=action):
service = self.service.__class__(
self.service.uri, "images", "iso", "default")
vm = service.create_vm(self.spec(name=f"lost-{action}"))
domain = self.backend.domains[-1]
if action == "start":
domain.shutdown()
method = {"start": "create", "poweroff": "destroy"}.get(action, action)
original = getattr(domain, method)
def commit_then_lose_response(*args):
original(*args)
raise FakeLibvirtError("transport response lost")
with (
patch.object(domain, method, side_effect=commit_then_lose_response) as command,
patch.object(domain, "info", side_effect=FakeLibvirtError(
"post-command state unavailable")) as info,
):
with self.assertRaises(self.error_type) as raised:
service.action(vm["uuid"], action)
self.assertEqual(raised.exception.status, 502)
self.assertEqual(raised.exception.error_code, "power_action_result_uncertain")
command.assert_called_once_with(*((0,) if action == "reset" else ()))
info.assert_not_called()
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_expiry_suspend_targets_do_not_interrupt_active_snapshot_backup(self):
vm = self.service.create_vm(self.spec())
domain = self.backend.domains[0]
original_job_stats = domain.jobStats
domain.jobStats = lambda flags: {
"type": 1,
"operation": self.backend.job_operation_backup,
} if flags == 0 else original_job_stats(flags)
before_xml = domain.XMLDesc(0)
with self.assertRaises(self.error_type) as service_error:
self.service.service_suspend(vm["uuid"])
with self.assertRaises(self.error_type) as network_error:
self.service.network_suspend(vm["uuid"])
self.assertEqual(service_error.exception.status, 409)
self.assertEqual(network_error.exception.status, 409)
self.assertTrue(domain.isActive())
self.assertTrue(domain.autostart())
self.assertEqual(self.backend.shutdown_calls, 0)
self.assertEqual(self.backend.device_updates, [])
self.assertEqual(domain.XMLDesc(0), before_xml)
def test_expiry_suspend_uses_legacy_job_info_when_job_stats_is_missing(self):
vm = self.service.create_vm(self.spec())
domain = self.backend.domains[0]
domain.jobStats = None
domain.jobInfo = lambda: (
self.backend.job_none, 0, 0, 0, 0, 0, 0, 0,
)
suspended = self.service.network_suspend(vm["uuid"])
self.assertTrue(suspended["network_suspended"])
self.service.network_resume(vm["uuid"])
domain.jobInfo = lambda: (1, 0, 0, 0, 0, 0, 0, 0)
with self.assertRaises(self.error_type) as active:
self.service.service_suspend(vm["uuid"])
self.assertEqual(active.exception.status, 409)
self.assertTrue(domain.isActive())
self.assertTrue(domain.autostart())
self.assertEqual(self.backend.shutdown_calls, 0)
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"], [])
metadata_flags = (
self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_MANAGED_SAVE
| self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA
| self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_CHECKPOINTS_METADATA
)
self.assertEqual(
self.backend.undefine_flags,
[metadata_flags
| self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_KEEP_NVRAM],
)
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
self.assertFalse(self.backend.domains)
def test_delete_removes_managed_save_and_domain_metadata(self):
vm = self.service.create_vm(self.spec())
self.service.action(vm["uuid"], "shutdown")
domain = self.backend.domains[0]
domain.managed_save_image = True
domain.checkpoints = 1
result = self.service.delete_vm(vm["uuid"], False)
self.assertTrue(result["deleted"])
self.assertEqual(
self.backend.undefine_flags,
[
self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_MANAGED_SAVE
| self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA
| self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_KEEP_NVRAM
| self.service_module.libvirt.VIR_DOMAIN_UNDEFINE_CHECKPOINTS_METADATA
],
)
self.assertFalse(self.backend.domains)
def test_delete_refuses_libvirt_native_snapshots_before_undefine(self):
for delete_disks in (False, True):
with self.subTest(delete_disks=delete_disks):
service = self.service.__class__(
self.service.uri, "images", "iso", "default")
vm = service.create_vm(
self.spec(name=f"native-snapshot-{delete_disks}"))
service.action(vm["uuid"], "shutdown")
domain = next(
item for item in self.backend.domains
if item.UUIDString() == vm["uuid"]
)
domain.snapshots = 1
before_volumes = set(self.backend.pools["images"].volumes)
with self.assertRaises(self.error_type) as raised:
service.delete_vm(vm["uuid"], delete_disks)
self.assertEqual(raised.exception.status, 409)
self.assertEqual(
raised.exception.error_code,
"vm_native_snapshot_present",
)
self.assertEqual(self.backend.undefine_flags, [])
self.assertIn(vm["uuid"], [
item.UUIDString() for item in self.backend.domains
])
self.assertEqual(
set(self.backend.pools["images"].volumes), before_volumes)
def test_disk_deletion_rejects_backing_image_reference(self):
vm = self.service.create_vm(self.spec())
self.service.action(vm["uuid"], "shutdown")
other_xml = ET.fromstring(self.backend.domains[0].XMLDesc(0))
other_xml.find("uuid").text = str(uuid.uuid4())
other_xml.find("name").text = "clone-vm"
disk = other_xml.find("./devices/disk[@device='disk']")
disk.set("type", "volume")
disk.find("source").attrib = {"pool": "images", "volume": "independent.qcow2"}
backing = ET.SubElement(disk, "backingStore", type="volume")
ET.SubElement(backing, "source", pool="images",
volume="alma-test.qcow2")
self.backend.domains.append(FakeDomain(self.backend, ET.tostring(other_xml)))
with self.assertRaises(self.error_type) as shared:
self.service.delete_vm(vm["uuid"], True)
self.assertEqual(shared.exception.status, 409)
def test_disk_deletion_rejects_nested_data_store_reference(self):
vm = self.service.create_vm(self.spec())
self.service.action(vm["uuid"], "shutdown")
other_xml = ET.fromstring(self.backend.domains[0].XMLDesc(0))
other_xml.find("uuid").text = str(uuid.uuid4())
other_xml.find("name").text = "data-store-vm"
source = other_xml.find("./devices/disk[@device='disk']/source")
source.attrib = {"file": "/var/lib/libvirt/images/independent.qcow2"}
data_store = ET.SubElement(source, "dataStore", type="file")
ET.SubElement(data_store, "source",
file="/var/lib/libvirt/images/alma-test.qcow2")
self.backend.domains.append(FakeDomain(self.backend, ET.tostring(other_xml)))
with self.assertRaises(self.error_type) as shared:
self.service.delete_vm(vm["uuid"], True)
self.assertEqual(shared.exception.status, 409)
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
self.assertEqual(len(self.backend.domains), 2)
def test_disk_deletion_rejects_nested_mirror_reference(self):
vm = self.service.create_vm(self.spec())
self.service.action(vm["uuid"], "shutdown")
other_xml = ET.fromstring(self.backend.domains[0].XMLDesc(0))
other_xml.find("uuid").text = str(uuid.uuid4())
other_xml.find("name").text = "mirror-vm"
source = other_xml.find("./devices/disk[@device='disk']/source")
source.attrib = {"file": "/var/lib/libvirt/images/independent.qcow2"}
mirror = ET.SubElement(other_xml.find("./devices/disk[@device='disk']"),
"mirror", type="file")
ET.SubElement(mirror, "source",
file="/var/lib/libvirt/images/alma-test.qcow2")
self.backend.domains.append(FakeDomain(self.backend, ET.tostring(other_xml)))
with self.assertRaises(self.error_type) as shared:
self.service.delete_vm(vm["uuid"], True)
self.assertEqual(shared.exception.status, 409)
self.assertIn("alma-test.qcow2", self.backend.pools["images"].volumes)
self.assertEqual(len(self.backend.domains), 2)
def test_cloud_vm_uses_panel_reserved_uuid_for_credential_binding(self):
service = self.cloud_service()
reserved_uuid = str(uuid.uuid4())
created = self.create_cloud_vm(service, self.cloud_spec(vm_uuid=reserved_uuid))
self.assertEqual(created["uuid"], reserved_uuid)
self.assertEqual(created["credential_generation"],
f"panel-seed-{reserved_uuid}.iso")
self.assertEqual(created["disks"][0]["capacity_gib"], 20)
resource_name = f"vc-{uuid.UUID(reserved_uuid).hex[:16]}"
self.assertEqual(self.backend.domains[0].name(), resource_name)
self.assertIn(f"{resource_name}.qcow2", self.backend.pools["images"].volumes)
self.assertEqual(created["name"], "cloud-vm")
def test_uuid_backed_cloud_vms_can_share_a_display_name(self):
service = self.cloud_service()
first_uuid = "14d9bb2f-65cd-4406-a377-90685c0690e4"
second_uuid = "24d9bb2f-65cd-4406-a377-90685c0690e4"
first = self.create_cloud_vm(
service, self.cloud_spec(vm_uuid=first_uuid))
second = self.create_cloud_vm(service, self.cloud_spec(
vm_uuid=second_uuid,
public_ip_cidr="8.8.8.19/24",
))
self.assertEqual(first["name"], "cloud-vm")
self.assertEqual(second["name"], "cloud-vm")
resource_names = {domain.name() for domain in self.backend.domains}
self.assertEqual(resource_names, {
"vc-14d9bb2f65cd4406",
"vc-24d9bb2f65cd4406",
})
pool_names = set(self.backend.pools["images"].volumes)
self.assertIn("vc-14d9bb2f65cd4406.qcow2", pool_names)
self.assertIn("vc-24d9bb2f65cd4406.qcow2", pool_names)
def test_cloud_vm_accepts_almalinux_9_panel_template_volume(self):
service = self.cloud_service()
alma9_volume = "panel-template-alma9-12345678-0123456789abcdef.qcow2"
self.backend.pools["images"].volumes[alma9_volume] = FakeVolume(
self.backend.pools["images"], alma9_volume, capacity=2 * 1024**3,
)
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED",
create=True) as seed_builder:
created = service.create_cloud_vm(
self.cloud_spec(os_name="AlmaLinux 9"), alma9_volume,
)
self.assertFalse(seed_builder.call_args.kwargs["debian12_network_fix"])
self.assertEqual(created["os_name"], "AlmaLinux 9")
self.assertEqual(self.backend.pools["images"].volumes["cloud-vm.qcow2"].cloned_from,
alma9_volume)
def test_debian_12_cloud_vm_seed_uses_cloud_init_network_fix(self):
service = self.cloud_service()
self.backend.pools["images"].volumes[DEBIAN_12_TEMPLATE_NAME] = FakeVolume(
self.backend.pools["images"], DEBIAN_12_TEMPLATE_NAME,
capacity=2 * 1024**3,
)
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED",
create=True) as seed_builder:
service.create_cloud_vm(
self.cloud_spec(os_name="Debian 12"), DEBIAN_12_TEMPLATE_NAME,
)
self.assertTrue(seed_builder.call_args.kwargs["debian12_network_fix"])
def test_cloud_vm_accepts_generated_template_replica_volume(self):
service = self.cloud_service()
self.backend.pools["images"].volumes[TEMPLATE_REPLICA_ONE] = FakeVolume(
self.backend.pools["images"], TEMPLATE_REPLICA_ONE,
capacity=2 * 1024**3,
)
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED",
create=True):
service.create_cloud_vm(self.cloud_spec(), TEMPLATE_REPLICA_ONE)
self.assertEqual(
self.backend.pools["images"].volumes["cloud-vm.qcow2"].cloned_from,
TEMPLATE_REPLICA_ONE,
)
def test_cloud_vm_clones_template_and_uses_nonboot_seed_iso(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec(os_name="AlmaLinux 10"))
self.assertEqual(created["state"], "running")
self.assertEqual(created["name"], "cloud-vm")
self.assertTrue(created["autostart"])
self.assertEqual(self.backend.domain_autostart_changed, [created["uuid"]])
pool = self.backend.pools["images"]
self.assertIn(TEMPLATE_NAME, pool.volumes)
self.assertEqual(pool.volumes["cloud-vm.qcow2"].cloned_from,
TEMPLATE_NAME)
self.assertEqual(pool.volumes["cloud-vm.qcow2"].capacity, 20 * 1024**3)
root = self.backend.domains[0].root
self.assertEqual([node.get("dev") for node in root.findall("./os/boot")],
["hd"])
self.assertIsNone(root.find("on_reboot"))
self.assertEqual(root.find("./devices/interface").get("type"), "bridge")
self.assertEqual(root.find("./devices/interface/source").get("bridge"), "br0")
self.assertEqual(root.find("./devices/interface/driver").get("queues"), "4")
mac = root.find("./devices/interface/mac").get("address")
self.assertRegex(mac, r"^([0-9a-f]{2}:){5}[0-9a-f]{2}$")
self.assertEqual(root.find("./devices/interface")[0].tag, "mac")
cdroms = root.findall("./devices/disk[@device='cdrom']")
self.assertEqual(len(cdroms), 1)
self.assertIsNotNone(cdroms[0].find("readonly"))
seed_path = cdroms[0].find("source").get("file")
self.assertTrue(seed_path.startswith("/var/lib/libvirt/images/"))
self.assertTrue(seed_path.endswith(".iso"))
seed_name = seed_path.rsplit("/", 1)[-1]
self.assertIn(seed_name, pool.volumes)
self.assertGreater(len(pool.volumes[seed_name].contents), 0)
self.assertTrue(self.backend.streams[-1].finished)
managed = root.find("./metadata/{urn:virsh-panel:1}managed")
self.assertEqual(managed.get("disk-volume"), "cloud-vm.qcow2")
self.assertEqual(managed.get("seed-volume"), seed_name)
self.assertEqual(managed.get("public-ip-cidr"), "8.8.8.18/24")
self.assertEqual(managed.get("public-pool-key"), "a" * 32)
self.assertEqual(created["public_ip_cidr"], "8.8.8.18/24")
self.assertEqual(created["public_pool_key"], "a" * 32)
self.assertEqual(managed.get("os-source"), "cloud_template")
self.assertEqual(managed.get("os-name"), "AlmaLinux 10")
self.assertEqual(managed.get("created-at"), created["created_at"])
self.assertRegex(created["created_at"], r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$")
self.assertEqual(created["os_name"], "AlmaLinux 10")
self.assertEqual(created["os_source"], "cloud_template")
metadata = service.list_vm_metadata([created["uuid"]])[0]
self.assertEqual(metadata["public_ip_cidr"], "8.8.8.18/24")
self.assertEqual(metadata["public_pool_key"], "a" * 32)
self.assertEqual(metadata["os_name"], "AlmaLinux 10")
self.assertEqual(metadata["os_source"], "cloud_template")
self.assertEqual(metadata["login_name"], "root")
self.assertEqual(metadata["disks"], [{"capacity_gib": 20}])
self.assertNotIn("source", metadata["disks"][0])
self.assertEqual(self.backend.opened, self.backend.closed)
def test_reinstall_to_debian_12_seed_uses_cloud_init_network_fix(self):
(service, created, spec, _domain,
_old_seed_name) = self.cloud_vm_with_real_seed()
pool = self.backend.pools["images"]
pool.volumes[DEBIAN_12_TEMPLATE_NAME] = FakeVolume(
pool, DEBIAN_12_TEMPLATE_NAME, capacity=2 * 1024**3,
)
with patch.object(self.service_module, "build_seed_iso", return_value=b"SEED",
create=True) as seed_builder:
service.reinstall_cloud_vm(
created["uuid"], DEBIAN_12_TEMPLATE_NAME,
os_name="Debian 12",
ssh_public_key=spec["guest_ssh_public_key"],
)
self.assertTrue(seed_builder.call_args.kwargs["debian12_network_fix"])
def test_cloud_vm_delete_disks_removes_clone_and_seed_but_keeps_template(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
root = self.backend.domains[0].root
seed_name = root.find("./metadata/{urn:virsh-panel:1}managed").get("seed-volume")
service.action(created["uuid"], "shutdown")
deleted = service.delete_vm(created["uuid"], True)
self.assertEqual(set(deleted["deleted_disks"]), {"cloud-vm.qcow2", seed_name})
self.assertEqual(set(self.backend.pools["images"].volumes),
{TEMPLATE_NAME})
def test_delete_volume_failure_is_committed_and_cleanup_is_idempotent(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
service.action(created["uuid"], "shutdown")
manifest = service.delete_vm_cleanup_manifest(created["uuid"])
root_name = manifest["primary_volume"]
root = self.backend.pools["images"].volumes[root_name]
def fail_delete(flags):
raise FakeLibvirtError("injected delete failure")
root.delete = fail_delete
with self.assertRaises(self.error_type) as failed:
service.delete_vm(created["uuid"], True)
self.assertEqual(failed.exception.status, 503)
self.assertEqual(
failed.exception.error_code, "vm_delete_volume_cleanup_pending")
self.assertNotIn(created["uuid"], [
domain.UUIDString() for domain in self.backend.domains])
self.assertIn(root_name, self.backend.pools["images"].volumes)
# A later reconciliation uses the persisted identity and does not
# require the domain definition to exist again.
root.delete = FakeVolume.delete.__get__(root, FakeVolume)
cleaned = service.cleanup_deleted_vm_volumes(
created["uuid"], manifest)
self.assertIn(root_name, cleaned["deleted"])
self.assertEqual(set(self.backend.pools["images"].volumes),
{TEMPLATE_NAME})
def test_delete_cleanup_accepts_random_reinstall_seed_name(self):
vm_uuid = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
seed_name = "panel-seed-11111111-2222-4333-8444-555555555555.iso"
self.assertEqual(
self.service._validate_delete_cleanup_volume_name(
vm_uuid, seed_name, seed=True),
seed_name,
)
for invalid in (
f"panel-seed-{vm_uuid}.img",
"panel-seed-not-a-uuid.iso",
"panel-seed-11111111-2222-4333-8444-555555555555.iso/escape",
"panel-seed-11111111-2222-4333-8444-555555555555.ISO",
):
with self.subTest(invalid=invalid), self.assertRaises(self.error_type):
self.service._validate_delete_cleanup_volume_name(
vm_uuid, invalid, seed=True)
def test_delete_cleanup_reconciles_random_reinstall_seed_after_undefine(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
domain = self.backend.domains[0]
pool = self.backend.pools["images"]
managed_path = f"./metadata/{{{self.service_module.PANEL_NS}}}managed"
managed = domain.root.find(managed_path)
old_name = managed.get("seed-volume")
seed_name = "panel-seed-11111111-2222-4333-8444-555555555555.iso"
seed = pool.volumes.pop(old_name)
seed._name = seed_name
pool.volumes[seed_name] = seed
for root in (domain.live_root, domain.inactive_root):
root.find(managed_path).set("seed-volume", seed_name)
root.find("./devices/disk[@device='cdrom']/source").set(
"file", seed.path())
service.action(created["uuid"], "shutdown")
manifest = service.delete_vm_cleanup_manifest(created["uuid"])
self.assertEqual(manifest["seed_volume"], seed_name)
original_delete = seed.delete
def fail_delete(flags):
raise FakeLibvirtError("injected seed delete failure")
seed.delete = fail_delete
try:
with self.assertRaises(self.error_type) as failed:
service.delete_vm(created["uuid"], True)
self.assertEqual(
failed.exception.error_code,
"vm_delete_volume_cleanup_pending",
)
finally:
seed.delete = original_delete
self.assertFalse(self.backend.domains)
cleaned = service.cleanup_deleted_vm_volumes(
created["uuid"], manifest)
self.assertIn(seed_name, cleaned["deleted"])
self.assertIn(manifest["primary_volume"], cleaned["deleted"])
self.assertEqual(set(pool.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)
self.assertEqual(set(self.backend.nwfilters), {"clean-traffic"})
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)
self.assertEqual(set(self.backend.nwfilters), {"clean-traffic"})
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])
self.assertEqual(set(self.backend.nwfilters), {"clean-traffic"})
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, [])
self.assertEqual(set(self.backend.nwfilters), {"clean-traffic"})
def test_cloud_vm_reports_incomplete_rollback_when_filter_cleanup_fails(self):
service = self.cloud_service()
self.backend.fail_domain_autostart = True
self.backend.fail_nwfilter_undefine = 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.assertFalse(self.backend.domains)
self.assertEqual(set(self.backend.pools["images"].volumes), {TEMPLATE_NAME})
self.assertEqual(len(self.backend.nwfilters), 2)
def test_reinstall_keeps_original_public_network_and_deletes_old_disk_only_after_start(self):
from virsh_panel.cloud_init import read_seed_network
platform_snapshot = self.platform_snapshot(self.test_platform_rule())
service, created, spec, domain, old_seed_name = self.cloud_vm_with_real_seed(
platform_network_policy_snapshot=platform_snapshot)
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)
policy_node = root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed/"
f"{{{self.service_module.PANEL_NS}}}platform-policy"
)
self.assertEqual(policy_node.get("digest"), platform_snapshot["digest"])
self.assertEqual(json.loads(policy_node.text), platform_snapshot)
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.assertEqual(result["status"], "uncertain")
self.assertEqual(result["error_code"], "reinstall_result_uncertain")
self.assertTrue(result["reinstall_committed"])
self.assertTrue(result["cleanup_pending"])
self.assertEqual(result["credential_generation"],
domain.root.find(
"./metadata/{urn:virsh-panel:1}managed"
).get("seed-volume"))
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_is_uncertain_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.assertEqual(result["status"], "uncertain")
self.assertEqual(result["error_code"], "reinstall_cleanup_pending")
self.assertEqual(result["error"], "重装已完成,但旧系统盘清理待核对")
self.assertTrue(result["reinstall_committed"])
self.assertTrue(result["cleanup_pending"])
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_progress_callback_failure_does_not_fake_failure(self):
service, created, spec, _domain, _old_seed_name = self.cloud_vm_with_real_seed()
def broken_progress(_phase):
raise RuntimeError("progress store unavailable")
result = service.reinstall_cloud_vm(
created["uuid"], TEMPLATE_NAME,
ssh_public_key=spec["guest_ssh_public_key"],
progress=broken_progress,
)
self.assertEqual(result["vm"]["state"], "running")
self.assertEqual(result["credential_generation"],
result["vm"].get("credential_generation")
or service._vm_xml(_domain).find(
"./metadata/{urn:virsh-panel:1}managed"
).get("seed-volume"))
self.assertNotEqual(result.get("status"), "failed")
def test_reinstall_password_mode_writes_only_hash_to_new_seed(self):
from virsh_panel.cloud_init import hash_root_password
service, created, _spec, domain, _seed_name = self.cloud_vm_with_real_seed()
password = "Another-strong-guest-password-2026"
password_hash = hash_root_password(password)
result = service.reinstall_cloud_vm(
created["uuid"], TEMPLATE_NAME,
root_password_hash=password_hash,
)
self.assertEqual(result["vm"]["state"], "running")
new_seed_name = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed").get("seed-volume")
seed = bytes(self.backend.pools["images"].volumes[new_seed_name].contents)
self.assertIn(password_hash.encode(), seed)
self.assertNotIn(password.encode(), seed)
def test_cloud_vm_can_be_reinstalled_more_than_once(self):
service, created, spec, domain, original_seed = self.cloud_vm_with_real_seed()
pool = self.backend.pools["images"]
service.reinstall_cloud_vm(
created["uuid"], TEMPLATE_NAME,
ssh_public_key=spec["guest_ssh_public_key"],
)
first_managed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
first_disk = first_managed.get("disk-volume")
first_seed = first_managed.get("seed-volume")
self.assertNotEqual(first_seed, original_seed)
second = service.reinstall_cloud_vm(
created["uuid"], TEMPLATE_NAME,
ssh_public_key=spec["guest_ssh_public_key"],
)
second_managed = domain.root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
second_disk = second_managed.get("disk-volume")
second_seed = second_managed.get("seed-volume")
self.assertEqual(second["vm"]["state"], "running")
self.assertEqual(second["vm"]["created_at"], created["created_at"])
self.assertNotEqual(first_disk, second_disk)
self.assertNotEqual(first_seed, second_seed)
self.assertNotIn(first_disk, pool.volumes)
self.assertNotIn(first_seed, pool.volumes)
self.assertEqual(set(pool.volumes), {TEMPLATE_NAME, second_disk, second_seed})
self.assertEqual(self.backend.shutdown_calls, 2)
def test_reinstall_refuses_iso_or_snapshotted_vm_without_shutdown(self):
service, created, spec, domain, _seed_name = self.cloud_vm_with_real_seed()
domain.snapshots = 1
before = set(self.backend.pools["images"].volumes)
with self.assertRaises(self.error_type) as raised:
service.reinstall_cloud_vm(
created["uuid"], TEMPLATE_NAME,
ssh_public_key=spec["guest_ssh_public_key"],
)
self.assertEqual(raised.exception.status, 409)
self.assertEqual(self.backend.shutdown_calls, 0)
self.assertEqual(set(self.backend.pools["images"].volumes), before)
iso_vm = self.service.create_vm(self.spec(name="iso-vm"))
with self.assertRaises(self.error_type):
service.reinstall_cloud_vm(
iso_vm["uuid"], TEMPLATE_NAME,
ssh_public_key=spec["guest_ssh_public_key"],
)
def test_template_import_uploads_new_qcow2_volume_without_overwrite(self):
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "verified.qcow2"
payload = b"QFI\xfb" + b"verified cloud image fixture"
image.write_bytes(payload)
result = self.service.import_template(image, TEMPLATE_NAME, 2 * 1024**3)
self.assertEqual(result["volume_name"], TEMPLATE_NAME)
self.assertEqual(result["image_bytes"], len(payload))
self.assertEqual(bytes(self.backend.pools["images"].volumes[TEMPLATE_NAME].contents),
payload)
self.assertEqual(self.backend.pools["images"].volumes[TEMPLATE_NAME].capacity,
2 * 1024**3)
self.assertTrue(self.backend.streams[-1].finished)
self.assertEqual(self.backend.opened, self.backend.closed)
def test_template_volume_allowlist_supports_each_official_os_family(self):
valid = (
"panel-template-alma8-12345678-0123456789abcdef.qcow2",
"panel-template-debian12-12345678-0123456789abcdef.qcow2",
"panel-template-ubuntu2404-12345678-0123456789abcdef.qcow2",
"panel-template-centosstream9-12345678-0123456789abcdef.qcow2",
"panel-template-centosstream10-12345678-0123456789abcdef-"
"1111111111111111.qcow2",
)
for volume_name in valid:
with self.subTest(volume_name=volume_name):
self.assertIsNotNone(
self.service_module.TEMPLATE_VOLUME_RE.fullmatch(volume_name)
)
for volume_name in (
"panel-template-ubuntu-arm64-12345678-0123456789abcdef.qcow2",
"panel-template-centos8-12345678-0123456789abcdef.qcow2",
"../panel-template-debian12-12345678-0123456789abcdef.qcow2",
):
with self.subTest(volume_name=volume_name):
self.assertIsNone(
self.service_module.TEMPLATE_VOLUME_RE.fullmatch(volume_name)
)
def test_template_import_stream_failure_deletes_only_new_volume(self):
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "verified.qcow2"
image.write_bytes(b"QFI\xfbverified cloud image fixture")
self.backend.fail_send = True
with self.assertRaises(self.error_type):
self.service.import_template(image, TEMPLATE_NAME, 2 * 1024**3)
self.assertNotIn(TEMPLATE_NAME, self.backend.pools["images"].volumes)
self.assertTrue(self.backend.streams[-1].aborted)
self.assertEqual(self.backend.opened, self.backend.closed)
def test_template_import_rejects_wrong_remote_capacity_and_cleans_volume(self):
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "verified.qcow2"
image.write_bytes(b"QFI\xfbverified cloud image fixture")
with patch.object(FakeVolume, "info", return_value=(0, 1024**3, 100, 0)):
with self.assertRaises(self.error_type) as raised:
self.service.import_template(image, TEMPLATE_NAME, 2 * 1024**3)
self.assertEqual(raised.exception.status, 502)
self.assertNotIn(TEMPLATE_NAME, self.backend.pools["images"].volumes)
self.assertEqual(self.backend.opened, self.backend.closed)
def test_template_cache_reuses_only_a_trusted_complete_replica(self):
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "global-template.qcow2"
payload = b"QFI\xfb" + b"global cloud image fixture"
image.write_bytes(payload)
first = self.service.cache_template(
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
)
pool = self.backend.pools["images"]
original = pool.volumes[TEMPLATE_REPLICA_ONE]
trusted = self.service.cache_template(
image, TEMPLATE_REPLICA_TWO, 2 * 1024**3,
trusted_replica_volume_name=TEMPLATE_REPLICA_ONE,
trusted_replica_identity=first["replica_identity"],
)
self.assertTrue(trusted["already_cached"])
self.assertEqual(trusted["volume_name"], TEMPLATE_REPLICA_ONE)
self.assertIs(pool.volumes[TEMPLATE_REPLICA_ONE], original)
self.assertNotIn(TEMPLATE_REPLICA_TWO, pool.volumes)
replaced = self.service.cache_template(
image, TEMPLATE_REPLICA_TWO, 2 * 1024**3,
)
self.assertFalse(first["already_cached"])
self.assertFalse(replaced["already_cached"])
self.assertEqual(replaced["volume_name"], TEMPLATE_REPLICA_TWO)
self.assertIs(pool.volumes[TEMPLATE_REPLICA_ONE], original)
self.assertEqual(bytes(pool.volumes[TEMPLATE_REPLICA_TWO].contents), payload)
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
def test_template_cache_uses_fresh_generation_when_pool_identity_changes(self):
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "global-template.qcow2"
payload = b"QFI\xfb" + b"global cloud image fixture"
image.write_bytes(payload)
first = self.service.cache_template(
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3)
pool = self.backend.pools["images"]
original = pool.volumes[TEMPLATE_REPLICA_ONE]
pool.path = "/srv/redefined-images"
self.backend.existing_dirs.add(pool.path)
replaced = self.service.cache_template(
image, TEMPLATE_REPLICA_TWO, 2 * 1024**3,
trusted_replica_volume_name=TEMPLATE_REPLICA_ONE,
trusted_replica_identity=first["replica_identity"],
)
self.assertFalse(replaced["already_cached"])
self.assertEqual(replaced["volume_name"], TEMPLATE_REPLICA_TWO)
self.assertNotEqual(
replaced["replica_identity"], first["replica_identity"])
self.assertIs(pool.volumes[TEMPLATE_REPLICA_ONE], original)
self.assertIn(TEMPLATE_REPLICA_TWO, pool.volumes)
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
def test_template_cache_rejects_a_recreated_same_name_volume(self):
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "global-template.qcow2"
payload = b"QFI\xfb" + b"global cloud image fixture"
image.write_bytes(payload)
first = self.service.cache_template(
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3)
pool = self.backend.pools["images"]
original = pool.volumes[TEMPLATE_REPLICA_ONE]
# Recreate the same visible libvirt identity and allocation with
# different bytes. Name/path/capacity/allocation alone must not
# make this new volume generation trusted.
recreated = FakeVolume(
pool, TEMPLATE_REPLICA_ONE,
capacity=original.capacity, fmt=original.format,
)
recreated.contents[:] = b"x" * len(payload)
pool.volumes[TEMPLATE_REPLICA_ONE] = recreated
replaced = self.service.cache_template(
image, TEMPLATE_REPLICA_TWO, 2 * 1024**3,
trusted_replica_volume_name=TEMPLATE_REPLICA_ONE,
trusted_replica_identity=first["replica_identity"],
)
self.assertFalse(replaced["already_cached"])
self.assertEqual(replaced["volume_name"], TEMPLATE_REPLICA_TWO)
self.assertIs(pool.volumes[TEMPLATE_REPLICA_ONE], recreated)
self.assertEqual(len(recreated.contents), len(payload))
self.assertNotEqual(bytes(recreated.contents), payload)
self.assertEqual(bytes(pool.volumes[TEMPLATE_REPLICA_TWO].contents), payload)
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
def test_template_cache_reuploads_an_interrupted_desired_generation(self):
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "global-template.qcow2"
payload = b"QFI\xfb" + b"global cloud image fixture"
image.write_bytes(payload)
self.service.cache_template(
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
)
pool = self.backend.pools["images"]
interrupted = pool.volumes[TEMPLATE_REPLICA_ONE]
interrupted.contents[:] = b"partial"
recovered = self.service.cache_template(
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
)
self.assertFalse(recovered["already_cached"])
self.assertIsNot(pool.volumes[TEMPLATE_REPLICA_ONE], interrupted)
self.assertEqual(bytes(pool.volumes[TEMPLATE_REPLICA_ONE].contents), payload)
self.assertIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
def test_template_cache_refuses_to_overwrite_its_trusted_generation(self):
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "global-template.qcow2"
image.write_bytes(b"QFI\xfbglobal cloud image fixture")
first = self.service.cache_template(
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
)
original = self.backend.pools["images"].volumes[TEMPLATE_REPLICA_ONE]
with self.assertRaises(self.error_type) as raised:
self.service.cache_template(
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
trusted_replica_volume_name=TEMPLATE_REPLICA_ONE,
trusted_replica_identity=first["replica_identity"],
)
self.assertEqual(raised.exception.status, 400)
self.assertIs(
self.backend.pools["images"].volumes[TEMPLATE_REPLICA_ONE], original)
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
def test_template_cache_does_not_replace_an_untrusted_referenced_volume(self):
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "global-template.qcow2"
image.write_bytes(b"QFI\xfbglobal cloud image fixture")
self.service.cache_template(
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
)
# A disk source referencing the desired replica generation is
# enough to make replacement unsafe, even if that definition was
# created outside the panel.
domain = FakeDomain(self.backend, f"""
<domain><name>external-template-user</name>
<uuid>00000000-0000-4000-8000-000000000099</uuid>
<devices><disk device="disk" type="volume">
<source pool="images" volume="{TEMPLATE_REPLICA_ONE}"/>
</disk></devices></domain>
""", running=True)
self.backend.domains.append(domain)
with self.assertRaises(self.error_type) as raised:
self.service.cache_template(
image, TEMPLATE_REPLICA_ONE, 2 * 1024**3,
)
self.assertEqual(raised.exception.status, 409)
self.assertIn(TEMPLATE_REPLICA_ONE, self.backend.pools["images"].volumes)
def test_template_delete_removes_source_and_every_replica_generation(self):
pool = self.backend.pools["images"]
unrelated = "panel-template-alma10-87654321-fedcba9876543210.qcow2"
for name in (TEMPLATE_NAME, TEMPLATE_REPLICA_ONE,
TEMPLATE_REPLICA_TWO, unrelated):
pool.volumes[name] = FakeVolume(pool, name, capacity=2 * 1024**3)
result = self.service.delete_cloud_template_replicas(TEMPLATE_NAME)
self.assertTrue(result["deleted"])
self.assertEqual(
result["deleted_volumes"],
[TEMPLATE_REPLICA_ONE, TEMPLATE_REPLICA_TWO, TEMPLATE_NAME],
)
self.assertEqual(set(pool.volumes), {unrelated})
def test_missing_template_cache_has_precise_idempotency_code(self):
with self.assertRaises(self.error_type) as missing:
self.service.delete_cloud_template_replicas(TEMPLATE_NAME)
self.assertEqual(missing.exception.status, 404)
self.assertEqual(
missing.exception.error_code,
"cloud_template_cache_not_found",
)
service = self.service.__class__(
self.service.uri, "missing-images-pool", "iso", "default")
with self.assertRaises(self.error_type) as pool_missing:
service.delete_cloud_template_replicas(TEMPLATE_NAME)
self.assertEqual(pool_missing.exception.status, 404)
self.assertEqual(pool_missing.exception.error_code, "")
def test_template_delete_is_all_or_nothing_when_a_replica_is_referenced(self):
pool = self.backend.pools["images"]
for name in (TEMPLATE_REPLICA_ONE, TEMPLATE_REPLICA_TWO):
pool.volumes[name] = FakeVolume(pool, name, capacity=2 * 1024**3)
self.backend.domains.append(FakeDomain(self.backend, f"""
<domain><name>external-template-user</name>
<uuid>00000000-0000-4000-8000-000000000099</uuid>
<devices><disk device="disk" type="volume">
<source pool="images" volume="{TEMPLATE_REPLICA_TWO}"/>
</disk></devices></domain>
""", running=True))
with self.assertRaises(self.error_type) as raised:
self.service.delete_cloud_template_replicas(TEMPLATE_NAME)
self.assertEqual(raised.exception.status, 409)
self.assertIn(TEMPLATE_REPLICA_ONE, pool.volumes)
self.assertIn(TEMPLATE_REPLICA_TWO, pool.volumes)
self.assertNotIn(TEMPLATE_REPLICA_ONE, self.backend.deleted_volumes)
def rescue_pool(self):
pool = self.backend.pools.get("rescue")
if pool is None:
pool = FakePool(self.backend, "rescue", "/home/rescue")
self.backend.pools["rescue"] = pool
return pool
def rescue_volume(self):
pool = self.rescue_pool()
pool.volumes[RESCUE_NAME] = FakeVolume(pool, RESCUE_NAME,
capacity=1024 * 1024, fmt="raw")
return pool.volumes[RESCUE_NAME]
def test_rescue_directory_is_registered_as_a_separate_persistent_pool(self):
configured = self.service.ensure_storage_pools()
self.assertEqual(configured, {
"storage_pool": "images", "iso_pool": "iso",
"rescue_iso_pool": self.backend.defined[-1][0],
})
self.assertEqual(self.backend.defined[-1][1], "/home/rescue")
self.assertTrue(self.backend.pools[configured["rescue_iso_pool"]].autostart())
self.assertEqual(self.backend.existing_dirs.intersection({"/home/rescue"}),
{"/home/rescue"})
def test_rescue_iso_is_separate_from_install_iso_list_and_creation(self):
self.rescue_volume()
self.assertEqual(self.service.resources()["isos"], ["AlmaLinux-10.iso"])
self.assertEqual(self.service.create_vm(self.spec())["state"], "running")
with self.assertRaises(self.error_type) as missing:
self.service.create_vm(self.spec(name="rescue-as-installer",
iso="another-rescue.iso"))
self.assertEqual(missing.exception.status, 404)
# Even if somebody places a panel-named rescue ISO into the ordinary
# pool by hand, it must not become a selectable installation source.
normal_pool = self.backend.pools["iso"]
normal_pool.volumes[RESCUE_NAME] = FakeVolume(normal_pool, RESCUE_NAME)
self.assertNotIn(RESCUE_NAME, self.service.resources()["isos"])
with self.assertRaises(self.error_type) as blocked:
self.service.create_vm(self.spec(name="rescue-as-installer",
iso=RESCUE_NAME))
self.assertEqual(blocked.exception.status, 409)
def test_rescue_operations_never_fall_back_to_normal_iso_pool(self):
ordinary = self.backend.pools["iso"]
ordinary.volumes[RESCUE_NAME] = FakeVolume(ordinary, RESCUE_NAME,
capacity=1024 * 1024, fmt="raw")
unconfigured = self.service.__class__(
self.service.uri, "images", "iso", "default")
with self.assertRaises(self.error_type) as missing:
unconfigured.delete_rescue_iso(RESCUE_NAME)
self.assertEqual(missing.exception.status, 409)
self.assertIn("配置救援 ISO", str(missing.exception))
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "rescue.iso"
payload = bytearray(1024 * 1024)
payload[32769:32774] = b"CD001"
image.write_bytes(payload)
with self.assertRaises(self.error_type) as missing_upload:
unconfigured.import_rescue_iso(image, RESCUE_NAME)
self.assertEqual(missing_upload.exception.status, 409)
self.assertIn(RESCUE_NAME, ordinary.volumes)
def test_rescue_pool_alias_of_install_iso_pool_is_rejected(self):
normal_pool = self.backend.pools["iso"]
alias = FakePool(self.backend, "rescue-alias", normal_pool.path)
self.backend.pools["rescue-alias"] = alias
service = self.service.__class__(
self.service.uri, "images", "iso", "default",
rescue_iso_pool="rescue-alias")
with self.assertRaises(self.error_type) as invalid:
service.ensure_storage_pools()
self.assertEqual(invalid.exception.status, 409)
with self.assertRaises(self.error_type) as invalid_lookup:
service.delete_rescue_iso(RESCUE_NAME)
self.assertEqual(invalid_lookup.exception.status, 409)
self.assertFalse(alias.volumes)
def test_rescue_pool_alias_with_mixed_file_pool_types_is_rejected(self):
normal_pool = self.backend.pools["iso"]
alias = FakePool(self.backend, "rescue-fs-alias", normal_pool.path,
pool_type="fs")
self.backend.pools["rescue-fs-alias"] = alias
service = self.service.__class__(
self.service.uri, "images", "iso", "default",
rescue_iso_pool="rescue-fs-alias")
with self.assertRaises(self.error_type) as invalid:
service.ensure_storage_pools()
self.assertEqual(invalid.exception.status, 409)
with self.assertRaises(self.error_type) as invalid_lookup:
service.delete_rescue_iso(RESCUE_NAME)
self.assertEqual(invalid_lookup.exception.status, 409)
def test_rescue_iso_import_rejects_invalid_file_and_never_overwrites(self):
self.rescue_pool()
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "rescue.iso"
image.write_bytes(b"not an ISO" * 10000)
with self.assertRaises(self.error_type) as invalid:
self.service.import_rescue_iso(image, RESCUE_NAME)
self.assertEqual(invalid.exception.status, 422)
self.assertNotIn(RESCUE_NAME, self.backend.pools["rescue"].volumes)
payload = bytearray(1024 * 1024)
payload[32769:32774] = b"CD001"
image.write_bytes(payload)
imported = self.service.import_rescue_iso(image, RESCUE_NAME)
self.assertEqual(imported, {"volume_name": RESCUE_NAME,
"image_bytes": len(payload)})
self.assertEqual(bytes(self.backend.pools["rescue"].volumes[RESCUE_NAME].contents),
payload)
with self.assertRaises(self.error_type) as exists:
self.service.import_rescue_iso(image, RESCUE_NAME)
self.assertEqual(exists.exception.status, 409)
def test_rescue_iso_import_stream_failure_removes_only_new_volume(self):
self.rescue_pool()
with tempfile.TemporaryDirectory() as directory:
image = pathlib.Path(directory) / "rescue.iso"
payload = bytearray(1024 * 1024)
payload[32769:32774] = b"CD001"
image.write_bytes(payload)
self.backend.fail_send = True
with self.assertRaises(self.error_type):
self.service.import_rescue_iso(image, RESCUE_NAME)
self.assertNotIn(RESCUE_NAME, self.backend.pools["rescue"].volumes)
self.assertTrue(self.backend.streams[-1].aborted)
def test_missing_rescue_volume_has_precise_idempotency_code(self):
self.rescue_pool()
with self.assertRaises(self.error_type) as missing:
self.service.delete_rescue_iso(RESCUE_NAME)
self.assertEqual(missing.exception.status, 404)
self.assertEqual(
missing.exception.error_code, "rescue_volume_not_found")
service = self.service.__class__(
self.service.uri, "images", "iso", "default",
rescue_iso_pool="missing-rescue-pool")
with self.assertRaises(self.error_type) as pool_missing:
service.delete_rescue_iso(RESCUE_NAME)
self.assertEqual(pool_missing.exception.status, 404)
self.assertEqual(pool_missing.exception.error_code, "")
def test_rescue_iso_delete_can_clean_corrupt_unreferenced_managed_volume(self):
pool = self.rescue_pool()
pool.volumes[RESCUE_NAME] = FakeVolume(pool, RESCUE_NAME,
capacity=1024, fmt="qcow2")
self.assertTrue(self.service.delete_rescue_iso(RESCUE_NAME)["deleted"])
self.assertNotIn(RESCUE_NAME, pool.volumes)
def test_rescue_boot_preserves_seed_cdrom_and_exit_restores_original_xml(self):
service = self.cloud_service()
created = self.create_cloud_vm(service, self.cloud_spec())
original_disk_names = set(self.backend.pools["images"].volumes)
self.rescue_volume()
original_xml = service.prepare_rescue_vm(created["uuid"], RESCUE_NAME)
entered = service.enter_rescue_vm(created["uuid"], RESCUE_NAME, original_xml)
self.assertTrue(entered["vm"]["rescue_mode"])
self.assertFalse(entered["vm"]["rescue_staged"])
self.assertEqual(entered["vm"]["rescue_volume_name"], RESCUE_NAME)
self.assertTrue(self.backend.domains[0].autostart())
rescue_root = self.backend.domains[0].root
self.assertEqual(len(rescue_root.findall("./devices/disk[@device='cdrom']")), 2)
self.assertIsNone(rescue_root.find("./os/boot"))
seed = rescue_root.findall("./devices/disk[@device='cdrom']")[0]
rescue = rescue_root.findall("./devices/disk[@device='cdrom']")[1]
self.assertIn("panel-seed-", seed.find("source").get("file"))
self.assertEqual(rescue.find("source").get("file"),
self.backend.pools["rescue"].volumes[RESCUE_NAME].path())
self.assertEqual(rescue.find("boot").get("order"), "1")
self.assertEqual(rescue_root.find("./devices/disk[@device='disk']/boot").get("order"),
"2")
with self.assertRaises(self.error_type) as in_use:
service.delete_rescue_iso(RESCUE_NAME)
self.assertEqual(in_use.exception.status, 409)
exited = service.exit_rescue_vm(created["uuid"], original_xml)
self.assertFalse(exited["vm"]["rescue_mode"])
self.assertTrue(self.backend.domains[0].autostart())
self.assertEqual(len(self.backend.domains[0].root.findall(
"./devices/disk[@device='cdrom']")), 1)
self.assertEqual(set(self.backend.pools["images"].volumes), original_disk_names)
self.assertEqual(self.backend.shutdown_calls, 2)
self.assertEqual(self.backend.destroyed, [])
self.assertTrue(service.delete_rescue_iso(RESCUE_NAME)["deleted"])
def test_rescue_entry_rolls_back_stripped_platform_metadata(self):
service = self.cloud_service()
platform_snapshot = self.platform_snapshot(self.test_platform_rule())
created = self.create_cloud_vm(service, self.cloud_spec(
platform_network_policy_snapshot=platform_snapshot,
))
self.rescue_volume()
domain = self.backend.domains[0]
original_xml = service.prepare_rescue_vm(
created["uuid"], RESCUE_NAME)
shutdowns = self.backend.shutdown_calls
with patch.object(
FakeConnection, "defineXML",
self.platform_policy_stripping_define()), \
self.assertRaises(self.service_module.VMError) as raised:
service.enter_rescue_vm(
created["uuid"], RESCUE_NAME, original_xml)
self.assertEqual(raised.exception.status, 502)
self.assertIn("原虚拟机未受影响", str(raised.exception))
self.assertEqual(self.backend.shutdown_calls, shutdowns)
self.assertTrue(domain.isActive())
self.assertFalse(service.get_vm(created["uuid"])["rescue_mode"])
managed = domain.inactive_root.find(
f"./metadata/{{{self.service_module.PANEL_NS}}}managed")
policy_node = managed.find(
f"{{{self.service_module.PANEL_NS}}}platform-policy")
self.assertEqual(json.loads(policy_node.text), platform_snapshot)
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)
def test_metric_counters_reject_ambiguous_extra_nic_role(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-000000000003",
info=lambda: (1, 2048 * 1024, 2048 * 1024, 2, 0),
ID=lambda: 9,
XMLDesc=lambda _flags: ("<domain><devices>"
"<interface type='bridge'><mac address='52:54:00:12:34:56'/>"
"<target dev='vnet9'/><alias name='ua-public0'/></interface>"
"<interface type='bridge'><mac address='52:54:00:aa:bb:cc'/>"
"<target dev='vnet10'/></interface>"
"</devices></domain>"),
)
def get_stats(_connection, _groups, _flags):
return [(domain, {"cpu.time": 123, "net.count": 2,
"net.0.name": "vnet9", "net.0.rx.bytes": 456,
"net.0.tx.bytes": 789,
"net.1.name": "vnet10", "net.1.rx.bytes": 12,
"net.1.tx.bytes": 34})]
with patch.object(FakeConnection, "getAllDomainStats", get_stats, create=True):
result = self.service.metric_counters()
self.assertEqual(len(result), 1)
self.assertEqual(result[0].values["net.0.role"], "public")
self.assertEqual(result[0].values["net.1.role"], "unknown")
def test_metric_counters_keep_generated_public_during_live_alias_migration(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)
for public_alias in ("net0", "ua-net-0"):
with self.subTest(public_alias=public_alias):
domain = types.SimpleNamespace(
UUIDString=lambda: "00000000-0000-4000-8000-000000000004",
info=lambda: (1, 2048 * 1024, 2048 * 1024, 2, 0),
ID=lambda: 10,
XMLDesc=lambda _flags, alias=public_alias: (
"<domain><devices>"
"<interface><mac address='52:54:00:12:34:56'/>"
f"<target dev='vnet9'/><alias name='{alias}'/></interface>"
"<interface><mac address='52:54:00:aa:bb:cc'/>"
"<target dev='vnet10'/><alias name='ua-private0'/></interface>"
"</devices></domain>"
),
)
def get_stats(_connection, _groups, _flags):
return [(domain, {
"cpu.time": 123, "net.count": 2,
"net.0.name": "vnet9", "net.0.rx.bytes": 456,
"net.0.tx.bytes": 789,
"net.1.name": "vnet10", "net.1.rx.bytes": 12,
"net.1.tx.bytes": 34,
})]
with patch.object(
FakeConnection, "getAllDomainStats", get_stats, create=True,
):
result = self.service.metric_counters()
self.assertEqual(result[0].values["net.0.role"], "public")
self.assertEqual(result[0].values["net.1.role"], "private")
if __name__ == "__main__":
unittest.main()