Confronta le enormi directory con il rapporto sullo stato di avanzamento

Ho appena risincronizzato 2.000.000 di file (3 TB) da un RAID all'altro.

Voglio assicurarmi che i miei dati siano intatti.

rsync -c richiede molto tempo.

diff non mi mostra cosa sta facendo.

Esiste un'alternativa che è (a) più veloce e (b) mi mostrerà i progressi durante il confronto?

(Sono su Mac e brew search diffmi dà apgdiff colordiff diffstat diffutils fmdiff libxdiff open-vcdiff podiff rfcdiff vbindiff bsdiff diffpdf diffuse dwdiff kdiff3 ndiff perceptualdiff rdiff-backup tkdiff wdiff ... uno di questi farebbe il lavoro?)

modifica per correzione e chiarezza delle opzioni - Ho dimenticato '--brief'

diff -rs --brief "$dir1" "$dir2" 

-r, --recursive              recursively compare any subdirectories found
-s, --report-identical-files report when two files are the same
-q, --brief                  report only when files differ
--speed-large-files      assume large files and many scattered small changes

e aggiungi altre opzioni a piacere, a seconda di cosa stai confrontando:

-i, --ignore-case            ignore case differences in file contents
-b, --ignore-space-change    ignore changes in the amount of white space
-B, --ignore-blank-lines     ignore changes whose lines are all blank
--strip-trailing-cr      strip trailing carriage return on input
--ignore-file-name-case  ignore case when comparing file names

diff -rs leggerà tutti i byte dell'originale e li copierà e riporterà i file uguali.

Il formato di output diff è definito da POSIX, quindi è abbastanza portatile. Potresti voler aggiungere qualcosa come:

| tee diff-out.1 | grep -v -Ee 'I file. * e. * sono identici'

Potresti usare chksums o hash, ma poi devi mantenerli sincronizzati con gli alberi dei file, quindi tornerai comunque a leggere ogni byte di ogni file.

EDIT - troppo tempo per essere un commento, in risposta a:

i file superiori a 10 GB non stanno verificando

Puoi provare questa opzione diff: --speed-large-files

È possibile che il diff che stai usando non stia gestendo bene file molto grandi (più grandi della memoria di sistema, per esempio), e quindi riferendo differenze tra file che sono effettivamente gli stessi.

Avevo pensato che ci fosse un'opzione -h o un 'bdiff' che funzionasse meglio su file di grandi dimensioni, ma non riesco a trovarne uno in Fedora. Credo che le opzioni --speed-large-files siano il successore di un'opzione '-h' "confronto senza cuore".

Un approccio diverso sarebbe quello di ripetere il comando rsync che hai usato, con '-vin' (verbose, itemize, no_run). Ciò segnalerebbe eventuali differenze rilevate da rsync - e non dovrebbero essercene.

Per spostare alcuni file, stai guardando uno script simile al seguente:

if [ cmp -s "$dir1/$path" "$dir2/$path" ] ; then 
target="$dir2/verified/$path"
mkdir -p $(basename "$target")
mv  "$dir2/$path" "$target"
fi

ma non consiglio di farlo. La domanda di fondo è "come posso essere sicuro che rsync abbia copiato correttamente una gerarchia di file?" e se puoi dimostrare a te stesso che rsync sta funzionando bene, con diff o qualche altro strumento, allora puoi semplicemente fare affidamento su rsync, piuttosto che aggirarlo.

rsync -vin comparerà in base a qualsiasi altra opzione tu gli dia. Ho pensato che il checksum fosse predefinito, ma hai ragione, -c o --checksum è richiesto per questo.

L'utilità diff è davvero pensata per file di righe di testo, ma dovrebbe riportare sottotitoli 'identici' per file binari.

Il --brief dovrebbe sopprimere qualsiasi output del contenuto del file - le mie scuse per averlo ignorato in precedenza - è stato semi-sepolto in una brutta sceneggiatura.

Ecco diffun rapporto sullo stato di avanzamento basato sul conteggio dei file:

diff -rqs dir1 dir2 | pv -l -s filecount > logfile

Avrai bisogno di pv (pipe viewer): http://www.ivarch.com/programs/pv.shtml

Spiegazione:

• diff -r confronta ricorsivamente directory e sottodirectory.
• diff -qstampa solo i nomi dei file dei file differiscono. non stampare differenze effettive.
• diff -sstampa anche nomi di file di file che non differiscono. questo è importante per le informazioni sullo stato di avanzamento.
• pv -l segnalare lo stato di avanzamento in base al conteggio delle righe.
• pv -s count tempo stimato per il completamento in base al conteggio.
• Il reindirizzamento logfileè per output piuttosto. Altrimenti l'output di diffsi mescolerà con la riga di stato di pv.

per ottenere il conteggio dei file utilizzare il seguente comando:

find dir1 -type f | wc -l

Filtra il file di registro per file diversi:

grep -v "^Files .* identical$" logfile

Questa variazione stamperà i file che sono diversi in tempo reale mentre si registra anche tutto logfile:

diff -rqs dir1 dir2 | pv -l -s filecount | 
    tee logfile | grep -v "^Files .* identical$"

In alternativa è possibile registrare solo file diversi:

diff -rqs dir1 dir2 | pv -l -s filecount | 
    grep -v "^Files .* identical$" > logfile

Nota: i comandi sopra riportati riporteranno l'avanzamento in base al conteggio dei file. Funziona meglio se ci sono molti file piccoli. Se hai alcuni file di grandi dimensioni, non ti divertirai molto con questo.

Purtroppo non conosco un modo semplice per segnalare i progressi in base ai byte confrontati.

Se riesci a trovare la pace solo confrontando i metadati (e non il contenuto effettivo dei file), puoi usare rsync. Questo sarà notevolmente più veloce.

Per ulteriori dettagli:

• Confronta le directory ma non il contenuto dei file
• Stimare il tempo o il lavoro rimasto per finire per rsync?

Vorrei utilizzare una sorta di applicazione hash per verificare l'integrità dei dati. So che molte utility per la ricerca di file duplicati usano gli hash per identificare duplicati / non duplicati. Mi sembra che questa sia un'indagine che potrebbe valere la pena.

È possibile utilizzare rdiff-backup per questo. Installalo su entrambi i server e farà un confronto intelligente dei checksum e sincronizzerà ciò che non è ancora lì.