Mostrando progreso total en rsync: ¿es posible?

232

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?

Aron Rotteveel
fuente
22
Desde rsync 3.1.0 ahora se incluye un progreso básico total de transferencia de archivos incluido. Consulte la respuesta serverfault.com/a/441724/107793 para más detalles.
Florian Feldhaus
14
Por favor cambie la respuesta aceptada. @ La respuesta de David es completamente inútil.
Navin
Ver también unix.stackexchange.com/q/215271/9454
Martin Schröder

Respuestas:

36

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.

David Mackintosh
fuente
42
Todavía podría tener un indicador simple como (datos transferidos + datos omitidos) / (datos totales en la fuente) o (# archivos transferidos u omitidos) / (# archivos en la fuente). No va a ser particularmente preciso, pero daría una idea. Bueno para cuando haces una gran transferencia al final del día, y te preguntas si esperar y apagar la computadora, o dejarla funcionar por la noche ...
nada101
3
No creo que esa conclusión sea correcta. Creo que @ naught101 está siendo más justo con la pregunta, y creo que predicar una respuesta sobre no usar --size-onlyo algo similar es aún más inexacto.
Evan Carroll
2
En el momento en que escribí la respuesta, era precisa: rsync no tenía un mecanismo para un indicador de progreso total. Y sí, podrías escribir el tuyo, pero muy pocas personas lo harían.
David Mackintosh
66
Comentario para los recién llegados: ahora es posible: serverfault.com/a/441724/422003
imposeren
El uso de dos pasadas, primero con "--dry-run" (recuento total esperado de archivos) y segundo con resultados detallados registrados en un archivo (y contando líneas completas o usando una tubería para 'pv'), permite estimar fácilmente la finalización. La desventaja es escanear directorios anidados grandes dos veces. Dependiendo de la necesidad, es decir, garantizar la seguridad de las migraciones de datos del cliente, esto podría ser aceptable.
ives
379

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

Avio
fuente
19
Tenga en cuenta que esto ha aterrizado en 3.1.0. También es importante tener en cuenta que esto no es necesariamente preciso en la perspectiva del tiempo. Básicamente, muestra la cantidad de datos que se verificó que existe en el extremo remoto. Y la tasa es la tasa a la que se está aprendiendo que los datos son correctos en el extremo remoto (ya sea de esa manera o si los nuevos datos se transfirieron y se corrigieron). Entonces, aunque es muy útil, debe comprender las advertencias.
Kevin Cox
15
Para usar esto en OSX con homebrew, "brew tap homebrew / dupes; brew install rsync"
Matt Carrier
18
Vale la pena señalar que eso --info=progress2no funciona-v
sanmai
42
Agregue el --no-i-rinterruptor también, de modo rsyncque no escanee de forma incremental sino completa antes de copiar y sepa + muestra cuánto trabajo queda.
Alex
16
Tenga en cuenta que puede usar --human-readable(o -h) para ver el tamaño total en MB / GB ... en progreso.
Nux
46

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).

zerodeux
fuente
1
Como zerodeuz especificó, use "df" solo cuando está sincronizando toda la partición, ya que df -i /sourceobtiene el número de inodes (archivos) de toda la partición en la que reside / source. De lo contrario, use 'find' para contar archivos dentro de un directorio dentro de la expresión "$ ()".
lepe
1
Una alternativa a duo find- digamos que usted está terminando una copia incompleta o hacer una actualización en contexto con eliminaciones - es utilizar rsync -ai --dry-runpara obtener la misma lista de archivos del proceso principal se pasa apv
Izkata
32

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).

Nate
fuente
3
Gracias por esto, ¡las otras respuestas dan como resultado un% de edad que sigue subiendo y bajando!
artfulrobot
28

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.

funollet
fuente
44
Gracias por el ejemplo del watchcomando!
Cam
2
// ¡listo! De acuerdo con linfo.org: "El comando du (es decir, el uso del disco) informa los tamaños de los árboles de directorios que incluyen todo su contenido y los tamaños de los archivos individuales. Esto lo hace útil para rastrear cerdos espaciales, es decir, directorios y archivos que consumen grandes o excesivas cantidades de espacio en una unidad de disco duro (HDD) u otro medio de almacenamiento ".
Nathan Basanese
10
No sé qué tipo de transferencias largas haces, dónde du es viable. du es lento como el infierno cuando el resultado estará en TB y M de archivos.
Nadie
2
Para mis "transferencias largas", una operación du tarda aproximadamente una hora en completarse, durante la cual rsync se ejecuta mucho más lentamente, porque están luchando por el acceso al disco.
Abhi Beckert
12

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?

danakim
fuente
Aquí hay un script de contenedor que muestra el progreso total y el progreso del archivo como una buena barra de progreso: gist.github.com/JohannesBuchner/4d61eb5a42aeaad6ce90
j13r
1
Puede cambiar la forma de --progresstrabajar --info=progress2, le mostrará el progreso global. Usted tendrá que desactivar el algoritmo recursivo incrementales para que sea útil, por lo que--info=progress2 --no-inc-recursive
estera
@ j13r, ¡también puedes compartir esta esencia como respuesta! ¡Es una gran opción!
skywinder
8

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"
FloHallo
fuente
7

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.)

Zhenyi Zhang
fuente
1
--info=name0es oro 🌈👑
ipatch
6

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!

usuario151779
fuente
encontrar obras de manera mucho mejor que rsync --dry-run!
hopeseekr
44
findsolo funciona si estás rsynclocalmente. rsync --dry-runtambién funciona con fuentes remotas ...
voretaq7
6

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

Aral Balkan
fuente
4

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

Cloom Magoo
fuente
Quería publicar esto, for i in $(pgrep 'rsync'); do ls -l /proc/$i/fd; donepero su solución es más simple.
Aalex Gabi
4

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.
Michael S
fuente
3

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.

solitario
fuente
La recursividad incremental se puede deshabilitar usando la --no-inc-recursiveopción o su --no-i-ralias más corto . (Ver otra respuesta)
koppor
2

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 -------------------------------------------------------------------"
nito
fuente
2

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]
Ostrokach
fuente
1

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.

cristiano
fuente
1

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
neill_L
fuente
Echa un vistazo a YAD. Es un tenedor (¿reescribir?) De Zenity y es como Zenity ... pero con esteroides. Mis scripts lo usan para todo con respaldo a Zenity ya que tengo una máquina con solo Zenity. Las opciones de comando son lo suficientemente similares para eso, pero solo pierdes muchas sutilezas con Zenity.
DocSalvager