@vibelord/lanes 1.0.0 → 1.0.2

package/payload/lanes/libexec/legacy_sessions.py

@@ -1,130 +0,0 @@
-"""Track pre-persistence Docker shells without pretending their lost Docker connection is reattachable."""
-import json
-import os
-import select
-import signal
-import sys
-import time
-from pathlib import Path
-
-import lanes_lib as L
-
-
-def process(pid):
-    root = Path(L.proc_root()) / str(pid)
-    stat = (root / 'stat').read_text().rsplit(') ', 1)[1].split()
-    return {'pid': int(pid), 'ppid': int(stat[1]), 'sid': int(stat[3]), 'tty': stat[4], 'start': stat[19],
-            'uid': root.stat().st_uid, 'cgroup': (root / 'cgroup').read_text(),
-            'cwd': os.readlink(root / 'cwd'), 'command': (root / 'comm').read_text().strip()}
-
-
-def observe():
-    lanes, groups = {}, {}
-    for path in (L.STATE / 'legacy-sessions').glob('*.json'):
-        entry = L.read_json(path) or {}
-        identity = entry.get('legacy') or {}
-        try:
-            actual = process(identity['pid'])
-            if actual['start'] != identity['start']:
-                continue
-            state = {'state': 'quiet', 'pid': actual['pid'], 'cwd': actual['cwd'],
-                     'command': actual['command'], 'legacy': True}
-        except (FileNotFoundError, ProcessLookupError, KeyError):
-            continue
-        except OSError:
-            state = {'state': 'unknown', 'observed': 'error', 'legacy': True}
-        lanes[entry['id']] = state
-        groups.setdefault(entry['workspace'], []).append(entry)
-        L.atomic_write(L.STATE / 'resolve.dynamic' / entry['id'],
-                       '\n'.join(['exec', entry['container'], 'legacy', entry['id'], entry['name']]) + '\n')
-    return lanes, groups
-
-
-def close(entry):
-    identity = entry.get('legacy') or {}
-    recorded = L.read_json(L.STATE / 'legacy-sessions' / (entry['id'] + '.json')) or {}
-    if recorded.get('legacy') != identity:
-        raise L.LanesError('Legacy shell identity changed; nothing was closed')
-    try:
-        root = process(identity['pid'])
-    except (OSError, KeyError):
-        raise L.LanesError('Legacy shell could not be checked; nothing was closed')
-    if root['start'] != identity['start'] or root['uid'] != os.getuid():
-        raise L.LanesError('Legacy shell changed; nothing was closed')
-    members = {}
-    for path in Path(L.proc_root()).iterdir():
-        if not path.name.isdigit():
-            continue
-        try:
-            candidate = process(path.name)
-            if candidate['uid'] == root['uid'] and candidate['cgroup'] == root['cgroup']:
-                members[candidate['pid']] = candidate
-        except OSError:
-            continue
-    # The root may have exited and its PID been reused while we scanned /proc.
-    # Keep the recorded identity authoritative rather than adopting the scan's replacement.
-    if members.get(root['pid'], {}).get('start') != root['start']:
-        raise L.LanesError('Legacy shell changed or could not be checked; nothing was closed')
-    chosen = {root['pid']} | {pid for pid, p in members.items()
-                            if p['sid'] == root['sid'] and p['tty'] == root['tty'] and root['tty'] != '0'}
-    while True:
-        children = {pid for pid, p in members.items() if p['ppid'] in chosen}
-        if children <= chosen:
-            break
-        chosen.update(children)
-    handles, root_verified = [], False
-    try:
-        for pid in chosen:
-            fd = None
-            try:
-                fd = os.pidfd_open(pid)
-                if process(pid)['start'] != members[pid]['start']:
-                    os.close(fd)
-                    continue
-                handles.append(fd)
-                if pid == root['pid']:
-                    root_verified = True
-            except (OSError, KeyError):
-                if fd is not None:
-                    os.close(fd)
-                continue
-        if not root_verified:
-            raise L.LanesError('Legacy shell could not be checked; nothing was closed')
-        # pidfds remain attached to these processes even if the kernel recycles their numeric pids.
-        for fd in handles:
-            try:
-                signal.pidfd_send_signal(fd, signal.SIGHUP)
-            except ProcessLookupError:
-                pass
-        remaining, deadline = set(handles), time.monotonic() + 2
-        while remaining and time.monotonic() < deadline:
-            ready, _, _ = select.select(list(remaining), [], [], 0.1)
-            remaining.difference_update(ready)
-        for fd in remaining:
-            try:
-                signal.pidfd_send_signal(fd, signal.SIGKILL)
-            except ProcessLookupError:
-                pass
-    finally:
-        for fd in handles:
-            os.close(fd)
-    (L.STATE / 'legacy-sessions' / (entry['id'] + '.json')).unlink(missing_ok=True)
-
-
-def view(container, lane_id):
-    L._require(L.IDENT, lane_id, 'legacy shell')
-    entry = L.read_json(L.STATE / 'legacy-sessions' / (lane_id + '.json')) or {}
-    if entry.get('container') != container:
-        raise L.LanesError('Legacy shell no longer exists')
-    print('\033[2J\033[H\n  ' + entry['name'] + '\n', flush=True)
-    print('  This shell predates persistent terminals. Its original Docker connection cannot be reattached.\n'
-          '  Its shell and running jobs are preserved. Use × in Unregistered to terminate them.\n'
-          '  New + creates a shell you can leave and reopen.\n', flush=True)
-    print('  Container: ' + container + '\n  Process: ' + str(entry['legacy']['pid']), flush=True)
-    while True:
-        time.sleep(30)
-
-
-if __name__ == '__main__':
-    if len(sys.argv) == 4 and sys.argv[1] == 'view':
-        view(sys.argv[2], sys.argv[3])