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.
1944 lines
76 KiB
Python
1944 lines
76 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 "--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') == 4
|
|
assert _CAPABILITY_PROBE_COMMAND.count(
|
|
'$firewall_cmd --state') == 4
|
|
assert _CAPABILITY_PROBE_COMMAND.index(
|
|
'firewall_service_state="$status"') < _CAPABILITY_PROBE_COMMAND.index(
|
|
'$firewall_cmd --state')
|
|
|
|
|
|
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 == []
|