Verificando automaticamente todos os arquivos RAR com um script Bash

Ilustração: um homem com uma camiseta No Backup, No Mercy rodando um teste de backup num laptop

🌐 Também em: English · Deutsch · Français · Español · Italiano · Nederlands · Polski

No meu artigo anterior descrevi como reorganizei vários terabytes de dados pessoais e juntei grandes coleções de fotos em arquivos RAR.

Essa abordagem reduziu drasticamente o número de arquivos pequenos no meu conjunto de dados e deixou os backups bem mais rápidos. Só que, quando você começa a depender de arquivos compactados para armazenamento de longo prazo, surge naturalmente uma nova pergunta:

Como verificar regularmente se todos os arquivos ainda estão íntegros? 🤔

Discos rígidos envelhecem, SSDs podem falhar, e corrupção silenciosa (bitrot) é sempre uma possibilidade teórica quando se guarda dados por muitos anos.

Felizmente, as ferramentas do RAR incluem comandos para testar arquivos sem extraí-los. Rodar um teste manualmente é fácil:

rar t archive.rar

Mas fazer isso manualmente para centenas ou milhares de arquivos obviamente não é prático.

Então escrevi um pequeno script Bash que varre recursivamente uma árvore de armazenamento e verifica cada arquivo RAR que encontra.


Índice

O que o script faz

  • Varre recursivamente um diretório de armazenamento
  • Detecta arquivos RAR de volume único e de múltiplos volumes
  • Testa só o primeiro volume de arquivos multipart
  • Faz primeiro um scan rápido de cabeçalho
  • Executa uma verificação CRC completa
  • Registra todos os resultados num logfile
  • Escreve os arquivos com falha numa lista de erros separada
  • Roda os testes em threads paralelas para ganhar velocidade
  • Mostra um indicador de progresso e o ETA

Isso torna viável verificar periodicamente um grande conjunto de arquivos sem tocar manualmente em cada um.


O script

Abaixo está o script Bash que uso atualmente para verificar meus arquivos 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"

Como funciona

O script faz a verificação em duas etapas:

  • Scan de cabeçalho – verifica rapidamente a estrutura do arquivo
  • Teste CRC completo – verifica o conteúdo real dos arquivos

Se um arquivo falha em qualquer uma das etapas, ele é escrito num arquivo de erros separado.

Como o script roda vários jobs de verificação em paralelo, ele consegue testar grandes conjuntos de dados bem mais rápido do que uma varredura sequencial.


Por que verificar arquivos importa

Armazenamento de longo prazo sempre traz algum risco. Verificar os arquivos periodicamente ajuda a detectar problemas cedo, antes que os backups fiquem inutilizáveis.

Principalmente para dados guardados por muitos anos — como fotos de família ou arquivos pessoais — rodar uma checagem de integridade periódica é simplesmente boa prática.

E claro… automatizar esse tipo de tarefa com Bash é metade da diversão 🙂.

Alguns textos e imagens deste site foram criados com a ajuda de IA ou gerados por IA. Detalhes