Compare directorios masivos con el informe de progreso

Acabo de sincronizar 2.000.000 de archivos (3 TB) de un RAID a otro.

Quiero asegurarme de que mis datos estén intactos.

rsync -c lleva mucho tiempo

diff No me muestra lo que está haciendo.

¿Existe una alternativa que sea (a) más rápida y (b) me muestre el progreso mientras se compara?

(Estoy en Mac, y brew search diffme da apgdiff colordiff diffstat diffutils fmdiff libxdiff open-vcdiff podiff rfcdiff vbindiff bsdiff diffpdf diffuse dwdiff kdiff3 ndiff perceptualdiff rdiff-backup tkdiff wdiff ... ¿alguno de estos haría el trabajo?)

editar para corrección y claridad de opciones - Olvidé '- breve'

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

y agregue otras opciones al gusto, según lo que esté comparando:

-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 leerá cada byte del original y la copia, e informará los archivos que son iguales.

POSIX define el formato de salida diff, por lo que es bastante portátil. Es posible que desee agregar algo como:

El | tee diff-out.1 | grep -v -Ee 'Los archivos. * y. * son idénticos'

Podría usar chksums o hashes, pero luego debe mantenerlos sincronizados con los árboles de archivos, de modo que volvería a leer cada byte de cada archivo de todos modos.

EDITAR: demasiado largo para ser un comentario, en respuesta a:

los archivos de más de 10 GB no están verificando

Es posible que desee probar esta opción diff: --speed-large-files

Es posible que la diferencia que está utilizando no se adapte bien a archivos muy grandes (más grandes que la memoria del sistema, por ejemplo) y, por lo tanto, informa diferencias entre archivos que en realidad son los mismos.

Pensé que había una opción -h o un 'bdiff' que funcionaba mejor en archivos grandes, pero no puedo encontrar uno en Fedora. Creo que la opción --speed-large-files es una sucesora de la opción '-h' "comparar a medias".

Un enfoque diferente sería repetir el comando rsync que usó, con '-vin' (detallado, itemize, no_run). Esto informaría cualquier diferencia que encuentre rsync, y no debería haber ninguna.

Para mover algunos archivos, estás viendo un script algo así como:

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

Pero no recomiendo hacer eso. La pregunta subyacente es "¿cómo puedo estar seguro de que rsync copió una jerarquía de archivos correctamente?" y si puede demostrarse a sí mismo que rsync está funcionando bien, con diff o alguna otra herramienta, entonces puede confiar en rsync, en lugar de evitarlo.

rsync -vin se comparará en función de cualquier otra opción que le des. Pensé que estaba predeterminado en la suma de comprobación, pero tienes razón, -c o - se requiere la suma de comprobación para eso.

La utilidad diff realmente está destinada a archivos de líneas de texto, pero debe informar sub-s 'idénticos' para archivos binarios.

El - resumen debería suprimir cualquier salida de contenido de archivo - mis disculpas por pasarlo por alto antes - fue semi enterrado en un script feo.

Aquí está diffcon el informe de progreso basado en el conteo de archivos:

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

Necesitará pv (visor de tuberías): http://www.ivarch.com/programs/pv.shtml

Explicación:

• diff -r comparar directorios y subdirectorios de forma recursiva.
• diff -qimprimir solo los nombres de los archivos difieren. No imprima las diferencias reales.
• diff -simprime también nombres de archivos que no difieren. Esto es importante para la información de progreso.
• pv -l informar el progreso en función del recuento de líneas.
• pv -s count tiempo estimado para completar en función del recuento.
• La redirección a logfilees para una salida bonita. De lo contrario, la salida de diffse mezclará con la línea de estado de pv.

para obtener el recuento de archivos use el siguiente comando:

find dir1 -type f | wc -l

Filtre el archivo de registro para archivos que son diferentes:

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

Esta variación imprimirá archivos que son diferentes en tiempo real y también registrará todo en logfile:

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

Alternativamente, puede registrar solo archivos que son diferentes:

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

Nota: los comandos anteriores informarán el progreso según el recuento de archivos. Esto funciona mejor si hay muchos archivos pequeños. Si tienes algunos archivos enormes, entonces no te divertirás mucho con esto.

Lamentablemente, no conozco una manera fácil de informar el progreso basado en bytes comparados.

Si puede encontrar su paz simplemente comparando los metadatos (y no el contenido real de los archivos), entonces puede usar rsync. Esto será considerablemente más rápido.

Para más detalles:

• Comparar directorios pero no contenido de archivos
• ¿Estima tiempo o trabajo restante para terminar para rsync?

Me gustaría ver el uso de algún tipo de aplicación hash para verificar la integridad de los datos. Sé que muchas utilidades de búsqueda de archivos duplicados usan hashes para identificar duplicados / no duplicados. Me parece que esta es una investigación que podría valer la pena.

Puede usar rdiff-backup para eso. Instálelo en ambos servidores y hará comparaciones inteligentes de sumas de verificación y sincronizará lo que aún no está allí.