Add Fathom vLLM backup 20260417_053924

restore_fathom_vm.sh

@@ -1,66 +1,40 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-REPO_ID="umer07/vllm-deployement-backup"
-WORKDIR="${PWD}"
+REPO_ID="${REPO_ID:-umer07/vllm-deployement-backup}"
+REPO_TYPE="${REPO_TYPE:-dataset}"
+WORKDIR="${WORKDIR:-/root/fathom-restore}"
 DOWNLOAD_LATEST=0
 START_SERVICES=0
-HF_TOKEN="${HF_TOKEN:-}"
+HF_TOKEN="${HF_TOKEN:-${HUGGING_FACE_HUB_TOKEN:-}}"
 
 usage() {
   cat <<'EOF'
 Usage:
   restore_fathom_vm.sh [--download-latest] [--start] [--workdir DIR] [--repo-id ID] [--hf-token TOKEN]
 
-What it does:
-  1. Finds the latest matching backup set
-  2. Extracts the application archive at /
-  3. Recreates and restores Docker volumes
-  4. Optionally starts /root/serve.py and docker compose
-
-Examples:
-  HF_TOKEN=hf_xxx sudo ./restore_fathom_vm.sh --download-latest --start
-  sudo ./restore_fathom_vm.sh --workdir /root/backups --start
-
-Expected files in workdir when not using --download-latest:
-  vllm_deployement_backup_<timestamp>.tar.gz
-  fathom_minio_data_<timestamp>.tar.gz
-  fathom_neo4j_data_<timestamp>.tar.gz
-  fathom_neo4j_logs_<timestamp>.tar.gz
+Restores the latest Fathom vLLM VM backup from Hugging Face.
+
+Expected current runtime:
+  - vLLM via systemd: fathom-vllm.service
+  - vLLM OpenAI-compatible API: http://127.0.0.1:8000/v1
+  - Backend: http://127.0.0.1:7860
+  - Dashboard: http://127.0.0.1:3000
+
+The target VM should be a ROCm/vLLM-capable image. The DigitalOcean vLLM ROCm
+marketplace image provides the expected container named "rocm".
 EOF
 }
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
-    --download-latest)
-      DOWNLOAD_LATEST=1
-      shift
-      ;;
-    --start)
-      START_SERVICES=1
-      shift
-      ;;
-    --workdir)
-      WORKDIR="$2"
-      shift 2
-      ;;
-    --repo-id)
-      REPO_ID="$2"
-      shift 2
-      ;;
-    --hf-token)
-      HF_TOKEN="$2"
-      shift 2
-      ;;
-    -h|--help)
-      usage
-      exit 0
-      ;;
-    *)
-      echo "Unknown argument: $1" >&2
-      usage
-      exit 1
-      ;;
+    --download-latest) DOWNLOAD_LATEST=1; shift ;;
+    --start) START_SERVICES=1; shift ;;
+    --workdir) WORKDIR="$2"; shift 2 ;;
+    --repo-id) REPO_ID="$2"; shift 2 ;;
+    --hf-token) HF_TOKEN="$2"; shift 2 ;;
+    -h|--help) usage; exit 0 ;;
+    *) echo "Unknown argument: $1" >&2; usage; exit 1 ;;
   esac
 done
 
@@ -77,9 +51,10 @@ if [[ ${DOWNLOAD_LATEST} -eq 1 ]]; then
     echo "HF_TOKEN is required with --download-latest." >&2
     exit 1
   fi
-
-  export REPO_ID HF_TOKEN WORKDIR
+  python3 -m pip install --break-system-packages -q -U huggingface_hub >/dev/null 2>&1 || true
+  export REPO_ID REPO_TYPE HF_TOKEN WORKDIR
   python3 - <<'PY'
+import json
 import os
 import re
 import sys
@@ -87,95 +62,114 @@ from collections import defaultdict
 from huggingface_hub import HfApi, hf_hub_download
 
 repo_id = os.environ["REPO_ID"]
+repo_type = os.environ["REPO_TYPE"]
 token = os.environ["HF_TOKEN"]
 workdir = os.environ["WORKDIR"]
 api = HfApi(token=token)
-files = api.list_repo_files(repo_id=repo_id, repo_type="dataset")
+files = api.list_repo_files(repo_id=repo_id, repo_type=repo_type)
 
-patterns = {
-    "app": re.compile(r"^vllm_deployement_backup_(\d{8}_\d{6})\.tar\.gz$"),
-    "minio": re.compile(r"^fathom_minio_data_(\d{8}_\d{6})\.tar\.gz$"),
-    "neo4j_data": re.compile(r"^fathom_neo4j_data_(\d{8}_\d{6})\.tar\.gz$"),
-    "neo4j_logs": re.compile(r"^fathom_neo4j_logs_(\d{8}_\d{6})\.tar\.gz$"),
+required = {
+    "app": r"^vllm_deployement_backup_(\d{8}_\d{6})\.tar\.gz$",
+    "minio": r"^fathom_minio_data_(\d{8}_\d{6})\.tar\.gz$",
+    "neo4j_data": r"^fathom_neo4j_data_(\d{8}_\d{6})\.tar\.gz$",
+    "neo4j_logs": r"^fathom_neo4j_logs_(\d{8}_\d{6})\.tar\.gz$",
+}
+optional = {
+    "hf_cache": r"^fathom_hf_cache_(\d{8}_\d{6})\.tar\.gz$",
+    "adapters": r"^fathom_adapters_(\d{8}_\d{6})\.tar\.gz$",
+    "guide": r"^VM_RECOVERY_GUIDE_(\d{8}_\d{6})\.md$",
+    "manifest": r"^vllm_deployement_backup_manifest_(\d{8}_\d{6})\.txt$",
+    "restore": r"^restore_fathom_vm\.sh$",
 }
 
-groups = defaultdict(set)
+groups = defaultdict(dict)
 for name in files:
     base = name.rsplit("/", 1)[-1]
-    for key, pattern in patterns.items():
-        match = pattern.match(base)
-        if match:
-            groups[match.group(1)].add(key)
-
-complete = [ts for ts, keys in groups.items() if set(patterns) <= keys]
+    if "/" in name and not name.startswith("backups/"):
+        continue
+    for key, pattern in {**required, **optional}.items():
+        m = re.match(pattern, base)
+        if m:
+            groups[m.group(1) if key != "restore" else "restore"][key] = name
+
+complete = [ts for ts, found in groups.items() if ts != "restore" and set(required) <= set(found)]
 if not complete:
-    print("No complete backup set found in dataset.", file=sys.stderr)
+    print("No complete backup set found.", file=sys.stderr)
     sys.exit(1)
 
 ts = sorted(complete)[-1]
-targets = [
-    f"vllm_deployement_backup_{ts}.tar.gz",
-    f"fathom_minio_data_{ts}.tar.gz",
-    f"fathom_neo4j_data_{ts}.tar.gz",
-    f"fathom_neo4j_logs_{ts}.tar.gz",
-]
-
-for name in targets:
+targets = dict(groups[ts])
+if "restore" in groups:
+    targets.update(groups["restore"])
+
+print(f"Downloading backup timestamp {ts}")
+for key, name in sorted(targets.items()):
     path = hf_hub_download(
         repo_id=repo_id,
-        repo_type="dataset",
+        repo_type=repo_type,
         filename=name,
         token=token,
         local_dir=workdir,
     )
-    print(path)
+    print(f"{key}: {path}")
 PY
 fi
 
 latest_file() {
   local pattern="$1"
-  ls -1 ${pattern} 2>/dev/null | sort | tail -n 1
+  find "${WORKDIR}" -maxdepth 3 -type f -name "${pattern}" -printf '%f\t%p\n' 2>/dev/null | sort | tail -n 1 | cut -f2-
 }
 
 APP_ARCHIVE="$(latest_file 'vllm_deployement_backup_*.tar.gz')"
 MINIO_ARCHIVE="$(latest_file 'fathom_minio_data_*.tar.gz')"
 NEO4J_DATA_ARCHIVE="$(latest_file 'fathom_neo4j_data_*.tar.gz')"
 NEO4J_LOGS_ARCHIVE="$(latest_file 'fathom_neo4j_logs_*.tar.gz')"
+HF_CACHE_ARCHIVE="$(latest_file 'fathom_hf_cache_*.tar.gz' || true)"
+ADAPTERS_ARCHIVE="$(latest_file 'fathom_adapters_*.tar.gz' || true)"
 
-for required in "${APP_ARCHIVE}" "${MINIO_ARCHIVE}" "${NEO4J_DATA_ARCHIVE}" "${NEO4J_LOGS_ARCHIVE}"; do
-  if [[ -z "${required}" || ! -f "${required}" ]]; then
+for required_file in "${APP_ARCHIVE}" "${MINIO_ARCHIVE}" "${NEO4J_DATA_ARCHIVE}" "${NEO4J_LOGS_ARCHIVE}"; do
+  if [[ -z "${required_file}" || ! -f "${required_file}" ]]; then
     echo "Missing required backup file in ${WORKDIR}." >&2
     exit 1
   fi
 done
 
-echo "Using backup set:"
-printf '  %s\n' "${APP_ARCHIVE}" "${MINIO_ARCHIVE}" "${NEO4J_DATA_ARCHIVE}" "${NEO4J_LOGS_ARCHIVE}"
+restore_volume() {
+  local volume="$1"
+  local archive="$2"
+  if [[ -z "${archive}" || ! -f "${archive}" ]]; then
+    echo "Skipping optional volume ${volume}; archive not present."
+    return
+  fi
+  echo "Restoring Docker volume ${volume}"
+  docker volume create "${volume}" >/dev/null
+  docker run --rm \
+    -v "${volume}:/restore" \
+    -v "$(dirname "${archive}"):/backup" \
+    alpine sh -c "cd /restore && rm -rf ./* ./.??* 2>/dev/null || true && tar -xzf /backup/$(basename "${archive}")"
+}
 
-echo "Extracting application archive at /"
+echo "Extracting application/vLLM archive at /"
 tar -xzf "${APP_ARCHIVE}" -C /
+chmod +x /usr/local/bin/fathom-vllm-start /usr/local/bin/fathom-vllm-stop 2>/dev/null || true
+systemctl daemon-reload || true
 
-echo "Recreating Docker volumes"
-docker volume create fathom_minio_data >/dev/null
-docker volume create fathom_neo4j_data >/dev/null
-docker volume create fathom_neo4j_logs >/dev/null
-
-echo "Restoring MinIO volume"
-docker run --rm -v fathom_minio_data:/restore -v "${WORKDIR}:/backup" alpine \
-  sh -c "cd /restore && rm -rf ./* ./.??* 2>/dev/null || true && tar -xzf /backup/$(basename "${MINIO_ARCHIVE}")"
-
-echo "Restoring Neo4j data volume"
-docker run --rm -v fathom_neo4j_data:/restore -v "${WORKDIR}:/backup" alpine \
-  sh -c "cd /restore && rm -rf ./* ./.??* 2>/dev/null || true && tar -xzf /backup/$(basename "${NEO4J_DATA_ARCHIVE}")"
-
-echo "Restoring Neo4j logs volume"
-docker run --rm -v fathom_neo4j_logs:/restore -v "${WORKDIR}:/backup" alpine \
-  sh -c "cd /restore && rm -rf ./* ./.??* 2>/dev/null || true && tar -xzf /backup/$(basename "${NEO4J_LOGS_ARCHIVE}")"
+restore_volume fathom_minio_data "${MINIO_ARCHIVE}"
+restore_volume fathom_neo4j_data "${NEO4J_DATA_ARCHIVE}"
+restore_volume fathom_neo4j_logs "${NEO4J_LOGS_ARCHIVE}"
+restore_volume fathom_hf_cache "${HF_CACHE_ARCHIVE}"
+restore_volume fathom_fathom_adapters "${ADAPTERS_ARCHIVE}"
 
 if [[ ${START_SERVICES} -eq 1 ]]; then
-  echo "Starting host-side model server"
-  nohup python3 /root/serve.py > /root/serve.log 2>&1 &
-  sleep 10
+  echo "Starting vLLM service"
+  systemctl enable fathom-vllm.service >/dev/null 2>&1 || true
+  systemctl restart fathom-vllm.service || true
+  for i in $(seq 1 40); do
+    if curl -fsS http://127.0.0.1:8000/v1/models >/dev/null 2>&1; then
+      break
+    fi
+    sleep 15
+  done
 
   echo "Starting Docker stack"
   cd /opt/fathom