diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-04 16:53:45 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-04 16:53:56 -0300 |
| commit | 87d9d6e3fe7122d4a2ff507d6561eebfa569f8e7 (patch) | |
| tree | b628809c132871d6f6543971d8d79b18328bcac3 /test | |
| parent | be3985092df1c3388cfa09ca5e989d2fa66f55ec (diff) | |
| download | pardes-87d9d6e3fe7122d4a2ff507d6561eebfa569f8e7.tar.gz pardes-87d9d6e3fe7122d4a2ff507d6561eebfa569f8e7.zip | |
Tty9p and its pardes-v9fs helper removed (the user: a one-off), a terminal with the session kernel-mounted through Linux v9fs: the builtin and its SPC n 9, the spawn's mounted path and the pane's flag, the host's helper launch, src/linux/v9fs.zig and its build and install, test/v9fs.py, v9fs_driver_test.py and v9fs_terminal.py with their three steps, the docs (the build notes keep how to mount a session by hand); the builtin lists regenerated; core, fs-unit, pane, behaviour and process tests, the gui build and all 113 snap scripts pass; ~/.local/bin/pardes-v9fs, installed before, is left
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'test')
| -rw-r--r-- | test/v9fs.py | 196 | ||||
| -rw-r--r-- | test/v9fs_driver_test.py | 26 | ||||
| -rw-r--r-- | test/v9fs_terminal.py | 108 |
3 files changed, 0 insertions, 330 deletions
diff --git a/test/v9fs.py b/test/v9fs.py deleted file mode 100644 index 30efe9fb..00000000 --- a/test/v9fs.py +++ /dev/null @@ -1,196 +0,0 @@ -#!/usr/bin/env python3 -"""Opt-in Linux kernel-mount probe; the editor always runs unprivileged. - -Run after `sudo -v` with a native Pardes binary and the runtime v9fs helper. -The helper alone runs through sudo, creates a private mount namespace, mounts -9P, drops privileges, and execs this file's worker. No FUSE or global mount. -""" -import argparse -import json -import os -import pwd -from pathlib import Path -import subprocess -import sys -import tempfile -import time -import traceback - -from fs import session -from ninep import Client - - -def write_existing(path, data, *, truncate=False): - flags = os.O_WRONLY | (os.O_TRUNC if truncate else 0) - fd = os.open(path, flags) - try: - assert os.write(fd, data) == len(data), str(path) - finally: - os.close(fd) - - -def worker(mountpoint, socket, uid, gid, original_namespace): - assert os.getresuid() == (uid, uid, uid), os.getresuid() - assert os.getresgid() == (gid, gid, gid), os.getresgid() - assert set(os.getgroups()) == set(os.getgrouplist(pwd.getpwuid(uid).pw_name, gid)), os.getgroups() - assert os.readlink('/proc/self/ns/mnt') != original_namespace - status = dict(line.split(':', 1) for line in Path('/proc/self/status').read_text().splitlines()) - for field in ('CapEff', 'CapPrm', 'CapAmb'): - assert int(status[field].strip(), 16) == 0, (field, status[field]) - entries = Path('/proc/self/mountinfo').read_text().splitlines() - mounted = [line for line in entries if line.split()[4] == str(mountpoint)] - assert len(mounted) == 1 and ' - 9p ' in mounted[0], mounted - assert not any(field.startswith(('shared:', 'master:')) for field in mounted[0].split()[6:]) - - tree = mountpoint - assert {'os', 'index', 'pane', 'status', 'look', 'exec', 'log', 'screen', 'README'} <= set(os.listdir(tree)) - assert 'self' not in os.listdir(tree) and 'new' not in os.listdir(tree) - assert 'new' not in os.listdir(tree / 'pane'), 'a listing would make a pane per stat' - # A direct connection provides independent evidence for VFS reads/writes. - with Client(socket) as client: - assert (tree / 'index').read_bytes() == client.read('/index') - assert (tree / 'pane/1/body').read_bytes() == b'initial\n' - - before = client.read('/index') - subprocess.run(['ls', '-l', str(tree), str(tree / 'pane' / '1')], check=True, capture_output=True, timeout=5) - subprocess.run(['find', str(tree / 'pane'), '-ls'], check=True, capture_output=True, timeout=5) - assert (tree / 'README').read_bytes() == client.read('/README') - assert client.read('/index') == before, 'browsing created panes' - # Opening pane/new makes a pane and the read names it, so no trip - # through the index. Whether a repeated path reaches the server at all - # is the kernel's dentry cache's business, so the second pane comes - # over the wire, where the open is exact. - def serials(): - return {int(row.split()[0]) for row in (tree / 'index').read_bytes().splitlines()} - - def mkpane(): - known = serials() - made = int((tree / 'pane' / 'new').read_bytes()) - assert made not in known, 'the open of new made no pane' - return made - - serial = mkpane() - another = int(client.read('/pane/new')) - assert serial != another, 'a second open of new reused a pane' - (tree / 'pane' / str(another)).rmdir() - assert another not in serials() - pane = tree / 'pane' / str(serial) - wire = f'/pane/{serial}' - assert str(serial) in os.listdir(tree / 'pane') - assert serial in [int(row.split()[0]) for row in (tree / 'index').read_bytes().splitlines()] - - write_existing(pane / 'body', b'kernel body\n', truncate=True) - assert client.read(wire + '/body') == b'kernel body\n' - # Reopen must observe changes made through another 9P connection. - client.write(wire + '/body', b'wire update\n', truncate=True) - assert (pane / 'body').read_bytes() == b'wire update\n' - write_existing(pane / 'body', b'appended\n') - assert client.read(wire + '/body') == b'wire update\nappended\n' - write_existing(pane / 'addr', b'#0,#4') - write_existing(pane / 'data', b'v9fs') - assert client.read(wire + '/body') == b'v9fs update\nappended\n' - - # Exercise an actual shell redirection, including its O_TRUNC open. - subprocess.run(['/bin/sh', '-c', 'printf "kernel-probe\\n" > "$1/name"', - 'v9fs-probe', str(pane)], check=True, timeout=5) - tag = client.read(wire + '/tag') - assert tag.split(maxsplit=1)[0] == str(socket.parent / 'kernel-probe').encode(), tag - # Children inherit this single mount and can use ordinary tools. - copied = subprocess.run(['/bin/cat', str(pane / 'body')], - check=True, capture_output=True, timeout=5).stdout - assert copied == b'v9fs update\nappended\n' - - command = b'Msg kernel-v9fs-ready' - write_existing(pane / 'body', command, truncate=True) - write_existing(pane / 'event', f'MX0 {len(command)}\n'.encode()) - # Event writes acknowledge dispatch, so reopen screen until rendered. - deadline = time.monotonic() + 5 - while True: - screen = json.loads((tree / 'screen').read_bytes()) - if 'kernel-v9fs-ready' in ''.join(cell[0] for cell in screen['cells']): - break - assert time.monotonic() < deadline, 'Exec result was not rendered' - time.sleep(.01) - - # Reading OS files through the exported tree does not recurse through - # the mount: the core still lives in the supervisor's namespace. - assert (mountpoint / 'os' / str(socket.parent).lstrip('/') / 'kernel.txt').read_bytes() == b'initial\n' - (tree / 'pane' / str(serial)).rmdir() - assert serial not in [int(row.split()[0]) for row in (tree / 'index').read_bytes().splitlines()] - - print('v9fs: namespace isolation, privilege drop, inherited mount, directory refresh, ' - 'text edits, control writes, Exec and screen checks passed', flush=True) - - -def run_helper(command, timeout=30): - # Keep the caller's controlling terminal: sudo credentials are commonly - # scoped to it. setsid/start_new_session makes an earlier sudo -v useless. - # The elevated helper itself creates the separate *mount* namespace. - child = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, - text=True) - try: - stdout, stderr = child.communicate(timeout=timeout) - except subprocess.TimeoutExpired: - # sudo forwards signals to its command. Keep the server alive while - # stopping the mount user, then let session() clean up. - child.terminate() - try: - child.communicate(timeout=5) - except subprocess.TimeoutExpired: - child.kill() - child.communicate(timeout=5) - raise RuntimeError('kernel probe timed out; no compatibility result') - if child.returncode: - raise RuntimeError(f'kernel probe failed ({child.returncode})\n{stdout}{stderr}') - return stdout - - -def run(binary, helper): - if sys.platform != 'linux': - raise RuntimeError('this probe requires Linux v9fs') - if os.getuid() == 0: - raise RuntimeError('run the driver as your normal user; only the mount helper uses sudo') - # Never prompt from a build step. An unavailable prerequisite is a failure, - # not a skipped test that might be mistaken for mounted-filesystem coverage. - available = subprocess.run(['sudo', '-n', '-v'], capture_output=True, text=True, timeout=5) - if available.returncode: - raise RuntimeError('mount authorization unavailable: run sudo -v in your terminal, then retry\n' - + available.stderr.strip()) - namespace = os.readlink('/proc/self/ns/mnt') - with tempfile.TemporaryDirectory(prefix='pardes-v9fs-') as directory: - root = Path(directory) - target = root / 'mount' - target.mkdir() - with session(str(binary), root, 'kernel') as (client, address): - command = ['sudo', '-n', '--', str(helper), str(address), str(target), - str(os.getuid()), str(os.getgid()), '--', sys.executable, '-B', - str(Path(__file__).resolve()), '--worker', str(target), str(address), - str(os.getuid()), str(os.getgid()), namespace] - print(run_helper(command), end='') - assert os.readlink('/proc/self/ns/mnt') == namespace - assert list(target.iterdir()) == [], 'mount escaped its private namespace' - assert client.read('/pane/1/body') == b'initial\n', 'core stopped serving after probe exit' - print('v9fs: supervisor namespace unchanged and session cleanup passed') - - -def main(): - if len(sys.argv) > 1 and sys.argv[1] == '--worker': - if len(sys.argv) != 7: - raise RuntimeError('invalid internal worker arguments') - worker(Path(sys.argv[2]), Path(sys.argv[3]), int(sys.argv[4]), int(sys.argv[5]), sys.argv[6]) - return - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument('binary', type=lambda text: Path(text).resolve(strict=True)) - parser.add_argument('helper', type=lambda text: Path(text).resolve(strict=True)) - args = parser.parse_args() - run(args.binary, args.helper) - - -if __name__ == '__main__': - try: - main() - except (AssertionError, OSError, RuntimeError, subprocess.SubprocessError) as error: - if len(sys.argv) > 1 and sys.argv[1] == '--worker': - traceback.print_exc() - print(f'v9fs: {error}', file=sys.stderr) - sys.exit(1) diff --git a/test/v9fs_driver_test.py b/test/v9fs_driver_test.py deleted file mode 100644 index 9781c4fe..00000000 --- a/test/v9fs_driver_test.py +++ /dev/null @@ -1,26 +0,0 @@ -#!/usr/bin/env python3 -"""Unprivileged regression checks for the v9fs helper launcher.""" -import os -import sys -import unittest - -from v9fs import run_helper - - -class HelperLaunchTests(unittest.TestCase): - def test_preserves_session_for_terminal_scoped_sudo_credentials(self): - output = run_helper([sys.executable, '-c', 'import os; print(os.getsid(0))']) - self.assertEqual(int(output), os.getsid(0)) - - def test_failure_preserves_diagnostics(self): - with self.assertRaisesRegex(RuntimeError, r'(?s)failed \(7\).*mount refused'): - run_helper([sys.executable, '-c', - 'import sys; print("mount refused", file=sys.stderr); sys.exit(7)']) - - def test_timeout_is_not_a_passing_probe(self): - with self.assertRaisesRegex(RuntimeError, 'timed out; no compatibility result'): - run_helper([sys.executable, '-c', 'import time; time.sleep(60)'], timeout=.1) - - -if __name__ == '__main__': - unittest.main() diff --git a/test/v9fs_terminal.py b/test/v9fs_terminal.py deleted file mode 100644 index b49246d1..00000000 --- a/test/v9fs_terminal.py +++ /dev/null @@ -1,108 +0,0 @@ -#!/usr/bin/env python3 -"""Exercise Tty9p and its real launcher with a nonprivileged sudo stand-in. - -This checks PTY routing and lifecycle, not kernel-mount compatibility (v9fs.py). -""" -import json -import os -from pathlib import Path -import signal -import shutil -import sys -import tempfile -import time - -from fs import execute, new_pane, session - - -def until(probe, description): - deadline = time.monotonic() + 8 - while time.monotonic() < deadline: - result = probe() - if result: - return result - time.sleep(.02) - raise AssertionError(description) - - -def test(binary, helper): - with tempfile.TemporaryDirectory(prefix='pardes-v9fs-terminal-') as directory: - root = Path(directory) - # Exercise shell quoting with a real executable path containing both - # whitespace and an apostrophe, under bash and fish where available. - quoted_helper = root / "helper's quoted path" - shutil.copy2(helper, quoted_helper) - helper = quoted_helper - sudo = root / 'sudo' - # A fresh PATH in the owned fixture selects this stand-in. It never - # invokes real sudo, mounts anything, or handles a real password. - sudo.write_text(f'#!{sys.executable}\n' + ''' -import json, os, signal, sys, termios -from pathlib import Path -tty = os.open('/dev/tty', os.O_RDWR) -assert os.isatty(tty) -report = dict(argv=sys.argv[1:], pane=os.environ['PARDES_PANE'], - socket=os.environ['PARDES_9P'], mount=os.environ['PARDES_MOUNT'], - path=os.environ['PARDES_V9FS_PATH'], launcher=os.getppid(), pid=os.getpid()) -parent_status = Path(f"/proc/{report['launcher']}/status").read_text().splitlines() -shell_pid = next(line.split()[1] for line in parent_status if line.startswith('PPid:')) -report['shell'] = os.readlink(f'/proc/{shell_pid}/exe') -Path(os.environ['V9FS_REPORT']).write_text(json.dumps(report)) -before = termios.tcgetattr(tty) -hidden = termios.tcgetattr(tty) -hidden[3] &= ~termios.ECHO -termios.tcsetattr(tty, termios.TCSANOW, hidden) -os.write(tty, b'V9FS_AUTH_READY: ') -response = os.read(tty, 100) -termios.tcsetattr(tty, termios.TCSANOW, before) -os.write(tty, b'V9FS_INPUT_RECEIVED\\n') -os.write(tty, b'sudo stand-in: authentication refused\\n') -sys.exit(1) -''') - sudo.chmod(0o700) - shells = [shutil.which('bash') or '/bin/sh', shutil.which('fish') or '/bin/sh'] - for shell, interrupted in zip(shells, (False, True)): - report_path = root / ('interrupted.json' if interrupted else 'normal.json') - path = str(root) + ':' + os.environ.get('PATH', '/usr/bin:/bin') - name = 'interrupted' if interrupted else 'normal' - with session(str(binary), root, name, inherited={ - 'PARDES_V9FS_HELPER': str(helper), 'PATH': path, - 'V9FS_REPORT': str(report_path), 'SHELL': shell, - }) as (client, address): - control = new_pane(client, b'') - execute(client, control, 'Shell ' + shell) - execute(client, control, 'Tty9p') - until(report_path.exists, 'Tty9p did not reach the sudo stand-in') - report = json.loads(report_path.read_text()) - pane = f"/pane/{report['pane']}" - until(lambda: b'V9FS_AUTH_READY' in client.read(pane + '/body'), 'prompt not visible') - assert report['socket'] == str(address) - assert report['argv'][:2] == ['-E', '--'], report - assert report['argv'][2] == str(helper), report - assert report['argv'][3] == str(address), report - assert report['argv'][4] == report['mount'], report - assert report['argv'][5:8] == [str(os.getuid()), str(os.getgid()), '--'], report - assert report['path'] == path - assert report['shell'] == str(Path(shell).resolve()), report - # The detached core remains responsive during authentication. - assert client.read('/pane/1/body') == b'initial\n' - target = Path(report['mount']) - assert target.is_dir() and list(target.iterdir()) == [] - if interrupted: - os.kill(report['launcher'], signal.SIGTERM) - else: - client.write(pane + '/pty/data', b'probe-response\r') - until(lambda: b'V9FS_INPUT_RECEIVED' in client.read(pane + '/body'), 'input did not reach new PTY') - assert b'probe-response' not in client.read(pane + '/body'), 'password input was echoed' - until(lambda: not target.exists(), 'launcher left its temporary mountpoint') - # Failure/cancellation returns to the original interactive - # shell, so the pane is useful and its errors remain visible. - client.write(pane + '/pty/data', b'printf "OUTER_READY:%s\\n" "$PARDES_PANE"\r') - expected = ('OUTER_READY:' + report['pane']).encode() - until(lambda: expected in client.read(pane + '/body'), 'original shell did not remain usable') - assert client.read('/pane/1/body') == b'initial\n' - print('Tty9p: shell-first startup, quoted paths, hidden password input, failure recovery and cleanup passed') - - -if __name__ == '__main__': - test(Path(sys.argv[1]).resolve(), Path(sys.argv[2]).resolve()) |
