Sami
d7804d6b68
When DashCaddy is installed without `${DASHBOARD_DIR}:/app/dashboard` bind
mounted into the container (e.g. legacy DNS2 setup where Caddy serves from
/var/www/dashcaddy-status/), the self-updater's in-container copy to
/app/dashboard was a silent no-op — leaving the dashboard stale across
self-updates, which led to CSP-hash mismatches and a broken UI.
- self-updater: new hostFrontendDir option (default `/var/www/dashcaddy-status`
on Linux, overridable via DASHCADDY_HOST_FRONTEND_DIR). When set, defer the
frontend copy to the host-side updater by passing frontendStagingDir +
frontendTargetDir in trigger.json. Now also includes `js/` in the copy list.
- dashcaddy-update.sh: read those new trigger fields and sync the dashboard
files on the host. Auto-detect fallback for older self-updaters (no fields
in trigger.json) so a single release upgrade self-heals.
286 lines
11 KiB
Bash
286 lines
11 KiB
Bash
#!/usr/bin/env bash
|
|
# DashCaddy Host-Side Updater
|
|
# Triggered by systemd path unit when the container writes trigger.json.
|
|
# Reads the trigger, backs up current API, copies new files, rebuilds container.
|
|
# Writes result.json so the new container knows the outcome.
|
|
#
|
|
# This runs on the HOST, outside the container.
|
|
|
|
set -euo pipefail
|
|
|
|
readonly UPDATES_DIR="/opt/dashcaddy/updates"
|
|
readonly TRIGGER_FILE="${UPDATES_DIR}/trigger.json"
|
|
readonly RESULT_FILE="${UPDATES_DIR}/result.json"
|
|
readonly BACKUPS_DIR="${UPDATES_DIR}/backups"
|
|
readonly CONTAINER_NAME="dashcaddy-api"
|
|
readonly MAX_BACKUPS=3
|
|
readonly HEALTH_TIMEOUT=60
|
|
|
|
log() { echo "[dashcaddy-update] $(date '+%Y-%m-%d %H:%M:%S') $*"; }
|
|
|
|
write_result() {
|
|
local success="$1" version="$2" duration="$3"
|
|
shift 3
|
|
local error="${1:-}"
|
|
|
|
if [[ "$success" == "true" ]]; then
|
|
cat > "$RESULT_FILE" <<EOF
|
|
{
|
|
"success": true,
|
|
"version": "${version}",
|
|
"duration": ${duration},
|
|
"timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
|
|
}
|
|
EOF
|
|
else
|
|
cat > "$RESULT_FILE" <<EOF
|
|
{
|
|
"success": false,
|
|
"version": "${version}",
|
|
"duration": ${duration},
|
|
"error": "${error}",
|
|
"timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
|
|
}
|
|
EOF
|
|
fi
|
|
}
|
|
|
|
cleanup_old_backups() {
|
|
local count
|
|
count=$(find "$BACKUPS_DIR" -maxdepth 1 -mindepth 1 -type d 2>/dev/null | wc -l)
|
|
if (( count > MAX_BACKUPS )); then
|
|
log "Cleaning old backups (${count} > ${MAX_BACKUPS})"
|
|
find "$BACKUPS_DIR" -maxdepth 1 -mindepth 1 -type d -printf '%T+ %p\n' \
|
|
| sort | head -n $(( count - MAX_BACKUPS )) | cut -d' ' -f2- \
|
|
| xargs rm -rf
|
|
fi
|
|
}
|
|
|
|
wait_for_health() {
|
|
local port="${1:-3001}"
|
|
local timeout="$HEALTH_TIMEOUT"
|
|
local elapsed=0
|
|
|
|
log "Waiting for health check (timeout: ${timeout}s)..."
|
|
while (( elapsed < timeout )); do
|
|
if curl -fsSL --max-time 3 "http://localhost:${port}/health" &>/dev/null; then
|
|
log "Health check passed after ${elapsed}s"
|
|
return 0
|
|
fi
|
|
sleep 2
|
|
elapsed=$(( elapsed + 2 ))
|
|
done
|
|
|
|
log "Health check FAILED after ${timeout}s"
|
|
return 1
|
|
}
|
|
|
|
main() {
|
|
local start_time
|
|
start_time=$(date +%s)
|
|
|
|
# 1. Read trigger
|
|
if [[ ! -f "$TRIGGER_FILE" ]]; then
|
|
log "No trigger file found — nothing to do"
|
|
exit 0
|
|
fi
|
|
|
|
# Parse trigger.json (uses python3 which is available on all supported distros)
|
|
local action version from_version staging_dir api_source_dir commit
|
|
local frontend_staging_dir frontend_target_dir
|
|
action=$(python3 -c "import json; print(json.load(open('${TRIGGER_FILE}'))['action'])")
|
|
version=$(python3 -c "import json; print(json.load(open('${TRIGGER_FILE}'))['version'])")
|
|
from_version=$(python3 -c "import json; print(json.load(open('${TRIGGER_FILE}'))['fromVersion'])")
|
|
staging_dir=$(python3 -c "import json; print(json.load(open('${TRIGGER_FILE}'))['stagingDir'])")
|
|
api_source_dir=$(python3 -c "import json; print(json.load(open('${TRIGGER_FILE}'))['apiSourceDir'])")
|
|
commit=$(python3 -c "import json; print(json.load(open('${TRIGGER_FILE}')).get('commit') or '')")
|
|
# Frontend paths — optional (older self-updaters don't write these). When
|
|
# present, this script also syncs the dashboard files (Caddy serves them
|
|
# directly from the host; the container path /app/dashboard isn't mounted).
|
|
frontend_staging_dir=$(python3 -c "import json; print(json.load(open('${TRIGGER_FILE}')).get('frontendStagingDir') or '')")
|
|
frontend_target_dir=$(python3 -c "import json; print(json.load(open('${TRIGGER_FILE}')).get('frontendTargetDir') or '')")
|
|
|
|
log "=== ${action^^}: v${from_version} -> v${version} ==="
|
|
log "Staging: ${staging_dir}"
|
|
log "API source: ${api_source_dir}"
|
|
|
|
# Consume the trigger immediately so we don't re-process on failure
|
|
mv "$TRIGGER_FILE" "${TRIGGER_FILE}.processing"
|
|
|
|
# 2. Validate staging directory
|
|
if [[ ! -d "$staging_dir" ]]; then
|
|
log "ERROR: Staging directory not found: ${staging_dir}"
|
|
write_result "false" "$version" "$(( $(date +%s) - start_time ))" "Staging directory not found"
|
|
rm -f "${TRIGGER_FILE}.processing"
|
|
exit 1
|
|
fi
|
|
|
|
# 3. Backup current API files
|
|
local backup_dir="${BACKUPS_DIR}/${from_version}"
|
|
mkdir -p "$backup_dir"
|
|
log "Backing up current API files to ${backup_dir}"
|
|
|
|
# Copy all JS files, package.json, Dockerfile, and tracked subdirs
|
|
for item in "$api_source_dir"/*.js "$api_source_dir"/package.json "$api_source_dir"/package-lock.json "$api_source_dir"/Dockerfile "$api_source_dir"/openapi.yaml "$api_source_dir"/VERSION; do
|
|
[[ -f "$item" ]] && cp -f "$item" "$backup_dir/" 2>/dev/null || true
|
|
done
|
|
[[ -d "$api_source_dir/routes" ]] && cp -rf "$api_source_dir/routes" "$backup_dir/"
|
|
[[ -d "$api_source_dir/src" ]] && cp -rf "$api_source_dir/src" "$backup_dir/"
|
|
# VERSION (commit hash) was copied from api_source_dir above; preserve as-is
|
|
# so a rollback restores the original commit marker. The version *string* is
|
|
# already encoded in the backup dir name (${from_version}).
|
|
|
|
cleanup_old_backups
|
|
|
|
# 4. Copy new files from staging to API source
|
|
log "Deploying new API files..."
|
|
for item in "$staging_dir"/*.js "$staging_dir"/package.json "$staging_dir"/package-lock.json "$staging_dir"/Dockerfile "$staging_dir"/openapi.yaml "$staging_dir"/VERSION; do
|
|
[[ -f "$item" ]] && cp -f "$item" "$api_source_dir/" 2>/dev/null || true
|
|
done
|
|
if [[ -d "$staging_dir/routes" ]]; then
|
|
rm -rf "$api_source_dir/routes"
|
|
cp -rf "$staging_dir/routes" "$api_source_dir/routes"
|
|
fi
|
|
if [[ -d "$staging_dir/src" ]]; then
|
|
rm -rf "$api_source_dir/src"
|
|
cp -rf "$staging_dir/src" "$api_source_dir/src"
|
|
fi
|
|
|
|
# Belt-and-suspenders: always write the commit from trigger.json to VERSION,
|
|
# even if the tarball didn't include one. The container's self-updater uses
|
|
# this to detect the "same version, different commit" case.
|
|
if [[ -n "$commit" ]]; then
|
|
echo "$commit" > "$api_source_dir/VERSION"
|
|
fi
|
|
|
|
# 4b. Sync frontend. Caddy serves the dashboard directly from the host
|
|
# filesystem; the container-side copy in older self-updater.js builds wrote
|
|
# to /app/dashboard which isn't always mounted, so the real sync happens
|
|
# here. Trigger fields take precedence; if absent (older self-updater),
|
|
# fall back to: staging dir's sibling status/ + first existing known target.
|
|
if [[ -z "$frontend_staging_dir" ]]; then
|
|
parent_staging=$(dirname "$staging_dir")
|
|
[[ -d "$parent_staging/status" ]] && frontend_staging_dir="$parent_staging/status"
|
|
fi
|
|
if [[ -z "$frontend_target_dir" ]]; then
|
|
for candidate in /var/www/dashcaddy-status /etc/dashcaddy/sites/status; do
|
|
[[ -d "$candidate" ]] && frontend_target_dir="$candidate" && break
|
|
done
|
|
fi
|
|
if [[ -n "$frontend_staging_dir" && -n "$frontend_target_dir" && -d "$frontend_staging_dir" ]]; then
|
|
log "Syncing frontend: $frontend_staging_dir -> $frontend_target_dir"
|
|
mkdir -p "$frontend_target_dir"
|
|
[[ -f "$frontend_staging_dir/index.html" ]] && cp -f "$frontend_staging_dir/index.html" "$frontend_target_dir/index.html"
|
|
[[ -f "$frontend_staging_dir/sw.js" ]] && cp -f "$frontend_staging_dir/sw.js" "$frontend_target_dir/sw.js"
|
|
for sub in dist css vendor js; do
|
|
if [[ -d "$frontend_staging_dir/$sub" ]]; then
|
|
mkdir -p "$frontend_target_dir/$sub"
|
|
cp -rf "$frontend_staging_dir/$sub"/* "$frontend_target_dir/$sub/" 2>/dev/null || true
|
|
fi
|
|
done
|
|
# assets/ is mounted into the container; usually already in sync via bind
|
|
# mount, but if a release ships new assets we want them on disk too.
|
|
if [[ -d "$frontend_staging_dir/assets" ]]; then
|
|
mkdir -p "$frontend_target_dir/assets"
|
|
cp -rf "$frontend_staging_dir/assets"/* "$frontend_target_dir/assets/" 2>/dev/null || true
|
|
fi
|
|
fi
|
|
|
|
# 5. Rebuild container
|
|
log "Rebuilding container..."
|
|
cd "$api_source_dir"
|
|
|
|
local build_ok=false
|
|
if docker compose build --quiet 2>&1; then
|
|
build_ok=true
|
|
elif docker-compose build --quiet 2>&1; then
|
|
build_ok=true
|
|
fi
|
|
|
|
if [[ "$build_ok" != "true" ]]; then
|
|
log "ERROR: Docker build failed — rolling back"
|
|
|
|
# Restore backup
|
|
for item in "$backup_dir"/*.js "$backup_dir"/package.json "$backup_dir"/package-lock.json "$backup_dir"/Dockerfile "$backup_dir"/openapi.yaml "$backup_dir"/VERSION; do
|
|
[[ -f "$item" ]] && cp -f "$item" "$api_source_dir/" 2>/dev/null || true
|
|
done
|
|
if [[ -d "$backup_dir/routes" ]]; then
|
|
rm -rf "$api_source_dir/routes"
|
|
cp -rf "$backup_dir/routes" "$api_source_dir/routes"
|
|
fi
|
|
if [[ -d "$backup_dir/src" ]]; then
|
|
rm -rf "$api_source_dir/src"
|
|
cp -rf "$backup_dir/src" "$api_source_dir/src"
|
|
fi
|
|
|
|
write_result "false" "$version" "$(( $(date +%s) - start_time ))" "Docker build failed"
|
|
rm -f "${TRIGGER_FILE}.processing"
|
|
exit 1
|
|
fi
|
|
|
|
# 6. Restart container
|
|
log "Restarting container..."
|
|
if docker compose up -d 2>&1 || docker-compose up -d 2>&1; then
|
|
log "Container restarted"
|
|
else
|
|
log "ERROR: Container restart failed — rolling back"
|
|
|
|
# Restore backup
|
|
for item in "$backup_dir"/*.js "$backup_dir"/package.json "$backup_dir"/package-lock.json "$backup_dir"/Dockerfile "$backup_dir"/openapi.yaml "$backup_dir"/VERSION; do
|
|
[[ -f "$item" ]] && cp -f "$item" "$api_source_dir/" 2>/dev/null || true
|
|
done
|
|
if [[ -d "$backup_dir/routes" ]]; then
|
|
rm -rf "$api_source_dir/routes"
|
|
cp -rf "$backup_dir/routes" "$api_source_dir/routes"
|
|
fi
|
|
if [[ -d "$backup_dir/src" ]]; then
|
|
rm -rf "$api_source_dir/src"
|
|
cp -rf "$backup_dir/src" "$api_source_dir/src"
|
|
fi
|
|
|
|
docker compose build --quiet 2>&1 || docker-compose build --quiet 2>&1 || true
|
|
docker compose up -d 2>&1 || docker-compose up -d 2>&1 || true
|
|
|
|
write_result "false" "$version" "$(( $(date +%s) - start_time ))" "Container restart failed"
|
|
rm -f "${TRIGGER_FILE}.processing"
|
|
exit 1
|
|
fi
|
|
|
|
# 7. Health check
|
|
if wait_for_health; then
|
|
local duration=$(( $(date +%s) - start_time ))
|
|
log "=== Update successful: v${version} in ${duration}s ==="
|
|
write_result "true" "$version" "$duration"
|
|
else
|
|
local duration=$(( $(date +%s) - start_time ))
|
|
log "ERROR: Health check failed after update — rolling back"
|
|
|
|
# Restore backup
|
|
for item in "$backup_dir"/*.js "$backup_dir"/package.json "$backup_dir"/package-lock.json "$backup_dir"/Dockerfile "$backup_dir"/openapi.yaml "$backup_dir"/VERSION; do
|
|
[[ -f "$item" ]] && cp -f "$item" "$api_source_dir/" 2>/dev/null || true
|
|
done
|
|
if [[ -d "$backup_dir/routes" ]]; then
|
|
rm -rf "$api_source_dir/routes"
|
|
cp -rf "$backup_dir/routes" "$api_source_dir/routes"
|
|
fi
|
|
if [[ -d "$backup_dir/src" ]]; then
|
|
rm -rf "$api_source_dir/src"
|
|
cp -rf "$backup_dir/src" "$api_source_dir/src"
|
|
fi
|
|
|
|
docker compose build --quiet 2>&1 || docker-compose build --quiet 2>&1 || true
|
|
docker compose up -d 2>&1 || docker-compose up -d 2>&1 || true
|
|
wait_for_health || log "WARNING: Rollback health check also failed"
|
|
|
|
write_result "false" "$version" "$duration" "Health check failed after update"
|
|
fi
|
|
|
|
# 8. Cleanup
|
|
rm -f "${TRIGGER_FILE}.processing"
|
|
rm -rf "${UPDATES_DIR}/staging" 2>/dev/null || true
|
|
|
|
log "=== Update process complete ==="
|
|
}
|
|
|
|
main "$@"
|