Remove firewalld support from VPC fabric
parent
82ce350001
commit
ecf221d181
File diff suppressed because it is too large
Load Diff
@ -1,304 +0,0 @@
|
||||
"""Strict ownership for NetworkManager's normal in-memory keyfile shadow."""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import json
|
||||
import re
|
||||
import shlex
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from virsh_panel.fabric import (
|
||||
_BOOT_HELPER,
|
||||
_FIREWALL_MODE_GUARD_SH,
|
||||
_NMCLI_FILENAME_RESOLVER_SH,
|
||||
_apply_script,
|
||||
_fabric_connection_uuid,
|
||||
_nm_profile_template,
|
||||
_observe_script,
|
||||
parse_fabric_plan,
|
||||
)
|
||||
|
||||
|
||||
KEY = base64.b64encode(bytes([7]) * 32).decode()
|
||||
UUID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
|
||||
DIGEST = "a" * 64
|
||||
NAME = "virt-cloud-wg-fabric0"
|
||||
|
||||
|
||||
def _write(path: Path, text: str, mode=0o600):
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(text, encoding="utf-8")
|
||||
path.chmod(mode)
|
||||
|
||||
|
||||
def _persistent():
|
||||
return f'''# virt-cloud-wg-fabric-v1
|
||||
# fabric-plan-digest={DIGEST}
|
||||
[connection]
|
||||
id={NAME}
|
||||
uuid={UUID}
|
||||
type=wireguard
|
||||
interface-name=wg-fabric0
|
||||
autoconnect=false
|
||||
autoconnect-retries=0
|
||||
|
||||
[wireguard]
|
||||
private-key={KEY}
|
||||
listen-port=51820
|
||||
|
||||
[ipv4]
|
||||
method=manual
|
||||
address1=100.64.1.1/32
|
||||
never-default=true
|
||||
route-metric=50
|
||||
route1=100.64.1.2/32
|
||||
|
||||
[ipv6]
|
||||
method=disabled
|
||||
'''
|
||||
|
||||
|
||||
def _runtime(persistent: Path, zone="trusted"):
|
||||
# Real NM serialization loses comments, changes section/key order and adds
|
||||
# only zone, an empty proxy group and these exact two shadow metadata keys.
|
||||
return f'''[wireguard]
|
||||
listen-port=51820
|
||||
private-key={KEY}
|
||||
|
||||
[connection]
|
||||
autoconnect-retries=0
|
||||
interface-name=wg-fabric0
|
||||
uuid={UUID}
|
||||
autoconnect=false
|
||||
type=wireguard
|
||||
id={NAME}
|
||||
zone={zone}
|
||||
|
||||
[ipv6]
|
||||
method=disabled
|
||||
|
||||
[ipv4]
|
||||
route1=100.64.1.2/32
|
||||
route-metric=50
|
||||
never-default=true
|
||||
address1=100.64.1.1/32
|
||||
method=manual
|
||||
|
||||
[proxy]
|
||||
|
||||
[.nmmeta]
|
||||
shadowed-storage={persistent}
|
||||
shadowed-owned=true
|
||||
'''
|
||||
|
||||
|
||||
_TOOL = r'''import hashlib, json, os, stat, sys
|
||||
from pathlib import Path
|
||||
name = Path(sys.argv[0]).name
|
||||
args = sys.argv[1:]
|
||||
root = Path(os.environ["VC_SHADOW_ROOT"])
|
||||
if name == "stat":
|
||||
path = Path(args[-1])
|
||||
value = os.stat(path)
|
||||
override = json.loads((root / "owners").read_text())
|
||||
uid, gid = override.get(str(path), [0, 0])
|
||||
mode = format(stat.S_IMODE(value.st_mode), "o")
|
||||
values = {"%u": str(uid), "%a": mode, "%u:%a": f"{uid}:{mode}",
|
||||
"%u:%g:%a": f"{uid}:{gid}:{mode}", "%s": str(value.st_size)}
|
||||
print(values[args[1]])
|
||||
elif name == "sha256sum":
|
||||
print(hashlib.sha256(Path(args[0]).read_bytes()).hexdigest(), args[0])
|
||||
elif name == "nmcli":
|
||||
if args[:5] == ["-t", "--escape", "no", "-f", "NAME,UUID"]:
|
||||
print((root / "names").read_text(), end="")
|
||||
elif args[:5] == ["-t", "--escape", "no", "-f", "UUID,FILENAME"]:
|
||||
print((root / "filenames").read_text(), end="")
|
||||
else:
|
||||
raise SystemExit(2)
|
||||
else:
|
||||
raise SystemExit(2)
|
||||
'''
|
||||
|
||||
|
||||
def _fixture(tmp_path):
|
||||
roots = {
|
||||
"/etc/NetworkManager": tmp_path / "etc" / "NetworkManager",
|
||||
"/run": tmp_path / "run",
|
||||
}
|
||||
persistent = roots["/etc/NetworkManager"] / "system-connections" / (NAME + ".nmconnection")
|
||||
runtime = roots["/run"] / "NetworkManager" / "system-connections" / (NAME + ".nmconnection")
|
||||
_write(persistent, _persistent())
|
||||
_write(runtime, _runtime(persistent))
|
||||
for path in (roots["/run"], runtime.parent.parent, runtime.parent):
|
||||
path.chmod(0o755)
|
||||
_write(tmp_path / "names", f"{NAME}:{UUID}\n")
|
||||
_write(tmp_path / "filenames", f"{UUID}:{runtime}\n")
|
||||
_write(tmp_path / "owners", "{}")
|
||||
tools = tmp_path / "tools"
|
||||
tools.mkdir()
|
||||
actual = tools / "tool"
|
||||
_write(actual, f"#!{sys.executable}\n" + _TOOL, 0o700)
|
||||
for name in ("stat", "sha256sum", "nmcli"):
|
||||
(tools / name).symlink_to(actual)
|
||||
start = _FIREWALL_MODE_GUARD_SH.index("vc_fabric_nm_profile_secure_hash() {")
|
||||
end = _FIREWALL_MODE_GUARD_SH.index("\nvc_fabric_nm_active()", start)
|
||||
body = _NMCLI_FILENAME_RESOLVER_SH + "\n" + _FIREWALL_MODE_GUARD_SH[start:end]
|
||||
for source, target in roots.items():
|
||||
body = body.replace(source, str(target))
|
||||
prefix = (
|
||||
f"STAT={shlex.quote(str(tools / 'stat'))}\n"
|
||||
f"NMCLI={shlex.quote(str(tools / 'nmcli'))}\n"
|
||||
f"NM_PROFILE={shlex.quote(str(persistent))}\n"
|
||||
f"CONNECTION={shlex.quote(NAME)}\nCONNECTION_UUID={shlex.quote(UUID)}\n"
|
||||
f"EXPECTED_DIGEST={shlex.quote(DIGEST)}\nFIREWALL_MODE=firewalld_nft\n"
|
||||
"find_tool() { printf '%s' " + shlex.quote(str(tools / "sha256sum")) + "; }\n"
|
||||
)
|
||||
script = prefix + body + "\nvc_fabric_nm_profile_owned expected\n"
|
||||
return persistent, runtime, script
|
||||
|
||||
|
||||
def _run(tmp_path, script):
|
||||
return subprocess.run(["/bin/sh", "-eu", "-c", script], capture_output=True,
|
||||
text=True, check=False,
|
||||
env={"VC_SHADOW_ROOT": str(tmp_path)}, timeout=15)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("location", ["persistent", "runtime"])
|
||||
@pytest.mark.parametrize("zone", ["trusted", "", "absent"])
|
||||
def test_same_owned_profile_accepts_only_exact_normal_shadow(tmp_path, location, zone):
|
||||
persistent, runtime, script = _fixture(tmp_path)
|
||||
text = _runtime(persistent, zone if zone != "absent" else "")
|
||||
if zone == "absent":
|
||||
text = text.replace("zone=\n", "")
|
||||
_write(runtime, text)
|
||||
if location == "persistent":
|
||||
_write(tmp_path / "filenames", f"{UUID}:{persistent}\n")
|
||||
result = _run(tmp_path, script)
|
||||
assert result.returncode == 0, result.stderr
|
||||
assert result.stdout == result.stderr == ""
|
||||
|
||||
|
||||
@pytest.mark.parametrize("drift", [
|
||||
"key", "port", "address", "route", "route_metric", "ipv4_method", "ipv6_method",
|
||||
"autoconnect", "uuid", "type", "zone", "persistent_zone", "metadata_path",
|
||||
"metadata_owner", "metadata_extra", "unknown_key", "unknown_section", "duplicate_key",
|
||||
"duplicate_section", "extra_route", "proxy_key", "metadata_missing",
|
||||
])
|
||||
def test_shadow_semantic_drift_or_unknown_shape_fails_without_secret_output(tmp_path, drift):
|
||||
persistent, runtime, script = _fixture(tmp_path)
|
||||
text = runtime.read_text(encoding="utf-8")
|
||||
substitutions = {
|
||||
"key": (KEY, base64.b64encode(bytes([8]) * 32).decode()),
|
||||
"port": ("listen-port=51820", "listen-port=51821"),
|
||||
"address": ("address1=100.64.1.1/32", "address1=100.64.1.3/32"),
|
||||
"route": ("route1=100.64.1.2/32", "route1=100.64.1.3/32"),
|
||||
"route_metric": ("route-metric=50", "route-metric=51"),
|
||||
"ipv4_method": ("method=manual", "method=auto"),
|
||||
"ipv6_method": ("method=disabled", "method=auto"),
|
||||
"autoconnect": ("autoconnect=false", "autoconnect=true"),
|
||||
"uuid": (UUID, "f" * 36),
|
||||
"type": ("type=wireguard", "type=bridge"),
|
||||
"zone": ("zone=trusted", "zone=public"),
|
||||
"metadata_path": (f"shadowed-storage={persistent}", "shadowed-storage=/etc/external"),
|
||||
"metadata_owner": ("shadowed-owned=true", "shadowed-owned=false"),
|
||||
"metadata_extra": ("shadowed-owned=true", "shadowed-owned=true\nexternal=true"),
|
||||
"unknown_key": ("listen-port=51820", "listen-port=51820\nfwmark=1"),
|
||||
"unknown_section": ("[proxy]", "[unmanaged]"),
|
||||
"duplicate_key": ("listen-port=51820", "listen-port=51820\nlisten-port=51820"),
|
||||
"duplicate_section": ("[proxy]", "[ipv4]\nmethod=manual\n[proxy]"),
|
||||
"extra_route": ("route1=100.64.1.2/32", "route1=100.64.1.2/32\nroute2=10.1.0.1/32"),
|
||||
"proxy_key": ("[proxy]", "[proxy]\nmethod=auto"),
|
||||
"metadata_missing": ("shadowed-owned=true\n", ""),
|
||||
}
|
||||
if drift == "persistent_zone":
|
||||
_write(persistent, persistent.read_text().replace("[connection]", "[connection]\nzone=trusted"))
|
||||
else:
|
||||
old, new = substitutions[drift]
|
||||
_write(runtime, text.replace(old, new))
|
||||
result = _run(tmp_path, script)
|
||||
assert result.returncode != 0
|
||||
assert result.stdout == result.stderr == ""
|
||||
|
||||
|
||||
@pytest.mark.parametrize("drift", [
|
||||
"filename", "basename", "runtime_symlink", "parent_symlink", "parent_writable",
|
||||
"runtime_wide", "runtime_owner", "persistent_owner", "duplicate_uuid", "duplicate_name",
|
||||
"runtime_empty", "runtime_large",
|
||||
])
|
||||
def test_runtime_path_and_ownership_are_not_widened(tmp_path, drift):
|
||||
persistent, runtime, script = _fixture(tmp_path)
|
||||
if drift in ("filename", "basename"):
|
||||
path = tmp_path / "external" if drift == "filename" else runtime.with_name("external.nmconnection")
|
||||
_write(path, runtime.read_text())
|
||||
_write(tmp_path / "filenames", f"{UUID}:{path}\n")
|
||||
elif drift == "runtime_symlink":
|
||||
external = tmp_path / "external"
|
||||
_write(external, runtime.read_text())
|
||||
runtime.unlink()
|
||||
runtime.symlink_to(external)
|
||||
elif drift == "parent_symlink":
|
||||
external = runtime.parent.with_name("external")
|
||||
runtime.parent.rename(external)
|
||||
runtime.parent.symlink_to(external)
|
||||
elif drift == "parent_writable":
|
||||
runtime.parent.chmod(0o775)
|
||||
elif drift == "runtime_wide":
|
||||
runtime.chmod(0o644)
|
||||
elif drift in ("runtime_owner", "persistent_owner"):
|
||||
path = runtime if drift == "runtime_owner" else persistent
|
||||
_write(tmp_path / "owners", json.dumps({str(path): [1000, 0]}))
|
||||
elif drift == "duplicate_uuid":
|
||||
_write(tmp_path / "names", f"{NAME}:{UUID}\nother:{UUID}\n")
|
||||
elif drift == "duplicate_name":
|
||||
_write(tmp_path / "names", f"{NAME}:{UUID}\n{NAME}:other\n")
|
||||
elif drift == "runtime_empty":
|
||||
_write(runtime, "")
|
||||
else:
|
||||
_write(runtime, runtime.read_text() + "#" * 65536)
|
||||
result = _run(tmp_path, script)
|
||||
assert result.returncode != 0
|
||||
assert result.stdout == result.stderr == ""
|
||||
|
||||
|
||||
def test_shared_shadow_contract_is_rendered_in_apply_observe_and_boot():
|
||||
plan = parse_fabric_plan({
|
||||
"fabric_id": "shadow-fabric", "region": "hk", "overlay_cidr": "100.64.1.0/24",
|
||||
"revision": 1, "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: KEY for node in plan.nodes}
|
||||
apply = _apply_script(plan, plan.nodes[0], keys, firewall_mode="firewalld_nft")
|
||||
observe = _observe_script(("100.64.1.2",), "100.64.1.1", firewall_mode="firewalld_nft")
|
||||
for script in (apply, observe):
|
||||
assert "vc_fabric_nm_profile_semantics_match() {" in script
|
||||
assert "shadowed-storage" in script
|
||||
subprocess.run(["/bin/sh", "-n"], input=script, text=True, check=True)
|
||||
assert "vc_fabric_nm_profile_semantics_match" in _BOOT_HELPER or "__VC_FIREWALL_MODE_GUARD__" in _BOOT_HELPER
|
||||
|
||||
|
||||
def test_first_deploy_recovery_dispatch_requires_exact_published_old_helper():
|
||||
plan = parse_fabric_plan({
|
||||
"fabric_id": "shadow-fabric", "region": "hk", "overlay_cidr": "100.64.1.0/24",
|
||||
"revision": 1, "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"},
|
||||
],
|
||||
})
|
||||
script = _apply_script(plan, plan.nodes[0], {node.host_id: KEY for node in plan.nodes},
|
||||
firewall_mode="firewalld_nft")
|
||||
start = script.index("transaction_first_deploy_helper_absent=no")
|
||||
end = script.index("transaction_missing_installing_snapshot=no", start)
|
||||
guard = script[start:end]
|
||||
assert 'transaction_recovery_helper_owned || exit 79' in guard
|
||||
assert 'fabric-plan-digest=$EXPECTED_DIGEST' in guard
|
||||
assert 'PLAN_DIGEST=\\"$EXPECTED_DIGEST\\"' in guard
|
||||
assert guard.index('helper.present') < guard.index('transaction_recovery_helper_owned')
|
||||
current = script.index('/bin/sh "$_tmp_helper" --recover-current', end)
|
||||
ordinary = script.index('/bin/sh "$HELPER" --recover-only', current)
|
||||
assert current < ordinary
|
||||
@ -1,121 +0,0 @@
|
||||
"""Replay a failed first-deploy post-image through the current recovery helper."""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import json
|
||||
import re
|
||||
import shlex
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from test_fabric_first_deploy_entry import _fixture, _journal, _write
|
||||
from virsh_panel.fabric import (
|
||||
FIREWALL_MODE_FIREWALLD,
|
||||
_FABRIC_NFT_VALIDATION_SH,
|
||||
_FABRIC_SYSCTL_VALIDATION_SH,
|
||||
_FIREWALL_MODE_GUARD_SH,
|
||||
_NMCLI_FILENAME_RESOLVER_SH,
|
||||
_TRANSACTION_SCRIPT,
|
||||
_nm_profile_template,
|
||||
)
|
||||
|
||||
|
||||
def _failed_first_deploy(tmp_path):
|
||||
plan, current, base, runtime, roots = _fixture(tmp_path, "networkmanager_nmcli")
|
||||
journal = _journal(plan, base, "networkmanager_nmcli", current, tmp_path,
|
||||
nft_phase="refreshed")
|
||||
content = current.read_text(encoding="utf-8")
|
||||
legacy = "\n".join(content.splitlines()[:4]) + (
|
||||
"\n# --recover-only\nprintf 'LEGACY_HELPER_EXECUTED\\n' >&2\nexit 99\n")
|
||||
installed = roots["/usr/local/libexec"] / "virt-cloud-wg-fabric"
|
||||
_write(installed, legacy, 0o700)
|
||||
_write(journal / "helper.desired", legacy, 0o700)
|
||||
_write(base / "wg-fabric0.owner", "virt-cloud-wg-fabric-v1\n")
|
||||
_write(journal / "owner.desired", "virt-cloud-wg-fabric-v1\n")
|
||||
uuid = re.search(r'^CONNECTION_UUID="([^"]+)"$', content, re.MULTILINE)[1]
|
||||
persistent = (roots["/etc/NetworkManager"] / "system-connections" /
|
||||
"virt-cloud-wg-fabric0.nmconnection")
|
||||
profile = _nm_profile_template(plan, plan.nodes[0], uuid, FIREWALL_MODE_FIREWALLD).replace(
|
||||
"private-key=\n", "private-key=" + base64.b64encode(bytes([7]) * 32).decode() + "\n")
|
||||
_write(persistent, profile)
|
||||
_write(journal / "nm_profile.desired", profile)
|
||||
shadow = roots["/run/NetworkManager"] / "system-connections" / persistent.name
|
||||
shadow_text = "\n".join(line for line in profile.splitlines() if not line.startswith("#"))
|
||||
_write(shadow, shadow_text.replace("[connection]", "[connection]\nzone=trusted") + (
|
||||
f"\n[proxy]\n[.nmmeta]\nshadowed-storage={persistent}\nshadowed-owned=true\n"))
|
||||
for directory in (tmp_path / "run", shadow.parent.parent, shadow.parent):
|
||||
directory.chmod(0o755)
|
||||
_write(tmp_path / "nm-loaded-uuid", uuid + "\n")
|
||||
_write(tmp_path / "nm-zone", "trusted\n")
|
||||
for name in ("link-present", "link-up"):
|
||||
_write(tmp_path / name, "")
|
||||
_write(tmp_path / "runtime-zone", "trusted\n")
|
||||
_write(roots["/proc/sys/net/ipv4"] / "conf" / "wg-fabric0" / "rp_filter", "2\n")
|
||||
return plan, current, installed, base, runtime, roots, journal, shadow
|
||||
|
||||
|
||||
def _driver(plan, current, installed, base, runtime, roots, tmp_path):
|
||||
boundary = "# A fixed-path sysctl file may be reused only when the authoritative owner\n"
|
||||
recovery = _TRANSACTION_SCRIPT.split(boundary, 1)[0]
|
||||
body = (_NMCLI_FILENAME_RESOLVER_SH + "\n" + _FABRIC_NFT_VALIDATION_SH + "\n"
|
||||
+ _FABRIC_SYSCTL_VALIDATION_SH + "\n" + _FIREWALL_MODE_GUARD_SH + "\n" + recovery)
|
||||
for source, destination in roots.items():
|
||||
body = body.replace(source, str(destination))
|
||||
body = body.replace("in /run ", "in " + shlex.quote(str(tmp_path / "run")) + " ")
|
||||
tools = tmp_path / "tools"
|
||||
values = {"BASE": base, "HELPER": installed, "_tmp_helper": current,
|
||||
"OWNER": base / "wg-fabric0.owner", "CONF": base / "wg-fabric0.conf",
|
||||
"NM_PROFILE": roots["/etc/NetworkManager"] / "system-connections" /
|
||||
"virt-cloud-wg-fabric0.nmconnection",
|
||||
"EMERGENCY_OWNER": runtime / "wg-fabric-emergency.owner",
|
||||
"EXPECTED_DIGEST": plan.digest, "DEPLOYMENT_MODE": "networkmanager_nmcli",
|
||||
"FIREWALL_MODE": "firewalld_nft", "IFACE": "wg-fabric0",
|
||||
"CONNECTION": "virt-cloud-wg-fabric0"}
|
||||
uuid = re.search(r'^CONNECTION_UUID="([^"]+)"$', current.read_text(), re.MULTILINE)[1]
|
||||
values["CONNECTION_UUID"] = uuid
|
||||
for variable, name in (("STAT", "stat"), ("NFT", "nft"), ("IP", "ip"),
|
||||
("WG", "wg"), ("SYSTEMCTL", "systemctl"),
|
||||
("NMCLI", "nmcli"), ("FIREWALL_CMD", "firewall-cmd")):
|
||||
values[variable] = tools / name
|
||||
values["CMP"] = "/usr/bin/cmp"
|
||||
prefix = "\n".join(key + "=" + shlex.quote(str(value)) for key, value in values.items())
|
||||
prefix += ("\nfind_tool() { printf '%s' " + shlex.quote(str(tools / "sha256sum")) + "; }\n"
|
||||
"vc_fabric_operation_checkpoint() { :; }\n"
|
||||
"PATH=" + shlex.quote(str(tools)) + ":/usr/bin:/bin; export PATH\n")
|
||||
return "set -eu\n" + prefix + body
|
||||
|
||||
|
||||
@pytest.mark.parametrize("failure", [None, "foreign_helper", "wrong_digest", "runtime_key"])
|
||||
def test_current_first_deploy_recovery_replays_only_exact_same_plan_post_image(tmp_path, failure):
|
||||
plan, current, installed, base, runtime, roots, journal, shadow = _failed_first_deploy(tmp_path)
|
||||
if failure == "foreign_helper":
|
||||
_write(installed, installed.read_text() + "# external replacement\n", 0o700)
|
||||
elif failure == "wrong_digest":
|
||||
changed = installed.read_text().replace(plan.digest, "b" * 64)
|
||||
_write(installed, changed, 0o700)
|
||||
_write(journal / "helper.desired", changed, 0o700)
|
||||
elif failure == "runtime_key":
|
||||
value = base64.b64encode(bytes([7]) * 32).decode()
|
||||
_write(shadow, shadow.read_text().replace(value, base64.b64encode(bytes([8]) * 32).decode()))
|
||||
result = subprocess.run(["/bin/sh", "-c", _driver(
|
||||
plan, current, installed, base, runtime, roots, tmp_path)],
|
||||
capture_output=True, text=True, check=False,
|
||||
env={"VC_ENTRY_ROOT": str(tmp_path), "VC_FABRIC_LOCK_HELD": "1"}, timeout=45)
|
||||
assert result.returncode == (0 if failure is None else 79), result.stderr
|
||||
assert "LEGACY_HELPER_EXECUTED" not in result.stdout + result.stderr
|
||||
assert (runtime / "wg-fabric-emergency.owner").is_file()
|
||||
for family in ("inet", "bridge"):
|
||||
assert (tmp_path / "tables" / f"{family}--virt_cloud_fabric_emergency").is_file()
|
||||
if failure is None:
|
||||
assert not journal.exists()
|
||||
assert not installed.exists()
|
||||
assert not shadow.exists()
|
||||
assert not (tmp_path / "link-present").exists()
|
||||
assert not (tmp_path / "tables" / "inet--virt_cloud_wg_fabric").exists()
|
||||
calls = [json.loads(line) for line in (tmp_path / "calls").read_text().splitlines()]
|
||||
assert not any(call[0] == "systemctl" and call[1] in ("start", "enable") for call in calls)
|
||||
else:
|
||||
assert journal.is_dir()
|
||||
assert installed.is_file()
|
||||
@ -1,272 +1,187 @@
|
||||
"""Recover a same-plan ready journal without redispatching its old helper."""
|
||||
"""Native journal recovery and retired firewalld fail-closed contracts."""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import json
|
||||
from pathlib import Path
|
||||
import re
|
||||
import shlex
|
||||
import stat
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
import pytest
|
||||
|
||||
from test_fabric_first_deploy_entry import _write
|
||||
from test_fabric_nm_runtime_shadow_recovery import _failed_first_deploy
|
||||
from test_fabric_first_deploy_entry import _fixture, _journal, _run, _write
|
||||
from virsh_panel.fabric import (
|
||||
FIREWALL_MODE_FIREWALLD,
|
||||
FIREWALL_MODE_NATIVE,
|
||||
_FABRIC_NFT_VALIDATION_SH,
|
||||
_FABRIC_SYSCTL_VALIDATION_SH,
|
||||
_FIREWALL_MODE_GUARD_SH,
|
||||
_NMCLI_FILENAME_RESOLVER_SH,
|
||||
_apply_script,
|
||||
)
|
||||
|
||||
|
||||
def _baseline_fixture(tmp_path):
|
||||
values = _failed_first_deploy(tmp_path)
|
||||
_, _, installed, _, _, _, journal, _ = values
|
||||
# The real Alma host now has a journaled old helper baseline, not the
|
||||
# helper.absent case covered by the first-deployment recovery path.
|
||||
(journal / "helper.absent").unlink()
|
||||
_write(journal / "helper.present", "")
|
||||
_write(journal / "helper", installed.read_text(encoding="utf-8"), 0o700)
|
||||
return values
|
||||
|
||||
|
||||
def _rendered_driver(values, root, firewall_mode=FIREWALL_MODE_FIREWALLD):
|
||||
plan, current, installed, base, runtime, roots, _, _ = values
|
||||
keys = {host.host_id: base64.b64encode(bytes([index]) * 32).decode()
|
||||
for index, host in enumerate(plan.nodes, start=1)}
|
||||
rendered = _apply_script(
|
||||
plan, plan.nodes[0], keys, deployment_mode="networkmanager_nmcli",
|
||||
firewall_mode=firewall_mode,
|
||||
)
|
||||
start = rendered.index("COMMITTED=no\nROLLBACK_FAILED=no")
|
||||
end = rendered.index("vc_fabric_operation_checkpoint preflight\n", start)
|
||||
# Execute the actual rendered outer recovery functions and dispatch, then
|
||||
# the complete current helper. Only host resources and CLI paths redirect
|
||||
# to fixture doubles; no ownership/recovery shell function is replaced.
|
||||
recovery = rendered[start:end]
|
||||
body = (_NMCLI_FILENAME_RESOLVER_SH + "\n" + _FABRIC_NFT_VALIDATION_SH + "\n"
|
||||
+ _FABRIC_SYSCTL_VALIDATION_SH + "\n" + _FIREWALL_MODE_GUARD_SH + "\n"
|
||||
+ recovery)
|
||||
for source, destination in roots.items():
|
||||
body = body.replace(source, str(destination))
|
||||
body = body.replace("in /run ", "in " + shlex.quote(str(root / "run")) + " ")
|
||||
tools = root / "tools"
|
||||
identity = re.search(r'^CONNECTION_UUID="([^"]+)"$', current.read_text(), re.MULTILINE)[1]
|
||||
variables = {
|
||||
"BASE": base, "HELPER": installed, "_tmp_helper": current,
|
||||
"OWNER": base / "wg-fabric0.owner", "CONF": base / "wg-fabric0.conf",
|
||||
"NM_PROFILE": roots["/etc/NetworkManager"] / "system-connections" /
|
||||
"virt-cloud-wg-fabric0.nmconnection",
|
||||
"EMERGENCY_OWNER": runtime / "wg-fabric-emergency.owner",
|
||||
"EXPECTED_DIGEST": plan.digest, "DEPLOYMENT_MODE": "networkmanager_nmcli",
|
||||
"FIREWALL_MODE": firewall_mode, "IFACE": "wg-fabric0",
|
||||
"CONNECTION": "virt-cloud-wg-fabric0", "CONNECTION_UUID": identity,
|
||||
"CMP": "/usr/bin/cmp",
|
||||
def _journal_image(journal: Path) -> dict[str, tuple[bytes, int]]:
|
||||
return {
|
||||
str(path.relative_to(journal)): (
|
||||
path.read_bytes(), stat.S_IMODE(path.stat().st_mode),
|
||||
)
|
||||
for path in journal.rglob("*")
|
||||
if path.is_file() and not path.is_symlink()
|
||||
}
|
||||
for variable, name in (("STAT", "stat"), ("NFT", "nft"), ("IP", "ip"),
|
||||
("WG", "wg"), ("SYSTEMCTL", "systemctl"),
|
||||
("NMCLI", "nmcli"), ("FIREWALL_CMD", "firewall-cmd")):
|
||||
variables[variable] = tools / name
|
||||
prefix = "\n".join(key + "=" + shlex.quote(str(value)) for key, value in variables.items())
|
||||
prefix += ("\nfind_tool() { printf '%s' " + shlex.quote(str(tools / "sha256sum")) + "; }\n"
|
||||
"vc_fabric_operation_checkpoint() { :; }\n"
|
||||
"PATH=" + shlex.quote(str(tools)) + ":/usr/bin:/bin; export PATH\n")
|
||||
return "set -eu\n" + prefix + body
|
||||
|
||||
|
||||
def _run(values, root, firewall_mode=FIREWALL_MODE_FIREWALLD):
|
||||
return subprocess.run(
|
||||
["/bin/sh", "-c", _rendered_driver(values, root, firewall_mode)], check=False,
|
||||
capture_output=True, text=True,
|
||||
env={"VC_ENTRY_ROOT": str(root), "VC_FABRIC_LOCK_HELD": "1"}, timeout=45,
|
||||
def _assert_no_recovery_mutation(root: Path) -> None:
|
||||
calls_path = root / "calls"
|
||||
calls = (
|
||||
[json.loads(line) for line in calls_path.read_text().splitlines()]
|
||||
if calls_path.is_file() else []
|
||||
)
|
||||
assert not any(call[0] == "nft" and "-f" in call for call in calls)
|
||||
assert not any(
|
||||
call[:3] == ["ip", "link", "set"] or
|
||||
call[:3] == ["ip", "link", "del"]
|
||||
for call in calls
|
||||
)
|
||||
assert not any(
|
||||
call[0] == "nmcli" and call[1:3] in (
|
||||
["connection", "delete"], ["connection", "modify"],
|
||||
)
|
||||
for call in calls
|
||||
)
|
||||
assert not any(
|
||||
call[0] == "systemctl" and call[1] in ("start", "enable")
|
||||
for call in calls
|
||||
)
|
||||
|
||||
|
||||
def _native_baseline_fixture(tmp_path, *, empty_header=False):
|
||||
values = _baseline_fixture(tmp_path)
|
||||
_, current, _, _, _, roots, journal, shadow = values
|
||||
# Rendered helper implementation is identical for both owners; the
|
||||
# explicit literal backend selects the native branch. No shell function
|
||||
# or recovery conditional is replaced in this fixture.
|
||||
content = current.read_text().replace(
|
||||
'FIREWALL_MODE="firewalld_nft"', 'FIREWALL_MODE="native_nftables"', 1,
|
||||
@pytest.mark.parametrize("state", ("ready", "committed"))
|
||||
def test_legacy_firewalld_journal_is_rejected_and_preserved(tmp_path, state):
|
||||
plan, helper, base, _, _ = _fixture(tmp_path, "networkmanager_nmcli")
|
||||
journal = _journal(
|
||||
plan, base, "networkmanager_nmcli", helper, tmp_path,
|
||||
nft_phase="refreshed",
|
||||
)
|
||||
native_main = tmp_path / "nftables.conf"
|
||||
roots["/etc/nftables.conf"] = native_main
|
||||
content = content.replace("/etc/nftables.conf", str(native_main))
|
||||
if empty_header:
|
||||
content = content.replace('UNDERLAY_ENDPOINT="203.0.113.1"', 'UNDERLAY_ENDPOINT=""')
|
||||
content = content.replace('UNDERLAY_PORT="51820"', 'UNDERLAY_PORT=""')
|
||||
_write(current, content, 0o700)
|
||||
metadata = dict(line.split("=", 1) for line in (journal / "meta").read_text().splitlines())
|
||||
metadata.update({
|
||||
"firewall_mode": FIREWALL_MODE_NATIVE, "nft_main": str(native_main),
|
||||
"firewalld_runtime_zone_before": "na", "firewalld_permanent_zone_before": "na",
|
||||
"underlay_endpoint": "", "underlay_port": "", "underlay_zone": "",
|
||||
"underlay_rule_owner": "none", "underlay_rule_runtime_before": "na",
|
||||
"underlay_rule_permanent_before": "na",
|
||||
})
|
||||
_write(journal / "meta", "".join(f"{key}={value}\n" for key, value in metadata.items()))
|
||||
distribution_rules = '# distribution-owned main file\ninclude "/etc/nftables.d/*.nft"\n'
|
||||
_write(native_main, distribution_rules, 0o644)
|
||||
(journal / "nft_main.absent").unlink()
|
||||
_write(journal / "nft_main.present", "")
|
||||
_write(journal / "nft_main", distribution_rules, 0o644)
|
||||
_write(shadow, shadow.read_text().replace("zone=trusted", "zone="))
|
||||
_write(tmp_path / "nm-zone", "")
|
||||
(tmp_path / "runtime-zone").unlink()
|
||||
# Native owner fixture: nftables enabled/running, firewalld masked and
|
||||
# inactive. Only external systemctl evidence differs from firewalld.
|
||||
tool = tmp_path / "tools" / "external-tool"
|
||||
external = tool.read_text().replace(
|
||||
'print("active" if args[1] == "firewalld" else "inactive")',
|
||||
'print("inactive" if args[1] == "firewalld" else "active")',
|
||||
).replace(
|
||||
'print("enabled" if args[1] == "firewalld" else "disabled")',
|
||||
'print("masked" if args[1] == "firewalld" else "enabled")',
|
||||
_write(journal / "state", state + "\n")
|
||||
_write(
|
||||
journal / "meta",
|
||||
(journal / "meta").read_text(encoding="utf-8").replace(
|
||||
"firewall_mode=native_nftables",
|
||||
"firewall_mode=firewalld_nft",
|
||||
),
|
||||
)
|
||||
_write(tool, external, 0o700)
|
||||
return values
|
||||
before = _journal_image(journal)
|
||||
|
||||
result = _run(helper, tmp_path, "--recover-current")
|
||||
|
||||
@pytest.mark.parametrize("empty_header", [False, True])
|
||||
@pytest.mark.parametrize("failure", [None, "endpoint", "port"])
|
||||
def test_native_same_plan_handoff_requires_empty_underlay_metadata_not_unused_header(
|
||||
tmp_path, empty_header, failure):
|
||||
values = _native_baseline_fixture(tmp_path, empty_header=empty_header)
|
||||
_, _, installed, _, runtime, _, journal, shadow = values
|
||||
historical = installed.read_bytes()
|
||||
if failure:
|
||||
_write(journal / "meta", (journal / "meta").read_text().replace(
|
||||
f"underlay_{failure}=\n",
|
||||
f"underlay_{failure}=" + ("203.0.113.1" if failure == "endpoint" else "51820") + "\n",
|
||||
1,
|
||||
))
|
||||
live = tmp_path / "tables" / "inet--virt_cloud_wg_fabric"
|
||||
original = live.read_bytes()
|
||||
result = _run(values, tmp_path, FIREWALL_MODE_NATIVE)
|
||||
assert result.returncode == (0 if failure is None else 79), result.stderr
|
||||
assert "LEGACY_HELPER_EXECUTED" not in result.stdout + result.stderr
|
||||
assert installed.read_bytes() == historical
|
||||
assert (runtime / "wg-fabric-emergency.owner").is_file()
|
||||
if failure is None:
|
||||
assert not journal.exists()
|
||||
assert not live.exists()
|
||||
assert not shadow.exists()
|
||||
assert not (tmp_path / "link-present").exists()
|
||||
else:
|
||||
assert journal.is_dir()
|
||||
assert live.read_bytes() == original
|
||||
assert shadow.is_file()
|
||||
assert result.returncode == 79, result.stderr
|
||||
assert journal.is_dir()
|
||||
assert _journal_image(journal) == before
|
||||
_assert_no_recovery_mutation(tmp_path)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("state", ("preparing", "committed"))
|
||||
def test_malformed_native_journal_is_rejected_and_preserved(tmp_path, state):
|
||||
plan, helper, base, _, _ = _fixture(tmp_path, "ifupdown")
|
||||
journal = _journal(plan, base, "ifupdown", helper, tmp_path)
|
||||
_write(journal / "state", state + "\n")
|
||||
_write(
|
||||
journal / "meta",
|
||||
(journal / "meta").read_text(encoding="utf-8")
|
||||
+ "firewall_mode=native_nftables\n",
|
||||
)
|
||||
before = _journal_image(journal)
|
||||
|
||||
result = _run(helper, tmp_path, "--recover-current")
|
||||
|
||||
def test_rendered_outer_replays_same_plan_old_baseline_with_current_helper(tmp_path):
|
||||
values = _baseline_fixture(tmp_path)
|
||||
_, current, installed, base, runtime, _, journal, shadow = values
|
||||
historical = installed.read_bytes()
|
||||
assert current.read_bytes() != historical
|
||||
assert "vc_fabric_nm_profile_semantics_match" not in historical.decode()
|
||||
result = _run(values, tmp_path)
|
||||
assert result.returncode == 0, result.stderr
|
||||
assert "LEGACY_HELPER_EXECUTED" not in result.stdout + result.stderr
|
||||
assert not journal.exists()
|
||||
# Complete recovery preserves its pre-existing, precisely journaled old
|
||||
# helper but must not execute it again under --recover-current.
|
||||
assert installed.read_bytes() == historical
|
||||
assert not shadow.exists()
|
||||
assert not (tmp_path / "link-present").exists()
|
||||
assert not (base / "wg-fabric0.owner").exists()
|
||||
assert not (tmp_path / "tables" / "inet--virt_cloud_wg_fabric").exists()
|
||||
assert (runtime / "wg-fabric-emergency.owner").is_file()
|
||||
for family in ("inet", "bridge"):
|
||||
assert (tmp_path / "tables" / f"{family}--virt_cloud_fabric_emergency").is_file()
|
||||
calls = [json.loads(line) for line in (tmp_path / "calls").read_text().splitlines()]
|
||||
assert not any(call[0] == "systemctl" and call[1] in ("start", "enable") for call in calls)
|
||||
assert not any(call[:5] == ["ip", "link", "set", "dev", "wg-fabric0"]
|
||||
and call[-1] == "up" for call in calls)
|
||||
assert result.returncode == 79, result.stderr
|
||||
assert journal.is_dir()
|
||||
assert _journal_image(journal) == before
|
||||
_assert_no_recovery_mutation(tmp_path)
|
||||
|
||||
|
||||
def test_normal_boot_recovery_still_reenters_verified_historical_helper(tmp_path):
|
||||
values = _baseline_fixture(tmp_path)
|
||||
_, current, installed, _, runtime, _, journal, _ = values
|
||||
historical = installed.read_bytes()
|
||||
result = subprocess.run(
|
||||
["/bin/sh", str(current)], check=False, capture_output=True, text=True,
|
||||
env={"VC_ENTRY_ROOT": str(tmp_path), "VC_FABRIC_LOCK_HELD": "1"}, timeout=45,
|
||||
@pytest.mark.parametrize("state", ("ready", "committed"))
|
||||
def test_needs_repair_reports_every_native_transaction_journal(tmp_path, state):
|
||||
plan, helper, base, _, _ = _fixture(tmp_path, "ifupdown")
|
||||
journal = _journal(
|
||||
plan, base, "ifupdown", helper, tmp_path, nft_phase="refreshed",
|
||||
)
|
||||
# This complete non-recovery-only entry still uses the restored old
|
||||
# implementation. Its deliberate exit99 proves the normal exec contract
|
||||
# was preserved instead of silently treating a regular boot as finished.
|
||||
assert result.returncode == 99, result.stderr
|
||||
assert "LEGACY_HELPER_EXECUTED" in result.stderr
|
||||
assert not journal.exists()
|
||||
assert installed.read_bytes() == historical
|
||||
assert (runtime / "wg-fabric-emergency.owner").is_file()
|
||||
_write(journal / "state", state + "\n")
|
||||
before = _journal_image(journal)
|
||||
|
||||
result = _run(helper, tmp_path, "--needs-repair")
|
||||
|
||||
@pytest.mark.parametrize("failure", [
|
||||
"foreign_helper", "baseline_and_desired_drift", "temporary_mode", "temporary_digest",
|
||||
"endpoint", "port", "runtime_key", "live_nft_verdict",
|
||||
])
|
||||
def test_rendered_same_plan_handoff_rejects_unproved_ownership_or_plan(tmp_path, failure):
|
||||
values = _baseline_fixture(tmp_path)
|
||||
plan, current, installed, _, runtime, _, journal, shadow = values
|
||||
if failure == "foreign_helper":
|
||||
_write(installed, installed.read_text() + "# external replacement\n", 0o700)
|
||||
elif failure == "baseline_and_desired_drift":
|
||||
for name in ("helper", "helper.desired"):
|
||||
_write(journal / name, (journal / name).read_text() + "# changed snapshot\n", 0o700)
|
||||
elif failure == "temporary_mode":
|
||||
current.chmod(0o600)
|
||||
elif failure == "temporary_digest":
|
||||
_write(current, current.read_text().replace(plan.digest, "a" * 64), 0o700)
|
||||
elif failure in ("endpoint", "port"):
|
||||
old, new = (("underlay_endpoint=203.0.113.1", "underlay_endpoint=203.0.113.9")
|
||||
if failure == "endpoint" else ("underlay_port=51820", "underlay_port=51821"))
|
||||
_write(journal / "meta", (journal / "meta").read_text().replace(old, new))
|
||||
elif failure == "runtime_key":
|
||||
old = base64.b64encode(bytes([7]) * 32).decode()
|
||||
_write(shadow, shadow.read_text().replace(old, base64.b64encode(bytes([8]) * 32).decode()))
|
||||
else:
|
||||
live = tmp_path / "tables" / "inet--virt_cloud_wg_fabric"
|
||||
_write(live, live.read_text().replace("counter drop comment", "counter accept comment", 1))
|
||||
live = tmp_path / "tables" / "inet--virt_cloud_wg_fabric"
|
||||
original = live.read_bytes()
|
||||
result = _run(values, tmp_path)
|
||||
assert result.returncode == 79, result.stderr
|
||||
assert "LEGACY_HELPER_EXECUTED" not in result.stdout + result.stderr
|
||||
assert result.returncode == 0, result.stderr
|
||||
assert journal.is_dir()
|
||||
assert installed.is_file()
|
||||
assert live.read_bytes() == original
|
||||
assert (runtime / "wg-fabric-emergency.owner").is_file()
|
||||
calls = [json.loads(line) for line in (tmp_path / "calls").read_text().splitlines()]
|
||||
assert not any(call[0] == "nft" and call[1] == "-f" for call in calls)
|
||||
assert _journal_image(journal) == before
|
||||
_assert_no_recovery_mutation(tmp_path)
|
||||
|
||||
|
||||
def _stat_tool(tmp_path: Path) -> Path:
|
||||
tool = tmp_path / "stat"
|
||||
tool.write_text(
|
||||
f"#!{sys.executable}\n"
|
||||
"import os, stat, sys\n"
|
||||
"value = os.lstat(sys.argv[3])\n"
|
||||
"mode = format(stat.S_IMODE(value.st_mode), 'o')\n"
|
||||
"fields = {\n"
|
||||
" '%u:%g:%a': '0:0:' + mode,\n"
|
||||
" '%u:%a': '0:' + mode,\n"
|
||||
" '%s': str(value.st_size),\n"
|
||||
"}\n"
|
||||
"print(fields[sys.argv[2]])\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
tool.chmod(0o700)
|
||||
return tool
|
||||
|
||||
|
||||
@pytest.mark.parametrize("field,value", [
|
||||
("plan_digest", "f" * 64),
|
||||
("connection_uuid", "ffffffff-ffff-ffff-ffff-ffffffffffff"),
|
||||
("deployment_mode", "ifupdown"),
|
||||
("firewall_mode", "native_nftables"),
|
||||
])
|
||||
def test_different_plan_keeps_historical_recovery_contract_without_current_handoff(
|
||||
tmp_path, field, value):
|
||||
values = _baseline_fixture(tmp_path)
|
||||
_, _, _, _, runtime, _, journal, _ = values
|
||||
text = (journal / "meta").read_text()
|
||||
_write(journal / "meta", re.sub(rf"^{field}=.*$", f"{field}={value}", text,
|
||||
flags=re.MULTILINE))
|
||||
before = (tmp_path / "tables" / "inet--virt_cloud_wg_fabric").read_bytes()
|
||||
result = _run(values, tmp_path)
|
||||
assert result.returncode == 79, result.stderr
|
||||
# This controlled historical helper rejects at exit99. Existing cross-
|
||||
# revision dispatch stays intact, and the current template never assumes
|
||||
# authority over the other journal identity.
|
||||
assert "LEGACY_HELPER_EXECUTED" in result.stderr
|
||||
assert "helper_state=failed" not in result.stderr
|
||||
assert journal.is_dir()
|
||||
assert (tmp_path / "tables" / "inet--virt_cloud_wg_fabric").read_bytes() == before
|
||||
assert (runtime / "wg-fabric-emergency.owner").is_file()
|
||||
def test_rendered_apply_initializes_awk_before_running_native_guard(tmp_path):
|
||||
plan, _, _, _, _ = _fixture(tmp_path, "networkmanager_nmcli")
|
||||
keys = {
|
||||
node.host_id: base64.b64encode(bytes([index]) * 32).decode()
|
||||
for index, node in enumerate(plan.nodes, start=1)
|
||||
}
|
||||
rendered = _apply_script(
|
||||
plan, plan.nodes[0], keys,
|
||||
deployment_mode="networkmanager_nmcli",
|
||||
firewall_mode=FIREWALL_MODE_NATIVE,
|
||||
)
|
||||
assignment = re.search(
|
||||
r"^AWK=\$\(find_tool [^\n]+\) \|\| exit 70$",
|
||||
rendered,
|
||||
re.MULTILINE,
|
||||
)
|
||||
assert assignment is not None
|
||||
guard_call = rendered.index("vc_legacy_firewalld_state_absent || exit 79")
|
||||
assert assignment.start() < guard_call
|
||||
|
||||
etc = tmp_path / "etc" / "virt-cloud"
|
||||
state_dir = etc / "vpc-dataplane"
|
||||
runtime = tmp_path / "run" / "virt-cloud"
|
||||
state_dir.mkdir(parents=True)
|
||||
runtime.mkdir(parents=True, exist_ok=True)
|
||||
config = etc / "wg-fabric0.conf"
|
||||
config.write_text("firewall|native_nftables\n", encoding="utf-8")
|
||||
config.chmod(0o600)
|
||||
guard = _FIREWALL_MODE_GUARD_SH.replace(
|
||||
"/etc/virt-cloud", str(etc),
|
||||
).replace(
|
||||
"/run/virt-cloud", str(runtime),
|
||||
)
|
||||
result = subprocess.run(
|
||||
["/bin/sh", "-eu", "-c", "\n".join((
|
||||
"find_tool() { for p in \"$@\"; do [ -x \"$p\" ] && "
|
||||
"{ printf '%s' \"$p\"; return 0; }; done; return 1; }",
|
||||
assignment.group(0),
|
||||
f"STAT={_stat_tool(tmp_path)}",
|
||||
"vc_test_nft() {",
|
||||
" [ \"$*\" = \"list tables\" ] || return 2",
|
||||
" printf '%s\\n' 'table inet filter'",
|
||||
"}",
|
||||
"NFT=vc_test_nft",
|
||||
guard,
|
||||
"vc_legacy_firewalld_state_absent",
|
||||
))],
|
||||
capture_output=True, text=True, check=False,
|
||||
)
|
||||
|
||||
assert result.returncode == 0, result.stderr
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,2 +1,2 @@
|
||||
{* Shared Venix CSS/JS cache key. Increment whenever a shared browser asset changes. *}
|
||||
{assign var=venix_asset_version value='2026100907' scope='global'}
|
||||
{assign var=venix_asset_version value='2026101001' scope='global'}
|
||||
|
||||
Loading…
Reference in New Issue