diff options
Diffstat (limited to 'test/daemon.py')
| -rw-r--r-- | test/daemon.py | 322 |
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) |
