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

2110 lines
81 KiB
Python

"""SSH host configuration is pinned, private, and switched only after test."""
from __future__ import annotations
import base64
import hashlib
import itertools
import json
import shlex
import shutil
import stat
import struct
import subprocess
from dataclasses import replace
from pathlib import Path
from urllib.parse import parse_qs, urlsplit
import pytest
from virsh_panel.remote_host import (
HOST_CAPABILITY_SCHEMA_VERSION,
WG_FABRIC_INTERFACE,
WG_FABRIC_OWNERSHIP_MARKER,
_CAPABILITY_MARKER,
_CAPABILITY_PROBE_COMMAND,
HostProfile,
RemoteHostError,
RemoteHostManager,
_parse_firewall_interface_zones,
_parse_networkmanager_interface_zones,
parse_host_capabilities,
)
from virsh_panel.ssh_agent import SSHAgentError
def host_key(seed: bytes) -> str:
blob = (
struct.pack("!I", len(b"ssh-ed25519"))
+ b"ssh-ed25519"
+ struct.pack("!I", 32)
+ seed * 32
)
return "ssh-ed25519 " + base64.b64encode(blob).decode("ascii")
PRIVATE_KEY = "-----BEGIN OPENSSH PRIVATE KEY-----\nZmFrZQ==\n-----END OPENSSH PRIVATE KEY-----\n"
CAPABILITY_OUTPUT = f"""{_CAPABILITY_MARKER}
__VCAP_OS_BEGIN__
ID=almalinux
NAME="AlmaLinux"
VERSION_ID="10.0"
__VCAP_OS_END__
__VCAP_KERNEL_BEGIN__
6.12.0-alma
__VCAP_KERNEL_END__
__VCAP_TOOL__wg=/usr/bin/wg
__VCAP_TOOL__wg_quick=/usr/bin/wg-quick
__VCAP_TOOL__ip=/usr/sbin/ip
__VCAP_TOOL__nft=/usr/sbin/nft
__VCAP_TOOL__firewall_cmd=
__VCAP_TOOL__nmcli=/usr/bin/nmcli
__VCAP_TOOL__networkctl=
__VCAP_TOOL__ifup=
__VCAP_TOOL__ifdown=
__VCAP_TOOL__ifquery=
__VCAP_TOOL__ifreload=
__VCAP_TOOL__flock=/usr/bin/flock
__VCAP_TOOL__systemctl=/usr/bin/systemctl
__VCAP_TOOL__modinfo=/usr/sbin/modinfo
__VCAP_TOOL__dnf=/usr/bin/dnf
__VCAP_TOOL__apt_get=
__VCAP_MODULE__wireguard=loaded
__VCAP_MODULE_FILE_BEGIN__
__VCAP_MODULE_FILE_END__
__VCAP_FABRIC_OWNER_BEGIN__
__VCAP_FABRIC_OWNER_END__
__VCAP_SYSCTL__ip_forward=1
__VCAP_SYSCTL__rp_filter=2
__VCAP_SYSCTL__rp_filter_default=2
__VCAP_RPF__br0=2
__VCAP_SERVICE__network_manager=active
__VCAP_SERVICE__networkd=inactive
__VCAP_SERVICE__networking=inactive
__VCAP_SERVICE__firewall=inactive
__VCAP_SERVICE__nftables=active
__VCAP_SERVICE_ENABLED__network_manager=enabled
__VCAP_SERVICE_ENABLED__networkd=disabled
__VCAP_SERVICE_ENABLED__networking=disabled
__VCAP_SERVICE_ENABLED__firewall=masked
__VCAP_SERVICE_ENABLED__nftables=enabled
__VCAP_SERVICE_LOAD__firewall=masked
__VCAP_SERVICE_LOAD__nftables=loaded
__VCAP_FIREWALL_CONF__backend=nftables
__VCAP_FIREWALL_CONF__table_owner=yes
__VCAP_FIREWALL_CONF__source_zones=absent
__VCAP_FIREWALL_CONF__default_runtime=public
__VCAP_FIREWALL_CONF__default_permanent=public
__VCAP_FIREWALL_CONF__runtime_nft=ready
__VCAP_FIREWALL_IFACE_BEGIN__runtime
br0|public
eth1|public
__VCAP_FIREWALL_IFACE_END__runtime=0
__VCAP_FIREWALL_IFACE_BEGIN__permanent
__VCAP_FIREWALL_IFACE_END__permanent=0
__VCAP_NM_ZONE_BEGIN__
br0|
eth1|
__VCAP_NM_ZONE_END__=0
__VCAP_IFCFG_ZONE_BEGIN__
__VCAP_IFCFG_ZONE_END__=0
__VCAP_FILE__interfaces=absent
__VCAP_FILE__interfaces_d=absent
__VCAP_FILE__networkmanager_profiles=absent
__VCAP_FILE__networkd_configs=absent
__VCAP_IP_BEGIN__links
[{{"ifname":"br0"}}]
__VCAP_IP_END__links=0
__VCAP_IP_BEGIN__addresses
[{{"ifname":"br0","addr_info":[{{"family":"inet","local":"203.0.113.10"}}]}},{{"ifname":"eth1","addr_info":[{{"family":"inet","local":"10.20.30.40"}}]}}]
__VCAP_IP_END__addresses=0
__VCAP_IP_BEGIN__bridges
[{{"ifname":"br0"}}]
__VCAP_IP_END__bridges=0
__VCAP_IP_BEGIN__wireguard
[]
__VCAP_IP_END__wireguard=0
__VCAP_NFT_BEGIN__
[{{"family":"inet","name":"filter"}}]
__VCAP_NFT_END__0
__VCAP_END__
"""
def test_capability_probe_command_is_parseable_by_posix_sh():
result = subprocess.run(
["/bin/sh", "-n", "-c", _CAPABILITY_PROBE_COMMAND],
capture_output=True, text=True, check=False,
)
assert result.returncode == 0, result.stderr
assert "probe_ip_json addresses -j -4 address show up scope global" in (
_CAPABILITY_PROBE_COMMAND)
assert "-g GENERAL.FILENAME" not in _CAPABILITY_PROBE_COMMAND
assert (
"$firewall_nmcli -t --escape no -f UUID,FILENAME connection show"
in _CAPABILITY_PROBE_COMMAND
)
assert 'test "${#firewall_nm_profiles}" -le 262144' in (
_CAPABILITY_PROBE_COMMAND)
assert "systemctl show -p LoadState --value" in _CAPABILITY_PROBE_COMMAND
assert "FirewallBackend" in _CAPABILITY_PROBE_COMMAND
assert "NftablesTableOwner" in _CAPABILITY_PROBE_COMMAND
assert "__VCAP_FIREWALL_CONF__source_zones=" in _CAPABILITY_PROBE_COMMAND
assert _CAPABILITY_PROBE_COMMAND.count("--list-all-zones") == 2
assert "--list-sources" not in _CAPABILITY_PROBE_COMMAND
assert "--list-interfaces" not in _CAPABILITY_PROBE_COMMAND
assert "--get-zones" not in _CAPABILITY_PROBE_COMMAND
assert "--permanent --get-default-zone" not in _CAPABILITY_PROBE_COMMAND
# firewall-cmd is a D-Bus client and can activate an inactive unit. Every
# use must therefore be dominated by the read-only systemd active check.
assert _CAPABILITY_PROBE_COMMAND.count(
'test "$firewall_service_state" = active') == 3
assert _CAPABILITY_PROBE_COMMAND.count(
'$firewall_cmd --state') == 3
assert _CAPABILITY_PROBE_COMMAND.index(
'firewall_service_state="$status"') < _CAPABILITY_PROBE_COMMAND.index(
'$firewall_cmd --state')
def run_probe_with_firewalld_snapshots(
tmp_path: Path,
*,
runtime: str,
permanent: str,
) -> tuple[subprocess.CompletedProcess[str], list[str]]:
runtime_path = tmp_path / "runtime.zones"
runtime_path.write_text(runtime, encoding="utf-8")
permanent_path = tmp_path / "permanent.zones"
permanent_path.write_text(permanent, encoding="utf-8")
calls_path = tmp_path / "firewall.calls"
firewall_cmd = tmp_path / "firewall-cmd"
firewall_cmd.write_text(
"#!/bin/sh\n"
f'printf "%s\\n" "$*" >> "{calls_path}"\n'
'case "$*" in\n'
' "--state") printf "%s\\n" running; exit 0 ;;\n'
' "--get-default-zone") printf "%s\\n" public; exit 0 ;;\n'
' "--list-all-zones") '
f'/bin/cat "{runtime_path}"; exit 0 ;;\n'
' "--permanent --list-all-zones") '
f'/bin/cat "{permanent_path}"; exit 0 ;;\n'
"esac\n"
"exit 64\n",
encoding="utf-8",
)
firewall_cmd.chmod(0o700)
systemctl = tmp_path / "systemctl"
systemctl.write_text(
"#!/bin/sh\n"
'case "$*" in\n'
' "is-active firewalld") printf "%s\\n" active; exit 0 ;;\n'
' "is-active "*) printf "%s\\n" inactive; exit 3 ;;\n'
' "is-enabled firewalld") printf "%s\\n" enabled; exit 0 ;;\n'
' "is-enabled "*) printf "%s\\n" disabled; exit 1 ;;\n'
' "show -p LoadState --value firewalld") '
'printf "%s\\n" loaded; exit 0 ;;\n'
' "show -p LoadState --value "*) '
'printf "%s\\n" not-found; exit 0 ;;\n'
"esac\n"
"exit 64\n",
encoding="utf-8",
)
systemctl.chmod(0o700)
command = _CAPABILITY_PROBE_COMMAND
for candidate in (
"/usr/bin/firewall-cmd", "/usr/sbin/firewall-cmd",
"/bin/firewall-cmd", "/sbin/firewall-cmd",
):
command = command.replace(candidate, str(firewall_cmd))
for candidate in (
"/usr/bin/systemctl", "/usr/sbin/systemctl",
"/bin/systemctl", "/sbin/systemctl",
):
command = command.replace(candidate, str(systemctl))
result = subprocess.run(
shlex.split(command),
capture_output=True,
text=True,
check=False,
timeout=15,
)
calls = calls_path.read_text(encoding="utf-8").splitlines()
return result, calls
def test_capability_probe_uses_two_bounded_firewalld_zone_snapshots(tmp_path):
result, calls = run_probe_with_firewalld_snapshots(
tmp_path,
runtime=(
"public (default, active)\n"
" target: default\n"
" interfaces: br0 bond0\n"
" sources:\n"
" services: ssh\n"
"trusted\n"
" target: ACCEPT\n"
" interfaces:\n"
" sources:\n"
),
permanent=(
"public (default)\n"
" target: default\n"
" interfaces: br0\n"
" sources:\n"
"trusted\n"
" target: ACCEPT\n"
" interfaces:\n"
" sources:\n"
),
)
assert result.returncode == 0, result.stderr
assert (
"__VCAP_FIREWALL_IFACE_BEGIN__runtime\n"
"br0|public\n"
"bond0|public\n"
"__VCAP_FIREWALL_IFACE_END__runtime=0"
) in result.stdout
assert (
"__VCAP_FIREWALL_IFACE_BEGIN__permanent\n"
"br0|public\n"
"__VCAP_FIREWALL_IFACE_END__permanent=0"
) in result.stdout
assert "__VCAP_FIREWALL_CONF__source_zones=absent" in result.stdout
assert calls.count("--list-all-zones") == 1
assert calls.count("--permanent --list-all-zones") == 1
assert not any("--list-sources" in call for call in calls)
assert not any("--list-interfaces" in call for call in calls)
@pytest.mark.parametrize(
("runtime", "expected_source_zones", "expected_status"),
[
(
"public (active)\n"
" interfaces: br0\n"
" sources: 192.0.2.0/24\n",
"present",
"0",
),
(
"public (active)\n"
" interfaces: br0\n"
" sources:\n"
" sources:\n",
"unknown",
"1",
),
],
)
def test_capability_probe_firewalld_snapshot_is_fail_closed(
tmp_path,
runtime,
expected_source_zones,
expected_status,
):
result, _ = run_probe_with_firewalld_snapshots(
tmp_path,
runtime=runtime,
permanent=(
"public\n"
" interfaces: br0\n"
" sources:\n"
),
)
assert result.returncode == 0, result.stderr
assert (
f"__VCAP_FIREWALL_IFACE_END__runtime={expected_status}"
in result.stdout
)
assert (
f"__VCAP_FIREWALL_CONF__source_zones={expected_source_zones}"
in result.stdout
)
def test_capability_probe_executes_the_discovered_ip_binary():
assert (
"probe_binary ip /usr/sbin/ip /usr/bin/ip /sbin/ip /bin/ip"
in _CAPABILITY_PROBE_COMMAND
)
assert 'ip) capability_ip_path="$path" ;;' in _CAPABILITY_PROBE_COMMAND
assert '"$capability_ip_path" "$@"' in _CAPABILITY_PROBE_COMMAND
def test_capability_probe_executes_discovered_nft_and_modinfo_paths(tmp_path):
nft_calls = tmp_path / "nft.calls"
nft = tmp_path / "nft"
nft.write_text(
"#!/bin/sh\n"
f'printf "%s\\n" "$*" >> "{nft_calls}"\n'
"printf '%s\\n' '{\"nftables\":[]}'\n",
encoding="utf-8",
)
nft.chmod(0o700)
modinfo_calls = tmp_path / "modinfo.calls"
modinfo = tmp_path / "modinfo"
modinfo.write_text(
"#!/bin/sh\n"
f'printf "%s\\n" "$*" >> "{modinfo_calls}"\n'
"printf '%s\\n' /lib/modules/test/wireguard.ko\n",
encoding="utf-8",
)
modinfo.chmod(0o700)
command = _CAPABILITY_PROBE_COMMAND.replace(
"probe_binary nft /usr/sbin/nft /usr/bin/nft /sbin/nft /bin/nft",
f"probe_binary nft {nft}",
).replace(
"probe_binary modinfo /usr/sbin/modinfo /usr/bin/modinfo "
"/sbin/modinfo /bin/modinfo",
f"probe_binary modinfo {modinfo}",
)
result = subprocess.run(
shlex.split(command),
capture_output=True,
text=True,
check=False,
timeout=15,
)
assert result.returncode == 0, result.stderr
assert f"__VCAP_TOOL__nft={nft}" in result.stdout
assert f"__VCAP_TOOL__modinfo={modinfo}" in result.stdout
assert (
"__VCAP_MODULE_FILE_BEGIN__\n/lib/modules/test/wireguard.ko\n"
"__VCAP_MODULE_FILE_END__"
) in result.stdout
assert (
'__VCAP_NFT_BEGIN__\n{"nftables":[]}\n__VCAP_NFT_END__0'
in result.stdout
)
assert nft_calls.read_text(encoding="utf-8") == "-j list tables\n"
assert modinfo_calls.read_text(encoding="utf-8") == (
"-F filename wireguard\n")
def test_capability_probe_resolves_nm_filename_from_bounded_list_mode(tmp_path):
connection_uuid = "00000000-0000-0000-0000-000000000001"
profile = tmp_path / "br0:primary.nmconnection"
profile.write_text("[connection]\nzone=public\n", encoding="utf-8")
profile.chmod(0o600)
calls = tmp_path / "nmcli.calls"
nmcli = tmp_path / "nmcli"
nmcli.write_text(
"#!/bin/sh\n"
f'printf "%s\\n" "$*" >> "{calls}"\n'
'case "$*" in\n'
' "-t --escape no -f UUID,DEVICE connection show --active")\n'
f' printf "%s\\n" "{connection_uuid}:br0" '
'"22222222-2222-4222-8222-222222222222:vnet3"; exit 0 ;;\n'
' "-t --escape no -f UUID,FILENAME connection show")\n'
f' printf "%s\\n" "{connection_uuid}:{profile}" '
'"22222222-2222-4222-8222-222222222222:'
'/run/NetworkManager/system-connections/vnet3.nmconnection"; exit 0 ;;\n'
' "-g GENERAL.FILENAME connection show uuid '
f'{connection_uuid}") exit 2 ;;\n'
"esac\n"
"exit 64\n",
encoding="utf-8",
)
nmcli.chmod(0o700)
systemctl = tmp_path / "systemctl"
systemctl.write_text(
"#!/bin/sh\n"
'if test "$*" = "is-active NetworkManager"; then\n'
' printf "%s\\n" active\n'
" exit 0\n"
"fi\n"
"exit 3\n",
encoding="utf-8",
)
systemctl.chmod(0o700)
stat_command = tmp_path / "stat"
stat_command.write_text(
"#!/bin/sh\n"
'if test "$1" = -c && test "$2" = %u:%a; then\n'
' printf "%s\\n" 0:600\n'
" exit 0\n"
"fi\n"
'if test "$1" = -c && test "$2" = %s; then\n'
' printf "%s\\n" 25\n'
" exit 0\n"
"fi\n"
"exit 64\n",
encoding="utf-8",
)
stat_command.chmod(0o700)
detail = subprocess.run(
[
str(nmcli), "-g", "GENERAL.FILENAME", "connection", "show",
"uuid", connection_uuid,
],
capture_output=True,
text=True,
check=False,
)
assert detail.returncode == 2
command = _CAPABILITY_PROBE_COMMAND.replace(
"for firewall_candidate in /usr/bin/nmcli /usr/sbin/nmcli "
"/bin/nmcli /sbin/nmcli; do",
f"for firewall_candidate in {nmcli}; do",
).replace(
"for firewall_candidate in /usr/bin/stat /bin/stat /usr/sbin/stat "
"/sbin/stat; do",
f"for firewall_candidate in {stat_command}; do",
).replace(
"for firewall_candidate in /usr/bin/systemctl /bin/systemctl "
"/usr/sbin/systemctl /sbin/systemctl; do",
f"for firewall_candidate in {systemctl}; do",
).replace(
"/etc/NetworkManager/system-connections/",
f"{tmp_path}/",
)
result = subprocess.run(
shlex.split(command),
capture_output=True,
text=True,
check=False,
timeout=15,
)
assert result.returncode == 0, result.stderr
assert (
"__VCAP_NM_ZONE_BEGIN__\nbr0|public\nvnet3|?\n"
"__VCAP_NM_ZONE_END__=0"
) in result.stdout
assert calls.read_text(encoding="utf-8").splitlines()[-2:] == [
"-t --escape no -f UUID,DEVICE connection show --active",
"-t --escape no -f UUID,FILENAME connection show",
]
def test_capability_probe_command_executes_the_complete_wrapped_script():
argv = shlex.split(_CAPABILITY_PROBE_COMMAND)
assert argv[:2] == ["/bin/sh", "-c"]
assert len(argv) == 3
assert "__VCAP_END__" in argv[2]
assert "'" not in argv[2]
result = subprocess.run(
argv,
capture_output=True,
text=True,
check=False,
timeout=15,
)
assert result.returncode == 0, result.stderr
assert result.stdout.startswith(f"{_CAPABILITY_MARKER}\n")
assert result.stdout.rstrip().endswith("__VCAP_END__")
def test_zone_inventory_parsers_allow_bounded_guest_density():
firewalld = "\n".join(
["br0|public"]
+ [f"vnet{index}|public" for index in range(300)])
networkmanager = "\n".join(
["br0|public"]
+ [f"vnet{index}|" for index in range(300)])
firewall_ok, firewall_values = _parse_firewall_interface_zones(
firewalld, "0")
nm_ok, nm_values = _parse_networkmanager_interface_zones(
networkmanager, "0")
assert firewall_ok is True
assert firewall_values["br0"] == "public"
assert len(firewall_values) == 301
assert nm_ok is True
assert nm_values["br0"] == "public"
assert len(nm_values) == 301
def test_zone_inventory_parsers_reject_more_than_4096_interfaces():
oversized = "\n".join(
f"vnet{index}|public" for index in range(4097))
assert _parse_firewall_interface_zones(oversized, "0") == (False, {})
assert _parse_networkmanager_interface_zones(
oversized, "0") == (False, {})
class Runner:
def __init__(self) -> None:
self.key = host_key(b"a")
self.ssh_exit = 0
self.encrypted = False
self.public_key_type = "ssh-ed25519"
self.capability_exit = 0
self.capability_output = CAPABILITY_OUTPUT
self.commands: list[list[str]] = []
def __call__(self, argv, **kwargs):
self.commands.append(argv)
assert kwargs["timeout"] <= 22
assert kwargs["capture_output"] is True
assert kwargs["check"] is False
if argv[0] == "ssh-keyscan":
return subprocess.CompletedProcess(argv, 0, f"[host.example]:2222 {self.key}\n", "")
if argv[0] == "ssh-keygen":
if self.encrypted:
return subprocess.CompletedProcess(argv, 255, "", "passphrase required")
return subprocess.CompletedProcess(argv, 0, f"{self.public_key_type} fake-public-key\n", "")
if argv[0] == "ssh":
if _CAPABILITY_MARKER in argv[-1]:
return subprocess.CompletedProcess(
argv, self.capability_exit, self.capability_output,
"private remote diagnostic",
)
return subprocess.CompletedProcess(argv, self.ssh_exit, "", "permission denied")
raise AssertionError(argv)
def make_manager(tmp_path: Path, runner: Runner) -> RemoteHostManager:
return RemoteHostManager(
tmp_path / "service-home",
ssh_user_config_path=tmp_path / "service-home" / ".ssh" / "config",
runner=runner,
)
def make_profile(
scanned: dict, *, key: str = PRIVATE_KEY, host: str = "host.example",
passphrase: str = "", storage_pool: str = "images", iso_pool: str = "iso",
rescue_iso_pool: str = "", default_network: str = "default", region: str = "",
fabric_endpoint_ip: str = "",
) -> HostProfile:
return HostProfile(
host=host,
port=2222,
private_key=key,
host_key=scanned["known_hosts_line"],
private_key_passphrase=passphrase,
storage_pool=storage_pool,
iso_pool=iso_pool,
rescue_iso_pool=rescue_iso_pool,
default_network=default_network,
region=region,
fabric_endpoint_ip=fabric_endpoint_ip,
)
def test_region_survives_host_save_and_legacy_metadata_defaults_empty(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(scanned, region="中国香港"), scanned["fingerprint"])
manager.test(staged)
assert manager.commit(staged)["region"] == "中国香港"
profile_path = staged.path / "profile.json"
legacy = json.loads(profile_path.read_text(encoding="utf-8"))
legacy.pop("region")
profile_path.write_text(json.dumps(legacy), encoding="utf-8")
assert manager.current()["region"] == ""
def test_fabric_endpoint_survives_save_and_legacy_metadata_defaults_empty(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(
scanned, fabric_endpoint_ip="10.20.30.40"), scanned["fingerprint"])
manager.test(staged)
assert manager.commit(staged)["fabric_endpoint_ip"] == "10.20.30.40"
profile_path = staged.path / "profile.json"
legacy = json.loads(profile_path.read_text(encoding="utf-8"))
legacy.pop("fabric_endpoint_ip")
profile_path.write_text(json.dumps(legacy), encoding="utf-8")
assert manager.current()["fabric_endpoint_ip"] == ""
@pytest.mark.parametrize("endpoint", [
"host.example", " 10.0.0.1", "0.0.0.1", "127.0.0.1",
"169.254.1.1", "224.0.0.1", "255.255.255.255",
])
def test_fabric_endpoint_rejects_unsafe_or_nonliteral_addresses(
tmp_path, endpoint,
):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
with pytest.raises(RemoteHostError) as error:
manager.stage(make_profile(
scanned, fabric_endpoint_ip=endpoint), scanned["fingerprint"])
assert error.value.error_code == "host_fabric_endpoint_invalid"
def test_fabric_endpoint_must_be_present_in_fresh_local_address_inventory(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(
scanned, fabric_endpoint_ip="10.20.30.41"), scanned["fingerprint"])
with pytest.raises(RemoteHostError) as error:
manager.test(staged)
assert error.value.error_code == "host_fabric_endpoint_not_local"
assert staged.tested is False
def test_public_pool_survives_host_save_and_legacy_metadata_defaults_empty(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
profile = replace(
make_profile(scanned),
public_pool_cidr="1.2.3.0/24",
public_gateway="1.2.3.1",
public_dns_servers=["1.1.1.1", "8.8.8.8"],
public_reserved_ips=["1.2.3.10", "1.2.3.10"],
)
staged = manager.stage(profile, scanned["fingerprint"])
assert staged.metadata["public_reserved_ips"] == ["1.2.3.10"]
manager.test(staged)
current = manager.commit(staged)
assert current["public_pool_cidr"] == "1.2.3.0/24"
assert current["public_gateway"] == "1.2.3.1"
assert current["public_dns_servers"] == ["1.1.1.1", "8.8.8.8"]
assert current["public_reserved_ips"] == ["1.2.3.10"]
metadata_path = staged.path / "profile.json"
legacy = json.loads(metadata_path.read_text(encoding="utf-8"))
for key in ("public_pool_cidr", "public_gateway", "public_dns_servers", "public_reserved_ips"):
legacy.pop(key)
metadata_path.write_text(json.dumps(legacy), encoding="utf-8")
assert manager.current()["public_pool_cidr"] == ""
assert manager.current()["public_dns_servers"] == []
assert manager.current()["public_reserved_ips"] == []
def test_provider_28_gateway_cidr_is_saved_as_canonical_network(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
profile = replace(
make_profile(scanned),
public_pool_cidr="123.123.123.113/28",
public_gateway="123.123.123.113",
public_dns_servers=["1.1.1.1"],
public_vm_prefix=24,
)
staged = manager.stage(profile, scanned["fingerprint"])
assert staged.metadata["public_pool_cidr"] == "123.123.123.112/28"
assert staged.metadata["public_vm_prefix"] == 24
manager.test(staged)
assert manager.commit(staged)["public_pool_cidr"] == "123.123.123.112/28"
assert manager.current()["public_vm_prefix"] == 24
class FakeAgent:
sequence = itertools.count()
def __init__(self, generation: Path, _key_path: Path, passphrase: str) -> None:
if passphrase != "open-sesame":
raise SSHAgentError("bad passphrase")
self.socket_path = generation / f"agent-{next(self.sequence)}.sock"
self.public_key = host_key(b"b")
self.alive = True
def close(self) -> None:
self.alive = False
def test_scan_returns_fingerprint_without_trusting_key(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
digest = hashlib.sha256(base64.b64decode(runner.key.split()[1])).digest()
assert scanned == {
"host": "host.example",
"port": 2222,
"key_type": "ssh-ed25519",
"fingerprint": "SHA256:" + base64.b64encode(digest).decode("ascii").rstrip("="),
"host_key": runner.key,
"known_hosts_line": "vp-managed " + runner.key,
}
assert manager.current() is None
assert not manager.ssh_user_config_path.exists()
assert runner.commands[0] == [
"ssh-keyscan", "-T", "8", "-p", "2222", "-t", "ed25519", "host.example",
]
def test_encrypted_key_is_memory_only_and_requires_unlock_after_restart(tmp_path):
runner = Runner()
runner.encrypted = True
data_dir = tmp_path / "panel-data"
manager = RemoteHostManager(data_dir, runner=runner, agent_factory=FakeAgent)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(
make_profile(scanned, passphrase="open-sesame"), scanned["fingerprint"],
)
config = (staged.path / "config").read_text(encoding="ascii")
assert f'IdentityFile "{staged.path / "identity.pub"}"' in config
assert f'IdentityAgent "{manager._agents[staged.path].socket_path}"' in config
assert all(
b"open-sesame" not in path.read_bytes()
for path in staged.path.iterdir() if path.is_file()
)
manager.test(staged)
manager.commit(staged)
assert manager.current()["private_key_encrypted"] is True
assert manager.current()["key_locked"] is False
manager.close()
assert manager.current()["key_locked"] is True
restarted = RemoteHostManager(data_dir, runner=runner, agent_factory=FakeAgent)
assert restarted.current()["key_locked"] is True
original_config = (staged.path / "config").read_text(encoding="ascii")
with pytest.raises(RemoteHostError, match="口令错误"):
restarted.unlock_current("wrong")
assert restarted.current()["key_locked"] is True
assert (staged.path / "config").read_text(encoding="ascii") == original_config
unlocked = restarted.unlock_current("open-sesame")
assert unlocked["key_locked"] is False
assert str(restarted._agents[staged.path].socket_path) in (
staged.path / "config"
).read_text(encoding="ascii")
restarted.close()
def test_encrypted_key_needs_passphrase_and_rejects_wrong_one(tmp_path):
runner = Runner()
runner.encrypted = True
manager = RemoteHostManager(tmp_path / "panel-data", runner=runner, agent_factory=FakeAgent)
scanned = manager.scan("host.example", 2222)
with pytest.raises(RemoteHostError, match="填写私钥口令") as missing:
manager.stage(make_profile(scanned), scanned["fingerprint"])
assert missing.value.error_code == "host_private_key_passphrase_required"
with pytest.raises(RemoteHostError, match="口令错误") as wrong:
manager.stage(make_profile(scanned, passphrase="wrong"), scanned["fingerprint"])
assert wrong.value.error_code == "host_private_key_invalid"
assert not list((manager.data_dir / "generations").iterdir())
def test_invalid_private_key_has_stable_code_without_echoing_key(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
secret = "private-key-material-must-not-leak"
with pytest.raises(RemoteHostError) as rejected:
manager.stage(
make_profile(scanned, key=secret),
scanned["fingerprint"],
)
assert rejected.value.error_code == "host_private_key_format_invalid"
assert secret not in str(rejected.value)
def test_existing_host_directories_are_accepted_as_pool_selectors(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(
make_profile(scanned, storage_pool="/home/kvm", iso_pool="/home/iso"),
scanned["fingerprint"],
)
assert staged.metadata["storage_pool"] == "/home/kvm"
assert staged.metadata["iso_pool"] == "/home/iso"
manager.abort(staged)
def test_rescue_iso_pool_survives_host_save_and_legacy_defaults_unconfigured(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(
make_profile(scanned, iso_pool="/home/iso", rescue_iso_pool="/home/rescue-iso"),
scanned["fingerprint"],
)
assert staged.metadata["rescue_iso_pool"] == "/home/rescue-iso"
manager.test(staged)
assert manager.commit(staged)["rescue_iso_pool"] == "/home/rescue-iso"
profile_path = staged.path / "profile.json"
legacy = json.loads(profile_path.read_text(encoding="utf-8"))
legacy.pop("rescue_iso_pool")
profile_path.write_text(json.dumps(legacy), encoding="utf-8")
assert manager.current()["rescue_iso_pool"] == ""
@pytest.mark.parametrize(
"rescue_selector,iso_selector",
[
("iso", "iso"),
("/home/iso", "/home/iso"),
],
)
def test_rescue_pool_cannot_equal_install_iso_pool(
tmp_path, rescue_selector, iso_selector,
):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
with pytest.raises(RemoteHostError, match="不能与安装 ISO 池相同"):
manager.stage(
make_profile(scanned, iso_pool=iso_selector, rescue_iso_pool=rescue_selector),
scanned["fingerprint"],
)
@pytest.mark.parametrize("selector", ["/", "/home/../iso", "/home//iso", "/home/iso/", None])
def test_rejects_invalid_rescue_pool_selector(tmp_path, selector):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
with pytest.raises(RemoteHostError, match="救援 ISO 池"):
manager.stage(
make_profile(scanned, rescue_iso_pool=selector),
scanned["fingerprint"],
)
def test_explicit_host_bridge_selector_is_accepted(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(
make_profile(scanned, default_network="bridge:br0"), scanned["fingerprint"],
)
assert staged.metadata["default_network"] == "bridge:br0"
manager.abort(staged)
@pytest.mark.parametrize(
"selector", ["bridge:", "bridge:br/0", "bridge:br 0", "bridge:-br0",
"bridge:" + "a" * 16],
)
def test_invalid_host_bridge_selector_is_rejected(tmp_path, selector):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
with pytest.raises(RemoteHostError, match="网桥名称格式无效"):
manager.stage(make_profile(scanned, default_network=selector), scanned["fingerprint"])
def test_unencrypted_ecdsa_private_key_does_not_require_passphrase(tmp_path):
runner = Runner()
runner.public_key_type = "ecdsa-sha2-nistp256"
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(scanned), scanned["fingerprint"])
assert staged.metadata["private_key_encrypted"] is False
assert "IdentityAgent none" in (staged.path / "config").read_text()
manager.abort(staged)
@pytest.mark.parametrize("bad_path", ["/", "/home/../kvm", "/home//kvm", "/home/kvm/"])
def test_rejects_unsafe_pool_paths(tmp_path, bad_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
with pytest.raises(RemoteHostError, match="磁盘池"):
manager.stage(make_profile(scanned, storage_pool=bad_path), scanned["fingerprint"])
def test_stage_test_commit_writes_private_pinned_ssh_config(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
stage = manager.stage(make_profile(scanned), scanned["fingerprint"])
assert stage.tested is False
assert manager.current() is None
for name in ("id_private", "known_hosts", "config", "profile.json"):
path = stage.path / name
assert stat.S_IMODE(path.stat().st_mode) == 0o600
assert stat.S_IMODE(stage.path.stat().st_mode) == 0o700
config = (stage.path / "config").read_text()
assert "Host vp-managed\n" in config
assert "HostName host.example\n" in config
assert "Port 2222\n" in config
assert "User root\n" in config
assert "HostKeyAlias vp-managed\n" in config
assert "StrictHostKeyChecking yes\n" in config
assert "BatchMode yes\n" in config
assert "IdentitiesOnly yes\n" in config
assert "PasswordAuthentication no\n" in config
assert "HostKeyAlgorithms ssh-ed25519\n" in config
assert "ServerAliveInterval 15\n" in config
assert "ServerAliveCountMax 2\n" in config
assert (stage.path / "known_hosts").read_text() == scanned["known_hosts_line"] + "\n"
assert (stage.path / "id_private").read_text() == PRIVATE_KEY
wrapper = stage.path / "ssh-wrapper"
assert stat.S_IMODE(wrapper.stat().st_mode) == 0o700
assert parse_qs(urlsplit(stage.libvirt_uri).query)["command"] == [str(wrapper)]
tested = manager.test(stage)
assert tested["ok"] is True
assert tested["ssh"] == "connected"
assert tested["libvirt"] == "available"
assert tested["capabilities"]["schema_version"] == HOST_CAPABILITY_SCHEMA_VERSION
assert tested["capabilities"]["vpc_ready"] is True
assert tested["capabilities"]["os"]["package_tool"] == "dnf"
assert tested["capabilities"]["os"]["package_tool_available"] is True
assert tested["capabilities"]["wireguard"]["deployment_mode"] == "networkmanager_nmcli"
assert tested["capabilities"]["nftables"]["service_active"] is True
assert tested["capabilities"]["nftables"]["service_persistent"] is True
assert tested["capabilities"]["network"]["firewall_manager_evidence"] == {
"firewalld_active": False,
"firewalld_enabled": False,
"firewalld_load_state": "masked",
"firewalld_backend": "nftables",
"firewalld_table_owner": "yes",
"firewalld_source_zones": "absent",
"firewalld_default_runtime": "public",
"firewalld_default_permanent": "public",
"firewalld_runtime_nft": "ready",
"firewalld_interface_inventory_ready": True,
"firewalld_command_available": False,
"nftables_active": True,
"nftables_enabled": True,
"nftables_load_state": "loaded",
}
assert tested["capabilities"]["network"]["local_ipv4_addresses"] == [
"10.20.30.40", "203.0.113.10",
]
assert tested["capabilities"]["network"]["local_ipv4_interfaces"] == {
"10.20.30.40": ["eth1"],
"203.0.113.10": ["br0"],
}
assert tested["capabilities"]["network"]["rp_filter_default"] == 2
assert tested["capabilities"]["network"]["rp_filter_interfaces"]["br0"] == 2
assert tested["capabilities"]["network_roles"]["private"]["host_interface"] == WG_FABRIC_INTERFACE
assert runner.commands[-1][0:4] == ["ssh", "-F", stage.ssh_config_file, "-T"]
current = manager.commit(stage)
assert current["host"] == "host.example"
assert current["port"] == 2222
assert current["fingerprint"] == scanned["fingerprint"]
assert current["private_key_configured"] is True
assert current["libvirt_uri"].startswith(
"qemu+ssh://root@vp-managed/system?no_tty=1&command="
)
assert parse_qs(urlsplit(current["libvirt_uri"]).query)["command"] == [str(wrapper)]
assert manager.libvirt_uri == current["libvirt_uri"]
assert current["ssh_target"] == "vp-managed"
assert "private_key" not in current
assert PRIVATE_KEY not in repr(current)
assert manager.ssh_user_config_path.is_symlink()
assert manager.ssh_user_config_path.resolve() == stage.path / "config"
assert stat.S_IMODE(manager.ssh_user_config_path.parent.stat().st_mode) == 0o700
def test_capability_snapshot_is_persisted_only_after_commit(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(scanned), scanned["fingerprint"])
tested = manager.test(staged)
assert tested["capabilities"]["os"]["id"] == "almalinux"
profile_before = json.loads((staged.path / "profile.json").read_text())
assert "capabilities" not in profile_before
current = manager.commit(staged)
assert current["capabilities"]["vpc_ready"] is True
profile_after = json.loads((staged.path / "profile.json").read_text())
assert profile_after["capabilities"]["wireguard"]["interface"] == WG_FABRIC_INTERFACE
def test_current_capabilities_are_reprobed_through_pinned_generation(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(
make_profile(scanned, default_network="bridge:br0"),
scanned["fingerprint"],
)
manager.test(staged)
current = manager.commit(staged)
profile_path = staged.path / "profile.json"
persisted_before = profile_path.read_bytes()
runner.capability_output = CAPABILITY_OUTPUT.replace(
"__VCAP_SERVICE_ENABLED__nftables=enabled",
"__VCAP_SERVICE_ENABLED__nftables=disabled",
)
capabilities = manager.reprobe_current_capabilities()
assert capabilities["probe_valid"] is True
assert capabilities["network_roles"]["public"]["selector"] == "bridge:br0"
assert capabilities["nftables"]["service_active"] is True
assert capabilities["nftables"]["service_persistent"] is False
assert capabilities["vpc_ready"] is False
assert "nftables_service_not_enabled" in capabilities["reasons"]
assert profile_path.read_bytes() == persisted_before
assert current["capabilities"]["vpc_ready"] is True
assert runner.commands[-1][0:4] == [
"ssh", "-F", str(staged.path / "config"), "-T",
]
assert runner.commands[-1][-1] == _CAPABILITY_PROBE_COMMAND
def test_current_fabric_endpoint_requires_fresh_local_address_evidence(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(
scanned, fabric_endpoint_ip="10.20.30.40"), scanned["fingerprint"])
manager.test(staged)
manager.commit(staged)
runner.capability_output = CAPABILITY_OUTPUT.replace(
'"local":"10.20.30.40"', '"local":"10.20.30.41"')
with pytest.raises(RemoteHostError) as error:
manager.reprobe_current_snapshot()
assert error.value.error_code == "host_fabric_endpoint_not_local"
def test_current_capability_reprobe_requires_configured_host(tmp_path):
manager = make_manager(tmp_path, Runner())
with pytest.raises(RemoteHostError) as error:
manager.reprobe_current_capabilities()
assert error.value.status == 409
assert error.value.error_code == "host_not_configured"
def test_current_capability_reprobe_hides_remote_failure_output(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(scanned), scanned["fingerprint"])
manager.test(staged)
manager.commit(staged)
runner.capability_exit = 255
with pytest.raises(RemoteHostError) as error:
manager.reprobe_current_capabilities()
assert error.value.status == 502
assert error.value.error_code == "host_capability_probe_failed"
assert "private remote diagnostic" not in str(error.value)
def test_current_capability_reprobe_rejects_invalid_protocol(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(scanned), scanned["fingerprint"])
manager.test(staged)
manager.commit(staged)
runner.capability_output = CAPABILITY_OUTPUT.replace("__VCAP_END__", "")
with pytest.raises(RemoteHostError) as error:
manager.reprobe_current_capabilities()
assert error.value.status == 502
assert error.value.error_code == "host_capability_probe_invalid"
def test_capability_probe_rejects_missing_private_plane_evidence():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_TOOL__wg=/usr/bin/wg", "__VCAP_TOOL__wg=",
).replace(
"__VCAP_SERVICE__nftables=active", "__VCAP_SERVICE__nftables=inactive",
).replace(
"__VCAP_SYSCTL__ip_forward=1", "__VCAP_SYSCTL__ip_forward=0",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["probe_valid"] is True
assert capabilities["private_ready"] is False
assert capabilities["vpc_ready"] is False
assert "wireguard_tool_missing" in capabilities["reasons"]
assert "nftables_service_not_active" in capabilities["reasons"]
assert "ipv4_forwarding_disabled_or_unknown" in capabilities["reasons"]
assert capabilities["network_roles"]["private"]["separate_from_public"] is True
assert capabilities["network_roles"]["public"]["cloud_init_key"] == "public0"
assert capabilities["network_roles"]["public"]["guest_alias"] == "ua-public0"
assert capabilities["network_roles"]["private"]["cloud_init_key"] == "private0"
assert capabilities["network_roles"]["private"]["guest_alias"] == "ua-private0"
def test_capability_probe_rejects_firewalld_enabled_for_next_boot():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_SERVICE_ENABLED__firewall=masked",
"__VCAP_SERVICE_ENABLED__firewall=enabled",
).replace(
"__VCAP_SERVICE_LOAD__firewall=masked",
"__VCAP_SERVICE_LOAD__firewall=loaded",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["network"]["firewall_manager"] == "conflict"
assert capabilities["nftables"]["ready"] is False
assert capabilities["vpc_ready"] is False
assert "firewall_manager_conflict" in capabilities["reasons"]
assert "firewall_owner_not_nftables" in capabilities["reasons"]
def firewalld_capability_output(
*, nft_active="inactive", nft_enabled="masked", nft_load="masked",
backend="nftables", table_owner="yes", source_zones="absent",
firewalld_enabled="enabled", default_runtime="public",
default_permanent="public", runtime_nft="ready",
):
replacements = (
("__VCAP_TOOL__firewall_cmd=",
"__VCAP_TOOL__firewall_cmd=/usr/bin/firewall-cmd"),
("__VCAP_SERVICE__firewall=inactive",
"__VCAP_SERVICE__firewall=active"),
("__VCAP_SERVICE__nftables=active",
f"__VCAP_SERVICE__nftables={nft_active}"),
("__VCAP_SERVICE_ENABLED__firewall=masked",
f"__VCAP_SERVICE_ENABLED__firewall={firewalld_enabled}"),
("__VCAP_SERVICE_LOAD__firewall=masked",
"__VCAP_SERVICE_LOAD__firewall=loaded"),
("__VCAP_SERVICE_ENABLED__nftables=enabled",
f"__VCAP_SERVICE_ENABLED__nftables={nft_enabled}"),
("__VCAP_SERVICE_LOAD__nftables=loaded",
f"__VCAP_SERVICE_LOAD__nftables={nft_load}"),
("__VCAP_FIREWALL_CONF__backend=nftables",
f"__VCAP_FIREWALL_CONF__backend={backend}"),
("__VCAP_FIREWALL_CONF__table_owner=yes",
f"__VCAP_FIREWALL_CONF__table_owner={table_owner}"),
("__VCAP_FIREWALL_CONF__source_zones=absent",
f"__VCAP_FIREWALL_CONF__source_zones={source_zones}"),
("__VCAP_FIREWALL_CONF__default_runtime=public",
f"__VCAP_FIREWALL_CONF__default_runtime={default_runtime}"),
("__VCAP_FIREWALL_CONF__default_permanent=public",
f"__VCAP_FIREWALL_CONF__default_permanent={default_permanent}"),
("__VCAP_FIREWALL_CONF__runtime_nft=ready",
f"__VCAP_FIREWALL_CONF__runtime_nft={runtime_nft}"),
)
output = CAPABILITY_OUTPUT
for old, new in replacements:
output = output.replace(old, new)
return output
@pytest.mark.parametrize(("nft_active", "nft_enabled", "nft_load"), [
("inactive", "disabled", "loaded"),
("inactive", "masked", "masked"),
("unknown", "unknown", "not-found"),
])
def test_capability_probe_accepts_supported_firewalld_nft_owner(
nft_active, nft_enabled, nft_load,
):
capabilities = parse_host_capabilities(firewalld_capability_output(
nft_active=nft_active, nft_enabled=nft_enabled, nft_load=nft_load,
), public_network="bridge:br0")
assert capabilities["network"]["firewall_manager"] == "firewalld"
assert capabilities["network"]["firewall_mode"] == "firewalld_nft"
assert capabilities["nftables"]["firewall_mode"] == "firewalld_nft"
# Raw nft remains required for the panel-owned tables even though
# firewalld owns the host's primary firewall lifecycle.
assert capabilities["nftables"]["ready"] is True
assert capabilities["vpc_ready"] is True
assert capabilities["reasons"] == []
@pytest.mark.parametrize(("backend", "table_owner", "reason"), [
("iptables", "yes", "firewalld_backend_not_nftables"),
("unknown", "yes", "firewalld_backend_not_nftables"),
("nftables", "no", "firewalld_table_owner_not_enabled"),
("nftables", "unknown", "firewalld_table_owner_not_enabled"),
])
def test_capability_probe_rejects_unsupported_firewalld_configuration(
backend, table_owner, reason,
):
capabilities = parse_host_capabilities(firewalld_capability_output(
backend=backend, table_owner=table_owner,
), public_network="bridge:br0")
assert capabilities["network"]["firewall_mode"] == "unsupported"
assert capabilities["nftables"]["ready"] is False
assert capabilities["vpc_ready"] is False
assert reason in capabilities["reasons"]
@pytest.mark.parametrize(("default_runtime", "default_permanent"), [
("trusted", "trusted"),
("public", "drop"),
("unknown", "public"),
])
def test_capability_probe_rejects_unsafe_or_drifted_firewalld_default_zone(
default_runtime, default_permanent,
):
capabilities = parse_host_capabilities(firewalld_capability_output(
default_runtime=default_runtime,
default_permanent=default_permanent,
), public_network="bridge:br0")
assert capabilities["network"]["firewall_mode"] == "unsupported"
assert capabilities["nftables"]["ready"] is False
assert capabilities["vpc_ready"] is False
assert "firewalld_default_zone_unsafe_or_drifted" in capabilities["reasons"]
def test_capability_probe_requires_live_firewalld_nft_owner_evidence():
capabilities = parse_host_capabilities(firewalld_capability_output(
runtime_nft="unknown",
), public_network="bridge:br0")
assert capabilities["network"]["firewall_mode"] == "unsupported"
assert capabilities["nftables"]["ready"] is False
assert capabilities["vpc_ready"] is False
assert "firewalld_runtime_nft_backend_unverified" in capabilities["reasons"]
def test_capability_probe_rejects_runtime_only_firewalld_enablement():
capabilities = parse_host_capabilities(firewalld_capability_output(
firewalld_enabled="enabled-runtime",
), public_network="bridge:br0")
assert capabilities["network"]["firewall_manager"] == "firewalld"
assert capabilities["network"]["firewall_mode"] == "unsupported"
assert capabilities["vpc_ready"] is False
assert "firewalld_service_not_enabled" in capabilities["reasons"]
def test_capability_probe_rejects_runtime_only_native_nft_enablement():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_SERVICE_ENABLED__nftables=enabled",
"__VCAP_SERVICE_ENABLED__nftables=enabled-runtime",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["network"]["firewall_manager"] == "nftables"
assert capabilities["network"]["firewall_mode"] == "unsupported"
assert capabilities["vpc_ready"] is False
assert "nftables_service_not_enabled" in capabilities["reasons"]
def test_capability_probe_rejects_an_active_competing_nftables_service():
capabilities = parse_host_capabilities(firewalld_capability_output(
nft_active="active",
), public_network="bridge:br0")
assert capabilities["network"]["firewall_manager"] == "conflict"
assert capabilities["network"]["firewall_mode"] == "unsupported"
assert capabilities["nftables"]["ready"] is False
assert "firewall_manager_conflict" in capabilities["reasons"]
@pytest.mark.parametrize("source_zones", ["present", "unknown"])
def test_capability_probe_rejects_firewalld_source_zone_ambiguity(source_zones):
capabilities = parse_host_capabilities(firewalld_capability_output(
source_zones=source_zones,
), public_network="bridge:br0")
assert capabilities["network"]["firewall_mode"] == "unsupported"
assert capabilities["nftables"]["ready"] is False
assert "firewalld_source_zones_present_or_unknown" in capabilities["reasons"]
def test_capability_probe_accepts_native_owner_when_firewalld_is_not_found():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_SERVICE__firewall=inactive",
"__VCAP_SERVICE__firewall=unknown",
).replace(
"__VCAP_SERVICE_ENABLED__firewall=masked",
"__VCAP_SERVICE_ENABLED__firewall=unknown",
).replace(
"__VCAP_SERVICE_LOAD__firewall=masked",
"__VCAP_SERVICE_LOAD__firewall=not-found",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["network"]["firewall_mode"] == "native_nftables"
assert capabilities["nftables"]["ready"] is True
assert capabilities["vpc_ready"] is True
def test_capability_probe_rejects_inactive_but_unmasked_firewalld_competitor():
native = CAPABILITY_OUTPUT.replace(
"__VCAP_SERVICE_ENABLED__firewall=masked",
"__VCAP_SERVICE_ENABLED__firewall=disabled",
).replace(
"__VCAP_SERVICE_LOAD__firewall=masked",
"__VCAP_SERVICE_LOAD__firewall=loaded",
)
native_capabilities = parse_host_capabilities(
native, public_network="bridge:br0")
assert native_capabilities["network"]["firewall_mode"] == "unsupported"
assert "firewall_competing_service_unknown" in native_capabilities["reasons"]
def test_capability_probe_rejects_preexisting_fabric_interface():
output = CAPABILITY_OUTPUT.replace(
'[{"ifname":"br0"}]',
'[{"ifname":"br0"},{"ifname":"wg-fabric0"}]',
1,
).replace(
"__VCAP_IP_BEGIN__wireguard\n[]",
'__VCAP_IP_BEGIN__wireguard\n[{"ifname":"wg-fabric0"}]',
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["vpc_ready"] is False
assert "wireguard_fabric_interface_conflict" in capabilities["reasons"]
def test_capability_probe_rejects_reserved_name_used_by_non_wireguard_link():
output = CAPABILITY_OUTPUT.replace(
'[{"ifname":"br0"}]',
'[{"ifname":"br0"},{"ifname":"wg-fabric0"}]',
1,
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["vpc_ready"] is False
assert capabilities["wireguard"]["interface_name_reserved"] is True
assert capabilities["wireguard"]["interface_is_wireguard"] is False
assert "wireguard_fabric_interface_conflict" in capabilities["reasons"]
def test_capability_probe_accepts_panel_owned_fabric_interface():
output = CAPABILITY_OUTPUT.replace(
'[{"ifname":"br0"}]',
'[{"ifname":"br0"},{"ifname":"wg-fabric0"}]',
1,
).replace(
"__VCAP_IP_BEGIN__wireguard\n[]",
'__VCAP_IP_BEGIN__wireguard\n[{"ifname":"wg-fabric0"}]',
).replace(
"__VCAP_FABRIC_OWNER_BEGIN__\n__VCAP_FABRIC_OWNER_END__",
"__VCAP_FABRIC_OWNER_BEGIN__\n"
+ WG_FABRIC_OWNERSHIP_MARKER
+ "\n__VCAP_FABRIC_OWNER_END__",
).replace(
"__VCAP_RPF__br0=2",
"__VCAP_RPF__br0=2\n__VCAP_RPF__wg-fabric0=2",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["vpc_ready"] is True
assert capabilities["wireguard"]["owned_by_panel"] is True
def test_capability_probe_accepts_almalinux_strict_underlay_for_auto_config():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_SYSCTL__rp_filter=2", "__VCAP_SYSCTL__rp_filter=0",
).replace(
"__VCAP_SYSCTL__rp_filter_default=2",
"__VCAP_SYSCTL__rp_filter_default=1",
).replace(
"__VCAP_RPF__br0=2", "__VCAP_RPF__br0=1",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["vpc_ready"] is True
assert "rp_filter_not_compatible" not in capabilities["reasons"]
network = capabilities["network"]
assert network["rp_filter"] == 0
assert network["rp_filter_default"] == 1
assert network["rp_filter_default_effective"] == 1
assert network["fabric_rp_filter_raw"] is None
assert network["fabric_rp_filter_effective"] is None
def test_capability_probe_accepts_debian_loose_rp_filter_defaults():
output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace(
'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"',
).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace(
"__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=",
).replace(
"__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get",
).replace(
"__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup",
).replace(
"__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown",
).replace(
"__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery",
).replace(
"__VCAP_SERVICE__network_manager=active",
"__VCAP_SERVICE__network_manager=inactive",
).replace(
"__VCAP_SERVICE_ENABLED__network_manager=enabled",
"__VCAP_SERVICE_ENABLED__network_manager=disabled",
).replace(
"__VCAP_SERVICE_ENABLED__networking=disabled",
"__VCAP_SERVICE_ENABLED__networking=enabled",
).replace(
"__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present",
).replace(
"__VCAP_SYSCTL__rp_filter=2", "__VCAP_SYSCTL__rp_filter=0",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["os"]["id"] == "debian"
assert capabilities["vpc_ready"] is True
assert "rp_filter_not_compatible" not in capabilities["reasons"]
network = capabilities["network"]
assert network["rp_filter"] == 0
assert network["rp_filter_default"] == 2
assert network["rp_filter_default_effective"] == 2
@pytest.mark.parametrize(
("all_value", "interface_value", "expected_effective"),
[
(0, 0, 0), (0, 1, 1), (0, 2, 2),
(1, 0, 1), (1, 1, 1), (1, 2, 2),
(2, 0, 2), (2, 1, 2), (2, 2, 2),
],
)
def test_capability_probe_reports_kernel_rp_filter_max_semantics(
all_value,
interface_value,
expected_effective,
):
output = CAPABILITY_OUTPUT.replace(
"__VCAP_SYSCTL__rp_filter=2",
f"__VCAP_SYSCTL__rp_filter={all_value}",
).replace(
"__VCAP_SYSCTL__rp_filter_default=2",
f"__VCAP_SYSCTL__rp_filter_default={interface_value}",
).replace(
'[{"ifname":"br0"}]',
'[{"ifname":"br0"},{"ifname":"wg-fabric0"}]',
1,
).replace(
"__VCAP_IP_BEGIN__wireguard\n[]",
'__VCAP_IP_BEGIN__wireguard\n[{"ifname":"wg-fabric0"}]',
).replace(
"__VCAP_FABRIC_OWNER_BEGIN__\n__VCAP_FABRIC_OWNER_END__",
"__VCAP_FABRIC_OWNER_BEGIN__\n"
+ WG_FABRIC_OWNERSHIP_MARKER
+ "\n__VCAP_FABRIC_OWNER_END__",
).replace(
"__VCAP_RPF__br0=2",
"__VCAP_RPF__br0=2\n"
f"__VCAP_RPF__wg-fabric0={interface_value}",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["vpc_ready"] is True
assert "rp_filter_not_compatible" not in capabilities["reasons"]
network = capabilities["network"]
assert network["rp_filter_default_effective"] == expected_effective
assert network["fabric_rp_filter_raw"] == interface_value
assert network["fabric_rp_filter_effective"] == expected_effective
@pytest.mark.parametrize(
"mutation",
[
("__VCAP_SYSCTL__rp_filter=2", ""),
("__VCAP_SYSCTL__rp_filter=2", "__VCAP_SYSCTL__rp_filter=invalid"),
("__VCAP_SYSCTL__rp_filter=2", "__VCAP_SYSCTL__rp_filter=3"),
("__VCAP_SYSCTL__rp_filter_default=2", ""),
(
"__VCAP_SYSCTL__rp_filter_default=2",
"__VCAP_SYSCTL__rp_filter_default=invalid",
),
("__VCAP_SYSCTL__rp_filter_default=2", "__VCAP_SYSCTL__rp_filter_default=3"),
],
)
def test_capability_probe_rejects_missing_or_invalid_required_rp_filter(
mutation,
):
old, new = mutation
capabilities = parse_host_capabilities(
CAPABILITY_OUTPUT.replace(old, new), public_network="bridge:br0",
)
assert capabilities["private_ready"] is False
assert capabilities["vpc_ready"] is False
assert "rp_filter_not_compatible" in capabilities["reasons"]
@pytest.mark.parametrize("fabric_value", [None, "invalid", "3"])
def test_capability_probe_requires_valid_rp_filter_for_existing_fabric(
fabric_value,
):
output = CAPABILITY_OUTPUT.replace(
'[{"ifname":"br0"}]',
'[{"ifname":"br0"},{"ifname":"wg-fabric0"}]',
1,
).replace(
"__VCAP_IP_BEGIN__wireguard\n[]",
'__VCAP_IP_BEGIN__wireguard\n[{"ifname":"wg-fabric0"}]',
).replace(
"__VCAP_FABRIC_OWNER_BEGIN__\n__VCAP_FABRIC_OWNER_END__",
"__VCAP_FABRIC_OWNER_BEGIN__\n"
+ WG_FABRIC_OWNERSHIP_MARKER
+ "\n__VCAP_FABRIC_OWNER_END__",
)
if fabric_value is not None:
output = output.replace(
"__VCAP_RPF__br0=2",
"__VCAP_RPF__br0=2\n"
f"__VCAP_RPF__wg-fabric0={fabric_value}",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["private_ready"] is False
assert "rp_filter_not_compatible" in capabilities["reasons"]
def test_capability_probe_ignores_guest_vnet_rp_filter_values():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_RPF__br0=2",
"__VCAP_RPF__br0=2\n"
"__VCAP_RPF__vnet1=1\n"
"__VCAP_RPF__vnet3=3\n"
"__VCAP_RPF__vnet10=invalid",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["vpc_ready"] is True
assert "rp_filter_not_compatible" not in capabilities["reasons"]
@pytest.mark.parametrize("underlay_value", [None, "invalid", "3"])
def test_capability_probe_does_not_guess_endpoint_from_public_bridge_selector(
underlay_value,
):
output = CAPABILITY_OUTPUT
if underlay_value is None:
output = output.replace("__VCAP_RPF__br0=2", "")
else:
output = output.replace(
"__VCAP_RPF__br0=2", f"__VCAP_RPF__br0={underlay_value}",
)
capabilities = parse_host_capabilities(
output, public_network="bridge:br0",
)
assert capabilities["network_roles"]["public"]["verified"] is True
assert capabilities["private_ready"] is True
assert capabilities["vpc_ready"] is True
assert "rp_filter_not_compatible" not in capabilities["reasons"]
def test_capability_probe_fails_closed_when_protocol_section_is_missing():
capabilities = parse_host_capabilities(
CAPABILITY_OUTPUT.replace("__VCAP_NFT_BEGIN__\n", ""),
public_network="bridge:br0",
)
assert capabilities["probe_valid"] is False
assert capabilities["vpc_ready"] is False
assert "capability_probe_invalid" in capabilities["reasons"]
def test_capability_probe_fails_closed_on_malformed_ip_json():
capabilities = parse_host_capabilities(
CAPABILITY_OUTPUT.replace(
'[{"ifname":"br0"}]', '[{"ifname":42}]', 1,
),
public_network="default",
)
assert capabilities["network"]["ip_probe_valid"] is False
assert capabilities["vpc_ready"] is False
assert "iproute2_probe_failed" in capabilities["reasons"]
def test_capability_probe_accepts_debian_wireguard_placeholders_when_unloaded():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_MODULE__wireguard=loaded",
"__VCAP_MODULE__wireguard=not_loaded",
).replace(
"__VCAP_IP_BEGIN__wireguard\n[]",
"__VCAP_IP_BEGIN__wireguard\n[{}, {}, {}]",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["network"]["ip_probe_valid"] is True
assert capabilities["network"]["wireguard_interfaces"] == []
assert "iproute2_probe_failed" not in capabilities["reasons"]
def test_capability_probe_rejects_wireguard_placeholders_when_loaded():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_IP_BEGIN__wireguard\n[]",
"__VCAP_IP_BEGIN__wireguard\n[{}]",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["network"]["ip_probe_valid"] is False
assert "iproute2_probe_failed" in capabilities["reasons"]
def test_capability_probe_rejects_nonempty_malformed_wireguard_record():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_MODULE__wireguard=loaded",
"__VCAP_MODULE__wireguard=not_loaded",
).replace(
"__VCAP_IP_BEGIN__wireguard\n[]",
'__VCAP_IP_BEGIN__wireguard\n[{}, {"ifindex":1}]',
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["network"]["ip_probe_valid"] is False
assert "iproute2_probe_failed" in capabilities["reasons"]
@pytest.mark.parametrize("section", ["links", "addresses", "bridges"])
def test_capability_probe_rejects_empty_placeholders_outside_wireguard(section):
begin = f"__VCAP_IP_BEGIN__{section}\n"
section_start = CAPABILITY_OUTPUT.index(begin) + len(begin)
section_end = CAPABILITY_OUTPUT.index(
f"__VCAP_IP_END__{section}=", section_start)
output = (
CAPABILITY_OUTPUT[:section_start]
+ "[{}]\n"
+ CAPABILITY_OUTPUT[section_end:]
).replace(
"__VCAP_MODULE__wireguard=loaded",
"__VCAP_MODULE__wireguard=not_loaded",
)
capabilities = parse_host_capabilities(output, public_network="bridge:br0")
assert capabilities["network"]["ip_probe_valid"] is False
assert "iproute2_probe_failed" in capabilities["reasons"]
def test_capability_probe_rejects_debian_networkd_policy():
output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace(
'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"',
).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace(
"__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=",
).replace(
"__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get",
).replace(
"__VCAP_TOOL__networkctl=", "__VCAP_TOOL__networkctl=/usr/bin/networkctl",
).replace(
"__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive",
).replace(
"__VCAP_SERVICE__networkd=inactive", "__VCAP_SERVICE__networkd=active",
).replace(
"__VCAP_SERVICE_ENABLED__network_manager=enabled",
"__VCAP_SERVICE_ENABLED__network_manager=disabled",
).replace(
"__VCAP_SERVICE_ENABLED__networkd=disabled",
"__VCAP_SERVICE_ENABLED__networkd=enabled",
)
capabilities = parse_host_capabilities(output)
assert capabilities["os"]["id"] == "debian"
assert capabilities["os"]["name"] == "Debian GNU/Linux"
assert capabilities["os"]["version_id"] == "13"
assert capabilities["os"]["family"] == "debian"
assert capabilities["os"]["package_manager"] == "apt"
assert capabilities["os"]["package_tool"] == "apt_get"
assert capabilities["os"]["package_tool_available"] is True
assert capabilities["os"]["supported"] is True
assert capabilities["network"]["network_manager"] == "systemd_networkd"
assert capabilities["network"]["network_manager_expected"] == "ifupdown"
assert capabilities["wireguard"]["deployment_mode"] == "unsupported"
assert capabilities["vpc_ready"] is False
assert "systemd_networkd_not_supported" in capabilities["reasons"]
def test_capability_probe_supports_debian_ifupdown_contract():
output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace(
'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"',
).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace(
"__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=",
).replace(
"__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get",
).replace(
"__VCAP_TOOL__networkctl=", "__VCAP_TOOL__networkctl=",
).replace(
"__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup",
).replace(
"__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown",
).replace(
"__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery",
).replace(
"__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive",
).replace(
"__VCAP_SERVICE_ENABLED__network_manager=enabled",
"__VCAP_SERVICE_ENABLED__network_manager=disabled",
).replace(
"__VCAP_SERVICE_ENABLED__networking=disabled",
"__VCAP_SERVICE_ENABLED__networking=enabled",
).replace(
"__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present",
)
capabilities = parse_host_capabilities(output)
assert capabilities["network"]["network_manager"] == "ifupdown"
assert capabilities["network"]["network_manager_expected"] == "ifupdown"
assert capabilities["network"]["ifupdown"]["configured"] is True
assert capabilities["network"]["ifupdown"]["service_enabled"] is True
assert capabilities["network"]["deployment_mode"] == "ifupdown"
assert capabilities["wireguard"]["deployment_mode"] == "ifupdown"
assert capabilities["vpc_ready"] is True
def test_capability_probe_ignores_static_networkd_when_ifupdown_owns_debian():
output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace(
'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"',
).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace(
"__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=",
).replace(
"__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get",
).replace(
"__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup",
).replace(
"__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown",
).replace(
"__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery",
).replace(
"__VCAP_SERVICE__network_manager=active",
"__VCAP_SERVICE__network_manager=inactive",
).replace(
"__VCAP_SERVICE_ENABLED__network_manager=enabled",
"__VCAP_SERVICE_ENABLED__network_manager=disabled",
).replace(
"__VCAP_SERVICE_ENABLED__networkd=disabled",
"__VCAP_SERVICE_ENABLED__networkd=static",
).replace(
"__VCAP_SERVICE_ENABLED__networking=disabled",
"__VCAP_SERVICE_ENABLED__networking=enabled",
).replace(
"__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present",
)
capabilities = parse_host_capabilities(output)
assert capabilities["network"]["network_manager"] == "ifupdown"
assert capabilities["network"]["network_manager_supported"] is True
assert capabilities["vpc_ready"] is True
def test_capability_probe_rejects_ifupdown_without_required_tools():
output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace(
'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"',
).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace(
"__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=",
).replace(
"__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get",
).replace(
"__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive",
).replace(
"__VCAP_SERVICE_ENABLED__network_manager=enabled",
"__VCAP_SERVICE_ENABLED__network_manager=disabled",
).replace(
"__VCAP_SERVICE_ENABLED__networking=disabled",
"__VCAP_SERVICE_ENABLED__networking=enabled",
).replace(
"__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present",
)
capabilities = parse_host_capabilities(output)
assert capabilities["network"]["network_manager"] == "ifupdown"
assert capabilities["vpc_ready"] is False
assert "ifupdown_tools_missing" in capabilities["reasons"]
def test_capability_probe_rejects_mixed_network_managers():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup",
).replace(
"__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown",
).replace(
"__VCAP_SERVICE_ENABLED__networking=disabled",
"__VCAP_SERVICE_ENABLED__networking=enabled",
).replace(
"__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present",
)
capabilities = parse_host_capabilities(output)
assert capabilities["network"]["network_manager"] == "conflict"
assert capabilities["network"]["network_manager_supported"] is False
assert capabilities["vpc_ready"] is False
assert "network_manager_conflict" in capabilities["reasons"]
def test_capability_probe_rejects_enabled_networkd_with_ifupdown():
output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace(
'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"',
).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace(
"__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=",
).replace(
"__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get",
).replace(
"__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup",
).replace(
"__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown",
).replace(
"__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery",
).replace(
"__VCAP_SERVICE__network_manager=active",
"__VCAP_SERVICE__network_manager=inactive",
).replace(
"__VCAP_SERVICE_ENABLED__network_manager=enabled",
"__VCAP_SERVICE_ENABLED__network_manager=disabled",
).replace(
"__VCAP_SERVICE_ENABLED__networkd=disabled",
"__VCAP_SERVICE_ENABLED__networkd=enabled",
).replace(
"__VCAP_SERVICE_ENABLED__networking=disabled",
"__VCAP_SERVICE_ENABLED__networking=enabled",
).replace(
"__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present",
)
capabilities = parse_host_capabilities(output)
assert capabilities["network"]["network_manager"] == "conflict"
assert capabilities["vpc_ready"] is False
assert "network_manager_conflict" in capabilities["reasons"]
def test_capability_probe_rejects_persistent_networkd_config_with_ifupdown():
output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace(
'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"',
).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace(
"__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=",
).replace(
"__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get",
).replace(
"__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup",
).replace(
"__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown",
).replace(
"__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery",
).replace(
"__VCAP_SERVICE__network_manager=active",
"__VCAP_SERVICE__network_manager=inactive",
).replace(
"__VCAP_SERVICE_ENABLED__network_manager=enabled",
"__VCAP_SERVICE_ENABLED__network_manager=disabled",
).replace(
"__VCAP_SERVICE_ENABLED__networking=disabled",
"__VCAP_SERVICE_ENABLED__networking=enabled",
).replace(
"__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present",
).replace(
"__VCAP_FILE__networkd_configs=absent",
"__VCAP_FILE__networkd_configs=present",
)
capabilities = parse_host_capabilities(output)
assert capabilities["network"]["network_manager"] == "conflict"
assert capabilities["network"]["network_manager_supported"] is False
assert capabilities["vpc_ready"] is False
assert capabilities["network"]["network_manager_evidence"][
"systemd_networkd_configured"] is True
assert "network_manager_conflict" in capabilities["reasons"]
def test_capability_probe_rejects_networkmanager_profile_with_debian_ifupdown():
output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace(
'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"',
).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace(
"__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=",
).replace(
"__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get",
).replace(
"__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup",
).replace(
"__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown",
).replace(
"__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery",
).replace(
"__VCAP_SERVICE__network_manager=active",
"__VCAP_SERVICE__network_manager=inactive",
).replace(
"__VCAP_SERVICE_ENABLED__network_manager=enabled",
"__VCAP_SERVICE_ENABLED__network_manager=disabled",
).replace(
"__VCAP_SERVICE_ENABLED__networking=disabled",
"__VCAP_SERVICE_ENABLED__networking=enabled",
).replace(
"__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present",
).replace(
"__VCAP_FILE__networkmanager_profiles=absent",
"__VCAP_FILE__networkmanager_profiles=present",
)
capabilities = parse_host_capabilities(output)
assert capabilities["network"]["network_manager"] == "conflict"
assert capabilities["network"]["network_manager_supported"] is False
assert capabilities["vpc_ready"] is False
assert capabilities["network"]["network_manager_evidence"][
"networkmanager_configured"] is True
assert "network_manager_conflict" in capabilities["reasons"]
def test_capability_probe_rejects_nonpersistent_networkmanager():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_SERVICE_ENABLED__network_manager=enabled",
"__VCAP_SERVICE_ENABLED__network_manager=disabled",
)
capabilities = parse_host_capabilities(output)
assert capabilities["network"]["network_manager"] == "networkmanager"
assert capabilities["wireguard"]["deployment_mode"] == "unsupported"
assert capabilities["vpc_ready"] is False
assert "networkmanager_service_not_enabled" in capabilities["reasons"]
def test_rejects_unconfirmed_or_changed_host_key(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
with pytest.raises(RemoteHostError, match="确认"):
manager.stage(make_profile(scanned), "")
runner.key = host_key(b"b")
with pytest.raises(RemoteHostError) as error:
manager.stage(make_profile(scanned), scanned["fingerprint"])
assert error.value.status == 409
assert manager.current() is None
def test_failed_test_preserves_old_connection_and_key_can_be_reused(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
first_scan = manager.scan("host.example", 2222)
first = manager.stage(make_profile(first_scan), first_scan["fingerprint"])
manager.test(first)
manager.commit(first)
first_config = manager.ssh_user_config_path.resolve()
next_scan = manager.scan("other.example", 2222)
second = manager.stage(
make_profile(next_scan, key="", host="other.example"),
next_scan["fingerprint"],
)
assert (second.path / "id_private").read_text() == PRIVATE_KEY
runner.ssh_exit = 255
with pytest.raises(RemoteHostError) as error:
manager.test(second)
assert error.value.status == 502
with pytest.raises(RemoteHostError, match="测试"):
manager.commit(second)
assert manager.ssh_user_config_path.resolve() == first_config
assert manager.current()["host"] == "host.example"
manager.abort(second)
assert not second.path.exists()
def test_first_connection_needs_key_and_does_not_replace_existing_config(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
with pytest.raises(RemoteHostError, match="首次") as missing:
manager.stage(make_profile(scanned, key=""), scanned["fingerprint"])
assert missing.value.error_code == "host_private_key_required"
manager.ssh_user_config_path.parent.mkdir(mode=0o700, parents=True)
manager.ssh_user_config_path.write_text("Host unrelated\n")
staged = manager.stage(make_profile(scanned), scanned["fingerprint"])
manager.test(staged)
with pytest.raises(RemoteHostError, match="已有其他 SSH 配置"):
manager.commit(staged)
assert manager.ssh_user_config_path.read_text() == "Host unrelated\n"
assert manager.current() is None
@pytest.mark.skipif(shutil.which("ssh") is None, reason="OpenSSH client unavailable")
def test_openssh_reads_staged_nondefault_port_and_root_identity(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(scanned), scanned["fingerprint"])
result = subprocess.run(
["ssh", "-G", "-F", staged.ssh_config_file, "vp-managed"],
check=True,
capture_output=True,
text=True,
timeout=8,
)
options = dict(line.split(" ", 1) for line in result.stdout.splitlines() if " " in line)
assert options["hostname"] == "host.example"
assert options["port"] == "2222"
assert options["user"] == "root"
assert options["hostkeyalias"] == "vp-managed"
assert options["stricthostkeychecking"] == "true"
assert options["identityfile"] == str(staged.path / "id_private")
assert options["userknownhostsfile"] == str(staged.path / "known_hosts")
def test_staged_wrapper_passes_config_to_ssh_without_shell(tmp_path):
runner = Runner()
manager = RemoteHostManager(
tmp_path / "service-home", ssh_binary="/bin/echo", runner=runner
)
scanned = manager.scan("host.example", 2222)
staged = manager.stage(make_profile(scanned), scanned["fingerprint"])
result = subprocess.run(
[str(staged.path / "ssh-wrapper"), "-T", "root@vp-managed"],
check=True,
capture_output=True,
text=True,
timeout=8,
)
assert result.stdout.strip() == f"-F {staged.ssh_config_file} -T root@vp-managed"
def test_only_retired_generations_are_pruned(tmp_path):
runner = Runner()
manager = make_manager(tmp_path, runner)
scanned = manager.scan("host.example", 2222)
first = manager.stage(make_profile(scanned), scanned["fingerprint"])
manager.test(first)
manager.commit(first)
second = manager.stage(make_profile(scanned, key=""), scanned["fingerprint"])
# An uncommitted generation must not be deleted by background cleanup.
assert manager.cleanup_inactive(grace_seconds=0) == 0
assert second.path.is_dir()
manager.test(second)
manager.commit(second)
assert manager.cleanup_inactive(grace_seconds=60) == 0
assert first.path.is_dir()
assert manager.cleanup_inactive(grace_seconds=0) == 1
assert not first.path.exists()
assert second.path.is_dir()
assert manager.current()["ssh_config_file"] == second.ssh_config_file
def test_symlinked_parent_keeps_active_generation(tmp_path):
# A lexical/canonical path mismatch must not classify the active
# generation as retired.
actual_parent = tmp_path / "private" / "virsh-panel"
actual_parent.mkdir(parents=True)
public_parent = tmp_path / "public-parent"
public_parent.symlink_to(actual_parent, target_is_directory=True)
runner = Runner()
manager = RemoteHostManager(public_parent / "state", runner=runner)
assert manager.data_dir == actual_parent / "state"
scanned = manager.scan("host.example", 2222)
first = manager.stage(make_profile(scanned), scanned["fingerprint"])
manager.test(first)
manager.commit(first)
assert manager.current()["ssh_config_file"] == first.ssh_config_file
assert manager.cleanup_inactive(grace_seconds=0) == 0
assert first.path.is_dir()
restarted = RemoteHostManager(public_parent / "state", runner=runner)
assert restarted.current()["ssh_config_file"] == first.ssh_config_file
assert restarted.cleanup_inactive(grace_seconds=0) == 0
assert first.path.is_dir()
second = restarted.stage(make_profile(scanned, key=""), scanned["fingerprint"])
restarted.test(second)
restarted.commit(second)
assert restarted.cleanup_inactive(grace_seconds=0) == 1
assert not first.path.exists()
assert second.path.is_dir()
assert restarted.current()["ssh_config_file"] == second.ssh_config_file
def test_rejects_symlink_as_final_data_directory(tmp_path):
actual = tmp_path / "actual"
actual.mkdir()
alias = tmp_path / "alias"
alias.symlink_to(actual, target_is_directory=True)
with pytest.raises(RemoteHostError, match="符号链接"):
RemoteHostManager(alias, runner=Runner())
@pytest.mark.parametrize("host,port", [
("-oProxyCommand=bad", 22),
("host.example\nUser attacker", 22),
("example.com", 0),
("example.com", 65536),
("example.com", True),
])
def test_rejects_host_and_port_injection(tmp_path, host, port):
runner = Runner()
manager = make_manager(tmp_path, runner)
with pytest.raises(RemoteHostError):
manager.scan(host, port)
assert runner.commands == []