fadenstack 0.5.1__tar.gz → 0.6.0rc3__tar.gz

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

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

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

{fadenstack-0.5.1 → fadenstack-0.6.0rc3}/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.0rc3"

{fadenstack-0.5.1 → fadenstack-0.6.0rc3}/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.6.0rc3/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