habppyar commited on
Commit
110b7ec
·
verified ·
1 Parent(s): a566b22

Update start.sh

Browse files
Files changed (1) hide show
  1. start.sh +104 -90
start.sh CHANGED
@@ -4,136 +4,150 @@ set -euo pipefail
4
  PORT="${PORT:-7860}"
5
  HOST="${HOST:-0.0.0.0}"
6
 
7
- # Where HF bucket is mounted (Space Settings -> Storage Buckets)
8
- PERSIST_MOUNT="${PERSIST_MOUNT:-/data}"
9
- BACKUP_DIR="${PERSIST_MOUNT}/opencode-backup"
10
- BACKUP_INTERVAL_SECONDS="${BACKUP_INTERVAL_SECONDS:-60}"
11
 
12
- HOME_DIR="${HOME:-/home/node}"
13
- export HOME="${HOME_DIR}"
 
 
 
14
 
15
- # OpenCode locations (using default XDG under HOME)
 
 
 
 
 
 
 
 
 
16
  LOCAL_CONFIG_DIR="${HOME}/.config/opencode"
17
  LOCAL_DATA_DIR="${HOME}/.local/share/opencode"
18
  LOCAL_DB="${LOCAL_DATA_DIR}/opencode.db"
19
  LOCAL_AUTH="${LOCAL_DATA_DIR}/auth.json"
 
 
 
20
 
21
- REMOTE_DB="${BACKUP_DIR}/opencode.db"
22
- REMOTE_AUTH="${BACKUP_DIR}/auth.json"
 
 
23
 
24
- # ---- 0) Require Basic Auth password (public Space) ----
25
- if [[ -z "${OPENCODE_SERVER_PASSWORD:-}" ]]; then
26
- echo "[FATAL] OPENCODE_SERVER_PASSWORD is not set. Refusing to start."
27
- exit 1
28
- fi
29
 
30
- mkdir -p "${HOME}/.config" "${HOME}/.local/share"
31
- mkdir -p "${LOCAL_CONFIG_DIR}" "${LOCAL_DATA_DIR}"
 
 
 
 
 
 
32
 
33
- # ---- 1) Diagnose /data mount + permissions ----
34
  echo "===== Startup diagnostics ====="
35
- echo "[INFO] Running as: $(id || true)"
36
  echo "[INFO] HOME=${HOME}"
37
- echo "[INFO] PERSIST_MOUNT=${PERSIST_MOUNT}"
38
- echo "[INFO] ls -ld ${PERSIST_MOUNT}:"
39
- (ls -ld "${PERSIST_MOUNT}" || true)
40
- echo "[INFO] /proc/mounts entry for ${PERSIST_MOUNT}:"
41
- grep -E "[[:space:]]${PERSIST_MOUNT}[[:space:]]" /proc/mounts || echo "[INFO] (no mount entry found)"
42
-
43
- IS_MOUNTED="false"
44
- if grep -qE "[[:space:]]${PERSIST_MOUNT}[[:space:]]" /proc/mounts; then
45
- IS_MOUNTED="true"
 
 
 
 
46
  fi
47
 
48
- IS_WRITABLE="false"
49
- if [[ -d "${PERSIST_MOUNT}" ]]; then
50
- if ( mkdir -p "${PERSIST_MOUNT}/.rwtest" && echo ok > "${PERSIST_MOUNT}/.rwtest/test.txt" ) 2>/dev/null; then
51
- IS_WRITABLE="true"
52
- rm -rf "${PERSIST_MOUNT}/.rwtest" || true
53
- fi
54
- fi
55
 
56
- echo "[INFO] Persist mounted? ${IS_MOUNTED}"
57
- echo "[INFO] Persist writable? ${IS_WRITABLE}"
 
 
 
 
58
 
59
- PERSIST_ENABLED="false"
60
- if [[ "${IS_MOUNTED}" == "true" && "${IS_WRITABLE}" == "true" ]]; then
61
- PERSIST_ENABLED="true"
62
- mkdir -p "${BACKUP_DIR}"
63
- echo "[INFO] Persistence ENABLED: using ${BACKUP_DIR}"
64
- else
65
- echo "[WARN] Persistence DISABLED: bucket not mounted or not writable."
66
- echo "[WARN] (UI may show mounted, but container doesn't see it. Mountpoint path + perms are the common causes.)"
67
- fi
68
 
69
- # ---- 2) Persist config safely (config is small JSON; OK to store on mounted volume) ----
70
- # If persistence enabled, keep config on /data via symlink to survive restarts.
71
- if [[ "${PERSIST_ENABLED}" == "true" ]]; then
72
- mkdir -p "${BACKUP_DIR}/config"
73
- # If config dir isn't already a symlink, migrate then link
74
- if [[ ! -L "${LOCAL_CONFIG_DIR}" ]]; then
75
- if [[ -d "${LOCAL_CONFIG_DIR}" && "$(ls -A "${LOCAL_CONFIG_DIR}" 2>/dev/null | wc -l)" -gt 0 ]]; then
76
- rsync -a "${LOCAL_CONFIG_DIR}/" "${BACKUP_DIR}/config/" || true
77
- rm -rf "${LOCAL_CONFIG_DIR}"
78
- else
79
- rm -rf "${LOCAL_CONFIG_DIR}" || true
80
- fi
81
- ln -s "${BACKUP_DIR}/config" "${LOCAL_CONFIG_DIR}"
82
  fi
 
 
83
  fi
84
 
85
- # ---- 3) Write config from env (optional) ----
86
- CONFIG_PATH="${LOCAL_CONFIG_DIR}/opencode.json"
87
  if [[ -n "${OPENCODE_CONFIG_CONTENT:-}" ]]; then
88
- echo "[INFO] Writing opencode config from OPENCODE_CONFIG_CONTENT -> ${CONFIG_PATH}"
89
- printf "%s" "${OPENCODE_CONFIG_CONTENT}" > "${CONFIG_PATH}"
90
- elif [[ ! -f "${CONFIG_PATH}" ]]; then
91
- echo "[INFO] No opencode.json found. Copying example template."
92
- cp -f "${HOME}/opencode.json.example" "${CONFIG_PATH}"
93
  fi
94
 
95
- # ---- 4) Restore DB/auth from /data backup (if available) ----
96
- if [[ "${PERSIST_ENABLED}" == "true" ]]; then
97
- if [[ -f "${REMOTE_DB}" && ! -f "${LOCAL_DB}" ]]; then
98
- echo "[INFO] Restoring SQLite DB from ${REMOTE_DB} -> ${LOCAL_DB}"
99
- cp -f "${REMOTE_DB}" "${LOCAL_DB}" || true
100
- fi
101
-
102
- if [[ -f "${REMOTE_AUTH}" && ! -f "${LOCAL_AUTH}" ]]; then
103
- echo "[INFO] Restoring auth.json from ${REMOTE_AUTH} -> ${LOCAL_AUTH}"
104
- cp -f "${REMOTE_AUTH}" "${LOCAL_AUTH}" || true
105
- fi
106
- fi
107
-
108
- # ---- 5) Background backup loop (SQLite .backup is safer than raw cp) ----
109
  backup_loop() {
110
- echo "[INFO] Backup loop started. interval=${BACKUP_INTERVAL_SECONDS}s"
111
  while true; do
112
- if [[ "${PERSIST_ENABLED}" == "true" ]]; then
113
- # Backup DB (when exists)
114
  if [[ -f "${LOCAL_DB}" ]]; then
115
- # sqlite3 backup creates a consistent snapshot
116
- sqlite3 "${LOCAL_DB}" ".backup '${REMOTE_DB}'" || true
 
 
 
 
 
 
 
 
 
 
 
 
 
117
  fi
118
 
119
- # Backup auth.json (small file)
120
- if [[ -f "${LOCAL_AUTH}" ]]; then
121
- cp -f "${LOCAL_AUTH}" "${REMOTE_AUTH}" || true
 
 
122
  fi
123
  fi
124
  sleep "${BACKUP_INTERVAL_SECONDS}"
125
  done
126
  }
127
 
128
- # run backup loop in background
129
  backup_loop &
130
 
131
- # ---- 6) Keep generic caches off /data ----
132
  export XDG_CACHE_HOME="/tmp/.cache"
133
  export TMPDIR="/tmp"
134
  mkdir -p "${XDG_CACHE_HOME}" "${TMPDIR}"
135
 
136
- # ---- 7) Start OpenCode Web ----
137
  echo "[INFO] Starting: opencode web --hostname ${HOST} --port ${PORT}"
138
  exec opencode web \
139
  --hostname "${HOST}" \
 
4
  PORT="${PORT:-7860}"
5
  HOST="${HOST:-0.0.0.0}"
6
 
7
+ export HOME="${HOME:-/home/node}"
 
 
 
8
 
9
+ # ---- Security: require Basic Auth password ----
10
+ if [[ -z "${OPENCODE_SERVER_PASSWORD:-}" ]]; then
11
+ echo "[FATAL] OPENCODE_SERVER_PASSWORD is not set. Refusing to start."
12
+ exit 1
13
+ fi
14
 
15
+ # ---- Persistence config ----
16
+ BACKUP_INTERVAL_SECONDS="${BACKUP_INTERVAL_SECONDS:-120}"
17
+ BUCKET_PREFIX="${BUCKET_PREFIX:-opencode-backup}"
18
+ BACKUP_AUTH_JSON="${BACKUP_AUTH_JSON:-0}"
19
+
20
+ bucket_ready() {
21
+ [[ -n "${HF_TOKEN:-}" && -n "${HF_BUCKET_ID:-}" ]]
22
+ }
23
+
24
+ # OpenCode paths (what opencode actually uses)
25
  LOCAL_CONFIG_DIR="${HOME}/.config/opencode"
26
  LOCAL_DATA_DIR="${HOME}/.local/share/opencode"
27
  LOCAL_DB="${LOCAL_DATA_DIR}/opencode.db"
28
  LOCAL_AUTH="${LOCAL_DATA_DIR}/auth.json"
29
+ LOCAL_OPENCODE_JSON="${LOCAL_CONFIG_DIR}/opencode.json"
30
+
31
+ mkdir -p "${LOCAL_CONFIG_DIR}" "${LOCAL_DATA_DIR}"
32
 
33
+ REMOTE_BASE="hf://buckets/${HF_BUCKET_ID}/${BUCKET_PREFIX}"
34
+ REMOTE_DB="${REMOTE_BASE}/opencode.db"
35
+ REMOTE_AUTH="${REMOTE_BASE}/auth.json"
36
+ REMOTE_OPENCODE_JSON="${REMOTE_BASE}/opencode.json"
37
 
38
+ hf_cp() {
39
+ # usage: hf_cp <src> <dst>
40
+ # explicit token to avoid relying on local login state
41
+ hf buckets cp --token "${HF_TOKEN}" "$1" "$2"
42
+ }
43
 
44
+ hf_cp_maybe() {
45
+ # best-effort copy (do not crash on missing remote file)
46
+ set +e
47
+ hf_cp "$1" "$2"
48
+ local code=$?
49
+ set -e
50
+ return $code
51
+ }
52
 
 
53
  echo "===== Startup diagnostics ====="
54
+ echo "[INFO] uid/gid: $(id || true)"
55
  echo "[INFO] HOME=${HOME}"
56
+ echo "[INFO] HF_BUCKET_ID=${HF_BUCKET_ID:-<empty>}"
57
+ echo "[INFO] bucket_ready? $(bucket_ready && echo yes || echo no)"
58
+ echo "[INFO] BACKUP_INTERVAL_SECONDS=${BACKUP_INTERVAL_SECONDS}"
59
+ echo "[INFO] BUCKET_PREFIX=${BUCKET_PREFIX}"
60
+ echo "[INFO] BACKUP_AUTH_JSON=${BACKUP_AUTH_JSON}"
61
+ echo "[INFO] Remote base: ${REMOTE_BASE}"
62
+
63
+ # Optional: print /data mount info for debugging (not required for this persistence strategy)
64
+ if [[ -d "/data" ]]; then
65
+ echo "[INFO] /data listing:"
66
+ (ls -ld /data || true)
67
+ echo "[INFO] /proc/mounts entry for /data:"
68
+ (grep -E "[[:space:]]/data[[:space:]]" /proc/mounts || true)
69
  fi
70
 
71
+ # ---- 1) Restore from bucket (if possible) ----
72
+ if bucket_ready; then
73
+ echo "[INFO] Restoring from bucket (best effort)..."
 
 
 
 
74
 
75
+ # Restore opencode.json if local missing
76
+ if [[ ! -f "${LOCAL_OPENCODE_JSON}" ]]; then
77
+ hf_cp_maybe "${REMOTE_OPENCODE_JSON}" "${LOCAL_OPENCODE_JSON}" \
78
+ && echo "[INFO] Restored opencode.json" \
79
+ || echo "[INFO] No remote opencode.json (or no access)."
80
+ fi
81
 
82
+ # Restore DB if local missing
83
+ if [[ ! -f "${LOCAL_DB}" ]]; then
84
+ hf_cp_maybe "${REMOTE_DB}" "${LOCAL_DB}" \
85
+ && echo "[INFO] Restored opencode.db" \
86
+ || echo "[INFO] No remote opencode.db (or no access)."
87
+ fi
 
 
 
88
 
89
+ # Restore auth.json only if you explicitly allow it
90
+ if [[ "${BACKUP_AUTH_JSON}" == "1" && ! -f "${LOCAL_AUTH}" ]]; then
91
+ hf_cp_maybe "${REMOTE_AUTH}" "${LOCAL_AUTH}" \
92
+ && echo "[INFO] Restored auth.json" \
93
+ || echo "[INFO] No remote auth.json (or no access)."
 
 
 
 
 
 
 
 
94
  fi
95
+ else
96
+ echo "[WARN] Persistence disabled (HF_TOKEN or HF_BUCKET_ID missing)."
97
  fi
98
 
99
+ # ---- 2) Ensure config exists (env injection > restored > example) ----
 
100
  if [[ -n "${OPENCODE_CONFIG_CONTENT:-}" ]]; then
101
+ echo "[INFO] Writing opencode.json from OPENCODE_CONFIG_CONTENT"
102
+ printf "%s" "${OPENCODE_CONFIG_CONTENT}" > "${LOCAL_OPENCODE_JSON}"
103
+ elif [[ ! -f "${LOCAL_OPENCODE_JSON}" ]]; then
104
+ echo "[INFO] No opencode.json found; copying example."
105
+ cp -f "${HOME}/opencode.json.example" "${LOCAL_OPENCODE_JSON}"
106
  fi
107
 
108
+ # ---- 3) Backup loop (DB + config; auth optional) ----
 
 
 
 
 
 
 
 
 
 
 
 
 
109
  backup_loop() {
110
+ echo "[INFO] Backup loop started (interval=${BACKUP_INTERVAL_SECONDS}s)."
111
  while true; do
112
+ if bucket_ready; then
113
+ # DB consistent snapshot
114
  if [[ -f "${LOCAL_DB}" ]]; then
115
+ TMP_DB="/tmp/opencode.db.backup"
116
+ if sqlite3 "${LOCAL_DB}" ".backup '${TMP_DB}'" >/dev/null 2>&1; then
117
+ hf_cp_maybe "${TMP_DB}" "${REMOTE_DB}" \
118
+ && echo "[INFO] Uploaded DB -> ${REMOTE_DB}" \
119
+ || echo "[WARN] Failed to upload DB."
120
+ else
121
+ echo "[WARN] sqlite3 .backup failed."
122
+ fi
123
+ fi
124
+
125
+ # Config is small; safe to upload
126
+ if [[ -f "${LOCAL_OPENCODE_JSON}" ]]; then
127
+ hf_cp_maybe "${LOCAL_OPENCODE_JSON}" "${REMOTE_OPENCODE_JSON}" \
128
+ && echo "[INFO] Uploaded opencode.json -> ${REMOTE_OPENCODE_JSON}" \
129
+ || echo "[WARN] Failed to upload opencode.json."
130
  fi
131
 
132
+ # auth.json optional (contains tokens/keys; only do if you accept the risk)
133
+ if [[ "${BACKUP_AUTH_JSON}" == "1" && -f "${LOCAL_AUTH}" ]]; then
134
+ hf_cp_maybe "${LOCAL_AUTH}" "${REMOTE_AUTH}" \
135
+ && echo "[INFO] Uploaded auth.json -> ${REMOTE_AUTH}" \
136
+ || echo "[WARN] Failed to upload auth.json."
137
  fi
138
  fi
139
  sleep "${BACKUP_INTERVAL_SECONDS}"
140
  done
141
  }
142
 
 
143
  backup_loop &
144
 
145
+ # ---- 4) Keep caches on /tmp ----
146
  export XDG_CACHE_HOME="/tmp/.cache"
147
  export TMPDIR="/tmp"
148
  mkdir -p "${XDG_CACHE_HOME}" "${TMPDIR}"
149
 
150
+ # ---- 5) Start OpenCode Web ----
151
  echo "[INFO] Starting: opencode web --hostname ${HOST} --port ${PORT}"
152
  exec opencode web \
153
  --hostname "${HOST}" \