fadenstack 0.5.0rc4__tar.gz → 0.5.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fadenstack
-Version: 0.5.0rc4
+Version: 0.5.1
 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.5.1}/pyproject.toml

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

{fadenstack-0.5.0rc4 → fadenstack-0.5.1}/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.5.1"

{fadenstack-0.5.0rc4 → fadenstack-0.5.1}/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.5.1}/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.5.1}/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.5.1}/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.5.1}/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.5.1}/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():

{fadenstack-0.5.0rc4 → fadenstack-0.5.1}/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.5.1}/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.5.1}/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.5.1}/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.1/tests/test_install_extensions.py

@@ -0,0 +1,158 @@
+"""What an add-on adds to an install: compose files, files written with the deployment, steps before pulling.
+
+``registry.extend_compose_files``: compose files every command includes. ``extend_bundle_files``: files
+written with the deployment. ``extend_install_hooks``: steps run before images are pulled. Without an add-on
+nothing changes.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+# The release bundle and the stand-ins for Docker an upgrade runs with (tests/test_release_bundle.py).
+from test_release_bundle import _configure, _no_docker, carried  # noqa: F401
+
+from faden_cli.core import bundle, registry
+from faden_cli.core.compose import ComposeContext
+
+
+@pytest.fixture(autouse=True)
+def no_addon(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Each test starts without an add-on, and leaves none behind."""
+    monkeypatch.setattr(registry, "COMPOSE_OVERLAYS", [])
+    monkeypatch.setattr(registry, "BUNDLE_FILES", {})
+    monkeypatch.setattr(registry, "INSTALL_HOOKS", [])
+
+
+def _files(cmd: list[str]) -> list[str]:
+    return [Path(cmd[i + 1]).name for i, part in enumerate(cmd) if part == "-f"]
+
+
+def _ctx(folder: Path) -> ComposeContext:
+    (folder / "docker-compose.yaml").write_text("services: {}\n", encoding="utf-8")
+    return ComposeContext(compose_files=[folder / "docker-compose.yaml"], project_dir=folder)
+
+
+def test_without_an_addon_the_install_runs_core_alone(tmp_path: Path) -> None:
+    (tmp_path / "docker-compose.extra.yaml").write_text("services: {}\n", encoding="utf-8")
+    assert _files(_ctx(tmp_path).base_cmd()) == ["docker-compose.yaml"]
+
+
+def test_every_command_includes_an_addons_compose_file_after_cores(tmp_path: Path) -> None:
+    registry.extend_compose_files(["docker-compose.extra.yaml", "docker-compose.missing.yaml"])
+    registry.extend_compose_files(["docker-compose.extra.yaml"])
+    (tmp_path / "docker-compose.extra.yaml").write_text("services: {}\n", encoding="utf-8")
+    assert _files(_ctx(tmp_path).base_cmd()) == ["docker-compose.yaml", "docker-compose.extra.yaml"]
+
+
+@pytest.mark.parametrize("name", ["../docker-compose.x.yaml", "sub/extra.yaml", "extra.env", "/etc/x.yaml"])
+def test_only_compose_files_beside_the_install_own(name: str) -> None:
+    with pytest.raises(ValueError, match="Not a compose file"):
+        registry.extend_compose_files([name])
+
+
+def test_unpacking_writes_an_addons_files_and_replaces_them_on_upgrade(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    shipped = tmp_path / "bundle"
+    shipped.mkdir()
+    (shipped / "docker-compose.yaml").write_text("services: {}\n", encoding="utf-8")
+    monkeypatch.setattr(bundle, "bundled_files", lambda: shipped)
+    source = tmp_path / "addon.yaml"
+    source.write_text("services: {a: {}}\n", encoding="utf-8")
+    registry.extend_bundle_files({"docker-compose.extra.yaml": source})
+
+    install = tmp_path / "install"
+    assert "docker-compose.extra.yaml" in bundle.unpack(install)
+    assert (install / "docker-compose.extra.yaml").read_text(encoding="utf-8") == "services: {a: {}}\n"
+    assert "docker-compose.extra.yaml" not in bundle.unpack(install), "unchanged: not written again"
+    source.write_text("services: {b: {}}\n", encoding="utf-8")
+    assert "docker-compose.extra.yaml" in bundle.unpack(install), "a newer add-on brings its copy"
+    assert (install / "docker-compose.extra.yaml").read_text(encoding="utf-8") == "services: {b: {}}\n"
+
+
+@pytest.mark.parametrize("name", ["../outside.yaml", "/etc/passwd"])
+def test_an_addons_files_stay_inside_the_install(name: str, tmp_path: Path) -> None:
+    with pytest.raises(ValueError, match="Not a path inside the install"):
+        registry.extend_bundle_files({name: tmp_path / "x"})
+
+
+def test_install_steps_run_once_each_in_order(tmp_path: Path) -> None:
+    seen: list[tuple[str, Path]] = []
+
+    def first(folder: Path) -> None:
+        seen.append(("first", folder))
+
+    def second(folder: Path) -> None:
+        seen.append(("second", folder))
+
+    registry.extend_install_hooks([first, second])
+    registry.extend_install_hooks([first])
+    registry.run_install_hooks(tmp_path)
+    assert seen == [("first", tmp_path), ("second", tmp_path)]
+
+
+def test_a_failing_install_step_stops_what_runs_it(tmp_path: Path) -> None:
+    def broken(folder: Path) -> None:
+        msg = f"cannot log in for {folder}"
+        raise RuntimeError(msg)
+
+    registry.extend_install_hooks([broken])
+    with pytest.raises(RuntimeError, match="cannot log in"):
+        registry.run_install_hooks(tmp_path)
+
+
+def test_an_upgrade_runs_the_steps_after_the_env_and_before_pulling(
+    carried: Path, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,  # noqa: F811 -- the fixture imported above
+) -> None:
+    import json  # noqa: PLC0415
+
+    from click.testing import CliRunner  # noqa: PLC0415
+
+    from faden_cli.commands import upgrade as upgrade_module  # noqa: PLC0415
+    from faden_cli.core import update_check  # noqa: PLC0415
+
+    install = tmp_path / "fadenstack"
+    bundle.unpack(install)
+    (install / bundle.MARKER).write_text(json.dumps({"version": "0.0.1"}), encoding="utf-8")
+    (install / ".env").write_text("VERSION=0.0.1\nPOSTGRES_PASSWORD=pgpw\n", encoding="utf-8")
+    _configure(tmp_path, monkeypatch, install)
+    calls: list[str] = []
+    _no_docker(monkeypatch, calls)
+    monkeypatch.setenv(update_check.ENV_OFF, "1")
+    monkeypatch.setattr(update_check, "cached_feed", lambda: None)
+
+    def step(folder: Path) -> None:
+        env = (folder / ".env").read_text(encoding="utf-8")
+        calls.append(f"step:{folder.name}:{'REDIS_AUTH' in env}")
+
+    registry.extend_install_hooks([step])
+    result = CliRunner().invoke(upgrade_module.upgrade_cmd, ["-y", "--no-backup", "--skip-doctor"])
+    assert result.exit_code == 0, result.output
+    assert calls[:2] == ["step:fadenstack:True", "pull"], "after the .env is complete, before any pull"
+
+
+def test_an_addons_keys_are_written_as_files_like_cores(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from faden_cli.core import secret_files  # noqa: PLC0415
+
+    monkeypatch.setattr(registry, "SECRET_FILE_KEYS", [])
+    registry.extend_secret_files(["FADEN_ADDON_KEY", "FADEN_ADDON_KEY"])
+    (tmp_path / ".env").write_text("FADEN_ADDON_KEY=addon-secret\n", encoding="utf-8")
+    secret_files.write(tmp_path, tmp_path / ".env")
+    assert (tmp_path / "secrets" / "FADEN_ADDON_KEY").read_text(encoding="utf-8") == "addon-secret"
+    written = {p.name for p in (tmp_path / "secrets").iterdir()}
+    assert written == {*secret_files.SECRET_FILES, "FADEN_ADDON_KEY"}
+    (tmp_path / ".env").write_text("FADEN_ADDON_KEY=rotated\n", encoding="utf-8")
+    secret_files.write(tmp_path, tmp_path / ".env")
+    rotated = (tmp_path / "secrets" / "FADEN_ADDON_KEY").read_text(encoding="utf-8")
+    assert rotated == "rotated", "follows .env"
+
+
+@pytest.mark.parametrize("key", ["faden_lower", "FADEN-DASH", "../ESCAPE", ""])
+def test_only_env_keys_become_files(key: str) -> None:
+    with pytest.raises(ValueError, match=r"Not an \.env key"):
+        registry.extend_secret_files([key])

{fadenstack-0.5.0rc4 → fadenstack-0.5.1}/tests/test_release_bundle.py

@@ -94,6 +94,10 @@ def _no_docker(monkeypatch: pytest.MonkeyPatch, calls: list[str]) -> None:
     monkeypatch.setattr(bootstrap, "wait_for_backend", lambda *a, **k: True)
     monkeypatch.setattr(deploy_module, "_sync_postgres_password", lambda *a, **k: None)
     monkeypatch.setattr(deploy_module, "retire_fixed_logins", lambda *a, **k: [])
+    # The runtime images are pulled for real otherwise: several gigabytes, on any machine with Docker.
+    from faden_cli.commands import runtime_images  # noqa: PLC0415
+
+    monkeypatch.setattr(runtime_images, "run_step", lambda *a, **k: calls.append("runtime images"))
 
 
 def _configure(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, install: Path) -> None:
@@ -137,7 +141,7 @@ def test_an_upgrade_moves_a_release_install_to_this_release(
     assert "REDIS_AUTH" in env, "keys a release introduces are added"
     assert env["FADEN_BACKEND_BOOTSTRAP_TOKEN"], "an install from before the bootstrap token gets one"
     # Pulled, not built; then the front door restarts first, and the rest.
-    assert calls == ["pull", "up", "up"], "published images are pulled, not built"
+    assert calls == ["pull", "up", "up", "runtime images"], "published images are pulled, not built"
     assert bundle.installed_release(install) == __version__
 
 

{fadenstack-0.5.0rc4 → fadenstack-0.5.1}/tests/test_tune_memory.py

@@ -16,7 +16,7 @@ import yaml
 
 from faden_cli.core import tune
 from faden_cli.core.env_gen import read_env_file, write_env_file
-from faden_cli.core.rmq import CONSUMER_TIMEOUT_MS, write_definitions
+from faden_cli.core.rmq import CONSUMER_TIMEOUT_MS, MEMORY_BYTES, write_definitions
 from faden_cli.core.sysinfo import (
     MAX_DOWNLOAD_RANGES,
     MIN_DOWNLOAD_RANGES,
@@ -110,3 +110,14 @@ def test_rabbitmq_lets_a_task_hold_its_message_for_as_long_as_a_download(tmp_pat
     conf = (tmp_path / "rabbitmq" / "10-faden.conf").read_text(encoding="utf-8")
     assert f"consumer_timeout = {CONSUMER_TIMEOUT_MS}" in conf
     assert CONSUMER_TIMEOUT_MS >= 24 * 3600 * 1000
+
+
+def test_rabbitmq_is_told_the_memory_its_container_has(tmp_path: Path) -> None:
+    """It read the host's (40 GB of a 64 GB machine) and was killed at 512M before its own alarm came."""
+    write_definitions(tmp_path, admin_pass="a", backend_pass="b", api_pass="c")
+    conf = (tmp_path / "rabbitmq" / "10-faden.conf").read_text(encoding="utf-8")
+    assert f"total_memory_available_override_value = {MEMORY_BYTES}" in conf
+    rmq = yaml.safe_load(COMPOSE.read_text(encoding="utf-8"))["services"]["faden-rmq"]
+    limit = rmq["deploy"]["resources"]["limits"]["memory"]
+    assert limit.endswith("G") and int(limit[:-1]) * 1024**3 == MEMORY_BYTES, "Docker's G is GiB"
+    assert MEMORY_BYTES >= 1024**3