splent-cli 1.33.0__tar.gz → 1.33.1__tar.gz

{splent_cli-1.33.0/src/splent_cli.egg-info → splent_cli-1.33.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.33.0
+Version: 1.33.1
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 Project-URL: Homepage, https://github.com/diverso-lab/splent_cli

{splent_cli-1.33.0 → splent_cli-1.33.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.33.0"
+version = "1.33.1"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"

{splent_cli-1.33.0 → splent_cli-1.33.1}/src/splent_cli/commands/feature/feature_test.py

@@ -47,6 +47,42 @@ def _container_running(name: str) -> bool:
 
 _PASSTHROUGH_ENV = ("PYTEST_ADDOPTS", "PYTHONDONTWRITEBYTECODE")
 
+# One test run at a time in a product's container: the runs share its test
+# database, and two at once fail each other's tests.
+TEST_LOCK = "/tmp/splent-feature-test.lock"
+
+
+def _tied_to_the_cli(command: str, lock: str = TEST_LOCK) -> str:
+    """``command`` as a script that stops when the CLI that started it does.
+
+    A docker exec without a terminal forwards no signal, so a Ctrl-C, or a
+    release stopped halfway, used to kill only the CLI. The tests went on in
+    the container against the test database, and the next run, started
+    beside them, failed in ways the code under test had nothing to do with.
+
+    The CLI holds the exec's stdin open while it runs (see
+    _delegate_to_web_container). When the CLI goes, stdin closes, and the
+    watcher stops the whole run. A run that finds another one holding the
+    lock waits for it instead of running beside it.
+    """
+    return f"""set -m
+exec 3<&0
+if command -v flock >/dev/null 2>&1; then
+  exec 9>{lock}
+  if ! flock -n 9; then
+    echo "  Another test run is using this product's test database. Waiting for it to finish..."
+    flock 9
+  fi
+fi
+( {command} ) </dev/null &
+run=$!
+( exec 9>&-; cat <&3 >/dev/null; kill -TERM -- -$run 2>/dev/null ) &
+watch=$!
+wait $run
+rc=$?
+kill -- -$watch 2>/dev/null
+exit $rc"""
+
 
 def _delegate_to_web_container(argv: list[str]) -> None:
     """Re-run this command inside the product's web container, and exit.
@@ -80,20 +116,29 @@ def _delegate_to_web_container(argv: list[str]) -> None:
         value = os.environ.get(var)
         if value:
             passthrough += ["-e", f"{var}={value}"]
-    result = run(
-        [
-            "docker",
-            "exec",
-            "-e",
-            f"SPLENT_APP={context.require_app()}",
-            *passthrough,
-            name,
-            "bash",
-            "-lc",
-            command,
-        ],
-        check=False,
-    )
+    # The exec reads a pipe only this process writes to, so it sees the end
+    # of its input exactly when this process ends, however it ends.
+    read_end, write_end = os.pipe()
+    try:
+        result = run(
+            [
+                "docker",
+                "exec",
+                "-i",
+                "-e",
+                f"SPLENT_APP={context.require_app()}",
+                *passthrough,
+                name,
+                "bash",
+                "-lc",
+                _tied_to_the_cli(command),
+            ],
+            check=False,
+            stdin=read_end,
+        )
+    finally:
+        os.close(read_end)
+        os.close(write_end)
     raise SystemExit(result.returncode)
 
 

{splent_cli-1.33.0 → splent_cli-1.33.1}/src/splent_cli/commands/product/product_restart.py

@@ -8,6 +8,7 @@ In production it restarts the web container, whose command is the entrypoint.
 
 import os
 import subprocess
+import time
 import tomllib
 
 import click
@@ -179,6 +180,196 @@ KILL_DEV_SERVER = (
 )
 
 
+# ── Waiting for the app ──────────────────────────────────────────────
+
+# Where a development container writes what the app and the entrypoint say:
+# the start script sends Flask's output to the first, and the entrypoint,
+# run as root, tees its steps into the second.
+DEV_LOGS = ("/var/log/entrypoint.log", "/var/log/splent/entrypoint.log")
+
+# How long the app gets to answer after a restart. A full restart reinstalls
+# the dependencies and compiles the assets first, and production runs its
+# migrations before gunicorn binds (its healthcheck allows 180 s).
+START_TIMEOUT = {"quick": 120, "full": 600, "prod": 180}
+START_POLL = 1.0
+
+# What only a start that failed writes. watchmedo starts Flask again every
+# time it exits, so a broken app never stops, it only prints its traceback
+# over and over. The entrypoint marks a failed step with FAIL.
+START_FAILURES = (
+    "Traceback (most recent call last)",
+    "Error: While importing",
+    "Error: Could not import",
+    "Error: Could not locate",
+    "is in use by another program",
+    "  FAIL ",
+)
+
+LOG_TAIL_LINES = 25
+
+
+def _exec(container_id: str, script: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["docker", "exec", container_id, "sh", "-c", script],
+        capture_output=True,
+        text=True,
+    )
+
+
+def _log_sizes(container_id: str, paths=DEV_LOGS) -> dict[str, int]:
+    """Size of each log now, so only what the restart writes is read later."""
+    sizes = {}
+    for path in paths:
+        result = _exec(container_id, f"stat -c %s {path} 2>/dev/null || echo 0")
+        try:
+            sizes[path] = int(result.stdout.strip() or 0)
+        except ValueError:
+            sizes[path] = 0
+    return sizes
+
+
+def _written_since(container_id: str, sizes: dict[str, int]) -> str:
+    """What the logs gained since ``sizes`` were taken."""
+    parts = []
+    for path, size in sizes.items():
+        result = _exec(
+            container_id,
+            f"[ -f {path} ] || exit 0; "
+            f'if [ "$(stat -c %s {path})" -lt {size} ]; then cat {path}; '
+            f"else tail -c +{size + 1} {path}; fi",
+        )
+        if result.stdout:
+            parts.append(result.stdout)
+    return "".join(parts)
+
+
+def _http_status(container_id: str) -> int | None:
+    """Status the app answers on port 5000 inside its container, or None."""
+    result = _exec(
+        container_id,
+        "curl -s -o /dev/null -w '%{http_code}' --max-time 3 http://localhost:5000/",
+    )
+    try:
+        status = int(result.stdout.strip()[-3:])
+    except ValueError:
+        return None
+    return status or None
+
+
+def _container_state(container_id: str) -> tuple[str, int, int]:
+    """(status, exit code, restart count) of the container."""
+    result = subprocess.run(
+        [
+            "docker",
+            "inspect",
+            "-f",
+            "{{.State.Status}} {{.State.ExitCode}} {{.RestartCount}}",
+            container_id,
+        ],
+        capture_output=True,
+        text=True,
+    )
+    fields = result.stdout.split()
+    if result.returncode != 0 or len(fields) != 3:
+        return "missing", 0, 0
+    return fields[0], int(fields[1]), int(fields[2])
+
+
+def _tail(text: str, lines: int = LOG_TAIL_LINES) -> str:
+    return "\n".join(text.strip().splitlines()[-lines:])
+
+
+def _last_failure(text: str) -> str:
+    """The end of the log from its last traceback on.
+
+    watchmedo starts the broken app again and again, so the log repeats the
+    same error; once is enough. Flask's own "Error: While importing" line,
+    just above the traceback, stays with it.
+    """
+    at = text.rfind("Traceback (most recent call last)")
+    if at < 0:
+        return _tail(text)
+    error = text.rfind("Error: ", 0, at)
+    if error >= 0 and text.count("\n", error, at) <= 3:
+        at = error
+    return _tail(text[text.rfind("\n", 0, at) + 1 :])
+
+
+def wait_for_dev_start(container_id, sizes, timeout, poll=START_POLL):
+    """Wait for a development app to answer after a restart.
+
+    Returns ``(None, "")`` once it answers, any status included, since a 500
+    is the application's own error and the browser shows it. Otherwise
+    returns why it did not start and the end of what its logs said.
+    """
+    deadline = time.monotonic() + timeout
+    announced = False
+    while True:
+        if _http_status(container_id):
+            return None, ""
+        written = _written_since(container_id, sizes)
+        if any(marker in written for marker in START_FAILURES):
+            return "the app failed to start", _last_failure(written)
+        if time.monotonic() >= deadline:
+            return f"the app did not answer within {timeout} s", _tail(written)
+        if not announced:
+            click.echo(click.style("  waiting ", dim=True) + "for the app to answer...")
+            announced = True
+        time.sleep(poll)
+
+
+def wait_for_prod_start(container_id, timeout, poll=START_POLL):
+    """Wait for a restarted production container to answer below 500.
+
+    The same bar as the image's healthcheck, which the autodeploy agent
+    rolls back on. Returns ``(None, "")`` once it is met, otherwise why not
+    and the end of the container's log.
+    """
+    _, _, restarts = _container_state(container_id)
+    deadline = time.monotonic() + timeout
+    announced = False
+    reason = None
+    while reason is None:
+        status, exit_code, count = _container_state(container_id)
+        if status in ("exited", "dead", "missing"):
+            reason = f"the container stopped (exit code {exit_code})"
+            break
+        if count > restarts:
+            reason = "the container keeps restarting"
+            break
+        code = _http_status(container_id) if status == "running" else None
+        if code and code < 500:
+            return None, ""
+        if time.monotonic() >= deadline:
+            reason = (
+                f"the app answers HTTP {code}"
+                if code
+                else f"the app did not answer within {timeout} s"
+            )
+            break
+        if not announced:
+            click.echo(click.style("  waiting ", dim=True) + "for the app to answer...")
+            announced = True
+        time.sleep(poll)
+    logs = subprocess.run(
+        ["docker", "logs", "--tail", str(LOG_TAIL_LINES), container_id],
+        capture_output=True,
+        text=True,
+    )
+    return reason, _tail((logs.stdout or "") + (logs.stderr or ""))
+
+
+def _report_start_failure(product, env, reason, log_tail, log_hint):
+    click.secho(f"  {product} ({env}) did not start, {reason}.", fg="red")
+    if log_tail:
+        click.echo()
+        for line in log_tail.splitlines():
+            click.echo(click.style("    ", dim=True) + line)
+        click.echo()
+    click.echo(f"  See the whole log with  {log_hint}")
+    raise SystemExit(1)
+
+
 # ── Command ──────────────────────────────────────────────────────────
 
 
@@ -257,9 +448,33 @@ def product_restart(env_dev, env_prod, full):
                 )
                 raise SystemExit(1)
 
+    # ── The env file the start reads ──────────────────────────────
+    # The start sources docker/.env with bash first, in a detached exec whose
+    # errors nobody sees. Read it now, before the running app is stopped, so
+    # a line bash cannot read is reported here and the app keeps running.
+    env_check = (
+        None
+        if env == "prod"
+        else _exec(
+            container_id, f"bash -c 'set -a && . /workspace/{product}/docker/.env'"
+        )
+    )
+    if env_check is not None and env_check.returncode != 0:
+        detail = (env_check.stderr or env_check.stdout or "").strip()
+        click.secho(
+            f"  {product}/docker/.env cannot be read by bash, so the app would "
+            "not start. Nothing was restarted.",
+            fg="red",
+        )
+        if detail:
+            click.secho(f"    {_tail(detail, 5)}", fg="red")
+        click.echo(f"  Write it again with  splent product:env --merge --{env}")
+        raise SystemExit(1)
+
     # ── Restart feature Docker containers (nginx, redis, etc.) ──
     features = _get_feature_order(workspace, product_path, env)
     restarted = 0
+    services_failed: list[str] = []
     for feat in features:
         clean = compose.normalize_feature_ref(feat)
         feat_docker = compose.feature_docker_dir(workspace, clean)
@@ -294,6 +509,10 @@ def product_restart(env_dev, env_prod, full):
             restarted += 1
         else:
             click.echo(click.style(" ✗", fg="red"))
+            detail = (result.stderr or result.stdout or "").strip()
+            if detail:
+                click.secho(f"      {_tail(detail, 3)}", fg="red")
+            services_failed.append(short)
 
     # ── Production: restart the web container ─────────────────────
     # Its command is the entrypoint, which ends by running gunicorn in the
@@ -314,7 +533,16 @@ def product_restart(env_dev, env_prod, full):
             if detail:
                 click.secho(f"    {detail}", fg="red")
             raise SystemExit(1)
-        click.secho("  done.", fg="green")
+        reason, log_tail = wait_for_prod_start(container_id, START_TIMEOUT["prod"])
+        if reason:
+            _report_start_failure(
+                product,
+                env,
+                reason,
+                log_tail,
+                f"docker logs {container_id[:12]}",
+            )
+        _finish(services_failed)
         return
 
     # ── Kill existing processes ───────────────────────────────────
@@ -322,6 +550,8 @@ def product_restart(env_dev, env_prod, full):
         ["docker", "exec", container_id, "bash", "-c", KILL_DEV_SERVER],
         capture_output=True,
     )
+    # What the logs hold now, so a failure is told from what this start writes.
+    sizes = _log_sizes(container_id)
 
     if full:
         click.echo(
@@ -335,10 +565,9 @@ def product_restart(env_dev, env_prod, full):
         start_script = _start_script(product, env)
         source_cmd = f"set -a && . /workspace/{product}/docker/.env && set +a && bash {start_script}"
 
-    # ``-d`` detaches, so this returncode reflects whether the app could be
-    # *launched* in the container (container reachable, exec accepted), not the
-    # eventual health of the app. A non-zero exit here means the start never
-    # happened, so don't claim success.
+    # ``-d`` detaches, so this returncode only says whether the start could be
+    # launched in the container. Whether the app came up is what the wait
+    # below finds out.
     result = run(
         ["docker", "exec", "-d", container_id, "bash", "-c", source_cmd],
         check=False,
@@ -351,6 +580,30 @@ def product_restart(env_dev, env_prod, full):
             click.secho(f"    {detail}", fg="red")
         raise SystemExit(1)
 
+    reason, log_tail = wait_for_dev_start(
+        container_id, sizes, START_TIMEOUT["full" if full else "quick"]
+    )
+    if reason:
+        log_path = DEV_LOGS[1] if full else DEV_LOGS[0]
+        _report_start_failure(
+            product,
+            env,
+            reason,
+            log_tail,
+            f"docker exec {container_id[:12]} tail -n 100 {log_path}",
+        )
+    _finish(services_failed)
+
+
+def _finish(services_failed: list[str]) -> None:
+    """Say done only when everything restarted."""
+    if services_failed:
+        click.secho(
+            f"  The app is up, but {len(services_failed)} feature service(s) did "
+            f"not restart: {', '.join(services_failed)}.",
+            fg="red",
+        )
+        raise SystemExit(1)
     click.secho("  done.", fg="green")
 
 

{splent_cli-1.33.0 → splent_cli-1.33.1/src/splent_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.33.0
+Version: 1.33.1
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 Project-URL: Homepage, https://github.com/diverso-lab/splent_cli