Mostrare progressi totali in rsync: è possibile?

Ho già cercato questa opzione, ma ho trovato solo soluzioni che prevedono patch personalizzate . Il fatto che non venga mostrato in --help e che non sia possibile trovare ulteriori informazioni probabilmente indica che le risposte sono "no", ma mi piacerebbe vederlo confermato.

È possibile mostrare l'avanzamento del trasferimento di file totale con rsync?

danakim è corretto. Non ci sono modi banali per aggiungere un indicatore di progresso totale.

La ragione di ciò è che quando rsync guarda un elenco di file da sincronizzare, non sa in anticipo quali file dovranno cambiare. Se si stanno effettuando trasferimenti delta, i delta stessi devono essere calcolati in anticipo per fornire un quadro complessivo del lavoro che deve essere fatto.

In altre parole, il modo più semplice per calcolare la quantità di lavoro da svolgere è effettivamente farlo.

Esiste ora un modo ufficiale per farlo in rsync (versione 3.1.0 protocollo versione 31, testato 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)

Ho provato con la mia /usrcartella perché volevo questa funzione per trasferire interi filesystem e /usrsembrava essere un buon esempio rappresentativo.

Il --info=progress2dà una bella percentuale complessiva, anche se è solo un valore parziale. In effetti, la mia /usrcartella è più di 6 concerti:

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

e ci è rsyncvoluto molto tempo per scansionare tutto. Quindi quasi sempre la percentuale che ho visto è stata completata per circa il 90%, ma è comunque confortante vedere che qualcosa viene copiato :)

Riferimenti:

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

Puoi farlo con 'pv' ( apt-get install pvcon Debian e Ubuntu). Consiglio di monitorare il numero di file trasferiti, poiché la quantità di dati trasferiti non è correlata alla dimensione dei file ma al delta tra l'origine e la destinazione. E il conteggio dei file conterà gli stessi progressi per un delta grande e un altro con delta piccolo. Ciò significa che in ogni caso la stima dell'ETA potrebbe essere lontana. L'ETA basato sulla dimensione funziona solo se la destinazione è vuota, in questo caso delta == dimensione della fonte.

L'idea generale è quella di emettere una riga per file 'trasferito' da rsync e contare quelle righe con 'pv':

rsync -ai / source remote: / dest | pv -les [numero di file]> / dev / null

Tendo a eseguire il backup di interi file system (per diversi motivi), in questo caso è possibile utilizzare il più economico dfper ottenere il numero di file (piuttosto che duo findche attraverserà la gerarchia dei sorgenti un'altra volta dopo che lo ha fatto rsync). L'opzione -x sembra assicurarsi che rsync rimanga sullo stesso filesystem di origine (e non segua altri mount interni):

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

Se vuoi contare i file in / source in modo generale, usa find /source|wc -l(di nuovo avviso: potrebbe essere lento e pesante su I / O).

Quanto segue si applica a rsync versione 3.0.0 e successive. Le opzioni descritte di seguito sono state introdotte in quella versione il 1 ° marzo 2008.

Insieme a --info = progress2 puoi anche usare l' opzione --no-inc-recursive (o il suo alias --no-ir più corto ) per disabilitare la ricorsione incrementale.

In questo modo verrà creato l'intero elenco di file all'inizio, anziché scoprire in modo incrementale più file durante il trasferimento. Dal momento che conoscerà tutti i file prima di iniziare, fornirà un rapporto migliore sui progressi complessivi. Questo vale per il numero di file: non segnala alcun progresso in base alle dimensioni dei file.

Ciò comporta un compromesso. La creazione anticipata dell'intero elenco di file è più costosa in termini di memoria e può ritardare in modo significativo l'inizio del trasferimento effettivo. Come ci si aspetterebbe, maggiore è il numero di file, maggiore sarà il ritardo e maggiore sarà la memoria necessaria.

Quanto segue è dal manuale di rsync (fonte - http://rsync.samba.org/ftp/rsync/rsync.html ):

-r, - ricorsivo

Questo dice a rsync di copiare ricorsivamente le directory. Vedi anche --dirs (-d). A partire da rsync 3.0.0, l'algoritmo ricorsivo utilizzato è ora una scansione incrementale che utilizza molta meno memoria rispetto a prima e inizia il trasferimento dopo che è stata completata la scansione delle prime directory. Questa scansione incrementale influisce solo sul nostro algoritmo di ricorsione e non modifica un trasferimento non ricorsivo. È anche possibile solo quando entrambe le estremità del trasferimento sono almeno la versione 3.0.0.

Alcune opzioni richiedono che rsync conosca l'elenco completo dei file, quindi queste opzioni disabilitano la modalità di ricorsione incrementale. Questi includono: --delete-before, --delete-after, --prune-empty-dirs e --delay-updates. Per questo motivo, la modalità di eliminazione predefinita quando si specifica --delete è ora --delete-durante quando entrambe le estremità della connessione sono almeno 3.0.0 (utilizzare --del o --delete-durante per richiedere questa modalità di eliminazione migliorata esplicitamente). Vedi anche l'opzione --delete-delay che è una scelta migliore rispetto all'utilizzo di --delete-after.

La ricorsione incrementale può essere disabilitata usando l' opzione --no-inc-ricorsive o il suo alias --no-ir più breve .

Vedi anche https://rsync.samba.org per differenze di versione specifiche (scorri verso il basso e controlla i collegamenti di Release News).

Per i trasferimenti lunghi, sono felice di correre du -ssu entrambi i lati. Anche watch -n1 du -sse mi sento davvero ansioso.

watchesegue un comando ( du -squi) periodicamente (ogni 1 secondo qui) e mostra l'output a schermo intero.

Fondamentalmente no. Puoi mostrare i progressi solo per file con il flag --progress, ma questo è tutto.

Immagino che tu possa scrivere un wrapper o usarne una qualsiasi delle patch che trovi già, ma devi chiederti se ne vale davvero la pena, hai davvero bisogno di un progresso totale per rsync?

Ho usato la risposta di zerodeux e ho scritto il mio piccolo 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"

Ho anche cercato come mostrare i progressi totali con rsync e ho trovato un'utile risposta da questo post: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

Fondamentalmente, puoi usare --info = progress2 nella versione dev di rsync 3.1.0 . Ecco cosa ha detto il doc :

Esiste anche un'opzione --info = progress2 che fornisce statistiche basate sull'intero trasferimento, anziché sui singoli file. Usa questo flag senza mostrare un nome di file (ad esempio, evita -v o specifica --info = nome0 se vuoi vedere come sta andando il trasferimento senza scorrere lo schermo con molti nomi. (Non è necessario specificare il - opzione progress per usare --info = progress2.)

Ho usato la risposta di zerodeux e ho scritto il mio piccolo 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"

Ho cambiato la corsa a secco TODO in

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

Trova il numero di file molto velocemente!

Se non disponi dell'ultima rsync (ad esempio, OS X ha 2.6.9) e non puoi utilizzarla --info=progress2, ecco un'altra alternativa per salvarti dalle pagine di testo scorrevole in corso:

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

Che stamperà, su una riga, il nome dell'ultimo file trasferito:

Transferring: the-latest.file

Uso

lsof -ad3-999 -c rsync

Per vedere quali file rsync ha attualmente aperto (mostrerà le dimensioni del file) rsync copie in un file nascosto localmente

Lo farei un commento ma non ho abbastanza reputazione. In risposta al commento di naught101 alla risposta scelta, l'opzione --progress mostra quanti file sono stati trasferiti dall'importo totale da trasferire. Non me ne sono reso conto fino a quando non ho guardato questo post e guardato l'output con più attenzione.

La stat "da verificare" mostra quanti file sono rimasti fuori dal totale. Questo è di grande utilità quando si risincronizza su una nuova destinazione, quindi si sa che tutti i file verranno copiati completamente.

Dalla pagina man:

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.

Si noti qui che anche --info = progress2 non è del tutto affidabile poiché questa percentuale si basa sul numero di file di cui "sa" rsync nel momento in cui viene visualizzato l'avanzamento. Questo non è necessariamente il numero totale di file che devono essere sincronizzati (ad esempio, se rileva un numero elevato di file di grandi dimensioni in una directory profondamente nidificata). Un modo per garantire che --info = progress2 non "salti indietro" nell'indicazione di avanzamento sarebbe quello di forzare rsync a scansionare tutte le directory in modo ricorsivo prima di iniziare la sincronizzazione (invece del suo comportamento predefinito di fare una scansione progressivamente ricorsiva), fornendo anche l'opzione --no-inc-ricorsive. Si noti tuttavia che questa opzione aumenterà anche l'utilizzo della memoria rsync e il tempo di esecuzione.

Uso uno script che estrae le informazioni da / proc // io per il processo rsync (o qualsiasi altro processo per quella materia) e sapendo che l'importo totale da trasferire calcola l'avanzamento.

#!/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 la tua versione di rsyncnon accetta l' --info=progress2opzione, puoi utilizzare tqdm:

Installare:

pip install tqdm

Usare:

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

Forse puoi combinare pvcon rsync. Soprattutto il parametro --sizepotrebbe essere utile. Dando un'occhiata ai documenti, qualcosa del genere pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/pathdovrebbe funzionare.

Qui troverai i documenti e il software.

Non ho provato questo da solo.

Potrebbe essere un po 'tardi qui, ma i futuri cercatori di risposte potrebbero trarne beneficio.

Anche questo mi infastidiva, così ho pensato di sporcarmi e scrivere la mia prima sceneggiatura. Il pacchetto zenity deve essere installato (sudo apt-get install zenity), ma sono sicuro che probabilmente sarà già lì. Inoltre, utilizzo wmctrl (controllo del gestore delle finestre) per modificare il titolo della finestra di dialogo di avanzamento al termine, è facilmente installabile ma in caso contrario non farà alcuna differenza. Mi piace solo vedere quando è finito nel mio pannello.

Lo script richiede fondamentalmente una directory di origine e di destinazione, calcola la percentuale della destinazione rispetto alla dimensione della sorgente utilizzando du e visualizza una barra di avanzamento.

Nota: questo funziona solo per la sincronizzazione completa di directory / file (di solito lo uso per fare backup della cache apt), quindi nessuna opzione --exclude = / file / in / Source-directory. Inoltre non funzionerà se ci sono file / directory nella directory di destinazione non nella directory di origine. Non sono sicuro che funzioni per fonti / destinazioni remote poiché non ne ho mai avuto la necessità o le risorse per testarlo.

PS. Questo script potrebbe essere scritto molto male o molto inefficiente, (script-virgin qui), ma almeno serve al suo scopo e, naturalmente, sei il benvenuto per modificarlo e migliorarlo in base alle tue esigenze. PSS. Inoltre, non sono riuscito a ottenere il pulsante Annulla per uccidere rsync, quindi l'ho appena rimosso.

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