# 0 = sin límite de tiempo por carpeta.
# Correcto SOLO para la primera carga completa con volúmenes grandes.
BACKUP_TIMEOUT=0

restic backup /srv/****/carpeta-ejemplo \
    --tag carpeta-ejemplo \
    -o rclone.connections=2

# Todos los snapshots del repositorio
restic snapshots

# Solo los snapshots de una carpeta puntual
restic snapshots --tag carpeta-ejemplo

mkdir -p /srv/restore-completo
restic restore latest --target /srv/restore-completo

mkdir -p /srv/restore-carpeta-ejemplo
restic restore latest --tag carpeta-ejemplo --target /srv/restore-carpeta-ejemplo

restic restore latest --tag carpeta-ejemplo \
    --target /tmp/restore-archivo \
    --include "/srv/****/carpeta-ejemplo/documento.xlsx"

# Queda en: /tmp/restore-archivo/srv/****/carpeta-ejemplo/documento.xlsx

restic dump latest --tag carpeta-ejemplo \
    /srv/****/carpeta-ejemplo/documento.xlsx > /tmp/documento.xlsx

#!/bin/bash
# ============================================================
# restic-backup.sh
#
# Backup incremental con deduplicación de un árbol de carpetas
# hacia un backend remoto (Nextcloud u otro WebDAV) usando
# restic + rclone.
#
# QUÉ HACE:
#   - Detecta automáticamente las subcarpetas de primer nivel
#     dentro de BACKUP_SOURCE (no hace falta listarlas a mano).
#   - Genera un snapshot restic por carpeta, todos dentro del
#     mismo repositorio (permite deduplicación también entre
#     carpetas y retención independiente por carpeta).
#   - Reintenta ante fallos transitorios, con espera suficiente
#     para que el backend remoto libere locks huérfanos.
#   - Aplica una política de retención (poda automática) al
#     final de cada corrida completa.
#   - Corre una verificación de integridad semanal (domingos).
#
# REQUISITOS:
#   - restic y rclone instalados.
#   - Un remote de rclone ya configurado (rclone config) apuntando
#     al backend WebDAV/S3/etc. de destino.
#   - Un archivo de entorno con RESTIC_REPOSITORY y RESTIC_PASSWORD
#     (ver samba.env.example en este mismo repositorio de ejemplo).
#
# USO:
#   bash restic-backup.sh
#   (pensado para disparar por cron una vez que la primera carga
#    completa haya terminado sin errores)
# ============================================================

set -o pipefail

# ------------------------------------------------------------
# CONFIGURACIÓN — ajustar estas rutas a tu entorno
# ------------------------------------------------------------
BACKUP_SOURCE="/srv/datos"                       # carpeta base a respaldar
EXCLUDE_DIRS=(".nc-staging" "lost+found")        # subcarpetas a ignorar dentro de BACKUP_SOURCE

RESTIC_ENV="/etc/scripts/backup/repo.env"        # acá van RESTIC_REPOSITORY y RESTIC_PASSWORD

LOG_DIR="/var/log/restic-backup"
LOG_FILE="${LOG_DIR}/backup-$(date +%Y%m%d).log"
LOCK_FILE="/tmp/restic-backup.lock"

MAX_RETRIES=2
RETRY_WAIT=300          # segundos entre reintentos (5 min - le da tiempo al backend remoto de liberar locks huérfanos)
BACKUP_TIMEOUT=0        # segundos por carpeta. 0 = SIN LÍMITE.
                         # Usar 0 en la primera carga completa con carpetas grandes / enlace lento.
                         # Una vez que todas las carpetas tengan snapshot base, fijar un valor
                         # acotado (ej. 10800 = 3hs) como red de seguridad para las corridas
                         # incrementales — si una corrida incremental tarda eso, algo anómalo
                         # está pasando y conviene que el script lo corte y avise.

RETENTION_ARGS="--keep-daily 7 --keep-weekly 4 --keep-monthly 6"

RCLONE_CONNECTIONS=2     # límite de conexiones concurrentes hacia el backend remoto.
                          # Reduce la presión sobre sistemas de locking basados en Redis
                          # (típico en Nextcloud) a costa de una subida algo más lenta.

BACKUP_HOST_TAG="$(hostname)"   # identificador de host que queda grabado en cada snapshot

# ------------------------------------------------------------
# LOG
# ------------------------------------------------------------
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "${LOG_FILE}"
}

log_separator() {
    echo "============================================================" >> "${LOG_FILE}"
}

# ------------------------------------------------------------
# CLEANUP
# ------------------------------------------------------------
cleanup() {
    rm -f "${LOCK_FILE}"
    log "Script finalizado. Lock liberado."
}

# ------------------------------------------------------------
# INSTANCIA ÚNICA
# Evita que dos ejecuciones se solapen si una corrida anterior
# todavía no terminó (por ejemplo si tarda más que el intervalo
# de cron configurado).
# ------------------------------------------------------------
mkdir -p "${LOG_DIR}"

if [ -f "${LOCK_FILE}" ]; then
    PID=$(cat "${LOCK_FILE}")
    if kill -0 "${PID}" 2>/dev/null; then
        log "AVISO: Backup en curso (PID ${PID}). Saliendo sin hacer nada."
        exit 0
    else
        log "Lock huérfano (PID ${PID} ya no existe). Continuando."
        rm -f "${LOCK_FILE}"
    fi
fi

echo $$ > "${LOCK_FILE}"
trap cleanup EXIT

# ------------------------------------------------------------
# DEPENDENCIAS
# ------------------------------------------------------------
for cmd in restic rclone; do
    if ! command -v "$cmd" &>/dev/null; then
        log "ERROR: comando requerido no encontrado: $cmd"
        exit 1
    fi
done

if [ ! -f "${RESTIC_ENV}" ]; then
    log "ERROR: no se encuentra ${RESTIC_ENV} con las credenciales del repo"
    exit 1
fi

# shellcheck disable=SC1090
source "${RESTIC_ENV}"

if [ -z "${RESTIC_REPOSITORY}" ] || [ -z "${RESTIC_PASSWORD}" ]; then
    log "ERROR: RESTIC_REPOSITORY o RESTIC_PASSWORD no están seteados"
    exit 1
fi

export RESTIC_REPOSITORY
export RESTIC_PASSWORD

# ------------------------------------------------------------
# DETECCIÓN AUTOMÁTICA DE CARPETAS
# Toma todas las subcarpetas de primer nivel de BACKUP_SOURCE,
# salvo las listadas en EXCLUDE_DIRS. Si mañana se crea una
# carpeta nueva, la próxima corrida la incorpora sola.
# ------------------------------------------------------------
detect_folders() {
    local folder
    while IFS= read -r -d '' folder; do
        local name
        name=$(basename "${folder}")
        local skip=false
        for excl in "${EXCLUDE_DIRS[@]}"; do
            [ "${name}" = "${excl}" ] && skip=true && break
        done
        [ "${skip}" = true ] && continue
        echo "${name}"
    done < <(find "${BACKUP_SOURCE}" -mindepth 1 -maxdepth 1 -type d -print0 | sort -z)
}

# ------------------------------------------------------------
# BACKUP DE UNA CARPETA CON REINTENTOS
# ------------------------------------------------------------
backup_folder() {
    local folder="$1"
    local local_path="${BACKUP_SOURCE}/${folder}"
    local attempt=0
    local success=false

    if [ ! -d "${local_path}" ]; then
        log "  [SKIP] ${folder}: no existe (${local_path})"
        return 2
    fi

    while [ $attempt -lt $MAX_RETRIES ]; do
        attempt=$((attempt + 1))
        log "  [INTENTO ${attempt}/${MAX_RETRIES}] Backup: ${folder}"

        if [ "${BACKUP_TIMEOUT}" -eq 0 ]; then
            restic backup "${local_path}" \
                --tag "${folder}" \
                --host "${BACKUP_HOST_TAG}" \
                -o rclone.connections=${RCLONE_CONNECTIONS} \
                >> "${LOG_FILE}" 2>&1
        else
            timeout ${BACKUP_TIMEOUT} restic backup "${local_path}" \
                --tag "${folder}" \
                --host "${BACKUP_HOST_TAG}" \
                -o rclone.connections=${RCLONE_CONNECTIONS} \
                >> "${LOG_FILE}" 2>&1
        fi

        local exit_code=$?

        if [ $exit_code -eq 0 ]; then
            log "  [OK] ${folder}: backup completado"
            success=true
            break
        elif [ $exit_code -eq 124 ]; then
            log "  [TIMEOUT] ${folder}: superó ${BACKUP_TIMEOUT}s en intento ${attempt}"
        else
            log "  [ERROR] ${folder}: falló con código ${exit_code} en intento ${attempt}"
        fi

        if [ $attempt -lt $MAX_RETRIES ]; then
            log "  [ESPERA] Reintentando en ${RETRY_WAIT} segundos..."
            sleep ${RETRY_WAIT}
        fi
    done

    if [ "$success" = false ]; then
        log "  [FALLO TOTAL] ${folder}: agotados ${MAX_RETRIES} intentos"
        return 1
    fi

    return 0
}

# ------------------------------------------------------------
# EJECUCIÓN
# ------------------------------------------------------------
log_separator
log "INICIO DE BACKUP"
log "Repo   : ${RESTIC_REPOSITORY}"
log "Base   : ${BACKUP_SOURCE}"
log_separator

mapfile -t FOLDERS < <(detect_folders)

log "Carpetas detectadas: ${#FOLDERS[@]}"
for f in "${FOLDERS[@]}"; do
    log "  - ${f}"
done
log_separator

SUCCESS=0
FAILED=0
SKIPPED=0

for folder in "${FOLDERS[@]}"; do
    log ""
    log ">> Procesando carpeta: ${folder}"
    backup_folder "${folder}"
    result=$?

    case $result in
        0) SUCCESS=$((SUCCESS + 1)) ;;
        1) FAILED=$((FAILED + 1)) ;;
        2) SKIPPED=$((SKIPPED + 1)) ;;
    esac
done

# ------------------------------------------------------------
# RETENCIÓN
# --group-by paths hace que cada carpeta se pode de forma
# independiente, según su propio historial de snapshots.
# ------------------------------------------------------------
log ""
log_separator
log "APLICANDO POLÍTICA DE RETENCIÓN"
log "  ${RETENTION_ARGS}"

restic forget --group-by paths ${RETENTION_ARGS} --prune >> "${LOG_FILE}" 2>&1
if [ $? -eq 0 ]; then
    log "  [OK] Retención aplicada correctamente"
else
    log "  [ERROR] Falló restic forget/prune - revisar log"
fi

# ------------------------------------------------------------
# VERIFICACIÓN LIGERA DEL REPO (chequea estructura, no baja todo)
# Se corre una vez por semana (domingo) para no sumar carga diaria.
# ------------------------------------------------------------
if [ "$(date +%u)" -eq 7 ]; then
    log ""
    log "Verificación semanal del repositorio (check)..."
    restic check >> "${LOG_FILE}" 2>&1
    if [ $? -eq 0 ]; then
        log "  [OK] Repositorio íntegro"
    else
        log "  [ERROR] Problemas de integridad detectados - revisar log"
    fi
fi

# Rotar logs viejos (mantener últimos 30 días)
find "${LOG_DIR}" -name "backup-*.log" -mtime +30 -delete

log ""
log_separator
log "RESUMEN FINAL"
log "  Exitosas : ${SUCCESS}"
log "  Fallidas : ${FAILED}"
log "  Omitidas : ${SKIPPED}"
log_separator

[ $FAILED -eq 0 ] && exit 0 || exit 1

# ============================================================
# repo.env.example
#
# Plantilla del archivo de entorno que necesita restic-backup.sh.
# Copiar como "repo.env" (o el nombre que apunte RESTIC_ENV en el
# script), completar con los valores reales, y restringir permisos:
#
#   cp repo.env.example repo.env
#   chmod 600 repo.env
#   chown root:root repo.env
#
# No versionar el archivo real (con los valores completos) en
# ningún repositorio ni compartirlo — RESTIC_PASSWORD es la clave
# de cifrado del backup completo. Sin ella el backup es
# irrecuperable, no hay forma de rescatar los datos.
# ============================================================

# Ubicación del repositorio restic. El prefijo "rclone:" le dice a
# restic que use rclone como transporte; lo que sigue es
# "<nombre-del-remote-en-rclone>:<carpeta-remota>".
# El remote ("NOMBRE_REMOTE" acá) se configura antes con:
#   rclone config
export RESTIC_REPOSITORY="rclone:NOMBRE_REMOTE:CARPETA-REMOTA/restic-backup"

# Clave de cifrado del repositorio. Generar una fuerte, por ejemplo:
#   openssl rand -base64 32
# Guardarla también en un gestor de contraseñas aparte del servidor.
export RESTIC_PASSWORD="REEMPLAZAR-POR-UNA-CLAVE-FUERTE"