Mostrando progreso total en rsync: ¿es posible?

Ya he buscado esta opción, pero solo he encontrado soluciones que implican parches personalizados . El hecho de que no se muestre en --help y no se pueda encontrar más información probablemente indica que las respuestas son 'no', pero me gustaría ver esto confirmado.

¿Es posible mostrar el progreso total de la transferencia de archivos con rsync?

Danakim es correcto. No hay formas triviales de agregar un indicador de progreso total.

La razón de esto es que cuando rsync mira una lista de archivos para sincronizar, no sabe de antemano qué archivos necesitarán cambiar. Si está haciendo transferencias delta, los deltas deben calcularse con anticipación para obtener una imagen total del trabajo que debe realizarse.

En otras palabras, la forma más fácil de calcular cuánto trabajo hay que hacer es hacerlo realmente.

Ahora hay una forma oficial de hacer esto en rsync (versión 3.1.0, versión 31 del protocolo, probado con Ubuntu Trusty 14.04).

#> ./rsync -a --info=progress2 /usr .
    305,002,533  80%   65.69MB/s    0:00:01  xfr#1653, ir-chk=1593/3594)

Intenté con mi /usrcarpeta porque quería esta característica para transferir sistemas de archivos completos, y /usrparecía ser una buena muestra representativa.

El --info=progress2da un buen porcentaje general, incluso si es solo un valor parcial. De hecho, mi /usrcarpeta tiene más de 6 conciertos:

#> du -sh /usr
6,6G    /usr/

y rsynctomé mucho tiempo para escanearlo todo. Casi todo el tiempo, el porcentaje que he visto se ha completado en un 90%, pero es reconfortante ver que se está copiando algo :)

Referencias

• https://stackoverflow.com/a/7272339/1396334
• https://download.samba.org/pub/rsync/src/rsync-3.1.0-NEWS

Puedes hacerlo con 'pv' ( apt-get install pvcon Debian y ubuntu). Recomiendo controlar la cantidad de archivos transferidos, ya que la cantidad de datos transferidos no está correlacionada con el tamaño de los archivos, sino en el delta entre el origen y el destino. Y contar archivos contará el mismo progreso para un gran delta y otro con un pequeño delta. Lo que significa que, en cualquier caso, la estimación de ETA podría estar muy lejos. La ETA basada en el tamaño solo funciona si su destino está vacío, en este caso delta == tamaño de origen.

La idea general es emitir una línea por archivo 'transferido' desde rsync, y contar esas líneas con 'pv':

rsync -ai / fuente remota: / dest | pv -les [número de archivos]> / dev / null

Tiendo a hacer copias de seguridad de sistemas de archivos completos (por varias razones), en este caso puede usar el más barato dfpara obtener la cantidad de archivos (en lugar de duo findque atravesará su jerarquía de origen otra vez después de que rsync lo hizo). La opción -x parece asegurarse de que rsync permanezca en el mismo sistema de archivos fuente (y no siga otros montajes internos):

rsync -aix / fuente remota: / dest | pv -les $ (df -i / source | perl -ane 'print $ F [2] if $ F [5] = ~ m: ^ /:')> / dev / null

Si desea contar archivos en / source de forma general, use find /source|wc -l(advertencia de nuevo: puede ser lento y pesado en E / S).

Lo siguiente se aplica a rsync versión 3.0.0 y superior. Las opciones que se describen a continuación se introdujeron en esa versión el 1 de marzo de 2008.

Junto con --info = progress2 también puede usar la opción --no-inc-recursive (o su abreviatura --no-ir alias) para deshabilitar la recursividad incremental.

Esto generará la lista completa de archivos al principio, en lugar de descubrir de manera incremental más archivos a medida que avanza la transferencia. Como conocerá todos los archivos antes de comenzar, proporcionará un mejor informe del progreso general. Esto se aplica al número de archivos; no informa ningún progreso en función del tamaño de los archivos.

Esto implica una compensación. Crear la lista completa de archivos con anticipación es más costoso para la memoria y puede retrasar significativamente el inicio de la transferencia real. Como era de esperar, cuantos más archivos haya, mayor será el retraso y más memoria requerirá.

Lo siguiente es del manual de rsync (fuente: http://rsync.samba.org/ftp/rsync/rsync.html ):

-r, --recursivo

Esto le dice a rsync que copie directorios recursivamente. Ver también --dirs (-d). Comenzando con rsync 3.0.0, el algoritmo recursivo utilizado ahora es un escaneo incremental que usa mucha menos memoria que antes y comienza la transferencia después de que se haya completado el escaneo de los primeros directorios. Este escaneo incremental solo afecta nuestro algoritmo de recursión y no cambia una transferencia no recursiva. También solo es posible cuando ambos extremos de la transferencia son al menos la versión 3.0.0.

Algunas opciones requieren que rsync conozca la lista completa de archivos, por lo que estas opciones desactivan el modo de recursión incremental. Estos incluyen: --delete-before, --delete-after, --prune-empty-dirs y --delay-updates. Debido a esto, el modo de eliminación predeterminado cuando especifica --delete es ahora --delete-durante cuando ambos extremos de la conexión son al menos 3.0.0 (use --del o --delete-during para solicitar este modo de eliminación mejorado explícitamente). Vea también la opción --delete-delay que es una mejor opción que usar --delete-after.

La recursividad incremental se puede deshabilitar utilizando la opción --no-inc-recursive o su alias más corto --no-ir .

Consulte también https://rsync.samba.org para conocer las diferencias de versión específicas (desplácese hacia abajo y consulte los enlaces de Noticias de lanzamiento).

Para transferencias largas, estoy contento con correr du -sen ambos lados. Incluso watch -n1 du -s, si me siento realmente ansioso.

watchejecuta un comando ( du -saquí) periódicamente (cada 1 segundo aquí) y muestra la salida a pantalla completa.

Básicamente no. Solo puede mostrar el progreso por archivo con el indicador --progress, pero eso es todo.

Supongo que puede escribir un envoltorio alrededor o usar cualquiera de los parches que ya encuentra, pero debe preguntarse si realmente vale la pena, ¿realmente necesita un progreso total para rsync?

Usé la respuesta de zerodeux y escribí mi propio pequeño script bash:

#!/bin/bash

RSYNC="ionice -c3 rsync"
# don't use --progress
RSYNC_ARGS="-vrltD --delete --stats --human-readable"
SOURCES="/dir1 /dir2 /file3"
TARGET="storage::storage"

echo "Executing dry-run to see how many files must be transferred..."
TODO=$(${RSYNC} --dry-run ${RSYNC_ARGS} ${SOURCES} ${TARGET}|grep "^Number of files transferred"|awk '{print $5}')

${RSYNC} ${RSYNC_ARGS} ${SOURCES} ${TARGET} | pv -l -e -p -s "$TODO"

También busqué cómo mostrar el progreso total con rsync y encontré un contestador útil en esta publicación: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

Básicamente, puede usar --info = progress2 en la versión de desarrollo de rsync 3.1.0 . Esto es lo que ha dicho el doctor :

También hay una opción --info = progress2 que genera estadísticas basadas en toda la transferencia, en lugar de archivos individuales. Utilice este indicador sin generar un nombre de archivo (por ejemplo, evite -v o especifique --info = name0 si desea ver cómo se realiza la transferencia sin desplazarse por la pantalla con muchos nombres. (No necesita especificar el - opción de progreso para usar --info = progress2.)

Usé la respuesta de zerodeux y escribí mi propio script BASH:

#!/bin/bash

RSYNC="ionice -c3 rsync"
# don't use --progress
RSYNC_ARGS="-vrltD --delete --stats --human-readable"
SOURCES="/dir1 /dir2 /file3"
TARGET="storage::storage"

#echo "Executing dry-run to see how many files must be transferred..."
TODO=$(find ${SOURCES} | wc -l)

${RSYNC} ${RSYNC_ARGS} ${SOURCES} ${TARGET} | pv -l -e -p -s "$TODO"

Cambié el funcionamiento en seco de TODO a

TODO=$(find ${SOURCES} | wc -l)

¡Encuentra el número de archivos muy rápido!

Si no tiene la última versión de rsync (p. Ej., OS X tiene 2.6.9) y no puede usarla --info=progress2, aquí hay otra alternativa para salvarse de las páginas de texto desplazable sobre el progreso:

rsync -aPh <source> <destination> | xargs -L1 printf "\33[2K\rTransferring: %s"

Esto imprimirá, en una línea, el nombre del último archivo que se transfiere:

Transferring: the-latest.file

Utilizar

lsof -ad3-999 -c rsync

Para ver qué archivos rsync tiene abiertos actualmente (mostrará el tamaño del archivo) rsync copia en un archivo oculto localmente

Haría de esto un comentario, pero no tengo suficiente reputación. En respuesta al comentario de naught101 a la respuesta elegida, la opción --progress muestra cuántos archivos se han transferido del monto total a transferir. No me di cuenta de esto hasta que miré esta publicación y miré la salida con más cuidado.

La estadística 'para verificar' muestra cuántos archivos quedan del total. Esto es muy útil cuando se sincroniza con un nuevo destino para que sepa que todos los archivos se copiarán por completo.

Desde la página del manual:

When [each] file transfer  finishes,  rsync  replaces  the
progress line with a summary line that looks like this:

    1238099 100%  146.38kB/s    0:00:08  (xfer#5, to-check=169/396)

In this example, the file was  1238099  bytes  long  in
total,  the average rate of transfer for the whole file
was 146.38 kilobytes per second over the 8 seconds that
it took to complete, it was the 5th transfer of a regu-
lar file during the current rsync  session,  and  there
are 169 more files for the receiver to check (to see if
they are up-to-date or not) remaining out  of  the  396
total files in the file-list.

Tenga en cuenta la advertencia aquí de que incluso --info = progress2 no es del todo confiable ya que este porcentaje se basa en la cantidad de archivos que rsync 'conoce' en el momento en que se muestra el progreso. Esta no es necesariamente la cantidad total de archivos que debían sincronizarse (por ejemplo, si descubre una gran cantidad de archivos grandes en un directorio profundamente anidado). Una manera de asegurarse de que --info = progress2 no 'retroceda' en la indicación de progreso sería forzar a rsync a escanear todos los directorios de forma recursiva antes de comenzar la sincronización (en lugar de su comportamiento predeterminado de hacer un escaneo incrementalmente recursivo), al proporcionar también la opción --no-inc-recursive. Sin embargo, tenga en cuenta que esta opción también aumentará el uso de la memoria rsync y el tiempo de ejecución.

Utilizo un script que extrae la información de / proc // io para el proceso rsync (o cualquier otro proceso para el caso) y saber el monto total a transferir es calcular el progreso.

#!/bin/bash

usage()
{
   echo "usage: $0 PID BASEMSIZE [DELAY[s|m|h]]"
}

if [ $# -lt 2 ]; then
   usage
   exit 1
elif [ $# -eq 3 ]; then
   DELAY=$3
else
   DELAY=5s
fi

PID=$1
PBASE=`echo "scale=2; $2/1024"|bc`

R_PID=$PID
W_PID=$PID

R_SPEED_MAX=0
W_SPEED_MAX=0
R_SPEED_CUM=0
W_SPEED_CUM=0
R_SPEED_AVG=0
W_SPEED_AVG=0

ETA=0
ETA_H=0
ETA_M=0
ETA_S=0

while [ ! -r /proc/$PID/io ];
do
   clear
   echo "Waiting for process with PID=$PID to appear!"
   sleep 1
done

B_READ_PREV=`cat /proc/$R_PID/io|awk '$1 ~ /^read_bytes/ {print $2}'`
B_WRITE_PREV=`cat /proc/$W_PID/io|awk '$1 ~ /^write_bytes/ {print $2}'`
T1=`date +%s.%N`

count=0
while true
do
   [ ! -r /proc/$PID/io ] && break
   clear
   B_READ=`cat /proc/$R_PID/io|awk '$1 ~ /^read_bytes/ {print $2}'`
   B_WRITE=`cat /proc/$W_PID/io|awk '$1 ~ /^write_bytes/ {print $2}'`
   BL_READ=`echo "scale=2; ($B_READ-$B_READ_PREV)/1048576"|bc`
   BL_WRITE=`echo "scale=2; ($B_WRITE-$B_WRITE_PREV)/1048576"|bc`
   GB_DONE=`echo "scale=2; $B_WRITE/1073741824"|bc`
   PDONE=`echo "scale=2; $GB_DONE*100/$PBASE"|bc`
   T2=`date +%s.%N`
   TLOOP=`echo "scale=2; ($T2-$T1)/1"|bc`
   R_SPEED=`echo "scale=2; $BL_READ/$TLOOP"|bc`
   W_SPEED=`echo "scale=2; $BL_WRITE/$TLOOP"|bc`

   if [ $count -ge 1 ]; then
      R_SPEED_CUM=`echo "scale=2; $R_SPEED_CUM+$R_SPEED"|bc`
      R_SPEED_AVG=`echo "scale=2; $R_SPEED_CUM/$count"|bc`
      W_SPEED_CUM=`echo "scale=2; $W_SPEED_CUM+$W_SPEED"|bc`
      W_SPEED_AVG=`echo "scale=2; $W_SPEED_CUM/$count"|bc`
      [ `echo "scale=2; $W_SPEED > $W_SPEED_MAX"|bc` -eq 1 ] && W_SPEED_MAX=$W_SPEED
      [ `echo "scale=2; $R_SPEED > $R_SPEED_MAX"|bc` -eq 1 ] && R_SPEED_MAX=$R_SPEED
   fi

   if [ `echo "scale=2; $W_SPEED_AVG > 0"|bc` -eq 1 ]; then
      ETA=`echo "scale=2; (($PBASE-$GB_DONE)*1024)/$W_SPEED_AVG"|bc`
      ETA_H=`echo "scale=0; $ETA/3600"|bc`
      ETA_M=`echo "scale=0; ($ETA%3600)/60"|bc`
      ETA_S=`echo "scale=0; ($ETA%3600)%60"|bc`
   fi

   echo "Monitoring PID: $PID"
   echo
   echo "Read:       $BL_READ MiB in $TLOOP s"
   echo "Write:      $BL_WRITE MiB in $TLOOP s"
   echo
   echo "Read Rate:  $R_SPEED MiB/s ( Avg: $R_SPEED_AVG, Max: $R_SPEED_MAX )"
   echo "Write Rate: $W_SPEED MiB/s ( Avg: $W_SPEED_AVG, Max: $W_SPEED_MAX )"
   echo
   echo "Done: $GB_DONE GiB / $PBASE GiB ($PDONE %)"
   [ `echo "scale=2; $ETA > 0"|bc` -eq 1 ] && printf "ETA: %02d:%02d:%05.2f (%.2fs)\n" $ETA_H $ETA_M $ETA_S $ETA
   echo "Elapsed: `ps -p $PID -o etime=`"

   T1=`date +%s.%N`
   sleep $DELAY
   B_READ_PREV=$B_READ
   B_WRITE_PREV=$B_WRITE
   ((count++))
done
echo "----- Finished -------------------------------------------------------------------"

Si su versión de rsyncno acepta la --info=progress2opción, puede usar tqdm:

Instalar:

pip install tqdm

Usar:

$ rsync -av / source / dest | tqdm --unit_scale | wc -l
10.0Mit [00:02, 3.58Mit / s]

Quizás puedas combinar pvcon rsync. Especialmente el parámetro --sizepodría ser útil. Echando un vistazo a los documentos, algo así pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/pathdebería funcionar.

Aquí encontrarás los documentos y el software.

No he intentado esto por mi cuenta.

Podría llegar un poco tarde aquí, pero los futuros buscadores de respuestas podrían beneficiarse.

Esto también me estaba molestando, así que pensé en ensuciarme y escribir mi primer guión. El paquete zenity debe estar instalado (sudo apt-get install zenity), pero estoy seguro de que probablemente ya esté allí. Además, uso wmctrl (control del administrador de ventanas) para cambiar el título del cuadro de diálogo de progreso cuando está hecho, es fácilmente instalable pero no hará la diferencia si no lo hace. Solo me gusta ver cuándo está hecho en mi panel.

El script básicamente solicita un directorio de origen y destino, calcula el porcentaje del destino sobre el tamaño del origen utilizando du y muestra una barra de progreso.

Nota: Esto solo funciona para la sincronización completa de directorio / archivo (generalmente lo uso para hacer copias de seguridad de la memoria caché de apt), por lo que no hay opción --exclude = / file / in / Source-directory. Tampoco funcionará si hay archivos / directorios en el directorio de destino que no están en el directorio de origen. No estoy seguro de si funciona para fuentes / destinos remotos ya que nunca he tenido la necesidad o los recursos para probarlo.

PD. Este script puede estar muy mal escrito o muy ineficiente (script-virgin aquí), pero al menos sirve para su propósito y, por supuesto, puede editarlo y mejorarlo para satisfacer sus necesidades. PSS Además, no pude obtener el botón cancelar para matar a rsync, así que lo eliminé.

    #!/bin/bash
set -e;

WELC="Running RsyncP as $USER";

function echo_progress()
{
    while (($TRANSFER_SIZE > 1000));    
    do  
        DEST_SIZE=$(du -s $DEST_FOLDER | cut -d / -f 1); 
        ((TRANSFER_SIZE=$SOURCE_SIZE-DEST_SIZE)); 
        PROGRESS_PERC=$((DEST_SIZE*100/SOURCE_SIZE));
        echo $PROGRESS_PERC;
        sleep 0.1s;
    done;
    echo 100;
    zenity --info --width=250 --title=RsyncP --text="File syncing complete!";
}

function get_input()
{
    dirs=$(zenity --forms --width=500 --title="RsyncP" --text="Enter source And destination directories" --add-entry="Source: " --add-entry="Destination: " --separator=" ");

    SOURCE_FOLDER=$(echo $dirs | cut -d' ' -f 1);
    DEST_FOLDER=$(echo $dirs | cut -d' ' -f 2);

    OPTIONS=-$(zenity --list --title="RsyncP Options" --text="Select rsync options" --separator='' --height=470 --width=470 --checklist --column "activate" --column "Option" --column "Description" FALSE v "Verbose (Terminal only)" FALSE q "Quiet, supress non-error messages (Terminal only)" FALSE P "Progress (Terminal only)" FALSE a "Archive (lrpog)" TRUE r "Recurse into directories" FALSE p "Preserve permissions" FALSE o "Preserve owner" FALSE g "Preserve group" FALSE l "Copy symlinks as symlinks");

    zenity --question --no-wrap --title="RsyncP" --width=500 --text="rsync  $OPTIONS $SOURCE_FOLDER $DEST_FOLDER\nDo you want to continue?";

    SOURCE_SIZE=$(du -s $SOURCE_FOLDER | cut -d / -f 1); 
    DEST_SIZE=$(du -s $DEST_FOLDER | cut -d / -f 1); 
    PROGRESS_PERC=$((DEST_SIZE*100/SOURCE_SIZE)); 
    TRANSFER_SIZE=1001;
}

if [ "$(id -u)" != "0" ]; then
    zenity --question --title=RsyncP --text="$WELC, Continue?";
    get_input;
    rsync  $OPTIONS $SOURCE_FOLDER $DEST_FOLDER & 
    echo_progress | zenity --progress --title=RsyncP --no-cancel --auto-close --text="Copying from \n$SOURCE_FOLDER to \n$DEST_FOLDER" ;

else            
    zenity --question --title=RsyncP --text="$WELC, Continue?";
    get_input; 
    sudo rsync  $OPTIONS $SOURCE_FOLDER $DEST_FOLDER & 
    echo_progress | zenity --progress --title=RsyncP --no-cancel --auto-close --text="Copying from \n$SOURCE_FOLDER to \n$DEST_FOLDER" ;
fi