fix: gate instance lifecycle on private readback
parent
3190012361
commit
e003c2abc2
@ -0,0 +1,88 @@
|
||||
from virsh_panel.private_network import observe_private_state_from_xml
|
||||
|
||||
|
||||
def _xml(*, private=True, link="up", private_source="vc-private",
|
||||
private_ip="10.24.3.7/32", verified="true", private_filter=False,
|
||||
public_source="br0", private_type="bridge"):
|
||||
private_block = ""
|
||||
if private:
|
||||
filt = '<filterref filter="clean-traffic" />' if private_filter else ""
|
||||
source = (f'<source bridge="{private_source}" />'
|
||||
if private_type == "bridge"
|
||||
else f'<source network="{private_source}" />')
|
||||
private_block = f'''<interface type="{private_type}">
|
||||
<mac address="52:54:00:aa:bb:cc" />
|
||||
{source}
|
||||
<link state="{link}" />{filt}
|
||||
<alias name="private0" />
|
||||
</interface>'''
|
||||
return f'''<domain><uuid>00000000-0000-4000-8000-000000000001</uuid>
|
||||
<metadata><panel:managed xmlns:panel="urn:virsh-panel:1" private-ip-cidr="{private_ip or ''}"
|
||||
private-network-verified="{verified}" /></metadata>
|
||||
<devices>
|
||||
<interface type="bridge"><mac address="52:54:00:11:22:33" />
|
||||
<source bridge="{public_source}" /><alias name="public0" /></interface>
|
||||
{private_block}
|
||||
</devices></domain>'''
|
||||
|
||||
|
||||
def test_private_state_without_private_nic_is_confirmed_disabled():
|
||||
state = observe_private_state_from_xml(_xml(private=False), vm_uuid="00000000-0000-4000-8000-000000000001", observed_at=10)
|
||||
assert state["state"] == "disabled"
|
||||
assert state["readback"] == "confirmed"
|
||||
assert state["interface"] is None
|
||||
|
||||
|
||||
def test_private_state_requires_verified_independent_bridge_and_ip():
|
||||
state = observe_private_state_from_xml(_xml(), observed_at=10)
|
||||
assert state["state"] == "degraded"
|
||||
assert state["reason_code"] == "private_source_unverified"
|
||||
state = observe_private_state_from_xml(_xml(), host_verified=True, observed_at=10)
|
||||
assert state["state"] == "active"
|
||||
assert state["readback"] == "confirmed"
|
||||
assert state["private_ip_cidr"] == "10.24.3.7/32"
|
||||
|
||||
unverified = observe_private_state_from_xml(_xml(verified="false"))
|
||||
assert unverified["state"] == "degraded"
|
||||
assert unverified["reason_code"] == "private_source_unverified"
|
||||
|
||||
missing_ip = observe_private_state_from_xml(_xml(private_ip=None))
|
||||
assert missing_ip["state"] == "degraded"
|
||||
assert missing_ip["reason_code"] == "private_ip_missing"
|
||||
|
||||
|
||||
def test_private_state_marks_link_down_suspended():
|
||||
state = observe_private_state_from_xml(_xml(link="down"), host_verified=True)
|
||||
assert state["state"] == "suspended"
|
||||
assert state["link_state"] == "down"
|
||||
|
||||
|
||||
def test_private_state_rejects_public_source_or_filter():
|
||||
shared = observe_private_state_from_xml(_xml(private_source="br0"))
|
||||
assert shared["state"] == "degraded"
|
||||
assert shared["reason_code"] == "private_source_invalid"
|
||||
|
||||
filtered = observe_private_state_from_xml(_xml(private_filter=True), host_verified=True)
|
||||
assert filtered["state"] == "degraded"
|
||||
assert filtered["reason_code"] == "private_filter_present"
|
||||
|
||||
|
||||
def test_private_network_source_network_is_not_proven_isolated():
|
||||
state = observe_private_state_from_xml(
|
||||
_xml(private_source="default", private_type="network"), host_verified=True
|
||||
)
|
||||
# The helper only accepts an explicit host bridge; a libvirt network name
|
||||
# does not prove which bridge it resolves to.
|
||||
assert state["state"] == "degraded"
|
||||
assert state["reason_code"] == "private_source_invalid"
|
||||
|
||||
|
||||
def test_private_state_rejects_ambiguous_extra_nic_without_private_role():
|
||||
xml = _xml(private=False).replace(
|
||||
'</devices>',
|
||||
'<interface type="bridge"><mac address="52:54:00:dd:ee:ff" />'
|
||||
'<source bridge="vpc0" /></interface></devices>',
|
||||
)
|
||||
state = observe_private_state_from_xml(xml)
|
||||
assert state["state"] == "degraded"
|
||||
assert state["reason_code"] == "private_interface_role_invalid"
|
||||
@ -0,0 +1,202 @@
|
||||
"""Bounded observation of a VM's private network role.
|
||||
|
||||
This module deliberately only reads the domain definition. It does not run
|
||||
``ip``, ``wg`` or ``nft`` commands and it never treats the host Fabric status
|
||||
as proof that a tenant NIC is connected. The PHP control plane supplies the
|
||||
VPC/member revision when it evaluates this observation at an operation
|
||||
commit boundary.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import ipaddress
|
||||
import re
|
||||
import time
|
||||
import xml.etree.ElementTree as ET
|
||||
from typing import Any
|
||||
|
||||
from virsh_panel.network_roles import (
|
||||
PRIVATE_INTERFACE_ALIAS,
|
||||
interface_role,
|
||||
private_interface_has_public_filter,
|
||||
select_private_interface,
|
||||
select_public_interface,
|
||||
)
|
||||
|
||||
|
||||
PRIVATE_STATE_VERSION = 1
|
||||
PANEL_NS = "urn:virsh-panel:1"
|
||||
_MAC_RE = re.compile(r"[0-9a-f]{2}(?::[0-9a-f]{2}){5}\Z")
|
||||
_DIGEST_RE = re.compile(r"[0-9a-f]{64}\Z")
|
||||
|
||||
|
||||
def _source(interface: ET.Element) -> tuple[str | None, str | None]:
|
||||
source = interface.find("source")
|
||||
if source is None:
|
||||
return None, None
|
||||
for kind in ("bridge", "network", "dev", "name", "path"):
|
||||
value = source.get(kind)
|
||||
if isinstance(value, str) and value.strip():
|
||||
return kind, value.strip()
|
||||
return None, None
|
||||
|
||||
|
||||
def _managed_metadata(root: ET.Element) -> ET.Element | None:
|
||||
# Only the panel-owned namespace is trusted for the optional identity
|
||||
# metadata. Guest/user XML must never become a host-state assertion.
|
||||
for node in root.findall("./metadata"):
|
||||
for child in list(node):
|
||||
if child.tag == f"{{{PANEL_NS}}}managed":
|
||||
return child
|
||||
return None
|
||||
|
||||
|
||||
def _private_ip(root: ET.Element, managed: ET.Element | None) -> str | None:
|
||||
values: list[str | None] = []
|
||||
if managed is not None:
|
||||
values.extend((managed.get("private-ip-cidr"), managed.get("private_ip_cidr")))
|
||||
for node in root.findall("./metadata/*"):
|
||||
if node.tag.rsplit("}", 1)[-1] in {"private-network", "private_state"}:
|
||||
values.extend((node.get("ip-cidr"), node.get("private-ip-cidr"), node.get("cidr")))
|
||||
for value in values:
|
||||
if not isinstance(value, str) or not value:
|
||||
continue
|
||||
try:
|
||||
address = ipaddress.ip_interface(value)
|
||||
except ValueError:
|
||||
continue
|
||||
if isinstance(address, ipaddress.IPv4Interface) and address.network.prefixlen == 32:
|
||||
return str(address)
|
||||
return None
|
||||
|
||||
|
||||
def _revision(managed: ET.Element | None) -> int:
|
||||
if managed is None:
|
||||
return 0
|
||||
raw = managed.get("private-network-revision") or managed.get("private_revision")
|
||||
try:
|
||||
value = int(raw or 0)
|
||||
except (TypeError, ValueError):
|
||||
return 0
|
||||
return value if 0 <= value <= (1 << 63) - 1 else 0
|
||||
|
||||
|
||||
def _digest(managed: ET.Element | None) -> str | None:
|
||||
if managed is None:
|
||||
return None
|
||||
value = managed.get("private-network-digest") or managed.get("private_digest")
|
||||
return value.lower() if isinstance(value, str) and _DIGEST_RE.fullmatch(value.lower()) else None
|
||||
|
||||
|
||||
def observe_private_state(
|
||||
root: ET.Element,
|
||||
*,
|
||||
vm_uuid: str | None = None,
|
||||
host_verified: bool = False,
|
||||
observed_at: int | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""Return a stable, credential-free private NIC observation.
|
||||
|
||||
``disabled/confirmed`` means that the domain has no private role and no
|
||||
VPC expectation was supplied to this read. A caller that has a VPC
|
||||
expectation must independently change that result to ``degraded`` or
|
||||
``uncertain`` until the expected member/revision/digest is verified.
|
||||
"""
|
||||
now = int(time.time()) if observed_at is None else int(observed_at)
|
||||
base: dict[str, Any] = {
|
||||
"version": PRIVATE_STATE_VERSION,
|
||||
"required": False,
|
||||
"vm_uuid": vm_uuid,
|
||||
"vpc_id": None,
|
||||
"member_id": None,
|
||||
"interface": None,
|
||||
"state": "disabled",
|
||||
"desired_revision": 0,
|
||||
"observed_revision": 0,
|
||||
"desired_digest": None,
|
||||
"observed_digest": None,
|
||||
"readback": "confirmed",
|
||||
"link_state": "absent",
|
||||
"private_ip_cidr": None,
|
||||
"private_mac": None,
|
||||
"reason_code": None,
|
||||
"observed_at": now,
|
||||
}
|
||||
interfaces = list(root.findall("./devices/interface"))
|
||||
# Validate the complete role map even when no private NIC is present. A
|
||||
# second unlabelled/ambiguous NIC must not disappear behind a successful
|
||||
# public-only observation and later become an accidental data-plane path.
|
||||
try:
|
||||
public = select_public_interface(interfaces)
|
||||
private = select_private_interface(interfaces)
|
||||
except (TypeError, ValueError):
|
||||
base.update(state="degraded", readback="mismatch",
|
||||
reason_code="private_interface_role_invalid")
|
||||
return base
|
||||
if private is None:
|
||||
return base
|
||||
|
||||
base["interface"] = PRIVATE_INTERFACE_ALIAS
|
||||
managed = _managed_metadata(root)
|
||||
base["private_ip_cidr"] = _private_ip(root, managed)
|
||||
base["observed_revision"] = _revision(managed)
|
||||
base["observed_digest"] = _digest(managed)
|
||||
mac_node = private.find("mac")
|
||||
mac = mac_node.get("address", "").lower() if mac_node is not None else ""
|
||||
base["private_mac"] = mac or None
|
||||
link = private.find("link")
|
||||
link_state = link.get("state", "up").lower() if link is not None else "up"
|
||||
base["link_state"] = link_state if link_state in {"up", "down"} else "absent"
|
||||
|
||||
private_kind, private_source = _source(private)
|
||||
public_kind, public_source = _source(public) if public is not None else (None, None)
|
||||
# The tenant data plane is an independent host bridge. A libvirt
|
||||
# ``network``/``direct`` source does not let this layer prove which host
|
||||
# bridge it resolves to, so accepting it would make a public bridge reuse
|
||||
# indistinguishable from a private network. The future data-plane apply
|
||||
# path may add an explicit verification marker to the managed metadata.
|
||||
if (private_kind != "bridge" or private_source is None
|
||||
or private_kind == public_kind and private_source == public_source):
|
||||
base.update(state="degraded", readback="mismatch",
|
||||
reason_code="private_source_invalid")
|
||||
return base
|
||||
if private_interface_has_public_filter(private):
|
||||
base.update(state="degraded", readback="mismatch",
|
||||
reason_code="private_filter_present")
|
||||
return base
|
||||
if not _MAC_RE.fullmatch(mac):
|
||||
base.update(state="degraded", readback="mismatch",
|
||||
reason_code="private_mac_missing")
|
||||
return base
|
||||
if base["private_ip_cidr"] is None:
|
||||
base.update(state="degraded", readback="missing",
|
||||
reason_code="private_ip_missing")
|
||||
return base
|
||||
# XML metadata is tenant/domain data and can be edited independently of
|
||||
# the host. Only a future host adapter probe may set ``host_verified``;
|
||||
# never use a managed-XML marker as proof of bridge/WireGuard/nft state.
|
||||
if not host_verified:
|
||||
base.update(state="degraded", readback="missing",
|
||||
reason_code="private_source_unverified")
|
||||
return base
|
||||
if link_state not in {"up", "down"}:
|
||||
base.update(state="degraded", readback="mismatch",
|
||||
reason_code="private_link_state_invalid")
|
||||
return base
|
||||
base["state"] = "suspended" if link_state == "down" else "active"
|
||||
return base
|
||||
|
||||
|
||||
def observe_private_state_from_xml(
|
||||
xml: str | bytes,
|
||||
*,
|
||||
vm_uuid: str | None = None,
|
||||
host_verified: bool = False,
|
||||
observed_at: int | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""Parse a libvirt XML document and return :func:`observe_private_state`."""
|
||||
root = ET.fromstring(xml)
|
||||
return observe_private_state(
|
||||
root, vm_uuid=vm_uuid, host_verified=host_verified,
|
||||
observed_at=observed_at,
|
||||
)
|
||||
Loading…
Reference in New Issue