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_vpc_readback.py

317 lines
13 KiB
Python

"""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(
"<interface type='bridge'><mac address='52:54:00:12:34:57'/>"
"<source bridge='vcbr-private'/><alias name='ua-private0'/></interface>")
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(
"<disk type='file' device='cdrom'><source file='/foreign.iso'/></disk>"))
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()