Spaces:
Paused
Paused
feat: add verbose logging to sync daemon and entrypoint
Browse files- Timestamps on every log line
- Log all shell commands + exit codes + elapsed time
- Show config at startup (token, repo, intervals, excludes)
- Show rootfs size/file count at each step
- Show upload method, ignore patterns, timing
- Cycle counter in sync-loop
- Boxed section headers for visual clarity
- Entrypoint logs all env vars and each step
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
- scripts/entrypoint.sh +36 -13
- ubuntu-server/git_sync_daemon.py +131 -30
scripts/entrypoint.sh
CHANGED
|
@@ -1,30 +1,44 @@
|
|
| 1 |
#!/bin/bash
|
| 2 |
# βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
|
| 3 |
# HuggingRun Entrypoint
|
| 4 |
-
# Uses git_sync_daemon.py
|
| 5 |
# Then runs the user command (start-server.sh)
|
| 6 |
# βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
|
| 7 |
set -e
|
| 8 |
-
echo "
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 9 |
|
| 10 |
# Determine dataset repo
|
| 11 |
if [ -z "$HF_DATASET_REPO" ]; then
|
| 12 |
if [ -n "$SPACE_ID" ]; then
|
| 13 |
export HF_DATASET_REPO="${SPACE_ID}-data"
|
|
|
|
| 14 |
elif [ -n "$HF_TOKEN" ]; then
|
|
|
|
| 15 |
export HF_DATASET_REPO=$(python3 -c "
|
| 16 |
from huggingface_hub import HfApi
|
| 17 |
import os
|
| 18 |
try:
|
| 19 |
-
|
| 20 |
-
|
| 21 |
-
|
|
|
|
| 22 |
" 2>/dev/null)
|
|
|
|
| 23 |
fi
|
| 24 |
fi
|
| 25 |
|
| 26 |
# Ensure dataset repo exists
|
| 27 |
if [ -n "$HF_TOKEN" ] && [ -n "$HF_DATASET_REPO" ]; then
|
|
|
|
| 28 |
python3 -c "
|
| 29 |
from huggingface_hub import HfApi
|
| 30 |
import os
|
|
@@ -32,11 +46,13 @@ api = HfApi(token=os.environ['HF_TOKEN'])
|
|
| 32 |
repo = os.environ['HF_DATASET_REPO']
|
| 33 |
try:
|
| 34 |
api.repo_info(repo_id=repo, repo_type='dataset')
|
| 35 |
-
print(f'[
|
| 36 |
except:
|
| 37 |
api.create_repo(repo_id=repo, repo_type='dataset', private=True)
|
| 38 |
-
print(f'[
|
| 39 |
-
" 2>
|
|
|
|
|
|
|
| 40 |
fi
|
| 41 |
|
| 42 |
# Write env for other processes (sshd, cron, etc.)
|
|
@@ -45,15 +61,22 @@ export HF_TOKEN="${HF_TOKEN}"
|
|
| 45 |
export HF_DATASET_REPO="${HF_DATASET_REPO}"
|
| 46 |
export PERSIST_PATH="${PERSIST_PATH:-/data}"
|
| 47 |
ENVEOF
|
|
|
|
| 48 |
|
| 49 |
-
# Step 1: Init β
|
|
|
|
| 50 |
python3 -u /opt/git_sync_daemon.py init
|
|
|
|
| 51 |
|
| 52 |
-
# Step 2: Start background sync-loop daemon
|
|
|
|
| 53 |
python3 -u /opt/git_sync_daemon.py sync-loop &
|
| 54 |
-
|
|
|
|
| 55 |
|
| 56 |
-
# Run user command
|
| 57 |
CMD="${RUN_CMD:-python3 /app/demo_app.py}"
|
| 58 |
-
echo "[
|
|
|
|
|
|
|
| 59 |
exec $CMD
|
|
|
|
| 1 |
#!/bin/bash
|
| 2 |
# βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
|
| 3 |
# HuggingRun Entrypoint
|
| 4 |
+
# Uses git_sync_daemon.py for dataset β filesystem sync
|
| 5 |
# Then runs the user command (start-server.sh)
|
| 6 |
# βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
|
| 7 |
set -e
|
| 8 |
+
echo "========================================" >&2
|
| 9 |
+
echo "[entrypoint] HuggingRun starting ..." >&2
|
| 10 |
+
echo "[entrypoint] Date: $(date -u)" >&2
|
| 11 |
+
echo "[entrypoint] Hostname: $(hostname)" >&2
|
| 12 |
+
echo "[entrypoint] SPACE_ID=${SPACE_ID:-not set}" >&2
|
| 13 |
+
echo "[entrypoint] HF_TOKEN=${HF_TOKEN:+set (${#HF_TOKEN} chars)}${HF_TOKEN:-NOT SET}" >&2
|
| 14 |
+
echo "[entrypoint] HF_DATASET_REPO=${HF_DATASET_REPO:-not set}" >&2
|
| 15 |
+
echo "[entrypoint] PERSIST_PATH=${PERSIST_PATH:-/data}" >&2
|
| 16 |
+
echo "[entrypoint] RUN_CMD=${RUN_CMD:-default}" >&2
|
| 17 |
+
echo "========================================" >&2
|
| 18 |
|
| 19 |
# Determine dataset repo
|
| 20 |
if [ -z "$HF_DATASET_REPO" ]; then
|
| 21 |
if [ -n "$SPACE_ID" ]; then
|
| 22 |
export HF_DATASET_REPO="${SPACE_ID}-data"
|
| 23 |
+
echo "[entrypoint] Auto-set HF_DATASET_REPO=${HF_DATASET_REPO} (from SPACE_ID)" >&2
|
| 24 |
elif [ -n "$HF_TOKEN" ]; then
|
| 25 |
+
echo "[entrypoint] Resolving HF_DATASET_REPO from HF_TOKEN whoami ..." >&2
|
| 26 |
export HF_DATASET_REPO=$(python3 -c "
|
| 27 |
from huggingface_hub import HfApi
|
| 28 |
import os
|
| 29 |
try:
|
| 30 |
+
name = HfApi(token=os.environ['HF_TOKEN']).whoami()['name']
|
| 31 |
+
print(name + '/HuggingRun-data')
|
| 32 |
+
except Exception as e:
|
| 33 |
+
print('', end='')
|
| 34 |
" 2>/dev/null)
|
| 35 |
+
echo "[entrypoint] Resolved HF_DATASET_REPO=${HF_DATASET_REPO}" >&2
|
| 36 |
fi
|
| 37 |
fi
|
| 38 |
|
| 39 |
# Ensure dataset repo exists
|
| 40 |
if [ -n "$HF_TOKEN" ] && [ -n "$HF_DATASET_REPO" ]; then
|
| 41 |
+
echo "[entrypoint] Verifying dataset repo: ${HF_DATASET_REPO} ..." >&2
|
| 42 |
python3 -c "
|
| 43 |
from huggingface_hub import HfApi
|
| 44 |
import os
|
|
|
|
| 46 |
repo = os.environ['HF_DATASET_REPO']
|
| 47 |
try:
|
| 48 |
api.repo_info(repo_id=repo, repo_type='dataset')
|
| 49 |
+
print(f'[entrypoint] Dataset exists: {repo}', flush=True)
|
| 50 |
except:
|
| 51 |
api.create_repo(repo_id=repo, repo_type='dataset', private=True)
|
| 52 |
+
print(f'[entrypoint] Created dataset: {repo}', flush=True)
|
| 53 |
+
" 2>&1 || echo "[entrypoint] WARNING: Could not verify dataset" >&2
|
| 54 |
+
else
|
| 55 |
+
echo "[entrypoint] WARNING: No HF_TOKEN or HF_DATASET_REPO β persistence disabled" >&2
|
| 56 |
fi
|
| 57 |
|
| 58 |
# Write env for other processes (sshd, cron, etc.)
|
|
|
|
| 61 |
export HF_DATASET_REPO="${HF_DATASET_REPO}"
|
| 62 |
export PERSIST_PATH="${PERSIST_PATH:-/data}"
|
| 63 |
ENVEOF
|
| 64 |
+
echo "[entrypoint] Wrote /etc/huggingrun.env" >&2
|
| 65 |
|
| 66 |
+
# Step 1: Init β download dataset + restore filesystem
|
| 67 |
+
echo "[entrypoint] ββ Step 1: Init (download + restore) ββ" >&2
|
| 68 |
python3 -u /opt/git_sync_daemon.py init
|
| 69 |
+
echo "[entrypoint] ββ Init done ββ" >&2
|
| 70 |
|
| 71 |
+
# Step 2: Start background sync-loop daemon
|
| 72 |
+
echo "[entrypoint] ββ Step 2: Starting sync-loop daemon ββ" >&2
|
| 73 |
python3 -u /opt/git_sync_daemon.py sync-loop &
|
| 74 |
+
SYNC_PID=$!
|
| 75 |
+
echo "[entrypoint] Sync daemon PID=${SYNC_PID}" >&2
|
| 76 |
|
| 77 |
+
# Step 3: Run user command
|
| 78 |
CMD="${RUN_CMD:-python3 /app/demo_app.py}"
|
| 79 |
+
echo "[entrypoint] ββ Step 3: exec user command ββ" >&2
|
| 80 |
+
echo "[entrypoint] CMD=${CMD}" >&2
|
| 81 |
+
echo "========================================" >&2
|
| 82 |
exec $CMD
|
ubuntu-server/git_sync_daemon.py
CHANGED
|
@@ -17,6 +17,7 @@ import sys
|
|
| 17 |
import time
|
| 18 |
import subprocess
|
| 19 |
import signal
|
|
|
|
| 20 |
|
| 21 |
# ββ Config βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
|
| 22 |
PERSIST_PATH = os.environ.get("PERSIST_PATH", "/data")
|
|
@@ -41,73 +42,141 @@ UPLOAD_IGNORE = [
|
|
| 41 |
|
| 42 |
|
| 43 |
def log(msg):
|
| 44 |
-
|
|
|
|
| 45 |
|
| 46 |
|
| 47 |
def run(cmd, cwd=None):
|
| 48 |
-
"""Run a shell command, return (returncode, stdout)."""
|
|
|
|
|
|
|
| 49 |
r = subprocess.run(
|
| 50 |
cmd, shell=True, cwd=cwd,
|
| 51 |
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
|
| 52 |
)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 53 |
return r.returncode, r.stdout.strip()
|
| 54 |
|
| 55 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 56 |
def download_dataset():
|
| 57 |
"""Download the full dataset to PERSIST_PATH using huggingface_hub."""
|
| 58 |
from huggingface_hub import snapshot_download
|
| 59 |
|
| 60 |
-
log(f"
|
|
|
|
|
|
|
| 61 |
try:
|
| 62 |
-
snapshot_download(
|
| 63 |
repo_id=HF_DATASET_REPO,
|
| 64 |
repo_type="dataset",
|
| 65 |
local_dir=PERSIST_PATH,
|
| 66 |
token=HF_TOKEN,
|
| 67 |
)
|
| 68 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 69 |
except Exception as e:
|
| 70 |
-
|
|
|
|
| 71 |
os.makedirs(PERSIST_PATH, exist_ok=True)
|
| 72 |
|
| 73 |
|
| 74 |
def restore_system():
|
| 75 |
"""Restore filesystem from /data/rootfs/ β /."""
|
| 76 |
-
|
| 77 |
-
|
|
|
|
| 78 |
os.makedirs(ROOTFS, exist_ok=True)
|
| 79 |
return
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 80 |
|
| 81 |
-
log("Restoring filesystem from rootfs β / ...")
|
| 82 |
excludes = " ".join(f"--exclude='{e}'" for e in RSYNC_EXCLUDES)
|
| 83 |
-
|
| 84 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 85 |
|
| 86 |
|
| 87 |
def ensure_passwords():
|
| 88 |
"""Re-ensure user/root passwords after restore."""
|
|
|
|
| 89 |
run("id user >/dev/null 2>&1 || useradd -m -s /bin/bash user")
|
| 90 |
run('usermod -p "$(openssl passwd -6 huggingrun)" user')
|
| 91 |
run('usermod -p "$(openssl passwd -6 huggingrun)" root')
|
| 92 |
run("ldconfig")
|
| 93 |
-
log("Passwords
|
| 94 |
|
| 95 |
|
| 96 |
def save_and_upload():
|
| 97 |
"""Rsync filesystem β rootfs, upload to dataset."""
|
| 98 |
from huggingface_hub import HfApi
|
| 99 |
|
| 100 |
-
log("
|
|
|
|
| 101 |
os.makedirs(ROOTFS, exist_ok=True)
|
| 102 |
|
| 103 |
excludes = " ".join(f"--exclude='{e}'" for e in RSYNC_EXCLUDES)
|
| 104 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 105 |
run(f"chmod -R a+r {ROOTFS}/")
|
| 106 |
|
| 107 |
-
log("
|
| 108 |
api = HfApi(token=HF_TOKEN)
|
| 109 |
ts = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
|
|
|
|
|
|
|
| 110 |
|
|
|
|
| 111 |
try:
|
| 112 |
api.upload_large_folder(
|
| 113 |
folder_path=PERSIST_PATH,
|
|
@@ -115,9 +184,13 @@ def save_and_upload():
|
|
| 115 |
repo_type="dataset",
|
| 116 |
ignore_patterns=UPLOAD_IGNORE,
|
| 117 |
)
|
| 118 |
-
|
|
|
|
| 119 |
except Exception as e:
|
| 120 |
-
|
|
|
|
|
|
|
|
|
|
| 121 |
try:
|
| 122 |
api.upload_folder(
|
| 123 |
folder_path=PERSIST_PATH,
|
|
@@ -127,66 +200,94 @@ def save_and_upload():
|
|
| 127 |
commit_message=f"sync {ts}",
|
| 128 |
ignore_patterns=UPLOAD_IGNORE,
|
| 129 |
)
|
| 130 |
-
|
|
|
|
| 131 |
except Exception as e2:
|
| 132 |
-
|
|
|
|
|
|
|
|
|
|
| 133 |
|
| 134 |
|
| 135 |
def cmd_init():
|
| 136 |
"""Run once at startup: download dataset + restore filesystem."""
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 137 |
if not HF_TOKEN or not HF_DATASET_REPO:
|
| 138 |
-
log("No HF_TOKEN or HF_DATASET_REPO
|
| 139 |
os.makedirs(PERSIST_PATH, exist_ok=True)
|
| 140 |
return
|
| 141 |
|
| 142 |
-
|
| 143 |
download_dataset()
|
| 144 |
restore_system()
|
| 145 |
ensure_passwords()
|
| 146 |
-
|
|
|
|
| 147 |
|
| 148 |
|
| 149 |
def cmd_sync_loop():
|
| 150 |
"""Background daemon: periodic save + upload."""
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 151 |
if not HF_TOKEN or not HF_DATASET_REPO:
|
| 152 |
-
log("No credentials
|
| 153 |
signal.pause()
|
| 154 |
return
|
| 155 |
|
| 156 |
-
log(f"Sync loop: interval={SYNC_INTERVAL}s")
|
| 157 |
-
|
| 158 |
def on_signal(sig, frame):
|
| 159 |
-
log(f"Signal {sig}, final save ...")
|
| 160 |
try:
|
| 161 |
save_and_upload()
|
| 162 |
except Exception as e:
|
| 163 |
-
log(f"Final save error: {e}")
|
| 164 |
sys.exit(0)
|
| 165 |
|
| 166 |
signal.signal(signal.SIGTERM, on_signal)
|
| 167 |
signal.signal(signal.SIGINT, on_signal)
|
| 168 |
|
| 169 |
-
|
| 170 |
time.sleep(60)
|
| 171 |
|
|
|
|
| 172 |
while True:
|
|
|
|
|
|
|
| 173 |
try:
|
| 174 |
save_and_upload()
|
| 175 |
except Exception as e:
|
| 176 |
-
log(f"Sync error: {e}")
|
|
|
|
|
|
|
|
|
|
| 177 |
time.sleep(SYNC_INTERVAL)
|
| 178 |
|
| 179 |
|
| 180 |
def cmd_save():
|
| 181 |
"""One-time save + upload."""
|
|
|
|
| 182 |
if not HF_TOKEN or not HF_DATASET_REPO:
|
| 183 |
-
log("No credentials")
|
| 184 |
return
|
| 185 |
save_and_upload()
|
| 186 |
|
| 187 |
|
| 188 |
if __name__ == "__main__":
|
| 189 |
cmd = sys.argv[1] if len(sys.argv) > 1 else "init"
|
|
|
|
| 190 |
if cmd == "init":
|
| 191 |
cmd_init()
|
| 192 |
elif cmd == "sync-loop":
|
|
|
|
| 17 |
import time
|
| 18 |
import subprocess
|
| 19 |
import signal
|
| 20 |
+
import shutil
|
| 21 |
|
| 22 |
# ββ Config βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
|
| 23 |
PERSIST_PATH = os.environ.get("PERSIST_PATH", "/data")
|
|
|
|
| 42 |
|
| 43 |
|
| 44 |
def log(msg):
|
| 45 |
+
ts = time.strftime("%H:%M:%S", time.gmtime())
|
| 46 |
+
print(f"[sync {ts}] {msg}", file=sys.stderr, flush=True)
|
| 47 |
|
| 48 |
|
| 49 |
def run(cmd, cwd=None):
|
| 50 |
+
"""Run a shell command, return (returncode, stdout). Logs the command."""
|
| 51 |
+
log(f" $ {cmd}")
|
| 52 |
+
t0 = time.time()
|
| 53 |
r = subprocess.run(
|
| 54 |
cmd, shell=True, cwd=cwd,
|
| 55 |
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
|
| 56 |
)
|
| 57 |
+
elapsed = time.time() - t0
|
| 58 |
+
if r.returncode != 0:
|
| 59 |
+
log(f" β exit={r.returncode} ({elapsed:.1f}s)")
|
| 60 |
+
if r.stdout.strip():
|
| 61 |
+
for line in r.stdout.strip().split('\n')[:10]:
|
| 62 |
+
log(f" {line}")
|
| 63 |
+
else:
|
| 64 |
+
log(f" β ({elapsed:.1f}s)")
|
| 65 |
return r.returncode, r.stdout.strip()
|
| 66 |
|
| 67 |
|
| 68 |
+
def disk_usage(path):
|
| 69 |
+
"""Get disk usage of a path in human-readable form."""
|
| 70 |
+
try:
|
| 71 |
+
total = 0
|
| 72 |
+
count = 0
|
| 73 |
+
for dirpath, dirnames, filenames in os.walk(path):
|
| 74 |
+
count += len(filenames)
|
| 75 |
+
for f in filenames:
|
| 76 |
+
fp = os.path.join(dirpath, f)
|
| 77 |
+
try:
|
| 78 |
+
total += os.path.getsize(fp)
|
| 79 |
+
except OSError:
|
| 80 |
+
pass
|
| 81 |
+
if total > 1024 * 1024 * 1024:
|
| 82 |
+
return f"{total / 1024 / 1024 / 1024:.1f}GB, {count} files"
|
| 83 |
+
return f"{total / 1024 / 1024:.0f}MB, {count} files"
|
| 84 |
+
except Exception:
|
| 85 |
+
return "unknown"
|
| 86 |
+
|
| 87 |
+
|
| 88 |
def download_dataset():
|
| 89 |
"""Download the full dataset to PERSIST_PATH using huggingface_hub."""
|
| 90 |
from huggingface_hub import snapshot_download
|
| 91 |
|
| 92 |
+
log(f"ββ DOWNLOAD: {HF_DATASET_REPO} β {PERSIST_PATH}")
|
| 93 |
+
log(f" Token: {HF_TOKEN[:10]}...{HF_TOKEN[-4:]}" if len(HF_TOKEN) > 14 else " Token: (short)")
|
| 94 |
+
t0 = time.time()
|
| 95 |
try:
|
| 96 |
+
path = snapshot_download(
|
| 97 |
repo_id=HF_DATASET_REPO,
|
| 98 |
repo_type="dataset",
|
| 99 |
local_dir=PERSIST_PATH,
|
| 100 |
token=HF_TOKEN,
|
| 101 |
)
|
| 102 |
+
elapsed = time.time() - t0
|
| 103 |
+
log(f" Download OK β {path} ({elapsed:.1f}s)")
|
| 104 |
+
# Show what was downloaded
|
| 105 |
+
if os.path.isdir(PERSIST_PATH):
|
| 106 |
+
items = os.listdir(PERSIST_PATH)
|
| 107 |
+
log(f" /data contents: {items}")
|
| 108 |
+
if os.path.isdir(ROOTFS):
|
| 109 |
+
items = os.listdir(ROOTFS)
|
| 110 |
+
log(f" /data/rootfs dirs: {len(items)} β {items[:10]}")
|
| 111 |
+
log(f" /data/rootfs size: {disk_usage(ROOTFS)}")
|
| 112 |
+
else:
|
| 113 |
+
log(f" /data/rootfs: does not exist")
|
| 114 |
except Exception as e:
|
| 115 |
+
elapsed = time.time() - t0
|
| 116 |
+
log(f" β Download failed ({elapsed:.1f}s): {e}")
|
| 117 |
os.makedirs(PERSIST_PATH, exist_ok=True)
|
| 118 |
|
| 119 |
|
| 120 |
def restore_system():
|
| 121 |
"""Restore filesystem from /data/rootfs/ β /."""
|
| 122 |
+
log("ββ RESTORE: /data/rootfs/ β /")
|
| 123 |
+
if not os.path.isdir(ROOTFS):
|
| 124 |
+
log(f" β {ROOTFS} does not exist, starting fresh")
|
| 125 |
os.makedirs(ROOTFS, exist_ok=True)
|
| 126 |
return
|
| 127 |
+
items = os.listdir(ROOTFS)
|
| 128 |
+
if not items:
|
| 129 |
+
log(f" β {ROOTFS} is empty, starting fresh")
|
| 130 |
+
return
|
| 131 |
+
log(f" rootfs has {len(items)} top-level items: {items[:15]}")
|
| 132 |
+
log(f" rootfs size: {disk_usage(ROOTFS)}")
|
| 133 |
|
|
|
|
| 134 |
excludes = " ".join(f"--exclude='{e}'" for e in RSYNC_EXCLUDES)
|
| 135 |
+
cmd = f"rsync -aAX --no-specials --no-devices {excludes} {ROOTFS}/ /"
|
| 136 |
+
t0 = time.time()
|
| 137 |
+
rc, out = run(cmd)
|
| 138 |
+
elapsed = time.time() - t0
|
| 139 |
+
if rc == 0:
|
| 140 |
+
log(f" Restore completed ({elapsed:.1f}s)")
|
| 141 |
+
else:
|
| 142 |
+
log(f" Restore had issues (rc={rc}, {elapsed:.1f}s)")
|
| 143 |
|
| 144 |
|
| 145 |
def ensure_passwords():
|
| 146 |
"""Re-ensure user/root passwords after restore."""
|
| 147 |
+
log("ββ PASSWORDS")
|
| 148 |
run("id user >/dev/null 2>&1 || useradd -m -s /bin/bash user")
|
| 149 |
run('usermod -p "$(openssl passwd -6 huggingrun)" user')
|
| 150 |
run('usermod -p "$(openssl passwd -6 huggingrun)" root')
|
| 151 |
run("ldconfig")
|
| 152 |
+
log(" Passwords set for user + root")
|
| 153 |
|
| 154 |
|
| 155 |
def save_and_upload():
|
| 156 |
"""Rsync filesystem β rootfs, upload to dataset."""
|
| 157 |
from huggingface_hub import HfApi
|
| 158 |
|
| 159 |
+
log("βοΏ½οΏ½οΏ½ββββββββββββββββββββββββββββββββββββββββββββ")
|
| 160 |
+
log("ββ SAVE: rsync / β /data/rootfs/")
|
| 161 |
os.makedirs(ROOTFS, exist_ok=True)
|
| 162 |
|
| 163 |
excludes = " ".join(f"--exclude='{e}'" for e in RSYNC_EXCLUDES)
|
| 164 |
+
t0 = time.time()
|
| 165 |
+
rc, out = run(f"rsync -aAX --no-specials --no-devices --delete {excludes} / {ROOTFS}/")
|
| 166 |
+
elapsed = time.time() - t0
|
| 167 |
+
log(f" rsync done (rc={rc}, {elapsed:.1f}s)")
|
| 168 |
+
log(f" rootfs size: {disk_usage(ROOTFS)}")
|
| 169 |
+
|
| 170 |
+
log(" chmod -R a+r rootfs/ ...")
|
| 171 |
run(f"chmod -R a+r {ROOTFS}/")
|
| 172 |
|
| 173 |
+
log("ββ UPLOAD: /data β dataset")
|
| 174 |
api = HfApi(token=HF_TOKEN)
|
| 175 |
ts = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
|
| 176 |
+
log(f" repo={HF_DATASET_REPO}, method=upload_large_folder")
|
| 177 |
+
log(f" ignore={UPLOAD_IGNORE}")
|
| 178 |
|
| 179 |
+
t0 = time.time()
|
| 180 |
try:
|
| 181 |
api.upload_large_folder(
|
| 182 |
folder_path=PERSIST_PATH,
|
|
|
|
| 184 |
repo_type="dataset",
|
| 185 |
ignore_patterns=UPLOAD_IGNORE,
|
| 186 |
)
|
| 187 |
+
elapsed = time.time() - t0
|
| 188 |
+
log(f" β Upload completed ({elapsed:.1f}s)")
|
| 189 |
except Exception as e:
|
| 190 |
+
elapsed = time.time() - t0
|
| 191 |
+
log(f" β upload_large_folder failed ({elapsed:.1f}s): {e}")
|
| 192 |
+
log(" Trying fallback: upload_folder ...")
|
| 193 |
+
t0 = time.time()
|
| 194 |
try:
|
| 195 |
api.upload_folder(
|
| 196 |
folder_path=PERSIST_PATH,
|
|
|
|
| 200 |
commit_message=f"sync {ts}",
|
| 201 |
ignore_patterns=UPLOAD_IGNORE,
|
| 202 |
)
|
| 203 |
+
elapsed = time.time() - t0
|
| 204 |
+
log(f" β Upload completed via fallback ({elapsed:.1f}s)")
|
| 205 |
except Exception as e2:
|
| 206 |
+
elapsed = time.time() - t0
|
| 207 |
+
log(f" β Fallback also failed ({elapsed:.1f}s): {e2}")
|
| 208 |
+
|
| 209 |
+
log("ββββββββββββββββββββββββββββββββββββββββββββββ")
|
| 210 |
|
| 211 |
|
| 212 |
def cmd_init():
|
| 213 |
"""Run once at startup: download dataset + restore filesystem."""
|
| 214 |
+
log("ββββββββββββββββββββββββββββββββββββββββββββββββ")
|
| 215 |
+
log("β INIT β Full Disk Persistence β")
|
| 216 |
+
log("ββββββββββββββββββββββββββββββββββββββββββββββββ")
|
| 217 |
+
log(f" HF_TOKEN: {'set (' + HF_TOKEN[:10] + '...)' if HF_TOKEN else 'NOT SET'}")
|
| 218 |
+
log(f" HF_DATASET_REPO: {HF_DATASET_REPO or 'NOT SET'}")
|
| 219 |
+
log(f" PERSIST_PATH: {PERSIST_PATH}")
|
| 220 |
+
log(f" ROOTFS: {ROOTFS}")
|
| 221 |
+
log(f" SYNC_INTERVAL: {SYNC_INTERVAL}s")
|
| 222 |
+
log(f" RSYNC_EXCLUDES: {RSYNC_EXCLUDES}")
|
| 223 |
+
|
| 224 |
if not HF_TOKEN or not HF_DATASET_REPO:
|
| 225 |
+
log(" β No HF_TOKEN or HF_DATASET_REPO β persistence DISABLED")
|
| 226 |
os.makedirs(PERSIST_PATH, exist_ok=True)
|
| 227 |
return
|
| 228 |
|
| 229 |
+
t0 = time.time()
|
| 230 |
download_dataset()
|
| 231 |
restore_system()
|
| 232 |
ensure_passwords()
|
| 233 |
+
elapsed = time.time() - t0
|
| 234 |
+
log(f" Init complete ({elapsed:.1f}s)")
|
| 235 |
|
| 236 |
|
| 237 |
def cmd_sync_loop():
|
| 238 |
"""Background daemon: periodic save + upload."""
|
| 239 |
+
log("ββββββββββββββββββββββββββββββββββββββββββββββββ")
|
| 240 |
+
log("β SYNC-LOOP daemon started β")
|
| 241 |
+
log("ββββββββββββββββββββββββββββββββββββββββββββββββ")
|
| 242 |
+
log(f" HF_TOKEN: {'set' if HF_TOKEN else 'NOT SET'}")
|
| 243 |
+
log(f" HF_DATASET_REPO: {HF_DATASET_REPO or 'NOT SET'}")
|
| 244 |
+
log(f" SYNC_INTERVAL: {SYNC_INTERVAL}s")
|
| 245 |
+
|
| 246 |
if not HF_TOKEN or not HF_DATASET_REPO:
|
| 247 |
+
log(" β No credentials β sync-loop DISABLED, sleeping forever")
|
| 248 |
signal.pause()
|
| 249 |
return
|
| 250 |
|
|
|
|
|
|
|
| 251 |
def on_signal(sig, frame):
|
| 252 |
+
log(f" Signal {sig} received, final save ...")
|
| 253 |
try:
|
| 254 |
save_and_upload()
|
| 255 |
except Exception as e:
|
| 256 |
+
log(f" Final save error: {e}")
|
| 257 |
sys.exit(0)
|
| 258 |
|
| 259 |
signal.signal(signal.SIGTERM, on_signal)
|
| 260 |
signal.signal(signal.SIGINT, on_signal)
|
| 261 |
|
| 262 |
+
log(f" Waiting {60}s before first sync (let services start) ...")
|
| 263 |
time.sleep(60)
|
| 264 |
|
| 265 |
+
cycle = 0
|
| 266 |
while True:
|
| 267 |
+
cycle += 1
|
| 268 |
+
log(f"ββ Sync cycle #{cycle}")
|
| 269 |
try:
|
| 270 |
save_and_upload()
|
| 271 |
except Exception as e:
|
| 272 |
+
log(f" β Sync cycle #{cycle} error: {e}")
|
| 273 |
+
import traceback
|
| 274 |
+
traceback.print_exc(file=sys.stderr)
|
| 275 |
+
log(f" Sleeping {SYNC_INTERVAL}s until next cycle ...")
|
| 276 |
time.sleep(SYNC_INTERVAL)
|
| 277 |
|
| 278 |
|
| 279 |
def cmd_save():
|
| 280 |
"""One-time save + upload."""
|
| 281 |
+
log("ββ ONE-TIME SAVE")
|
| 282 |
if not HF_TOKEN or not HF_DATASET_REPO:
|
| 283 |
+
log(" β No credentials, cannot save")
|
| 284 |
return
|
| 285 |
save_and_upload()
|
| 286 |
|
| 287 |
|
| 288 |
if __name__ == "__main__":
|
| 289 |
cmd = sys.argv[1] if len(sys.argv) > 1 else "init"
|
| 290 |
+
log(f"Command: {cmd} (pid={os.getpid()})")
|
| 291 |
if cmd == "init":
|
| 292 |
cmd_init()
|
| 293 |
elif cmd == "sync-loop":
|