Anzeigen des Gesamtfortschritts in rsync: Ist es möglich?

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

Kann ich mit rsync den gesamten Fortschritt der Dateiübertragung anzeigen?

Danakim ist richtig. Es gibt keine einfachen Möglichkeiten, eine Gesamtfortschrittsanzeige hinzuzufügen.

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

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

Es gibt jetzt eine offizielle Möglichkeit, dies in rsync zu tun (Version 3.1.0, Protokollversion 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 /usrOrdner versucht, weil ich diese Funktion zum Übertragen ganzer Dateisysteme haben wollte, und /usrschien ein gutes repräsentatives Beispiel zu sein.

Das --info=progress2ergibt einen schönen Gesamtprozentsatz, auch wenn es sich nur um einen Teilwert handelt. In der Tat ist mein /usrOrdner mehr als 6 Gigs:

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

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

Verweise:

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

Sie können mit 'pv' ( apt-get install pvmit 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 Datei 'übertragen' von rsync 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 verschiedenen Gründen). In diesem Fall können Sie die wesentlich günstigere Version verwenden df, um die Anzahl der Dateien zu ermitteln (anstatt duoder wenn Sie findIhre Quellhierarchie ein weiteres Mal durchlaufen, nachdem rsync dies getan hat). Die Option -x wird angezeigt, um sicherzustellen, dass rsync auf demselben Quelldateisystem verbleibt (und nicht anderen internen Bereitstellungen folgt):

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

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

Das Folgende gilt für rsync Version 3.0.0 und höher. Die nachfolgend 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 --no-ir- Alias) verwenden, um die inkrementelle Rekursion zu deaktivieren.

Dadurch wird die gesamte Dateiliste am Anfang erstellt, anstatt schrittweise mehr Dateien zu ermitteln, während die Übertragung fortgesetzt wird. Da alle Dateien vor dem Start bekannt sind, wird ein besserer Bericht über den Gesamtfortschritt erstellt. Dies gilt für die Anzahl der Dateien - es werden keine Fortschritte aufgrund 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. Je mehr Dateien vorhanden sind, desto länger dauert die Verzögerung und desto mehr Speicher wird benötigt.

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

-r, --rekursiv

Dadurch wird rsync angewiesen, Verzeichnisse rekursiv zu kopieren. Siehe auch --dirs (-d). Ab rsync 3.0.0 handelt es sich bei dem verwendeten rekursiven Algorithmus nun um einen inkrementellen Scan, der viel weniger Speicher als zuvor benötigt und die Übertragung startet, nachdem die ersten Verzeichnisse durchsucht wurden. 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.

Einige Optionen erfordern, dass rsync die vollständige Dateiliste kennt, daher deaktivieren diese Optionen den inkrementellen Rekursionsmodus. Dazu gehören: --delete-before, --delete-after, --prune-empty-dirs und --delay-updates. Aus diesem Grund lautet der Standardlöschmodus, wenn Sie --delete angeben, jetzt --delete-during, wenn beide Enden der Verbindung mindestens 3.0.0 sind (verwenden Sie --del oder --delete-during, um diesen verbesserten Löschmodus anzufordern ausdrücklich). Siehe auch die Option --delete-delay, die eine bessere Wahl ist als --delete-after.

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

Unter https://rsync.samba.org finden Sie Informationen zu bestimmten Versionsunterschieden.

Für lange Transfers bin ich glücklich, du -sauf beiden Seiten zu laufen . Auch watch -n1 du -swenn ich mich sehr ängstlich fühle.

watchFührt ( du -shier) periodisch einen Befehl aus ( hier alle 1 Sekunde) und zeigt die Ausgabe im Vollbildmodus an.

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

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

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"

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

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

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

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-Probelauf auf geändert

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

Es findet die Anzahl der Dateien sehr schnell!

Wenn Sie nicht über die neueste Version von rsync verfügen (z. B. OS X 2.6.9) und diese nicht verwenden können --info=progress2, können Sie sich anhand der folgenden Alternative vor laufendem Bildlauf schützen :

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

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

Transferring: the-latest.file

Verwenden

lsof -ad3-999 -c rsync

Um zu sehen, welche Dateien rsync aktuell geöffnet hat (wird die Dateigröße anzeigen), kopiert rsync lokal in eine versteckte Datei

Ich würde das kommentieren, habe aber nicht genug Reputation. Als Antwort auf den Kommentar von naught101 zur ausgewählten Antwort zeigt die Option --progress an, wie viele Dateien von der zu übertragenden Gesamtmenge übertragen wurden. Ich habe das erst bemerkt, als ich mir diesen Beitrag angesehen und die Ausgabe genauer untersucht habe.

Der Status "zu prüfen" zeigt an, wie viele Dateien von der Gesamtsumme übrig bleiben. Dies ist am nützlichsten, wenn Sie eine Synchronisierung mit einem neuen Ziel durchführen, 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.

Beachten Sie hierbei, 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 (wenn beispielsweise 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 durchsuchen, bevor die Synchronisierung gestartet wird (anstatt standardmäßig einen inkrementellen rekursiven Scan durchzuführen). indem Sie auch die Option --no-inc-recursive angeben. Beachten Sie jedoch, dass diese Option auch die Speichernutzung und die Laufzeit von rsync erhöht.

Ich verwende ein Skript, das die Informationen aus / proc // io für den rsync-Prozess (oder einen anderen Prozess in diesem Fall) extrahiert. Wenn ich weiß, dass der Gesamtbetrag übertragen werden muss, wird der 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 -------------------------------------------------------------------"

Wenn Ihre Version von rsyncdie --info=progress2Option nicht akzeptiert , können Sie Folgendes verwenden tqdm:

Installieren:

pip install tqdm

Benutzen:

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

Vielleicht können Sie pvmit rsync kombinieren . Vor allem der Parameter --sizekönnte hilfreich sein. Wenn Sie sich die Dokumente ansehen, sollte so etwas pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/pathfunktionieren.

Hier finden Sie die Dokumentation und Software.

Habe ich nicht alleine ausprobiert.

Könnte ein bisschen zu spät sein, aber zukünftige Antwortsuchende könnten davon profitieren.

Das nervte mich auch, also dachte ich, ich würde runter und schmutzig werden und mein erstes Drehbuch schreiben. Das Paket zenity muss installiert sein (sudo apt-get install zenity), aber ich bin mir sicher, dass es wahrscheinlich schon dort sein wird. Außerdem verwende ich wmctrl (Fenster-Manager-Steuerung), um den Titel des Fortschrittsdialogs zu ändern, wenn er fertig ist. Er ist leicht zu installieren, macht aber keinen Unterschied, wenn Sie es 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 von apt cache zu erstellen). Daher gibt es 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 entfernte Quellen / Ziele funktioniert, da ich nie die Notwendigkeit oder die Ressourcen hatte, es zu testen.

PS. Dieses Skript ist möglicherweise sehr schlecht geschrieben oder sehr ineffizient (Skript-Jungfrau hier), aber es erfüllt zumindest seinen Zweck und natürlich können Sie es gerne bearbeiten und verbessern, um es Ihren Bedürfnissen anzupassen. PSS. Außerdem konnte ich die Abbrechen-Schaltfläche nicht zum Beenden von rsync verwenden, sodass ich sie gerade 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