Verificar automáticamente todos tus archivos RAR con un script de Bash

🌐 También en: English · Deutsch · Français

En mi artículo anterior conté cómo reorganicé varios terabytes de datos personales y empaqueté grandes colecciones de fotos en archivos RAR.

Con eso se redujo drásticamente el número de ficheros pequeños de mis datos y las copias de seguridad pasaron a ser mucho más rápidas. Pero en cuanto empiezas a confiar en archivos comprimidos para el almacenamiento a largo plazo, surge de forma natural una nueva pregunta:

¿Cómo compruebas con regularidad que todos los archivos siguen intactos? 🤔

Los discos duros envejecen, los SSD pueden fallar y la corrupción silenciosa (bitrot) siempre es una posibilidad teórica cuando guardas datos durante muchos años.

Por suerte, las herramientas de RAR incluyen comandos para probar archivos sin extraerlos. Lanzar una prueba a mano es fácil:

rar t archive.rar

Pero hacerlo a mano con cientos o miles de archivos, evidentemente, no es práctico.

Así que escribí un pequeño script de Bash que recorre de forma recursiva un árbol de almacenamiento y verifica cada archivo RAR que encuentra.

Qué hace el script

• Recorre de forma recursiva un directorio de almacenamiento
• Detecta archivos RAR tanto de un solo volumen como multivolumen
• En los archivos de varias partes solo prueba el primer volumen
• Hace primero un escaneo rápido de cabeceras
• Ejecuta una verificación CRC completa
• Registra todos los resultados en un fichero de log
• Anota los archivos con errores en una lista de errores aparte
• Ejecuta las pruebas en hilos paralelos para ganar velocidad
• Muestra el progreso y el tiempo restante estimado (ETA)

Así resulta práctico verificar periódicamente un gran conjunto de archivos sin tener que tocar cada fichero a mano.

El script

Este es el script de Bash que uso actualmente para verificar mis archivos RAR.

#!/usr/bin/env bash

# ==========================================
# Configuration
# ==========================================

ERRORFILE="fehlerhafte_rars.txt"
LOGFILE="rar_test.log"
LISTFILE="$(mktemp)"

# Number of parallel jobs (adjust depending on storage speed)
THREADS=${THREADS:-4}

: > "$ERRORFILE"
: > "$LOGFILE"

echo "Searching for RAR archives..."

# ==========================================
# Build list of archives to test
# Only first volumes are included
# ==========================================

find /media/user3/MASTER/daten/ -type f \( -iname "*.rar" -o -iname "*.r[0-9][0-9]" \) | while read -r f
do
    base=$(basename "$f")

    # Detect modern multipart archives (.part01.rar)
    if [[ "$base" =~ \.part([0-9]+)\.rar$ ]]; then
        part="${BASH_REMATCH[1]}"

        # Only keep the first volume
        [[ "$part" != "01" && "$part" != "1" ]] && continue

        echo "$f"
        continue
    fi

    # Skip old multipart volumes (.r00 .r01 ...)
    if [[ "$base" =~ \.r[0-9][0-9]$ ]]; then
        continue
    fi

    # Normal archive or first volume of an old multipart set
    echo "$f"

done | sort -u > "$LISTFILE"

TOTAL=$(wc -l < "$LISTFILE") echo "Found archives: $TOTAL" echo "Parallel jobs: $THREADS" echo START=$(date +%s) COUNT=0 # ========================================== # Function: test archive # ========================================== test_archive() { file="$1" # Fast header scan (quickly checks archive structure) if ! unrar lt -idq "$file" >/dev/null 2>&1; then

        echo "$(date '+%F %T') | HEADER_ERROR | $file" >> "$LOGFILE"
        echo "$(date '+%F %T') | $file" >> "$ERRORFILE"
        return

    fi

    # Full CRC verification
    if unrar t -idq "$file" >/dev/null 2>&1; then

        echo "$(date '+%F %T') | OK | $file" >> "$LOGFILE"

    else

        echo "$(date '+%F %T') | CRC_ERROR | $file" >> "$LOGFILE"
        echo "$(date '+%F %T') | $file" >> "$ERRORFILE"

    fi
}

export -f test_archive
export ERRORFILE LOGFILE

# ==========================================
# Main loop with parallel execution
# ==========================================

while read -r file
do
    ((COUNT++))

    test_archive "$file" &

    # Limit number of parallel jobs
    if (( $(jobs -r | wc -l) >= THREADS )); then
        wait -n
    fi

    # Progress and ETA calculation
    now=$(date +%s)
    runtime=$((now-START))
    avg=$((runtime/COUNT))
    remain=$((TOTAL-COUNT))
    eta=$((remain*avg))

    printf "\rProgress: %d/%d | ETA %02d:%02d:%02d" \
        "$COUNT" "$TOTAL" \
        $((eta/3600)) $((eta%3600/60)) $((eta%60))

done < "$LISTFILE"

wait

echo
echo
echo "Finished."
echo "Error list: $ERRORFILE"
echo "Logfile: $LOGFILE"

Cómo funciona

El script realiza la verificación en dos fases:

• Escaneo de cabeceras: comprueba rápidamente la estructura del archivo
• Prueba CRC completa: verifica el contenido real de los ficheros

Si un archivo falla en cualquiera de los dos pasos, se apunta en un fichero de errores aparte.

Como el script ejecuta varias verificaciones en paralelo, puede probar grandes volúmenes de datos mucho más rápido que un recorrido secuencial.

Por qué importa verificar los archivos

El almacenamiento a largo plazo siempre conlleva cierto riesgo. Verificar los archivos periódicamente ayuda a detectar problemas a tiempo, antes de que las copias de seguridad dejen de servir.

Sobre todo con datos que se guardan durante muchos años —como fotos familiares o archivos personales—, hacer una comprobación de integridad periódica es, sencillamente, una buena práctica.

Y, por supuesto… automatizar este tipo de tareas con Bash es la mitad de la diversión 🙂.