Mostrando o progresso total no rsync: é possível?

229

Eu já procurei por essa opção, mas encontrei apenas soluções que envolvem correções personalizadas . O fato de ele não aparecer em --help e nenhuma informação adicional pode ser encontrada provavelmente indica que as respostas são 'não', mas eu gostaria de ver isso confirmado.

É possível mostrar o progresso total da transferência de arquivos com o rsync?

Aron Rotteveel
fonte
22
Desde o rsync 3.1.0, agora existe um progresso básico básico na transferência de arquivos. Consulte a resposta serverfault.com/a/441724/107793 para obter detalhes.
Florian Feldhaus 14/01
14
Por favor, altere a resposta aceita. @ A resposta de David é completamente inútil.
Navin
Veja também unix.stackexchange.com/q/215271/9454
Martin Schröder

Respostas:

36

danakim está correto. Não há maneiras triviais de adicionar um indicador de progresso total.

A razão para isso é que, quando o rsync examina uma lista de arquivos a serem sincronizados, ele não sabe antecipadamente quais arquivos precisarão ser alterados. Se você estiver realizando transferências delta, os próprios deltas deverão ser calculados com antecedência para fornecer uma imagem total do trabalho que precisa ser realizado.

Em outras palavras, a maneira mais fácil de calcular quanto trabalho deve ser feito é realmente fazê-lo.

David Mackintosh
fonte
42
Você ainda pode ter um indicador simples como (dados transferidos + dados ignorados) / (total de dados na fonte) ou (# arquivos transferidos ou ignorados) / (# arquivos na fonte). Não será particularmente preciso, mas daria uma ideia. Bom para quando você está fazendo uma grande transferência no final do dia, e você está se perguntando se a esperar e desligue o computador, ou deixá-lo correr para a noite ...
naught101
3
Não acredito que essa conclusão esteja certa. Eu acho que @ naught101 está sendo mais justo com a pergunta, e acho que predicar uma resposta para não usar --size-onlyou algo parecido é ainda mais impreciso.
Evan Carroll
2
No momento em que escrevi a resposta, ela era precisa - o rsync não tinha um mecanismo para um indicador de progresso total. E sim, você poderia escrever o seu próprio, mas pouquíssimas pessoas o escreveriam.
David Mackintosh
6
Comentário para os recém-chegados: Agora é possível: serverfault.com/a/441724/422003
imposeren
o uso de duas passagens, primeiro com "--dry-run" (contagem total esperada de arquivos) e segundo com saída detalhada registrada em um arquivo (e linhas de contagem concluídas ou usando um pipe para 'pv'), permite estimar facilmente a conclusão. A desvantagem é verificar grandes diretórios aninhados duas vezes. Dependendo da necessidade, isto é, garantindo migrações seguras de dados do cliente, isso pode ser aceitável.
ives
377

Agora existe uma maneira oficial de fazer isso no rsync (versão 3.1.0, protocolo 31, testado com 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)

Tentei com minha /usrpasta porque queria esse recurso para transferir sistemas de arquivos inteiros e /usrparecia ser um bom exemplo representativo.

A --info=progress2dá uma percentagem global agradável, mesmo se é apenas um valor parcial. Na verdade, minha /usrpasta tem mais de 6 shows:

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

e rsyncdemorou muito tempo para digitalizar tudo. Então, quase o tempo todo, a porcentagem que eu vi foi cerca de 90% concluída, mas, no entanto, é reconfortante ver que algo está sendo copiado :)

Referências:

Avio
fonte
19
Observe que isso chegou ao 3.1.0. Também é importante observar que isso não é necessariamente preciso na perspectiva do tempo. Ele mostra essencialmente a quantidade de dados que foi verificada na extremidade remota. E a taxa é a taxa na qual os dados estão sendo aprendidos para estarem corretos no lado remoto (se já era assim ou se os novos dados foram transferidos e os tornaram corretos). Portanto, embora seja muito útil, você precisa entender as advertências.
Kevin Cox
15
Para usar isso em OSX com homebrew "cerveja torneira homebrew / dupes; bebida instalar rsync"
Matt portador
18
Vale notar que --info=progress2não funciona com-v
sanmai
42
Adicione a --no-i-ropção também, para rsyncnão digitalizar incrementalmente, mas completamente antes de copiar e saber + exibe quanto trabalho resta.
19415 Alex
16
Observe que você pode usar --human-readable(ou -h) para ver o tamanho total em MB / GB .. em andamento.
Nux
45

Você pode com 'pv' ( apt-get install pvcom Debian e ubuntu). Eu recomendo monitorar o número de arquivos transferidos, pois a quantidade de dados transferidos não está correlacionada com o tamanho dos arquivos, mas no delta entre a origem e o destino. E a contagem de arquivos contará o mesmo progresso para um delta grande e outro com delta pequeno. O que significa que, em qualquer caso, a estimativa da ETA pode estar distante. O ETA baseado em tamanho funciona apenas se o seu destino estiver vazio, neste caso delta == tamanho da fonte.

A idéia geral é emitir uma linha por arquivo 'transferido' do rsync e contar essas linhas com 'pv':

rsync -ai / source remote: / dest | pv -les [número de arquivos]> / dev / null

Eu costumo fazer backup de sistemas de arquivos inteiros (por várias razões); nesse caso, você pode usar o mais barato dfpara obter o número de arquivos (em vez de duou findque atravessará sua hierarquia de fontes outra vez após o rsync fazer isso). A opção -x parece garantir que o rsync permaneça no mesmo sistema de arquivos de origem (e não siga outras montagens internas):

rsync -aix / source remote: / dest | pv -les $ (df -i / fonte | perl -ane 'imprime $ F [2] se $ F [5] = ~ m: ^ /:')> / dev / null

Se você deseja contar arquivos no / source de uma maneira geral, use find /source|wc -l(aviso novamente: pode ser lento e pesado na E / S).

zerodeux
fonte
1
Como zerodeuz especificou, use "df" somente quando você estiver sincronizando a partição inteira, pois df -i /sourceobtém o número de inodes (arquivos) de toda a partição na qual / source reside. Caso contrário, use 'find' para contar arquivos dentro de um diretório dentro da expressão "$ ()".
Lepe
1
Uma alternativa para duou find- digamos que você está terminando uma cópia incompleta ou fazendo uma atualização no local com exclusões - é usar rsync -ai --dry-runpara obter a mesma lista de arquivos a principal corrida estará passando parapv
Izkata
32

O seguinte se aplica ao rsync versão 3.0.0 e superior. As opções descritas abaixo foram introduzidas nessa versão em 1º de março de 2008.

Juntamente com --info = progress2, você também pode usar a opção --no-inc-recursive (ou seu apelido mais curto --no-ir ) para desativar a recursão incremental.

Isso criará a lista de arquivos inteira no início, em vez de descobrir mais arquivos de forma incremental à medida que a transferência continuar. Como ele conhecerá todos os arquivos antes de iniciar, fornecerá um relatório melhor do progresso geral. Isso se aplica ao número de arquivos - não informa nenhum progresso com base no tamanho dos arquivos.

Isso envolve uma troca. Criar a lista inteira de arquivos com antecedência é mais dispendioso em termos de memória e pode atrasar significativamente o início da transferência real. Como seria de esperar, quanto mais arquivos houver, maior será o atraso e mais memória será necessária.

O seguinte é do manual do rsync (fonte - http://rsync.samba.org/ftp/rsync/rsync.html ):

-r, --recursive

Isso diz ao rsync para copiar diretórios recursivamente. Veja também --dirs (-d). A partir do rsync 3.0.0, o algoritmo recursivo usado agora é uma varredura incremental que usa muito menos memória do que antes e inicia a transferência após a varredura dos primeiros diretórios. Essa varredura incremental afeta apenas nosso algoritmo de recursão e não altera uma transferência não recursiva. Também é possível apenas quando as duas extremidades da transferência são pelo menos a versão 3.0.0.

Algumas opções exigem que o rsync conheça a lista completa de arquivos, portanto, essas opções desativam o modo de recursão incremental. Eles incluem: --delete-before, --delete-after, --une-empty-dirs e --delay-updates. Por esse motivo, o modo de exclusão padrão quando você especifica --delete agora é --delete-during quando ambas as extremidades da conexão são pelo menos 3.0.0 (use --del ou --delete-durante para solicitar este modo de exclusão aprimorado explicitamente). Veja também a opção --delete-delay que é uma escolha melhor do que usar --delete-after.

A recursão incremental pode ser desativada usando a opção --no-inc-recursive ou seu alias mais curto --no-ir .

Consulte também https://rsync.samba.org para obter diferenças de versão específicas (role para baixo e confira os links Notícias de Lançamento).

Nate
fonte
3
Obrigado por isso, as outras respostas resultam em uma% de idade que continua subindo e descendo!
Artfulrobot
28

Para transferências longas, fico feliz em correr du -sdos dois lados. Mesmo watch -n1 du -sse eu me sentir realmente ansioso.

watchexecuta um comando ( du -saqui) periodicamente (a cada 1 segundo aqui) e mostra a saída em tela cheia.

funollet
fonte
4
Obrigado pelo exemplo do watchcomando!
Cam
2
// , Esperto! De acordo com linfo.org: "O comando du (isto é, uso do disco) relata os tamanhos das árvores de diretórios, incluindo todo o seu conteúdo e os tamanhos dos arquivos individuais. Isso o torna útil para rastrear os porcos espaciais, como diretórios e arquivos. que consomem grandes ou excessivas quantidades de espaço em uma unidade de disco rígido (HDD) ou em outra mídia de armazenamento ".
21715 Nathan Basanese
10
Não sei que tipo de transferências longas você faz, onde du é viável. du é lento como o inferno quando o resultado estará em TB e M de arquivos.
Ninguém
2
Para minhas "transferências longas", uma operação du leva cerca de uma hora para concluir, durante a qual o rsync está executando muito mais devagar, porque eles estão brigando pelo acesso ao disco.
Abhi Beckert
12

Basicamente não. Você só pode mostrar o progresso por arquivo com o sinalizador --progress, mas é isso.

Acho que você pode escrever um invólucro em volta dele ou usar qualquer um dos patches que você já encontra, mas você deve se perguntar se realmente vale a pena. Você realmente precisa de um progresso total para o rsync?

danakim
fonte
Aqui está um script de wrapper que mostra o progresso total e o progresso do arquivo como uma boa barra de progresso: gist.github.com/JohannesBuchner/4d61eb5a42aeaad6ce90
j13r
1
Você pode mudar a maneira de --progresstrabalhar --info=progress2, ele mostrará o progresso global. Você vai precisar para desativar o algoritmo recursivo incremental para que possa ser útil, por isso--info=progress2 --no-inc-recursive
mat
@ j13r, você também pode compartilhar essa essência como resposta! sua ótima opção!
22417 skywinder
8

Usei a resposta do zerodeux e escrevi meu próprio pequeno 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
fonte
7

Também procurei como mostrar o progresso total com o rsync e encontrei um respondedor útil desta postagem: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

Basicamente, você pode usar --info = progress2 na versão dev do rsync 3.1.0 . Aqui está o que o documento disse:

Há também uma opção --info = progress2 que gera estatísticas com base em toda a transferência, em vez de arquivos individuais. Use esse sinalizador sem emitir um nome de arquivo (por exemplo, evite -v ou especifique --info = name0 se quiser ver como está a transferência sem rolar a tela com muitos nomes. (Você não precisa especificar - opção progress para usar --info = progress2.)

Zhenyi Zhang
fonte
1
--info=name0é ouro 🌈👑
ipatch
6

Usei a resposta do zerodeux e escrevi meu próprio 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"

Alterei o teste seco TODO para

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

Ele encontra o número de arquivos muito rápido!

user151779
fonte
encontrar obras de modo muito melhor do que rsync --dry-run!
hopeseekr
4
findsó funciona se você estiver localizando rsync. rsync --dry-runtrabalha com fontes remotas também ...
voretaq7
6

Se você não possui o rsync mais recente (por exemplo, o OS X tem 2.6.9) e não pode usá-lo --info=progress2, aqui está outra alternativa para se salvar das páginas de rolagem de texto em andamento:

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

Isso imprimirá, em uma linha, o nome do arquivo mais recente sendo transferido:

Transferring: the-latest.file

Aral Balkan
fonte
4

Usar

lsof -ad3-999 -c rsync

Para ver quais arquivos o rsync atualmente abriu (mostrará o tamanho do arquivo) o rsync copia localmente em um arquivo oculto

Cloom Magoo
fonte
Eu queria postar isso, for i in $(pgrep 'rsync'); do ls -l /proc/$i/fd; donemas sua solução é mais simples.
Aalex Gabi
4

Gostaria de fazer um comentário, mas não tenho reputação suficiente. Em resposta ao comentário de naught101 na resposta escolhida, a opção --progress mostra quantos arquivos foram transferidos do valor total a ser transferido. Eu não percebi isso até olhar para este post e analisar a saída com mais cuidado.

A estatística 'verificar' mostra quantos arquivos são deixados de fora do total. Isso é mais útil ao sincronizar para um novo destino, para que você saiba que todos os arquivos serão totalmente copiados.

Na página do 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
fonte
3

Observe a ressalva aqui que mesmo --info = progress2 não é totalmente confiável, pois essa porcentagem é baseada no número de arquivos que o rsync 'conhece' no momento em que o progresso está sendo exibido. Esse não é necessariamente o número total de arquivos que precisavam ser sincronizados (por exemplo, se ele descobrir um grande número de arquivos grandes em um diretório profundamente aninhado). Uma maneira de garantir que --info = progress2 não retorne na indicação de progresso seria forçar o rsync a varrer todos os diretórios recursivamente antes de iniciar a sincronização (em vez de seu comportamento padrão de fazer uma varredura incremental recursiva), fornecendo também a opção --no-inc-recursive. Observe, no entanto, que esta opção também aumentará o uso da memória rsync e o tempo de execução.

lonetwin
fonte
A recursão incremental pode ser desativada usando a --no-inc-recursiveopção ou seu --no-i-ralias mais curto . (Ver outra resposta)
koppor 13/01
2

Eu uso um script que extrai as informações de / proc // io para o processo rsync (ou qualquer outro processo) e saber que o valor total a ser transferido calcula o progresso.

#!/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
fonte
2

Se sua versão do rsyncnão aceitar a --info=progress2opção, você poderá usar tqdm:

Para instalar:

pip install tqdm

Usar:

$ rsync -av / fonte / dest | tqdm --unit_scale | wc -l
10,0Mit [00:02, 3,58Mit / s]
ostrokach
fonte
1

Talvez você possa combinar pvcom o rsync. Especialmente o parâmetro --sizepoderia ser útil. Dando uma olhada nos documentos, algo como pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/pathdeve funcionar.

Aqui você encontrará os documentos e o software.

Ainda não tentei isso sozinho.

cristão
fonte
1

Pode ser um pouco tarde aqui, mas os futuros candidatos a respostas podem se beneficiar.

Isso estava me incomodando também, então eu pensei em ficar suja e escrever meu primeiro script. O pacote zenity deve estar instalado (sudo apt-get install zenity), mas tenho certeza de que provavelmente já estará lá. Além disso, eu uso o wmctrl (controle do gerenciador de janelas) para alterar o título da caixa de diálogo de progresso quando terminar; é facilmente instalável, mas não fará diferença se você não o fizer. Eu só gosto de ver quando é feito no meu painel.

O script basicamente solicita um diretório de origem e destino, calcula a porcentagem do destino sobre o tamanho da fonte usando du e exibe uma barra de progresso.

Nota: Isso funciona apenas para a sincronização completa de diretório / arquivo (eu normalmente o uso para fazer backups do apt cache), portanto, não existe --exclude = / file / in / opção Diretório de origem. Também não funcionará se houver arquivos / diretórios no diretório de destino que não estão no diretório de origem. Não tenho certeza se funciona para fontes / destinos remotos, pois nunca tive a necessidade ou os recursos para testá-lo.

PS. Esse script pode ser muito mal escrito ou muito ineficiente (virgem de script aqui), mas pelo menos serve ao seu objetivo e, é claro, você pode editá-lo e melhorá-lo para atender às suas necessidades. PSS. Além disso, não foi possível obter o botão Cancelar para matar o rsync, então eu apenas o removi.

    #!/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
fonte
Dê uma olhada no YAD. É um garfo (reescrever?) Do Zenity e é como o Zenity ... mas em esteróides. Meus scripts o utilizam para tudo o que ocorre com o Zenity, já que eu tenho uma máquina com apenas o Zenity. As opções de comando são semelhantes o suficiente para isso, mas você perde muitas sutilezas com o Zenity.
DocSalvager