"""Real iproute2 output and read-only removal of an unapplied private NIC.""" import copy import json import sys from types import ModuleType, SimpleNamespace from unittest.mock import patch import xml.etree.ElementTree as ET import pytest import test_libvirt_service as fixtures @pytest.fixture def fixture(): case = fixtures.VMServiceTests() case.setUp() yield case case.doCleanups() def probe(fixture, monkeypatch, rows): domain, mac, address, routes = fixture.private_guest_probe_domain() service = fixture.service execute = service._qga_exec_bytes def output(*args, **kwargs): if kwargs["probe_kind"] == "routes": # ip -j route show ... dev ens7 suppresses the redundant dev key. assert kwargs["arguments"][-1] == "ens7" assert 'dev "$1"' in kwargs["arguments"][1] return json.dumps(rows).encode() return execute(*args, **kwargs) monkeypatch.setattr(type(service), "_qga_exec_bytes", staticmethod(output)) return service.read_private_domain_pair( domain.UUIDString(), private_mac=mac, private_ip_cidr=address, private_routes=routes, )["guest_network"] def test_guest_routes_accept_device_omitted_by_fixed_iproute2_filter(fixture, monkeypatch): evidence = probe(fixture, monkeypatch, [{ "dst": "10.20.0.0/24", "scope": "link", "protocol": "static", }]) assert evidence["verified"] is True assert evidence["state"] == "confirmed" assert evidence["routes"] == ["10.20.0.0/24"] @pytest.mark.parametrize("changes", [ {"dev": "eth0"}, {"dev": None}, {"scope": "global"}, {"gateway": "10.20.0.1"}, {"via": "10.20.0.1"}, {"flags": ["linkdown"]}, {"table": 100}, {"dst": "10.21.0.0/24"}, ]) def test_guest_route_normalization_keeps_other_identity_checks(fixture, monkeypatch, changes): row = {"dst": "10.20.0.0/24", "scope": "link", "protocol": "static"} row.update(changes) evidence = probe(fixture, monkeypatch, [row]) assert evidence["verified"] is False def remove(service, vm_id): return service.remove_private_interface( vm_id, vpc_id="vpc-delete-test", resources=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", ) def private_interface(): return ET.fromstring( "" "") def test_running_vm_can_confirm_unapplied_private_interface_absent(fixture): service, created, _spec, domain, _seed_name = fixture.cloud_vm_with_real_seed() inactive = domain.XMLDesc(1) live = domain.XMLDesc(0) with patch.object(service, "_upload_volume") as upload, patch.object( fixtures.FakeConnection, "defineXML", autospec=True, ) as define: result = remove(service, created["uuid"]) assert result["removed"] is True assert result["already_absent"] is True assert result["readback"] == "confirmed" assert result["running"] is True assert domain.running is True assert domain.XMLDesc(1) == inactive assert domain.XMLDesc(0) == live upload.assert_not_called() define.assert_not_called() def test_running_pending_attach_can_be_cancelled_without_stopping_guest(fixture): from virsh_panel.vpc import VpcMember service, created, _spec, domain, seed_name = fixture.cloud_vm_with_real_seed() seed = fixture.backend.pools["images"].volumes[seed_name] original_seed = bytes(seed.contents) original_defines = list(fixture.backend.define_xmls) member = VpcMember( "member-delete-test", created["uuid"], "host-a", "10.20.0.10", "subnet-a", "52:54:00:12:34:57", ) pending = service.ensure_private_interface( created["uuid"], member=member, resources=SimpleNamespace(bridge="vcbr-private"), vpc_id="vpc-delete-test", desired_revision=1, desired_digest="a" * 64, private_routes=["10.20.0.0/24"], ) assert pending["readback"] == "pending_restart" assert pending["seed_updated"] is False result = remove(service, created["uuid"]) assert result["removed"] is True assert result["already_absent"] is True assert result["readback"] == "confirmed" assert domain.running is True assert bytes(seed.contents) == original_seed assert fixture.backend.define_xmls == original_defines assert fixture.backend.device_updates == [] @pytest.mark.parametrize("layer", ["inactive_root", "live_root"]) @pytest.mark.parametrize("artifact", [ "nic", "metadata", "unowned_cdrom", "unknown_nic", "foreign_seed", ]) def test_running_absence_rejects_remaining_or_unowned_artifacts(fixture, layer, artifact): service, created, _spec, domain, _seed_name = fixture.cloud_vm_with_real_seed() root = getattr(domain, layer) if artifact == "nic": root.find("./devices").append(private_interface()) elif artifact == "metadata": root.find(f"./metadata/{{{fixture.service_module.PANEL_NS}}}managed").set( "private-vpc-id", "vpc-delete-test") elif artifact == "unowned_cdrom": root.find("./devices").append(ET.fromstring( "")) elif artifact == "foreign_seed": source = root.find("./devices/disk[@device='cdrom']/source") source.attrib.clear() source.set("file", "/foreign.iso") else: nic = private_interface() nic.find("alias").set("name", "ua-other") root.find("./devices").append(nic) with patch.object(service, "_upload_volume") as upload, patch.object( fixtures.FakeConnection, "defineXML", autospec=True, ) as define, pytest.raises(fixture.error_type) as failure: remove(service, created["uuid"]) if artifact == "foreign_seed" and layer == "live_root": # The shared seed ownership verifier rejects a changed live source. assert "配置盘已被修改" in str(failure.value) else: assert failure.value.error_code == "vpc_private_remove_requires_stopped" upload.assert_not_called() define.assert_not_called() def test_running_absence_rejects_private_seed_even_when_both_xml_layers_clean(fixture): service, created, _domain, seed, _resources, _mac, _address = ( fixture.cloud_vm_with_private_artifacts(include_private_nic=False)) domain = fixture.backend.domains[0] managed = domain.inactive_root.find( f"./metadata/{{{fixture.service_module.PANEL_NS}}}managed") for key in tuple(managed.attrib): if key.startswith("private-"): managed.attrib.pop(key) domain.running = True domain.live_root = copy.deepcopy(domain.inactive_root) original_seed = bytes(seed.contents) with pytest.raises(fixture.error_type) as failure: remove(service, created["uuid"]) assert failure.value.error_code == "vpc_private_remove_requires_stopped" assert bytes(seed.contents) == original_seed def test_running_absence_without_seed_requires_no_cdrom_in_either_xml(fixture): service, created, _spec, domain, _seed_name = fixture.cloud_vm_with_real_seed() for root in (domain.live_root, domain.inactive_root): root.find(f"./metadata/{{{fixture.service_module.PANEL_NS}}}managed").attrib.pop( "seed-volume") devices = root.find("./devices") for cdrom in list(devices.findall("./disk[@device='cdrom']")): devices.remove(cdrom) result = remove(service, created["uuid"]) assert result["removed"] is True assert result["already_absent"] is True assert result["readback"] == "confirmed" def test_running_absence_rechecks_xml_after_seed_read(fixture): service, created, _spec, domain, _seed_name = fixture.cloud_vm_with_real_seed() download = service._download_seed_volume def drift(*args): result = download(*args) domain.live_root.find("./devices").append(private_interface()) return result with patch.object(service, "_download_seed_volume", side_effect=drift), \ pytest.raises(fixture.error_type) as failure: remove(service, created["uuid"]) assert failure.value.error_code == "vpc_private_remove_requires_stopped" def test_running_absence_rechecks_seed_and_rejects_concurrent_change(fixture): from virsh_panel.cloud_init import replace_seed_private_network service, created, _spec, _domain, seed_name = fixture.cloud_vm_with_real_seed() seed = fixture.backend.pools["images"].volumes[seed_name] download = service._download_seed_volume def drift(*args): result = download(*args) seed.contents = bytearray(replace_seed_private_network( result, private_mac="52:54:00:12:34:57", private_ip_cidr="10.20.0.10/32", private_routes=["10.20.0.0/24"], )) return result with patch.object(service, "_download_seed_volume", side_effect=drift), \ pytest.raises(fixture.error_type) as failure: remove(service, created["uuid"]) assert failure.value.error_code == "vpc_private_remove_requires_stopped" @pytest.mark.parametrize("running", [False, True]) @pytest.mark.parametrize("phase", [None, "launch_intent", "pending"]) def test_coordinator_preserves_guest_execution_until_stopped_before_removal( fixture, monkeypatch, running, phase): from test_vpc import FakeFabric, MemoryStore, delete_payload from virsh_panel.vpc import ( VPC_GUEST_EXEC_KIND, VpcCoordinator, VpcError, VpcMember, parse_vpc_delete_plan, ) from virsh_panel.vpc_dataplane import VpcPrivateHostAdapter service, created, _spec, domain, _seed_name = fixture.cloud_vm_with_real_seed() if not running: domain.running = False domain.live_root = None row = { "member_id": "member-delete-test", "instance_uuid": created["uuid"], "host_id": "host-a", "private_ip_cidr": "10.20.0.10/32", "private_mac": "52:54:00:12:34:57", } plan, _manifest = parse_vpc_delete_plan(delete_payload( vpc_id="vpc-delete-test", retiring_members=(row,), )) store = MemoryStore() coordinator = VpcCoordinator(store, FakeFabric()) member = VpcMember( row["member_id"], row["instance_uuid"], row["host_id"], "10.20.0.10", "retiring", row["private_mac"], ) if phase is not None: _ledger, persist, _clear = coordinator._guest_exec_context(plan, member) core = { "version": 1, "phase": phase, "domain_uuid": created["uuid"], "domain_runtime_id": 7, "qemu_runtime_token": "a" * 32, "guest_network_generation": "generation-1", "probe_kind": "routes", } if phase == "pending": core["pid"] = 41 persist(core) key = f"{plan.vpc_id}.{created['uuid']}" before = store.get(VPC_GUEST_EXEC_KIND, key) module = ModuleType("virsh_panel.libvirt_service") module.VMService = lambda *_args, **_kwargs: service monkeypatch.setitem(sys.modules, "virsh_panel.libvirt_service", module) monkeypatch.setattr(VpcPrivateHostAdapter, "__init__", lambda self, *_args, **_kwargs: None) host_removals = [] def remove_host(_self, dataplane): host_removals.append(dataplane.host_id) return {"removed": True, "readback": "confirmed"} monkeypatch.setattr(VpcPrivateHostAdapter, "remove", remove_host) def run(): return coordinator._run_host_dataplane( plan, "host-a", SimpleNamespace(manager=object()), {"libvirt_uri": "qemu:///system", "storage_pool": "images", "iso_pool": "iso", "default_network": "default"}, [], None, retiring_members=[row], fabric_public_keys={}, fabric_plan_digest="ef" * 32, ) with patch.object(service, "_upload_volume") as upload, patch.object( fixtures.FakeConnection, "defineXML", autospec=True, ) as define: if running and phase is not None: with pytest.raises(VpcError) as failure: run() assert failure.value.status == 409 assert failure.value.error_code == "vpc_private_remove_requires_stopped" assert store.get(VPC_GUEST_EXEC_KIND, key) == before assert host_removals == [] else: result = run() assert result["removed"] is True assert result["readback"] == "confirmed" assert store.get(VPC_GUEST_EXEC_KIND, key) is None assert host_removals == ["host-a"] assert domain.running is running assert fixture.backend.guest_agent_commands == [] upload.assert_not_called() define.assert_not_called()