[feature request] AutoBackup save files

[DrParanoia]

Hi!

After a 7 hour gaming session (the save file was probably more like 30 hours, since the server is still running when players are not around), the save file got corrupted after I restarted the Docker container, and all progress was lost.

It would be cool if we could have rotating backups with a configurable interval and number of copies to keep.

[DrParanoia]

As a temporary solution, I "vibe-coded" a separate docker container to handle backups (but you need to make sure that SaveGames and /backup/backups directories have the correct permitions for the respectful containers to access them). I was a bit too lazy to automate directory permissions, so I would suggest to run the server first and let it create some save files in the StarRupture/Saved/SaveGames directory.

docker-compose.yml:

services:
  star-rupture:
    image: indifferentbroccoli/starrupture-server-docker
    restart: unless-stopped
    container_name: star-rupture
    stop_grace_period: 30s
    ports:
      - 7777:7777/udp
      - 7777:7777/tcp
      - 27015:27015/udp
    environment:
      # User Settings
      - PUID=1000
      - PGID=1000

      # Server Settings
      - SERVER_NAME=vault
      - DEFAULT_PORT=7777
      - QUERY_PORT=27015

      # Update Settings
      - UPDATE_ON_START=false
    volumes:
      - ./server-files:/home/steam/server-files
      
  star-rupture-backup:
    build: ./backup
    container_name: star-rupture-backup
    restart: unless-stopped
    depends_on:
      - star-rupture
    environment:
      # interval | inotify
      - MODE=inotify

      # interval mode settings
      - INTERVAL_SECONDS=900

      # inotify mode settings (wait for changes to “settle”)
      - DEBOUNCE_SECONDS=15

      # retention settings
      - KEEP_LAST=48
      # 0 disables size-based trimming; example: 20480 = 20 GiB (MiB units)
      - MAX_BACKUP_MB=2048

      # paths inside the container
      - SRC=/src
      - DEST=/backups
    volumes:
      # Mount ONLY the savegames folder read-only
      - ./server-files/StarRupture/Saved/SaveGames:/src:ro
      # Where backups will be stored on the host
      - ./backup/backups:/backups

backup/Dockerfile:

FROM alpine:3.20

RUN apk add --no-cache \
    bash tar coreutils findutils inotify-tools

# Copy script into the image (or you can still mount it if you prefer)
COPY backup.sh /usr/local/bin/backup.sh
RUN chmod +x /usr/local/bin/backup.sh

# Run as your host UID/GID (numeric is fine even if no user exists in /etc/passwd)
USER 1000:1000

ENTRYPOINT ["/usr/local/bin/backup.sh"]

backup/backup.sh:

#!/usr/bin/env bash
set -euo pipefail

MODE="${MODE:-interval}"
INTERVAL_SECONDS="${INTERVAL_SECONDS:-900}"
DEBOUNCE_SECONDS="${DEBOUNCE_SECONDS:-60}"

KEEP_LAST="${KEEP_LAST:-48}"

MAX_BACKUP_MB="${MAX_BACKUP_MB:-0}"
# Convert MiB -> bytes (1 MiB = 1024*1024 bytes)
MAX_BACKUP_BYTES=$(( MAX_BACKUP_MB * 1024 * 1024 ))

SRC="${SRC:-/src}"
DEST="${DEST:-/backups}"

mkdir -p "$DEST"

timestamp() {
  date -u +"%Y-%m-%dT%H-%M-%SZ"
}

backup_once() {
  local ts file tmp
  ts="$(timestamp)"
  file="$DEST/savegames-$ts.tar.gz"
  tmp="$file.tmp"

  echo "[backup] Creating $file from $SRC"

  # tar the directory contents (SRC is SaveGames itself)
  tar -C "$SRC" -czf "$tmp" .

  mv -f "$tmp" "$file"
  echo "[backup] Done: $file"

  rotate_backups
}

rotate_backups() {
  # 1) Rotate by count
  if [[ "$KEEP_LAST" -gt 0 ]]; then
    mapfile -t files < <(ls -1t "$DEST"/savegames-*.tar.gz 2>/dev/null || true)
    if (( ${#files[@]} > KEEP_LAST )); then
      for ((i=KEEP_LAST; i<${#files[@]}; i++)); do
        echo "[rotate] Removing (count) ${files[$i]}"
        rm -f -- "${files[$i]}"
      done
    fi
  fi

  # 2) Rotate by max total folder size (configured in MB)
  if [[ "$MAX_BACKUP_BYTES" -gt 0 ]]; then
    while true; do
      local size oldest
      size="$(du -sb "$DEST" | awk '{print $1}')"
      if [[ "$size" -le "$MAX_BACKUP_BYTES" ]]; then
        break
      fi

      # remove oldest
      oldest="$(ls -1t "$DEST"/savegames-*.tar.gz 2>/dev/null | tail -n 1 || true)"
      if [[ -z "$oldest" ]]; then
        break
      fi

      echo "[rotate] Removing (size) $oldest (DEST size=$size bytes, limit=${MAX_BACKUP_BYTES} bytes)"
      rm -f -- "$oldest"
    done
  fi
}

interval_loop() {
  while true; do
    backup_once
    sleep "$INTERVAL_SECONDS"
  done
}

inotify_loop() {
  echo "[inotify] Watching $SRC for changes (debounce ${DEBOUNCE_SECONDS}s)"
  while true; do
    # Wait for *any* change
    inotifywait -r -e create,modify,delete,move,close_write "$SRC" >/dev/null 2>&1 || true

    # Debounce: wait for quiet period
    sleep "$DEBOUNCE_SECONDS"
    while inotifywait -r -t 1 -e create,modify,delete,move,close_write "$SRC" >/dev/null 2>&1; do
      sleep "$DEBOUNCE_SECONDS"
    done

    backup_once
  done
}

case "$MODE" in
  interval) interval_loop ;;
  inotify)  inotify_loop ;;
  *)
    echo "Unknown MODE=$MODE (use interval|inotify)"
    exit 1
    ;;
esac