it-swarm.com.de

Gesamte Fortschritte in rsync anzeigen: Ist das möglich?

Ich habe bereits nach dieser Option gesucht, aber nur Lösungen gefunden, die benutzerdefiniertes Patchen beinhalten. Die Tatsache, dass es nicht in --help angezeigt wird und keine weiteren Informationen gefunden werden können, zeigt wahrscheinlich an, dass die Antworten "Nein" sind, aber ich würde dies gerne bestätigt sehen.

Ist es möglich, Gesamtfortschritt der Dateiübertragung anzuzeigen mit rsync?

260
Aron Rotteveel

Es gibt jetzt eine offizielle Möglichkeit, dies in rsync zu tun (Version 3.1.0 Protokoll Version 31, getestet mit 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)

Ich habe es mit meinem Ordner /usr Versucht, weil ich diese Funktion zum Übertragen ganzer Dateisysteme haben wollte, und /usr Schien ein gutes repräsentatives Beispiel zu sein.

Der --info=progress2 Gibt einen schönen Gesamtprozentsatz an, auch wenn es sich nur um einen Teilwert handelt. Tatsächlich umfasst mein Ordner /usr Mehr als 6 Gigs:

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

und rsync hat viel Zeit gebraucht, um alles zu scannen. Fast die ganze Zeit war der Prozentsatz, den ich gesehen habe, zu 90% abgeschlossen, aber es ist trotzdem beruhigend zu sehen, dass etwas kopiert wird :)

Verweise:

409
Avio

Sie können mit 'pv' (apt-get install pv mit Debian und Ubuntu). Ich empfehle, die Anzahl der übertragenen Dateien zu überwachen, da die übertragene Datenmenge nicht mit der Größe der Dateien korreliert, sondern im Delta zwischen Quelle und Ziel. Und das Zählen von Dateien zählt den gleichen Fortschritt für ein großes Delta und ein anderes mit kleinem Delta. Dies bedeutet, dass die ETA-Schätzung in jedem Fall weit entfernt sein könnte. Die größenbasierte ETA funktioniert nur, wenn Ihr Ziel leer ist, in diesem Fall Delta == Größe der Quelle.

Die allgemeine Idee ist, eine Zeile pro von rsync 'übertragener' Datei auszugeben und diese Zeilen mit 'pv' zu zählen:

 Rsync -ai/source remote:/dest | pv -les [Anzahl der Dateien]>/dev/null 

Ich neige dazu, ganze Dateisysteme zu sichern (aus mehreren Gründen). In diesem Fall können Sie das viel billigere df verwenden, um die Anzahl der Dateien zu erhalten (anstatt du oder find, die wird Ihre Quellhierarchie ein anderes Mal durchlaufen, nachdem rsync es getan hat). Die Option -x scheint sicherzustellen, dass rsync auf demselben Quelldateisystem bleibt (und nicht anderen inneren Mounts folgt):

 Rsync -aix/source remote:/dest | pv -les $ (df -i/source | Perl -ane 'drucke $ F [2], wenn $ F [5] = ~ m: ^ /:')>/dev/null 

Wenn Sie Dateien in/source allgemein zählen möchten, verwenden Sie find /source|wc -l (Warnung erneut: Möglicherweise ist die E/A langsam und stark).

48
zerodeux

Das Folgende gilt für rsync Version 3.0.0 und höher. Die unten beschriebenen Optionen wurden in dieser Version am 1. März 2008 eingeführt.

Zusammen mit - info = progress2 können Sie auch die Option - no-inc-recursive (oder den kürzeren Alias ​​- no-ir) verwenden ), um die inkrementelle Rekursion zu deaktivieren.

Dadurch wird die gesamte Dateiliste am Anfang erstellt, anstatt schrittweise weitere Dateien zu ermitteln, während die Übertragung fortgesetzt wird. Da alle Dateien vor dem Start bekannt sind, wird der Gesamtfortschritt besser dargestellt. Dies gilt für die Anzahl der Dateien. Es werden keine Fortschritte basierend auf der Dateigröße gemeldet.

Dies beinhaltet einen Kompromiss. Das Erstellen der gesamten Dateiliste im Voraus ist speicherintensiver und kann den Start der eigentlichen Übertragung erheblich verzögern. Wie zu erwarten ist, ist die Verzögerung umso länger und desto mehr Speicher wird benötigt, je mehr Dateien vorhanden sind.

Folgendes stammt aus dem rsync-Handbuch (Quelle - http://rsync.samba.org/ftp/rsync/rsync.html ):

- r, --recursive

Dies weist rsync an, Verzeichnisse rekursiv zu kopieren. Siehe auch --dirs (-d). Beginnend mit rsync 3.0.0 ist der verwendete rekursive Algorithmus nun ein inkrementeller Scan, der viel weniger Speicher als zuvor benötigt und die Übertragung beginnt, nachdem das Scannen der ersten Verzeichnisse abgeschlossen wurde. Dieser inkrementelle Scan wirkt sich nur auf unseren Rekursionsalgorithmus aus und ändert keine nicht rekursive Übertragung. Es ist auch nur möglich, wenn beide Enden der Übertragung mindestens Version 3.0.0 sind.

Bei einigen Optionen muss rsync die vollständige Dateiliste kennen, sodass diese Optionen den inkrementellen Rekursionsmodus deaktivieren. Dazu gehören: --delete-before, --delete-after, --Prune-empty-dirs und --delay-updates. Aus diesem Grund ist der Standardlöschmodus, wenn Sie --delete angeben, jetzt --delete-while, wenn beide Enden der Verbindung mindestens 3.0.0 sind (verwenden Sie --del oder --delete-while, um diesen verbesserten Löschmodus anzufordern ausdrücklich). Siehe auch die Option --delete-delay, die eine bessere Wahl ist als die Verwendung von --delete-after.

Inkrementelle Rekursion kann mit der Option - no-inc-recursive oder dem kürzeren Alias ​​- no-i-r deaktiviert werden.

Siehe auch https://rsync.samba.org für spezifische Versionsunterschiede (scrollen Sie nach unten und lesen Sie die Links zu Release News).

40
Nate

danakim ist richtig. Es gibt keine einfachen Möglichkeiten, einen Gesamtfortschrittsindikator hinzuzufügen.

Der Grund dafür ist, dass rsync beim Betrachten einer Liste der zu synchronisierenden Dateien nicht im Voraus weiß, welche Dateien geändert werden müssen. Wenn Sie Delta-Transfers durchführen, müssen die Deltas selbst im Voraus berechnet werden, um ein Gesamtbild der zu erledigenden Arbeiten zu erhalten.

Mit anderen Worten, der einfachste Weg, um zu berechnen, wie viel Arbeit dort zu erledigen ist, besteht darin, sie tatsächlich zu erledigen.

37

Bei langen Überweisungen bin ich mit dem Ausführen von du -s Auf beiden Seiten zufrieden. Sogar watch -n1 du -s, Wenn ich wirklich ängstlich bin.

watch führt regelmäßig (hier alle 1 Sekunde) einen Befehl (du -s hier) aus und zeigt die Ausgabe im Vollbildmodus an.

29
funollet

Grundsätzlich nein. Sie können den Fortschritt pro Datei nur mit dem Flag --progress anzeigen, aber das war es auch schon.

Ich vermute, Sie können einen Wrapper darum schreiben oder einen der bereits gefundenen Patches verwenden, aber Sie müssen sich fragen, ob es sich wirklich lohnt. Brauchen Sie tatsächlich einen vollständigen Fortschritt für rsync?

13
danakim

Ich habe die Antwort von zerodeux verwendet und mein eigenes kleines Bash-Skript geschrieben:

#!/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"
8
FloHallo

Ich habe auch gesucht, wie der Gesamtfortschritt mit rsync angezeigt werden kann, und in diesem Beitrag habe ich eine nützliche Antwort gefunden: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

Grundsätzlich können Sie -- info = progress2 in der Dev-Version von rsync 3.1.0 verwenden. Folgendes hat der doc gesagt:

Es gibt auch die Option --info = progress2, die Statistiken basierend auf der gesamten Übertragung und nicht auf einzelne Dateien ausgibt. Verwenden Sie dieses Flag, ohne einen Dateinamen auszugeben (z. B. vermeiden Sie -v oder geben Sie --info = name0 an, wenn Sie sehen möchten, wie die Übertragung abläuft, ohne den Bildschirm mit vielen Namen zu scrollen. (Sie müssen nicht - angeben. Fortschrittsoption zur Verwendung von --info = progress2.)

7
Zhenyi Zhang

Wenn Sie nicht über die neueste Version von rsync verfügen (z. B. OS X hat 2.6.9) und --info=progress2 Nicht verwenden können, haben Sie eine weitere Alternative, um sich vor Seiten mit Bildlauftext zu schützen:

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

Dadurch wird in einer Zeile der Name der zuletzt übertragenen Datei ausgedruckt:

Transferring: the-latest.file

6
Aral Balkan

Ich habe die Antwort von zerodeux verwendet und mein eigenes kleines BASH-Skript geschrieben:

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

Ich habe den TODO-Trockenlauf auf geändert

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

Es findet die Anzahl der Dateien sehr schnell!

6
user151779

Ich würde dies zu einem Kommentar machen, habe aber nicht genug Ruf. Als Antwort auf den Kommentar von naught101 zu der ausgewählten Antwort zeigt die Option --progress an, wie viele Dateien aus dem zu übertragenden Gesamtbetrag übertragen wurden. Ich habe das erst bemerkt, als ich mir diesen Beitrag und die Ausgabe genauer angesehen habe.

Die Statistik "Zu überprüfen" zeigt an, wie viele Dateien von der Gesamtzahl übrig bleiben. Dies ist am nützlichsten, wenn Sie mit einem neuen Ziel synchronisieren, damit Sie wissen, dass alle Dateien vollständig kopiert werden.

Von der Manpage:

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.
4
Michael S

Verwenden

lsof -ad3-999 -c rsync

Um zu sehen, welche Dateien rsync derzeit geöffnet hat (zeigt die Dateigröße an), kopiert rsync lokal in eine versteckte Datei

4
Cloom Magoo

Beachten Sie die Einschränkung hier, dass sogar --info = progress2 nicht ganz zuverlässig ist, da dieser Prozentsatz auf der Anzahl der Dateien basiert, die rsync zum Zeitpunkt der Anzeige des Fortschritts "kennt". Dies ist nicht unbedingt die Gesamtzahl der Dateien, die synchronisiert werden mussten (z. B. wenn eine große Anzahl großer Dateien in einem tief verschachtelten Verzeichnis erkannt wird). Eine Möglichkeit, um sicherzustellen, dass --info = progress2 in der Fortschrittsanzeige nicht zurückspringt, besteht darin, rsync zu zwingen, alle Verzeichnisse rekursiv zu scannen, bevor die Synchronisierung gestartet wird (anstelle des Standardverhaltens, einen inkrementell rekursiven Scan durchzuführen). indem Sie auch die Option --no-inc-recursive bereitstellen. Beachten Sie jedoch, dass diese Option auch die Auslastung und Laufzeit des rsync-Speichers erhöht.

3
lonetwin

Ich verwende ein Skript, das die Informationen aus/proc // io für den rsync-Prozess (oder einen anderen Prozess) extrahiert, und wenn ich weiß, dass der zu übertragende Gesamtbetrag den Fortschritt berechnet.

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

Wenn Ihre Version von rsync die Option --info=progress2 Nicht akzeptiert, können Sie tqdm verwenden:

Installieren:

pip install tqdm

Benutzen:

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

Vielleicht können Sie pv mit rsync kombinieren. Insbesondere der Parameter --size Könnte hilfreich sein. Wenn Sie sich die Dokumente ansehen, sollte so etwas wie pv --size $(du -sb . | awk '{print $1}') | rsync -av . Host:/your/path funktionieren.

Hier Hier finden Sie die Dokumente und Software.

Ich habe das nicht alleine versucht.

1
Christian

Könnte hier etwas spät sein, aber zukünftige Antwortsuchende könnten davon profitieren.

Das nervte mich auch, also dachte ich, ich würde mich schmutzig machen und mein erstes Skript schreiben. Das Paket zenity muss installiert sein (Sudo apt-get install zenity), aber ich bin mir sicher, dass es wahrscheinlich bereits vorhanden sein wird. Außerdem verwende ich wmctrl (Fenstermanagersteuerung), um den Titel des Fortschrittsdialogs zu ändern, wenn er fertig ist. Er ist leicht zu installieren, macht aber keinen Unterschied, wenn Sie dies nicht tun. Ich möchte nur sehen, wann es in meinem Panel fertig ist.

Das Skript fragt grundsätzlich nach einem Quell- und Zielverzeichnis, berechnet mit du den Prozentsatz des Ziels über der Quellgröße und zeigt einen Fortschrittsbalken an.

Hinweis: Dies funktioniert nur für die vollständige Verzeichnis-/Dateisynchronisierung (ich verwende es normalerweise, um Backups des passenden Caches zu erstellen), daher keine Option --exclude =/file/in/Source-directory. Funktioniert auch nicht, wenn sich Dateien/Verzeichnisse im Zielverzeichnis befinden, die sich nicht im Quellverzeichnis befinden. Ich bin mir nicht sicher, ob es für Remote-Quellen/-Ziele funktioniert, da ich nie die Notwendigkeit oder die Ressourcen zum Testen hatte.

PS. Dieses Skript ist möglicherweise sehr schlecht geschrieben oder sehr ineffizient (Skript-jungfräulich hier), aber es erfüllt zumindest seinen Zweck und natürlich können Sie es gerne bearbeiten und verbessern, um es Ihren Anforderungen anzupassen. PSS. Außerdem konnte die Abbrechen-Schaltfläche nicht zum Beenden von rsync verwendet werden, sodass ich sie einfach entfernt habe.

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