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.
317 lines
13 KiB
Python
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()
|