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.
1092 lines
41 KiB
Python
1092 lines
41 KiB
Python
"""Pure VPC private data-plane contract tests.
|
|
|
|
These tests render the host transaction only; real nft/ip/wg and libvirt
|
|
acceptance remains a host-matrix test because this checkout has no network
|
|
namespace or libvirt daemon.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import tempfile
|
|
import xml.etree.ElementTree as ET
|
|
from dataclasses import replace
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from virsh_panel.shell_contracts import IP_RULE_CONVERGENCE_SH
|
|
from virsh_panel.vpc import VPC_SCHEMA_VERSION
|
|
from virsh_panel.vpc_dataplane import (
|
|
VpcDataplaneError,
|
|
VpcPrivateHostAdapter,
|
|
_allowed,
|
|
_member_nics,
|
|
_markers,
|
|
_routes,
|
|
parse_vpc_dataplane_plan,
|
|
patch_private_interface_xml,
|
|
private_guest_network_generation,
|
|
private_guest_routes,
|
|
render_apply_script,
|
|
render_observe_script,
|
|
render_remove_script,
|
|
render_vpc_nft_rules,
|
|
)
|
|
|
|
|
|
WG_KEY = "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE="
|
|
WG_KEY_2 = "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI="
|
|
|
|
|
|
_FAKE_IP_RULE_FUNCTION = r'''
|
|
mock_ip() {
|
|
printf '%s\n' "$*" >> "$VC_RULE_LOG"
|
|
while [ "$#" -gt 0 ]; do
|
|
case "$1" in -*) shift ;; *) break ;; esac
|
|
done
|
|
[ "$1" = rule ] || return 90
|
|
shift
|
|
verb=$1
|
|
shift
|
|
case "$verb" in
|
|
show)
|
|
[ "${VC_RULE_SHOW_FAIL:-no}" != yes ] || return 97
|
|
wanted=
|
|
if [ "$#" -gt 0 ]; then
|
|
[ "$1" = pref ] && [ "$#" = 2 ] || return 91
|
|
wanted=$2
|
|
fi
|
|
awk -F'|' -v wanted="$wanted" 'wanted == "" || $1 == wanted {
|
|
printf "%s: from all to %s", $1, $3
|
|
if ($2 != "-") printf " iif %s", $2
|
|
printf " lookup %s", $4
|
|
if (NF >= 5 && $5 != "-") printf " %s", $5
|
|
printf "\n"
|
|
}' "$VC_RULE_STATE"
|
|
;;
|
|
add)
|
|
[ "$1" = pref ] || return 92
|
|
pref=$2
|
|
shift 2
|
|
iif=-
|
|
if [ "$1" = iif ]; then iif=$2; shift 2; fi
|
|
[ "$1" = to ] || return 93
|
|
destination=$2
|
|
shift 2
|
|
[ "$1" = lookup ] || return 94
|
|
table=$2
|
|
shift 2
|
|
[ "$#" = 0 ] || return 95
|
|
[ "${VC_RULE_FAIL_PREF:-}" != "$pref" ] || return 97
|
|
printf '%s|%s|%s|%s|-\n' "$pref" "$iif" "$destination" "$table" >> "$VC_RULE_STATE"
|
|
;;
|
|
del)
|
|
[ "$1" = pref ] || return 92
|
|
pref=$2
|
|
shift 2
|
|
iif=-
|
|
if [ "$1" = iif ]; then iif=$2; shift 2; fi
|
|
[ "$1" = to ] || return 93
|
|
destination=$2
|
|
shift 2
|
|
[ "$1" = lookup ] || return 94
|
|
table=$2
|
|
shift 2
|
|
[ "$#" = 0 ] || return 95
|
|
awk -F'|' -v pref="$pref" -v iif="$iif" -v destination="$destination" -v table="$table" '
|
|
!($1 == pref && $2 == iif && $3 == destination && $4 == table)
|
|
' "$VC_RULE_STATE" > "$VC_RULE_STATE.tmp" || return 98
|
|
mv "$VC_RULE_STATE.tmp" "$VC_RULE_STATE" || return 98
|
|
;;
|
|
*)
|
|
return 96
|
|
;;
|
|
esac
|
|
}
|
|
'''
|
|
|
|
|
|
def _run_ip_rule_contract(initial_state: str, commands: str, **extra_env: str):
|
|
with tempfile.TemporaryDirectory(prefix="virt-cloud-ip-rule-") as directory:
|
|
root = Path(directory)
|
|
paths = {
|
|
"state": root / "state",
|
|
"log": root / "log",
|
|
"before": root / "rules.before",
|
|
"attempted": root / "rules.attempted",
|
|
"created": root / "rules.created",
|
|
"rollback": root / "rollback",
|
|
}
|
|
for name, path in paths.items():
|
|
path.write_text(initial_state if name == "state" else "")
|
|
script = "\n".join((
|
|
_FAKE_IP_RULE_FUNCTION,
|
|
IP_RULE_CONVERGENCE_SH,
|
|
"IP=mock_ip",
|
|
commands,
|
|
))
|
|
env = dict(os.environ)
|
|
env.update({
|
|
"VC_RULE_STATE": str(paths["state"]),
|
|
"VC_RULE_LOG": str(paths["log"]),
|
|
"VC_BEFORE": str(paths["before"]),
|
|
"VC_ATTEMPTED": str(paths["attempted"]),
|
|
"VC_CREATED": str(paths["created"]),
|
|
"VC_ROLLBACK": str(paths["rollback"]),
|
|
"VC_TXN": str(root),
|
|
})
|
|
env.update(extra_env)
|
|
result = subprocess.run(
|
|
["/bin/sh", "-eu", "-c", script], env=env,
|
|
capture_output=True, text=True, check=False,
|
|
)
|
|
contents = {name: path.read_text().splitlines()
|
|
for name, path in paths.items()}
|
|
return result, contents
|
|
|
|
|
|
def _shell_block(script: str, start: str, end: str) -> str:
|
|
"""Return one rendered production shell block between stable markers."""
|
|
start_at = script.index(start)
|
|
end_at = script.index(end, start_at)
|
|
return script[start_at:end_at]
|
|
|
|
|
|
def _plan():
|
|
return parse_vpc_dataplane_plan({
|
|
"schema_version": VPC_SCHEMA_VERSION,
|
|
"vpc_id": "vpc-hk-dp",
|
|
"region": "hk",
|
|
"fabric_id": "fabric-hk",
|
|
"fabric_revision": 3,
|
|
"cidr": "10.42.0.0/24",
|
|
"desired_revision": 1,
|
|
"operation_id": "vpc-op-dp-0001",
|
|
"subnets": [{"subnet_id": "subnet-a", "cidr": "10.42.0.0/25"}],
|
|
"hosts": [
|
|
{"host_id": "host-a", "members": [{
|
|
"member_id": "member-a",
|
|
"instance_uuid": "11111111-1111-4111-8111-111111111111",
|
|
"private_ip_cidr": "10.42.0.10/32",
|
|
"subnet_id": "subnet-a",
|
|
}]},
|
|
{"host_id": "host-b", "members": [{
|
|
"member_id": "member-b",
|
|
"instance_uuid": "22222222-2222-4222-8222-222222222222",
|
|
"private_ip_cidr": "10.42.0.11/32",
|
|
"subnet_id": "subnet-a",
|
|
}]},
|
|
],
|
|
"routes": [{
|
|
"route_id": "service-a", "destination_cidr": "10.42.0.100/32",
|
|
"next_hop_member_id": "member-b", "metric": 20,
|
|
}],
|
|
"acls": [{
|
|
"acl_id": "allow-https", "direction": "ingress", "action": "allow",
|
|
"protocol": "tcp", "source_cidr": "10.42.0.0/24",
|
|
"destination_cidr": "10.42.0.10/32", "port_from": 443,
|
|
"port_to": 443, "priority": 10,
|
|
}],
|
|
"fabric_peers": [{
|
|
"host_id": "host-b", "public_key": WG_KEY,
|
|
"overlay_ip": "100.64.0.2/32",
|
|
"tenant_allowed_ips": ["10.42.0.11/32", "10.42.0.100/32"],
|
|
}],
|
|
}, "host-a")
|
|
|
|
|
|
def _guest_network_evidence(member, routes):
|
|
return {
|
|
"state": "confirmed",
|
|
"verified": True,
|
|
"source": "qemu_guest_agent",
|
|
"private_mac": member.private_mac,
|
|
"private_ip_cidr": f"{member.private_ip}/32",
|
|
"link_state": "up",
|
|
"routes": sorted(routes),
|
|
"reason_code": None,
|
|
"observed_at": 1_700_000_000,
|
|
}
|
|
|
|
|
|
def test_rendered_data_plane_has_exact_routes_proxy_arp_and_atomic_nft_batch():
|
|
plan = _plan()
|
|
apply = render_apply_script(plan)
|
|
nft = render_vpc_nft_rules(plan)
|
|
assert "10.42.0.11/32|wg-fabric0" in apply
|
|
assert "10.42.0.100/32|wg-fabric0" in apply
|
|
assert 'route replace "$destination" table "$table" via "$via" dev "$device" onlink' in apply
|
|
assert 'neigh replace proxy "$proxy_ip"' in apply
|
|
assert "table arp" in nft
|
|
assert "arp-proxy-output" in nft
|
|
assert 'proxy_arp = 0' in apply
|
|
assert 'proxy_arp_pvlan = 1' in apply
|
|
assert 'NFT_BATCH="$TXN/apply.nft"' in apply
|
|
assert '"$NFT" -f "$NFT_BATCH"' in apply
|
|
scope_call = (
|
|
f'vc_ip_rule_scope_check {plan.vpc.cidr} "$ROUTE_TABLE"')
|
|
assert apply.index(scope_call) < apply.index(
|
|
"trap rollback EXIT HUP INT TERM")
|
|
assert '"$NFT" delete table inet "$TABLE"' not in apply
|
|
assert "anti-spoof-public-to-bridge" in nft
|
|
assert "anti-spoof-public-to-fabric" in nft
|
|
assert "anti-spoof-bridge-to-foreign" in nft
|
|
assert "anti-spoof-fabric-to-foreign" in nft
|
|
assert 'oifname "wg-fabric0" ip daddr @vpc_dest_ips drop' in nft
|
|
assert (
|
|
"arp operation request arp daddr ip != @local_dest_ips drop"
|
|
in nft
|
|
)
|
|
assert "bridge-unknown-arp-target-drop" in nft
|
|
|
|
|
|
def test_rendered_scripts_are_posix_shell():
|
|
plan = _plan()
|
|
for script in (render_apply_script(plan), render_observe_script(plan)):
|
|
result = subprocess.run(
|
|
["/bin/sh", "-n"], input=script, text=True,
|
|
capture_output=True, check=False,
|
|
)
|
|
assert result.returncode == 0, result.stderr
|
|
|
|
|
|
def test_generated_ip_rule_verbs_are_supported_by_iproute2():
|
|
from virsh_panel.fabric import _BOOT_HELPER
|
|
|
|
plan = _plan()
|
|
empty_host = replace(
|
|
plan,
|
|
members=tuple(member for member in plan.members
|
|
if member.host_id != plan.host_id),
|
|
)
|
|
scripts = (
|
|
render_apply_script(plan),
|
|
render_observe_script(plan),
|
|
render_remove_script(empty_host),
|
|
_BOOT_HELPER,
|
|
)
|
|
command = re.compile(
|
|
r'"?\$IP"?\s+(?:(?:-[A-Za-z0-9]+)\s+)*rule\s+([a-z]+)')
|
|
for script in scripts:
|
|
verbs = command.findall(script)
|
|
assert verbs
|
|
assert set(verbs) <= {"show", "add", "del"}
|
|
assert "rule replace" not in script
|
|
|
|
|
|
def test_ip_rule_convergence_adds_only_missing_rules_and_replays_without_writes():
|
|
commands = r'''
|
|
vc_ip_rule_preflight 20000 - 10.42.0.0/24 10000 71 72 "$VC_BEFORE" || exit $?
|
|
vc_ip_rule_preflight 20001 wg-fabric0 10.42.0.0/24 10000 71 72 "$VC_BEFORE" || exit $?
|
|
vc_ip_rule_ensure 20000 - 10.42.0.0/24 10000 71 72 "$VC_ATTEMPTED" "$VC_CREATED" || exit $?
|
|
vc_ip_rule_ensure 20001 wg-fabric0 10.42.0.0/24 10000 71 72 "$VC_ATTEMPTED" "$VC_CREATED" || exit $?
|
|
vc_ip_rule_ensure 20000 - 10.42.0.0/24 10000 71 72 "$VC_ATTEMPTED" "$VC_CREATED" || exit $?
|
|
vc_ip_rule_ensure 20001 wg-fabric0 10.42.0.0/24 10000 71 72 "$VC_ATTEMPTED" "$VC_CREATED" || exit $?
|
|
'''
|
|
result, contents = _run_ip_rule_contract("", commands)
|
|
assert result.returncode == 0, result.stderr
|
|
assert contents["state"] == [
|
|
"20000|-|10.42.0.0/24|10000|-",
|
|
"20001|wg-fabric0|10.42.0.0/24|10000|-",
|
|
]
|
|
assert contents["attempted"] == [
|
|
"20000|-|10.42.0.0/24|10000",
|
|
"20001|wg-fabric0|10.42.0.0/24|10000",
|
|
]
|
|
assert contents["created"] == contents["attempted"]
|
|
assert sum(" rule add " in f" {line} " for line in contents["log"]) == 2
|
|
assert all("rule replace" not in line for line in contents["log"])
|
|
|
|
existing = "\n".join(contents["state"]) + "\n"
|
|
result, replay = _run_ip_rule_contract(existing, commands)
|
|
assert result.returncode == 0, result.stderr
|
|
assert replay["state"] == contents["state"]
|
|
assert replay["attempted"] == []
|
|
assert replay["created"] == []
|
|
assert replay["before"] == [
|
|
"20000|-|10.42.0.0/24|10000",
|
|
"20001|wg-fabric0|10.42.0.0/24|10000",
|
|
]
|
|
assert all(" rule add " not in f" {line} " for line in replay["log"])
|
|
|
|
|
|
def test_ip_rule_preflight_rejects_conflicts_duplicates_and_extra_selectors():
|
|
command = (
|
|
'vc_ip_rule_preflight 20000 - 10.42.0.0/24 10000 '
|
|
'71 72 "$VC_BEFORE" || exit $?'
|
|
)
|
|
invalid_states = (
|
|
"20000|-|10.99.0.0/24|10000|-\n",
|
|
"20000|-|10.42.0.0/24|10000|-\n"
|
|
"20000|-|10.42.0.0/24|10000|-\n",
|
|
"20000|-|10.42.0.0/24|10000|fwmark 0x1\n",
|
|
)
|
|
for initial in invalid_states:
|
|
result, contents = _run_ip_rule_contract(initial, command)
|
|
assert result.returncode == 71
|
|
assert contents["state"] == initial.splitlines()
|
|
assert contents["before"] == []
|
|
assert all(" rule add " not in f" {line} "
|
|
for line in contents["log"])
|
|
|
|
|
|
def test_ip_rule_scope_rejects_foreign_rules_and_can_require_empty_scope():
|
|
managed = (
|
|
"vc_ip_rule_scope_check 10.42.0.0/24 10000 20000 "
|
|
"wg-fabric0 managed 71 72 || exit $?"
|
|
)
|
|
exact = (
|
|
"20000|-|10.42.0.0/24|10000|-\n"
|
|
"20001|wg-fabric0|10.42.0.0/24|10000|-\n"
|
|
)
|
|
result, contents = _run_ip_rule_contract(exact, managed)
|
|
assert result.returncode == 0, result.stderr
|
|
assert contents["state"] == exact.splitlines()
|
|
|
|
foreign_states = (
|
|
exact + "19999|-|10.42.0.0/24|10001|-\n",
|
|
exact + "20100|-|10.99.0.0/24|10000|-\n",
|
|
exact + "20000|-|10.42.0.0/24|10000|fwmark 0x1\n",
|
|
)
|
|
for initial in foreign_states:
|
|
result, contents = _run_ip_rule_contract(initial, managed)
|
|
assert result.returncode == 71
|
|
assert contents["state"] == initial.splitlines()
|
|
assert all(" rule add " not in f" {line} "
|
|
for line in contents["log"])
|
|
|
|
unrelated = "19999|-|10.99.0.0/24|10001|-\n"
|
|
result, _contents = _run_ip_rule_contract(unrelated, managed)
|
|
assert result.returncode == 0, result.stderr
|
|
empty = (
|
|
"vc_ip_rule_scope_check 10.42.0.0/24 10000 20000 "
|
|
"wg-fabric0 empty 71 72 || exit $?"
|
|
)
|
|
result, _contents = _run_ip_rule_contract(exact, empty)
|
|
assert result.returncode == 71
|
|
result, contents = _run_ip_rule_contract(unrelated, empty)
|
|
assert result.returncode == 0, result.stderr
|
|
assert contents["state"] == unrelated.splitlines()
|
|
result, contents = _run_ip_rule_contract(
|
|
exact, managed, VC_RULE_SHOW_FAIL="yes")
|
|
assert result.returncode == 72
|
|
assert contents["state"] == exact.splitlines()
|
|
|
|
|
|
def test_ip_rule_failed_add_is_attempted_but_not_claimed_as_created():
|
|
commands = r'''
|
|
vc_ip_rule_preflight 20000 - 10.42.0.0/24 10000 71 72 "$VC_BEFORE" || exit $?
|
|
vc_ip_rule_preflight 20001 wg-fabric0 10.42.0.0/24 10000 71 72 "$VC_BEFORE" || exit $?
|
|
vc_ip_rule_ensure 20000 - 10.42.0.0/24 10000 71 72 "$VC_ATTEMPTED" "$VC_CREATED" || exit $?
|
|
vc_ip_rule_ensure 20001 wg-fabric0 10.42.0.0/24 10000 71 72 "$VC_ATTEMPTED" "$VC_CREATED" || exit $?
|
|
'''
|
|
result, contents = _run_ip_rule_contract(
|
|
"", commands, VC_RULE_FAIL_PREF="20001")
|
|
assert result.returncode == 72
|
|
assert contents["state"] == ["20000|-|10.42.0.0/24|10000|-"]
|
|
assert contents["attempted"] == [
|
|
"20000|-|10.42.0.0/24|10000",
|
|
"20001|wg-fabric0|10.42.0.0/24|10000",
|
|
]
|
|
assert contents["created"] == ["20000|-|10.42.0.0/24|10000"]
|
|
apply = render_apply_script(_plan())
|
|
assert 'done < "$TXN/rules.attempted"' in apply
|
|
assert 'grep -Fqx "$rule_pref|$rule_iif|$rule_to|$rule_table" "$TXN/rules.created"' in apply
|
|
|
|
|
|
def test_production_ip_rule_rollback_removes_only_rules_created_by_failed_apply():
|
|
plan = _plan()
|
|
apply = render_apply_script(plan)
|
|
apply_rules = "\n".join((
|
|
_shell_block(
|
|
apply,
|
|
"# vc-policy-rule-preflight-begin",
|
|
"# vc-policy-rule-preflight-end",
|
|
),
|
|
_shell_block(
|
|
apply,
|
|
"# vc-policy-rule-ensure-begin",
|
|
"# vc-policy-rule-ensure-end",
|
|
),
|
|
))
|
|
rollback_rules = _shell_block(
|
|
apply,
|
|
"# vc-policy-rule-rollback-begin",
|
|
"# vc-policy-rule-rollback-end",
|
|
)
|
|
priority = plan.resources.rule_priority
|
|
table = plan.resources.route_table
|
|
cidr = str(plan.vpc.cidr)
|
|
commands = f'''\
|
|
TXN="$VC_TXN"
|
|
RULE_PRIORITY={priority}
|
|
WG_RULE_PRIORITY=$((RULE_PRIORITY + 1))
|
|
WG_IFACE=wg-fabric0
|
|
ROUTE_TABLE={table}
|
|
ROLLBACK_FAILED=no
|
|
production_rule_rollback() {{
|
|
{rollback_rules}
|
|
}}
|
|
production_rollback_on_exit() {{
|
|
status=$?
|
|
trap - EXIT
|
|
set +e
|
|
production_rule_rollback
|
|
printf '%s\\n' "$ROLLBACK_FAILED" > "$VC_ROLLBACK"
|
|
exit "$status"
|
|
}}
|
|
trap production_rollback_on_exit EXIT
|
|
{apply_rules}
|
|
trap - EXIT
|
|
'''
|
|
failed_priority = str(priority + 1)
|
|
|
|
result, fresh = _run_ip_rule_contract(
|
|
"", commands, VC_RULE_FAIL_PREF=failed_priority)
|
|
assert result.returncode == 73, result.stderr
|
|
assert fresh["state"] == []
|
|
assert fresh["attempted"] == [
|
|
f"{priority}|-|{cidr}|{table}",
|
|
f"{priority + 1}|wg-fabric0|{cidr}|{table}",
|
|
]
|
|
assert fresh["created"] == [f"{priority}|-|{cidr}|{table}"]
|
|
assert fresh["rollback"] == ["no"]
|
|
assert any(
|
|
f" rule del pref {priority} to {cidr} lookup {table}" in f" {line}"
|
|
for line in fresh["log"]
|
|
)
|
|
assert all(
|
|
f" rule del pref {priority + 1} " not in f" {line} "
|
|
for line in fresh["log"]
|
|
)
|
|
|
|
preexisting = f"{priority}|-|{cidr}|{table}|-\n"
|
|
result, replay = _run_ip_rule_contract(
|
|
preexisting, commands, VC_RULE_FAIL_PREF=failed_priority)
|
|
assert result.returncode == 73, result.stderr
|
|
assert replay["state"] == preexisting.splitlines()
|
|
assert replay["before"] == [f"{priority}|-|{cidr}|{table}"]
|
|
assert replay["attempted"] == [
|
|
f"{priority + 1}|wg-fabric0|{cidr}|{table}",
|
|
]
|
|
assert replay["created"] == []
|
|
assert replay["rollback"] == ["no"]
|
|
assert all(" rule del " not in f" {line} " for line in replay["log"])
|
|
|
|
|
|
def test_remove_script_checks_ownership_before_destructive_cleanup():
|
|
plan = _plan()
|
|
empty_host = replace(
|
|
plan,
|
|
members=tuple(member for member in plan.members
|
|
if member.host_id != plan.host_id),
|
|
)
|
|
for mode in ("networkmanager_nmcli", "ifupdown"):
|
|
script = render_remove_script(empty_host, deployment_mode=mode)
|
|
result = subprocess.run(
|
|
["/bin/sh", "-n"], input=script, text=True,
|
|
capture_output=True, check=False,
|
|
)
|
|
assert result.returncode == 0, result.stderr
|
|
assert 'connection.stable-id' in script
|
|
assert 'nm_empty ipv4.routes' in script
|
|
assert "virt-cloud-vpc-dataplane-v1 vpc=" in script
|
|
assert 'nft_table_count' in script
|
|
assert '[ "$name" = "$TABLE" ]' in script
|
|
assert 'BRIDGE_PRESENT=no' in script
|
|
assert 'if "$IP" link show dev "$BRIDGE"' in script
|
|
assert 'bridge_routes6' in script
|
|
assert 'proxy_left' in script
|
|
for phase in (
|
|
"routes_removed", "manager_removed", "bridge_removed",
|
|
"nft_removed", "files_removed", "wg_merged", "committed",
|
|
):
|
|
assert f"set_phase {phase}" in script
|
|
assert '[ "$RESUME" = yes ]' in script
|
|
assert 'committed)' in script
|
|
assert 'files_removed|wg_merged)' in script
|
|
assert script.index("exec 8>>") < script.index('exec 9>>"$LOCK"')
|
|
assert '"$IP" -o -4 -N rule show pref' in script
|
|
assert 'route show table "$ROUTE_TABLE" 2>/dev/null) || return 1' in script
|
|
assert 'route show table "$ROUTE_TABLE" 2>/dev/null) || exit 72' in script
|
|
assert "vc_ip_rule_scope_check" in script
|
|
assert "managed 71 72" in script
|
|
assert "empty 1 1" in script
|
|
assert "empty 71 72" in script
|
|
identity_check = 'vc_vpc_artifact_identity_check "$nft_identity"'
|
|
assert script.index(identity_check) < script.index(
|
|
'mkdir -m 700 "$TXN"')
|
|
assert script.index(identity_check) < script.index(
|
|
'"$IP" route del "$destination"')
|
|
assert script.index(identity_check) < script.index(
|
|
'"$NFT" delete table "$family" "$name"')
|
|
|
|
|
|
def test_remove_artifact_identity_allows_older_revision_only():
|
|
plan = _plan()
|
|
delete_plan = replace(
|
|
plan,
|
|
vpc=replace(
|
|
plan.vpc,
|
|
desired_revision=2,
|
|
desired_digest="b" * 64,
|
|
),
|
|
members=tuple(member for member in plan.members
|
|
if member.host_id != plan.host_id),
|
|
)
|
|
script = render_remove_script(delete_plan)
|
|
function = re.search(
|
|
r"(?ms)^vc_vpc_artifact_identity_check\(\) \{.*?^\}\n",
|
|
script,
|
|
)
|
|
assert function is not None
|
|
contract = function.group(0) + r'''
|
|
vc_vpc_artifact_identity_check "vpc=vpc-hk-dp revision=1 digest=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" || exit 81
|
|
vc_vpc_artifact_identity_check "vpc=vpc-hk-dp revision=2 digest=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" || exit 82
|
|
if vc_vpc_artifact_identity_check "vpc=vpc-hk-dp revision=2 digest=cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"; then exit 83; fi
|
|
if vc_vpc_artifact_identity_check "vpc=vpc-hk-dp revision=3 digest=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; then exit 84; fi
|
|
if vc_vpc_artifact_identity_check "vpc=foreign revision=1 digest=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; then exit 85; fi
|
|
exit 0
|
|
'''
|
|
result = subprocess.run(
|
|
["/bin/sh"], input=contract, text=True,
|
|
capture_output=True, check=False,
|
|
)
|
|
assert result.returncode == 0, result.stderr
|
|
|
|
|
|
def test_proxy_markers_are_bounded_and_typed():
|
|
parsed = _markers(
|
|
"__VC_VPC_PROXY_ARP__=0\n"
|
|
"__VC_VPC_PROXY_ARP_PVLAN__=1\n"
|
|
"__VC_VPC_PROXY_STATE__=owned\n"
|
|
"__VC_VPC_PROXY_IP__=10.42.0.11\n"
|
|
)
|
|
assert parsed["proxy_arp"] == "0"
|
|
assert parsed["proxy_arp_pvlan"] == "1"
|
|
assert parsed["proxy_state"] == "owned"
|
|
assert parsed["proxy_ips"] == ["10.42.0.11"]
|
|
|
|
|
|
def test_peer_allowed_ips_are_closed_over_vpc_or_trusted_fabric_set():
|
|
plan = _plan()
|
|
payload = plan.vpc.canonical()
|
|
payload["fabric_peers"] = [{
|
|
"host_id": "host-b", "public_key": WG_KEY,
|
|
"overlay_ip": "100.64.0.2/32",
|
|
"tenant_allowed_ips": ["10.42.0.11/32", "10.42.0.100/32",
|
|
"10.42.0.200/32"],
|
|
}]
|
|
try:
|
|
parse_vpc_dataplane_plan(payload, "host-a")
|
|
except Exception as exc:
|
|
assert getattr(exc, "error_code", None) == "vpc_tenant_allowed_ip_unowned"
|
|
else:
|
|
raise AssertionError("unowned peer AllowedIP was accepted")
|
|
|
|
parsed = parse_vpc_dataplane_plan(
|
|
payload, "host-a",
|
|
trusted_tenant_allowed_ips={
|
|
"host-b": ["10.42.0.11/32", "10.42.0.100/32",
|
|
"10.42.0.200/32"],
|
|
})
|
|
assert parsed.peers[0].tenant_allowed_ips[-1] == "10.42.0.200/32"
|
|
|
|
|
|
def test_observe_can_require_the_complete_authoritative_fabric_peer_set():
|
|
plan = _plan()
|
|
strict = parse_vpc_dataplane_plan(
|
|
plan.vpc.canonical(), "host-a",
|
|
fabric_peers=[{
|
|
"host_id": "host-b", "public_key": WG_KEY,
|
|
"overlay_ip": "100.64.0.2/32",
|
|
"tenant_allowed_ips": ["10.42.0.11/32", "10.42.0.100/32"],
|
|
}],
|
|
trusted_tenant_allowed_ips={
|
|
"host-b": ["10.42.0.11/32", "10.42.0.100/32"],
|
|
},
|
|
fabric_peer_keys=[WG_KEY, WG_KEY_2],
|
|
)
|
|
assert strict.fabric_peer_keys == frozenset({WG_KEY, WG_KEY_2})
|
|
observe = render_observe_script(strict)
|
|
assert "__VC_VPC_WG_PEER_SET__" in observe
|
|
assert "live_fabric_peer_keys" in observe
|
|
try:
|
|
parse_vpc_dataplane_plan(
|
|
plan.vpc.canonical(), "host-a",
|
|
fabric_peers=[{
|
|
"host_id": "host-b", "public_key": WG_KEY,
|
|
"overlay_ip": "100.64.0.2/32",
|
|
"tenant_allowed_ips": ["10.42.0.11/32", "10.42.0.100/32"],
|
|
}],
|
|
trusted_tenant_allowed_ips={
|
|
"host-b": ["10.42.0.11/32", "10.42.0.100/32"],
|
|
},
|
|
fabric_peer_keys=[WG_KEY_2],
|
|
)
|
|
except Exception as exc:
|
|
assert getattr(exc, "error_code", None) == "vpc_fabric_peer_set_invalid"
|
|
else:
|
|
raise AssertionError("VPC peer outside authoritative Fabric set was accepted")
|
|
|
|
|
|
def test_private_xml_patch_migrates_pre_fix_aliases_and_leaves_private_filter_free():
|
|
plan = _plan()
|
|
member = plan.members[0]
|
|
xml = """<domain><metadata/><devices>
|
|
<interface type='bridge'><mac address='52:54:00:00:00:01'/>
|
|
<alias name='public0'/><source bridge='br0'/></interface>
|
|
</devices></domain>"""
|
|
patched = patch_private_interface_xml(
|
|
xml, member=member, resources=plan.resources,
|
|
guest_network_generation=private_guest_network_generation(
|
|
member, private_guest_routes(plan.vpc, member)),
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
assert 'alias name="ua-public0"' in patched
|
|
assert 'alias name="ua-private0"' in patched
|
|
assert 'alias name="public0"' not in patched
|
|
assert 'alias name="private0"' not in patched
|
|
assert f'bridge="{plan.resources.bridge}"' in patched
|
|
assert 'filter="clean-traffic"' not in patched
|
|
assert f'private-network-digest="{plan.desired_digest}"' in patched
|
|
|
|
|
|
def test_private_xml_patch_promotes_legacy_public_aliases_idempotently():
|
|
plan = _plan()
|
|
member = plan.members[0]
|
|
for alias in (None, "net0", "ua-net-0"):
|
|
alias_xml = "" if alias is None else f"<alias name='{alias}'/>"
|
|
legacy = f"""<domain><devices>
|
|
<interface type='bridge'><mac address='52:54:00:00:00:01'/>
|
|
{alias_xml}<source bridge='br0'/></interface>
|
|
</devices></domain>"""
|
|
patched = patch_private_interface_xml(
|
|
legacy, member=member, resources=plan.resources,
|
|
guest_network_generation=private_guest_network_generation(
|
|
member, private_guest_routes(plan.vpc, member)),
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
assert patched.count('alias name="ua-public0"') == 1
|
|
assert patched.count('alias name="ua-private0"') == 1
|
|
# A second reconciliation must still identify the original NIC as public.
|
|
reparsed = patch_private_interface_xml(
|
|
patched, member=member, resources=plan.resources,
|
|
guest_network_generation=private_guest_network_generation(
|
|
member, private_guest_routes(plan.vpc, member)),
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
assert reparsed.count('alias name="ua-public0"') == 1
|
|
assert reparsed.count('alias name="ua-private0"') == 1
|
|
|
|
|
|
def test_private_xml_patch_rejects_domain_wide_alias_collision():
|
|
plan = _plan()
|
|
for collision, public_alias in (
|
|
("ua-public0", "net0"),
|
|
("ua-private0", "ua-public0"),
|
|
):
|
|
xml = f"""<domain><devices>
|
|
<disk type='file'><alias name='{collision}'/></disk>
|
|
<interface type='bridge'><mac address='52:54:00:00:00:01'/>
|
|
<alias name='{public_alias}'/><source bridge='br0'/></interface>
|
|
</devices></domain>"""
|
|
try:
|
|
patch_private_interface_xml(
|
|
xml, member=plan.members[0], resources=plan.resources,
|
|
guest_network_generation=private_guest_network_generation(
|
|
plan.members[0],
|
|
private_guest_routes(plan.vpc, plan.members[0])),
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
except VpcDataplaneError as exc:
|
|
assert exc.status == 409
|
|
assert exc.error_code == "vpc_private_xml_role_invalid"
|
|
else:
|
|
raise AssertionError("domain-wide duplicate libvirt alias was accepted")
|
|
|
|
|
|
def test_guest_network_generation_is_stable_across_member_and_route_churn():
|
|
plan = _plan()
|
|
member = plan.local_members[0]
|
|
routes = private_guest_routes(plan.vpc, member)
|
|
assert routes == ("10.42.0.0/24",)
|
|
expected = private_guest_network_generation(member, routes)
|
|
assert private_guest_routes(
|
|
replace(plan.vpc, routes=()), member) == routes
|
|
assert private_guest_routes(
|
|
replace(plan.vpc, members=(member,)), member) == routes
|
|
wider = private_guest_routes(
|
|
replace(plan.vpc, cidr="10.42.0.0/16"), member)
|
|
assert private_guest_network_generation(member, wider) != expected
|
|
for invalid in ((), ("10.42.0.11/32",),
|
|
("10.42.0.0/24", "10.42.0.11/32")):
|
|
with pytest.raises(VpcDataplaneError):
|
|
private_guest_network_generation(member, invalid)
|
|
|
|
|
|
def test_running_member_requires_booted_guest_network_generation():
|
|
plan = _plan()
|
|
member = plan.local_members[0]
|
|
routes = private_guest_routes(plan.vpc, member)
|
|
generation = private_guest_network_generation(member, routes)
|
|
original = """<domain><metadata/><devices>
|
|
<interface type='bridge'><mac address='52:54:00:00:00:01'/>
|
|
<alias name='ua-public0'/><source bridge='br0'/></interface>
|
|
</devices></domain>"""
|
|
persistent = patch_private_interface_xml(
|
|
original, member=member, resources=plan.resources,
|
|
guest_network_generation=generation,
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
stale_live_root = ET.fromstring(persistent)
|
|
stale_managed = stale_live_root.find(
|
|
"./metadata/{urn:virsh-panel:1}managed")
|
|
stale_managed.attrib.pop("private-guest-network-generation")
|
|
stale_live = ET.tostring(stale_live_root, encoding="unicode")
|
|
|
|
pending = _member_nics(plan, {
|
|
member.instance_uuid: {
|
|
"inactive": persistent,
|
|
"live": stale_live,
|
|
},
|
|
})[0]
|
|
# Device identity is present in both definitions, but the stale live
|
|
# generation means this running guest still needs a full restart before
|
|
# a missing guest-agent proof can be treated as potentially curable.
|
|
# Legacy v1 observations did not carry physical seed proof. Even with
|
|
# matching XML device identity they must remain non-usable.
|
|
assert pending["xml_verified"] is False
|
|
assert pending["config_verified"] is True
|
|
assert pending["guest_network_verified"] is False
|
|
assert pending["restart_required"] is True
|
|
|
|
booted = _member_nics(plan, {
|
|
member.instance_uuid: {
|
|
"inactive": persistent,
|
|
"live": persistent,
|
|
"seed_verified": True,
|
|
"guest_network": _guest_network_evidence(member, routes),
|
|
},
|
|
})[0]
|
|
assert booted["xml_verified"] is True
|
|
assert booted["config_verified"] is True
|
|
assert booted["domain_running"] is True
|
|
assert booted["guest_network_verified"] is True
|
|
assert booted["guest_private_ip_cidr"] == f"{member.private_ip}/32"
|
|
assert booted["guest_routes"] == sorted(routes)
|
|
assert booted["restart_required"] is False
|
|
|
|
|
|
def test_booted_generation_fails_closed_when_guest_evidence_is_unavailable():
|
|
plan = _plan()
|
|
member = plan.local_members[0]
|
|
routes = private_guest_routes(plan.vpc, member)
|
|
persistent = patch_private_interface_xml(
|
|
"""<domain><metadata/><devices>
|
|
<interface type='bridge'><mac address='52:54:00:00:00:01'/>
|
|
<alias name='ua-public0'/><source bridge='br0'/></interface>
|
|
</devices></domain>""",
|
|
member=member, resources=plan.resources,
|
|
guest_network_generation=private_guest_network_generation(
|
|
member, routes),
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
|
|
observed = _member_nics(plan, {
|
|
member.instance_uuid: {
|
|
"inactive": persistent,
|
|
"live": persistent,
|
|
"seed_verified": True,
|
|
"guest_network": {
|
|
"state": "unavailable", "verified": False,
|
|
"reason_code": "vpc_private_guest_agent_unavailable",
|
|
},
|
|
},
|
|
})[0]
|
|
|
|
assert observed["config_verified"] is True
|
|
assert observed["xml_verified"] is True
|
|
assert observed["domain_running"] is True
|
|
assert observed["guest_network_verified"] is False
|
|
assert observed["guest_network_readback"] == "unavailable"
|
|
assert observed["guest_reason_code"] == (
|
|
"vpc_private_guest_agent_unavailable")
|
|
# The generation is current, so a restart would not cure an unavailable
|
|
# agent. The host remains non-active for the guest-specific reason.
|
|
assert observed["restart_required"] is False
|
|
|
|
|
|
def test_booted_generation_rejects_guest_address_or_route_mismatch():
|
|
plan = _plan()
|
|
member = plan.local_members[0]
|
|
routes = private_guest_routes(plan.vpc, member)
|
|
persistent = patch_private_interface_xml(
|
|
"""<domain><metadata/><devices>
|
|
<interface type='bridge'><mac address='52:54:00:00:00:01'/>
|
|
<alias name='ua-public0'/><source bridge='br0'/></interface>
|
|
</devices></domain>""",
|
|
member=member, resources=plan.resources,
|
|
guest_network_generation=private_guest_network_generation(
|
|
member, routes),
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
mismatch = _guest_network_evidence(member, routes)
|
|
mismatch.update({
|
|
"state": "mismatch", "verified": False,
|
|
"private_ip_cidr": "10.42.0.99/32",
|
|
"routes": [],
|
|
"reason_code": "vpc_private_guest_address_mismatch",
|
|
})
|
|
|
|
observed = _member_nics(plan, {
|
|
member.instance_uuid: {
|
|
"inactive": persistent,
|
|
"live": persistent,
|
|
"seed_verified": True,
|
|
"guest_network": mismatch,
|
|
},
|
|
})[0]
|
|
|
|
assert observed["config_verified"] is True
|
|
assert observed["xml_verified"] is True
|
|
assert observed["guest_network_verified"] is False
|
|
assert observed["guest_private_ip_cidr"] == "10.42.0.99/32"
|
|
assert observed["guest_routes"] == []
|
|
assert observed["guest_reason_code"] == (
|
|
"vpc_private_guest_address_mismatch")
|
|
assert observed["restart_required"] is False
|
|
|
|
|
|
def test_stopped_member_preserves_config_proof_but_is_not_runtime_verified():
|
|
plan = _plan()
|
|
member = plan.local_members[0]
|
|
routes = private_guest_routes(plan.vpc, member)
|
|
persistent = patch_private_interface_xml(
|
|
"""<domain><metadata/><devices>
|
|
<interface type='bridge'><mac address='52:54:00:00:00:01'/>
|
|
<alias name='ua-public0'/><source bridge='br0'/></interface>
|
|
</devices></domain>""",
|
|
member=member, resources=plan.resources,
|
|
guest_network_generation=private_guest_network_generation(
|
|
member, routes),
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
|
|
observed = _member_nics(plan, {
|
|
member.instance_uuid: {
|
|
"inactive": persistent,
|
|
"live": None,
|
|
"seed_verified": True,
|
|
"guest_network": {
|
|
"state": "stopped", "verified": False,
|
|
"reason_code": "vpc_private_guest_stopped",
|
|
},
|
|
},
|
|
})[0]
|
|
|
|
assert observed["config_verified"] is True
|
|
assert observed["domain_running"] is False
|
|
assert observed["xml_verified"] is True
|
|
assert observed["guest_network_verified"] is False
|
|
assert observed["restart_required"] is False
|
|
assert observed["guest_reason_code"] == (
|
|
"vpc_private_guest_stopped")
|
|
|
|
|
|
def _active_observation_markers(plan):
|
|
markers = [
|
|
f"__VC_VPC_BRIDGE__={plan.resources.bridge}",
|
|
"__VC_VPC_BRIDGE_OWNER__=virt-cloud-vpc-dataplane-v1",
|
|
"__VC_VPC_PERSISTENCE__=yes",
|
|
"__VC_VPC_BRIDGE_BOUNDARY__=yes",
|
|
"__VC_VPC_PROXY_ARP__=0",
|
|
"__VC_VPC_PROXY_ARP_PVLAN__=1",
|
|
"__VC_VPC_PROXY_STATE__=owned",
|
|
"__VC_VPC_RP_FILTER__=2",
|
|
f"__VC_VPC_NFT_TABLE__={plan.resources.nft_table}",
|
|
"__VC_VPC_STATE_OWNER__=owned",
|
|
f"__VC_VPC_STATE_REVISION__={plan.desired_revision}",
|
|
f"__VC_VPC_STATE_DIGEST__={plan.desired_digest}",
|
|
f"__VC_VPC_ACL_REVISION__={plan.desired_revision}",
|
|
f"__VC_VPC_ACL_DIGEST__={plan.desired_digest}",
|
|
"__VC_VPC_ANTI_SPOOF__=yes",
|
|
"__VC_VPC_BRIDGE_NFT__=yes",
|
|
"__VC_VPC_ROUTE_EXTRA__=no",
|
|
"__VC_VPC_RULE_EXTRA__=no",
|
|
"__VC_VPC_ARP_NFT__=yes",
|
|
]
|
|
for route in _routes(plan):
|
|
markers.append(
|
|
"__VC_VPC_ROUTE__="
|
|
f"{route['destination_cidr']}|{route['device']}|"
|
|
f"{route['table']}|{route.get('via') or '-'}|"
|
|
f"{route.get('metric', 100)}|owned")
|
|
markers.append(
|
|
"__VC_VPC_PROXY_IP__="
|
|
f"{route['destination_cidr'].removesuffix('/32')}")
|
|
markers.extend((
|
|
"__VC_VPC_RULE__="
|
|
f"{plan.resources.rule_priority}|-|{plan.vpc.cidr}|"
|
|
f"{plan.resources.route_table}|owned",
|
|
"__VC_VPC_RULE__="
|
|
f"{plan.resources.rule_priority + 1}|wg-fabric0|{plan.vpc.cidr}|"
|
|
f"{plan.resources.route_table}|owned",
|
|
))
|
|
for peer in plan.peers:
|
|
markers.extend((
|
|
f"__VC_VPC_WG_ALLOWED__={peer.host_id}|{peer.public_key}|"
|
|
f"{_allowed(plan, peer)}",
|
|
f"__VC_VPC_WG_STATE__={peer.host_id}|owned",
|
|
))
|
|
return markers
|
|
|
|
|
|
def test_observer_does_not_activate_unavailable_or_mismatched_guest():
|
|
plan = _plan()
|
|
member = plan.local_members[0]
|
|
routes = private_guest_routes(plan.vpc, member)
|
|
persistent = patch_private_interface_xml(
|
|
"""<domain><metadata/><devices>
|
|
<interface type='bridge'><mac address='52:54:00:00:00:01'/>
|
|
<alias name='ua-public0'/><source bridge='br0'/></interface>
|
|
</devices></domain>""",
|
|
member=member, resources=plan.resources,
|
|
guest_network_generation=private_guest_network_generation(
|
|
member, routes),
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
adapter = VpcPrivateHostAdapter(object(), {})
|
|
adapter._deployment_contract = lambda: ("networkmanager", "", "", "")
|
|
adapter._run = lambda _script: "\n".join(
|
|
_active_observation_markers(plan)) + "\n"
|
|
|
|
for state, reason in (
|
|
("unavailable", "vpc_private_guest_agent_unavailable"),
|
|
("mismatch", "vpc_private_guest_address_mismatch"),
|
|
):
|
|
observed = adapter.observe(plan, xml_by_instance={
|
|
member.instance_uuid: {
|
|
"inactive": persistent,
|
|
"live": persistent,
|
|
"seed_verified": True,
|
|
"guest_network": {
|
|
"state": state, "verified": False,
|
|
"reason_code": reason,
|
|
},
|
|
},
|
|
})
|
|
assert observed["config_verified"] is True
|
|
assert observed["state"] == "applying"
|
|
assert observed["observed_revision"] == 0
|
|
assert observed["observed_digest"] is None
|
|
assert observed["readback"] == "pending_guest"
|
|
assert observed["reason_code"] == reason
|
|
assert observed["member_nics"][0]["xml_verified"] is True
|
|
assert observed["member_nics"][0]["guest_network_verified"] is False
|
|
|
|
confirmed = adapter.observe(plan, xml_by_instance={
|
|
member.instance_uuid: {
|
|
"inactive": persistent,
|
|
"live": persistent,
|
|
"seed_verified": True,
|
|
"guest_network": _guest_network_evidence(member, routes),
|
|
},
|
|
})
|
|
assert confirmed["state"] == "active"
|
|
assert confirmed["observed_revision"] == plan.desired_revision
|
|
assert confirmed["observed_digest"] == plan.desired_digest
|
|
assert confirmed["readback"] == "confirmed"
|
|
|
|
|
|
def test_observer_reports_pending_restart_instead_of_active():
|
|
plan = _plan()
|
|
member = plan.local_members[0]
|
|
generation = private_guest_network_generation(
|
|
member, private_guest_routes(plan.vpc, member))
|
|
original = """<domain><metadata/><devices>
|
|
<interface type='bridge'><mac address='52:54:00:00:00:01'/>
|
|
<alias name='ua-public0'/><source bridge='br0'/></interface>
|
|
</devices></domain>"""
|
|
persistent = patch_private_interface_xml(
|
|
original, member=member, resources=plan.resources,
|
|
guest_network_generation=generation,
|
|
vpc_id=plan.vpc.vpc_id, desired_revision=plan.desired_revision,
|
|
desired_digest=plan.desired_digest,
|
|
)
|
|
stale_live_root = ET.fromstring(persistent)
|
|
stale_live_root.find(
|
|
"./metadata/{urn:virsh-panel:1}managed"
|
|
).attrib.pop("private-guest-network-generation")
|
|
stale_live = ET.tostring(stale_live_root, encoding="unicode")
|
|
|
|
markers = [
|
|
f"__VC_VPC_BRIDGE__={plan.resources.bridge}",
|
|
"__VC_VPC_BRIDGE_OWNER__=virt-cloud-vpc-dataplane-v1",
|
|
"__VC_VPC_PERSISTENCE__=yes",
|
|
"__VC_VPC_BRIDGE_BOUNDARY__=yes",
|
|
"__VC_VPC_PROXY_ARP__=0",
|
|
"__VC_VPC_PROXY_ARP_PVLAN__=1",
|
|
"__VC_VPC_PROXY_STATE__=owned",
|
|
"__VC_VPC_RP_FILTER__=2",
|
|
f"__VC_VPC_NFT_TABLE__={plan.resources.nft_table}",
|
|
"__VC_VPC_STATE_OWNER__=owned",
|
|
f"__VC_VPC_STATE_REVISION__={plan.desired_revision}",
|
|
f"__VC_VPC_STATE_DIGEST__={plan.desired_digest}",
|
|
f"__VC_VPC_ACL_REVISION__={plan.desired_revision}",
|
|
f"__VC_VPC_ACL_DIGEST__={plan.desired_digest}",
|
|
"__VC_VPC_ANTI_SPOOF__=yes",
|
|
"__VC_VPC_BRIDGE_NFT__=yes",
|
|
"__VC_VPC_ROUTE_EXTRA__=no",
|
|
"__VC_VPC_RULE_EXTRA__=no",
|
|
"__VC_VPC_ARP_NFT__=yes",
|
|
]
|
|
for route in _routes(plan):
|
|
markers.append(
|
|
"__VC_VPC_ROUTE__="
|
|
f"{route['destination_cidr']}|{route['device']}|"
|
|
f"{route['table']}|{route.get('via') or '-'}|"
|
|
f"{route.get('metric', 100)}|owned")
|
|
markers.append(
|
|
"__VC_VPC_PROXY_IP__="
|
|
f"{route['destination_cidr'].removesuffix('/32')}")
|
|
markers.extend((
|
|
"__VC_VPC_RULE__="
|
|
f"{plan.resources.rule_priority}|-|{plan.vpc.cidr}|"
|
|
f"{plan.resources.route_table}|owned",
|
|
"__VC_VPC_RULE__="
|
|
f"{plan.resources.rule_priority + 1}|wg-fabric0|{plan.vpc.cidr}|"
|
|
f"{plan.resources.route_table}|owned",
|
|
))
|
|
for peer in plan.peers:
|
|
markers.extend((
|
|
f"__VC_VPC_WG_ALLOWED__={peer.host_id}|{peer.public_key}|"
|
|
f"{_allowed(plan, peer)}",
|
|
f"__VC_VPC_WG_STATE__={peer.host_id}|owned",
|
|
))
|
|
|
|
adapter = VpcPrivateHostAdapter(object(), {})
|
|
adapter._deployment_contract = lambda: ("networkmanager", "", "", "")
|
|
adapter._run = lambda _script: "\n".join(markers) + "\n"
|
|
observed = adapter.observe(plan, xml_by_instance={
|
|
member.instance_uuid: {
|
|
"inactive": persistent,
|
|
"live": stale_live,
|
|
},
|
|
})
|
|
assert observed["state"] == "applying"
|
|
assert observed["readback"] == "pending_restart"
|
|
assert observed["reason_code"] == "vpc_private_guest_restart_required"
|
|
assert observed["member_nics"][0]["restart_required"] is True
|