| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162 |
- """Inline-source (``python -c <src> …``) command-line parsing for gateway process identity.
- Everything after ``-c`` is data for the inline program, not the process's own identity -- except
- Hermes' own bootstraps, which run an entry point in-process and are mapped back to the equivalent
- ``python -m <module> <argv…>`` (see #107002).
- """
- from __future__ import annotations
- import re
- def inline_source_flag_index(tokens: list[str]) -> int | None:
- """Index of the ``-c`` token when *tokens* is an interpreter running INLINE SOURCE, else None.
- Everything after ``-c`` is data the inline program receives, not this process's own identity.
- The detached gateway restart watcher (``gateway._spawn_gateway_restart_watcher``) is spawned as
- ``python -c <watcher source> <old_pid> <python> -m hermes_cli.main gateway run``: its trailing
- argv is the command the watcher will LATER spawn, so every argv matcher used to read it as a
- live gateway. See #107002 and the "never infer process identity from argv substrings" rule.
- Only interpreter options may precede ``-c``; the first non-option token ends the option block
- (``python -m hermes_cli.main …`` therefore never matches).
- The walk is VALUE-AWARE: ``-X``/``-W``/``-Q`` and ``--check-hash-based-pycs``/``--jit`` take a
- SEPARATE operand, so a naive "first non-option token ends the block" walk mistakes that operand
- for the end of the block and never reaches the ``-c`` behind it (``python -X utf8 -c <src> …``
- was still read as a live gateway). The operand sets are the canonical ones in
- ``hermes_state_holders``, not a second hand-rolled copy.
- *tokens* must be CASE-PRESERVING: the operand-taking ``-Q``/``-W``/``-X`` differ from the
- operand-less ``-q``/``-b``, so a lowercased argv would skip the token after a plain ``-q``.
- """
- from hermes_state_holders import (
- _PYTHON_LONG_OPTIONS_WITH_OPERANDS,
- _PYTHON_SHORT_OPTIONS_WITH_OPERANDS,
- )
- index = 1
- while index < len(tokens):
- token = tokens[index]
- if token == "--":
- return None
- if token in _PYTHON_LONG_OPTIONS_WITH_OPERANDS:
- index += 2 # the next token is this option's operand, not the end of the option block
- continue
- if token.startswith("--"):
- index += 1 # ``--opt=value`` and operand-less long options
- continue
- if not token.startswith("-") or token == "-":
- return None
- # Clustered short options (``-uc``, ``-IsB``). An operand-taking letter consumes the rest of
- # the cluster as its attached value, or the following token when the cluster ends there --
- # so ``-Xc`` is ``-X c``, NOT an inline-source ``-c``.
- cluster = token[1:]
- for position, letter in enumerate(cluster):
- if letter == "c":
- return index
- if letter in _PYTHON_SHORT_OPTIONS_WITH_OPERANDS:
- index += 1 if cluster[position + 1 :] else 2
- break
- else:
- index += 1
- return None
- def command_line_runs_inline_source(tokens: list[str]) -> bool:
- """True when *tokens* is an interpreter running INLINE SOURCE (``python -c <src> [args]``)."""
- return inline_source_flag_index(tokens) is not None
- # Hermes' own inline bootstraps hand control to a Hermes entry point IN this process, so the argv
- # they run with is this process's own identity; every other ``-c`` program keeps its trailing argv
- # as data (#107002). Each pattern is one emitted source shape, anchored at both ends so a program
- # merely CARRYING a bootstrap command line (the restart watcher's respawn argv) never matches.
- _Q = r"""['"]?"""
- _MAIN = rf"{_Q}__main__{_Q}"
- _RUN_MODULE = rf"runpy\.run_module\(\s*{_Q}(?P<target>[\w.]+){_Q}\s*,\s*run_name\s*=\s*{_MAIN}\s*,\s*alter_sys\s*=\s*True\s*\)"
- _BOOTSTRAPS = (
- # hermes_cli._launchers.runtime_command (store launcher, the Windows updater's relaunch)
- ("module", re.compile(rf"import os, sys, runpy;.*\b{_RUN_MODULE}", re.DOTALL)),
- # hermes_cli.venv_sync.relaunch_command: argv is assigned inside the source
- ("module", re.compile(rf"import sys, runpy; sys\.path\.insert\(.*\b{_RUN_MODULE}", re.DOTALL)),
- ("path", re.compile(
- rf"import sys, runpy; sys\.path\.insert\(.*\brunpy\.run_path\(\s*{_Q}(?P<target>[^'\"]+?){_Q}\s*,\s*run_name\s*=\s*{_MAIN}\s*\)",
- re.DOTALL)),
- # hermes_cli.venv_sync.relaunch_command re-entering a ``-c`` launcher: the launcher's source is
- # exec'd as a string literal, its argv assigned before it; resolved through the rows above/below
- ("exec", re.compile(r"import sys, runpy; sys\.path\.insert\(.*?;\s*exec\((?P<target>.+)\)", re.DOTALL)),
- # hermes_cli._launchers._launcher_script (the published POSIX shell / Windows .cmd launcher)
- ("entry", re.compile(r"import os, re, sys\s.*\bfrom\s+(?P<target>[\w.]+)\s+import\s+(?P<func>\w+)\b.*\bsys\.exit\(\s*(?P=func)\(\)\s*\)", re.DOTALL)),
- # scripts/build/launchers.py::posix_launcher (the bundled/Docker payload's bin/hermes). Spelled out
- # statement by statement: a ``.*`` would span a carrier's source plus the launcher argv it carries.
- # Only the ``hermes`` entry: the same shape importing any other module is someone else's program.
- ("module", re.compile(
- rf"import os, site, sys;\s*sys\.argv\[0\]\s*=\s*{_Q}[\w.-]+{_Q};\s*"
- rf"site\.addsitedir\(os\.environ\[{_Q}HERMES_SITE{_Q}\]\);"
- r"\s*from\s+(?P<target>hermes_cli\.main)\s+import\s+main\s*;\s*sys\.exit\(\s*main\(\)\s*\)")),
- # hermes_cli._launchers._write_cmd_launcher: the launcher script, base64-encoded
- ("base64", re.compile(rf"import base64; exec\(base64\.b64decode\({_Q}(?P<target>[A-Za-z0-9+/=]+){_Q}\)\)")),
- )
- _ASSIGNED_ARGV = re.compile(r"\bsys\.argv\s*=\s*\[(.*?)\]\s*;")
- _EXEC_LAUNCHER = re.compile(
- # no ``\b`` before ``from``/``sys``: an escaped newline normalizes to ``/n`` and abuts them
- r"import os, re, sys\W.*?from\s+(?P<target>[\w.]+)\s+import\s+(?P<func>\w+)\b.*sys\.exit\(\s*(?P=func)\(\)\s*\)", re.DOTALL)
- _EXEC_BASE64 = re.compile(r"import base64; exec\(base64\.b64decode\(\W*(?P<b64>[A-Za-z0-9+/=]+)")
- def _bootstrap_entry(source: str, argv: list[str]) -> list[str] | None:
- """``[-m, <module>, *argv]`` (or ``[<path>, *argv]``) the inline *source* runs in-process, else None."""
- source = source.strip()
- kind, match = next(((k, m) for k, p in _BOOTSTRAPS if (m := p.fullmatch(source))), (None, None))
- if match is None:
- return None
- target = match["target"]
- if kind == "base64":
- import base64
- import binascii
- try:
- return _bootstrap_entry(base64.b64decode(target, validate=True).decode("utf-8"), argv)
- except (binascii.Error, UnicodeDecodeError):
- return None
- if kind == "exec":
- # The launcher source is a string literal here, and readers normalize its escapes (``\\n`` ->
- # ``/n``), so it is matched in place by the launcher row's anchors, never decoded.
- if assigned := _ASSIGNED_ARGV.search(source):
- argv = [item.strip().strip("'\"") for item in assigned.group(1).split(",")][1:]
- if wrapped := _EXEC_BASE64.search(target): # the .cmd launcher: its script, base64-encoded
- import base64
- import binascii
- try:
- return _bootstrap_entry(base64.b64decode(wrapped["b64"], validate=True).decode("utf-8"), argv)
- except (binascii.Error, UnicodeDecodeError):
- return None
- launcher = _EXEC_LAUNCHER.search(target)
- if launcher is None:
- return None
- kind, target = "entry", launcher["target"]
- if kind == "entry": # the launcher script's own ``--run-module <module>`` switch
- return ["-m", argv[1], *argv[2:]] if argv[:1] == ["--run-module"] and len(argv) > 1 else ["-m", target, *argv]
- if assigned := _ASSIGNED_ARGV.search(source):
- argv = [item.strip().strip("'\"") for item in assigned.group(1).split(",")][1:]
- return [target, *argv] if kind == "path" else ["-m", target, *argv]
- def inline_bootstrap_argv(tokens: list[str]) -> list[str] | None:
- """*tokens* as the equivalent ``python -m <module> <argv…>`` when this interpreter's ``-c`` source
- is a Hermes bootstrap running an entry point in-process; None for any other inline source.
- Command lines usually arrive space-joined (``/proc``, psutil, ``ps``), which splits the source
- across tokens; the shortest token run that ends in a recognised tail is the source, whatever
- joined it, and the tokens after it are the entry point's argv.
- """
- index = inline_source_flag_index(tokens)
- if index is None:
- return None
- for end in range(index + 1, len(tokens)):
- if tokens[end].rstrip().endswith(")"):
- entry = _bootstrap_entry(" ".join(tokens[index + 1 : end + 1]), tokens[end + 1 :])
- if entry is not None:
- return [tokens[0], *entry]
- return None
|