summaryrefslogtreecommitdiff
path: root/test/daemon.py
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-29 10:48:56 -0300
committerGabriel Schneider <[email protected]>2026-10-29 12:01:27 -0300
commit4ffe5c93b3087f245f5b57a822ab0ecf41cc085c (patch)
treeede4d5de12fe169838f1f5993a9896bd32f45715 /test/daemon.py
parentcb2a6cd79e443d671f5255d262ea79b7e26552a5 (diff)
downloadpardes-4ffe5c93b3087f245f5b57a822ab0ecf41cc085c.tar.gz
pardes-4ffe5c93b3087f245f5b57a822ab0ecf41cc085c.zip
sessions register with the daemon: a terminal's session forked off its stub, Detach and --attach in place for terminals and windows, pty masters kept, Adopt
pardes in a terminal reaches (or starts) the daemon, opens /dev/tty and forks: the child is the session, in a session of its own (setsid), drawing on that terminal (tty.Term.fd, a raw vaxis Tty made from the fd); the parent stays as its stub, the job the shell waits on. Not the daemon spawning it from a passed fd, env and argv: the user's terminals each run in a 9ns user and mount namespace, which a session spawned by a per-user daemon would not share, and a fork costs one small process's page tables where the spawn cost an IPC and an exec. GUI windows and --detach sessions just register. tty: Detach (and a terminal's end: EOF, EIO, a hangup the stub passes on, taken on the signal thread) puts the terminal back, drops it and the stub's stdio, tells the stub (which ends, exit 0), and leaves the session running with nothing drawn (Host.watched), its messages on the clock and `size` its own. pardes --attach[=name] hands its terminal through the daemon; the session enters it as the first one, sized, queried and drawn whole, and that process is its stub until it leaves. A hangup never ends a kept session; TERM and INT do, telling the daemon so the shells go with it (one async-signal-safe send). gui: Detach closes the window (its swapchain or renderer) and keeps the device, atlas and pipelines; the loop sleeps on SDL's queue; pardes-gui --attach[=name] opens a window again. Closing a window still quits. --detach is a session started detached: the tty host with no terminal yet, the GUI with a hidden window closed at once. forkShell sends the daemon a dup of every master and the hosts tell it what they close, so a session killed outright leaves its shells running; the new Adopt word takes them in as terminal panes (the Tty word's pane, its spawn taking the pty, a 1x1 size then the pane's to make it redraw). The Attach word, which switched a session's own terminal to a detached session through the frames, goes, with its effect and request in the core. PARDES_DAEMON=off (the e2e harness's) runs a session as before. test/daemon.py: 50 detach/attach cycles at a level fd count with no stale socket, kill -9 and Adopt, and nothing left; --gui the same for a window. test/fs.py: a forked session's socket is found by its own pid, and a hangup leaves a kept session running. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'test/daemon.py')
-rw-r--r--test/daemon.py322
1 files changed, 322 insertions, 0 deletions
diff --git a/test/daemon.py b/test/daemon.py
new file mode 100644
index 00000000..bf3d237c
--- /dev/null
+++ b/test/daemon.py
@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""The per-user daemon end to end (docs/next-daemon.md, phase 3), under a
+private HOME and runtime directory:
+
+- a terminal's session detached (the stub ends, exit 0) and attached again
+ from another terminal, N times;
+- a session killed outright: its shells live on, held by the daemon, and
+ another session adopts them as terminal panes;
+- nothing left behind: no session, shell, daemon or socket.
+
+ python3 -B test/daemon.py <pardes> [cycles]
+ python3 -B test/daemon.py --gui <pardes-gui> [cycles] (a hidden window;
+ needs a Wayland display, and a pardes beside it for the refusal)
+"""
+import fcntl
+import os
+import shutil
+import signal
+import struct
+import subprocess
+import sys
+import tempfile
+import termios
+import threading
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from ninep import Client # noqa: E402
+
+
+def wait_for(what, check, timeout=10):
+ deadline = time.monotonic() + timeout
+ while True:
+ got = check()
+ if got:
+ return got
+ if time.monotonic() > deadline:
+ raise TimeoutError(what)
+ time.sleep(.01)
+
+
+class Term:
+ """A terminal: a pty whose other end is read and kept, its frame
+ requests answered (CSI 5 n), as a terminal emulator does."""
+
+ def __init__(self, rows=24, cols=80):
+ self.master, self.slave = os.openpty()
+ fcntl.ioctl(self.slave, termios.TIOCSWINSZ, struct.pack('HHHH', rows, cols, 0, 0))
+ self.out = bytearray()
+ self.lock = threading.Lock()
+ self.reader = threading.Thread(target=self.drain, daemon=True)
+ self.reader.start()
+
+ def drain(self):
+ while True:
+ try:
+ got = os.read(self.master, 65536)
+ except OSError:
+ return
+ if not got:
+ return
+ with self.lock:
+ self.out += got
+ if b'\x1b[5n' in got:
+ try:
+ os.write(self.master, b'\x1b[0n')
+ except OSError:
+ return
+
+ def spawn(self, argv, env):
+ slave = self.slave
+ return subprocess.Popen(argv, env=env, stdin=slave, stdout=slave, stderr=slave,
+ start_new_session=True,
+ preexec_fn=lambda: fcntl.ioctl(0, termios.TIOCSCTTY, 0))
+
+ def text(self):
+ with self.lock:
+ return bytes(self.out)
+
+ def close(self):
+ os.close(self.slave)
+ os.close(self.master)
+ self.reader.join(timeout=2)
+
+
+def run(client, serial, line):
+ """pty/run: a line in, `exit N` and its output out."""
+ fid = client.open(f'/pane/{serial}/pty/run', 2)
+ try:
+ client.rpc(118, struct.pack('<IQI', fid, 0, len(line)) + line)
+ return client.read_fid(fid)
+ finally:
+ client.close(fid)
+
+
+def processes(root):
+ """The pids whose environment is this run's (its runtime directory)."""
+ found = []
+ mark = f'XDG_RUNTIME_DIR={root}'.encode()
+ for entry in os.listdir('/proc'):
+ if not entry.isdigit():
+ continue
+ try:
+ environ = open(f'/proc/{entry}/environ', 'rb').read().split(b'\0')
+ except OSError:
+ continue
+ if mark in environ:
+ found.append(int(entry))
+ return found
+
+
+def cmdline(pid):
+ try:
+ return open(f'/proc/{pid}/cmdline', 'rb').read().split(b'\0')
+ except OSError:
+ return []
+
+
+def alive(pid):
+ try:
+ os.kill(pid, 0)
+ except ProcessLookupError:
+ return False
+ try:
+ state = open(f'/proc/{pid}/stat').read().rsplit(')', 1)[1].split()[0]
+ except OSError:
+ return False
+ return state != 'Z'
+
+
+def fds(pid):
+ try:
+ return len(os.listdir(f'/proc/{pid}/fd'))
+ except OSError:
+ return -1
+
+
+def terminals(client):
+ return [int(row.split()[0]) for row in client.read('/index').splitlines() if row.split()[1] == b'term']
+
+
+def main(binary, cycles):
+ scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn'
+ scratch.mkdir(parents=True, exist_ok=True)
+ root = Path(tempfile.mkdtemp(prefix='rt-', dir=scratch))
+ env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_') and 'PAGER' not in k}
+ env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), XDG_CONFIG_HOME=str(root / 'config'),
+ TERM='xterm-256color', SHELL='/bin/bash', PARDES_NOTIME='1')
+ (root / 'config' / 'pardes').mkdir(parents=True)
+ (root / 'config' / 'pardes' / 'init').write_text('Shell bash\nMessageLinger 0\n')
+ daemon_sock = root / 'pardes-daemon.sock'
+ started = []
+ try:
+ term = Term()
+ stub = term.spawn([binary, '--tty', '--9p=work'], env)
+ started.append(stub.pid)
+ sock = root / 'pardes-9p-work.sock'
+ wait_for('the session\'s 9P socket', sock.exists)
+ client = Client(sock)
+ status = dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())
+ session = int(status['pid'])
+ started.append(session)
+ assert session != stub.pid, 'the session is forked off its stub'
+ assert daemon_sock.exists(), list(root.iterdir())
+ daemons = [p for p in processes(root) if cmdline(p)[1:2] == [b'--daemon']]
+ assert len(daemons) == 1, [cmdline(p) for p in processes(root)]
+ daemon = daemons[0]
+ started.append(daemon)
+ shell = terminals(client)[0]
+ shell_pid = int(run(client, shell, b'echo $$\n').split(b'\n')[1])
+ started.append(shell_pid)
+ baseline = None
+ for cycle in range(cycles):
+ client.write(f'/pane/{shell}/exec', b'Detach\n')
+ assert stub.wait(timeout=10) == 0, stub.returncode
+ said = term.text()
+ assert b'detached from \'work\'' in said, said[-400:]
+ assert b'\x1b[?1049l' in said, 'the terminal is put back'
+ term.close()
+ assert alive(session) and alive(shell_pid)
+ assert run(client, shell, b'echo still\n').startswith(b'exit 0\nstill'), 'the shell runs on, detached'
+ term = Term(30, 100)
+ stub = term.spawn([binary, '--attach=work'], env)
+ wait_for('the attached terminal\'s first frame', lambda: b'\x1b[?1049h' in term.text())
+ wait_for('the session sized to its new terminal',
+ lambda: client.screen()['cols'] == 100 and client.screen()['rows'] == 30)
+ now = (fds(session), fds(daemon), len(list(root.iterdir())), len(processes(root)))
+ if baseline is None:
+ baseline = now
+ assert now == baseline, (cycle, now, baseline)
+ print(f'daemon: {cycles} detach/attach cycles, fds/sockets/processes level: {baseline}')
+
+ # Killed outright: its shells live on, their masters the daemon's.
+ os.kill(session, signal.SIGKILL)
+ stub.wait(timeout=10)
+ client.socket.close()
+ term.close()
+ wait_for('the killed session gone', lambda: not alive(session))
+ time.sleep(.3)
+ assert alive(shell_pid), 'a killed session\'s shell is not hung up'
+ assert alive(daemon)
+ term = Term()
+ stub = term.spawn([binary, '--tty', '--9p=fresh'], env)
+ started.append(stub.pid)
+ sock = root / 'pardes-9p-fresh.sock'
+ wait_for('the second session', sock.exists)
+ client = Client(sock)
+ status = dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())
+ session = int(status['pid'])
+ started.append(session)
+ before = set(terminals(client))
+ client.write(f'/pane/{min(before)}/exec', b'Adopt\n')
+ adopted = wait_for('the adopted pane', lambda: set(terminals(client)) - before)
+ pane = adopted.pop()
+ said = run(client, pane, b'echo $$\n')
+ assert said.split(b'\n')[1] == str(shell_pid).encode(), said
+ print(f'daemon: shell {shell_pid} outlived kill -9 of its session and was adopted')
+
+ # The end: the session quits, its shells hang up, the daemon goes.
+ client.write(f'/pane/{pane}/exec', b'Exit\n')
+ stub.wait(timeout=10)
+ client.socket.close()
+ term.close()
+ wait_for('the adopted shell hung up', lambda: not alive(shell_pid))
+ wait_for('the daemon gone once idle', lambda: not alive(daemon), timeout=5)
+ left = [p for p in processes(root) if alive(p)]
+ assert not left, [cmdline(p) for p in left]
+ sockets = [p.name for p in root.iterdir() if p.is_socket()]
+ assert not sockets, sockets
+ print('daemon: nothing left behind')
+ finally:
+ for pid in started + processes(root):
+ try:
+ os.kill(pid, signal.SIGKILL)
+ except OSError:
+ pass
+ shutil.rmtree(root, ignore_errors=True)
+
+
+def sized(client):
+ """Whether the session takes a `size`: only with no window or terminal."""
+ try:
+ client.write('/ctl', b'size 100 30\n')
+ return True
+ except OSError:
+ return False
+
+
+def gui(binary, cycles):
+ """A window's Detach closes it and keeps the process; `pardes-gui
+ --attach` opens it again. Test mode: a hidden window, its stdin the
+ test feed."""
+ scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn'
+ root = Path(tempfile.mkdtemp(prefix='rtg-', dir=scratch))
+ env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_') and 'PAGER' not in k}
+ display = Path(os.environ.get('WAYLAND_DISPLAY', 'wayland-0'))
+ if not display.is_absolute():
+ display = Path(os.environ.get('XDG_RUNTIME_DIR', f'/run/user/{os.getuid()}')) / display
+ (root / 'caps').mkdir()
+ env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), XDG_CONFIG_HOME=str(root / 'config'),
+ SHELL='/bin/bash', PARDES_NOTIME='1', PARDES_TEST='1', PARDES_TEST_CAPTURE_DIR=str(root / 'caps'),
+ SDL_VIDEODRIVER='wayland', WAYLAND_DISPLAY=str(display), PARDES_DAEMON='on')
+ (root / 'config' / 'pardes').mkdir(parents=True)
+ (root / 'config' / 'pardes' / 'init').write_text('Shell bash\nMessageLinger 0\n')
+ feed_r, feed_w = os.pipe()
+ proc = subprocess.Popen([binary, '--9p=win'], env=env, cwd=root, stdin=feed_r,
+ stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+ os.close(feed_r)
+ try:
+ sock = root / 'pardes-9p-win.sock'
+ wait_for('the window session', sock.exists, timeout=20)
+ client = Client(sock)
+ shell = terminals(client)[0]
+ assert not sized(client), 'a window owns the size'
+ baseline = None
+ for cycle in range(cycles):
+ client.write(f'/pane/{shell}/exec', b'Detach\n')
+ wait_for('the window closed', lambda: sized(client))
+ assert proc.poll() is None, 'the process carries on with no window'
+ attach = subprocess.run([binary, '--attach=win'], env=env, cwd=root, timeout=10,
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ assert attach.returncode == 0, attach.stderr
+ wait_for('the window open again', lambda: not sized(client))
+ now = (fds(proc.pid), len(processes(root)))
+ baseline = baseline or now
+ assert now == baseline, (cycle, now, baseline)
+ print(f'daemon: {cycles} window detach/attach cycles, fds/processes level: {baseline}')
+ # Another kind is refused in words, and so is a name nobody has.
+ client.write(f'/pane/{shell}/exec', b'Detach\n')
+ wait_for('the window closed', lambda: sized(client))
+ term = Term()
+ tty_attach = term.spawn([binary.replace('pardes-gui', 'pardes'), '--attach=win'], env)
+ assert tty_attach.wait(timeout=10) == 1
+ said = term.text()
+ term.close()
+ assert b'is a window' in said, said
+ nobody = subprocess.run([binary, '--attach=nobody'], env=env, cwd=root, timeout=10,
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ assert nobody.returncode == 1 and b"no session called 'nobody'" in nobody.stderr, nobody.stderr
+ # Detached and told to end: it ends.
+ client.write(f'/pane/{shell}/exec', b'Exit\n')
+ proc.wait(timeout=10)
+ client.socket.close()
+ wait_for('the daemon gone once idle', lambda: not [p for p in processes(root) if alive(p)], timeout=5)
+ print('daemon: window session ended, nothing left behind')
+ finally:
+ os.close(feed_w)
+ for pid in [proc.pid] + processes(root):
+ try:
+ os.kill(pid, signal.SIGKILL)
+ except OSError:
+ pass
+ shutil.rmtree(root, ignore_errors=True)
+
+
+if __name__ == '__main__':
+ if '--gui' in sys.argv:
+ args = [a for a in sys.argv[1:] if a != '--gui']
+ gui(args[0], int(args[1]) if len(args) > 1 else 50)
+ else:
+ main(sys.argv[1], int(sys.argv[2]) if len(sys.argv) > 2 else 50)