止めたはずの MCP サーバが残り続ける — 停止方法 4 種を 84 回測って見えた setsid の壁

os.killpg(top.pid, signal.SIGTERM)

"""子プロセスとして起動した MCP サーバを, 取りこぼしなく停止する."""
import os
import signal
import time
 
 
def _read_stat(pid):
    """/proc/<pid>/stat から (ppid, starttime) を返す. 読めなければ None."""
    try:
        with open(f"/proc/{pid}/stat", "r") as f:
            raw = f.read()
    except (FileNotFoundError, ProcessLookupError, PermissionError):
        return None
    # comm には空白や ')' が入りうるので, 最後の ') ' で切る
    try:
        fields = raw.rsplit(") ", 1)[1].split()
    except IndexError:
        return None
    return int(fields[1]), int(fields[19])      # ppid, starttime
 
 
def _is_live(pid, starttime):
    """zombie を除いた生存判定 + PID 再利用ガード."""
    st = _read_stat(pid)
    if st is None or st[1] != starttime:
        return False                            # 死亡, または同じ PID の別プロセス
    try:
        with open(f"/proc/{pid}/cmdline", "rb") as f:
            return len(f.read()) > 0            # zombie は cmdline が空になる
    except OSError:
        return False
 
 
def snapshot_tree(root_pid):
    """root_pid 以下の子孫を (pid, starttime) で収集し, 葉から順に返す."""
    children, meta = {}, {}
    for entry in os.listdir("/proc"):
        if not entry.isdigit():
            continue
        pid = int(entry)
        st = _read_stat(pid)
        if st is None:
            continue
        children.setdefault(st[0], []).append(pid)
        meta[pid] = st[1]
    ordered, stack = [], [root_pid]
    while stack:
        pid = stack.pop()
        if pid in meta:
            ordered.append((pid, meta[pid]))
        stack.extend(children.get(pid, []))
    return list(reversed(ordered))              # 葉から先に止める
 
 
def terminate_tree(root_pid, grace=0.5, poll=0.01):
    """子孫を SIGTERM で止め, 猶予内に落ちなかったものだけ SIGKILL する.
 
    返り値: (対象数, SIGKILL に落ちた数)
    """
    targets = snapshot_tree(root_pid)
    if not targets:
        return 0, 0
    for pid, _ in targets:
        try:
            os.kill(pid, signal.SIGTERM)
        except (ProcessLookupError, PermissionError):
            pass
    deadline = time.monotonic() + grace
    while time.monotonic() < deadline:
        if not any(_is_live(pid, st) for pid, st in targets):
            return len(targets), 0
        time.sleep(poll)
    killed = 0
    for pid, st in targets:
        if _is_live(pid, st):
            try:
                os.kill(pid, signal.SIGKILL)
                killed += 1
            except (ProcessLookupError, PermissionError):
                pass
    return len(targets), killed

# psweep.py — /proc を持たない環境向けの子孫スイープ
import subprocess
 
 
def ps_snapshot():
    """pid -> (ppid, lstart, stat) を ps 一回で集める."""
    out = subprocess.run(
        ["ps", "-axo", "pid=,ppid=,stat=,lstart="],
        capture_output=True, text=True, check=True,
    ).stdout
    table = {}
    for line in out.splitlines():
        parts = line.split(None, 3)             # lstart は空白を含むので 3 分割で止める
        if len(parts) < 4:
            continue
        pid, ppid, stat, lstart = parts
        table[int(pid)] = (int(ppid), lstart.strip(), stat)
    return table
 
 
def snapshot_tree_ps(root_pid, table):
    """root_pid 以下の子孫を (pid, lstart) で収集し, 葉から順に返す."""
    children = {}
    for pid, (ppid, _, _) in table.items():
        children.setdefault(ppid, []).append(pid)
    ordered, stack = [], [root_pid]
    while stack:
        pid = stack.pop()
        if pid in table:
            ordered.append((pid, table[pid][1]))
        stack.extend(children.get(pid, []))
    return list(reversed(ordered))              # 葉から先に止める
 
 
def is_live_ps(pid, lstart, table):
    """zombie を除いた生存判定 + PID 再利用ガード. table は都度取り直す."""
    row = table.get(pid)
    if row is None or row[1] != lstart:
        return False                            # 死亡, または同じ PID の別プロセス
    return "Z" not in row[2]                    # zombie は STAT に Z が立つ

deadline = time.monotonic() + grace
while time.monotonic() < deadline:
    table = ps_snapshot()                       # 1 周に 1 回だけ取り直す
    if not any(is_live_ps(pid, ls, table) for pid, ls in targets):
        break
    time.sleep(0.05)                            # ps は fork+exec を伴うので粗めに