,backup-homelab

#!/usr/bin/env bash

# Backup process:
# 1. automate the individual backup process of all services
# 2. rsync to a central dir
# 3. encrypt that
# 4. backup to hardware (usb, etc.)
# 5. backup to offsite (backblaze b2 bucket)

set -e

# services
services="$HOME/services"
NTFY_ENDPOINT="https://ntfy.local.ejsadiarin.com/backups"

# traefik
traefik="$HOME/services/traefik"
# authentik
authentik="$HOME/services/authentik"
# immich
immich="$HOME/services/immich"
# portainer
portainer="$HOME/services/portainer"
# gitea
gitea="$HOME/services/gitea"
# ntfy
ntfy="$HOME/services/ntfy"
# uptime kuma
uptime_kuma="$HOME/services/uptime_kuma"
# glance
glance="$HOME/services/glance"
# beszel
beszel="$HOME/services/beszel"

# essentials
restic="$HOME/services/restic"
vault="$HOME/vault"

#  TODO: make one for vaultwarden
dirs=(
    "$traefik"
    "$authentik"
    "$portainer"
    "$gitea"
    "$ntfy"
    "$glance"
    "$beszel"
    "$uptime_kuma"
    "$immich"
    "$restic"
    "$vault"
)

mkdir -p "$HOME/backups"
backups="$HOME/backups"

assert_rsync() {
    local dir=$1
    shift
    "$@" || {
        err=$("$@" 2>&1)
        echo "Error on rsync [$dir]: $err"
        return 1
    }
}

dry_run() {
    for dir in "${dirs[@]}"; do
        echo "Backing up $dir"
        bn=$(basename "$dir")
        echo "Current bn: $bn"
        bk_dir="$backups/$bn" # example: ~/backups/traefik
        echo "Creating if not exists: $bk_dir"

        case "$dir" in
        "$traefik" | "$uptime_kuma" | "$glance" | "$beszel")
            echo "current dir: $dir/ with bk_dir: $bk_dir/"
            sudo rsync -azvh --delete --progress --dry-run "$dir"/ "$bk_dir"/
            ;;

        "$portainer")
            echo "current dir: $dir/ with bk_dir: $bk_dir/"
            sudo rsync -azvh --delete --progress --dry-run "$dir"/ "$bk_dir"/
            ;;

        "$authentik")
            echo "current dir: $dir/ with bk_dir: $bk_dir/"
            sudo rsync -azvh --delete --progress --dry-run "$dir"/ "$bk_dir"/
            echo "will run: docker exec -i authentik-postgres /usr/local/bin/pg_dump --username authentik-pg-admin authentik-pg-db >""$bk_dir""/postgres-backup.sql"
            ;;

        "$ntfy")
            ntfy_etc="$dir/etc"
            ntfy_cache="$dir/cache"
            echo "backing up: files (maxdepth 1) on bk_dir: $bk_dir"
            find "$dir" -maxdepth 1 -type f -print0 | xargs -0 -I {} rsync -azvh --delete --progress --dry-run {} "$bk_dir"
            echo "backing up: $ntfy_etc with bk_dir: $bk_dir"
            sudo rsync -azvh --delete --progress --dry-run "$dir"/etc "$bk_dir"
            echo "backing up: $ntfy_cache with bk_dir: $bk_dir"
            sudo rsync -azvh --delete --progress --dry-run "$dir"/cache "$bk_dir"
            ;;

        "$gitea")
            echo "backing up: files (maxdepth 1) on bk_dir: $bk_dir"
            find "$dir" -maxdepth 1 -type f -print0 | xargs -0 -I {} rsync -azvh --delete --progress --dry-run {} "$bk_dir"
            echo "backing up: dumps to bk_dir: $bk_dir/dumps/"
            num_dumps=$(ls "$bk_dir"/dumps/ -A | wc -l)
            if [[ "$num_dumps" -gt 3 ]]; then
                oldest_zip=$(ls -Art "$bk_dir"/dumps/ | head -n 1)
                echo "Will remove oldest dump file: $oldest_zip"
            fi
            ;;

        "$immich")
            immich_library="$dir/library/library"
            immich_profile="$dir/library/profile"
            immich_backups="$dir/library/backups"
            immich_upload="$dir/library/upload"
            echo "backing up: files (maxdepth 1) on bk_dir: $bk_dir"
            find "$dir" -maxdepth 1 -type f -print0 | xargs -0 -I {} rsync -azvh --delete --progress --dry-run {} "$bk_dir"
            echo "backing up: $immich_library with bk_dir: $bk_dir"
            sudo rsync -azvh --delete --progress --dry-run "$dir"/library/library "$bk_dir"
            echo "backing up: $immich_profile with bk_dir: $bk_dir"
            sudo rsync -azvh --delete --progress --dry-run "$dir"/library/profile "$bk_dir"
            echo "backing up: $immich_backups with bk_dir: $bk_dir"
            sudo rsync -azvh --delete --progress --dry-run "$dir"/library/backups "$bk_dir"
            echo "backing up: $immich_upload with bk_dir: $bk_dir"
            sudo rsync -azvh --delete --progress --dry-run "$dir"/library/upload "$bk_dir"
            ;;

        *)
            echo "current dir: $dir/ with bk_dir: $bk_dir/"
            ;;
        esac
    done
}

local_backup() {
    # onsite backups (hardware)
    # TODO: refactor to use basename and not dir, so all inside services are backed up automatically just by adding new service
    for dir in "${dirs[@]}"; do
        bn=$(basename "$dir")
        bk_dir="$backups/$bn" # example: ~/backups/traefik
        mkdir -p "$bk_dir"
        case "$dir" in
        "$traefik" | "$uptime_kuma" | "$glance")
            # traefik - backup everything
            # src: ~/services/traefik/
            # dest: ~/backups/traefik/
            sudo rsync -azvh --delete --progress "$dir"/ "$bk_dir"/ || {
                echo "[x] Error on rsync [$dir]"
                continue
            }
            ;;
        "$portainer")
            # portainer - backup everything
            # dest: ~/backups/portainer
            {
                sudo rsync -azvh --delete --progress "$dir"/ "$bk_dir"/
                sudo chown -R "$(whoami)":"$(whoami)" "$bk_dir"/data
            } || {
                echo "Error on rsync [$dir]"
                continue
            }
            ;;
        "$authentik")
            # dest: ~/backups/authentik/postgres-backup.sql
            sudo rsync -azvh --delete --progress "$dir"/ "$bk_dir"/ || {
                echo "[x] Error on rsync [$dir]"
                continue
            }
            {
                timestamp=$(date +%s%3N)
                docker exec -i authentik-postgres /usr/local/bin/pg_dump --username authentik-pg-admin authentik-pg-db >"$bk_dir"/postgres-backup-"$timestamp".sql
            } || {
                echo "Error on docker pg_dump [$dir]: $err"
                continue
            }
            ;;
        "$ntfy")
            # ntfy - backup everything
            echo "Backing up NTFY..."
            {
                # docker-compose, env files, etc.
                find "$dir" -maxdepth 1 -type f -print0 | xargs -0 -I {} rsync -azvh --delete --progress {} "$bk_dir"
                # dest (bk_dir): ~/backups/ntfy
                sudo rsync -azvh --delete --progress "$dir"/etc "$bk_dir"
                sudo rsync -azvh --delete --progress "$dir"/cache "$bk_dir"
            } || {
                echo "Error on rsync [$dir]"
                continue
            }
            ;;
        "$gitea")
            # gitea - backup everything via gitea dump inside container (outputs tar.gz file)
            echo "Running gitea dump command..."
            mkdir -p "$bk_dir/dumps"
            {

                find "$dir" -maxdepth 1 -type f -print0 | xargs -0 -I {} rsync -azvh --delete --progress {} "$bk_dir" # docker-compose, env files, etc.
                docker exec -u git -it -w /tmp "$(docker ps -qf 'name=^gitea-server$')" bash -c '/usr/local/bin/gitea dump -c /data/gitea/conf/app.ini'
                latest_zip=$(docker exec -u git "$(docker ps -qf 'name=^gitea-server$')" ls /tmp -Art | tail -n 1 | tr -d '\r')
                echo "Latest dump file: $latest_zip"
                docker cp "$(docker ps -qf 'name=^gitea-server$')":/tmp/"$latest_zip" "$bk_dir/dumps/" || {
                    echo "Error: Failed to copy $latest_zip from container."
                    continue
                }
                # after copy, delete the oldest one (retains 3 latest copies)
                num_dumps=$(ls "$bk_dir"/dumps/ -A | wc -l)
                if [[ "$num_dumps" -gt 3 ]]; then
                    oldest_zip=$(ls -Art "$bk_dir"/dumps/ | head -n 1)
                    echo "Removing oldest dump file: $oldest_zip"
                    sudo rm -f "$oldest_zip" || {
                        echo "Error: Failed to remove $oldest_zip."
                        continue
                    }
                fi
                echo "Gitea dump completed."
            } || {
                echo "Error on backing up via gitea dump [$dir]"
                continue
            }
            ;;
        "$immich")
            # immich - backup specific dirs only
            echo "Backing up immich [$dir]..."
            {
                timestamp=$(date +%s%3n)
                sudo docker exec -t immich_postgres pg_dumpall --clean --if-exists --username=postgres | gzip | sudo tee "$dir"/library/backups/immich-db-backup-"$timestamp".sql.gz >/dev/null
                # docker-compose, env files, etc.
                find "$dir" -maxdepth 1 -type f -print0 | xargs -0 -I {} rsync -azvh --delete --progress {} "$bk_dir"
                # libs
                sudo rsync -azvh --delete --progress "$dir"/library/library "$bk_dir"
                # profile
                sudo rsync -azvh --delete --progress "$dir"/library/profile "$bk_dir"
                # database
                sudo rsync -azvh --delete --progress "$dir"/library/backups "$bk_dir"
                # imgs/vids
                sudo rsync -azvh --delete --progress "$dir"/library/upload "$bk_dir"
                echo "Successfully backed up immich"
            } || {
                echo "Error on rsync [$dir]"
                continue
            }
            ;;
        *)
            echo "Backing up $dir..."
            sudo rsync -azvh --delete --progress "$dir"/ "$bk_dir"/ || {
                echo "Error on rsync [$dir]"
                continue
            }
            ;;
        esac
    done
}

# offsite backup via restic
remote_backup() {
    restic_env="$HOME/services/restic/restic-env"
    if [[ -e $restic_env ]]; then
        echo "Sourcing $restic_env"
        source "$restic_env"
    else
        echo "The required restic-env file doesn't exist. Aborting..."
        # TODO: maybe help setup restic if don't have this
        exit 1
    fi
    # backup whole $HOME/backups
    restic backup "$backups" || {
        echo "Restic failed"
        return 1
    }
    restic check || {
        echo "Restic integrity check failed"
        return 1
    }
}

# flags
if [[ "$#" -eq 0 ]]; then
    echo "Running this script by itself (without flags) will run --all/-a by default."
    read -rp "Do you want to continue? [y/n] " yn
    case $yn in
    [Yy]*)
        echo "initializing full backup..."
        {
            local_backup
            remote_backup
            echo "Successfully finished backing up!"
            curl -X POST -H "Title: 🟢 Successful Homelab Backup" -d "Finished updating local and offsite backups (snapshots)" "$NTFY_ENDPOINT"
        } || {
            echo "Failed to backup..."
            curl -X POST -H "Title: 🔴 Failed Homelab Backup" -d "An error occured when backing up..." "$NTFY_ENDPOINT"
        }
        ;;
    [Nn]*)
        echo "Aborting..."
        exit 0
        ;;
    *) printf " Error: only write 'y' or 'n'\n\n" ;;
    esac
else
    for arg in "$@"; do
        case $arg in
        --all | backup)
            echo "initializing full backup..."
            {
                local_backup
                remote_backup
                echo "Successfully finished backing up!"
                curl -X POST -H "Title: 🟢 Successful Homelab Backup" -d "Finished updating local and offsite backups (snapshots)" "$NTFY_ENDPOINT"
            } || {
                echo "Failed to backup..."
                curl -X POST -H "Title: 🔴 Failed Homelab Backup" -d "An error occured when backing up..." "$NTFY_ENDPOINT"
            }
            ;;
        --dry-run)
            echo "initializing dry-run..."
            {
                dry_run
                echo "Successfully finished dry run!"
                curl -X POST -H "Title: 🟢 [DRY-RUN] Successful Homelab Backup" -d "Finished updating local and offsite backups (snapshots)" "$NTFY_ENDPOINT"
            } || {
                echo "Failed to backup..."
                curl -X POST -H "Title: 🔴 Failed Homelab Backup" -d "An error occured when backing up..." "$NTFY_ENDPOINT"
            }
            ;;
        --local | local)
            echo "initializing local (via rsync)..."
            {
                local_backup
                echo "Successfully finished backing up!"
                curl -X POST -H "Title: 🟢 Successful Homelab Backup" -d "Finished updating local backups" "$NTFY_ENDPOINT"
            } || {
                echo "Failed to backup..."
                curl -X POST -H "Title: 🔴 Failed Homelab Backup" -d "An error occured when backing up..." "$NTFY_ENDPOINT"
            }
            ;;
        --remote | remote)
            echo "initializing remote backup (via restic)..."
            {
                remote_backup
                echo "Successfully finished backing up!"
                curl -X POST -H "Title: 🟢 Successful Homelab Backup" -d "Finished updating offsite backups (snapshots)" "$NTFY_ENDPOINT"
            } || {
                echo "Failed to backup..."
                curl -X POST -H "Title: 🔴 Failed Homelab Backup" -d "An error occured when backing up..." "$NTFY_ENDPOINT"
            }
            ;;
        *)
            echo "Unknown flag: $arg"
            exit 1
            ;;
        esac
    done
fi