#!/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; - a replica's hello on the daemon's stream socket (phase 5): one of this build handed to its session, which welcomes it, sends its dump and answers its pings; another build's refused, and a session nobody has; - replica clients (`pardes --attach=:`, phase 5 part B) of a detached session, one through the delay relay: each one's keys in the session's text, every client's digest the session's once quiet, one killed outright while the other types on; - nothing left behind: no session, shell, daemon or socket. python3 -B test/daemon.py [cycles] python3 -B test/daemon.py --gui [cycles] (a hidden window; needs a Wayland display, and a pardes beside it for the refusal) python3 -B test/daemon.py --ping [n] a hello of 's build and n pings on a replica socket (one `ssh -L` forwards, say), timed python3 -B test/daemon.py --clients the replica clients alone python3 -B test/daemon.py --far the far clients and their blob cache alone python3 -B test/daemon.py --window-clients window replica clients (hidden, offscreen) of a terminal's session, at 0/30/80/207 ms, and a window's session serving replicas """ import fcntl import os import re import select import shutil import signal import socket import statistics 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.closing = False self.tail = b'' self.reader = threading.Thread(target=self.drain, daemon=True) self.reader.start() def drain(self): # Never blocked in a read when `close` comes: a master closed under a # read stays open until it returns, so the terminal would not hang # up, and its fd's number, taken again, would be read here. while not self.closing: try: if not select.select([self.master], [], [], 0.05)[0]: continue got = os.read(self.master, 65536) except OSError: return if not got: return with self.lock: self.out += got # A request split across two reads is answered too. seen, self.tail = self.tail + got, got[-3:] if b'\x1b[5n' in seen: 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): self.closing = True self.reader.join(timeout=2) os.close(self.slave) os.close(self.master) 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(' t.rfind(b'\x1b[6 q') def agreed(path, after): """A check after the first `after` agreed; one that differed fails.""" lines = checks(path) bad = [line for line in lines if line.startswith('differ')] assert not bad, (path.name, bad) return len(lines) > after def made_live(term, check): """A key in a replica client's terminal (`gg`), stepped by its session (a check after it agreed): its view is the live one, the one /layout reads and /exec runs in, until the next input. A client asks one check at a time, and checks come on (each answer wakes its session): the first after the key may have been asked before it, the second was not.""" seen = len(checks(check)) os.write(term.master, b'gg') wait_for('the client\'s key stepped', lambda: agreed(check, seen + 1), timeout=20) def view_panes(client): """The panes the live view lays out (/layout's pane serials).""" return {int(x) for line in client.read('/layout').decode().splitlines() if line.split()[:1] != ['active'] for x in line.split()[6:]} def clients(binary): """Replica clients of a detached session: one on the replica socket, one through the delay relay; each one's keys in the session's text and every client's digest the session's once quiet; one killed outright while the other types on; nothing left behind.""" scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn' scratch.mkdir(parents=True, exist_ok=True) root = Path(tempfile.mkdtemp(prefix='rc-', 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=shutil.which('bash') or '/bin/bash', PARDES_NOTIME='1') (root / 'config' / 'pardes').mkdir(parents=True) (root / 'config' / 'pardes' / 'init').write_text('Shell bash\nMessageLinger 0\n') notes = root / 'notes.txt' notes.write_text(''.join(f'line {i} of the notes\n' for i in range(300))) started = [] terms = [] try: sess = subprocess.Popen([binary, '--detach=files', str(notes)], env=env, cwd=root, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True) started.append(sess.pid) sock = root / 'pardes-replica.sock' wait_for('the replica socket', sock.exists) wait_for('the session\'s 9P socket', (root / 'pardes-9p-files.sock').exists) nine = Client(root / 'pardes-9p-files.sock') pane = next(int(row.split()[0]) for row in nine.read('/index').splitlines() if row.split()[1] == b'text') alone = fds(sess.pid) relay = subprocess.Popen([sys.executable, '-B', str(Path(__file__).parent / 'delay_relay.py'), str(root / 'relay.sock'), str(sock), '--delay', '40'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) started.append(relay.pid) wait_for('the relay', (root / 'relay.sock').exists) ta, tb = Term(30, 100), Term(24, 80) terms += [ta, tb] a = ta.spawn([binary, f'--attach={sock}:files'], dict(env, PARDES_REPLICA_CHECK=str(root / 'a.check'))) b = tb.spawn([binary, f'--attach={root / "relay.sock"}:files'], dict(env, PARDES_REPLICA_CHECK=str(root / 'b.check'))) started += [a.pid, b.pid] for t in (ta, tb): wait_for('a client\'s first frame', lambda: b'line 3 of the notes' in t.text(), timeout=20) os.write(ta.master, b'Ofrom-A\x1b') os.write(tb.master, b'jjofrom-B\x1b') wait_for('both clients\' keys in the session\'s text', lambda: b'from-A' in nine.read(f'/pane/{pane}/body') and b'from-B' in nine.read(f'/pane/{pane}/body')) wait_for('both clients out of insert mode', lambda: normal_again(ta) and normal_again(tb)) wait_for('client A agrees once quiet', lambda: agreed(root / 'a.check', 0)) wait_for('client B agrees once quiet', lambda: agreed(root / 'b.check', 0)) # A terminal attached while a client's view is live (its input the # last): it takes the session's own and is drawn. tt = Term(24, 80) terms.append(tt) stub = tt.spawn([binary, '--attach=files'], env) started.append(stub.pid) wait_for('the attached terminal\'s frame', lambda: b'line 3 of the notes' in tt.text(), timeout=20) stub.send_signal(signal.SIGHUP) stub.wait(timeout=10) # One put off the session's state (PARDES_TEST_DIVERGE, at its # 100th unit): the next unit's digest finds it, it says so in a line # and joins again for its view, a pane of its own in it, its keys # after go into that pane and it agrees. td = Term(24, 90) terms.append(td) d = td.spawn([binary, f'--attach={sock}:files'], dict(env, PARDES_REPLICA_CHECK=str(root / 'd.check'), PARDES_TEST_DIVERGE='100')) started.append(d.pid) wait_for('client D\'s first frame', lambda: b'line 3 of the notes' in td.text(), timeout=20) made_live(td, root / 'd.check') shown = view_panes(nine) nine.write('/exec', b'New\n') mine = wait_for('a pane in client D\'s view', lambda: view_panes(nine) - shown).pop() # Others' units, replayed on D's core: one after its 100th finds it. deadline = time.monotonic() + 60 while b'joined again' not in td.text(): assert time.monotonic() < deadline, 'client D diverged and joined again' os.write(ta.master, b'jk') time.sleep(.2) assert d.poll() is None made_live(td, root / 'd.check') assert mine in view_panes(nine), ('client D in its own view again', mine, nine.read('/layout')) seen = len(checks(root / 'd.check')) os.write(td.master, b'Oafter-rejoin-D\x1b') wait_for('client D\'s keys after its rejoin', lambda: b'after-rejoin-D' in nine.read(f'/pane/{mine}/body')) wait_for('client D out of insert mode', lambda: normal_again(td)) wait_for('client D agrees after its rejoin', lambda: agreed(root / 'd.check', seen)) os.write(td.master, b' sD') wait_for('client D let go', lambda: d.poll() is not None, timeout=10) # Killed outright: the session and the other client carry on. os.kill(b.pid, signal.SIGKILL) b.wait(timeout=10) seen = len(checks(root / 'a.check')) os.write(ta.master, b'jjjAagain-A\x1b') wait_for('client A\'s keys after B went', lambda: b'again-A' in nine.read(f'/pane/{pane}/body')) wait_for('client A out of insert mode', lambda: normal_again(ta)) wait_for('client A agrees again', lambda: agreed(root / 'a.check', seen)) assert sess.poll() is None # Detach typed in it: it alone goes. os.write(ta.master, b' sD') wait_for('client A let go', lambda: a.poll() is not None, timeout=10) assert b'let this client go' in ta.text(), ta.text()[-300:] # A third client, a shell: its keys wait for the session (a pty # write), its output comes back in units, the same on both sides. nine.write(f'/pane/{pane}/exec', b'Term\n') shell = wait_for('a shell pane', lambda: next((int(row.split()[0]) for row in nine.read('/index').splitlines() if row.split()[1] == b'term'), None)) wait_for('the shell\'s prompt', lambda: b'$' in nine.read(f'/pane/{shell}/body') or b'#' in nine.read(f'/pane/{shell}/body')) alone = fds(sess.pid) tc = Term(30, 100) terms.append(tc) c = tc.spawn([binary, f'--attach={sock}:files'], dict(env, PARDES_REPLICA_CHECK=str(root / 'c.check'))) started.append(c.pid) wait_for('client C\'s first frame', lambda: b'$' in tc.text(), timeout=20) run(nine, shell, b'echo from-the-session\n') os.write(tc.master, b'echo from-C\r') wait_for('client C\'s keys in the shell', lambda: b'from-C' in nine.read(f'/pane/{shell}/body')) wait_for('client C agrees with a shell\'s output', lambda: agreed(root / 'c.check', 0)) # Its terminal hung up: it dies, and the session carries on. c.send_signal(signal.SIGHUP) c.wait(timeout=10) relay.kill() relay.wait() wait_for('the session\'s fds level', lambda: fds(sess.pid) == alone, timeout=10) print(f'daemon: two replica clients (one through a 40 ms relay) typed into a detached session; ' f'digests agreed {len(checks(root / "a.check"))} and {len(checks(root / "b.check"))} times; ' f'one put off the session\'s state joined again in its own view and agreed {len(checks(root / "d.check"))} times; ' f'one killed, the other typed on and detached; a third typed into a shell, agreed ' f'{len(checks(root / "c.check"))} times, and was hung up') exit_session(nine, pane) sess.wait(timeout=10) nine.socket.close() wait_for('nothing left', lambda: not [p for p in processes(root) if alive(p)], timeout=10) print('daemon: replica clients\' session ended, nothing left behind') finally: for t in terms: t.close() for pid in started + processes(root): try: os.kill(pid, signal.SIGKILL) except OSError: pass shutil.rmtree(root, ignore_errors=True) def manage(binary): """`pardes --ps`, `--kill=NAME` and `--kill-all`: two detached sessions and their shells listed, one session killed outright and its shell listed as no one's, the other ended by name with its shell, a name no session has refused, the kept shell ended by --kill-all, and the daemon gone after it.""" scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn' scratch.mkdir(parents=True, exist_ok=True) root = Path(tempfile.mkdtemp(prefix='rm-', 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=shutil.which('bash') or '/bin/bash', PARDES_NOTIME='1') (root / 'config' / 'pardes').mkdir(parents=True) (root / 'config' / 'pardes' / 'init').write_text('Shell bash\nMessageLinger 0\n') def cli(*args): return subprocess.run([binary, *args], env=env, cwd=root, capture_output=True, timeout=30) started = [] try: sessions, shells = {}, {} for name in ('one', 'two'): (root / f'{name}.txt').write_text(f'{name}\n') started.append(subprocess.Popen([binary, f'--detach={name}', str(root / f'{name}.txt')], env=env, cwd=root, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True).pid) sock = root / f'pardes-9p-{name}.sock' wait_for(f'session {name}\'s 9P socket', sock.exists) with Client(sock) as c: status = dict(line.split(maxsplit=1) for line in c.read('/status').decode().splitlines()) sessions[name] = int(status['pid']) started.append(sessions[name]) c.write('/pane/1/exec', b'Term\n') wait_for(f'session {name}\'s shell', lambda: terminals(c)) shell = terminals(c)[0] wait_for(f'session {name}\'s shell answers', lambda: run(c, shell, b'true\n') == b'exit 0\n') shells[name] = int(run(c, shell, b'echo $$\n').split(b'\n')[1]) started.append(shells[name]) daemon = [p for p in processes(root) if cmdline(p)[1:2] == [b'--daemon']][0] started.append(daemon) out = cli('--ps') assert out.returncode == 0, out listed = out.stdout.decode() assert f'pardes daemon {daemon}' in listed, listed for name in ('one', 'two'): assert f'session {name} {sessions[name]} (tty, detached)' in listed, listed assert f'shell {shells[name]}' in listed, listed # The same, a record a line, in each session's /sessions. with Client(root / 'pardes-9p-one.sock') as c: records = c.read('/sessions').decode().splitlines() assert records[0] == f'daemon {daemon}', records for name in ('one', 'two'): at = records.index(f'session {sessions[name]} tty detached {name}') assert records[at + 1] == f'shell {shells[name]}', records print('manage: /sessions read over 9P listed the daemon, both sessions and their shells') os.kill(sessions['two'], signal.SIGKILL) wait_for('session two gone', lambda: not alive(sessions['two'])) wait_for('its shell no session\'s', lambda: 'no session holds' in cli('--ps').stdout.decode()) listed = cli('--ps').stdout.decode() assert 'session two' not in listed and listed.index(f'shell {shells["two"]}') > listed.index('no session holds'), listed assert alive(shells['two']) print('manage: --ps listed two sessions and their shells, then a killed one\'s shell as no one\'s') refused = cli('--kill=nobody') assert refused.returncode == 1 and b"no session called 'nobody'" in refused.stderr, refused killed = cli('--kill=one') assert killed.returncode == 0, killed assert not alive(sessions['one']) wait_for('session one\'s shell hung up with it', lambda: not alive(shells['one'])) assert alive(shells['two']) and 'session one' not in cli('--ps').stdout.decode() assert cli('--kill-all').returncode == 0 wait_for('the kept shell ended', lambda: not alive(shells['two'])) wait_for('the daemon gone once it keeps nothing', lambda: not alive(daemon)) none = cli('--ps') assert none.returncode == 1 and b'no pardes daemon is running' in none.stderr, none print('manage: --kill=one ended it and its shell, --kill-all the kept shell, a name nobody has refused; the daemon left') finally: for pid in started + processes(root): try: os.kill(pid, signal.SIGKILL) except (ProcessLookupError, PermissionError): pass shutil.rmtree(root, ignore_errors=True) class Window: """A pardes-gui in test mode, its window offscreen and hidden, its keys written to its stdin (the test feed: Escape as `CSI 27 u`, which a pipe's lone ESC would hold for the next key).""" def __init__(self, root, name, argv, env): (root / name).mkdir() self.err = root / f'{name}.err' self.p = subprocess.Popen(argv, env=dict(env, PARDES_TEST='1', PARDES_TEST_CAPTURE_DIR=str(root / name), SDL_VIDEO_DRIVER='offscreen'), cwd=root, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=open(self.err, 'w'), start_new_session=True) self.pid = self.p.pid def keys(self, text): self.p.stdin.write(text.replace(b'\x1b', b'\x1b[27u')) self.p.stdin.flush() def mouse(self, kind, button, x, y): """A pointer event at window pixels (gui.zig's test feed).""" self.p.stdin.write(f'\x1b]777;mouse;{kind};{button};{x};{y}\x07'.encode()) self.p.stdin.flush() def said(self): return self.err.read_text(errors='replace') if self.err.exists() else '' def close(self): if self.p.poll() is None: self.p.stdin.close() self.p.wait(timeout=15) return self.p.returncode def sessions_listed(binary, env, root): """`pardes --ps`'s session lines, each `[name, pid, (kind, state)]`.""" out = subprocess.run([binary, '--ps'], env=env, cwd=root, capture_output=True, timeout=30) assert out.returncode == 0, out rows = [line.split(maxsplit=3)[1:] for line in out.stdout.decode().splitlines() if line.lstrip().startswith('session ')] return [[name, pid, rest] for name, pid, rest in rows] def pdf_window(binary, gui_binary): """A PDF in a terminal's detached session (the pdf addon its prefix installs, `/lib/pardes/addons/pdf.so`), a window client attached and its wheel turned over the PDF: the session's page moves, the window's digest is the session's, and the window, which runs no addon code, draws the session's frames of it. Skipped when the build has no pdf.so.""" lib = Path(binary).resolve().parent.parent / 'lib' / 'pardes' / 'addons' / 'pdf.so' if not lib.exists(): print(f'daemon: no {lib}: the PDF window case skipped') return scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn' scratch.mkdir(parents=True, exist_ok=True) root = Path(tempfile.mkdtemp(prefix='pdfw-', dir=os.environ.get('TMPDIR') or 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=shutil.which('bash') or '/bin/bash', PARDES_NOTIME='1') env.pop('XDG_DATA_HOME', None) (root / 'config' / 'pardes').mkdir(parents=True) (root / 'config' / 'pardes' / 'init').write_text('Shell bash\nMessageLinger 0\n') doc = root / 'design.pdf' shutil.copy(Path(__file__).resolve().parent.parent / 'docs' / 'design.pdf', doc) notes = root / 'notes.txt' notes.write_text('notes\n') started = [] try: sess = subprocess.Popen([binary, '--detach=pdf', str(notes)], env=env, cwd=root, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True) started.append(sess.pid) sock = root / 'pardes-replica.sock' wait_for('the replica socket', sock.exists) wait_for('the session\'s 9P socket', (root / 'pardes-9p-pdf.sock').exists) nine = Client(root / 'pardes-9p-pdf.sock') assert any(row.startswith(b'pdf ') for row in nine.read('/addons').splitlines()), nine.read('/addons') nine.write('/look', f'{doc}\n'.encode()) pdf = next(int(row.split()[0]) for row in nine.read('/index').splitlines() if row.split()[1] == b'pdf') for row in nine.read('/index').splitlines(): if row.split()[1] == b'text': nine.write(f'/pane/{int(row.split()[0])}/ctl', b'Del\n') def page(): # A kind's prefix is its last frame's: one drawn first. nine.read('/screen') tag = nine.read(f'/pane/{pdf}/tag') return int(tag[1:tag.index(b'/')]) if tag.startswith(b'[') else 0 wait_for('the PDF at its first page', lambda: page() == 1) check = root / 'w.check' w = Window(root, 'w', [gui_binary, '--attach=' + str(sock) + ':pdf'], dict(env, PARDES_REPLICA_CHECK=str(check))) started.append(w.pid) wait_for('the window client agrees', lambda: agreed(check, 0), timeout=30) for _ in range(60): w.mouse('wheel', -3, 400, 400) time.sleep(0.02) wait_for('the session\'s PDF past its first page', lambda: page() > 1, timeout=30) n = len(checks(check)) wait_for('the window client agrees after the wheel', lambda: agreed(check, n), timeout=30) assert w.close() == 0, w.said()[-800:] print(f'daemon: a PDF in a detached session, a window client\'s wheel over it: the session at page {page()}, ' f'the window\'s digest the session\'s {len(checks(check))} times') exit_session(nine, pdf) sess.wait(timeout=10) nine.socket.close() finally: for pid in started: try: os.killpg(pid, signal.SIGKILL) except (ProcessLookupError, PermissionError): pass shutil.rmtree(root, ignore_errors=True) def window_clients(binary, gui_binary): """Window replica clients (`pardes-gui --attach=:`): of a terminal's detached session, directly and through the delay relay at 30, 80 and 207 ms, beside a terminal's client, one put off the session's state that joins again, one that detaches; and a window's session served to a terminal's client and a window's. Each one's keys in the session's text, every client's digest the session's once quiet; nothing left.""" scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn' scratch.mkdir(parents=True, exist_ok=True) root = Path(tempfile.mkdtemp(prefix='wc-', dir=os.environ.get('TMPDIR') or 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=shutil.which('bash') or '/bin/bash', PARDES_NOTIME='1') (root / 'config' / 'pardes').mkdir(parents=True) (root / 'config' / 'pardes' / 'init').write_text('Shell bash\nMessageLinger 0\n') notes = root / 'notes.txt' notes.write_text(''.join(f'line {i} of the notes\n' for i in range(300))) started = [] terms = [] windows = [] try: sess = subprocess.Popen([binary, '--detach=files', str(notes)], env=env, cwd=root, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True) started.append(sess.pid) sock = root / 'pardes-replica.sock' wait_for('the replica socket', sock.exists) wait_for('the session\'s 9P socket', (root / 'pardes-9p-files.sock').exists) nine = Client(root / 'pardes-9p-files.sock') pane = next(int(row.split()[0]) for row in nine.read('/index').splitlines() if row.split()[1] == b'text') body = lambda: nine.read(f'/pane/{pane}/body') # A terminal's client beside the windows, typing as they do. ta = Term(30, 100) terms.append(ta) a = ta.spawn([binary, f'--attach={sock}:files'], dict(env, PARDES_REPLICA_CHECK=str(root / 'a.check'))) started.append(a.pid) wait_for('the terminal client\'s first frame', lambda: b'line 3 of the notes' in ta.text(), timeout=30) agreements = [] for i, rtt in enumerate((0, 30, 80, 207)): to = sock relay = None if rtt: relay = subprocess.Popen([sys.executable, '-B', str(Path(__file__).parent / 'delay_relay.py'), str(root / f'relay{rtt}.sock'), str(sock), '--delay', str(rtt / 2)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) started.append(relay.pid) wait_for('the relay', (root / f'relay{rtt}.sock').exists) to = root / f'relay{rtt}.sock' check = root / f'w{rtt}.check' w = Window(root, f'w{rtt}', [gui_binary, f'--attach={to}:files'], dict(env, PARDES_REPLICA_CHECK=str(check))) windows.append(w) started.append(w.pid) seen = len(checks(root / 'a.check')) w.keys(b'jjjjjjj' * (i + 1) + f'Ofrom-window-{rtt}\x1b'.encode()) os.write(ta.master, b'jjjjOfrom-terminal-%d\x1b' % rtt) wait_for(f'the window\'s and the terminal\'s keys ({rtt} ms)', lambda: f'from-window-{rtt}'.encode() in body() and b'from-terminal-%d' % rtt in body(), timeout=30) wait_for('the terminal client normal again', lambda: normal_again(ta), timeout=20) wait_for(f'the window client agrees ({rtt} ms)', lambda: agreed(check, 0), timeout=30) wait_for('the terminal client agrees', lambda: agreed(root / 'a.check', seen), timeout=30) if not rtt: # Its clients are no sessions of the daemon's. listed = sessions_listed(binary, env, root) assert [(n, k) for n, _, k in listed] == [('files', '(tty, detached)')], listed # Moved and scrolled, its own view only: agreed again. n = len(checks(check)) w.keys(b'jjjjjkkk\x06\x06\x02') wait_for(f'the window client agrees again ({rtt} ms)', lambda: agreed(check, n), timeout=30) if rtt in (0, 207): # The pointer over the tags (the workspace's, the column's, # the pane's: the top rows, a test window's cells about 16 by # 33 pixels) and over the body, a click there: a window's # hits are its own frame's, which the session never draws, # so they are its input's, not re-made from a frame. Each # tag motion made it join again (the user's, 2026-10-30). n = len(checks(check)) for y in range(5, 170, 11): for x in range(4, 1280, 23): w.mouse('motion', 0, x, y) for k in range(40): w.mouse('motion', 0, 100 + 25 * k, 200 + 9 * k) w.mouse('down', 1, 400, 300) w.mouse('motion', 1, 600, 360) w.mouse('up', 1, 600, 360) wait_for(f'the window client agrees after its pointer ({rtt} ms)', lambda: agreed(check, n), timeout=30) assert 'joined again' not in w.said(), w.said()[-800:] agreements.append(len(checks(check))) assert w.close() == 0, w.said()[-800:] if relay: relay.kill() relay.wait() # One put off the session's state (PARDES_TEST_DIVERGE): the next # unit it replays finds it, it joins again, and its keys after go in. # Far (PARDES_REPLICA_FAR, as through ssh): its first join sent its # blobs by hash, in zstd; its rejoin finds them in the core it left. dcheck = root / 'wd.check' wd = Window(root, 'wd', [gui_binary, f'--attach={sock}:files'], dict(env, PARDES_REPLICA_CHECK=str(dcheck), PARDES_TEST_DIVERGE='1', PARDES_REPLICA_FAR='1', PARDES_REPLICA_STATS=str(root / 'wd.stats'), XDG_CACHE_HOME=str(root / 'wd-cache'))) windows.append(wd) started.append(wd.pid) time.sleep(2) wd.keys(b'jj') time.sleep(.5) os.write(ta.master, b'jj') wait_for('the window client diverged and joined again', lambda: 'joined again' in wd.said(), timeout=30) assert wd.p.poll() is None seen = len(checks(dcheck)) wd.keys(b'Oafter-rejoin-W\x1b') wait_for('the window\'s keys after its rejoin', lambda: b'after-rejoin-W' in body(), timeout=30) wait_for('the window client agrees after its rejoin', lambda: agreed(dcheck, seen), timeout=30) # An Upgrade (to the same build): the session lets it go in words # (`refused`), it dials again, joins, and its keys after go in. nine.write('/ctl', b'Upgrade\n') wait_for('the window client joined again after the upgrade', lambda: 'joined again: the session is upgrading' in wd.said(), timeout=60) nine.socket.close() nine = reconnect(root / 'pardes-9p-files.sock') seen = len(checks(dcheck)) wd.keys(b'jjjOafter-upgrade-W\x1b') wait_for('the window\'s keys after the upgrade', lambda: b'after-upgrade-W' in body(), timeout=30) wait_for('the window client agrees after the upgrade', lambda: agreed(dcheck, seen), timeout=30) assert wd.p.poll() is None # Detach typed in it: it alone goes, and says why. wd.keys(b' sD') wait_for('the window client let go', lambda: wd.p.poll() is not None, timeout=15) assert 'let this client go' in wd.said(), wd.said()[-500:] # A link a line: the first join sent every blob, its rejoins held them. links = joins(root / 'wd.stats') assert len(links) == 3 and links[0]['blobs'] > 0 and links[0]['from_memory'] + links[0]['from_disk'] == 0, links assert links[1]['from_memory'] == links[1]['blobs'] and links[1]['sent_kb'] == 0, links os.write(ta.master, b' sD') wait_for('the terminal client let go', lambda: a.poll() is not None, timeout=10) print(f'daemon: window clients of a terminal\'s session at 0/30/80/207 ms beside a terminal\'s, digests agreed ' f'{agreements} and {len(checks(root / "a.check"))} times; one put off the session\'s state joined again, ' f'joined again across an Upgrade, agreed {len(checks(dcheck))} times and detached (far: its joins {joins(root / "wd.stats")})') exit_session(nine, pane) sess.wait(timeout=10) nine.socket.close() # A window's session (its daemon on, as a desktop's is), served to a # terminal's client and a window's, the window typing as they do. win = Window(root, 'win', [gui_binary, '--9p=win', str(notes)], dict(env, PARDES_DAEMON='on')) windows.append(win) started.append(win.pid) wait_for('the window session\'s 9P socket', (root / 'pardes-9p-win.sock').exists, timeout=30) wait_for('the replica socket', sock.exists) nine = Client(root / 'pardes-9p-win.sock') pane = next(int(row.split()[0]) for row in nine.read('/index').splitlines() if row.split()[1] == b'text') tb = Term(30, 100) terms.append(tb) b = tb.spawn([binary, f'--attach={sock}:win'], dict(env, PARDES_REPLICA_CHECK=str(root / 'b.check'))) started.append(b.pid) wait_for('the terminal client\'s first frame', lambda: b'line 3 of the notes' in tb.text(), timeout=30) wg = Window(root, 'wg', [gui_binary, f'--attach={sock}:win'], dict(env, PARDES_REPLICA_CHECK=str(root / 'g.check'))) windows.append(wg) started.append(wg.pid) time.sleep(2) os.write(tb.master, b'jjjOfrom-T\x1b') wg.keys(b'jjjjjjOfrom-G\x1b') win.keys(b'jjjjjjjjjOfrom-W\x1b') wait_for('everyone\'s keys in the window\'s session', lambda: all(x in body() for x in (b'from-T', b'from-G', b'from-W')), timeout=30) wait_for('the terminal client normal again', lambda: normal_again(tb), timeout=20) for k in range(3): nb, ng = len(checks(root / 'b.check')), len(checks(root / 'g.check')) os.write(tb.master, b'jk') wg.keys(b'kj') win.keys(b'jj') wait_for('the terminal client agrees with the window', lambda: agreed(root / 'b.check', nb), timeout=30) wait_for('the window client agrees with the window', lambda: agreed(root / 'g.check', ng), timeout=30) listed = sessions_listed(binary, env, root) assert [(n, k) for n, _, k in listed] == [('win', '(gui, attached)')], listed assert wg.close() == 0, wg.said()[-800:] os.write(tb.master, b' sD') wait_for('the terminal client let go', lambda: b.poll() is not None, timeout=10) assert win.p.poll() is None print(f'daemon: a window\'s session served a terminal\'s client and a window\'s, digests agreed ' f'{len(checks(root / "b.check"))} and {len(checks(root / "g.check"))} times; --ps listed it alone, (gui, attached)') win.close() nine.socket.close() wait_for('nothing left', lambda: not [p for p in processes(root) if alive(p)], timeout=15) print('daemon: window clients\' sessions ended, nothing left behind') finally: for t in terms: t.close() for w in windows: if w.p.poll() is None: w.p.kill() for pid in started + processes(root): try: os.kill(pid, signal.SIGKILL) except OSError: pass shutil.rmtree(root, ignore_errors=True) def joins(path): """A replica client's joins (PARDES_REPLICA_STATS, a line a link): how many blobs each listed, how many it held already from the core it left and from disk, and the KB it was sent.""" out = [] for line in checks(path): words = line.split() if 'blobs' not in words: continue got = {words[i]: int(words[i + 1]) for i in range(0, len(words) - 1, 2) if words[i + 1].isdigit()} out.append(got) return out def cache_file(cache): """The blob cache (a far client's, XDG_CACHE_HOME/pardes/cache.xitdb).""" return cache / 'pardes' / 'cache.xitdb' def cached(cache): """The blob cache's size in bytes, 0 with none.""" f = cache_file(cache) return f.stat().st_size if f.exists() else 0 def far(binary): """Far replica clients (PARDES_REPLICA_FAR, as through ssh) of a detached session and their blob cache: the first one is sent every blob and keeps them; a second on the same machine, and one put off the session's state that joins again, are sent none they hold, from disk and from the core they leave; one started after the first ended gets what it made from disk; one after the cache was cut short by hand (a file that is no database: started afresh), and one with the cache full, are sent what they lack. Every client's digest is the session's once quiet.""" scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn' scratch.mkdir(parents=True, exist_ok=True) root = Path(tempfile.mkdtemp(prefix='rf-', dir=scratch)) cache = root / 'cache' 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'), XDG_CACHE_HOME=str(cache), TERM='xterm-256color', SHELL=shutil.which('bash') or '/bin/bash', PARDES_NOTIME='1', PARDES_REPLICA_FAR='1') (root / 'config' / 'pardes').mkdir(parents=True) (root / 'config' / 'pardes' / 'init').write_text('Shell bash\nMessageLinger 0\n') notes = root / 'notes.txt' notes.write_text(''.join(f'line {i} of the notes\n' for i in range(300))) big = root / 'big.txt' big.write_text(''.join(f'{i:06d} the quick brown fox jumps over the lazy dog {i * 7919 % 10007}\n' for i in range(20000))) started = [] terms = [] def client(name, extra=None): t = Term(24, 90) terms.append(t) c = t.spawn([binary, f'--attach={root / "pardes-replica.sock"}:files'], dict(env, PARDES_REPLICA_CHECK=str(root / f'{name}.check'), PARDES_REPLICA_STATS=str(root / f'{name}.stats'), **(extra or {}))) started.append(c.pid) wait_for(f'client {name}\'s first frame', lambda: b'line 3 of the notes' in t.text(), timeout=30) # Its frame's request answered before a key goes: an answer behind # an Esc, in one read, is taken as Alt with it. time.sleep(.3) return t, c def texts(): return b''.join(nine.read(f'/pane/{row.split()[0].decode()}/body') for row in nine.read('/index').splitlines() if row.split()[1] == b'text') def typed(name, t, words): seen = len(checks(root / f'{name}.check')) os.write(t.master, b'O' + words) wait_for(f'client {name}\'s keys in the session\'s text', lambda: words in texts()) time.sleep(.2) os.write(t.master, b'\x1b') wait_for(f'client {name} out of insert mode', lambda: normal_again(t)) wait_for(f'client {name} agrees once quiet', lambda: agreed(root / f'{name}.check', seen)) def detach(name, t, c): os.write(t.master, b' sD') wait_for(f'client {name} let go', lambda: c.poll() is not None, timeout=20) try: sess = subprocess.Popen([binary, '--detach=files', str(notes)], env=env, cwd=root, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True) started.append(sess.pid) wait_for('the replica socket', (root / 'pardes-replica.sock').exists) wait_for('the session\'s 9P socket', (root / 'pardes-9p-files.sock').exists) nine = Client(root / 'pardes-9p-files.sock') pane = next(int(row.split()[0]) for row in nine.read('/index').splitlines() if row.split()[1] == b'text') nine.write(f'/pane/{pane}/exec', f'Look {big}\n'.encode()) nine.write(f'/pane/{pane}/exec', b'Edit 3a/ an edit the session made /\n') # A: the first, its cache empty: every blob sent, and kept. ta, a = client('a') typed('a', ta, b'from-A') # The notes and the big file, a megabyte and more between them. wait_for('client A\'s blobs on disk', lambda: cached(cache) > 1 << 20) time.sleep(.5) # B: a second client on this machine, and put off the session's # state once quiet: its first join from disk, its rejoin from the # core it left. tb, b = client('b', {'PARDES_TEST_DIVERGE': '1'}) os.write(tb.master, b'jj') time.sleep(.5) os.write(ta.master, b'jj') wait_for('client B diverged and joined again', lambda: b'joined again' in tb.text(), timeout=30) typed('b', tb, b'from-B') typed('a', ta, b'again-A') detach('b', tb, b) detach('a', ta, a) a_joins, b_joins = joins(root / 'a.stats'), joins(root / 'b.stats') assert len(a_joins) == 1 and len(b_joins) == 2, (a_joins, b_joins) assert a_joins[0]['from_disk'] == 0 and a_joins[0]['from_memory'] == 0 and a_joins[0]['sent_kb'] > 100, a_joins assert b_joins[0]['from_disk'] >= b_joins[0]['blobs'] - 2 and b_joins[0]['sent_kb'] < a_joins[0]['sent_kb'], b_joins assert b_joins[1]['from_memory'] >= b_joins[1]['blobs'] - 1 and b_joins[1]['sent_kb'] < 64, b_joins # C: a client started again after them: what they made since they # joined is on disk too (Have.keep at their end). tc, c = client('c') typed('c', tc, b'from-C') detach('c', tc, c) c_join = joins(root / 'c.stats')[0] assert c_join['from_disk'] >= c_join['blobs'] - 1 and c_join['sent_kb'] < 64, c_join # D: the cache cut short by hand: no database, started afresh, every # blob sent again. whole = cache_file(cache).read_bytes() cache_file(cache).write_bytes(whole[:len(whole) // 2]) td, d = client('d') typed('d', td, b'from-D') detach('d', td, d) d_join = joins(root / 'd.stats')[0] assert d_join['from_disk'] == 0 and d_join['sent_kb'] > 100, d_join # E: the cache full (D's, past a 1 MiB cap): the oldest go at its end, # the file compacted, under its cap but for xitdb's own few KB. before_e = cached(cache) assert before_e > 1 << 20, before_e te, e = client('e', {'PARDES_BLOB_CACHE_MB': '1'}) typed('e', te, b'from-E') detach('e', te, e) assert cached(cache) <= (1 << 20) + (64 << 10), cached(cache) tf, f = client('f', {'PARDES_BLOB_CACHE_MB': '1'}) typed('f', tf, b'from-F') detach('f', tf, f) f_join = joins(root / 'f.stats')[0] assert f_join['from_disk'] > 0 and cached(cache) <= (1 << 20) + (64 << 10), (f_join, cached(cache)) far_joins(root / 'pardes-replica.sock', 'files', binary, 200) # Through ssh (a stand-in forwarding as `ssh -L` does): a client # refused and one detached each end their ssh and its socket (one # refused left both, 2026-10-30). fake = root / 'ssh' fake.write_text('#!/bin/sh\nwhile [ $# -gt 0 ]; do case $1 in -L) fwd=$2; shift;; esac; shift; done\n' f'exec {sys.executable} -B {Path(__file__).parent / "delay_relay.py"} "${{fwd%%:*}}" "${{fwd#*:}}" --delay 0\n') fake.chmod(0o755) senv = dict(env, PARDES_SSH=str(fake), PARDES_REMOTE_RUNTIME=str(root), TMPDIR=str(root)) def forwarded(): return [q for q in processes(root) if alive(q) and any(b'pardes-ssh-' in a for a in cmdline(q))] or list(root.glob('pardes-ssh-*')) for name in ('nobody', 'files'): ts = Term(24, 90) terms.append(ts) sc = ts.spawn([binary, f'--attach=box:{name}'], senv) started.append(sc.pid) if name == 'files': wait_for('the client through ssh\'s first frame', lambda: b'line 3 of the notes' in ts.text(), timeout=30) time.sleep(.3) os.write(ts.master, b' sD') wait_for(f'the client through ssh ends ({name})', lambda: sc.poll() is not None, timeout=30) assert name == 'files' or b"no session called 'nobody'" in ts.text(), ts.text()[-300:] wait_for(f'its ssh and socket gone ({name})', lambda: not forwarded(), timeout=10) body = texts() for words in (b'from-A', b'from-B', b'again-A', b'from-C', b'from-D', b'from-E', b'from-F'): assert words in body, words print('daemon: far clients: the first sent {} KB; a second from disk ({} of {} blobs), its rejoin from memory ' '({} of {}); one started again from disk ({} of {}); after the cache was spoilt by hand sent {} KB; with ' 'the cache full it stayed under its cap; every digest agreed ({} checks)'.format( a_joins[0]['sent_kb'], b_joins[0]['from_disk'], b_joins[0]['blobs'], b_joins[1]['from_memory'], b_joins[1]['blobs'], c_join['from_disk'], c_join['blobs'], d_join['sent_kb'], sum(len(checks(root / f'{n}.check')) for n in 'abcdef'))) exit_session(nine, pane) sess.wait(timeout=10) nine.socket.close() wait_for('nothing left', lambda: not [p for p in processes(root) if alive(p)], timeout=10) finally: for t in terms: t.close() for pid in started + processes(root): try: os.kill(pid, signal.SIGKILL) except OSError: pass shutil.rmtree(root, ignore_errors=True) def far_joins(sock, session, binary, n): """`n` far joins of one session in a row, each read whole (its blobs asked for by none, its zstd frames unpacked) and answering a ping, then gone: the session's fds and threads as they were, its RSS within a bound. Each join made zstd contexts through the C heap, whose release builds named a new allocator at every malloc and aborted at the 65th (the box's session, after 15 far joins, 2026-10-30).""" from compression import zstd build = semantics(binary) def join(): r = Replica(sock, timeout=30) name = session.encode() r.send(0x01, struct.pack('= 5: t, m = struct.unpack_from(' 2000, timeout=30) os.kill(session, signal.SIGKILL) killed = time.monotonic() wait_for('the replica client ended with its session', lambda: rc.poll() is not None, timeout=10) assert time.monotonic() - killed < 2 and b'let this client go' in tr.text(), (time.monotonic() - killed, tr.text()[-300:]) tr.close() 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) # Started from a shell, which leads the terminal's session and # outlives the stub, as a terminal's shell does (on FreeBSD the # leader's exit revokes the terminal for every process). term = Term() stub_pid = root / 'stub.pid' shell = term.spawn(['sh', '-c', '"$@" & echo $! > "$0"; wait; exec sleep 600', str(stub_pid), binary, '--tty', '--9p=fresh'], env) started.append(shell.pid) sock = root / 'pardes-9p-fresh.sock' wait_for('the second session', sock.exists) stub = int(stub_pid.read_text()) started.append(stub) client = Client(sock) status = dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines()) session = int(status['pid']) started.append(session) # Its stub killed outright, the terminal left open: the session # (the stub's child) takes that as the terminal's end and detaches. wait_for('the second session\'s first frame', lambda: b'\x1b[?1049h' in term.text()) drawn = len(term.text()) os.kill(stub, signal.SIGKILL) wait_for('the stub gone', lambda: not alive(stub)) wait_for('the session detached from its killed stub', lambda: sized(client)) assert b'\x1b[?1049l' in term.text()[drawn:], 'the terminal is put back' assert alive(session) shell.kill() shell.wait(timeout=10) term.close() term = Term() stub = term.spawn([binary, '--attach=fresh'], 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: not sized(client)) print('daemon: a session whose stub was killed outright detached, and was attached again') 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}') # Attached already: another window is a replica client of the # session (its own process, its captures its own), listed by --ps; # closed, it ends alone. second = Window(root, 'second', [binary, '--attach=win'], env) wait_for('the second window drawn', lambda: (root / 'second' / 'latest.ppm').exists(), timeout=20) listed = subprocess.run([binary, '--ps'], env=env, cwd=root, capture_output=True, timeout=30).stdout.decode() assert f'client {second.pid} ' in listed, listed second.close() wait_for('the client gone from --ps', lambda: 'client ' not in subprocess.run([binary, '--ps'], env=env, cwd=root, capture_output=True, timeout=30).stdout.decode()) assert not sized(client), 'the first window stays' assert proc.poll() is None print('daemon: a second window on an attached window session a client of it (in --ps), closed alone') # Another kind joins as a replica client: a terminal of the window's # session, by its name alone. A name nobody has is refused in words. 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) wait_for('the window session drawn in the terminal', lambda: b'\x1b[?1049h' in term.text()) time.sleep(1) assert tty_attach.poll() is None, term.text()[-400:] tty_attach.terminate() tty_attach.wait(timeout=10) term.close() assert proc.poll() is None print('daemon: a terminal attached to a window session by name, as a client') 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) def screen_text(client): shown = client.screen() cells = ''.join(cell[0] for cell in shown['cells']) return '\n'.join(cells[i:i + shown['cols']] for i in range(0, len(cells), shown['cols'])) def reconnect(sock, timeout=20): """The session's 9P again, once its upgraded process listens.""" return wait_for('the upgraded session\'s 9P', lambda: dial(sock), timeout=timeout) def dial(sock): try: return Client(sock) except (OSError, EOFError): # mid-exec: refused, or cut after the accept return None def saying(sock, words, timeout=30): """A connection to the session once its screen shows `words`: dialled afresh each look, since the process it talks to may exec meanwhile.""" last = [''] def look(): c = dial(sock) if c is None: return None try: last[0] = screen_text(c) if words in last[0]: return c except (OSError, EOFError): pass c.socket.close() return None try: return wait_for(f'the session saying {words!r}', look, timeout=timeout) except TimeoutError: raise TimeoutError(f'the session saying {words!r}; it shows:\n{last[0]}') def exe_of(pid): """What /proc says the process runs: (its path, whether that file is the one at the path now). FreeBSD's procstat names the path alone.""" if not procfs: rows = subprocess.run(['procstat', '-b', str(pid)], capture_output=True).stdout.decode().splitlines() return (rows[-1].split()[-1] if len(rows) > 1 else ''), None link = os.readlink(f'/proc/{pid}/exe') try: same = os.stat(f'/proc/{pid}/exe').st_ino == os.stat(link).st_ino except OSError: same = False return link, same def ppid(pid): if not procfs: return int(ps('-o', 'ppid=', '-p', str(pid))) return int(open(f'/proc/{pid}/stat').read().rsplit(')', 1)[1].split()[1]) def install(binary, at): """As `zig build` and install(1) put a build in place: a new file renamed over the old, which a process running it keeps, deleted.""" tmp = at.with_name(at.name + '.new') if procfs: subprocess.run(['cp', '--reflink=auto', os.fspath(binary), os.fspath(tmp)], check=True) else: shutil.copyfile(binary, tmp) os.chmod(tmp, 0o755) os.replace(tmp, at) def upgrades(old, new): """Upgrade (docs/next-daemon.md, phase 6): a tui session with an unsaved edit, a shell running `sleep 1000; echo done` and two terminals (two views) moved onto another build installed at the path it started from, the daemon with it; then a build that refuses the dump, which falls back to the running one, and one that refuses it everywhere, which starts afresh with the shells adopted and the dump kept.""" scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn' scratch.mkdir(parents=True, exist_ok=True) root = Path(tempfile.mkdtemp(prefix='rtu-', 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=shutil.which('bash') or '/bin/bash', PARDES_NOTIME='1') (root / 'config' / 'pardes').mkdir(parents=True) (root / 'config' / 'pardes' / 'init').write_text('Shell bash\nMessageLinger 0\n') (root / 'bin').mkdir() binary = root / 'bin' / 'pardes' install(old, binary) notes = root / 'notes.txt' notes.write_text('one\ntwo\n') started = [] try: term = Term() stub = term.spawn([str(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) session = int(dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())['pid']) started.append(session) daemon = wait_for('the daemon', lambda: [p for p in processes(root) if cmdline(p)[1:2] == [b'--daemon']])[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) client.write(f'/pane/{shell}/look', f'{notes}\n'.encode()) text = int(client.read('/look')) client.write(f'/pane/{text}/body', b'unsaved\n') assert client.read(f'/pane/{text}/body') == b'one\ntwo\nunsaved\n' client.write(f'/pane/{shell}/pty/data', b'sleep 1000; echo done-after-upgrade\r') sleeper = wait_for('the sleep', lambda: [p for p in processes(root) if cmdline(p)[:2] == [b'sleep', b'1000']])[0] # A second terminal: a view of its own (an older build's), or a client. term2 = Term(30, 100) stub2 = term2.spawn([str(binary), '--attach=work'], env) started.append(stub2.pid) wait_for('the second terminal\'s first frame', lambda: b'\x1b[?1049h' in term2.text()) old_build = semantics(old) replica = Replica(root / 'pardes-replica.sock') assert replica.hello('work', old_build)[0] == 'welcome' # A replica client of the old build: let go at the upgrade, it dials # again and is told to upgrade too. term3 = Term(24, 90) stale = term3.spawn([str(old), f'--attach={root / "pardes-replica.sock"}:work'], env) started.append(stale.pid) wait_for('the old build\'s client drawn', lambda: b'\x1b[?1049h' in term3.text() and b'one' in term3.text()) before = len(term.text()), len(term2.text()) install(new, binary) assert not procfs or exe_of(session)[1] is False, 'the session runs the old build, deleted' # Come back to the terminal: the newer build is said. os.write(term.master, b'\x1b[I') wait_for('the newer build said', lambda: 'a newer pardes is installed' in screen_text(client)) fds_before = fds(session), fds(daemon) state_before = state_fds(session) rcs = sorted(Path('/tmp').glob(f'pardes-osc133-*-{session}-*')) t = time.monotonic() client.write('/ctl', b'Upgrade\n') client.socket.close() new_build = semantics(new) assert new_build != old_build if procfs: wait_for('the session on the new build', lambda: exe_of(session) == (str(binary), True), timeout=30) else: wait_for('the session registered as the new build', lambda: Replica(root / 'pardes-replica.sock').hello('work', new_build)[0] == 'welcome', timeout=30) client = reconnect(sock) took = time.monotonic() - t assert int(dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())['pid']) == session if procfs: wait_for('the daemon on the new build', lambda: exe_of(daemon) == (str(binary), True)) else: wait_for('the daemon exec\'d again', lambda: any(a.startswith(b'--upgraded=') for a in cmdline(daemon))) assert alive(daemon) and stub.poll() is None # A replica of the old build is told why it is let go, after what it # was sent (units, terminals). tag, body = replica.read() while tag in (0x05, 0x06, 0x07): tag, body = replica.read() assert tag == 0x02 and b'upgrading to another build' in body, (tag, body) replica.close() stale.wait(timeout=30) # (Across a change of the replica protocol, it says that instead.) assert b'upgrade this client too' in term3.text() or b'run the same pardes at both ends' in term3.text(), term3.text()[-400:] term3.close() print('upgrade: a replica client of the old build was let go, dialled again and was told to upgrade too') # The old image's prompt files swept, the new one's made. wait_for('the prompt files level', lambda: len(list(Path('/tmp').glob(f'pardes-osc133-*-{session}-*'))) == len(rcs)) assert sorted(Path('/tmp').glob(f'pardes-osc133-*-{session}-*')) != rcs or not rcs # Nothing kept that was not: the old binary let go, every fd back. # (The replicas' connections are two fewer; the state file's one # more after a build that opened Recent's file for each use, and # only one: a session holds it once.) # The second terminal: a replica client, its connection let go at # the exec (one fewer), or a view of its own an older build kept, # its terminal and its stub's pipe let go once its stub is told # (two fewer). def level(): gone = 2 if b'detached from' in term2.text() else 1 return fds_before[0] - 2 - gone + min(state_fds(session), 1) - state_before, fds_before[1] try: wait_for('the fds level', lambda: (fds(session), fds(daemon)) == level(), timeout=5) except TimeoutError: raise AssertionError(('fds', level(), (fds(session), fds(daemon)), links(session))) # The edit and its undo. assert client.read(f'/pane/{text}/body') == b'one\ntwo\nunsaved\n' assert any(row.split()[0] == str(text).encode() and row.split()[2] == b'1' for row in client.read('/index').splitlines()), client.read('/index') client.write(f'/pane/{text}/exec', b'Undo\n') assert client.read(f'/pane/{text}/body') == b'one\ntwo\n', client.read(f'/pane/{text}/body') # The shell, its job and its pty: the same, the session's still. assert alive(shell_pid) and ppid(shell_pid) == session and alive(sleeper) # Both terminals drawn again, each its own view. wait_for('the first terminal redrawn', lambda: b'\x1b[?1049h' in term.text()[before[0]:]) # The second: a client again; a replica client of the old build let # go and told to upgrade too, as the third; or, a view of an older # build's own, let go (a session shows one frontend of its own now), # its stub told. wait_for('the second terminal redrawn or let go', lambda: b'\x1b[?1049h' in term2.text()[before[1]:] or (stub2.poll() is not None and (b'detached from' in term2.text() or b'upgrade this client too' in term2.text()))) wait_for('the word said', lambda: 'Upgrade: now pardes' in screen_text(client)) # The daemon lists the session under its new build. said = Replica(root / 'pardes-replica.sock').hello('work', new_build) assert said == ('welcome', session, 'work'), said said = Replica(root / 'pardes-replica.sock').hello('work', old_build) assert said[0] == 'refused' and 'another build' in said[1], said os.kill(sleeper, signal.SIGTERM) wait_for('the shell carrying on', lambda: b'done-after-upgrade\n' in client.read(f'/pane/{shell}/body')) print(f'upgrade: session {session}, its daemon {daemon}, shell {shell_pid} and its terminal on the new build (a second one an older build kept let go, or a client again) ' f'(the word to its 9P again: {took * 1000:.0f} ms); the edit, its undo and the job kept') # A build that cannot load the dump: back to the one running (a copy # of it kept open from /proc/self/exe; FreeBSD keeps none). refuser = root / 'refuser' def refusing(how): refuser.write_text('#!/bin/sh\n# A pardes whose load refuses the dump (upgrade.zig).\n' f'case "$1" in --upgraded=*) PARDES_TEST_UPGRADE_REFUSE={how} exec {new} "$@";; esac\n' f'exec {new} "$@"\n') refuser.chmod(0o755) install(refuser, binary) if procfs: running = os.stat(f'/proc/{session}/exe').st_ino # A replica client of the build running: let go at the upgrade, # it joins again once the session is back, says so, and agrees. term4 = Term(24, 90) again = term4.spawn([str(new), f'--attach={root / "pardes-replica.sock"}:work'], dict(env, PARDES_REPLICA_CHECK=str(root / 'e.check'))) started.append(again.pid) wait_for('the client of the build running drawn', lambda: b'\x1b[?1049h' in term4.text() and b'one' in term4.text()) # A second, and each a pane of its own in its own view: the # Upgrade's rejoin gives each its own view back, its pane in it, # not a new one (a copy of the session's, without it). term5 = Term(30, 100) again5 = term5.spawn([str(new), f'--attach={root / "pardes-replica.sock"}:work'], dict(env, PARDES_REPLICA_CHECK=str(root / 'f.check'))) started.append(again5.pid) wait_for('the second client of the build running drawn', lambda: b'\x1b[?1049h' in term5.text() and b'one' in term5.text()) owners = ((term4, root / 'e.check'), (term5, root / 'f.check')) mine = [] for t, check in owners: made_live(t, check) shown = view_panes(client) client.write('/exec', b'New\n') mine.append(wait_for('a pane in the client\'s view', lambda: view_panes(client) - shown).pop()) refusing('1') client.write(f'/pane/{shell}/exec', b'Upgrade\n') client.socket.close() client = saying(sock, 'it goes on as') for t, _ in owners: wait_for('the client joined again', lambda: b'joined again: the session is upgrading' in t.text(), timeout=30) assert again.poll() is None and again5.poll() is None for (t, check), pane, theirs in zip(owners, mine, reversed(mine)): made_live(t, check) shown = view_panes(client) assert pane in shown and theirs not in shown, ('its own view again', pane, theirs, client.read('/layout')) for c, t in ((again, term4), (again5, term5)): c.send_signal(signal.SIGHUP) c.wait(timeout=10) t.close() print('upgrade: two replica clients of the build running joined again after the upgrade, said so and agreed, ' 'each in its own view again, its own pane in it') assert os.stat(f'/proc/{session}/exe').st_ino == running, 'back on the build that ran' assert alive(shell_pid) and ppid(shell_pid) == session and stub.poll() is None assert client.read(f'/pane/{text}/body') == b'one\ntwo\n' assert run(client, shell, b'echo $$\n').split(b'\n')[1] == str(shell_pid).encode() print('upgrade: a build that refused the dump fell back to the one running; the shell ran on') # One that refuses it everywhere: a fresh session, the shells adopted. refusing('all') client.write(f'/pane/{shell}/exec', b'Upgrade\n') client.socket.close() client = saying(sock, 'brings the rest back') # The dump stays in the state file, under its label (a second # upgrade of one pid is `upgrade--2`). kept = client.read('/dumps').decode() assert any(line.split()[0].startswith(f'upgrade-{session}') for line in kept.splitlines()), kept assert alive(shell_pid) and ppid(shell_pid) == session pids = {p: run(client, p, b'echo $$\n') for p in terminals(client)} adopted = [p for p, out in pids.items() if out.split(b'\n')[1:2] == [str(shell_pid).encode()]] assert adopted, ('the shell is a pane of the fresh session', shell_pid, pids, client.read('/index')) print(f'upgrade: a build that refused it everywhere started afresh, shell {shell_pid} adopted, the dump kept') # The daemon, three times upgraded, still holds the shell's master: # the session killed outright, another adopts it. install(new, binary) os.kill(session, signal.SIGKILL) stub.wait(timeout=10) stub2.wait(timeout=10) client.socket.close() term.close() term2.close() wait_for('the killed session gone', lambda: not alive(session)) time.sleep(.3) assert alive(shell_pid) and alive(daemon) term = Term() stub = term.spawn([str(binary), '--tty', '--9p=again'], env) started.append(stub.pid) sock = root / 'pardes-9p-again.sock' wait_for('the next session', sock.exists) client = Client(sock) started.append(int(dict(line.split(maxsplit=1) for line in client.read('/status').decode().splitlines())['pid'])) # Its reader of the daemon starts after its first frame: an Adopt # before that waits for an `ok` nobody reads, and is refused. wait_for('the next session\'s first frame', lambda: b'\x1b[?1049h' in term.text()) before = set(terminals(client)) client.write(f'/pane/{min(before)}/exec', b'Adopt\n') pane = wait_for('the adopted pane', lambda: set(terminals(client)) - before).pop() assert run(client, pane, b'echo $$\n').split(b'\n')[1] == str(shell_pid).encode() print(f'upgrade: the upgraded daemon kept shell {shell_pid} through kill -9 of its session, and it was adopted') client.write(f'/pane/{pane}/exec', b'Exit\n') stub.wait(timeout=10) client.socket.close() term.close() wait_for('the 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] print('upgrade: 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 gui_upgrades(old, new): """Upgrade in a window session (test mode: hidden windows, captured): its window, a client window, an unsaved edit and a shell's job, onto another build.""" scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn' root = Path(tempfile.mkdtemp(prefix='rtgu-', 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 caps = root / 'caps' 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(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') (root / 'bin').mkdir() binary = root / 'bin' / 'pardes-gui' install(old, binary) notes = root / 'notes.txt' notes.write_text('one\ntwo\n') feed_r, feed_w = os.pipe() proc = subprocess.Popen([str(binary), '--9p=win'], env=env, cwd=root, stdin=feed_r, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True) os.close(feed_r) started = [proc.pid] try: sock = root / 'pardes-9p-win.sock' wait_for('the window session', sock.exists, timeout=20) client = Client(sock) daemon = wait_for('the daemon', lambda: [p for p in processes(root) if cmdline(p)[1:2] == [b'--daemon']])[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) client.write(f'/pane/{shell}/look', f'{notes}\n'.encode()) text = int(client.read('/look')) client.write(f'/pane/{text}/body', b'unsaved\n') client.write(f'/pane/{shell}/pty/data', b'sleep 1000; echo done-after-upgrade\r') sleeper = wait_for('the sleep', lambda: [p for p in processes(root) if cmdline(p)[:2] == [b'sleep', b'1000']])[0] # A second window: a replica client of the session (its own # process, its captures its own), as window_clients' second. second = Window(root, 'second', [str(binary), '--attach=win'], env) started.append(second.pid) frames = [caps / 'latest.ppm', root / 'second' / 'latest.ppm'] wait_for('both windows drawn', lambda: all(f.exists() for f in frames), timeout=20) install(new, binary) time.sleep(.05) mark = time.time() client.write(f'/pane/{shell}/exec', b'Upgrade\n') client.socket.close() wait_for('the session on the new build', lambda: exe_of(proc.pid) == (str(binary), True), timeout=30) client = reconnect(sock) assert proc.poll() is None wait_for('the daemon on the new build', lambda: exe_of(daemon) == (str(binary), True)) assert client.read(f'/pane/{text}/body') == b'one\ntwo\nunsaved\n' client.write(f'/pane/{text}/exec', b'Undo\n') assert client.read(f'/pane/{text}/body') == b'one\ntwo\n' assert alive(shell_pid) and ppid(shell_pid) == proc.pid and alive(sleeper) wait_for('the window drawn again', lambda: frames[0].stat().st_mtime > mark) # The second, a client of the old build: let go and told to upgrade too. second.p.wait(timeout=30) said = second.err.read_bytes() assert b'upgrade this client too' in said or b'run the same pardes at both ends' in said, said[-400:] said = Replica(root / 'pardes-replica.sock').hello('win', semantics(new)) assert said == ('welcome', proc.pid, 'win'), said os.kill(sleeper, signal.SIGTERM) wait_for('the shell carrying on', lambda: b'done-after-upgrade\n' in client.read(f'/pane/{shell}/body')) print(f'upgrade: window session {proc.pid}, its daemon, shell {shell_pid} and its window on the new build, ' 'a client window of the old build let go and told to upgrade too; the edit, its undo and the job kept') client.write(f'/pane/{shell}/exec', b'Exit\n') proc.wait(timeout=10) client.socket.close() wait_for('nothing left', lambda: not [p for p in processes(root) if alive(p)], timeout=5) print('upgrade: window session ended, nothing left behind') finally: os.close(feed_w) for pid in started + processes(root): try: os.kill(pid, signal.SIGKILL) except OSError: pass shutil.rmtree(root, ignore_errors=True) if __name__ == '__main__': # A session's state file is its HOME's, never the user's: the dumps a # test makes there would push the user's out. os.environ.pop('XDG_DATA_HOME', None) if sys.argv[1:3] == ['--upgrade', '--gui']: gui_upgrades(Path(sys.argv[3]).resolve(), Path(sys.argv[4]).resolve()) elif sys.argv[1:2] == ['--upgrade']: upgrades(Path(sys.argv[2]).resolve(), Path(sys.argv[3]).resolve()) elif sys.argv[1:2] == ['--clients']: clients(sys.argv[2]) elif sys.argv[1:2] == ['--manage']: manage(sys.argv[2]) elif sys.argv[1:2] == ['--far']: far(sys.argv[2]) elif sys.argv[1:2] == ['--window-clients']: window_clients(sys.argv[2], sys.argv[3]) pdf_window(sys.argv[2], sys.argv[3]) elif sys.argv[1:2] == ['--ping']: ping(sys.argv[2], sys.argv[3], sys.argv[4], int(sys.argv[5]) if len(sys.argv) > 5 else 50) elif '--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)