Vérifier automatiquement toutes ses archives RAR avec un script Bash

🌐 Aussi en: English · Deutsch · Español

Dans mon article précédent, j’ai expliqué comment j’ai réorganisé plusieurs téraoctets de données personnelles et regroupé de grandes collections de photos dans des archives RAR.

Cette approche a considérablement réduit le nombre de petits fichiers dans mes données et rendu les sauvegardes bien plus rapides. Mais dès que l’on s’appuie sur des archives pour le stockage à long terme, une nouvelle question se pose naturellement :

Comment vérifier régulièrement que tous les fichiers d’archive sont toujours intacts ? 🤔

Les disques durs vieillissent, les SSD peuvent lâcher, et la corruption silencieuse (bitrot) reste toujours une possibilité théorique quand on conserve des données pendant de nombreuses années.

Heureusement, les outils RAR intègrent des commandes pour tester les archives sans les extraire. Lancer un test à la main est simple :

rar t archive.rar

Mais le faire à la main pour des centaines, voire des milliers d’archives, n’est évidemment pas réaliste.

J’ai donc écrit un petit script Bash qui parcourt récursivement une arborescence de stockage et vérifie chaque archive RAR qu’il y trouve.

Ce que fait le script

• Parcourt récursivement un répertoire de stockage
• Détecte les archives RAR en un seul volume comme multivolumes
• Ne teste que le premier volume des archives en plusieurs parties
• Effectue d’abord un scan rapide des en-têtes
• Lance une vérification CRC complète
• Consigne tous les résultats dans un fichier journal
• Inscrit les archives défectueuses dans une liste d’erreurs séparée
• Exécute les tests dans des threads parallèles pour gagner en vitesse
• Affiche une progression et le temps restant estimé (ETA)

Il devient ainsi facile de vérifier périodiquement un gros volume d’archives sans toucher chaque fichier à la main.

Le script

Voici le script Bash que j’utilise actuellement pour vérifier mes archives 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"

Comment ça marche

Le script procède à une vérification en deux étapes :

• Scan des en-têtes – vérifie rapidement la structure de l’archive
• Test CRC complet – vérifie le contenu réel des fichiers

Si une archive échoue à l’une ou l’autre étape, elle est inscrite dans un fichier d’erreurs séparé.

Comme le script exécute plusieurs vérifications en parallèle, il teste de gros volumes de données bien plus vite qu’un parcours séquentiel.

Pourquoi vérifier ses archives

Le stockage à long terme comporte toujours une part de risque. Vérifier périodiquement ses archives permet de détecter les problèmes tôt, avant que les sauvegardes ne deviennent inutilisables.

Surtout pour des données conservées pendant de nombreuses années – photos de famille ou archives personnelles, par exemple –, un contrôle d’intégrité régulier relève tout simplement des bonnes pratiques.

Et bien sûr… automatiser ce genre de tâche en Bash, c’est déjà la moitié du plaisir 🙂.