fadenstack 0.5.1__tar.gz → 0.6.0rc4__tar.gz

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

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

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

{fadenstack-0.5.1 → fadenstack-0.6.0rc4}/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.1"
+__version__ = "0.6.0rc4"

{fadenstack-0.5.1 → fadenstack-0.6.0rc4}/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.1 → fadenstack-0.6.0rc4}/src/faden_cli/core/compose.py

@@ -346,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.1 → fadenstack-0.6.0rc4}/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"]

fadenstack-0.6.0rc4/tests/test_restore_rabbitmq.py

@@ -0,0 +1,96 @@
+"""``faden restore`` writes RabbitMQ's users from the .env it restores, and says when services did not start.
+
+RabbitMQ makes its users from ``rabbitmq/definitions.json`` on every start, and the services log in with the
+passwords in ``.env``. A restore onto a server rebuilt with ``faden deploy`` (Help: Backups, Rebuild a lost
+server) put back the old ``.env`` but kept the file the deploy wrote: RabbitMQ refused the backend and the
+gateway (ACCESS_REFUSED), they stayed unhealthy, and the restore still ended with "Restore complete."
+(release test bed, 1 November 2026). How the file is written from .env: test_upgrade_rabbitmq.py.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+from click.testing import CliRunner
+
+from faden_cli.commands import restore
+from faden_cli.core import backend_tool, env_gen, provenance_keys
+from faden_cli.core.backup import RestoreResult
+
+RESTORED_ENV = (
+    "RABBITMQ_ADMIN_USER=admin\nRABBITMQ_ADMIN_PASS=restored-admin\n"
+    "RABBITMQ_BACKEND_PASS=restored-backend\nRABBITMQ_API_PASS=restored-api\n"
+)
+
+
+@pytest.fixture
+def install(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> SimpleNamespace:
+    """An install the restore puts RESTORED_ENV back into; every step it takes, in order, in ``steps``."""
+    root = tmp_path / "install"
+    root.mkdir()
+    (tmp_path / "backup").mkdir()
+    ctx = SimpleNamespace(project_dir=root, env_file=root / ".env")
+    state = SimpleNamespace(root=root, started=0, steps=[])
+
+    def fake_restore(_ctx: object, **_: object) -> RestoreResult:
+        (root / ".env").write_text(RESTORED_ENV, encoding="utf-8")
+        return RestoreResult(databases_restored=["faden_backend"], env_restored=True)
+
+    def up(_ctx: object, *, services: list[str] | None = None, **_: object) -> int:
+        """Starting postgres works; starting everything returns what the test sets."""
+        state.steps.append(("up", services))
+        return 0 if services else state.started
+
+    def rabbitmq_users(shared_dir: Path, env_vars: dict[str, str], profiles: list[str]) -> None:
+        state.steps.append(("rabbitmq users", shared_dir, env_vars))
+
+    monkeypatch.setattr(restore, "load_config", lambda: SimpleNamespace(profiles=[]))
+    monkeypatch.setattr(restore, "build_context_from_config", lambda cfg: ctx)
+    monkeypatch.setattr(restore, "read_manifest", lambda path: {"databases": {}, "volumes": []})
+    monkeypatch.setattr(restore, "verify_backup", lambda path, manifest: [])
+    monkeypatch.setattr(restore, "service_names", lambda ctx: ["nginx", "postgres", "rabbitmq", "backend"])
+    monkeypatch.setattr(restore, "compose_stop", lambda *a, **k: 0)
+    monkeypatch.setattr(restore, "compose_restart", lambda *a, **k: 0)
+    monkeypatch.setattr(restore, "compose_up", up)
+    monkeypatch.setattr(restore, "restore_backup", fake_restore)
+    monkeypatch.setattr(restore, "_regenerate_rmq_definitions", rabbitmq_users, raising=False)
+    monkeypatch.setattr(restore, "_sync_postgres_password", lambda *a, **k: None)
+    monkeypatch.setattr(env_gen, "fill_required_env", lambda *a, **k: [])
+    monkeypatch.setattr(provenance_keys, "ensure_step", lambda *a, **k: None)
+    monkeypatch.setattr(backend_tool, "record_event", lambda *a, **k: True)
+    return state
+
+
+def _run(tmp_path: Path) -> Any:
+    return CliRunner().invoke(restore.restore_cmd, [str(tmp_path / "backup"), "-y"])
+
+
+def test_rabbitmqs_users_are_written_from_the_restored_env_before_the_start(
+    tmp_path: Path, install: SimpleNamespace
+) -> None:
+    result = _run(tmp_path)
+
+    assert result.exit_code == 0, result.output
+    written = [step for step in install.steps if step[0] == "rabbitmq users"]
+    assert len(written) == 1
+    _, shared_dir, env_vars = written[0]
+    assert shared_dir == install.root
+    assert env_vars["RABBITMQ_API_PASS"] == "restored-api"
+    assert env_vars["RABBITMQ_BACKEND_PASS"] == "restored-backend"
+    assert env_vars["RABBITMQ_ADMIN_PASS"] == "restored-admin"
+    assert install.steps.index(written[0]) < install.steps.index(("up", None)), "before it all starts again"
+    assert "Restore complete." in result.output
+
+
+def test_a_restore_whose_services_do_not_start_says_so(tmp_path: Path, install: SimpleNamespace) -> None:
+    install.started = 1
+
+    result = _run(tmp_path)
+
+    assert result.exit_code == 1
+    assert "Restore complete." not in result.output
+    assert "not every service started" in result.output
+    assert "faden status" in result.output