diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..b6983ac --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +# Shell-Skripte laufen im Container bzw. auf dem Linux-Runner. +*.sh text eol=lf diff --git a/deploy/Dockerfile b/deploy/Dockerfile index 4b11422..ad8dc57 100644 --- a/deploy/Dockerfile +++ b/deploy/Dockerfile @@ -59,4 +59,5 @@ COPY tests/ tests/ COPY deploy/ deploy/ USER mindnet:mindnet ENTRYPOINT [] -CMD ["python", "-m", "pytest", "-q", "-p", "no:cacheprovider", "tests/test_container_preflight.py"] +CMD ["python", "-m", "pytest", "-q", "-p", "no:cacheprovider", \ + "tests/test_container_preflight.py", "tests/test_container_connectivity.py"] diff --git a/deploy/compose.dev.yml b/deploy/compose.dev.yml index 88ea648..b99adc9 100644 --- a/deploy/compose.dev.yml +++ b/deploy/compose.dev.yml @@ -15,7 +15,7 @@ x-hardening: &hardening context: .. dockerfile: deploy/Dockerfile target: runtime - env_file: [env/dev.env] + env_file: ["${MINDNET_ENV_FILE:-env/dev.env}"] read_only: true tmpfs: ["/tmp:size=64m,mode=1777"] cap_drop: [ALL] diff --git a/deploy/compose.prod.yml b/deploy/compose.prod.yml index a7e2732..b1e7b3b 100644 --- a/deploy/compose.prod.yml +++ b/deploy/compose.prod.yml @@ -17,7 +17,7 @@ x-hardening: &hardening context: .. dockerfile: deploy/Dockerfile target: runtime - env_file: [env/prod.env] + env_file: ["${MINDNET_ENV_FILE:-env/prod.env}"] read_only: true tmpfs: ["/tmp:size=64m,mode=1777"] cap_drop: [ALL] diff --git a/deploy/deploy.sh b/deploy/deploy.sh new file mode 100755 index 0000000..a64a357 --- /dev/null +++ b/deploy/deploy.sh @@ -0,0 +1,89 @@ +#!/usr/bin/env bash +# Baut, prüft und startet einen Mindnet-Container-Stack. Genutzt von den +# Gitea-Workflows (develop -> dev, main -> prod) und für manuelle Deploys. +# +# MINDNET_ENV_FILE=/home/llmadmin/docker/mindnet-dev/dev.env deploy/deploy.sh dev +# +# Ablauf (jeder Schritt bricht ab, bevor der laufende Stack angefasst wird): +# 1. Container-Tests im Test-Image, ohne Netzwerk (blockierend) +# 2. volle Testsuite ohne Netzwerk (informativ, bekannte Fehler siehe Migrationsplan) +# 3. Image bauen, Tag = Umgebung + Commit +# 4. preflight --live: Ollama/Qdrant erreichbar, Modelle, 768 Dimensionen, Vault (nur lesend) +# 5. up --wait (Healthchecks), danach smoke.py über die veröffentlichten Ports +# 6. Prod: bei Fehler Rückkehr zum letzten erfolgreichen Tag +# +# Die env-Datei liegt auf dem Host außerhalb von Git; in ihrem Verzeichnis +# merkt sich das Skript den letzten erfolgreichen Image-Tag (last_good_tag). +set -euo pipefail +cd "$(dirname "$0")/.." + +ENV="${1:-}" +case "$ENV" in + dev|prod) ;; + *) echo "Aufruf: deploy/deploy.sh dev|prod" >&2; exit 2 ;; +esac +: "${MINDNET_ENV_FILE:?MINDNET_ENV_FILE auf die env-Datei des Hosts setzen}" +[ -f "$MINDNET_ENV_FILE" ] || { echo "env-Datei fehlt: $MINDNET_ENV_FILE" >&2; exit 1; } +export MINDNET_ENV_FILE + +SHA="$(git rev-parse --short=12 HEAD)" +export MINDNET_IMAGE_TAG="$ENV-$SHA" +LAST_GOOD="$(dirname "$MINDNET_ENV_FILE")/last_good_tag" + +if [ "$ENV" = dev ]; then + PREFIX=mindnet_dev + RUN_DEPS=() # startet die eigene Dev-Qdrant für den Preflight mit + SMOKE_ARGS=() +else + PREFIX="$(sed -n 's/^COLLECTION_PREFIX=//p' "$MINDNET_ENV_FILE" | tail -n 1)" + RUN_DEPS=(--no-deps) # Prod hat keine eigene Qdrant + SMOKE_ARGS=(--require-data) +fi + +dc() { docker compose -f "deploy/compose.$ENV.yml" --env-file "$MINDNET_ENV_FILE" "$@"; } +step() { printf '\n=== %s\n' "$*"; } +show_logs() { dc ps || true; dc logs --tail 150 api ui || true; } +published() { dc port "$1" "$2" | head -n 1 | sed 's/^0\.0\.0\.0:/127.0.0.1:/'; } + +smoke() { + python3 deploy/smoke.py --api "http://$(published api 8000)" --ui "http://$(published ui 8501)" \ + --prefix "$PREFIX" "${SMOKE_ARGS[@]}" +} + +step "1/5 Container-Tests (ohne Netzwerk)" +docker build -f deploy/Dockerfile --target test -t "mindnet:test-$SHA" . +docker run --rm --network none "mindnet:test-$SHA" + +step "2/5 Volle Testsuite (informativ, ohne Netzwerk)" +if ! docker run --rm --network none "mindnet:test-$SHA" \ + python -m pytest tests -q -p no:cacheprovider --continue-on-collection-errors --basetemp=/tmp/pytest; then + echo "WARNUNG: Testsuite nicht grün. Bekannte Fehler: docs/05_Development/05_docker_migration_plan.md" +fi +docker image rm "mindnet:test-$SHA" >/dev/null || true + +step "3/5 Image bauen ($MINDNET_IMAGE_TAG)" +dc build api ui + +step "4/5 Preflight mit Erreichbarkeit (nur lesend)" +dc run --rm "${RUN_DEPS[@]}" api preflight --live + +step "5/5 Start ($MINDNET_IMAGE_TAG) und Smoke" +if dc up -d --wait --no-build && smoke; then + echo "$MINDNET_IMAGE_TAG" > "$LAST_GOOD" + echo "=== mindnet-$ENV läuft mit $MINDNET_IMAGE_TAG" + exit 0 +fi + +show_logs +PREV="$(cat "$LAST_GOOD" 2>/dev/null || true)" +if [ "$ENV" = prod ] && [ -n "$PREV" ] && [ "$PREV" != "$MINDNET_IMAGE_TAG" ]; then + step "Rollback auf $PREV" + export MINDNET_IMAGE_TAG="$PREV" + if dc up -d --wait --no-build && smoke; then + echo "Rollback erfolgreich; Deploy von $ENV-$SHA ist trotzdem fehlgeschlagen." + else + show_logs + echo "ROLLBACK FEHLGESCHLAGEN, manueller Eingriff nötig." >&2 + fi +fi +exit 1 diff --git a/deploy/entrypoint.py b/deploy/entrypoint.py index 4dcf400..08922b4 100644 --- a/deploy/entrypoint.py +++ b/deploy/entrypoint.py @@ -7,7 +7,10 @@ DESCRIPTION: Container-Entrypoint für Mindnet (API, UI, Preflight). - explizite Umgebung und Collection-Präfix (Dev nie auf Prod-Präfix) - Vault: vorhanden, Sentinel lesbar (NAS gemountet), schreibgeschützt - kein Cloud-LLM-Key ohne ausdrückliche Freigabe -VERSION: 1.0.0 + - Dienst-URLs gesetzt und nicht auf den Container selbst (localhost) + Mit 'preflight --live' zusätzlich (nur lesend): Ollama und Qdrant + erreichbar, benötigte Modelle vorhanden, Dimensionen stimmen. +VERSION: 1.1.0 STATUS: Active USAGE: entrypoint.py api | ui | preflight [--live] """ @@ -17,6 +20,7 @@ import json import os import sys import urllib.error +import urllib.parse import urllib.request from pathlib import Path @@ -24,6 +28,8 @@ import yaml CLOUD_KEYS = ("OPENROUTER_API_KEY", "GOOGLE_API_KEY") CLOUD_EGRESS_ACK = "MINDNET_ALLOW_CLOUD_EGRESS" +SERVICE_URLS = ("MINDNET_OLLAMA_URL", "QDRANT_URL") +LOOPBACK_HOSTS = {"localhost", "127.0.0.1", "::1", "0.0.0.0"} class PreflightError(RuntimeError): @@ -49,6 +55,16 @@ def check_environment() -> str: return env +def _load_profiles(profiles_path: str | None = None) -> dict: + # Gleicher Pfad wie in der App (Settings kennt keinen Override dafür). + path = Path(profiles_path or "config/llm_profiles.yaml") + try: + data = yaml.safe_load(path.read_text(encoding="utf-8")) or {} + except (OSError, yaml.YAMLError) as e: + raise PreflightError(f"LLM-Profile nicht lesbar: {path} ({type(e).__name__}).") from None + return data.get("profiles") or {} + + def check_embeddings(profiles_path: str | None = None) -> None: expected_dim = int(os.getenv("MINDNET_EXPECTED_VECTOR_DIM", "768")) expected_model = os.getenv("MINDNET_EXPECTED_EMBEDDING_MODEL", "nomic-embed-text") @@ -63,13 +79,7 @@ def check_embeddings(profiles_path: str | None = None) -> None: raise PreflightError(f"MINDNET_EMBEDDING_MODEL='{env_model}' weicht von '{expected_model}' ab.") # Das Profil hat Vorrang vor der Umgebung; fehlt es, fällt der Client auf das Chat-Modell zurück. - # Gleicher Pfad wie in der App (Settings kennt keinen Override dafür). - path = Path(profiles_path or "config/llm_profiles.yaml") - try: - data = yaml.safe_load(path.read_text(encoding="utf-8")) or {} - except (OSError, yaml.YAMLError) as e: - raise PreflightError(f"LLM-Profile nicht lesbar: {path} ({type(e).__name__}).") from None - profile = (data.get("profiles") or {}).get("embedding_expert") or {} + profile = _load_profiles(profiles_path).get("embedding_expert") or {} if profile.get("provider", "ollama") != "ollama" or profile.get("model") != expected_model: raise PreflightError(f"Profil embedding_expert muss ollama/{expected_model} sein.") if int(profile.get("dimensions") or 0) != expected_dim: @@ -109,36 +119,92 @@ def check_vault() -> None: raise PreflightError(f"Vault '{root}' ist nicht schreibgeschützt gemountet (':ro' erforderlich).") -def check_live() -> None: - """Optionale Laufzeitprüfung: tatsächliche Embedding- und Collection-Dimension (nur lesend).""" +def check_service_urls() -> None: + for name in SERVICE_URLS: + url = os.getenv(name, "").strip() + if not url: + # Die App fiele sonst still auf http://127.0.0.1:... zurück, also auf den Container selbst. + raise PreflightError(f"{name} muss explizit gesetzt sein.") + if urllib.parse.urlsplit(url).hostname in LOOPBACK_HOSTS: + raise PreflightError( + f"{name}='{url}' zeigt im Container auf den Container selbst. " + "Host-Dienste über host.docker.internal ansprechen." + ) + + +def _fetch_json(url: str, payload: dict | None = None, headers: dict | None = None, timeout: float = 10): + """GET (oder POST mit payload). Netzwerkfehler werden zu PreflightError, HTTPError bleibt erhalten.""" + req = urllib.request.Request( + url, method="POST" if payload is not None else "GET", + data=json.dumps(payload).encode() if payload is not None else None, + headers={"Content-Type": "application/json", **(headers or {})}, + ) + try: + with urllib.request.urlopen(req, timeout=timeout) as res: + return json.load(res) + except urllib.error.HTTPError: + raise + except (urllib.error.URLError, OSError) as e: + hint = "" + if urllib.parse.urlsplit(url).hostname == "host.docker.internal": + hint = " Lauscht der Dienst auf dem Host nur an 127.0.0.1?" + raise PreflightError(f"{url} nicht erreichbar ({getattr(e, 'reason', e)}).{hint}") from None + except ValueError: + raise PreflightError(f"{url} liefert kein JSON.") from None + + +def required_ollama_models(profiles_path: str | None = None) -> set[str]: + models = {p["model"] for p in _load_profiles(profiles_path).values() + if isinstance(p, dict) and p.get("provider") == "ollama" and p.get("model")} + # Lokales Chat-Modell: Endpunkt der Fallback-Kette ohne Cloud-Keys (Review R4). + if os.getenv("MINDNET_LLM_MODEL", "").strip(): + models.add(os.environ["MINDNET_LLM_MODEL"].strip()) + return models + + +def _has_model(required: str, available: set[str]) -> bool: + return required in available or (":" not in required and f"{required}:latest" in available) + + +def check_live(profiles_path: str | None = None) -> None: + """Laufzeitprüfung (nur lesend): Erreichbarkeit, Modelle, Embedding- und Collection-Dimension.""" expected_dim = int(os.getenv("MINDNET_EXPECTED_VECTOR_DIM", "768")) ollama = os.getenv("MINDNET_OLLAMA_URL", "").rstrip("/") model = os.getenv("MINDNET_EXPECTED_EMBEDDING_MODEL", "nomic-embed-text") - req = urllib.request.Request( - f"{ollama}/api/embeddings", method="POST", - data=json.dumps({"model": model, "prompt": "preflight"}).encode(), - headers={"Content-Type": "application/json"}, - ) - with urllib.request.urlopen(req, timeout=30) as res: - got = len(json.load(res).get("embedding") or []) + + tags = _fetch_json(f"{ollama}/api/tags") + available = {m.get("name") for m in tags.get("models") or []} + missing = sorted(m for m in required_ollama_models(profiles_path) if not _has_model(m, available)) + if missing: + raise PreflightError(f"Ollama ({ollama}) fehlen die Modelle: {', '.join(missing)}.") + + embedding = _fetch_json(f"{ollama}/api/embeddings", {"model": model, "prompt": "preflight"}, timeout=30) + got = len(embedding.get("embedding") or []) if got != expected_dim: raise PreflightError(f"Ollama liefert {got} Dimensionen für '{model}', erwartet {expected_dim}.") + print(f"preflight: Ollama erreichbar ({ollama}), Modelle vorhanden, '{model}' = {got} Dimensionen.") qdrant = os.getenv("QDRANT_URL", "").rstrip("/") + headers = {"api-key": os.environ["QDRANT_API_KEY"]} if os.getenv("QDRANT_API_KEY") else {} + try: + _fetch_json(f"{qdrant}/collections", headers=headers) + except urllib.error.HTTPError as e: + raise PreflightError(f"Qdrant ({qdrant}) antwortet mit HTTP {e.code}.") from None prefix = os.getenv("COLLECTION_PREFIX", "") for suffix in ("notes", "chunks"): name = f"{prefix}_{suffix}" try: - with urllib.request.urlopen(f"{qdrant}/collections/{name}", timeout=10) as res: - vectors = json.load(res)["result"]["config"]["params"]["vectors"] + info = _fetch_json(f"{qdrant}/collections/{name}", headers=headers) except urllib.error.HTTPError as e: if e.code == 404: print(f"preflight: Collection '{name}' existiert noch nicht.") continue - raise + raise PreflightError(f"Qdrant-Collection '{name}': HTTP {e.code}.") from None + vectors = info["result"]["config"]["params"]["vectors"] sizes = [vectors["size"]] if "size" in vectors else [v["size"] for v in vectors.values()] if any(s != expected_dim for s in sizes): raise PreflightError(f"Collection '{name}' hat Dimension {sizes}, erwartet {expected_dim}.") + print(f"preflight: Qdrant erreichbar ({qdrant}), Collections '{prefix}_*' passen.") def run_checks(mode: str) -> None: @@ -146,6 +212,7 @@ def run_checks(mode: str) -> None: check_embeddings() check_cloud_egress() if mode in {"api", "preflight"}: + check_service_urls() check_vault() diff --git a/deploy/gitea-workflows/deploy-dev.yml b/deploy/gitea-workflows/deploy-dev.yml new file mode 100644 index 0000000..9a689b8 --- /dev/null +++ b/deploy/gitea-workflows/deploy-dev.yml @@ -0,0 +1,31 @@ +# VORLAGE, NICHT AKTIV: liegt absichtlich nicht unter .gitea/workflows/. +# Aktivierung erst mit Freigabe (Gate G3, Dev-Start auf dem Runner-Host): +# git mv deploy/gitea-workflows/deploy-dev.yml .gitea/workflows/deploy-dev.yml +# Danach deployt jeder Push auf develop den Dev-Stack (Muster wie Kansho). +# Ablauf und Abbruchbedingungen: deploy/deploy.sh. + +name: Deploy mindnet DEV (Container) + +on: + push: + branches: [develop] + workflow_dispatch: + +concurrency: + group: deploy-mindnet-dev + cancel-in-progress: false + +jobs: + deploy: + # Runner auf dem Zielhost (heute llm-node). Bei einem Umzug auf einen anderen + # Mini-PC nur das Label und den Pfad der env-Datei anpassen. + runs-on: linux_host + env: + # Liegt auf dem Host, außerhalb von Git (Vorlage: deploy/env/dev.env.example). + MINDNET_ENV_FILE: /home/llmadmin/docker/mindnet-dev/dev.env + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Test, Build, Preflight, Start, Smoke + run: bash deploy/deploy.sh dev diff --git a/deploy/gitea-workflows/deploy-dev.yml.example b/deploy/gitea-workflows/deploy-dev.yml.example deleted file mode 100644 index c1186e7..0000000 --- a/deploy/gitea-workflows/deploy-dev.yml.example +++ /dev/null @@ -1,57 +0,0 @@ -# VORLAGE – NICHT AKTIV. Liegt absichtlich außerhalb von .gitea/workflows/. -# Aktivierung (Kopie nach .gitea/workflows/deploy-dev.yml) erst nach Freigabe, -# da der Runner `linux_host` auf llm-node (= Produktionsserver) läuft. -# -# Muster wie Kansho, aber nur manuell auslösbar (workflow_dispatch), kein Push-Trigger. -# Ein PROD-Workflow für Container existiert bewusst noch nicht; der bestehende -# .gitea/workflows/deploy.yml (systemd, Push auf main) bleibt unverändert. - -name: Deploy mindnet DEV (Container) - -on: - workflow_dispatch: - -concurrency: - group: deploy-mindnet-dev - cancel-in-progress: false - -jobs: - deploy: - runs-on: linux_host - env: - TARGET: /home/llmadmin/docker/mindnet-dev - COMPOSE: docker compose -f deploy/compose.dev.yml --env-file deploy/env/dev.env - steps: - - name: Checkout develop - run: | - set -euo pipefail - REPO="http://192.168.2.144:3000/Lars/mindnet.git" - mkdir -p "$TARGET" && cd "$TARGET" - if [ ! -d .git ]; then - git clone -b develop "$REPO" . - else - git fetch origin develop - git checkout develop - git reset --hard origin/develop - fi - test -f deploy/env/dev.env || { echo "deploy/env/dev.env fehlt auf dem Host"; exit 1; } - - - name: Build (Tag = Commit) - run: | - set -euo pipefail - cd "$TARGET" - export MINDNET_IMAGE_TAG="dev-$(git rev-parse --short HEAD)" - $COMPOSE build --pull - $COMPOSE run --rm --no-deps api preflight - - - name: Start und Health - run: | - set -euo pipefail - cd "$TARGET" - export MINDNET_IMAGE_TAG="dev-$(git rev-parse --short HEAD)" - if ! $COMPOSE up -d --wait; then - $COMPOSE logs api --tail 150 || true - $COMPOSE ps || true - exit 1 - fi - curl -sf "http://127.0.0.1:${MINDNET_API_PORT:-8012}/healthz" diff --git a/deploy/gitea-workflows/deploy-prod.yml b/deploy/gitea-workflows/deploy-prod.yml new file mode 100644 index 0000000..2ec1f98 --- /dev/null +++ b/deploy/gitea-workflows/deploy-prod.yml @@ -0,0 +1,33 @@ +# VORLAGE, NICHT AKTIV: liegt absichtlich nicht unter .gitea/workflows/. +# Aktivierung erst bei der Umschaltung (Gate G5, eigene Freigabe), und zwar im +# selben Commit, der .gitea/workflows/deploy.yml (systemd) entfernt: +# git rm .gitea/workflows/deploy.yml +# git mv deploy/gitea-workflows/deploy-prod.yml .gitea/workflows/deploy-prod.yml +# Sonst deployen bei jedem Push auf main beide Wege. +# +# Prod nur über Merge-Commit develop -> main (git merge --no-ff develop), wie bei Kansho. +# Ablauf, Abbruchbedingungen und Rollback: deploy/deploy.sh. + +name: Deploy mindnet PROD (Container) + +on: + push: + branches: [main] + workflow_dispatch: + +concurrency: + # Gleiche Gruppe wie der systemd-Workflow: nie zwei Prod-Deploys gleichzeitig. + group: deploy-mindnet + cancel-in-progress: false + +jobs: + deploy: + runs-on: linux_host + env: + MINDNET_ENV_FILE: /home/llmadmin/docker/mindnet/prod.env + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Test, Build, Preflight, Start, Smoke (Rollback bei Fehler) + run: bash deploy/deploy.sh prod diff --git a/deploy/smoke.py b/deploy/smoke.py new file mode 100644 index 0000000..34dc5f5 --- /dev/null +++ b/deploy/smoke.py @@ -0,0 +1,113 @@ +""" +FILE: deploy/smoke.py +DESCRIPTION: Nicht-schreibender Smoke-Test gegen einen laufenden Mindnet-Stack, + aus Sicht des Hosts über die veröffentlichten Ports. Nur Standardbibliothek, + läuft daher direkt auf dem Runner (python3), ohne venv. + - API /healthz: Status ok, erwartetes Collection-Präfix + - API /admin/stats: Vektorgröße 768; API erreicht Qdrant (Collection-Counts) + - UI /_stcore/health + --require-data (Prod): alle Collections vorhanden und Notes nicht leer. +VERSION: 1.0.0 +STATUS: Active +USAGE: smoke.py --api http://127.0.0.1:8012 --ui http://127.0.0.1:8512 --prefix mindnet_dev [--require-data] +""" +from __future__ import annotations + +import argparse +import json +import sys +import time +import urllib.error +import urllib.request + +EXPECTED_VECTOR_SIZE = 768 + + +class SmokeError(RuntimeError): + pass + + +def _get(url: str, timeout: float = 15) -> bytes: + try: + with urllib.request.urlopen(url, timeout=timeout) as res: + return res.read() + except urllib.error.HTTPError as e: + raise SmokeError(f"{url}: HTTP {e.code}") from None + except (urllib.error.URLError, OSError) as e: + raise SmokeError(f"{url} nicht erreichbar ({getattr(e, 'reason', e)})") from None + + +def _get_json(url: str) -> dict: + try: + return json.loads(_get(url)) + except ValueError: + raise SmokeError(f"{url} liefert kein JSON") from None + + +def check_api(api: str, prefix: str, require_data: bool) -> list[str]: + """Gibt Warnungen zurück; harte Fehler als SmokeError.""" + health = _get_json(f"{api}/healthz") + if health.get("status") != "ok": + raise SmokeError(f"/healthz meldet {health.get('status')!r}") + if health.get("prefix") != prefix: + raise SmokeError(f"API nutzt Präfix {health.get('prefix')!r}, erwartet {prefix!r}") + + stats = _get_json(f"{api}/admin/stats") + size = (stats.get("config") or {}).get("vector_size") + if size != EXPECTED_VECTOR_SIZE: + raise SmokeError(f"API-Vektorgröße {size}, erwartet {EXPECTED_VECTOR_SIZE}") + + warnings = [] + collections = stats.get("collections") or {} + for kind in ("notes", "chunks", "edges"): + entry = collections.get(kind) or {} + count = entry.get("count", -1) + if count < 0: + # -1: Collection fehlt oder Qdrant ist aus dem API-Container nicht erreichbar. + msg = f"Collection {entry.get('name', kind)!r} nicht lesbar (fehlt oder Qdrant nicht erreichbar)" + if require_data: + raise SmokeError(msg) + warnings.append(msg) + if require_data and (collections.get("notes") or {}).get("count", 0) <= 0: + raise SmokeError("Notes-Collection ist leer") + return warnings + + +def check_ui(ui: str) -> None: + body = _get(f"{ui}/_stcore/health").decode("utf-8", "replace").strip() + if body != "ok": + raise SmokeError(f"UI-Health meldet {body!r}") + + +def run(api: str, ui: str, prefix: str, require_data: bool = False, attempts: int = 1, delay: float = 5) -> int: + api, ui = api.rstrip("/"), ui.rstrip("/") + for attempt in range(1, attempts + 1): + try: + warnings = check_api(api, prefix, require_data) + check_ui(ui) + except SmokeError as e: + if attempt == attempts: + print(f"smoke: FEHLER: {e}", file=sys.stderr) + return 1 + time.sleep(delay) + continue + for w in warnings: + print(f"smoke: WARNUNG: {w}") + print(f"smoke: OK (api={api}, ui={ui}, prefix={prefix})") + return 0 + return 1 + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__.split("USAGE:")[0]) + parser.add_argument("--api", required=True) + parser.add_argument("--ui", required=True) + parser.add_argument("--prefix", required=True) + parser.add_argument("--require-data", action="store_true") + parser.add_argument("--attempts", type=int, default=3) + args = parser.parse_args(argv) + return run(args.api, args.ui, args.prefix, args.require_data, args.attempts) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/docs/04_Operations/04_docker_deployment.md b/docs/04_Operations/04_docker_deployment.md index d8b8298..f5d92ec 100644 --- a/docs/04_Operations/04_docker_deployment.md +++ b/docs/04_Operations/04_docker_deployment.md @@ -3,7 +3,7 @@ doc_type: operations_manual audience: devops, deployment_engineer scope: docker, compose, container_security, nas_mount status: draft -version: 0.1.0 +version: 0.2.0 context: "Container-Betrieb von Mindnet (Dev/Prod) auf llm-node. Vorbereitung, noch keine produktive Umschaltung." --- @@ -26,7 +26,7 @@ Stand: 28.10.2026. **Status: vorbereitet, nicht aktiv.** Produktion läuft unver Die Ports kollidieren weder untereinander noch mit systemd (8001/8002/8501/8502). Dev und Prod können später parallel zu den systemd-Diensten laufen, was einen Vergleich vor der Umschaltung erlaubt. -Alle Dateien liegen unter `deploy/`. Dieser Ordner gehört nicht zu `DEPLOY_DIRS` des bestehenden Workflows und wird daher nicht automatisch auf den Server synchronisiert. Der alte Ordner `docker/` (MiniLM-Embed-Dienst, Port 8990) bleibt unverändert, siehe Abschnitt 8. +Alle Dateien liegen unter `deploy/`. Dieser Ordner gehört nicht zu `DEPLOY_DIRS` des bestehenden Workflows und wird daher nicht automatisch auf den Server synchronisiert. Der alte Ordner `docker/` (MiniLM-Embed-Dienst, Port 8990) bleibt unverändert, siehe Abschnitt 9. ## 2. Image @@ -67,10 +67,21 @@ Der aktuelle Lock wurde mit `--exclude-newer 2026-01-22` erzeugt, also dem Stand | `VECTOR_DIM == 768`, Profil `embedding_expert` = ollama/`nomic-embed-text`/768, kein abweichendes `MINDNET_EMBEDDING_MODEL` | stiller Rückfall auf 384 (MiniLM) in `qdrant.py` bzw. auf das Chat-Modell als Embedding | | Cloud-Key gesetzt ohne `MINDNET_ALLOW_CLOUD_EGRESS=true` | unmaskierte Vault-Inhalte an OpenRouter/Gemini | | Vault fehlt, Sentinel nicht lesbar, Mount nicht `ro` (`statvfs` `ST_RDONLY`) | Arbeiten auf leerem NAS-Mountpunkt; Schreiben in den Vault (R2) | +| `MINDNET_OLLAMA_URL`/`QDRANT_URL` fehlen oder zeigen auf `localhost`/`127.0.0.1` | App fiele still auf `127.0.0.1` zurück, im Container also auf sich selbst | Die Werte für Umgebung, Dimension und Vault stehen in den Compose-Dateien unter `environment` und lassen sich nicht über die env-Datei überschreiben. -`preflight --live` prüft zusätzlich **nur lesend** die tatsächliche Ollama-Embedding-Länge und die Vektorgröße der Collections `_notes` und `_chunks`: +`preflight --live` prüft zusätzlich **nur lesend** aus dem Container heraus, also über dasselbe Netz wie die API: + +| Prüfung | Fehlerbild bei Abbruch | +| --- | --- | +| Ollama `/api/tags` erreichbar | `… nicht erreichbar`; bei `host.docker.internal` mit Hinweis auf eine `127.0.0.1`-Bindung | +| Alle Ollama-Modelle vorhanden: Profile mit `provider: ollama` (heute `nomic-embed-text`, `phi3:mini`) plus `MINDNET_LLM_MODEL` | `Ollama fehlen die Modelle: …` | +| Ollama liefert für `nomic-embed-text` 768 Dimensionen | `Ollama liefert N Dimensionen` | +| Qdrant `/collections` erreichbar (mit `QDRANT_API_KEY`, falls gesetzt) | `nicht erreichbar` bzw. `HTTP 401` | +| `_notes`/`_chunks` haben 768 Dimensionen; fehlende Collections sind erlaubt (Hinweis) | `Collection … hat Dimension …` | + +Netzwerkfehler enden als klarer Abbruch mit Exit-Code 1, nicht als Traceback. ```bash docker compose -f deploy/compose.dev.yml --env-file deploy/env/dev.env run --rm --no-deps api preflight --live @@ -108,6 +119,14 @@ Für `api` und `ui`: `read_only`-Rootfs, `tmpfs /tmp`, `cap_drop: ALL`, `no-new- ## 7. Bedienung +Normalerweise über das Deploy-Skript (Abschnitt 8), auch manuell: + +```bash +MINDNET_ENV_FILE=/home/llmadmin/docker/mindnet-dev/dev.env deploy/deploy.sh dev +``` + +Einzelschritte von Hand: + ```bash cp deploy/env/dev.env.example deploy/env/dev.env # ausfüllen; *.env ist git-ignoriert docker compose -f deploy/compose.dev.yml --env-file deploy/env/dev.env build @@ -127,12 +146,55 @@ Hinweis: Ein Befehl hinter `run` ersetzt nur `CMD`; `entrypoint.py` lehnt unbeka **Ohne Cloud-Keys** (Prod-Standard) ruft der stabile Code für Cloud-Profile Ollama mit der Cloud-Modell-ID auf. Das scheitert zunächst und endet über `fallback_profile` bei `identity_safe` (phi3:mini). Chat funktioniert damit lokal, aber mit Verzögerung durch Fehlversuche (Review R4). -## 8. Altbestand `docker/` (MiniLM) +## 8. Gitea-Pipeline: `develop` → Dev, `main` → Prod + +Gleiches Muster wie Kansho, aber auf dem eigenen Runner des Zielhosts (heute llm-node, Label `linux_host`, laut [Server-Handbuch](04_server_operation_manual.md) als `root`). Die Workflows liegen als **inaktive Vorlagen** unter `deploy/gitea-workflows/`, weil Gitea nur `.gitea/workflows/` ausführt: + +| Workflow | Trigger | Aktivierung | +| --- | --- | --- | +| `deploy-dev.yml` | Push `develop`, manuell | Gate G3: `git mv` nach `.gitea/workflows/` | +| `deploy-prod.yml` | Push `main`, manuell | Gate G5, im **selben Commit** `git rm .gitea/workflows/deploy.yml` (systemd), sonst deployen beide | + +Prod nur über einen Merge-Commit `develop` → `main` (`git merge --no-ff develop`), wie bei Kansho. + +Beide Workflows rufen nur `deploy/deploy.sh dev|prod` auf. Jeder Schritt bricht ab, **bevor** der laufende Stack angefasst wird: + +1. Container-Tests im Test-Image mit `--network none` (Preflight, Erreichbarkeit gegen Fake-Server, statische Compose-/Workflow-Prüfungen), **blockierend**. +2. Volle Testsuite mit `--network none`, **informativ**, bis die 17 bekannten Fehler behoben sind ([Migrationsplan §4](../05_Development/05_docker_migration_plan.md)). Ohne Netzwerk kann kein Test einen echten Dienst erreichen. +3. Image bauen, Tag `-`. +4. `preflight --live` in einem Wegwerf-Container (Prod mit `--no-deps`; Dev startet dafür die eigene Qdrant). +5. `up -d --wait` (Healthchecks) und danach `deploy/smoke.py` über die veröffentlichten Ports, also aus Sicht des Hosts: + - API `/healthz`: Status `ok`, erwartetes Präfix. + - API `/admin/stats`: Vektorgröße 768; die API erreicht Qdrant (Collection-Counts ≠ −1). + - UI `/_stcore/health`. + - Prod zusätzlich `--require-data`: alle Collections lesbar, Notes nicht leer. +6. Erfolg: Der Tag wird in `last_good_tag` neben der env-Datei vermerkt. Prod bei Fehler: Rückkehr zum letzten erfolgreichen Tag und erneuter Smoke-Test; der Workflow bleibt trotzdem rot. + +Die env-Dateien liegen nur auf dem Host (`/home/llmadmin/docker/mindnet-dev/dev.env`, `/home/llmadmin/docker/mindnet/prod.env`). Die Compose-Dateien lesen sie über `MINDNET_ENV_FILE`; Secrets landen nicht im Runner-Workspace. + +**Unterschiede zu Kansho, bewusst:** + +| | Kansho | Mindnet | +| --- | --- | --- | +| Checkout | `git clone`/`reset --hard` im Zielordner | `actions/checkout` im Runner-Workspace (funktioniert auch bei privatem Repo mit dem Job-Token; Compose-Projektnamen sind fest, daher ist der Ordner egal) | +| Tests | eigener `test.yml` nach dem Dev-Deploy | Teil des Deploys, **vor** dem Start; ohne Netzwerk | +| Prüfung vor Start | keine | `preflight --live` (Dienste, Modelle, Dimensionen, Vault) | +| Image | `build --no-cache`, kein Tag | Hash-Lock, Tag pro Commit, Rollback in Prod | +| Zustand des Hosts | `.env` im Checkout | env-Datei und `last_good_tag` außerhalb des Checkouts | + +**Umzug auf einen anderen Mini-PC:** Runner dort registrieren, in beiden Workflows `runs-on` und `MINDNET_ENV_FILE` anpassen, env-Dateien und Vault-Mount einrichten. Hostspezifisch ist sonst nur `host.docker.internal` (über `host-gateway`, funktioniert auf jedem Linux-Docker). + +## 9. Altbestand `docker/` (MiniLM) `docker/docker-compose.yml` und `docker/embeddings.Dockerfile` bauen einen MiniLM-Dienst (384 Dimensionen, Port 8990). Laut [Server-Handbuch](04_server_operation_manual.md) läuft `mindnet-embed` auf llm-node. Im Anwendungscode wird er nicht genutzt; außerdem verweist das Dockerfile auf `app/embed_server.py`, das im Repository nicht mehr existiert. **Nicht entfernen, bevor geprüft ist**, ob der Container auf llm-node noch läuft und von irgendetwas angesprochen wird. Grund: `deploy.yml` synchronisiert `docker/` mit `rsync --delete`; eine Löschung auf `main` entfernt die Dateien auch auf dem Server. -## 9. Noch nicht verifiziert +## 10. Noch nicht verifiziert -- Kein `docker build` und kein Compose-Start: Auf der Entwicklungsmaschine ist kein Docker installiert. Verifiziert sind die Preflight-Logik, statische Compose-/Dockerfile-Zusagen (`tests/test_container_preflight.py`) und die Testsuite mit exakt den gelockten Versionen (frische venv aus dem Lock, Windows). +- Kein `docker build` und kein Compose-Start: Auf der Entwicklungsmaschine ist kein Docker installiert. Verifiziert sind: + - die Preflight-Logik und die Erreichbarkeitsprüfungen gegen einen Fake-Server (`tests/test_container_connectivity.py`), + - statische Compose-, Dockerfile- und Workflow-Zusagen (`tests/test_container_preflight.py`), + - der Ablauf von `deploy.sh` mit einer Docker-Attrappe: Erfolg, Abbruch im Preflight vor dem Start, Prod-Startfehler mit Rollback, + - die Testsuite mit exakt den gelockten Versionen (frische venv aus dem Lock, Windows). +- Runner auf llm-node: Docker-Compose-Version (benötigt `up --wait` und Interpolation in `env_file`), Node für `actions/checkout` (nutzt `deploy.yml` heute schon), Rechte des Runner-Nutzers auf `/home/llmadmin/docker/`. - Healthcheck von `qdrant/qdrant` nutzt `bash` und `/dev/tcp`; beim ersten Dev-Build prüfen. - Der Abgleich mit den produktiven Paketversionen fehlt (Abschnitt 2). diff --git a/docs/05_Development/05_docker_migration_plan.md b/docs/05_Development/05_docker_migration_plan.md index 787105c..8227eb3 100644 --- a/docs/05_Development/05_docker_migration_plan.md +++ b/docs/05_Development/05_docker_migration_plan.md @@ -36,7 +36,7 @@ Stand: 28.10.2026. Betriebsdetails: [Container-Betrieb](../04_Operations/04_dock | Branch | Basis | Inhalt | Ort | | --- | --- | --- | --- | | `main` | — | Produktion (systemd, Auto-Deploy) | Gitea | -| `develop` | `origin/main` (`0d61a9e`) | Integrationszweig nach Kansho-Muster; noch ohne Deploy | **nur lokal** | +| `develop` | `origin/main` (`0d61a9e`) | Integrationszweig nach Kansho-Muster; Push deployt Dev, sobald `deploy-dev.yml` aktiv ist (G3) | **nur lokal** | | `feature/containerization` | `develop` | Phase 1 | **nur lokal** | | `codex/privacy-gateway` | `origin/main` | Gateway (2 Commits), unverändert | **nur lokal** + Bundle | | `origin/SectionType` | `origin/main` | WP-26; R3 offen | Gitea | @@ -59,7 +59,7 @@ Gleiches Ergebnis mit lokaler venv und mit einer frischen venv aus `deploy/requi | **D – braucht Infrastruktur / falsch gepatcht** | `test_graph_unit::test_graph_neighbors` | Patcht nicht mehr die tatsächlich aufgerufene Funktion → echte Qdrant-Verbindung. | Patch korrigieren; danach Unit-Test ohne Qdrant. | | **E – kein pytest-Test** | `test_interview_intent::test_intent`, `test_wp06_decision::test_decision_engine` | Funktionsparameter `message`/`query` werden als Fixture interpretiert; manuelle Skripte gegen laufende Dienste. | Nach `scripts/` verschieben oder als Integrationstest mit Marker. | -Für eine CI-Pipeline wie bei Kansho: zuerst A beheben, B/D portieren, C entscheiden, E umziehen. Danach ist die Baseline ehrlich grün. Bis dahin sollte eine künftige Test-Pipeline nur prüfen, dass **keine neuen** Fehler gegenüber dieser Liste entstehen. +Für eine CI-Pipeline wie bei Kansho: zuerst A beheben, B/D portieren, C entscheiden, E umziehen. Danach ist die Baseline ehrlich grün. Bis dahin läuft die volle Suite in `deploy/deploy.sh` nur informativ; blockierend sind die Container-Tests. Nächster Schritt dafür: eine explizite Liste dieser 17 Fälle, gegen die neue Fehler den Deploy stoppen. ## 5. Freigabe-Gates @@ -68,9 +68,9 @@ Für eine CI-Pipeline wie bei Kansho: zuerst A beheben, B/D portieren, C entsche | **G0** | Repo `Lars/mindnet` auf privat stellen (oder anderes privates Ziel benennen); danach Push von `codex/privacy-gateway`, `develop`, `feature/containerization` | Lars | | **G1** | Review dieses Stands; Merge `feature/containerization` → `develop` | Lars | | **G2** | **Nur lesende** Prüfungen auf llm-node: Docker-/Compose-Version, Port-Bindung Qdrant/Ollama (`ss -ltnp`), `docker ps` (läuft `mindnet-embed`?), `pip freeze` der Prod-venv, NAS-Mount (`findmnt`), Lesbarkeit für UID 10001 | Freigabe Lars | -| **G3** | Dev-Stack auf llm-node bauen und starten (eigene Qdrant, Testdaten-Vault), `preflight --live`; Aktivierung der Workflow-Vorlage `deploy/gitea-workflows/deploy-dev.yml.example` | Freigabe Lars | +| **G3** | Dev-Stack auf llm-node bauen und starten (eigene Qdrant, Testdaten-Vault), `preflight --live`; danach Aktivierung von `deploy/gitea-workflows/deploy-dev.yml` (jeder Push auf `develop` deployt Dev) | Freigabe Lars | | **G4** | Prod-Container parallel zu systemd starten (nur lesend auf Prod-Qdrant, Vault `ro`), Vergleich der Antworten | Freigabe Lars | -| **G5** | Umschaltung Prod auf Container; systemd 2–3 Wochen als Rückfallebene; `deploy.yml` anpassen | Freigabe Lars; Voraussetzung R2, falls Schreibzugriff nötig | +| **G5** | Umschaltung Prod auf Container; systemd 2–3 Wochen als Rückfallebene; im selben Commit `deploy-prod.yml` aktivieren und `.gitea/workflows/deploy.yml` entfernen | Freigabe Lars; Voraussetzung R2, falls Schreibzugriff nötig | ### R2 – Pfadsicherheit beim Speichern (Pflicht vor beschreibbarem Vault) diff --git a/tests/test_container_connectivity.py b/tests/test_container_connectivity.py new file mode 100644 index 0000000..f9c6a4b --- /dev/null +++ b/tests/test_container_connectivity.py @@ -0,0 +1,258 @@ +""" +FILE: tests/test_container_connectivity.py +DESCRIPTION: Prüft die Erreichbarkeitsprüfungen der Container-Bereitstellung gegen einen + lokalen Fake-Server (Ollama, Qdrant, Mindnet-API, Streamlit-UI): + - deploy/entrypoint.py: preflight --live (Dienste, Modelle, Dimensionen) + - deploy/smoke.py: Smoke-Test nach dem Start + Läuft ohne Docker und ohne echte Dienste (auch mit --network none). +""" +import importlib.util +import json +import threading +import urllib.error +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path + +import pytest + +DEPLOY = Path(__file__).resolve().parents[1] / "deploy" + + +def _load(name): + spec = importlib.util.spec_from_file_location(f"mindnet_{name}", DEPLOY / f"{name}.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +ep = _load("entrypoint") +smoke = _load("smoke") + + +class FakeServices(ThreadingHTTPServer): + """Ein Server für alle Dienste; Zustand pro Test über Attribute steuerbar.""" + + def __init__(self): + super().__init__(("127.0.0.1", 0), _Handler) + self.models = ["nomic-embed-text:latest", "phi3:mini"] + self.embedding_dim = 768 + self.collections = {"mindnet_dev_notes": 768, "mindnet_dev_chunks": 768} + self.api_key = None + self.seen_headers = [] + self.health = {"status": "ok", "prefix": "mindnet_dev"} + self.vector_size = 768 + self.counts = {"notes": 12, "chunks": 80, "edges": 40} + self.ui_body = b"ok" + + @property + def url(self): + return f"http://127.0.0.1:{self.server_address[1]}" + + +class _Handler(BaseHTTPRequestHandler): + def log_message(self, *args): + pass + + def _send(self, status, body): + data = body if isinstance(body, bytes) else json.dumps(body).encode() + self.send_response(status) + self.send_header("Content-Length", str(len(data))) + self.end_headers() + self.wfile.write(data) + + def do_POST(self): + srv = self.server + self.rfile.read(int(self.headers.get("Content-Length") or 0)) + if self.path == "/api/embeddings": + return self._send(200, {"embedding": [0.1] * srv.embedding_dim}) + self._send(404, {}) + + def do_GET(self): + srv = self.server + srv.seen_headers.append(dict(self.headers)) + if self.path.startswith("/collections") and srv.api_key and self.headers.get("api-key") != srv.api_key: + return self._send(401, {}) + if self.path == "/api/tags": + return self._send(200, {"models": [{"name": m} for m in srv.models]}) + if self.path == "/collections": + return self._send(200, {"result": {"collections": []}}) + if self.path.startswith("/collections/"): + name = self.path.rsplit("/", 1)[1] + if name not in srv.collections: + return self._send(404, {}) + size = srv.collections[name] + return self._send(200, {"result": {"config": {"params": {"vectors": {"size": size}}}}}) + if self.path == "/healthz": + return self._send(200, srv.health) + if self.path == "/admin/stats": + collections = {k: {"name": f"mindnet_dev_{k}", "count": v} for k, v in srv.counts.items()} + return self._send(200, {"collections": collections, "config": {"vector_size": srv.vector_size}}) + if self.path == "/_stcore/health": + return self._send(200, srv.ui_body) + self._send(404, {}) + + +@pytest.fixture +def services(): + srv = FakeServices() + thread = threading.Thread(target=srv.serve_forever, daemon=True) + thread.start() + yield srv + srv.shutdown() + srv.server_close() + + +@pytest.fixture +def live_env(monkeypatch, services): + for key in ("QDRANT_API_KEY", "MINDNET_EXPECTED_VECTOR_DIM", "MINDNET_EXPECTED_EMBEDDING_MODEL"): + monkeypatch.delenv(key, raising=False) + monkeypatch.chdir(DEPLOY.parent) + monkeypatch.setenv("MINDNET_OLLAMA_URL", services.url) + monkeypatch.setenv("QDRANT_URL", services.url) + monkeypatch.setenv("COLLECTION_PREFIX", "mindnet_dev") + monkeypatch.setenv("MINDNET_LLM_MODEL", "phi3:mini") + return monkeypatch + + +def _closed_port_url(): + srv = ThreadingHTTPServer(("127.0.0.1", 0), BaseHTTPRequestHandler) + port = srv.server_address[1] + srv.server_close() + return f"http://127.0.0.1:{port}" + + +# --- Dienst-URLs (statisch) ------------------------------------------------------------- + +@pytest.mark.parametrize("url", ["", "http://127.0.0.1:11434", "http://localhost:6333", "http://0.0.0.0:6333"]) +def test_service_urls_reject_missing_or_container_local(monkeypatch, url): + monkeypatch.setenv("QDRANT_URL", "http://qdrant:6333") + monkeypatch.setenv("MINDNET_OLLAMA_URL", url) + with pytest.raises(ep.PreflightError, match="MINDNET_OLLAMA_URL"): + ep.check_service_urls() + + +def test_service_urls_accept_host_gateway_and_compose_service(monkeypatch): + monkeypatch.setenv("MINDNET_OLLAMA_URL", "http://host.docker.internal:11434") + monkeypatch.setenv("QDRANT_URL", "http://qdrant:6333") + ep.check_service_urls() + + +def test_required_models_come_from_ollama_profiles_and_chat_model(live_env): + live_env.setenv("MINDNET_LLM_MODEL", "llama3:8b") + assert {"nomic-embed-text", "phi3:mini", "llama3:8b"} <= ep.required_ollama_models() + + +# --- preflight --live ---------------------------------------------------------------------- + +def test_live_passes_when_everything_matches(live_env, capsys): + ep.check_live() + out = capsys.readouterr().out + assert "Ollama erreichbar" in out and "Qdrant erreichbar" in out + + +def test_live_reports_missing_ollama_model(live_env, services): + services.models = ["nomic-embed-text:latest"] + with pytest.raises(ep.PreflightError, match="phi3:mini"): + ep.check_live() + + +def test_live_does_not_accept_other_tag_as_latest(live_env, services): + services.models = ["nomic-embed-text:v1.5", "phi3:mini"] + with pytest.raises(ep.PreflightError, match="nomic-embed-text"): + ep.check_live() + + +def test_live_rejects_wrong_embedding_dimension(live_env, services): + services.embedding_dim = 384 + with pytest.raises(ep.PreflightError, match="384 Dimensionen"): + ep.check_live() + + +def test_live_rejects_wrong_collection_dimension(live_env, services): + services.collections["mindnet_dev_chunks"] = 384 + with pytest.raises(ep.PreflightError, match="mindnet_dev_chunks"): + ep.check_live() + + +def test_live_accepts_missing_collections(live_env, services, capsys): + services.collections = {} + ep.check_live() + assert "existiert noch nicht" in capsys.readouterr().out + + +def test_live_sends_qdrant_api_key(live_env, services): + services.api_key = "secret" + with pytest.raises(ep.PreflightError, match="HTTP 401"): + ep.check_live() + live_env.setenv("QDRANT_API_KEY", "secret") + ep.check_live() + + +@pytest.mark.parametrize("var", ["MINDNET_OLLAMA_URL", "QDRANT_URL"]) +def test_live_unreachable_service_is_a_clear_error(live_env, var): + live_env.setenv(var, _closed_port_url()) + with pytest.raises(ep.PreflightError, match="nicht erreichbar"): + ep.check_live() + + +def test_unreachable_host_gateway_hints_at_loopback_binding(monkeypatch): + def refuse(*args, **kwargs): + raise urllib.error.URLError(ConnectionRefusedError(111, "Connection refused")) + + monkeypatch.setattr(ep.urllib.request, "urlopen", refuse) + with pytest.raises(ep.PreflightError, match="nur an 127.0.0.1"): + ep._fetch_json("http://host.docker.internal:11434/api/tags") + + +def test_preflight_live_exits_1_instead_of_traceback(live_env, monkeypatch, tmp_path): + root = tmp_path / "vault" + (root / "_system" / "dictionary").mkdir(parents=True) + (root / "_system" / "dictionary" / "edge_vocabulary.md").write_text("x", encoding="utf-8") + for key, value in {"MINDNET_ENV": "dev", "VECTOR_DIM": "768", "MINDNET_VAULT_ROOT": str(root), + "OPENROUTER_API_KEY": "", "GOOGLE_API_KEY": "", "MINDNET_EMBEDDING_MODEL": ""}.items(): + monkeypatch.setenv(key, value) + monkeypatch.setattr(ep, "_is_read_only_mount", lambda path: True) + monkeypatch.setattr(ep, "check_service_urls", lambda: None) # Fake-Server läuft auf 127.0.0.1 + assert ep.main(["entrypoint.py", "preflight", "--live"]) == 0 + monkeypatch.setenv("QDRANT_URL", _closed_port_url()) + assert ep.main(["entrypoint.py", "preflight", "--live"]) == 1 + + +# --- smoke.py --------------------------------------------------------------------------------- + +def _smoke(services, **kwargs): + return smoke.run(services.url, services.url, "mindnet_dev", attempts=1, **kwargs) + + +def test_smoke_ok(services, capsys): + assert _smoke(services) == 0 + assert "smoke: OK" in capsys.readouterr().out + + +@pytest.mark.parametrize("change", [ + lambda s: s.health.update(prefix="mindnet"), + lambda s: s.health.update(status="degraded"), + lambda s: setattr(s, "vector_size", 384), + lambda s: setattr(s, "ui_body", b"starting"), +]) +def test_smoke_fails_on_wrong_state(services, change): + change(services) + assert _smoke(services) == 1 + + +def test_smoke_unreachable_api(): + url = _closed_port_url() + assert smoke.run(url, url, "mindnet_dev", attempts=1) == 1 + + +def test_smoke_missing_collection_warns_in_dev_and_fails_with_require_data(services, capsys): + services.counts["edges"] = -1 + assert _smoke(services) == 0 + assert "WARNUNG" in capsys.readouterr().out + assert _smoke(services, require_data=True) == 1 + + +def test_smoke_require_data_rejects_empty_notes(services): + services.counts["notes"] = 0 + assert _smoke(services) == 0 + assert _smoke(services, require_data=True) == 1 diff --git a/tests/test_container_preflight.py b/tests/test_container_preflight.py index 197978b..648b706 100644 --- a/tests/test_container_preflight.py +++ b/tests/test_container_preflight.py @@ -240,3 +240,42 @@ def test_prod_env_example_blocks_cloud_egress(): if "=" in l and not l.startswith("#")) assert values["OPENROUTER_API_KEY"] == "" and values["GOOGLE_API_KEY"] == "" assert values["MINDNET_ALLOW_CLOUD_EGRESS"] == "false" + + +# --- Gitea-Workflows und Deploy-Skript (Muster wie Kansho: develop -> dev, main -> prod) ---- + +def _workflow(name): + data = yaml.safe_load((DEPLOY / "gitea-workflows" / name).read_text(encoding="utf-8")) + return data, data.get("on", data.get(True)) # PyYAML liest den Schlüssel 'on' als True + + +@pytest.mark.parametrize("name, branch, envname", [("deploy-dev.yml", "develop", "dev"), + ("deploy-prod.yml", "main", "prod")]) +def test_workflow_maps_branch_to_environment(name, branch, envname): + wf, on = _workflow(name) + assert on["push"]["branches"] == [branch] + job = wf["jobs"]["deploy"] + assert job["runs-on"] == "linux_host" + assert job["env"]["MINDNET_ENV_FILE"].startswith("/") and job["env"]["MINDNET_ENV_FILE"].endswith(f"{envname}.env") + assert any(s.get("run") == f"bash deploy/deploy.sh {envname}" for s in job["steps"]) + + +def test_prod_workflow_shares_concurrency_with_systemd_deploy(): + wf, _ = _workflow("deploy-prod.yml") + systemd = yaml.safe_load((ROOT / ".gitea" / "workflows" / "deploy.yml").read_text(encoding="utf-8")) + assert wf["concurrency"]["group"] == systemd["concurrency"]["group"] + + +def test_deploy_script_checks_before_touching_running_stack(): + script = (DEPLOY / "deploy.sh").read_text(encoding="utf-8") + assert "\r" not in script + steps = script.split('step "1/5', 1)[1] # ohne Kopfkommentar und Funktionsdefinitionen + order = [steps.index(s) for s in ("--network none", "preflight --live", "up -d --wait --no-build && smoke")] + assert order == sorted(order) + assert "RUN_DEPS=(--no-deps)" in script and "SMOKE_ARGS=(--require-data)" in script + assert "last_good_tag" in script + + +@pytest.mark.parametrize("envname", ["dev", "prod"]) +def test_compose_reads_env_file_from_host(envname): + assert COMPOSE[envname]["x-hardening"]["env_file"] == [f"${{MINDNET_ENV_FILE:-env/{envname}.env}}"]