caffeinated-whale-cli 3.2.0__tar.gz → 3.2.1__tar.gz

{caffeinated_whale_cli-3.2.0 → caffeinated_whale_cli-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: caffeinated-whale-cli
-Version: 3.2.0
+Version: 3.2.1
 Summary: A CLI tool to help manage Frappe Docker instances.
 Author-email: Christopher McKay <mckay.christopher73@outlook.com>
 License: MIT

{caffeinated_whale_cli-3.2.0 → caffeinated_whale_cli-3.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "caffeinated-whale-cli"
-version = "3.2.0"
+version = "3.2.1"
 authors = [
   { name = "Christopher McKay", email = "mckay.christopher73@outlook.com" },
 ]

caffeinated_whale_cli-3.2.1/src/caffeinated_whale_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.2.1"

{caffeinated_whale_cli-3.2.0 → caffeinated_whale_cli-3.2.1}/src/caffeinated_whale_cli/core/supervision.py

@@ -51,6 +51,7 @@ never returned across a boundary; every return is plain serializable data.
 from __future__ import annotations
 
 import json
+import re
 import shlex
 import time
 from collections.abc import Callable
@@ -1230,6 +1231,89 @@ def _resync_failed(text: str, restarted: list[str]) -> ResyncOutcome:
     return ResyncOutcome(attempted=True, restarted=list(restarted), unserved_sites=[], error=text)
 
 
+# A bench's ``common_site_config.json`` MAY legitimately omit ``webserver_port`` -
+# a DNS-multitenant bench (many domain-named sites) removes it deliberately so
+# Frappe routes purely by Host header, not by a port cwcli would otherwise read as
+# a fixed default. `resolve_assigned_ports(fill_defaults=False)` reports that the
+# same way it reports a genuinely unreadable config: absent. Below, "the config has
+# no port" is answered with EVIDENCE instead - the live web process's own bound
+# port, from its argv - never a bare guess.
+_PORT_FLAG_RE = re.compile(r"--port[=\s]+(\d+)")
+_BIND_FLAG_RE = re.compile(r"(?:--bind|-b)[=\s]+\S*:(\d+)")
+_LISTENER_OWNERSHIP_SCRIPT = r"""
+import os
+import sys
+
+pid = int(sys.argv[1])
+port = int(sys.argv[2])
+bench = os.path.realpath(sys.argv[3])
+try:
+    cwd = os.path.realpath(f"/proc/{pid}/cwd")
+    if os.path.commonpath((cwd, bench)) != bench:
+        raise OSError
+    inodes = set()
+    for fd in os.listdir(f"/proc/{pid}/fd"):
+        try:
+            target = os.readlink(f"/proc/{pid}/fd/{fd}")
+        except OSError:
+            continue
+        if target.startswith("socket:[") and target.endswith("]"):
+            inodes.add(target[8:-1])
+    for table in ("/proc/net/tcp", "/proc/net/tcp6"):
+        with open(table, encoding="ascii") as rows:
+            next(rows)
+            for row in rows:
+                fields = row.split()
+                local_port = int(fields[1].rsplit(":", 1)[1], 16)
+                if fields[3] == "0A" and local_port == port and fields[9] in inodes:
+                    raise SystemExit(0)
+except (OSError, ValueError):
+    raise SystemExit(2)
+raise SystemExit(1)
+""".strip()
+
+
+def _port_from_process(container, pid: int) -> int | None:
+    """The bound port of ``pid``, read from its own argv - evidence, not a guess.
+
+    bench bakes the bench's real assigned port into the Procfile's ``web:`` line at
+    init (``bench serve --port <N>``), so once that line is running its cmdline IS
+    the truth; a gunicorn-fronted web instead carries ``--bind``/``-b <host>:<N>``.
+    Returns None when the process is gone or its argv names no port at all (a bare
+    ``bench serve`` with no ``--port``, which defers to Frappe's own default).
+    """
+    for row in _ps_rows(container):
+        if row.pid != pid:
+            continue
+        match = _PORT_FLAG_RE.search(row.args) or _BIND_FLAG_RE.search(row.args)
+        return int(match.group(1)) if match else None
+    return None
+
+
+def _process_owns_listener(container, pid: int, port: int, bench_path: str) -> bool:
+    """Return whether this bench's process owns the listener on ``port``."""
+    exit_code, _output = container.exec_run(
+        ["python3", "-c", _LISTENER_OWNERSHIP_SCRIPT, str(pid), str(port), bench_path]
+    )
+    return bool(exit_code == 0)
+
+
+def _resync_web_port(container, bench_path: str, web_pid: int | None) -> int | None:
+    ports = resolvers.resolve_assigned_ports(container, [bench_path], fill_defaults=False).get(
+        bench_path
+    )
+    if ports is not None:
+        return ports[0]
+    process_port = _port_from_process(container, web_pid) if web_pid is not None else None
+    if process_port is not None:
+        return process_port
+    if web_pid is not None and _process_owns_listener(
+        container, web_pid, resolvers.WEB_CONTAINER_BASE, bench_path
+    ):
+        return resolvers.WEB_CONTAINER_BASE
+    return None
+
+
 def resync_after_code_change(
     container,
     bench_path: str,
@@ -1280,6 +1364,18 @@ def resync_after_code_change(
       bound-port-shaped claim, and serving stale code is exactly the class of defect a
       claim like that misses. Every site the caller names must answer a real
       site-routed request before the outcome is ``ok``.
+    - **An absent ``webserver_port`` is not a read failure.** A DNS-multitenant
+      bench (many domain-named sites) deliberately removes it from
+      ``common_site_config.json`` so Frappe routes purely by Host header; a bench
+      like that used to fail here with "the bench's assigned port could not be
+      read", even though the update itself had already succeeded. The probe port
+      now falls back to EVIDENCE - the live web process's own bound port (its argv
+      carries bench's real assignment, baked into the Procfile's ``web:`` line at
+      init), then Frappe's own unconfigured default only when that listener is
+      proven to belong to this bench's web process - before the sites are probed
+      for real. Missing evidence fails honestly without probing a sibling bench or
+      blaming a config key that was never supposed to exist.
+      See :func:`_port_from_process`.
     """
     announce = on_restart or (lambda _program: None)
     unique_sites = list(dict.fromkeys(sites))
@@ -1290,6 +1386,7 @@ def resync_after_code_change(
 
     restarted: list[str] = []
     supervised = False
+    web_port: int | None
     try:
         supervised = discover_stack(container, bench_path, required=True).supervisor_up
         if supervised:
@@ -1304,6 +1401,7 @@ def resync_after_code_change(
             # is no site to verify against, and starting one is not this verb's job.
             if states[web][0] not in _LIVE_STATES:
                 return quiet
+            web_port = _resync_web_port(container, bench_path, states[web][1])
 
             for program in code_bearing_programs(list(states)):
                 if states[program][0] not in _LIVE_STATES:
@@ -1320,21 +1418,24 @@ def resync_after_code_change(
                         restarted,
                     )
                 restarted.append(program)
-        elif not discover_unsupervised_stack(container, bench_path, required=True).manager_up:
-            return quiet
+        else:
+            unsupervised = discover_unsupervised_stack(container, bench_path, required=True)
+            if not unsupervised.manager_up:
+                return quiet
+            web_process = next((p for p in unsupervised.processes if p.label == "web"), None)
+            web_port = _resync_web_port(
+                container, bench_path, web_process.pid if web_process is not None else None
+            )
 
-        ports = resolvers.resolve_assigned_ports(container, [bench_path], fill_defaults=False).get(
-            bench_path
-        )
-        if ports is None:
+        if web_port is None:
             return _resync_failed(
-                "the bench's assigned port could not be read, so cwcli could not confirm "
-                "the affected sites serve",
+                "the bench's serving port could not be determined safely, so cwcli could not "
+                "confirm the affected sites serve",
                 restarted,
             )
 
         pending, codes = _wait_for_serving_sites(
-            container, port=ports[0], sites=unique_sites, timeout=timeout
+            container, port=web_port, sites=unique_sites, timeout=timeout
         )
         if pending:
             observed = ", ".join(f"{site}={codes[site] or 'unreachable'}" for site in pending)

caffeinated_whale_cli-3.2.0/src/caffeinated_whale_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "3.2.0"