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

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?

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.

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:

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

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

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

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.

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?

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"

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

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!

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

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

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.

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.

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

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]

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.

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