ODS V3 Pre-Release: Public testing and refinement ahead of the official V3 launch. Turn your PC, Mac, or Linux box into a private AI server.
Python ai-agentsamdcomfyuidockerllama-cppllmlocal-ain8nnvidiaopen-webuiragself-hostedspeech-to-textstrix-halotext-to-speechworkflow-automation
fix(installer): support restrictive DGX device and manifest permissions (#8228)
Mike Bradley25bd8a64d0e6
diff --git a/.github/workflows/test-linux.yml b/.github/workflows/test-linux.ymlindex c32eaad6b..2994e8e13 100644--- a/.github/workflows/test-linux.yml+++ b/.github/workflows/test-linux.yml@@ -442,6 +442,11 @@ jobs:- name: Installer Created Container Ownership Testsrun: bash tests/test-phase11-created-container-ownership.sh+ - name: Installer Public Manifests and Containerd Device Policy+ run: |+ python3 tests/test_containerd_console_policy.py+ sudo -n env ODS_MIXED_UID_TEST=1 python3 tests/test_public_extension_manifest_permissions.py+- name: Dotenv Serializer Testsrun: bash tests/test-dotenv-serializer.shdiff --git a/ods/installers/lib/containerd-console.sh b/ods/installers/lib/containerd-console.shnew file mode 100644index 000000000..847959bad--- /dev/null+++ b/ods/installers/lib/containerd-console.sh@@ -0,0 +1,38 @@+#!/bin/bash+# Prepare the known NVIDIA-only containerd device policy before image unpack.+# Runtime discovery remains in phase 05; the Python helper owns the narrow,+# revalidated host change and never restarts the daemon.+ods_prepare_containerd_console() {+ [[ "${GPU_BACKEND:-}" == nvidia && "${GPU_COUNT:-0}" -gt 0 ]] || return 0+ [[ "$(uname -s)" == Linux ]] || return 0+ if [[ "${DRY_RUN:-false}" == true ]]; then+ log "[DRY RUN] Would check local containerd image-unpack permissions"+ return 0+ fi+ _runtime_is_podman && return 0+ _docker_is_desktop_engine && return 0++ local endpoint security rc+ if [[ -n "${DOCKER_HOST:-}" && -z "${DOCKER_CONTEXT:-}" ]]; then+ endpoint="$DOCKER_HOST"+ else+ endpoint="$(docker_run context inspect --format '{{.Endpoints.docker.Host}}')" || return 1+ fi+ # Never repair this host for a remote daemon or a rootless user socket.+ case "$endpoint" in+ unix:///var/run/docker.sock|unix:///run/docker.sock) ;;+ *) return 0 ;;+ esac+ security="$(docker_run info --format '{{json .SecurityOptions}}')" || return 1+ [[ "$security" != *rootless* ]] || return 0++ if python3 "$SCRIPT_DIR/scripts/prepare-containerd-console.py" --check; then+ return 0+ else+ rc=$?+ fi+ [[ "$rc" == 10 ]] || return "$rc"+ ai "Allowing containerd to create the standard console node while unpacking images..."+ ods_sudo python3 "$SCRIPT_DIR/scripts/prepare-containerd-console.py" --apply || return 1+ ai_ok "Containerd image-unpack permission verified; existing device rules retained"+}diff --git a/ods/installers/phases/05-docker.sh b/ods/installers/phases/05-docker.shindex 54bb14716..622f60e17 100755--- a/ods/installers/phases/05-docker.sh+++ b/ods/installers/phases/05-docker.sh@@ -19,6 +19,8 @@# shellcheck source=installers/lib/podman-registries.shsource "$SCRIPT_DIR/installers/lib/podman-registries.sh"+# shellcheck source=installers/lib/containerd-console.sh+source "$SCRIPT_DIR/installers/lib/containerd-console.sh"ods_progress 30 "docker" "Setting up Docker"show_phase 3 6 "Docker Setup" "~2 minutes"@@ -672,3 +674,8 @@ fiif [[ "${ENABLE_PIXEL_RUNTIME:-false}" == true && "$DRY_RUN" != true ]]; thenods_pixel_check_owner_docker || return 1fi++ods_prepare_containerd_console || {+ error "Could not verify containerd image-unpack permissions; review the device-policy diagnostic above."+ return 1+}diff --git a/ods/installers/phases/06-directories.sh b/ods/installers/phases/06-directories.shindex 0ec6691ac..28627ae72 100755--- a/ods/installers/phases/06-directories.sh+++ b/ods/installers/phases/06-directories.sh@@ -753,6 +753,23 @@ Fix with: sudo chown -R \$(id -u):\$(id -g) $INSTALL_DIR/config $INSTALL_DIR/datchmod go-w "$INSTALL_DIR" || error "Could not secure installed root"unset _installed_code_root+ # Dashboard runs as a different UID and reads these public bind-mounted+ # manifests. Keep .env, service-private files and runtime data private.+ _phase06_step "prepare-extension-manifests"+ _phase06_manifest_args=()+ if [[ -n "${ODS_PIXEL_SOURCE_TRANSACTION:-}" ]]; then+ # Pixel installed candidate file modes from its staged inventory.+ # Preserve those and retained custom files while preparing traversal.+ _phase06_manifest_args+=(--preserve-file-modes)+ fi+ if ! python3 "$INSTALL_DIR/scripts/prepare-extension-manifests.py" "$INSTALL_DIR" \+ "${_phase06_manifest_args[@]}" \+ >> "$LOG_FILE" 2>&1; then+ error "Could not prepare public service manifests for the Dashboard API. See $LOG_FILE for details."+ return 1+ fi+ unset _phase06_manifest_args+# Source staging under umask 077 makes the two public policy bind mounts# unreadable to APE and remote-provider-egress, which run as non-root.# Normalize them on fresh and retained installs before Compose starts.diff --git a/ods/scripts/prepare-containerd-console.py b/ods/scripts/prepare-containerd-console.pynew file mode 100644index 000000000..b3cb9df65--- /dev/null+++ b/ods/scripts/prepare-containerd-console.py@@ -0,0 +1,269 @@+#!/usr/bin/env python3+"""Narrow ODS repair: add DeviceAllow=/dev/console m to containerd.++Scope: Linux, rootful Docker, NVIDIA-only DeviceAllow policy on containerd.+Only repairs the exact known auto+nonempty+NVIDIA-only+rwm case by adding+an owned drop-in with `DeviceAllow=/dev/console m` (create-only, never rwm).+Never restarts containerd, never edits vendor drop-ins, never touches+DevicePolicy or existing DeviceAllow entries.++Usage:+ prepare-containerd-console.py [--check | --apply]++Exit codes:+ 0 no repair needed (or apply succeeded)+ 10 repair needed (--check only)+ 1 error / refused / apply failed+"""++import argparse+import os+import re+import stat+import subprocess+import sys++UNIT = "containerd.service"+DROPIN_DIR = "/etc/systemd/system/containerd.service.d"+DROPIN_PATH = os.path.join(DROPIN_DIR, "90-ods-image-unpack.conf")+DROPIN_CONTENT = (+ "# Managed by ODS: allow image unpack to create /dev/console (mknodat).\n"+ "# Create-only; never grants read/write on /dev/console.\n"+ "[Service]\n"+ "DeviceAllow=/dev/console m\n"+)++# Known NVIDIA-only DeviceAllow patterns (device path, perms).+_NVIDIA_DEV_RE = re.compile(r"^/dev/nvidia(?:[A-Za-z0-9_/-]*)$")+_NVIDIA_CAPS_RE = re.compile(r"^char-nvidia-caps$")+++def _run_systemctl_show():+ """Return dict of systemctl show properties for containerd.service."""+ try:+ proc = subprocess.run(+ ["systemctl", "show", UNIT,+ "--property=ActiveState",+ "--property=DevicePolicy",+ "--property=DeviceAllow"],+ capture_output=True, text=True, check=True, timeout=15,+ )+ except FileNotFoundError:+ return None+ props: dict[str, list[str]] = {}+ for line in proc.stdout.splitlines():+ if "=" not in line:+ continue+ key, _, val = line.partition("=")+ props.setdefault(key, []).append(val)+ return props+++def _parse_device_allow(entries):+ """Parse repeated DeviceAllow= values into [(device, perms), ...].++ Each entry is 'device perms' with perms at the last space.+ """+ out = []+ for raw in entries:+ raw = raw.strip()+ if not raw:+ continue+ idx = raw.rfind(" ")+ if idx <= 0:+ out.append((raw, ""))+ else:+ out.append((raw[:idx], raw[idx + 1:]))+ return out+++def _is_nvidia_only(entries):+ """True iff every entry is a known NVIDIA pattern with rwm perms."""+ if not entries:+ return False+ for dev, perms in entries:+ if perms != "rwm":+ return False+ if _NVIDIA_DEV_RE.match(dev):+ continue+ if _NVIDIA_CAPS_RE.match(dev):+ continue+ return False+ return True+++def _has_console_m(entries):+ for dev, perms in entries:+ if dev == "/dev/console" and "m" in perms:+ return True+ return False+++def classify(props):+ """Return (needs_repair: bool, reason: str)."""+ if props is None:+ return False, "systemctl unavailable or unit not queryable"+ active = (props.get("ActiveState") or [""])[0]+ if active != "active":+ return False, "containerd.service not active (%s)" % (active or "unknown")+ policy = (props.get("DevicePolicy") or [""])[0]+ if policy != "auto":+ return False, "DevicePolicy=%s (not auto); manual review if image unpack fails" % (policy or "unknown")+ entries = _parse_device_allow(props.get("DeviceAllow") or [])+ if not entries:+ return False, "DeviceAllow empty (unrestricted); no repair"+ if _has_console_m(entries):+ return False, "already has DeviceAllow=/dev/console m"+ if not _is_nvidia_only(entries):+ return False, "custom/closed DeviceAllow policy; manual review if image unpack fails"+ return True, "NVIDIA-only DeviceAllow with rwm; /dev/console m missing"+++def _is_root():+ return os.geteuid() == 0+++def _read_existing():+ """Return (state, content) where state in {'absent','owned','foreign','symlink'}."""+ try:+ st = os.lstat(DROPIN_PATH)+ except FileNotFoundError:+ return "absent", None+ if stat.S_ISLNK(st.st_mode):+ return "symlink", None+ if (not stat.S_ISREG(st.st_mode) or st.st_nlink != 1+ or st.st_uid != os.geteuid() or stat.S_IMODE(st.st_mode) & 0o022):+ return "foreign", None+ with open(DROPIN_PATH, "r", encoding="utf-8") as f:+ content = f.read()+ if content == DROPIN_CONTENT:+ return "owned", content+ return "foreign", content+++def _ensure_dir():+ if os.path.islink(DROPIN_DIR):+ raise RuntimeError("refusing: %s is a symlink" % DROPIN_DIR)+ if not os.path.isdir(DROPIN_DIR):+ os.makedirs(DROPIN_DIR, mode=0o755, exist_ok=True)+ os.chmod(DROPIN_DIR, 0o755)+ if os.path.islink(DROPIN_DIR):+ raise RuntimeError("refusing: %s became a symlink" % DROPIN_DIR)+ st = os.stat(DROPIN_DIR)+ if st.st_uid != os.geteuid() or stat.S_IMODE(st.st_mode) & 0o022:+ raise RuntimeError("refusing: containerd drop-in directory is not owner-controlled")+++def _write_owned():+ """Create the owned drop-in atomically with O_EXCL/O_NOFOLLOW."""+ _ensure_dir()+ flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL+ if hasattr(os, "O_NOFOLLOW"):+ flags |= os.O_NOFOLLOW+ fd = os.open(DROPIN_PATH, flags, 0o644)+ with os.fdopen(fd, "w", encoding="utf-8") as stream:+ os.fchmod(fd, 0o644)+ stream.write(DROPIN_CONTENT)+ stream.flush()+ os.fsync(fd)+++def _daemon_reload():+ proc = subprocess.run(+ ["systemctl", "daemon-reload"],+ capture_output=True, text=True, check=False, timeout=15,+ )+ if proc.returncode != 0:+ raise RuntimeError("systemctl daemon-reload failed: %s" % (proc.stderr.strip() or proc.returncode))+++def _verify_after_apply(old_entries):+ props = _run_systemctl_show()+ if props is None:+ raise RuntimeError("cannot verify: systemctl show failed after apply")+ active = (props.get("ActiveState") or [""])[0]+ if active != "active":+ raise RuntimeError("containerd.service not active after apply (%s)" % (active or "unknown"))+ if props.get("DevicePolicy") != ["auto"]:+ raise RuntimeError("containerd DevicePolicy changed during repair; review host policy")+ new_entries = _parse_device_allow(props.get("DeviceAllow") or [])+ if not _has_console_m(new_entries):+ raise RuntimeError("effective DeviceAllow missing /dev/console m after apply")+ new_set = set(new_entries)+ for e in old_entries:+ if e not in new_set:+ raise RuntimeError("effective DeviceAllow lost prior entry %r" % (e,))+++def do_check():+ props = _run_systemctl_show()+ needs, reason = classify(props)+ print("containerd console policy: %s" % reason)+ return 10 if needs else 0+++def do_apply():+ props = _run_systemctl_show()+ needs, reason = classify(props)+ if not needs:+ print("containerd console policy: %s" % reason)+ return 0+ if not _is_root():+ print("error: --apply requires root", file=sys.stderr)+ return 1++ old_entries = _parse_device_allow(props.get("DeviceAllow") or [])+ try:+ _ensure_dir()+ except (OSError, RuntimeError) as exc:+ print("error: unsafe drop-in directory: %s" % exc, file=sys.stderr)+ return 1+ state, _ = _read_existing()+ if state == "symlink":+ print("error: refusing: %s is a symlink" % DROPIN_PATH, file=sys.stderr)+ return 1+ if state == "foreign":+ print("error: refusing: %s exists with foreign content" % DROPIN_PATH, file=sys.stderr)+ return 1++ if state == "absent":+ try:+ _write_owned()+ except FileExistsError:+ # Race: someone created it; re-check ownership.+ state2, _ = _read_existing()+ if state2 != "owned":+ print("error: refusing: %s appeared with foreign content" % DROPIN_PATH, file=sys.stderr)+ return 1+ except (OSError, RuntimeError) as e:+ print("error: write failed: %s" % e, file=sys.stderr)+ return 1+ # state == 'owned': retry daemon-reload (safe idempotent path).++ try:+ _daemon_reload()+ _verify_after_apply(old_entries)+ except RuntimeError as e:+ print("error: %s" % e, file=sys.stderr)+ return 1++ print("containerd console policy: repaired (DeviceAllow=/dev/console m)")+ return 0+++def main(argv=None):+ if not sys.platform.startswith("linux"):+ print("containerd console policy: only applicable to Linux")+ return 0+ parser = argparse.ArgumentParser(description=__doc__)+ g = parser.add_mutually_exclusive_group()+ g.add_argument("--check", action="store_true", help="report whether repair is needed (default)")+ g.add_argument("--apply", action="store_true", help="apply the repair")+ args = parser.parse_args(argv)+ if args.apply:+ return do_apply()+ return do_check()+++if __name__ == "__main__":+ sys.exit(main())diff --git a/ods/scripts/prepare-extension-manifests.py b/ods/scripts/prepare-extension-manifests.pynew file mode 100644index 000000000..70716e706--- /dev/null+++ b/ods/scripts/prepare-extension-manifests.py@@ -0,0 +1,236 @@+#!/usr/bin/env python3+"""Prepare public extension manifest permissions for ODS runtime bind-mounts.++Root cause: with umask 077, copied extensions/services/ape directory is 0700 and+manifest.yaml is 0600. The rootless dashboard-api (UID 1000) then fails in+config.load_extension_manifests at candidate.exists()/read_text().++This script only fixes the runtime manifest bind-mount surface:+ - root extensions/services ancestors: traversal only (add x, remove g/o w)+ - services root: 0755+ - service child dirs: traversal only (add x, remove g/o w)+ - public manifest files (manifest.yaml/.yml/.json): 0644++It validates the full scoped tree before any mutation, refuses symlinks,+special files, hardlinked manifests, and wrong path types. It does not descend+into child dirs except for the listed manifest leaves. Private files such as+private.key (0600) and unrelated dirs are left untouched.++POSIX only. CLI: prepare-extension-manifests.py <install_dir>+"""++from __future__ import annotations++import argparse+import os+import stat+import sys+from pathlib import Path++MANIFEST_NAMES = ("manifest.yaml", "manifest.yml", "manifest.json")+++class ManifestPermissionError(Exception):+ """Actionable error for manifest permission preparation."""+++class _Plan:+ def __init__(self) -> None:+ # path -> target mode+ self.modes: dict[Path, int] = {}+ self.identities: dict[Path, tuple[int, int]] = {}+ self.manifest_count = 0++ def add(self, path: Path, mode: int) -> None:+ self.modes[path] = mode+ entry = os.lstat(path)+ self.identities[path] = (entry.st_dev, entry.st_ino)+++def _lstat(path: Path) -> os.stat_result:+ try:+ return os.lstat(path)+ except FileNotFoundError as exc:+ raise ManifestPermissionError(f"required path missing: {path}") from exc+ except OSError as exc:+ raise ManifestPermissionError(f"cannot stat {path}: {exc}") from exc+++def _require_dir(path: Path, label: str) -> os.stat_result:+ st = _lstat(path)+ if stat.S_ISLNK(st.st_mode):+ raise ManifestPermissionError(f"{label} is a symlink (refused): {path}")+ if not stat.S_ISDIR(st.st_mode):+ raise ManifestPermissionError(f"{label} is not a directory: {path}")+ return st+++def _require_regular_manifest(path: Path) -> os.stat_result:+ st = _lstat(path)+ if stat.S_ISLNK(st.st_mode):+ raise ManifestPermissionError(f"manifest is a symlink (refused): {path}")+ if not stat.S_ISREG(st.st_mode):+ raise ManifestPermissionError(f"manifest is not a regular file: {path}")+ if st.st_nlink != 1:+ raise ManifestPermissionError(+ f"manifest is hardlinked (st_nlink={st.st_nlink}, refused): {path}"+ )+ return st+++def _dir_traversal_mode(st_mode: int) -> int:+ """Keep existing read bits, add execute, remove group/other write."""+ mode = stat.S_IMODE(st_mode)+ mode |= stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH+ mode &= ~(stat.S_IWGRP | stat.S_IWOTH)+ return mode+++def _services_root_mode(st_mode: int) -> int:+ """Services root must be 0755."""+ del st_mode+ return 0o755+++def _manifest_mode(st_mode: int) -> int:+ """Public manifest files must be 0644."""+ del st_mode+ return 0o644+++def _validate_ancestor(path: Path, label: str) -> None:+ _require_dir(path, label)+++def _build_plan(install_dir: Path, *, preserve_file_modes: bool = False) -> _Plan:+ plan = _Plan()++ if not install_dir.is_absolute():+ # abspath preserves a final symlink so validation can reject it.+ install_dir = Path(os.path.abspath(install_dir))++ # Only the installation and its children belong to this repair.+ _validate_ancestor(install_dir, "install_dir")++ extensions = install_dir / "extensions"+ services = extensions / "services"++ _validate_ancestor(extensions, "extensions dir")+ _validate_ancestor(services, "services dir")++ # Root and extensions: traversal only.+ plan.add(install_dir, _dir_traversal_mode(_lstat(install_dir).st_mode))+ plan.add(extensions, _dir_traversal_mode(_lstat(extensions).st_mode))++ # Services root: 0755.+ plan.add(services, _services_root_mode(_lstat(services).st_mode))++ # Enumerate service child dirs (no descent beyond this level).+ try:+ entries = list(os.scandir(services))+ except OSError as exc:+ raise ManifestPermissionError(f"cannot list services dir {services}: {exc}") from exc++ for entry in entries:+ child = Path(entry.path)+ try:+ st = entry.stat(follow_symlinks=False)+ except OSError as exc:+ raise ManifestPermissionError(f"cannot stat service entry {child}: {exc}") from exc++ if stat.S_ISLNK(st.st_mode):+ raise ManifestPermissionError(f"service child is a symlink (refused): {child}")+ if not stat.S_ISDIR(st.st_mode):+ # Match the service loader: files beside service directories are+ # not service packages and are outside this permission repair.+ continue++ plan.add(child, _dir_traversal_mode(st.st_mode))++ # Only inspect listed manifest leaves; do not descend further.+ for name in MANIFEST_NAMES:+ manifest = child / name+ try:+ mst = _require_regular_manifest(manifest)+ except ManifestPermissionError as exc:+ # Missing manifest is okay; other errors are not.+ if isinstance(exc.__cause__, FileNotFoundError):+ continue+ raise+ mode = stat.S_IMODE(mst.st_mode)+ if preserve_file_modes:+ # Pixel's staged source inventory owns file modes during an+ # upgrade. Candidates are already normalized to 0644/0755;+ # retained custom files must not drift from that inventory.+ if mode & 0o444 != 0o444 or mode & 0o022:+ raise ManifestPermissionError(+ f"public manifest is unreadable under a protected source "+ f"transaction: {manifest}; preserve the pending upgrade "+ "and resolve its source permissions before retrying"+ )+ else:+ mode = _manifest_mode(mst.st_mode)+ plan.add(manifest, mode)+ plan.manifest_count += 1++ return plan+++def _apply_plan(plan: _Plan) -> int:+ changed = 0+ for path, target in plan.modes.items():+ try:+ current = stat.S_IMODE(os.lstat(path).st_mode)+ except OSError as exc:+ raise ManifestPermissionError(f"cannot stat {path} before chmod: {exc}") from exc+ if current == target:+ continue+ try:+ # Do not follow a leaf replaced with a symlink after validation.+ fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)+ try:+ opened = os.fstat(fd)+ if (opened.st_dev, opened.st_ino) != plan.identities[path]:+ raise ManifestPermissionError(f"path was replaced before chmod: {path}")+ if not (stat.S_ISDIR(opened.st_mode) or stat.S_ISREG(opened.st_mode)):+ raise ManifestPermissionError(f"path type changed before chmod: {path}")+ if stat.S_ISREG(opened.st_mode) and opened.st_nlink != 1:+ raise ManifestPermissionError(f"manifest became hardlinked: {path}")+ os.fchmod(fd, target)+ finally:+ os.close(fd)+ except OSError as exc:+ raise ManifestPermissionError(+ f"cannot chmod {path} from {oct(current)} to {oct(target)}: {exc}"+ ) from exc+ changed += 1+ return changed+++def prepare(install_dir: Path, *, preserve_file_modes: bool = False) -> tuple[int, int]:+ plan = _build_plan(install_dir, preserve_file_modes=preserve_file_modes)+ changed = _apply_plan(plan)+ return plan.manifest_count, changed+++def main(argv: list[str]) -> int:+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument("install_dir", type=Path)+ parser.add_argument("--preserve-file-modes", action="store_true",+ help="validate protected source modes without changing manifest files")+ args = parser.parse_args(argv[1:])+ try:+ manifest_count, changed = prepare(args.install_dir, preserve_file_modes=args.preserve_file_modes)+ except ManifestPermissionError as exc:+ print(f"error: {exc}", file=sys.stderr)+ return 1++ print(+ f"prepare-extension-manifests: {manifest_count} manifest(s) validated, "+ f"{changed} path(s) updated"+ )+ return 0+++if __name__ == "__main__":+ sys.exit(main(sys.argv))diff --git a/ods/tests/bats-tests/docker-phase.bats b/ods/tests/bats-tests/docker-phase.batsindex e2b927607..251d77a3e 100644--- a/ods/tests/bats-tests/docker-phase.bats+++ b/ods/tests/bats-tests/docker-phase.bats@@ -37,7 +37,10 @@ setup() {export DOCKER_COMPOSE_CMD=""export DOCKER_NEEDS_SUDO=false- mkdir -p "$SCRIPT_DIR"+ mkdir -p "$SCRIPT_DIR/installers/lib"+ cp "$BATS_TEST_DIRNAME/../../installers/lib/podman-registries.sh" \+ "$BATS_TEST_DIRNAME/../../installers/lib/containerd-console.sh" \+ "$SCRIPT_DIR/installers/lib/"touch "$LOG_FILE"}diff --git a/ods/tests/ci-suite.txt b/ods/tests/ci-suite.txtindex 5217df499..6cf72d6e8 100644--- a/ods/tests/ci-suite.txt+++ b/ods/tests/ci-suite.txt@@ -265,6 +265,8 @@ tests/test_build_installation_context_port.pytests/test_chromadb_healthcheck.pytests/test_cleanup_wsl_pixel_mounts.pytests/test_compose_failure_report_port_check.py+tests/test_containerd_console_policy.py+tests/test_public_extension_manifest_permissions.pytests/test_extension_audit_library.pytests/test_generate_llama_architectures.pytests/test_healthcheck_redirect_policy.pydiff --git a/ods/tests/test_containerd_console_policy.py b/ods/tests/test_containerd_console_policy.pynew file mode 100644index 000000000..fe57ff883--- /dev/null+++ b/ods/tests/test_containerd_console_policy.py@@ -0,0 +1,354 @@+#!/usr/bin/env python3+"""Unit tests for ods/scripts/prepare-containerd-console.py."""++import importlib.util+import os+import subprocess+import tempfile+import unittest+from unittest import mock++_HERE = os.path.dirname(os.path.abspath(__file__))+_SCRIPT = os.path.join(_HERE, "..", "scripts", "prepare-containerd-console.py")+++def _load_module():+ spec = importlib.util.spec_from_file_location("ods_prepare_containerd_console", _SCRIPT)+ mod = importlib.util.module_from_spec(spec)+ spec.loader.exec_module(mod)+ return mod+++class _FakeProc:+ def __init__(self, returncode=0, stdout="", stderr=""):+ self.returncode = returncode+ self.stdout = stdout+ self.stderr = stderr+++NVIDIA_ONLY_SHOW = (+ "ActiveState=active\n"+ "DevicePolicy=auto\n"+ "DeviceAllow=/dev/nvidia0 rwm\n"+ "DeviceAllow=/dev/nvidiactl rwm\n"+ "DeviceAllow=char-nvidia-caps rwm\n"+)++NVIDIA_WITH_CONSOLE_SHOW = NVIDIA_ONLY_SHOW + "DeviceAllow=/dev/console m\n"++CUSTOM_SHOW = (+ "ActiveState=active\n"+ "DevicePolicy=auto\n"+ "DeviceAllow=/dev/nvidia0 rwm\n"+ "DeviceAllow=/dev/dri/card0 rwm\n"+)++STRICT_SHOW = (+ "ActiveState=active\n"+ "DevicePolicy=closed\n"+ "DeviceAllow=/dev/nvidia0 rwm\n"+)++EMPTY_SHOW = (+ "ActiveState=active\n"+ "DevicePolicy=auto\n"+ "DeviceAllow=\n"+)++INACTIVE_SHOW = (+ "ActiveState=inactive\n"+ "DevicePolicy=auto\n"+ "DeviceAllow=/dev/nvidia0 rwm\n"+)+++class ContainerdConsolePolicyTests(unittest.TestCase):+ def setUp(self):+ self.mod = _load_module()+ self.tmp = tempfile.TemporaryDirectory()+ self.addCleanup(self.tmp.cleanup)+ self.dropin_dir = os.path.join(self.tmp.name, "containerd.service.d")+ self.dropin_path = os.path.join(self.dropin_dir, "90-ods-image-unpack.conf")+ self.mod.DROPIN_DIR = self.dropin_dir+ self.mod.DROPIN_PATH = self.dropin_path++ def _patch_show(self, stdout, returncode=0):+ return mock.patch.object(+ self.mod.subprocess, "run",+ return_value=_FakeProc(returncode=returncode, stdout=stdout),+ )++ def _patch_run_sequence(self, *procs):+ return mock.patch.object(+ self.mod.subprocess, "run",+ side_effect=list(procs),+ )++ def test_check_nvidia_only_needs_repair(self):+ with self._patch_show(NVIDIA_ONLY_SHOW):+ rc = self.mod.main(["--check"])+ self.assertEqual(rc, 10)+ self.assertFalse(os.path.exists(self.dropin_path))++ def test_check_already_has_console_m(self):+ with self._patch_show(NVIDIA_WITH_CONSOLE_SHOW):+ rc = self.mod.main(["--check"])+ self.assertEqual(rc, 0)++ def test_existing_broader_console_permission_is_not_rewritten(self):+ with self._patch_show(NVIDIA_ONLY_SHOW + "DeviceAllow=/dev/console rwm\n"):+ self.assertEqual(self.mod.main(["--apply"]), 0)+ self.assertFalse(os.path.exists(self.dropin_path))++ def test_systemctl_failure_is_not_reported_as_success(self):+ with mock.patch.object(self.mod.subprocess, "run", side_effect=subprocess.CalledProcessError(1, "systemctl")):+ with self.assertRaises(subprocess.CalledProcessError):+ self.mod.main(["--check"])++ def test_check_custom_policy_no_change(self):+ with self._patch_show(CUSTOM_SHOW):+ rc = self.mod.main(["--check"])+ self.assertEqual(rc, 0)++ def test_check_strict_policy_no_change(self):+ with self._patch_show(STRICT_SHOW):+ rc = self.mod.main(["--check"])+ self.assertEqual(rc, 0)++ def test_check_empty_allow_no_change(self):+ with self._patch_show(EMPTY_SHOW):+ rc = self.mod.main(["--check"])+ self.assertEqual(rc, 0)++ def test_check_inactive_no_change(self):+ with self._patch_show(INACTIVE_SHOW):+ rc = self.mod.main(["--check"])+ self.assertEqual(rc, 0)++ def test_check_no_writes(self):+ with self._patch_show(NVIDIA_ONLY_SHOW):+ self.mod.main(["--check"])+ self.assertFalse(os.path.exists(self.dropin_dir))++ def test_apply_creates_owned_dropin_with_m_only(self):+ with mock.patch.object(self.mod, "_is_root", return_value=True), \+ self._patch_run_sequence(+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),+ _FakeProc(returncode=0),+ _FakeProc(stdout=NVIDIA_WITH_CONSOLE_SHOW),+ ):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 0)+ with open(self.dropin_path, "r", encoding="utf-8") as f:+ content = f.read()+ self.assertIn("DeviceAllow=/dev/console m\n", content)+ self.assertNotIn("rwm", content)+ self.assertEqual(content, self.mod.DROPIN_CONTENT)+ self.assertEqual(os.stat(self.dropin_path).st_mode & 0o777, 0o644)++ def test_apply_requires_root(self):+ with mock.patch.object(self.mod, "_is_root", return_value=False), \+ self._patch_show(NVIDIA_ONLY_SHOW):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 1)+ self.assertFalse(os.path.exists(self.dropin_path))++ def test_apply_idempotent_when_already_repaired(self):+ with self._patch_show(NVIDIA_WITH_CONSOLE_SHOW):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 0)+ self.assertFalse(os.path.exists(self.dropin_path))++ def test_apply_refuses_foreign_file(self):+ os.makedirs(self.dropin_dir)+ with open(self.dropin_path, "w", encoding="utf-8") as f:+ f.write("[Service]\nDeviceAllow=/dev/console rwm\n")+ with mock.patch.object(self.mod, "_is_root", return_value=True), \+ self._patch_show(NVIDIA_ONLY_SHOW):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 1)+ with open(self.dropin_path, "r", encoding="utf-8") as f:+ self.assertIn("rwm", f.read())++ def test_apply_preserves_vendor_file(self):+ os.makedirs(self.dropin_dir)+ vendor = os.path.join(self.dropin_dir, "containerd-override.conf")+ original = "[Service]\nDeviceAllow=/dev/nvidia0\n"+ with open(vendor, "w", encoding="utf-8") as stream:+ stream.write(original)+ with mock.patch.object(self.mod, "_is_root", return_value=True), self._patch_run_sequence(+ _FakeProc(stdout=NVIDIA_ONLY_SHOW), _FakeProc(), _FakeProc(stdout=NVIDIA_WITH_CONSOLE_SHOW)+ ):+ self.assertEqual(self.mod.main(["--apply"]), 0)+ with open(vendor, encoding="utf-8") as stream:+ self.assertEqual(stream.read(), original)++ def test_apply_refuses_symlink(self):+ os.makedirs(self.dropin_dir)+ target = os.path.join(self.tmp.name, "target.conf")+ with open(target, "w", encoding="utf-8") as f:+ f.write("x")+ os.symlink(target, self.dropin_path)+ with mock.patch.object(self.mod, "_is_root", return_value=True), \+ self._patch_show(NVIDIA_ONLY_SHOW):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 1)+ self.assertTrue(os.path.islink(self.dropin_path))++ def test_apply_refuses_symlink_dir(self):+ real_dir = os.path.join(self.tmp.name, "real")+ os.makedirs(real_dir)+ os.symlink(real_dir, self.dropin_dir)+ with mock.patch.object(self.mod, "_is_root", return_value=True), \+ self._patch_show(NVIDIA_ONLY_SHOW):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 1)+ self.assertFalse(os.path.exists(os.path.join(real_dir, "90-ods-image-unpack.conf")))++ def test_apply_reload_failure_returns_error_and_retry_succeeds(self):+ with mock.patch.object(self.mod, "_is_root", return_value=True), \+ self._patch_run_sequence(+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),+ _FakeProc(returncode=1, stderr="boom"),+ ):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 1)+ self.assertTrue(os.path.exists(self.dropin_path))++ # Retry: owned file exists, daemon-reload succeeds, verify passes.+ with mock.patch.object(self.mod, "_is_root", return_value=True), \+ self._patch_run_sequence(+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),+ _FakeProc(returncode=0),+ _FakeProc(stdout=NVIDIA_WITH_CONSOLE_SHOW),+ ):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 0)++ def test_apply_verify_fails_if_console_missing(self):+ with mock.patch.object(self.mod, "_is_root", return_value=True), \+ self._patch_run_sequence(+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),+ _FakeProc(returncode=0),+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),+ ):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 1)++ def test_apply_verify_fails_if_old_entry_lost(self):+ lost = (+ "ActiveState=active\n"+ "DevicePolicy=auto\n"+ "DeviceAllow=/dev/console m\n"+ )+ with mock.patch.object(self.mod, "_is_root", return_value=True), \+ self._patch_run_sequence(+ _FakeProc(stdout=NVIDIA_ONLY_SHOW),+ _FakeProc(returncode=0),+ _FakeProc(stdout=lost),+ ):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 1)++ def test_apply_never_calls_restart_or_stop(self):+ calls = []+ state = {"shows": 0}++ def fake_run(cmd, **kwargs):+ calls.append(list(cmd))+ if cmd[:2] == ["systemctl", "show"]:+ state["shows"] += 1+ return _FakeProc(stdout=NVIDIA_ONLY_SHOW if state["shows"] == 1 else NVIDIA_WITH_CONSOLE_SHOW)+ return _FakeProc(returncode=0)++ with mock.patch.object(self.mod, "_is_root", return_value=True), \+ mock.patch.object(self.mod.subprocess, "run", side_effect=fake_run):+ rc = self.mod.main(["--apply"])+ self.assertEqual(rc, 0)+ for c in calls:+ self.assertNotIn("restart", c)+ self.assertNotIn("stop", c)+ self.assertNotIn("start", c)++ def test_parse_device_allow_repeated_keys(self):+ entries = self.mod._parse_device_allow([+ "/dev/nvidia0 rwm",+ "/dev/nvidiactl rwm",+ "char-nvidia-caps rwm",+ ])+ self.assertEqual(entries, [+ ("/dev/nvidia0", "rwm"),+ ("/dev/nvidiactl", "rwm"),+ ("char-nvidia-caps", "rwm"),+ ])++ def test_nvidia_patterns(self):+ self.assertTrue(self.mod._NVIDIA_DEV_RE.match("/dev/nvidia0"))+ self.assertTrue(self.mod._NVIDIA_DEV_RE.match("/dev/nvidiactl"))+ self.assertTrue(self.mod._NVIDIA_DEV_RE.match("/dev/nvidia-caps/nvidia-cap1"))+ self.assertFalse(self.mod._NVIDIA_DEV_RE.match("/dev/dri/card0"))+ self.assertFalse(self.mod._NVIDIA_DEV_RE.match("/dev/nvidia0/../dri"))+++class InstallerRuntimeGateTests(unittest.TestCase):+ def run_gate(self, **overrides):+ with tempfile.TemporaryDirectory() as directory:+ env = dict(os.environ, GPU_BACKEND="nvidia", GPU_COUNT="2", DRY_RUN="false",+ PODMAN="1", DESKTOP="1", ENDPOINT="unix:///var/run/docker.sock",+ SECURITY='["name=apparmor"]', CHECK_RC="10", APPLY_RC="0",+ CALLS=os.path.join(directory, "calls"), DOCKER_HOST="", DOCKER_CONTEXT="")+ env.update(overrides)+ wrapper = os.path.abspath(os.path.join(_HERE, "..", "installers", "lib", "containerd-console.sh"))+ script = r'''+set -euo pipefail+source "$1"+SCRIPT_DIR=/reviewed-source+uname() { printf 'Linux\n'; }+_runtime_is_podman() { return "$PODMAN"; }+_docker_is_desktop_engine() { return "$DESKTOP"; }+log() { :; }+ai() { :; }+ai_ok() { :; }+docker_run() {+ if [[ "$1" == context ]]; then printf '%s\n' "$ENDPOINT";+ else printf '%s\n' "$SECURITY"; fi+}+python3() { printf 'check\n' >> "$CALLS"; return "$CHECK_RC"; }+ods_sudo() { printf 'apply\n' >> "$CALLS"; return "$APPLY_RC"; }+ods_prepare_containerd_console+'''+ result = subprocess.run(["bash", "-c", script, "_", wrapper], env=env, capture_output=True, text=True)+ calls = []+ if os.path.exists(env["CALLS"]):+ with open(env["CALLS"], encoding="utf-8") as stream:+ calls = stream.read().splitlines()+ return result.returncode, calls++ def test_local_nvidia_requires_check_before_apply(self):+ self.assertEqual(self.run_gate(), (0, ["check", "apply"]))++ def test_unsupported_runtime_never_applies_host_change(self):+ for values in [dict(GPU_BACKEND="cpu"), dict(DRY_RUN="true"), dict(PODMAN="0"),+ dict(DESKTOP="0"), dict(ENDPOINT="ssh://remote"),+ dict(DOCKER_HOST="tcp://remote:2375"),+ dict(ENDPOINT="unix:///run/user/1000/docker.sock"),+ dict(SECURITY='["name=rootless"]')]:+ with self.subTest(values=values):+ self.assertEqual(self.run_gate(**values), (0, []))++ def test_failed_check_or_apply_fails_phase(self):+ self.assertEqual(self.run_gate(CHECK_RC="2"), (2, ["check"]))+ self.assertEqual(self.run_gate(APPLY_RC="1"), (1, ["check", "apply"]))++ def test_already_ready_does_not_request_sudo(self):+ self.assertEqual(self.run_gate(CHECK_RC="0"), (0, ["check"]))++ def test_explicit_context_takes_precedence_over_docker_host(self):+ self.assertEqual(self.run_gate(DOCKER_HOST="unix:///var/run/docker.sock",+ DOCKER_CONTEXT="remote", ENDPOINT="ssh://remote"), (0, []))+ self.assertEqual(self.run_gate(DOCKER_HOST="tcp://ignored:2375", DOCKER_CONTEXT="default"),+ (0, ["check", "apply"]))+++if __name__ == "__main__":+ unittest.main()diff --git a/ods/tests/test_public_extension_manifest_permissions.py b/ods/tests/test_public_extension_manifest_permissions.pynew file mode 100644index 000000000..68b546487--- /dev/null+++ b/ods/tests/test_public_extension_manifest_permissions.py@@ -0,0 +1,378 @@+#!/usr/bin/env python3+"""Tests for ods/scripts/prepare-extension-manifests.py.++Covers:+ - real temp dirs with umask 077 and 022+ - in-place rerun and idempotence+ - private file modes unchanged (private.key 0600)+ - all three manifest extensions+ - symlink / fifo / hardlink refusal before any mode changes+ - invalid root refusal+ - mixed-UID actual read (optional, skipped unless env set)++Run: python3 -m unittest ods/tests/test_public_extension_manifest_permissions.py+"""++from __future__ import annotations++import importlib.util+import os+import stat+import tempfile+import unittest+from pathlib import Path+++_HERE = Path(__file__).resolve()+_SCRIPT = _HERE.parent.parent / "scripts" / "prepare-extension-manifests.py"+++def _load_module():+ spec = importlib.util.spec_from_file_location(+ "prepare_extension_manifests", _SCRIPT+ )+ if spec is None or spec.loader is None:+ raise RuntimeError(f"cannot load {_SCRIPT}")+ module = importlib.util.module_from_spec(spec)+ spec.loader.exec_module(module)+ return module+++_mod = _load_module()+++class _Umask:+ def __init__(self, mask: int) -> None:+ self.mask = mask+ self.prev = None++ def __enter__(self):+ self.prev = os.umask(self.mask)+ return self++ def __exit__(self, *exc):+ os.umask(self.prev)+ return False+++def _mode(path: Path) -> int:+ return stat.S_IMODE(os.lstat(path).st_mode)+++def _make_tree(root: Path, umask: int) -> dict[str, Path]:+ """Create a realistic ODS install tree under root with given umask."""+ with _Umask(umask):+ extensions = root / "extensions"+ services = extensions / "services"+ services.mkdir(parents=True)++ paths: dict[str, Path] = {+ "root": root,+ "extensions": extensions,+ "services": services,+ }++ for name, manifest_name in (+ ("ape", "manifest.yaml"),+ ("beta", "manifest.yml"),+ ("gamma", "manifest.json"),+ ):+ child = services / name+ child.mkdir()+ manifest = child / manifest_name+ manifest.write_text(f"name: {name}\n", encoding="utf-8")+ private = child / "private.key"+ private.write_text("secret\n", encoding="utf-8")+ private.chmod(0o600)+ paths[f"child_{name}"] = child+ paths[f"manifest_{name}"] = manifest+ paths[f"private_{name}"] = private++ # A child with no manifest is valid.+ empty = services / "empty"+ empty.mkdir()+ paths["child_empty"] = empty++ # Unrelated sibling dir under install root must be untouched.+ unrelated = root / "data"+ unrelated.mkdir()+ paths["unrelated"] = unrelated+ env = root / ".env"+ env.write_text("fixture-only\n", encoding="utf-8")+ env.chmod(0o600)+ paths["env"] = env++ return paths+++def _snapshot_modes(paths: dict[str, Path]) -> dict[str, int]:+ return {k: _mode(v) for k, v in paths.items()}+++class PrepareExtensionManifestsTests(unittest.TestCase):+ def test_protected_source_inventory_is_unchanged(self) -> None:+ spec = importlib.util.spec_from_file_location(+ "pixel_source_upgrade", _HERE.parent.parent / "bin/pixel_source_upgrade.py"+ )+ upgrade = importlib.util.module_from_spec(spec)+ spec.loader.exec_module(upgrade)+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir(mode=0o700)+ paths = _make_tree(root, 0o077)+ for name in upgrade.ROOTS:+ (root / name).mkdir(exist_ok=True)+ for key, mode in (("manifest_ape", 0o644), ("manifest_beta", 0o755),+ ("manifest_gamma", 0o444)):+ paths[key].chmod(mode)+ before = upgrade.inventory(root, os.getuid())+ _mod.prepare(root, preserve_file_modes=True)+ self.assertEqual(upgrade.inventory(root, os.getuid()), before)+ self.assertEqual(_mode(paths["services"]), 0o755)++ def test_private_manifest_in_protected_source_refused_before_mutation(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir(mode=0o700)+ paths = _make_tree(root, 0o077)+ before = {key: _mode(path) for key, path in paths.items()}+ with self.assertRaisesRegex(_mod.ManifestPermissionError, "protected source"):+ _mod.prepare(root, preserve_file_modes=True)+ self.assertEqual({key: _mode(path) for key, path in paths.items()}, before)++ def _run(self, root: Path) -> tuple[int, int]:+ return _mod.prepare(root)++ def test_relative_symlink_root_is_refused(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)+ (Path(td) / "linked").symlink_to(root, target_is_directory=True)+ previous = Path.cwd()+ try:+ os.chdir(td)+ with self.assertRaises(_mod.ManifestPermissionError):+ self._run(Path("linked"))+ finally:+ os.chdir(previous)+ self.assertEqual(_mode(paths["manifest_ape"]), 0o600)++ def test_umask_077_fixes_public_surface(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)++ # Preconditions: umask 077 produced restrictive modes.+ self.assertEqual(_mode(paths["services"]), 0o700)+ self.assertEqual(_mode(paths["manifest_ape"]), 0o600)+ self.assertEqual(_mode(paths["private_ape"]), 0o600)++ manifest_count, changed = self._run(root)+ self.assertEqual(manifest_count, 3)+ self.assertGreater(changed, 0)+ self.assertEqual(_mode(paths["env"]), 0o600)++ # Services root 0755.+ self.assertEqual(_mode(paths["services"]), 0o755)+ # Child dirs: traversal (x added, g/o w removed, read bits kept).+ for key in ("child_ape", "child_beta", "child_gamma", "child_empty"):+ m = _mode(paths[key])+ self.assertTrue(m & stat.S_IXUSR, key)+ self.assertTrue(m & stat.S_IXGRP, key)+ self.assertTrue(m & stat.S_IXOTH, key)+ self.assertFalse(m & stat.S_IWGRP, key)+ self.assertFalse(m & stat.S_IWOTH, key)+ # Manifests 0644.+ for key in ("manifest_ape", "manifest_beta", "manifest_gamma"):+ self.assertEqual(_mode(paths[key]), 0o644, key)+ # Private keys unchanged.+ for key in ("private_ape", "private_beta", "private_gamma"):+ self.assertEqual(_mode(paths[key]), 0o600, key)+ # Unrelated dir untouched.+ self.assertEqual(_mode(paths["unrelated"]), 0o700)++ def test_umask_022_idempotent(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o022)++ self._run(root)+ first = _snapshot_modes(paths)+ manifest_count, changed = self._run(root)+ second = _snapshot_modes(paths)++ self.assertEqual(manifest_count, 3)+ self.assertEqual(changed, 0)+ self.assertEqual(first, second)+ self.assertEqual(_mode(paths["manifest_ape"]), 0o644)+ self.assertEqual(_mode(paths["private_ape"]), 0o600)++ def test_in_place_rerun_after_umask_077(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)++ self._run(root)+ first = _snapshot_modes(paths)+ _, changed = self._run(root)+ second = _snapshot_modes(paths)++ self.assertEqual(changed, 0)+ self.assertEqual(first, second)++ def test_symlink_manifest_refused_before_mutation(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)++ target = paths["manifest_ape"]+ real = target.with_name("real.yaml")+ real.write_text("name: ape\n", encoding="utf-8")+ target.unlink()+ target.symlink_to(real)++ before = _snapshot_modes(paths)+ with self.assertRaises(_mod.ManifestPermissionError):+ self._run(root)+ after = _snapshot_modes(paths)+ self.assertEqual(before, after)++ def test_symlink_child_dir_refused_before_mutation(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)++ real = paths["child_ape"]+ link = paths["services"] / "linked"+ link.symlink_to(real)++ before = _snapshot_modes(paths)+ with self.assertRaises(_mod.ManifestPermissionError):+ self._run(root)+ after = _snapshot_modes(paths)+ self.assertEqual(before, after)++ def test_fifo_manifest_refused_before_mutation(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)++ target = paths["manifest_ape"]+ target.unlink()+ os.mkfifo(target)++ before = _snapshot_modes(paths)+ with self.assertRaises(_mod.ManifestPermissionError):+ self._run(root)+ after = _snapshot_modes(paths)+ self.assertEqual(before, after)++ def test_hardlinked_manifest_refused_before_mutation(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)++ target = paths["manifest_ape"]+ other = target.with_name("other.yaml")+ os.link(target, other)++ before = _snapshot_modes(paths)+ with self.assertRaises(_mod.ManifestPermissionError):+ self._run(root)+ after = _snapshot_modes(paths)+ self.assertEqual(before, after)++ def test_invalid_root_refused(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ _make_tree(root, 0o077)++ missing = Path(td) / "does-not-exist"+ with self.assertRaises(_mod.ManifestPermissionError):+ self._run(missing)++ def test_root_is_file_refused(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.write_text("not a dir\n", encoding="utf-8")+ with self.assertRaises(_mod.ManifestPermissionError):+ self._run(root)++ def test_missing_manifest_in_child_ok(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)++ manifest_count, _ = self._run(root)+ self.assertEqual(manifest_count, 3)+ self.assertTrue(paths["child_empty"].is_dir())++ def test_names_with_spaces_ok(self) -> None:+ with tempfile.TemporaryDirectory() as td:+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)++ spaced = paths["services"] / "with space"+ spaced.mkdir()+ manifest = spaced / "manifest.yaml"+ manifest.write_text("name: spaced\n", encoding="utf-8")++ manifest_count, _ = self._run(root)+ self.assertEqual(manifest_count, 4)+ self.assertEqual(_mode(manifest), 0o644)++ @unittest.skipUnless(+ os.environ.get("ODS_MIXED_UID_TEST") == "1",+ "set ODS_MIXED_UID_TEST=1 and run as root to exercise mixed-UID read",+ )+ def test_mixed_uid_actual_read(self) -> None:+ """Optional integration: verify a non-owner UID can read manifests.++ Run separately as root, e.g.:+ ODS_MIXED_UID_TEST=1 python3 -m unittest \+ ods/tests/test_public_extension_manifest_permissions.py+ """+ import pwd++ with tempfile.TemporaryDirectory() as td:+ os.chmod(td, 0o755)+ root = Path(td) / "install"+ root.mkdir()+ paths = _make_tree(root, 0o077)+ nobody = pwd.getpwnam("nobody")++ def can_read(path):+ pid = os.fork()+ if pid == 0:+ try:+ os.setgroups([])+ os.setgid(nobody.pw_gid)+ os.setuid(nobody.pw_uid)+ with open(path, "rb") as fh:+ fh.read(1)+ except OSError:+ os._exit(1)+ os._exit(0)+ _, status = os.waitpid(pid, 0)+ return os.waitstatus_to_exitcode(status) == 0++ self.assertFalse(can_read(paths["manifest_ape"]))+ self._run(root)+ for key in ("manifest_ape", "manifest_beta", "manifest_gamma"):+ self.assertTrue(can_read(paths[key]), key)+ self.assertFalse(can_read(paths["private_ape"]))+++if __name__ == "__main__":+ unittest.main()