Automatisch alle RAR-archieven verifiëren met een Bash-script

Illustratie: een man in een No Backup, No Mercy-T-shirt die op een laptop een back-uptest draait

🌐 Ook in: English · Deutsch · Français · Español · Italiano · Português · Polski

In mijn vorige artikel beschreef ik hoe ik een aantal terabytes aan persoonlijke data heb gereorganiseerd en grote fotocollecties heb gebundeld in RAR-archieven.

Die aanpak verminderde het aantal kleine bestanden in mijn dataset drastisch en maakte back-ups veel sneller. Maar zodra je voor langetermijnopslag op archieven gaat vertrouwen, rijst vanzelf een nieuwe vraag:

Hoe controleer je regelmatig of alle archiefbestanden nog intact zijn? 🤔

Harde schijven verouderen, SSD’s kunnen falen, en stille corruptie (bitrot) is altijd een theoretische mogelijkheid als je data vele jaren bewaart.

Gelukkig bevat de RAR-toolchain ingebouwde commando’s om archieven te testen zonder ze uit te pakken. Een test handmatig draaien is makkelijk:

rar t archive.rar

Maar dat handmatig doen voor honderden of duizenden archieven is natuurlijk niet praktisch.

Dus schreef ik een klein Bash-script dat recursief een opslagboom doorzoekt en elk RAR-archief verifieert dat het vindt.


Inhoud

Wat het script doet

  • Doorzoekt recursief een opslagdirectory
  • Herkent zowel RAR-archieven met één volume als met meerdere volumes
  • Test alleen het eerste volume van multipart-archieven
  • Voert eerst een snelle headerscan uit
  • Draait een volledige CRC-verificatie
  • Logt alle resultaten naar een logbestand
  • Schrijft falende archieven naar een aparte foutenlijst
  • Draait de tests in parallelle threads voor snelheid
  • Toont een voortgangsindicator en ETA

Daardoor wordt het haalbaar om een grote archiefdataset periodiek te verifiëren zonder elk bestand handmatig aan te raken.


Het script

Hieronder staat het Bash-script dat ik op dit moment gebruik om mijn RAR-archieven te verifiëren.

#!/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"

Hoe het werkt

Het script verifieert in twee fasen:

  • Headerscan – controleert snel de archiefstructuur
  • Volledige CRC-test – controleert de daadwerkelijke bestandsinhoud

Als een archief bij een van beide stappen faalt, wordt het in een apart foutenbestand geschreven.

Omdat het script meerdere verificatiejobs parallel draait, kan het grote datasets veel sneller testen dan een sequentiële scan.


Waarom archiefverificatie belangrijk is

Langetermijnopslag brengt altijd enig risico met zich mee. Periodieke archiefverificatie helpt problemen vroeg te ontdekken, voordat back-ups onbruikbaar worden.

Vooral bij datasets die vele jaren bewaard worden — zoals familiefoto’s of persoonlijke archieven — is een periodieke integriteitscheck gewoon goede praktijk.

En natuurlijk… zulke taken automatiseren met Bash is het halve plezier 🙂.

Sommige teksten en afbeeldingen op deze site zijn met hulp van AI gemaakt of door AI gegenereerd. Details