Files
lilleman 39de100a34
CI / tests (pull_request) Successful in 3m5s
Kill the endless-wait message mutants
2026-11-18 20:39:10 +01:00

123 lines
7.0 KiB
Python

"""The waits that cannot end in a Bash or Monitor command, for the `endless-wait` rule: a loop that sleeps with no time or count cap, and a `pgrep -f` or `pkill -f` whose pattern matches the command line that holds it.
A sleeping loop with no cap never ends. A `pgrep -f` or `pkill -f` finds the shell that runs it when its pattern matches that shell's command line, so a loop that waits for the process to disappear, as in `until [ -s f ] && ! pgrep -f "chunk-pr merg"; do sleep 15; done`, never ends either. A session that waits on one hangs.
It reads the command's own text. A loop in a script file or in a variable's value isn't read, and a counter or deadline it doesn't recognise leaves the loop refused, which an override waives.
"""
import itertools
import re
from command_lines.shell_command import launched, segments, Simple
# What stands before a command in a segment without being part of it, as in `do sleep 15` or `! pgrep -f x`.
KEYWORDS = frozenset({"!", "do", "elif", "else", "if", "then", "{"})
# The keywords of a loop whose condition is a command, as in `while sleep 30`.
CONDITIONS = frozenset({"until", "while"})
LOOPS = frozenset({"for", "until", "while"})
SHELLS = frozenset({"bash", "dash", "sh", "zsh"})
# A word with which a loop counts its rounds: `[ "$n" -lt 40 ]`.
COUNTERS = frozenset({"-ge", "-gt", "-le", "-lt"})
# `for ((;;))` has no condition. The lexer splits at its parentheses, so the check reads the command's text.
FOREVER = re.compile(r"\bfor\s*\(\(\s*[^;)]*;\s*;")
# A signal given to pkill, as -9 or -KILL, which is not a cluster of options.
SIGNAL = re.compile(r"-(?:\d+|[A-Z]{2,})")
# pgrep's and pkill's options that take a value, as short letters and as long names.
VALUED = frozenset("dFgGPrstuU")
VALUED_LONG = frozenset({"--delimiter", "--euid", "--group", "--ns", "--nslist", "--parent", "--pgroup", "--pidfile", "--runstates", "--session", "--signal", "--terminal", "--uid"})
HOW = "use `~/.claude/bin/wait-for <file> [<pattern>] --timeout <seconds>`"
# What the refusal of a self-matching pgrep or pkill suggests first. Only a pgrep waits, so only it is pointed to wait-for.
INSTEAD = {"pgrep": f"{HOW}, a `pgrep -x` on the process name", "pkill": "use a `pkill -x` on the process name"}
def endless_waits(command: str, simples: list[Simple], capped: bool) -> list[tuple[str, str]]:
"""Each endless wait the command starts, as its detail and the directory it runs in. capped is whether something ends every loop in the simple commands: a Monitor call's timeout_ms, or a `timeout` around the shell, as in `timeout 60 bash -c '…'`."""
found = [] if capped else [(f"a loop that sleeps, `{' '.join(loop[0].words)[:60]}`, has neither a time limit nor a count cap; {HOW}, or give the loop a deadline compared with `date` or $SECONDS, or a counter, as in `for i in $(seq 1 40)`", loop[0].directory) for loop in loops(simples) if endless(loop, command)]
for simple in simples:
if (found_match := self_match(simple.words, command)) is not None:
tool, pattern = found_match
found.append((f"`{pattern}` matches the command line that holds this `{tool} -f`, so `{tool}` finds the shell that runs the command; {INSTEAD[tool]}, or a pattern the command doesn't contain, such as `[c]hunk` for `chunk`", simple.directory))
if (script := shell_script(simple.words)) is not None:
found += endless_waits(command, [Simple(words, simple.directory) for words in segments(script)], capped or launched(simple.words, {"timeout"}) is not None)
return found
def core(words: list[str]) -> list[str]:
"""The words of a segment without the keywords before its command or its loop keyword."""
return list(itertools.dropwhile(KEYWORDS.__contains__, words))
def invoked(words: list[str]) -> list[str]:
"""The command a segment runs, which a loop's condition may be: `until ! pgrep -f x` runs pgrep."""
return list(itertools.dropwhile((KEYWORDS | CONDITIONS).__contains__, words))
def loops(simples: list[Simple]) -> list[list[Simple]]:
"""Each loop as the segments from its keyword to its `done`, those of a loop nested in it included."""
open_loops: list[list[Simple]] = []
closed = []
for simple in (Simple(core(simple.words), simple.directory) for simple in simples):
kind = simple.words[0] if simple.words else None
for loop in open_loops:
loop.append(simple)
if kind in LOOPS:
open_loops.append([simple])
elif kind == "done" and open_loops:
closed.append(open_loops.pop())
return closed + open_loops
def endless(loop: list[Simple], command: str) -> bool:
"""Whether the loop sleeps and nothing bounds it."""
if not any(launched(invoked(simple.words), {"sleep"}) for simple in loop):
return False
head = loop[0].words
if head[0] == "for":
# A list ends the loop. An arithmetic `for` ends it only with a condition; its words stop at the lexer's split at `((`.
return head == ["for"] and FOREVER.search(command) is not None
# `while ((i < 10))` splits the same way, so a bare keyword reads as a count.
if len(head) == 1:
return False
# A counter or a clock is judged by its words alone: a stricter test would refuse the bounded loops people write, and none can tell that the count advances or the clock is compared. So `-ge` on a file's line count, or a `date` that only logs, passes.
words = {word for simple in loop for word in simple.words}
return not (COUNTERS & words or any("SECONDS" in word for word in words) or any(launched(invoked(simple.words), {"date"}) for simple in loop))
def shell_script(words: list[str]) -> str | None:
"""The script of `bash -c <script>`, whose inner commands the lexer keeps as one word; None for any other command."""
shell = launched(words, SHELLS)
if shell is None:
return None
flags = [i for i, argument in enumerate(shell.arguments) if re.fullmatch(r"-[a-z]*c[a-z]*", argument)]
return shell.arguments[flags[0] + 1] if flags and flags[0] + 1 < len(shell.arguments) else None
def self_match(words: list[str], command: str) -> tuple[str, str] | None:
"""The tool and the pattern of a `pgrep -f` or `pkill -f` whose pattern matches the command's own text, which is the shell's command line; None where there is none."""
launch = launched(invoked(words), {"pgrep", "pkill"})
if launch is None:
return None
full, patterns, rest = False, [], iter(launch.arguments)
for word in rest:
if word.startswith("--"):
full = full or word == "--full"
if word in VALUED_LONG:
next(rest, None)
elif word.startswith("-") and len(word) > 1 and not SIGNAL.fullmatch(word):
for at, letter in enumerate(word[1:], 1):
full = full or letter == "f"
if letter in VALUED:
# `-u root` takes the next word; `-uroot` has it in the cluster.
if at == len(word) - 1:
next(rest, None)
break
elif not word.startswith("-") or len(word) == 1:
patterns.append(word)
return next(((launch.tool, pattern) for pattern in patterns if full and matches(pattern, command)), None)
def matches(pattern: str, text: str) -> bool:
"""Whether pgrep's regular expression finds a match in text; an expression Python cannot read is taken as plain text."""
try:
return re.search(pattern, text) is not None
except re.error:
return pattern in text