fadenstack 0.5.0rc4__tar.gz → 0.6.0__tar.gz

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fadenstack
-Version: 0.5.0rc4
+Version: 0.6.0
 Summary: CLI installer and management tool for the Fadenstack platform
 Project-URL: Homepage, https://fadenstack.com
 Project-URL: Repository, https://github.com/fadenstack/fadenstack

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/pyproject.toml

@@ -10,7 +10,7 @@ packages = ["src/faden_cli"]
 
 [project]
 name = "fadenstack"
-version = "0.5.0rc4"
+version = "0.6.0"
 requires-python = ">=3.12,<4.0"
 description = "CLI installer and management tool for the Fadenstack platform"
 authors = [

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/__init__.py

@@ -13,4 +13,4 @@ Module activation via Docker Compose profiles.
 All secrets generated securely during init phase.
 """
 
-__version__ = "0.5.0rc4"
+__version__ = "0.6.0"

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/bundle/shared/docker-compose.yaml

@@ -340,7 +340,10 @@ services:
       resources:
         limits:
           cpus: "1"
-          memory: 512M
+          # RabbitMQ is told this same amount (rabbitmq/10-faden.conf, written by the CLI's core/rmq.py): it reads
+          # the host's memory otherwise and slows publishers only at 60 % of that, long after the kernel has killed
+          # it here. 512M was too little at start-up after a reboot (recovering its data, every service starting).
+          memory: 1G
     healthcheck:
       test: rabbitmq-diagnostics check_running -q
       interval: 3s
@@ -610,6 +613,7 @@ services:
       FADEN_BACKEND_SKILLS_ENABLED: ${FADEN_BACKEND_SKILLS_ENABLED:-false}
       FADEN_BACKEND_MAILER_SERVICE_URL: ${FADEN_BACKEND_MAILER_SERVICE_URL:-http://faden-mailer:8000}
       FADEN_BACKEND_AUTH_SERVICE_URL: ${FADEN_BACKEND_AUTH_SERVICE_URL:-http://faden-auth:8000}
+      FADEN_BACKEND_AUTH_SERVICE_TOKEN: ${FADEN_BACKEND_AUTH_SERVICE_TOKEN:-}
       FADEN_BACKEND_DOCLING_SERVICE_URL: ${FADEN_BACKEND_DOCLING_SERVICE_URL:-http://faden-docling:8000}
       FADEN_BACKEND_SKILLS_SERVICE_URL: ${FADEN_BACKEND_SKILLS_SERVICE_URL:-http://faden-skills:8000}
       FADEN_BACKEND_SKILLS_SERVICE_TOKEN: ${FADEN_BACKEND_SKILLS_SERVICE_TOKEN:?set it in .env, as faden deploy and faden upgrade do (Help, Installing, Secrets in .env)}
@@ -731,6 +735,7 @@ services:
       FADEN_BACKEND_MCP_SERVICE_TOKEN: ${FADEN_BACKEND_MCP_SERVICE_TOKEN:?set it in .env, as faden deploy and faden upgrade do (Help, Installing, Secrets in .env)}
       FADEN_BACKEND_MAILER_SERVICE_URL: ${FADEN_BACKEND_MAILER_SERVICE_URL:-http://faden-mailer:8000}
       FADEN_BACKEND_AUTH_SERVICE_URL: ${FADEN_BACKEND_AUTH_SERVICE_URL:-http://faden-auth:8000}
+      FADEN_BACKEND_AUTH_SERVICE_TOKEN: ${FADEN_BACKEND_AUTH_SERVICE_TOKEN:-}
       FADEN_BACKEND_DOCLING_SERVICE_URL: ${FADEN_BACKEND_DOCLING_SERVICE_URL:-http://faden-docling:8000}
       FADEN_BACKEND_SKILLS_SERVICE_URL: ${FADEN_BACKEND_SKILLS_SERVICE_URL:-http://faden-skills:8000}
       FADEN_BACKEND_SKILLS_SERVICE_TOKEN: ${FADEN_BACKEND_SKILLS_SERVICE_TOKEN:?set it in .env, as faden deploy and faden upgrade do (Help, Installing, Secrets in .env)}

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/bundle/shared/nginx/rate-limits.conf

@@ -11,9 +11,13 @@
 # for everyone, shares one count. Over the limit nginx answers 429 at
 # once (nodelay) and the next try a few seconds later goes through.
 #
-#   faden_signin   console and API sign-in: 20 a minute, 20 at once.
-#   faden_account  forgotten and reset passwords, e-mail verification and
-#                  bootstrap: 10 a minute, 10 at once.
+#   faden_signin   console and API sign-in, every step of a sign-in with an
+#                  outside provider, and the password or code that links one
+#                  to an existing account: 20 a minute, 20 at once.
+#   faden_account  forgotten and reset passwords (by mail or by a link an
+#                  administrator made), e-mail verification, the code mailed
+#                  to link an outside sign-in, and bootstrap: 10 a minute,
+#                  10 at once.
 #   faden_refresh  agents renewing their tokens: 300 a minute, 200 at once.
 #                  Each running agent renews about every 10 minutes
 #                  (FADEN_BACKEND_AGENT_ACCESS_TOKEN_TTL_S); the SDKs keep
@@ -26,11 +30,16 @@
 map "$request_method $uri" $faden_signin_key {
     default "";
     "~^POST /api/auth/(jwt|cookie)/login$" $binary_remote_addr;
+    "~^GET /api/auth/sso/[a-z0-9-]+/(start|callback)$" $binary_remote_addr;
+    "~^POST /api/auth/sso/[a-z0-9-]+/(acs|password)$" $binary_remote_addr;
+    "~^POST /api/auth/sso/link/with-(password|code)$" $binary_remote_addr;
 }
 
 map "$request_method $uri" $faden_account_key {
     default "";
     "~^POST /api/auth/(forgot-password|reset-password|request-verify-token|verify)$" $binary_remote_addr;
+    "~^POST /api/auth/sso/link/code$" $binary_remote_addr;
+    "~^POST /api/auth/reset-link/(preview|use)$" $binary_remote_addr;
     "~^POST /api/bootstrap$" $binary_remote_addr;
 }
 

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/commands/deploy.py

@@ -840,6 +840,11 @@ def deploy_cmd(
         env_path, days=chat_retention_days, yes=yes, heading="Step 3f: Deleted chats…",
     )
 
+    # ── 3g. Add-ons' steps (registry.extend_install_hooks): their settings, secrets, registry login ──
+    from faden_cli.core.registry import run_install_hooks  # noqa: PLC0415
+
+    run_install_hooks(shared_dir)
+
     # ── 4. Save config ────────────────────────────────────────────
     cfg.install_dir = str(shared_dir)
     cfg.compose_file = compose_file.name

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/commands/restore.py

@@ -32,7 +32,7 @@ from faden_cli.core.compose import (
 )
 from faden_cli.core.console import console, error, info, success, warning
 from faden_cli.core.settings import FadenConfig, load_config
-from faden_cli.commands.deploy import _sync_postgres_password
+from faden_cli.commands.deploy import _regenerate_rmq_definitions, _sync_postgres_password
 
 
 @click.command("restore")
@@ -154,10 +154,10 @@ def _restore_cmd(
     # however this ends. nginx holds none of the volumes a restore writes (it mounts the install's nginx/
     # and tls/ directories, read-only), so it can run through it.
     with maintenance.during(Path(str(ctx.project_dir)), reason="restore"):
-        result = _restore(ctx, cfg, source, db_only=db_only, skip_env=skip_env)
+        result, started = _restore(ctx, cfg, source, db_only=db_only, skip_env=skip_env)
 
     console.print()
-    success("Restore complete.")
+    _report_start(started)
     from faden_cli.core.backend_tool import record_event  # noqa: PLC0415
 
     record_event(
@@ -175,6 +175,20 @@ def _restore_cmd(
         console.print(f"  Volumes: {', '.join(result.volumes_restored)}")
     if result.tls_restored:
         console.print(f"  Certificate material: {len(result.tls_restored)} file(s); the machines still trust it")
+    if started != 0:
+        sys.exit(1)
+
+
+def _report_start(started: int) -> None:
+    """Whether everything came back: *started* is the exit code of starting it all again.
+
+    The data is back either way; `faden status` names what did not start. It used to say "Restore complete."
+    """
+    if started == 0:
+        success("Restore complete.")
+        return
+    error(f"The backup is restored, but not every service started (docker compose up exited with {started}).")
+    error("  See which with `faden status`, and why with `faden logs <service>`.")
 
 
 #: The front door, which keeps running (and serving the maintenance page) while everything else is restored.
@@ -183,8 +197,11 @@ _FRONT = "nginx"
 
 def _restore(
     ctx: ComposeContext, cfg: FadenConfig, backup_path: Path, *, db_only: bool, skip_env: bool
-) -> RestoreResult:
-    """Stop everything but nginx, restore, and start everything again; exits when the restore fails."""
+) -> tuple[RestoreResult, int]:
+    """Stop everything but nginx, restore, and start everything again; exits when the restore fails.
+
+    Returns what was restored and the exit code of starting everything again (0: all started).
+    """
     console.print("\n[bold cyan]Stopping application services…[/bold cyan]")
     names = service_names(ctx)
     # Stopped, not taken down: nginx is left alone, and the containers keep their volumes and networks.
@@ -214,6 +231,14 @@ def _restore(
             warning(note)
         info("Syncing Postgres password with restored .env…")
         _sync_postgres_password(ctx, env_path)
+        # RabbitMQ makes its users from definitions.json on every start; the services log in with the
+        # passwords in .env. The file still held those of the .env the restore replaced: RabbitMQ refused
+        # the backend and the gateway (ACCESS_REFUSED), and the install did not come back. `faden upgrade`
+        # writes it the same way.
+        from faden_cli.core.env_gen import read_env_file  # noqa: PLC0415
+
+        _regenerate_rmq_definitions(Path(str(ctx.project_dir)), read_env_file(env_path), cfg.profiles)
+        success("RabbitMQ users written from the restored .env.")
     # The provenance signer of a .env from before the module, or issued by an authority the restore replaced.
     if (result.env_restored or result.tls_restored) and ctx.env_file and ctx.project_dir:
         from faden_cli.core.provenance_keys import ensure_step as provenance_keys_step  # noqa: PLC0415
@@ -222,9 +247,9 @@ def _restore(
 
     # ── Restart all services ──────────────────────────────────
     console.print("\n[bold cyan]Restarting all services…[/bold cyan]")
-    compose_up(ctx, detach=True, wait=True, timeout=120)
+    started = compose_up(ctx, detach=True, wait=True, timeout=120)
     # nginx read the certificate and picked plain HTTP or HTTPS when it started; a restored one is
     # only served after it starts again.
     if result.tls_restored and _FRONT in names:
         compose_restart(ctx, services=[_FRONT])
-    return result
+    return result, started

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/commands/upgrade.py

@@ -386,6 +386,10 @@ def upgrade_cmd(
     from faden_cli.commands.tls import refresh_edge_info  # noqa: PLC0415
 
     refresh_edge_info(shared_dir)
+    # Add-ons' steps (registry.extend_install_hooks): their settings, secrets, registry login.
+    from faden_cli.core.registry import run_install_hooks  # noqa: PLC0415
+
+    run_install_hooks(shared_dir)
 
     # ── 4. Images ─────────────────────────────────────────────
     if release is not None:

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/core/bundle.py

@@ -96,6 +96,16 @@ def unpack(install_dir: Path) -> list[str]:
         if not target.is_file() or target.read_bytes() != data:
             target.write_bytes(data)
             written.append(rel)
+    # What an add-on ships (registry.extend_bundle_files), replaced like the bundle's own files.
+    from faden_cli.core.registry import BUNDLE_FILES  # noqa: PLC0415
+
+    for rel, source in BUNDLE_FILES.items():
+        target = install_dir / rel
+        data = Path(source).read_bytes()
+        if not target.is_file() or target.read_bytes() != data:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_bytes(data)
+            written.append(rel)
     for rel, content in _STARTING_CONTENT.items():
         target = install_dir / rel
         if not target.exists():

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/core/compose.py

@@ -121,6 +121,15 @@ class ComposeContext:
             error(f"The keys' files could not be written: {exc}")
             sys.exit(1)
 
+    def extension_overlays(self) -> list[Path]:
+        """The add-ons' compose files beside the main one that exist (``registry.extend_compose_files``)."""
+        from faden_cli.core.registry import COMPOSE_OVERLAYS  # noqa: PLC0415
+
+        if not self.compose_files:
+            return []
+        folder = Path(str(self.compose_files[0])).parent
+        return [folder / name for name in COMPOSE_OVERLAYS if (folder / name).is_file()]
+
     def base_cmd(self) -> list[str]:
         """Build the ``docker compose`` prefix with all file/profile flags."""
         docker = shutil.which("docker")
@@ -135,6 +144,7 @@ class ComposeContext:
         overlay = gpu_overlay(self.env_file, self.project_dir)
         if overlay is not None and overlay not in files:
             files.append(overlay)
+        files.extend(p for p in self.extension_overlays() if p not in files)
         for f in files:
             cmd.extend(["-f", str(f)])
         if self.env_file and Path(str(self.env_file)).exists():
@@ -336,11 +346,49 @@ def stop_inactive_modules(ctx: ComposeContext) -> list[tuple[str, list[str]]]:
     return sorted(cleaned.items())
 
 
+#: Services that start only when their profile is asked for, which ``faden`` never does, by the profile. An
+#: earlier release started them with a module: up to 0.4.x ``faden-pii-worker`` was in profile ``pii``, since
+#: 0.5.0 it is in ``pii-tasks``. Compose leaves a container of a service whose profile is off alone, so after
+#: an upgrade from 0.4.x the old worker kept running on its 0.4.x image, through every restart and
+#: ``faden down``.
+ON_REQUEST_SERVICES: dict[str, str] = {"faden-pii-worker": "pii-tasks"}
+
+
+def stop_unrequested_services(ctx: ComposeContext) -> list[str]:
+    """Stop and remove the containers of :data:`ON_REQUEST_SERVICES` whose profile is off; their names.
+
+    Volumes stay. Like :func:`stop_inactive_modules`, a failure is said and not fatal.
+    """
+    from dataclasses import replace  # noqa: PLC0415
+
+    wanted = [name for name, profile in ON_REQUEST_SERVICES.items() if profile not in set(ctx.profiles)]
+    if not wanted:
+        return []
+    everything = replace(ctx, profiles=["*"])
+    present = {row.service: row.name for row in ps(everything) if row.service in wanted}
+    if not present:
+        return []
+    names = sorted(present)
+    failed = stop(everything, services=names)
+    failed = failed or _run(everything.base_cmd() + ["rm", "-f", *names], stream=True).returncode
+    if failed:
+        containers = " ".join(sorted(present.values()))
+        warning(f"Containers this release no longer runs could not be stopped and removed: {containers}. "
+                f"Run `faden up` again, or remove them with `docker rm -f {containers}`.")
+        return []
+    return sorted(name or service for service, name in present.items())
+
+
 def report_inactive_modules(ctx: ComposeContext) -> None:
-    """Run :func:`stop_inactive_modules` and print one line per module it stopped."""
+    """Run :func:`stop_inactive_modules` and print one line per module it stopped.
+
+    Then :func:`stop_unrequested_services`, with a line of its own: those containers are an earlier release's.
+    """
     for module, containers in stop_inactive_modules(ctx):
         label = module.upper() if len(module) <= 3 else module.capitalize()
         info(f"{label} is switched off: stopped and removed {', '.join(containers)} (their data is kept).")
+    for container in stop_unrequested_services(ctx):
+        info(f"Stopped and removed {container}: an earlier release started it, this one does not.")
 
 
 def down(

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/core/registry.py

@@ -7,8 +7,9 @@ instead of hard-coding values.
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 
 
 # ── GitHub organisation ───────────────────────────────────────────
@@ -543,6 +544,67 @@ def extend_dev_processes(extra: list[DevProcess]) -> None:
             existing.add(proc.name)
 
 
+# ── What an add-on adds to an install ────────────────────────────
+
+#: Compose files beside the install's ``docker-compose.yaml`` that every compose command of the install
+#: includes, after core's own, when they exist (``compose.ComposeContext.base_cmd``).
+COMPOSE_OVERLAYS: list[str] = []
+#: Files an add-on ships, by their name in the install: ``faden deploy`` and ``faden upgrade`` write them
+#: with the bundled deployment files (``bundle.unpack``), so an upgrade brings the add-on's copy too.
+BUNDLE_FILES: dict[str, Path] = {}
+#: Keys of ``.env`` written to ``secrets/<KEY>`` before every compose command, like core's own keys
+#: (``secret_files.SECRET_FILES``): an add-on's compose file mounts them under ``/run/secrets``.
+SECRET_FILE_KEYS: list[str] = []
+#: Called by ``faden deploy`` and ``faden upgrade`` with the install's directory once its ``.env`` is
+#: written and before any image is pulled or started: an add-on writes its settings and secrets, or logs in
+#: to the registry its images come from. One that raises stops the deploy or the upgrade.
+INSTALL_HOOKS: list[Callable[[Path], None]] = []
+
+
+def extend_compose_files(names: list[str]) -> None:
+    """Add compose files every command of an install includes when they exist (idempotent)."""
+    for name in names:
+        if Path(name).name != name or not name.endswith((".yaml", ".yml")):
+            msg = f"Not a compose file beside the install's own: {name!r}"
+            raise ValueError(msg)
+        if name not in COMPOSE_OVERLAYS:
+            COMPOSE_OVERLAYS.append(name)
+
+
+def extend_bundle_files(files: dict[str, Path]) -> None:
+    """Add files written into an install with the bundled deployment files (a later add wins)."""
+    for name, source in files.items():
+        # Either separator: an install on Windows reads "/etc/x" as relative to its drive.
+        rel = PurePosixPath(name.replace("\\", "/"))
+        if rel.is_absolute() or Path(name).is_absolute() or ".." in rel.parts:
+            msg = f"Not a path inside the install: {name!r}"
+            raise ValueError(msg)
+        BUNDLE_FILES[name] = source
+
+
+def extend_secret_files(keys: list[str]) -> None:
+    """Add ``.env`` keys written as files under ``secrets/`` before every compose command (idempotent)."""
+    for key in keys:
+        if not key.isidentifier() or key.upper() != key:
+            msg = f"Not an .env key: {key!r}"
+            raise ValueError(msg)
+        if key not in SECRET_FILE_KEYS:
+            SECRET_FILE_KEYS.append(key)
+
+
+def extend_install_hooks(hooks: list[Callable[[Path], None]]) -> None:
+    """Add steps ``faden deploy`` and ``faden upgrade`` run before pulling (idempotent)."""
+    for hook in hooks:
+        if hook not in INSTALL_HOOKS:
+            INSTALL_HOOKS.append(hook)
+
+
+def run_install_hooks(install_dir: Path) -> None:
+    """Run the add-ons' install steps, in the order they were added."""
+    for hook in INSTALL_HOOKS:
+        hook(install_dir)
+
+
 def _read_env_values(path: Path) -> dict[str, str]:
     """Parse a simple ``KEY=VALUE`` env file into a dict."""
     path = Path(path)

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/core/rmq.py

@@ -94,6 +94,12 @@ def generate_definitions(
 #: still running and leaves it be (backend ``services/llm/tasks.py``).
 CONSUMER_TIMEOUT_MS = 2 * 24 * 3600 * 1000
 
+#: The memory RabbitMQ's container may use (``faden-rmq``'s limit in shared/docker-compose.yaml), which RabbitMQ is
+#: told (``total_memory_available_override_value``): it reads the host's memory otherwise, and its memory alarm
+#: (60 % of what it believes it has: 40 GB on a 64 GB host) never came before the kernel killed it at the
+#: container's limit. Killed at start-up after a reboot, in a loop, while it recovered its data.
+MEMORY_BYTES = 1024**3
+
 
 def write_definitions(
     output_dir: Path,
@@ -128,7 +134,8 @@ def write_definitions(
     conf_path.write_text(
         "# Auto-generated by faden deploy — do not edit.\n"
         "load_definitions = /etc/rabbitmq/definitions.json\n"
-        f"consumer_timeout = {CONSUMER_TIMEOUT_MS}\n",
+        f"consumer_timeout = {CONSUMER_TIMEOUT_MS}\n"
+        f"total_memory_available_override_value = {MEMORY_BYTES}\n",
         encoding="utf-8",
     )
 

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/src/faden_cli/core/secret_files.py

@@ -75,9 +75,11 @@ def _clear_docker_folder(path: Path) -> None:
 
 def write(project_dir: Path, env_file: Path) -> list[str]:
     """Write every key's file from *env_file* into ``<project_dir>/secrets/``; the required keys .env lacks."""
+    from faden_cli.core.registry import SECRET_FILE_KEYS  # noqa: PLC0415 -- an add-on's keys, added at start
+
     values = read_env_file(env_file) if env_file.is_file() else {}
     folder = private_dir(project_dir / FOLDER)
-    for name in SECRET_FILES:
+    for name in (*SECRET_FILES, *(key for key in SECRET_FILE_KEYS if key not in SECRET_FILES)):
         path = folder / name
         if path.is_dir():
             _clear_docker_folder(path)

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/tests/conftest.py

@@ -6,7 +6,12 @@ tests drive that code, and three of them mocked only some of the helpers
 and killed the development stack the developer was running at the time.
 A test run should never be able to do that. The same went for a deploy step
 that ran `docker exec faden-postgres` for real and switched off logins of the
-developer's database, so a real `docker exec` fails the test too.
+developer's database, so a real `docker exec` fails the test too. And for the
+runtime images `deploy` and `upgrade` fetch at the end: the upgrade tests read
+the pins out of the real backend image and pulled every runtime image it names
+(about 10 GB each), which filled CI's disk; a machine that already had them
+passed. So that step's Docker is answered "not here", and a real `docker pull`
+fails the test.
 
 The guard patches the primitives rather than the functions, so the tests that
 exist to exercise the matching logic still call the real thing; they just
@@ -17,10 +22,12 @@ this fixture and therefore wins.
 
 from __future__ import annotations
 
+import subprocess
+
 import pytest
 
 from faden_cli.commands.dev import dev_up
-from faden_cli.core import backend_tool, backup, sealing
+from faden_cli.core import backend_tool, backup, runtime_images, sealing
 
 
 @pytest.fixture(autouse=True)
@@ -33,6 +40,12 @@ def never_touch_real_processes(monkeypatch: pytest.MonkeyPatch) -> None:
     # The upgrade, deploy and rebuild steps that carry chat files out of the gateway container: none here.
     monkeypatch.setattr(backup, "keep_chat_files", lambda *_a, **_k: None)
     monkeypatch.setattr(backup, "keep_company_files", lambda *_a, **_k: None)
+    # The runtime images step's Docker (reading the pins out of the backend image, inspecting, pulling): it
+    # finds nothing, says so and goes on, as it does on a server without Docker. Its own tests fake `_run`.
+    monkeypatch.setattr(
+        runtime_images, "_run",
+        lambda cmd, **_k: subprocess.CompletedProcess(cmd, 1, "", "no Docker in the tests"),
+    )
 
     # Nothing to find...
     monkeypatch.setattr(dev_up.psutil, "process_iter", lambda *_a, **_k: [])
@@ -60,6 +73,11 @@ def never_touch_real_processes(monkeypatch: pytest.MonkeyPatch) -> None:
             "cp" in args[1:2] or list(args[1:3]) == ["volume", "create"]
         ):
             pytest.fail(f"a test reached a real `docker cp` or `docker volume create`: {args!r}")
+        # Nor a pull: the images are gigabytes, and a test passes only where they happen to be present.
+        if isinstance(args, (list, tuple)) and isinstance(first, str) and "docker" in first.lower() and (
+            "pull" in args[1:2]
+        ):
+            pytest.fail(f"a test reached a real `docker pull`: {args!r}")
         return real_run(args, *rest, **kwargs)
 
     monkeypatch.setattr(dev_up.subprocess, "run", guarded_run)

{fadenstack-0.5.0rc4 → fadenstack-0.6.0}/tests/test_inactive_modules.py

@@ -1,4 +1,8 @@
-"""A module that is switched off has its containers stopped and removed (data kept) by ``faden up``."""
+"""A module that is switched off has its containers stopped and removed (data kept) by ``faden up``.
+
+So has a service that starts only on request when it was not asked for: the PII worker an install from 0.4.x
+still ran on its 0.4.x image (its profile is ``pii-tasks`` since 0.5.0, ``pii`` before).
+"""
 
 from __future__ import annotations
 
@@ -18,7 +22,7 @@ SERVICES = {
     "postgres": {},
     "backend": {},
     "faden-pii": {"profiles": ["pii"]},
-    "faden-pii-worker": {"profiles": ["pii"]},
+    "faden-pii-worker": {"profiles": ["pii-tasks"]},
     "faden-mcp": {"profiles": ["mcp"]},
     "faden-base": {"profiles": ["_build"]},
 }
@@ -56,17 +60,17 @@ def fake(monkeypatch: pytest.MonkeyPatch):
 
 
 def test_a_disabled_module_is_stopped_and_removed(fake) -> None:
-    f = fake(["postgres", "backend", "faden-pii", "faden-pii-worker"])
+    f = fake(["postgres", "backend", "faden-pii", "faden-mcp"])
     done = compose.stop_inactive_modules(ComposeContext(profiles=[]))
-    assert done == [("pii", ["faden-pii", "faden-pii-worker"])]
+    assert done == [("mcp", ["faden-mcp"]), ("pii", ["faden-pii"])]
     stop, rm = f.calls[-2], f.calls[-1]
-    assert stop[-3:] == ["stop", "faden-pii", "faden-pii-worker"]
-    assert rm[-4:] == ["rm", "-f", "faden-pii", "faden-pii-worker"]
+    assert stop[-3:] == ["stop", "faden-mcp", "faden-pii"]
+    assert rm[-4:] == ["rm", "-f", "faden-mcp", "faden-pii"]
     assert all(w not in c for c in f.calls for w in ("down", "-v", "--volumes"))
 
 
 def test_an_enabled_module_is_left_running(fake) -> None:
-    f = fake(["postgres", "faden-pii", "faden-pii-worker", "faden-mcp"])
+    f = fake(["postgres", "faden-pii", "faden-mcp"])
     done = compose.stop_inactive_modules(ComposeContext(profiles=["pii"]))
     assert done == [("mcp", ["faden-mcp"])]
     assert "faden-pii" not in f.calls[-1] and "faden-pii" not in f.calls[-2]
@@ -96,10 +100,12 @@ def test_up_reports_each_stopped_module(monkeypatch: pytest.MonkeyPatch, tmp_pat
     monkeypatch.setattr(up_command, "build_context_from_config", lambda _c: ctx)
     monkeypatch.setattr(up_command, "compose_up", lambda *_a, **_k: 0)
     monkeypatch.setattr("faden_cli.core.backup.keep_company_files", lambda *_a, **_k: None)
-    monkeypatch.setattr(compose, "stop_inactive_modules", lambda _c: [("pii", ["faden-pii", "faden-pii-worker"])])
+    monkeypatch.setattr(compose, "stop_inactive_modules", lambda _c: [("pii", ["faden-pii"])])
+    monkeypatch.setattr(compose, "stop_unrequested_services", lambda _c: ["faden-pii-worker"])
     result = CliRunner().invoke(up_command.up_cmd, [])
     assert result.exit_code == 0, result.output
-    assert "PII is switched off: stopped and removed faden-pii, faden-pii-worker" in result.output
+    assert "PII is switched off: stopped and removed faden-pii" in result.output
+    assert "Stopped and removed faden-pii-worker: an earlier release" in result.output
 
 
 def test_up_with_named_services_does_not_stop_modules(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
@@ -129,3 +135,25 @@ def test_a_failed_stop_is_said_not_swallowed(fake, monkeypatch: pytest.MonkeyPat
     monkeypatch.setattr(compose, "warning", said.append)
     assert compose.stop_inactive_modules(ComposeContext(profiles=[])) == []
     assert len(said) == 1 and "faden-pii" in said[0] and "docker rm -f faden-pii" in said[0]
+
+
+def test_the_old_pii_worker_is_removed_also_with_pii_on(fake) -> None:
+    """What an install from 0.4.x still ran: the worker, outside every profile `faden` switches on."""
+    f = fake(["postgres", "faden-pii", "faden-pii-worker"])
+    assert compose.stop_unrequested_services(ComposeContext(profiles=["pii"])) == ["faden-pii-worker"]
+    stop, rm = f.calls[-2], f.calls[-1]
+    assert stop[-2:] == ["stop", "faden-pii-worker"]
+    assert rm[-3:] == ["rm", "-f", "faden-pii-worker"]
+    assert all("faden-pii" not in c for c in (stop, rm)), "the PII service itself keeps running"
+
+
+def test_a_service_asked_for_stays(fake) -> None:
+    f = fake(["faden-pii", "faden-pii-worker"])
+    assert compose.stop_unrequested_services(ComposeContext(profiles=["pii", "pii-tasks"])) == []
+    assert f.calls == [], "nothing to look up when every on-request service was asked for"
+
+
+def test_no_old_worker_means_one_lookup(fake) -> None:
+    f = fake(["postgres", "faden-pii"])
+    assert compose.stop_unrequested_services(ComposeContext(profiles=["pii"])) == []
+    assert f.verbs() == ["ps"]