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_fabric_apply_final_rea...

325 lines
16 KiB
Python

"""Execute the production-rendered final readback with real CLI serialization.
Only external tools are replaced. The final shell body, nft owner checks and
tenant-set matcher are the production code.
"""
from __future__ import annotations
import base64
import json
import os
from pathlib import Path
import subprocess
import sys
import pytest
from virsh_panel.fabric import (
FIREWALL_MODE_NATIVE,
_FABRIC_NFT_VALIDATION_SH,
_FABRIC_WG_READBACK_SH,
_BOOT_HELPER,
_TRANSACTION_SCRIPT,
_VPC_STATE_LOADER,
_apply_script,
_config_text,
_nft_rules_text,
parse_fabric_plan,
)
def _between(text: str, start: str, end: str) -> str:
begin = text.index(start)
return text[begin:text.index(end, begin)]
_TOOLS = r'''import json
import os
from pathlib import Path
import sys
root = Path(os.environ["VC_FINAL_ROOT"])
name = Path(sys.argv[0]).name
args = sys.argv[1:]
with (root / "calls").open("a", encoding="utf-8") as log:
log.write(json.dumps([name, *args]) + "\n")
fixture = json.loads((root / "responses").read_text())
call = json.dumps([name, *args])
if call not in fixture:
print("unexpected test tool invocation", file=sys.stderr)
raise SystemExit(99)
if name == "wg" and args == ["pubkey"]:
if sys.stdin.read() != "test-only-private-identity\n":
raise SystemExit(98)
response = fixture[call]
sys.stdout.write(response["stdout"])
raise SystemExit(response["status"])
'''
class FinalFixture:
def __init__(self, tmp_path: Path, manager: str, peers: int = 1):
self.root = tmp_path
self.manager = manager
self.plan = parse_fabric_plan({
"fabric_id": "final-readback", "region": "hk",
"overlay_cidr": "100.64.1.0/24", "revision": 1,
"nodes": [
{"host_id": str(index), "overlay_ip": f"100.64.1.{index}",
"endpoint": f"203.0.113.{index}:51820"}
for index in range(1, peers + 2)
],
})
self.keys = {
node.host_id: base64.b64encode(bytes([index]) * 32).decode()
for index, node in enumerate(self.plan.nodes, 1)
}
self.responses: dict[str, dict[str, object]] = {}
self.routes = ""
tool = tmp_path / "tool"
tool.write_text(f"#!{sys.executable}\n" + _TOOLS, encoding="utf-8")
tool.chmod(0o700)
for name in ("ip", "wg", "nft"):
(tmp_path / name).symlink_to(tool)
(tmp_path / "private").write_text("test-only-private-identity\n")
(tmp_path / "config").write_text(_config_text(
self.plan, self.plan.nodes[0], self.keys, FIREWALL_MODE_NATIVE))
for filename in ("vpc-peers", "vpc-routes", "vpc-tenants"):
(tmp_path / filename).write_text("")
self.respond("nft", ["-s", "list", "table", "inet",
"virt_cloud_wg_fabric"],
_nft_rules_text(self.plan.digest))
self.respond("nft", ["list", "set", "inet", "virt_cloud_wg_fabric",
"vpc_tenant_ips"],
"table inet virt_cloud_wg_fabric {\n"
"\tset vpc_tenant_ips {\n\t\ttype ipv4_addr\n"
"\t\tflags interval\n\t}\n}\n")
self.respond("wg", ["show", "wg-fabric0"], "")
self.respond("wg", ["pubkey"], self.keys["1"] + "\n")
self.respond("wg", ["show", "wg-fabric0", "public-key"],
self.keys["1"] + "\n")
self.respond("wg", ["show", "wg-fabric0", "listen-port"], "51820\n")
self.respond("ip", ["-o", "link", "show", "dev", "wg-fabric0"],
"16: wg-fabric0: <POINTOPOINT,NOARP,UP,LOWER_UP> mtu 1420 "
"qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000\n")
# ip -o replaces the line break between address and lifetime by a
# backslash. The entire address record must remain one physical line.
self.respond("ip", ["-o", "-4", "address", "show", "dev", "wg-fabric0"],
"16: wg-fabric0 inet 100.64.1.1/32 scope global wg-fabric0\\"
" valid_lft forever preferred_lft forever\n")
live_peers = self.plan.nodes[1:]
self.respond("wg", ["show", "wg-fabric0", "peers"],
"".join(self.keys[node.host_id] + "\n" for node in live_peers))
self.respond("wg", ["show", "wg-fabric0", "endpoints"],
"".join(self.keys[node.host_id] + "\t" + node.endpoint + "\n"
for node in reversed(live_peers)))
self.respond("wg", ["show", "wg-fabric0", "allowed-ips"],
"".join(self.keys[node.host_id] + "\t" + node.allowed_ip + "\n"
for node in reversed(live_peers)))
metric = " metric 50" if manager == "networkmanager_nmcli" else ""
self.routes = "".join(node.overlay_ip + " scope 253" + metric + "\n"
for node in live_peers)
self.routes += ("2 100.64.1.1 table 255 proto 2 scope 254 "
"src 100.64.1.1\n")
self.respond("ip", ["-N", "-o", "route", "show", "table", "all", "dev",
"wg-fabric0"], self.routes)
for node in live_peers:
self.respond("ip", ["route", "get", node.overlay_ip,
"from", "100.64.1.1"],
node.overlay_ip + " from 100.64.1.1 dev wg-fabric0 uid 0\n"
" cache\n")
def respond(self, tool: str, args: list[str], stdout: str, status: int = 0):
self.responses[json.dumps([tool, *args])] = {
"stdout": stdout, "status": status,
}
def add_vpc_member(self):
key = self.keys["2"]
(self.root / "vpc-peers").write_text(key + "|10.1.0.3/32\n")
(self.root / "vpc-tenants").write_text("10.1.0.3/32\n")
(self.root / "vpc-routes").write_text(
"10.1.0.3/32|wg-fabric0|100|100.64.1.2|100\n")
self.respond("nft", ["-s", "list", "table", "inet", "virt_cloud_wg_fabric"],
_nft_rules_text(self.plan.digest).replace(
"flags interval;", "flags interval;\n elements = { 10.1.0.3 }", 1))
self.respond("nft", ["list", "set", "inet", "virt_cloud_wg_fabric", "vpc_tenant_ips"],
"table inet virt_cloud_wg_fabric {\n\tset vpc_tenant_ips {\n"
"\t\ttype ipv4_addr\n\t\tflags interval\n"
"\t\telements = { 10.1.0.3 }\n\t}\n}\n")
self.respond("ip", ["-N", "-o", "route", "show", "table", "all", "dev", "wg-fabric0"],
self.routes + "10.1.0.3 via 100.64.1.2 table 100 proto 186 metric 100\n")
def run(self):
rendered = _apply_script(
self.plan, self.plan.nodes[0], self.keys,
deployment_mode=self.manager, firewall_mode=FIREWALL_MODE_NATIVE)
final = _between(rendered, "vc_fabric_operation_checkpoint final_readback\n",
"_txn_state_tmp=$(mktemp")
final = final.split("\n", 1)[1]
functions = "\n".join((
_FABRIC_NFT_VALIDATION_SH,
_FABRIC_WG_READBACK_SH,
_between(_TRANSACTION_SCRIPT, "nft_panel_owned() {", "snapshot_file() {"),
_between(_VPC_STATE_LOADER, "vpc_state_allowed_for_peer() {",
"vpc_state_route_owned() {"),
_VPC_STATE_LOADER[_VPC_STATE_LOADER.index("vpc_state_nft_set_matches() {"):],
))
env = {**os.environ, "VC_FINAL_ROOT": str(self.root),
"IFACE": "wg-fabric0", "EXPECTED_DIGEST": self.plan.digest,
"FIREWALL_MODE": FIREWALL_MODE_NATIVE,
"MANAGED_PEERS": " ".join(self.keys[n.host_id] for n in self.plan.nodes[1:]),
"MANAGED_ROUTES": " ".join(n.allowed_ip for n in self.plan.nodes[1:]),
"KEY": str(self.root / "private"), "CONF": str(self.root / "config"),
"VPC_PEER_FILE": str(self.root / "vpc-peers"),
"VPC_ROUTE_FILE": str(self.root / "vpc-routes"),
"VPC_TENANT_FILE": str(self.root / "vpc-tenants")}
env.update({name: str(self.root / tool) for name, tool in (
("WG", "wg"), ("IP", "ip"), ("NFT", "nft"))})
(self.root / "responses").write_text(json.dumps(self.responses))
result = subprocess.run(["/bin/sh", "-eu", "-c", functions + "\n" + final],
capture_output=True, text=True, env=env, check=False)
assert "unexpected test tool invocation" not in result.stderr
return result
@pytest.mark.parametrize("manager", ["ifupdown", "networkmanager_nmcli"])
@pytest.mark.parametrize("peers", [1, 2])
def test_actual_final_slice_accepts_debian_and_alma_serialization(tmp_path, manager, peers):
fixture = FinalFixture(tmp_path, manager, peers)
if manager == "networkmanager_nmcli":
rules = _nft_rules_text(fixture.plan.digest).replace(
"hook output priority -100;", "hook output priority dstnat;")
rules = "\n".join(line.replace(" ", "\t") for line in rules.splitlines()) + "\n"
fixture.respond("nft", ["-s", "list", "table", "inet",
"virt_cloud_wg_fabric"], rules)
result = fixture.run()
assert result.returncode == 0, result.stderr
@pytest.mark.parametrize("drift", ["nft", "public-key", "listen-port", "down", "address",
"extra-peer", "endpoint", "allowed", "route", "path"])
def test_actual_final_slice_rejects_mutable_readback_drift(tmp_path, drift):
fixture = FinalFixture(tmp_path, "ifupdown")
key = fixture.keys["2"]
if drift == "nft":
fixture.respond("nft", ["-s", "list", "table", "inet", "virt_cloud_wg_fabric"],
_nft_rules_text(fixture.plan.digest).replace("counter drop", "counter accept", 1))
elif drift in ("public-key", "listen-port"):
fixture.respond("wg", ["show", "wg-fabric0", drift], "wrong\n")
elif drift == "down":
fixture.respond("ip", ["-o", "link", "show", "dev", "wg-fabric0"],
"16: wg-fabric0: <POINTOPOINT,NOARP> mtu 1420\n")
elif drift == "address":
fixture.respond("ip", ["-o", "-4", "address", "show", "dev", "wg-fabric0"],
"16: wg-fabric0 inet 100.64.1.1/24 scope global wg-fabric0\n")
elif drift == "extra-peer":
fixture.respond("wg", ["show", "wg-fabric0", "peers"], key + "\nforeign\n")
elif drift == "endpoint":
fixture.respond("wg", ["show", "wg-fabric0", "endpoints"], key + "\t203.0.113.9:51820\n")
elif drift == "allowed":
fixture.respond("wg", ["show", "wg-fabric0", "allowed-ips"], key + "\t100.64.1.9/32\n")
elif drift == "route":
fixture.respond("ip", ["-N", "-o", "route", "show", "table", "all", "dev", "wg-fabric0"],
fixture.routes + "100.64.1.3 scope link\n")
elif drift == "path":
fixture.respond("ip", ["route", "get", "100.64.1.2", "from", "100.64.1.1"],
"100.64.1.2 from 100.64.1.1 dev br0 uid 0\n cache\n")
result = fixture.run()
assert result.returncode in (71, 78), result.stderr
@pytest.mark.parametrize("manager", ["ifupdown", "networkmanager_nmcli"])
@pytest.mark.parametrize("reverse", [False, True])
@pytest.mark.parametrize("peers", [1, 2])
def test_actual_final_slice_accepts_official_multiple_allowed_ips_serialization(tmp_path, manager, reverse, peers):
fixture = FinalFixture(tmp_path, manager, peers)
key = fixture.keys["2"]
fixture.add_vpc_member()
prefixes = ["100.64.1.2/32", "10.1.0.3/32"]
if reverse:
prefixes.reverse()
fixture.respond("wg", ["show", "wg-fabric0", "allowed-ips"],
key + "\t" + " ".join(prefixes) + "\n" + "".join(
fixture.keys[node.host_id] + "\t" + node.allowed_ip + "\n"
for node in fixture.plan.nodes[2:]))
assert fixture.run().returncode == 0
@pytest.mark.parametrize("drift", ["missing", "extra", "duplicate", "unknown", "multiple-key-fields"])
def test_actual_final_slice_requires_complete_unique_peer_records(tmp_path, drift):
fixture = FinalFixture(tmp_path, "ifupdown", 2)
first, second = fixture.keys["2"], fixture.keys["3"]
if drift == "missing":
actual = first + "\n"
elif drift == "extra":
actual = first + "\n" + second + "\n" + base64.b64encode(bytes([9]) * 32).decode() + "\n"
elif drift == "duplicate":
actual = first + "\n" + second + "\n" + first + "\n"
elif drift == "unknown":
actual = first + "\n" + "bad-key\n"
else:
actual = first + "\t" + second + "\n"
fixture.respond("wg", ["show", "wg-fabric0", "peers"], actual)
assert fixture.run().returncode == 71
@pytest.mark.parametrize("drift", ["wide", "public", "duplicate", "missing", "extra", "csv",
"malformed", "ipv6", "duplicate-peer", "unknown-peer"])
def test_actual_final_slice_multiple_allowed_ips_remains_fail_closed(tmp_path, drift):
fixture = FinalFixture(tmp_path, "ifupdown")
key = fixture.keys["2"]
fixture.add_vpc_member()
values = ["100.64.1.2/32", "10.1.0.3/32"]
if drift == "wide":
values[1] = "10.1.0.3/24"
elif drift == "public":
values[1] = "203.0.113.9/32"
elif drift == "duplicate":
values.append(values[1])
elif drift == "missing":
values.pop()
elif drift == "extra":
values.append("10.1.0.4/32")
elif drift == "malformed":
values[1] = "10.1.0.256/32"
elif drift == "ipv6":
values[1] = "fd00::3/128"
actual = key + "\t" + ("," if drift == "csv" else " ").join(values) + "\n"
if drift == "duplicate-peer":
actual += actual
elif drift == "unknown-peer":
actual += base64.b64encode(bytes([9]) * 32).decode() + "\t10.1.0.9/32\n"
fixture.respond("wg", ["show", "wg-fabric0", "allowed-ips"], actual)
assert fixture.run().returncode == 71
@pytest.mark.parametrize("peers", [1, 2])
@pytest.mark.parametrize("reverse", [False, True])
@pytest.mark.parametrize("vpc", [False, True])
def test_boot_actual_peer_readback_uses_identical_record_validator(tmp_path, peers, reverse, vpc):
fixture = FinalFixture(tmp_path, "ifupdown", peers)
if vpc:
fixture.add_vpc_member()
fixture.respond("wg", ["show", "wg-fabric0", "allowed-ips"],
fixture.keys["2"] + "\t10.1.0.3/32 100.64.1.2/32\n" + "".join(
fixture.keys[node.host_id] + "\t" + node.allowed_ip + "\n"
for node in fixture.plan.nodes[2:]))
live_keys = [fixture.keys[node.host_id] for node in fixture.plan.nodes[1:]]
if reverse:
live_keys.reverse()
fixture.respond("wg", ["show", "wg-fabric0", "peers"], "\n".join(live_keys) + "\n")
(tmp_path / "responses").write_text(json.dumps(fixture.responses))
peer_body = _between(_BOOT_HELPER, 'actual_peers=$("$WG" show "$IFACE" peers',
"actual_fabric_routes=")
allowed = _between(_VPC_STATE_LOADER, "vpc_state_allowed_for_peer() {",
"vpc_state_route_owned() {")
result = subprocess.run(["/bin/sh", "-eu", "-c", _FABRIC_WG_READBACK_SH + "\n" + allowed + "\n" + peer_body],
capture_output=True, text=True, check=False,
env={**os.environ, "VC_FINAL_ROOT": str(tmp_path),
"WG": str(tmp_path / "wg"), "IFACE": "wg-fabric0",
"seen_peers": " ".join(live_keys),
"CONF": str(tmp_path / "config"),
"VPC_PEER_FILE": str(tmp_path / "vpc-peers")})
assert result.returncode == 0, result.stderr