wasm-cli 1.0.2__tar.gz → 1.1.0__tar.gz

{wasm_cli-1.0.2/src/wasm_cli.egg-info → wasm_cli-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wasm-cli
-Version: 1.0.2
+Version: 1.1.0
 Summary: Web App System Management - Deploy and manage web applications on Linux servers
 Author: Yago López Prado
 Author-email: Yago López Prado <yago.lopez.adeje@gmail.com>

{wasm_cli-1.0.2 → wasm_cli-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wasm-cli"
-version = "1.0.2"
+version = "1.1.0"
 description = "Web App System Management - Deploy and manage web applications on Linux servers"
 readme = "README.md"
 license = { text = "WASM-NCSAL" }

{wasm_cli-1.0.2 → wasm_cli-1.1.0}/setup.py

@@ -9,7 +9,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="wasm-cli",
-    version="1.0.2",
+    version="1.1.0",
     description="Web App System Management - Deploy and manage web applications on Linux servers",
     author="Yago López Prado",
     author_email="yago.lopez.adeje@gmail.com",

{wasm_cli-1.0.2 → wasm_cli-1.1.0}/src/wasm/__init__.py

@@ -15,7 +15,7 @@ from importlib.metadata import version as _installed_version
 #: as an OBS build directory. The single source of truth is the ``version``
 #: field of pyproject.toml; ``scripts/release.py`` keeps this literal and the
 #: distribution packaging files in step with it.
-_FALLBACK_VERSION = "1.0.2"
+_FALLBACK_VERSION = "1.1.0"
 
 try:
     __version__ = _installed_version("wasm-cli")

{wasm_cli-1.0.2 → wasm_cli-1.1.0}/src/wasm/cli/commands/health.py

@@ -28,11 +28,11 @@ from datetime import datetime
 import click
 
 from wasm.cli.app import Context, pass_context
+from wasm.core.app_state import RUNNING, STATIC, resolve_states
 from wasm.core.config import Config
-from wasm.core.exceptions import ServiceError, WASMError
+from wasm.core.exceptions import WASMError
 from wasm.core.logger import Logger
 from wasm.core.store import get_store
-from wasm.core.utils import domain_to_app_name
 from wasm.managers.apache_manager import ApacheManager
 from wasm.managers.cert_manager import CertificateInfo, CertManager
 from wasm.managers.nginx_manager import NginxManager
@@ -50,21 +50,14 @@ def _print_status(logger: Logger, key: str, value: str, status: str) -> None:
     Print a key-value pair with status indicator.
 
     Args:
-        logger: Logger of the current command, kept for signature stability.
+        logger: Logger of the current command. Writing through it is what makes
+            ``wasm --no-color health`` colourless; the escape codes used to be
+            written to stdout directly, so the flag did nothing here.
         key: Name of the checked item.
         value: Human readable result.
         status: One of "ok", "warning", "error" or "info".
     """
-    if status == "ok":
-        indicator = "\033[32m[OK]\033[0m"
-    elif status == "warning":
-        indicator = "\033[33m[!]\033[0m"
-    elif status == "error":
-        indicator = "\033[31m[X]\033[0m"
-    else:  # info
-        indicator = "\033[34m[i]\033[0m"
-
-    print(f"  {indicator} {key}: {value}")
+    logger.check(key, value, status)
 
 
 def _days_until(expiry: str) -> int | None:
@@ -222,37 +215,35 @@ def run_health_check(verbose: bool = False) -> int:
     service_manager = ServiceManager(verbose=verbose)
 
     apps = store.list_apps()
-    apps_running = 0
-    apps_stopped = 0
-    apps_failed = 0
-
-    for app in apps:
-        try:
-            # The unit was created from domain_to_app_name(); a hand-rolled
-            # replace() disagrees with it for any domain that is not lowercase.
-            status = service_manager.get_status(domain_to_app_name(app.domain))
-        except ServiceError as e:
-            apps_failed += 1
-            warnings.append(f"App '{app.domain}' could not be queried: {e}")
-            continue
-
-        if status.get("active"):
-            apps_running += 1
-        else:
-            apps_stopped += 1
-            warnings.append(f"App '{app.domain}' is not running")
+
+    # The same resolver `wasm list` uses. When these two commands each decided
+    # for themselves what "running" meant, list reported fifteen applications
+    # running while this reported seven stopped, and five of the seven were
+    # static sites that have no service to run in the first place.
+    states = resolve_states(apps, service_manager)
+
+    apps_running = sum(1 for s in states.values() if s.label == RUNNING)
+    apps_static = sum(1 for s in states.values() if s.label == STATIC)
+    unhealthy = [(domain, s) for domain, s in states.items() if not s.healthy]
+
+    for domain, current in unhealthy:
+        warnings.append(f"App '{domain}' - {current.detail or current.label.lower()}")
 
     total_apps = len(apps)
+    served = apps_running + apps_static
     if total_apps > 0:
-        if apps_stopped > 0 or apps_failed > 0:
+        summary = f"{served}/{total_apps} serving"
+        if apps_static:
+            summary += f" ({apps_static} static)"
+        if unhealthy:
             _print_status(
                 logger,
                 "Applications",
-                f"{apps_running}/{total_apps} running, {apps_stopped} stopped",
+                f"{summary}, {len(unhealthy)} need attention",
                 "warning",
             )
         else:
-            _print_status(logger, "Applications", f"{apps_running}/{total_apps} running", "ok")
+            _print_status(logger, "Applications", summary, "ok")
     else:
         _print_status(logger, "Applications", "No applications deployed", "info")
 

{wasm_cli-1.0.2 → wasm_cli-1.1.0}/src/wasm/cli/commands/web.py

@@ -708,6 +708,38 @@ def _prompt_install(missing_apt: list[str], missing_pip: list[str], verbose: boo
 # ---------------------------------------------------------------------------
 
 
+def _port_in_use(host: str, port: int) -> bool:
+    """
+    Ask whether the panel's address is already taken.
+
+    Binding is the only reliable answer: a connection attempt says nothing
+    about a socket bound with no backlog, and reading ``ss`` output means
+    parsing a different format on every distribution.
+
+    Args:
+        host: Address the panel would bind.
+        port: Port the panel would bind.
+
+    Returns:
+        True when binding would fail because something holds the address.
+    """
+    family = socket.AF_INET6 if ":" in _strip_brackets(host) else socket.AF_INET
+    probe = socket.socket(family, socket.SOCK_STREAM)
+    try:
+        # Deliberately not SO_REUSEADDR: with it the bind succeeds against a
+        # socket in TIME_WAIT, which is the case this is meant to catch.
+        probe.bind((_strip_brackets(host), port))
+    except OSError:
+        return True
+    except (ValueError, socket.gaierror):
+        # An address this process cannot even parse is not this check's problem;
+        # the bind that follows will report it properly.
+        return False
+    finally:
+        probe.close()
+    return False
+
+
 def _start(options: StartOptions, verbose: bool, *, dry_run: bool = False) -> int:
     """
     Start the panel, refusing an unsafe exposure first.
@@ -773,6 +805,21 @@ def _start(options: StartOptions, verbose: bool, *, dry_run: bool = False) -> in
             # Process not running, remove stale PID file
             get_fs().remove(pid_file, missing_ok=True)
 
+    # The PID file only catches a panel this machine still has a record of. A
+    # panel whose PID file was removed, or anything else on the port, walked
+    # past that check: the token was printed and then uvicorn failed with a
+    # bare OSError, leaving an operator holding a credential for a server that
+    # never started.
+    if not dry_run and _port_in_use(host, config.port):
+        logger.error(f"Something is already listening on {host}:{config.port}")
+        logger.info("If it is a panel this machine has forgotten about:")
+        logger.info("  wasm web stop")
+        logger.info("To see what holds the port:")
+        logger.info(f"  ss -ltnp 'sport = :{config.port}'")
+        logger.info("Or serve somewhere else:")
+        logger.info(f"  wasm web start --port {config.port + 1}")
+        return 1
+
     if config.ip_whitelist:
         logger.info(f"Only these clients may connect: {', '.join(config.ip_whitelist)}")
     if config.trusted_proxies:

{wasm_cli-1.0.2 → wasm_cli-1.1.0}/src/wasm/cli/commands/webapp.py

@@ -33,15 +33,16 @@ from typing import Any, TypeVar
 import click
 
 from wasm.cli.app import Context, enable_dry_run, pass_context
+from wasm.core.app_state import RUNNING, STATIC, resolve_states
 from wasm.core.config import Config
 from wasm.core.dependencies import check_deployment_ready
 from wasm.core.exceptions import DeploymentError, ServiceError, WASMError
-from wasm.core.logger import Logger, set_colors_disabled
+from wasm.core.logger import Logger, set_colors_disabled, state, styled
 from wasm.core.runner import (
     CommandResult,
     get_runner,
 )
-from wasm.core.store import AppStatus, get_store
+from wasm.core.store import get_store
 from wasm.core.utils import domain_to_app_name, remove_directory
 from wasm.deployers import detect_app_type, get_deployer
 from wasm.deployers.docker_compose import DockerComposeDeployer
@@ -464,30 +465,44 @@ def _list_apps(logger: Logger) -> int:
         logger.info("  wasm deploy -d example.com -s https://github.com/user/repo")
         return 0
 
+    # Asked of systemd and of the port, not read from the status column. That
+    # column is written at deploy time and never again, so it called everything
+    # Running while health, which did ask, reported half of them stopped.
+    states = resolve_states(apps, ServiceManager(verbose=logger.verbose))
+
     headers = ["Domain", "Type", "Status", "Port", "SSL"]
     rows = []
 
-    labels = {
-        AppStatus.RUNNING.value: "Running",
-        AppStatus.STOPPED.value: "Stopped",
-        AppStatus.DEPLOYING.value: "Deploying",
-        AppStatus.FAILED.value: "Failed",
-    }
-
     for app in apps:
-        status_str = labels.get(app.status, "Unknown")
-        port_str = str(app.port) if app.port else "static"
-        ssl_str = "yes" if app.ssl_enabled else "no"
+        current = states[app.domain]
+        rows.append(
+            [
+                styled(app.domain, "bold"),
+                app.app_type,
+                state(current.label),
+                styled(app.port, "") if app.port else state("static"),
+                state("yes") if app.ssl_enabled else state("no"),
+            ]
+        )
 
-        rows.append([app.domain, app.app_type, status_str, port_str, ssl_str])
+    logger.table(headers, rows, justify=["left", "left", "left", "right", "left"])
 
-    logger.table(headers, rows)
+    running = sum(1 for s in states.values() if s.label == RUNNING)
+    static = sum(1 for s in states.values() if s.label == STATIC)
+    unhealthy = [(domain, s) for domain, s in states.items() if not s.healthy]
 
     logger.blank()
-    running = sum(1 for a in apps if a.status == AppStatus.RUNNING.value)
-    static = sum(1 for a in apps if a.is_static)
     logger.info(f"Total: {len(apps)} apps ({running} running, {static} static)")
 
+    # The reason belongs next to the list. Making the operator run a second
+    # command to find out why something says Stopped is how the contradiction
+    # between these two commands went unnoticed for as long as it did.
+    if unhealthy:
+        logger.blank()
+        logger.warning(f"{len(unhealthy)} need attention:")
+        for domain, current in unhealthy:
+            logger.list_item(f"{domain} - {current.detail or current.label.lower()}")
+
     return 0
 
 

{wasm_cli-1.0.2 → wasm_cli-1.1.0}/src/wasm/cli/interactive.py

@@ -34,9 +34,11 @@ class InteractiveMode:
             raise WASMError(
                 "Interactive mode needs questionary, which is missing",
                 details=(
-                    "It is a hard dependency, so this means a broken install.\n"
-                    "  pip install --force-reinstall wasm-cli\n"
-                    "  or, on a distribution package: apt install python3-questionary"
+                    "Every other command works without it. To get it:\n"
+                    "  apt install python3-questionary        Debian 13, Ubuntu 24.04+\n"
+                    "  dnf install python3-questionary        Fedora 42+\n"
+                    "  pip install questionary                anywhere else\n"
+                    "It is not packaged for Debian 12, Ubuntu 22.04 or Leap 15."
                 ),
             )
 

wasm_cli-1.1.0/src/wasm/core/app_state.py

@@ -0,0 +1,205 @@
+# Copyright (c) 2024-2026 Yago Lopez Prado
+# Licensed under WASM-NCSAL 1.0 (Commercial use prohibited)
+# https://github.com/Perkybeet/wasm/blob/main/LICENSE
+
+"""
+One answer to the question "is this application actually working".
+
+``wasm list`` printed the status column from the database and ``wasm health``
+asked systemd, so on the same machine at the same moment list called fifteen
+applications Running while health reported seven of them stopped. Nothing ever
+wrote to that column after a deploy, so list was reading a value that had been
+true once.
+
+Asking systemd instead is necessary but not sufficient. A unit is active while
+the process exists, which includes a service that accepts no connections and
+one systemd is restarting every few seconds because it crashes on startup. Both
+report ``active`` if you catch them between restarts. So the state here is
+decided from four signals:
+
+- what systemd says the unit is doing (ActiveState and SubState),
+- how many times it has been restarted (NRestarts),
+- whether anything answers on the port the application is supposed to serve,
+- and whether the application is static, in which case there is no unit at all
+  and the web server serves the files directly.
+
+The last one is why health warned about five sites that were fine: a static
+site has no systemd unit, so querying one always says "not running".
+"""
+
+from __future__ import annotations
+
+import socket
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from wasm.core.exceptions import ValidationError, WASMError
+from wasm.core.utils import domain_to_app_name
+
+if TYPE_CHECKING:  # pragma: no cover - imported for types only
+    from wasm.core.store import App
+    from wasm.managers.service_manager import ServiceManager
+
+#: How long to wait for a port to accept a connection. The probe runs against
+#: loopback, where anything listening answers immediately; a longer wait would
+#: only make `wasm list` slower on the applications that are already broken.
+PROBE_TIMEOUT = 0.4
+
+#: Labels. These are what the Status column shows, and core.logger.STATE_STYLES
+#: gives each of them its colour.
+RUNNING = "Running"
+RESTARTING = "Restarting"
+NOT_RESPONDING = "No answer"
+STOPPED = "Stopped"
+FAILED = "Failed"
+STATIC = "Static"
+UNKNOWN = "Unknown"
+
+
+@dataclass(frozen=True)
+class AppState:
+    """
+    What is true about one application right now.
+
+    Attributes:
+        label: One word for the Status column.
+        healthy: Whether this needs an operator's attention. Static sites are
+            healthy: there is nothing to run.
+        detail: Why, in a sentence, when the answer is not simply "it works".
+            Empty when there is nothing to explain.
+    """
+
+    label: str
+    healthy: bool
+    detail: str = ""
+
+
+def port_answers(port: int, host: str = "127.0.0.1", timeout: float = PROBE_TIMEOUT) -> bool:
+    """
+    Ask whether anything accepts a connection on a port.
+
+    Args:
+        port: The port the application should be serving.
+        host: Where to look, loopback by default.
+        timeout: Seconds to wait.
+
+    Returns:
+        True when the connection is accepted.
+    """
+    try:
+        with socket.create_connection((host, port), timeout=timeout):
+            return True
+    except (OSError, ValueError):
+        return False
+
+
+def _restart_count(status: dict[str, Any]) -> int:
+    """
+    Read NRestarts out of a status dictionary.
+
+    Args:
+        status: What ServiceManager.get_status returned.
+
+    Returns:
+        The restart count, and 0 when systemd did not report one.
+    """
+    try:
+        return int(str(status.get("restarts", "0")).strip() or 0)
+    except ValueError:
+        return 0
+
+
+def resolve_state(
+    app: App,
+    service_manager: ServiceManager,
+    *,
+    probe: bool = True,
+) -> AppState:
+    """
+    Work out what is true about one application.
+
+    Args:
+        app: The application record.
+        service_manager: Used to ask systemd about the unit.
+        probe: Whether to check that the port answers. Turn it off where the
+            extra connection is not wanted; the systemd signals still apply.
+
+    Returns:
+        The state, ready to be shown or counted.
+    """
+    if app.is_static:
+        return AppState(STATIC, healthy=True, detail="served directly by the web server")
+
+    try:
+        status = service_manager.get_status(domain_to_app_name(app.domain))
+    except (WASMError, ValidationError) as error:
+        return AppState(UNKNOWN, healthy=False, detail=str(error))
+
+    active_state = str(status.get("active_state", "")).strip()
+    sub_state = str(status.get("sub_state", "")).strip()
+    restarts = _restart_count(status)
+
+    if not status.get("exists", True) and not status.get("active"):
+        return AppState(STOPPED, healthy=False, detail="there is no systemd unit for it")
+
+    if active_state == "failed" or sub_state == "failed":
+        reason = str(status.get("result", "")).strip()
+        detail = f"systemd gave up on it ({reason})" if reason else "systemd gave up on it"
+        return AppState(FAILED, healthy=False, detail=detail)
+
+    # A crash loop: systemd keeps starting it and it keeps dying. Between two
+    # restarts the unit reads as active, which is how this got reported as
+    # Running for as long as it did.
+    if sub_state == "auto-restart" or active_state == "activating":
+        detail = f"restarted {restarts} times; check the logs with wasm service logs {app.domain}"
+        return AppState(RESTARTING, healthy=False, detail=detail)
+
+    if not status.get("active"):
+        return AppState(STOPPED, healthy=False, detail="the unit is not running")
+
+    # systemd is satisfied. That only means a process exists, so ask the
+    # application itself.
+    if probe and app.port and not port_answers(app.port):
+        return AppState(
+            NOT_RESPONDING,
+            healthy=False,
+            detail=f"the unit is up but nothing accepts connections on port {app.port}",
+        )
+
+    if restarts:
+        return AppState(RUNNING, healthy=True, detail=f"answering, after {restarts} restarts")
+
+    return AppState(RUNNING, healthy=True)
+
+
+def resolve_states(
+    apps: list[App],
+    service_manager: ServiceManager,
+    *,
+    probe: bool = True,
+) -> dict[str, AppState]:
+    """
+    Resolve several applications at once.
+
+    Each one costs three systemctl calls and possibly a connection attempt, so
+    fifteen applications in sequence is a visible pause before `wasm list`
+    prints anything. They are independent, so they run together.
+
+    Args:
+        apps: The applications to resolve.
+        service_manager: Used to ask systemd about the units.
+        probe: Whether to check that the ports answer.
+
+    Returns:
+        The state of each application, keyed by domain.
+    """
+    if not apps:
+        return {}
+
+    def one(app: App) -> tuple[str, AppState]:
+        return app.domain, resolve_state(app, service_manager, probe=probe)
+
+    workers = min(8, len(apps))
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        return dict(pool.map(one, apps))