Merge pull request 'Fix BW Manager deploy staging argv limit' (#18) from fix/bw-deploy-argv-20260812 into main

app.py

@@ -11,7 +11,7 @@ from fastapi.responses import JSONResponse, RedirectResponse
 from contextlib import asynccontextmanager
 
 log = logging.getLogger("butler")
-VERSION = "2.3.4"
+VERSION = "2.3.5"
 
 API_DIR = os.environ.get("API_KEY_DIR", "/data/api")
 VAULT_CACHE_DIR = os.environ.get("VAULT_CACHE_DIR", "/data/vault-cache")
@@ -1164,6 +1164,117 @@ async def vps_speedtest_deploy(req: SpeedtestDeployRequest, _=Depends(_verify)):
     return result
 
 
+BW_MANAGER_REPO_FILES = (
+    ".env.example", ".gitignore", "README.md", "compose.yaml",
+    "src/.dockerignore", "src/Dockerfile", "src/app.py",
+    "src/remote_policy.py", "src/requirements.txt",
+    "src/templates/base.html", "src/templates/history.html",
+    "src/templates/index.html", "src/templates/users.html",
+)
+
+
+async def _fetch_bw_manager_text(path: str) -> str:
+    if path not in BW_MANAGER_REPO_FILES:
+        raise ValueError("unsupported BW Manager file")
+    cfg = SERVICES.get("forgejo", {})
+    base_url, token = cfg.get("url"), _get_key(cfg)
+    if not base_url or not token:
+        raise RuntimeError("Forgejo service configuration is unavailable")
+    url = f"{base_url}/api/v1/repos/sascha/bw-manager/contents/{path}"
+    async with httpx.AsyncClient(timeout=30) as client:
+        response = await client.get(
+            url, params={"ref": "main"},
+            headers={"Authorization": f"token {token}"},
+        )
+        response.raise_for_status()
+    return base64.b64decode(response.json()["content"]).decode()
+
+
+def _deploy_bw_manager_compose(files: dict[str, str]) -> dict:
+    if set(files) != set(BW_MANAGER_REPO_FILES):
+        raise ValueError("BW Manager source bundle is incomplete")
+    if "build: ./src" not in files["compose.yaml"]:
+        raise ValueError("BW Manager compose contract is invalid")
+    if "build_gated_targets" not in files["src/app.py"]:
+        raise ValueError("BW Manager candidate lacks the user/network AND gate")
+    rc, working_dir, err = _ssh(
+        VPS_SSH,
+        "docker inspect -f '{{ index .Config.Labels \"com.docker.compose.project.working_dir\" }}' bw-manager",
+        timeout=30,
+    )
+    working_dir = working_dir.strip()
+    if rc != 0 or not re.fullmatch(r"/app-config/[A-Za-z0-9_./-]+", working_dir):
+        raise RuntimeError(f"cannot determine safe BW Manager working directory: {(err or working_dir)[-300:]}")
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    candidate = f"/app-config/deployment-candidates/bw-manager-{timestamp}"
+    backup = f"/app-config/deployment-backups/bw-manager-{timestamp}"
+    image = "bw-manager-bw-manager"
+    rollback_image = f"{image}:rollback-{timestamp}"
+    init_script = f"""from pathlib import Path
+import shutil
+candidate = Path({candidate!r})
+if candidate.exists(): shutil.rmtree(candidate)
+candidate.mkdir(parents=True)
+live_env = Path({working_dir!r}) / '.env'
+if live_env.exists(): shutil.copy2(live_env, candidate / '.env')
+"""
+    rc, _out, err = _remote_python(init_script)
+    if rc != 0:
+        raise RuntimeError(f"BW Manager candidate initialization failed: {err[-300:]}")
+    # Stage one file per SSH call. Sending the complete repository in one
+    # command exceeds Linux's argv limit once app.py and templates are encoded.
+    for relative, content in files.items():
+        file_script = f"""from pathlib import Path
+target = Path({candidate!r}) / {relative!r}
+target.parent.mkdir(parents=True, exist_ok=True)
+target.write_text({content!r})
+"""
+        rc, _out, err = _remote_python(file_script)
+        if rc != 0:
+            raise RuntimeError(f"BW Manager staging failed for {relative}: {err[-300:]}")
+    rc, _out, err = _ssh(VPS_SSH, f"cd {candidate} && docker compose config -q && docker compose build --pull", timeout=600)
+    if rc != 0:
+        raise RuntimeError(f"BW Manager candidate build failed: {err[-500:]}")
+    deploy_script = f"""from pathlib import Path
+import shutil
+live, backup, candidate = Path({working_dir!r}), Path({backup!r}), Path({candidate!r})
+backup.parent.mkdir(parents=True, exist_ok=True)
+if backup.exists(): shutil.rmtree(backup)
+shutil.copytree(live, backup)
+for relative in {BW_MANAGER_REPO_FILES!r}:
+    source, target = candidate / relative, live / relative
+    target.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source, target)
+"""
+    rc, _out, err = _remote_python(deploy_script)
+    if rc != 0:
+        raise RuntimeError(f"BW Manager live file switch failed: {err[-300:]}")
+    _ssh(VPS_SSH, f"docker image tag {image} {rollback_image}", timeout=60)
+    rollback = (
+        f"rm -rf {working_dir} && cp -a {backup} {working_dir} && "
+        f"docker image tag {rollback_image} {image} && cd {working_dir} && "
+        "docker compose up -d --no-build"
+    )
+    rc, out, err = _ssh(VPS_SSH, f"cd {working_dir} && docker compose up -d --build --remove-orphans", timeout=600)
+    if rc != 0:
+        _ssh(VPS_SSH, rollback, timeout=180)
+        raise RuntimeError(f"BW Manager deployment failed: {(err or out)[-500:]}")
+    health = "for i in $(seq 1 45); do curl -fsS --max-time 3 http://127.0.0.1:8870/api/status >/dev/null && exit 0; sleep 2; done; exit 1"
+    rc, _out, err = _ssh(VPS_SSH, health, timeout=105)
+    if rc != 0:
+        _ssh(VPS_SSH, rollback, timeout=180)
+        raise RuntimeError(f"BW Manager health failed; rollback attempted: {err[-300:]}")
+    return {"status": "deployed", "health": "ok", "working_dir": working_dir, "backup": backup}
+
+
+@app.post("/vps/bw-manager/deploy")
+async def vps_bw_manager_deploy(_=Depends(_verify)):
+    contents = await asyncio.gather(*(_fetch_bw_manager_text(path) for path in BW_MANAGER_REPO_FILES))
+    result = await asyncio.to_thread(_deploy_bw_manager_compose, dict(zip(BW_MANAGER_REPO_FILES, contents)))
+    _audit("/vps/bw-manager/deploy", "POST", 200, "Git-managed BW Manager deployment")
+    return result
+
+
 # --- VM Lifecycle Endpoints ---
 import subprocess as _sp
 
@@ -1574,11 +1685,29 @@ async def ansible_run(request: Request, _=Depends(_verify)):
         return JSONResponse({"error": "action must be setup, tune or pvetune"}, status_code=400)
     if not re.fullmatch(r"[a-zA-Z0-9_.:-]+", hostname):
         return JSONResponse({"error": "invalid hostname/limit"}, status_code=400)
-    command = (
-        "cd /app-config/ansible && "
-        "git pull --ff-only origin master && "
-        f"bash pfannkuchen.sh {action} {hostname}"
-    )
+    if action in {"tune", "pvetune"}:
+        approved_files = (
+            "roles/sysctl/defaults/main.yml",
+            "roles/sysctl/tasks/main.yml",
+            "group_vars/vps/sysctl.yml",
+            "sysctl-proxmox.yaml",
+            "roles/sysctl_proxmox/tasks/main.yml",
+        )
+        file_sync = " && ".join(
+            f"git show origin/master:{path} > {path}" for path in approved_files
+        )
+        command = (
+            "cd /app-config/ansible && "
+            "git fetch origin master && "
+            f"{file_sync} && "
+            f"bash pfannkuchen.sh {action} {hostname}"
+        )
+    else:
+        command = (
+            "cd /app-config/ansible && "
+            "git pull --ff-only origin master && "
+            f"bash pfannkuchen.sh {action} {hostname}"
+        )
     rc, out, err = _ssh(AUTOMATION1, command, timeout=600)
     _audit("/ansible/run", "POST", 200 if rc == 0 else 502, f"{action} {hostname}")
     if action != "setup":

tests/test_app.py

@@ -42,7 +42,7 @@ def test_health_exposes_current_version():
     with TestClient(app.app) as client:
         response = client.get("/health")
     assert response.status_code == 200
-    assert response.json()["version"] == app.VERSION == "2.3.4"
+    assert response.json()["version"] == app.VERSION == "2.3.5"
 
 
 def test_sysctl_audit_reads_fixed_keys_from_inventory_host(monkeypatch):
@@ -108,7 +108,7 @@ def test_inventory_upsert_uses_base64_script(monkeypatch):
     assert "\\nname =" not in calls[0][1]
 
 
-def test_ansible_run_supports_safe_tune_action_and_syncs_git(monkeypatch):
+def test_ansible_run_supports_safe_tune_action_and_syncs_approved_files(monkeypatch):
     calls = []
 
     def fake_ssh(host, command, timeout=600):
@@ -124,7 +124,9 @@ def test_ansible_run_supports_safe_tune_action_and_syncs_git(monkeypatch):
         )
     assert response.status_code == 200
     assert response.json()["action"] == "tune"
-    assert "git pull --ff-only origin master" in calls[0][1]
+    assert "git fetch origin master" in calls[0][1]
+    assert "git show origin/master:roles/sysctl/tasks/main.yml" in calls[0][1]
+    assert "git pull --ff-only" not in calls[0][1]
     assert "bash pfannkuchen.sh tune emby-sascha" in calls[0][1]
     assert len(calls) == 1
 

tests/test_bw_manager_deploy.py

@@ -0,0 +1,32 @@
+import importlib.util
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def load_app(monkeypatch):
+    monkeypatch.setenv("BUTLER_TOKEN", "test-token")
+    spec = importlib.util.spec_from_file_location("butler_bw_test", ROOT / "app.py")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_bw_manager_deploy_rejects_bundle_without_and_gate(monkeypatch):
+    app = load_app(monkeypatch)
+    files = {path: "placeholder" for path in app.BW_MANAGER_REPO_FILES}
+    files["compose.yaml"] = "services:\n  bw-manager:\n    build: ./src\n"
+    files["src/app.py"] = "def old_policy(): pass\n"
+
+    with pytest.raises(ValueError, match="AND gate"):
+        app._deploy_bw_manager_compose(files)
+
+
+def test_bw_manager_deploy_endpoint_requires_auth(monkeypatch):
+    app = load_app(monkeypatch)
+    response = TestClient(app.app).post("/vps/bw-manager/deploy")
+    assert response.status_code in (401, 403)