"""Exercise the production proc/sys reader with real POSIX shells.""" from __future__ import annotations import base64 import os import re import shlex import subprocess from pathlib import Path import pytest from virsh_panel.fabric import ( _BOOT_HELPER, _FABRIC_SYSCTL_VALIDATION_SH, _apply_script, _observe_script, parse_fabric_plan, ) SHELLS = tuple(path for path in ("/bin/sh", "/bin/dash", "/bin/bash") if os.access(path, os.X_OK)) @pytest.fixture(params=SHELLS) def shell(request): return request.param def run_reader(shell, path, prefix="", reader="vc_read_proc_sysctl", source=_FABRIC_SYSCTL_VALIDATION_SH): return subprocess.run( [shell, "-c", prefix + "\n" + source + f'\n{reader} "$1"\n', "sysctl-reader", str(path)], text=True, capture_output=True, timeout=5, check=False, ) @pytest.mark.parametrize("value", ("0", "1", "2")) def test_buffered_reader_accepts_one_kernel_integer_line(tmp_path, shell, value): path = tmp_path / "sysctl" path.write_text(value + "\n", encoding="ascii") result = run_reader(shell, path) assert result.returncode == 0, result.stderr assert result.stdout == value @pytest.mark.parametrize("payload", ( "", "1", "1\n\n", "1\n2\n", "1\ninvalid\n", " 1\n", "1 \n", "1\r\n", "3\n", "-1\n", "01\n", "1.0\n", )) def test_buffered_reader_rejects_empty_multiline_or_malformed_values( tmp_path, shell, payload): path = tmp_path / "sysctl" path.write_text(payload, encoding="ascii") result = run_reader(shell, path) assert result.returncode != 0 assert result.stdout == "" @pytest.mark.parametrize("target", ("missing", "directory", "partial_io")) def test_buffered_reader_rejects_io_failure_even_after_a_valid_digit( tmp_path, shell, target): path = tmp_path / "sysctl" prefix = "" if target == "directory": path.mkdir() elif target == "partial_io": path.write_text("1\n", encoding="ascii") # A partial read must not become valid merely because stdout already # contained a valid-looking value before cat reported an I/O error. prefix = 'cat() { command cat "$@"; return 42; }' result = run_reader(shell, path, prefix) assert result.returncode != 0 assert result.stdout == "" def test_buffered_reader_survives_proc_single_read_eof(tmp_path, shell): path = tmp_path / "sysctl" path.write_text("1\n", encoding="ascii") # Model the observable result of a one-byte shell read from an integer # proc sysctl: it assigns the digit, then sees EOF before the newline. # The buffered production reader must not depend on that builtin result. prefix = '''read() { proc_digit=1; return 1; } legacy_reader() { proc_digit= IFS= read -r proc_digit < "$1" || return 1 printf '%s' "$proc_digit" } ''' legacy = run_reader(shell, path, prefix, "legacy_reader") assert legacy.returncode != 0 buffered = run_reader(shell, path, prefix) assert buffered.returncode == 0, buffered.stderr assert buffered.stdout == "1" @pytest.fixture(scope="module") def production_scripts(): plan = parse_fabric_plan({ "fabric_id": "proc-test", "region": "hk", "revision": 1, "overlay_cidr": "100.64.1.0/24", "listen_port": 51820, "nodes": [ {"host_id": "a", "overlay_ip": "100.64.1.1", "endpoint": "203.0.113.1:51820"}, {"host_id": "b", "overlay_ip": "100.64.1.2", "endpoint": "203.0.113.2:51820"}, ], }) keys = {node.host_id: base64.b64encode(bytes([index + 1]) * 32).decode() for index, node in enumerate(plan.nodes)} return { "apply": _apply_script(plan, plan.nodes[0], keys), "boot": _BOOT_HELPER, "observe": _observe_script( ("100.64.1.2",), "100.64.1.1", expected_digest=plan.digest, ), } @pytest.mark.parametrize("script_name", ("apply", "boot", "observe")) def test_each_production_sysctl_reader_uses_buffered_io( tmp_path, shell, production_scripts, script_name): script = production_scripts[script_name] reader = "read_observed_sysctl" if script_name == "observe" else "read_sysctl" function = re.search( rf"^{reader}\(\) \{{\n.*?^\}}", script, re.MULTILINE | re.DOTALL) assert function is not None shared_reader = re.search( r"^vc_read_proc_sysctl\(\) \{\n.*?^\}", script, re.MULTILINE | re.DOTALL) assert shared_reader is not None path = tmp_path / "sysctl" path.write_text("1\n", encoding="ascii") result = run_reader( shell, path, function.group(0), reader, shared_reader.group(0)) assert result.returncode == 0, result.stderr assert result.stdout == "1" assert 'IFS= read -r sysctl_value' not in script assert 'IFS= read -r observed_sysctl_value' not in script assert 'IFS= read -r vc_rpf_value' not in script @pytest.mark.parametrize("script_name", ("apply", "boot")) @pytest.mark.parametrize("value,expected_rc", (("0", 71), ("1", 0), ("2", 71))) def test_preflight_and_boot_still_require_exact_ip_forward_one( tmp_path, shell, production_scripts, script_name, value, expected_rc): script = production_scripts[script_name] reader = re.search( r'^read_sysctl\(\) \{\n vc_read_proc_sysctl "\$1"\n\}', script, re.MULTILINE) check = re.search( r'^if ! sysctl_forward=\$\(read_sysctl /proc/sys/net/ipv4/ip_forward\); ' r'then exit 71; fi\n\[ "\$sysctl_forward" = 1 \] \|\| exit 71', script, re.MULTILINE) assert reader is not None and check is not None path = tmp_path / "sysctl" path.write_text(value + "\n", encoding="ascii") # Phase logging may occur between the reader and the check; extract only # these exact fragments, never intervening rendered helper/transaction code. check_script = reader.group(0) + "\n" + check.group(0).replace( "/proc/sys/net/ipv4/ip_forward", '"$1"') result = subprocess.run( [shell, "-c", _FABRIC_SYSCTL_VALIDATION_SH + "\n" + check_script, "sysctl-preflight", str(path)], text=True, capture_output=True, timeout=5, check=False, ) assert result.returncode == expected_rc, result.stderr @pytest.mark.parametrize("io_fails", (False, True)) def test_platform_rp_filter_write_requires_buffered_exact_two_readback( tmp_path, shell, io_fails): owner = tmp_path / "owner" owner.write_text("virt-cloud-wg-fabric-v1\n", encoding="ascii") path = tmp_path / "rp_filter" path.write_text("1\n", encoding="ascii") setter = re.search( r"^vc_fabric_rp_filter_set\(\) \{\n.*?^\}", _FABRIC_SYSCTL_VALIDATION_SH, re.MULTILINE | re.DOTALL) assert setter is not None source = _FABRIC_SYSCTL_VALIDATION_SH + "\n" + setter.group(0).replace( 'vc_rpf_path="/proc/sys/net/ipv4/conf/$IFACE/rp_filter"', 'vc_rpf_path="$RPF_FILE"', ) prefix = (f"OWNER={shlex.quote(str(owner))}\n" f"RPF_FILE={shlex.quote(str(path))}\nWG=:; IFACE=wg-fabric0\n") if io_fails: prefix += '''cat() { command cat "$@" || return 1 [ "$1" != "$RPF_FILE" ] || return 42 } ''' result = run_reader( shell, path, prefix, "vc_fabric_rp_filter_set", source) assert path.read_text(encoding="ascii") == "2\n" assert result.returncode == (1 if io_fails else 0), result.stderr @pytest.mark.parametrize("path", ( "/proc/sys/net/ipv4/ip_forward", "/proc/sys/net/ipv4/conf/all/rp_filter", "/proc/sys/net/ipv4/conf/default/rp_filter", )) def test_buffered_reader_reads_real_linux_proc_sysctl(shell, path): source = Path(path) if not source.is_file(): pytest.skip("real Linux proc sysctls are unavailable on this test host") expected = source.read_text(encoding="ascii").strip() assert expected in ("0", "1", "2") result = run_reader(shell, source) assert result.returncode == 0, result.stderr assert result.stdout == expected