Backup incrementale con rotazione (bash)

#!/usr/bin/env bash
#
# Lomazzi Federico 8/12/2023
# Backup incrementale con rotazione
# Sincronizzato; quello che non cambia non viene copiato x volte..

set -u

# ----------------------------------------------------------------------
# Configurazione
# ----------------------------------------------------------------------

SOURCE="/home/federico/dati"
BACKUP_ROOT="/backup/snapshots"

KEEP_DAYS=30

DATE="$(date +%Y-%m-%d)"
DEST="$BACKUP_ROOT/$DATE"
TMP="$BACKUP_ROOT/.snapshot-$DATE.tmp"

# ----------------------------------------------------------------------
# Controlli
# ----------------------------------------------------------------------

if [ ! -d "$SOURCE" ]; then
    echo "ERRORE: directory sorgente inesistente: $SOURCE"
    exit 1
fi

mkdir -p "$BACKUP_ROOT" || exit 1

if [ -e "$DEST" ]; then
    echo "Lo snapshot di oggi esiste già: $DEST"
    exit 0
fi

# Evito di lasciare in giro un eventuale backup interrotto.
rm -rf "$TMP"
mkdir -p "$TMP" || exit 1

# ----------------------------------------------------------------------
# Cerco l'ultimo snapshot
# ----------------------------------------------------------------------

PREVIOUS=""

while IFS= read -r dir; do
    [ "$dir" = "$TMP" ] && continue
    [ "$dir" = "$DEST" ] && continue

    PREVIOUS="$dir"
done < <(
    find "$BACKUP_ROOT" \
        -mindepth 1 \
        -maxdepth 1 \
        -type d \
        -name '????-??-??' \
        -print 2>/dev/null | sort
)

# ----------------------------------------------------------------------
# BASE DEL NUOVO SNAPSHOT
# ----------------------------------------------------------------------

if [ -n "$PREVIOUS" ] && [ -d "$PREVIOUS" ]; then

    echo "Snapshot precedente: $PREVIOUS"

    # Questa è la parte interessante:
    # copio la struttura ma i file sono hard link, quindi spazio quasi zero.
    cp -al "$PREVIOUS"/. "$TMP"/ || {
        echo "ERRORE durante la clonazione dello snapshot precedente."
        rm -rf "$TMP"
        exit 1
    }

else

    echo "Primo backup: nessuno snapshot precedente."

fi

# ----------------------------------------------------------------------
# Sincronizzo
# ----------------------------------------------------------------------

echo "Analisi dei file..."

while IFS= read -r -d '' SRC; do

    REL="${SRC#"$SOURCE"/}"
    DST="$TMP/$REL"

    if [ -d "$SRC" ]; then

        mkdir -p "$DST"

    elif [ -L "$SRC" ]; then

        LINK_SOURCE="$(readlink "$SRC")"
        LINK_DEST=""

        if [ -L "$DST" ]; then
            LINK_DEST="$(readlink "$DST")"
        fi

        if [ "$LINK_SOURCE" != "$LINK_DEST" ]; then
            rm -rf "$DST"
            ln -s "$LINK_SOURCE" "$DST"
        fi

    elif [ -f "$SRC" ]; then

        # Se il file è identico non faccio nulla (resta collegato fisicamente allo snapshot precedente)..
        if [ -f "$DST" ] && cmp -s "$SRC" "$DST"; then
            continue
        fi
        # ...se invece è cambiato rompo l'hard link e copio il nuovo file.
        rm -f "$DST"
        mkdir -p "$(dirname "$DST")" # creo la folder dst
        cp -p "$SRC" "$DST" || {
            echo "ERRORE copiando: $SRC"
            rm -rf "$TMP"
            exit 1
        }

    fi

done < <(find "$SOURCE" -mindepth 1 -print0)

# ----------------------------------------------------------------------
# Elimino dallo snapshot quello che non c'è più
# ----------------------------------------------------------------------

while IFS= read -r -d '' DSTFILE; do

    REL="${DSTFILE#"$TMP"/}"
    SRCFILE="$SOURCE/$REL"

    if [ ! -e "$SRCFILE" ] && [ ! -L "$SRCFILE" ]; then
        rm -rf "$DSTFILE"
    fi

done < <(find "$TMP" -mindepth 1 -depth -print0)

# Copio anche permessi e date delle directory.
while IFS= read -r -d '' SRCDIR; do

    REL="${SRCDIR#"$SOURCE"/}"
    DSTDIR="$TMP/$REL"

    [ -d "$DSTDIR" ] && chmod --reference="$SRCDIR" "$DSTDIR" 2>/dev/null
    [ -d "$DSTDIR" ] && touch -r "$SRCDIR" "$DSTDIR" 2>/dev/null

done < <(find "$SOURCE" -mindepth 1 -type d -print0)

# ----------------------------------------------------------------------
# completato
# ----------------------------------------------------------------------
mv "$TMP" "$DEST" || {
    echo "!ERRORE durante la chiusura dello snapshot."
    exit 1
}
echo "Creato: $DEST"

# ----------------------------------------------------------------------
# Qui gestisco la rotazione
# ----------------------------------------------------------------------

COUNT=0
while IFS= read -r SNAPSHOT; do
    COUNT=$((COUNT + 1))
    if [ "$COUNT" -gt "$KEEP_DAYS" ]; then
        echo "Elimino vecchio snapshot: $SNAPSHOT"
        rm -rf "$SNAPSHOT"
    fi
done < <(
    find "$BACKUP_ROOT" \
        -mindepth 1 \
        -maxdepth 1 \
        -type d \
        -name '????-??-??' \
        -print 2>/dev/null |
    sort -r
)
echo "Backup terminato."
exit 0