Pokazuje całkowity postęp w rsync: czy to możliwe?

Już szukałem tej opcji, ale znalazłem tylko rozwiązania obejmujące niestandardowe łatanie . Fakt, że nie wyświetla się w --help i nie można znaleźć więcej informacji, prawdopodobnie oznacza, że ​​odpowiedzi brzmi „nie”, ale chciałbym, aby to potwierdziło.

Czy można wyświetlić całkowity postęp przesyłania plików za pomocą rsync?

Danakim ma rację. Nie ma łatwych sposobów dodania wskaźnika całkowitego postępu.

Powodem tego jest to, że kiedy rsync przegląda listę plików do synchronizacji, nie wie z góry, które pliki należy zmienić. Jeśli wykonujesz transfery delta, same delty muszą zostać obliczone z wyprzedzeniem, aby dać całkowity obraz pracy, którą należy wykonać.

Innymi słowy, najłatwiejszym sposobem obliczenia ilości pracy, jaką należy wykonać, jest jej wykonanie.

Istnieje teraz oficjalny sposób, aby to zrobić w rsync (wersja protokołu 3.1.0 wersja 31, przetestowana z 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)

Próbowałem z moim /usrfolderem, ponieważ chciałem tej funkcji do przesyłania całych systemów plików i wydawałem /usrsię być dobrą reprezentatywną próbką.

--info=progress2Daje ładny ogólny odsetek, nawet jeśli jest to tylko częściowe wartość. W rzeczywistości mój /usrfolder zawiera ponad 6 koncertów:

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

i rsyncdużo czasu zajęło jej zeskanowanie. Tak więc prawie cały czas, jaki widziałem, został ukończony w około 90%, ale mimo to pocieszające jest, że coś jest kopiowane :)

Bibliografia:

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

Możesz to zrobić przy pomocy „pv” ( apt-get install pvz Debianem i Ubuntu). Zalecam monitorowanie liczby przesyłanych plików, ponieważ ilość przesyłanych danych nie jest skorelowana z rozmiarem plików, ale na delcie między źródłem a miejscem docelowym. A zliczanie plików policzy ten sam postęp dla jednej dużej delty i drugiej z małą deltą. Co oznacza, że ​​w każdym razie oszacowanie ETA może być dalekie. ETA oparte na rozmiarach działa tylko wtedy, gdy miejsce docelowe jest puste, w tym przypadku delta == rozmiar źródła.

Ogólny pomysł polega na emisji jednej linii na plik „przesłany” z rsync i policzeniu tych linii za pomocą „pv”:

rsync -ai / source remote: / dest | pv -les [liczba plików]> / dev / null

Mam tendencję do tworzenia kopii zapasowych całych systemów plików (z kilku powodów), w tym przypadku możesz użyć o wiele tańszego, dfaby uzyskać liczbę plików (zamiast dulub findktóry przejdzie do twojej hierarchii źródłowej innym razem po tym, jak rsync to zrobi). Pojawia się opcja -x, aby upewnić się, że rsync pozostaje w tym samym źródłowym systemie plików (i nie wykonuje innych wewnętrznych montowań):

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

Jeśli chcesz policzyć pliki w / source w ogólny sposób, użyj find /source|wc -l(ponownie ostrzeżenie: może być powolny i ciężki we / wy).

Poniższe informacje dotyczą rsync w wersji 3.0.0 i nowszej. Opcje opisane poniżej zostały wprowadzone w tym wydaniu 1 marca 2008 r.

Wraz z --info = progress2 możesz również użyć opcji --no-inc-recursive (lub jej krótszego aliasu - no -ir ), aby wyłączyć przyrostową rekurencję.

Spowoduje to utworzenie całej listy plików na początku, zamiast stopniowego wykrywania kolejnych plików w miarę przesyłania. Ponieważ zna wszystkie pliki przed uruchomieniem, daje lepszy raport na temat ogólnego postępu. Dotyczy to liczby plików - nie zgłasza żadnego postępu w oparciu o rozmiary plików.

Obejmuje to kompromis. Zbudowanie całej listy plików przed czasem jest bardziej kosztowne pod względem pamięci i może znacznie opóźnić rozpoczęcie faktycznego transferu. Jak można się spodziewać, im więcej plików, tym dłuższe będzie opóźnienie i więcej pamięci zajmie.

Poniżej znajduje się podręcznik rsync (źródło - http://rsync.samba.org/ftp/rsync/rsync.html ):

-r, --recursive

To mówi rsync, aby rekurencyjnie kopiowało katalogi. Zobacz także --dirs (-d). Począwszy od rsync 3.0.0, stosowany algorytm rekurencyjny jest teraz skanem przyrostowym, który zużywa znacznie mniej pamięci niż wcześniej i rozpoczyna transfer po zakończeniu skanowania pierwszych kilku katalogów. Ten przyrostowy skan wpływa tylko na nasz algorytm rekurencyjny i nie zmienia transferu nierekurencyjnego. Jest to również możliwe tylko wtedy, gdy oba końce przesyłania są co najmniej w wersji 3.0.0.

Niektóre opcje wymagają rsync do zapoznania się z pełną listą plików, więc te opcje wyłączają tryb przyrostowej rekurencji. Należą do nich: --delete-before, --delete-after, --prune-empty-dirs i --delay-updates. Z tego powodu domyślnym trybem usuwania po określeniu opcji --delete jest teraz --delete-during, gdy oba końce połączenia mają co najmniej 3.0.0 (użyj opcji --del lub --delete-during, aby zażądać tego ulepszonego trybu usuwania wyraźnie). Zobacz także opcję --delete-delay, która jest lepszym wyborem niż użycie opcji --delete-after.

Przyrostową rekurencję można wyłączyć za pomocą opcji --no-inc-recursive lub jej krótszego aliasu - no -ir .

Zobacz także https://rsync.samba.org, aby zapoznać się z konkretnymi różnicami między wersjami (przewiń w dół i sprawdź linki Wiadomości prasowych).

W przypadku długich transferów jestem zadowolony z biegania du -spo obu stronach. Nawet watch -n1 du -sjeśli czuję się naprawdę niespokojny.

watchwykonuje polecenie ( du -stutaj) okresowo (co 1 sekundę tutaj) i wyświetla pełny ekran wyjściowy.

Zasadniczo nie. Postęp można wyświetlać tylko dla pliku z flagą --progress, ale o to chodzi.

Zgaduję, że możesz napisać wokół niego opakowanie lub użyć jednej z łat, które już znalazłeś, ale musisz zadać sobie pytanie, czy naprawdę jest tego warte, czy naprawdę potrzebujesz całkowitego postępu dla rsync?

Użyłem odpowiedzi z zerodeux i napisałem własny skrypt 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"

Szukałem również sposobu pokazania całkowitego postępu z rsync i znalazłem użyteczną odpowiedź z tego postu: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

Zasadniczo możesz użyć --info = progress2 w wersji deweloperskiej rsync 3.1.0 . Oto, co powiedział doktor :

Istnieje również opcja --info = progress2, która generuje statystyki na podstawie całego transferu, a nie pojedynczych plików. Użyj tej flagi bez wypisywania nazwy pliku (np. Unikaj -v lub określ --info = nazwa0, jeśli chcesz zobaczyć, jak działa transfer bez przewijania ekranu z wieloma nazwami. (Nie musisz określać - opcja postępu w celu użycia opcji --info = progress2.)

Użyłem odpowiedzi z zerodeux i napisałem własny mały skrypt 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"

Zmieniłem bieg próbny TODO na

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

Bardzo szybko wyszukuje liczbę plików!

Jeśli nie masz najnowszej wersji rsync (np. OS X ma wersję 2.6.9) i nie możesz jej użyć --info=progress2, oto kolejna alternatywa, aby zapisać się na stronach przewijanego tekstu o postępie:

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

Spowoduje to wydrukowanie, w jednym wierszu, nazwy najnowszego przesyłanego pliku:

Transferring: the-latest.file

Posługiwać się

lsof -ad3-999 -c rsync

Aby zobaczyć, jakie pliki rsync obecnie otworzy (pokaże rozmiar pliku), lokalnie kopiuje rsync do ukrytego pliku

Zrobiłbym to komentarz, ale nie mam wystarczającej reputacji. W odpowiedzi na komentarz naught101 do wybranej odpowiedzi opcja --progress pokazuje, ile plików zostało przeniesionych z całkowitej kwoty do przesłania. Nie zdawałem sobie z tego sprawy, dopóki nie spojrzałem na ten post i nie przyjrzałem się dokładniej wynikowi.

Statystyka „do sprawdzenia” pokazuje, ile plików pozostało w sumie. Jest to najbardziej przydatne podczas synchronizacji z nowym miejscem docelowym, aby wiedzieć, że wszystkie pliki zostaną w pełni skopiowane.

Ze strony podręcznika:

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.

Zwróć uwagę na to, że nawet --info = progress2 nie jest do końca wiarygodne, ponieważ procent ten jest oparty na liczbie plików, o których rsync „wie” w czasie, gdy wyświetlany jest postęp. Niekoniecznie jest to łączna liczba plików, które musiały zostać zsynchronizowane (na przykład, jeśli wykryje dużą liczbę dużych plików w głęboko zagnieżdżonym katalogu). Jednym ze sposobów upewnienia się, że --info = progress2 nie „przeskakuje do tyłu” we wskazaniu postępu, byłoby wymuszenie na rsync skanowania wszystkich katalogów rekurencyjnie przed rozpoczęciem synchronizacji (zamiast domyślnego zachowania polegającego na wykonywaniu skanowania przyrostowo rekurencyjnego), udostępniając także opcję --no-inc-recursive. Należy jednak pamiętać, że ta opcja zwiększy również zużycie pamięci rsync i czas działania.

Używam skryptu, który wyodrębnia informacje z / proc // io dla procesu rsync (lub dowolnego innego procesu w tym zakresie) i wiedząc, że całkowita kwota do przesłania oblicza postęp.

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

Jeśli twoja wersja rsyncnie akceptuje tej --info=progress2opcji, możesz użyć tqdm:

Żeby zainstalować:

pip install tqdm

Używać:

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

Być może możesz połączyć pvz rsync. Szczególnie ten parametr --sizemoże być pomocny. Patrząc na dokumenty, coś takiego pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/pathpowinno działać.

Tutaj znajdziesz dokumenty i oprogramowanie.

Nie próbowałem tego sam.

Może tu być trochę za późno, ale przyszli poszukiwacze odpowiedzi mogą skorzystać.

To mnie też wkurzyło, więc pomyślałem, że zejdę na dół i napisam swój pierwszy scenariusz. Pakiet zenity musi być zainstalowany (sudo apt-get install zenity), ale jestem pewien, że prawdopodobnie już tam będzie. Ponadto używam wmctrl (kontrolka menedżera okien), aby zmienić tytuł okna dialogowego postępu, gdy jest zrobiony, jest łatwy do zainstalowania, ale nie zrobi różnicy, jeśli tego nie zrobisz. Po prostu lubię widzieć, kiedy skończy się w moim panelu.

Skrypt zasadniczo pyta o katalog źródłowy i docelowy, oblicza procent miejsca docelowego w stosunku do źródła za pomocą du i wyświetla pasek postępu.

Uwaga: Działa to tylko w przypadku pełnej synchronizacji katalogu / pliku (zwykle używam go do tworzenia kopii zapasowych apt cache), więc nie ma opcji --exclude = / file / in / Source-directory. Nie zadziała również, jeśli w katalogu docelowym nie ma plików / katalogów, a nie katalogu źródłowego. Nie jestem pewien, czy to działa dla zdalnych źródeł / miejsc docelowych, ponieważ nigdy nie miałem potrzeby ani zasobów, aby to przetestować.

PS. Ten skrypt może być bardzo źle napisany lub bardzo nieefektywny (tutaj skrypt-dziewica), ale przynajmniej spełnia swój cel i oczywiście możesz go edytować i ulepszać, aby odpowiadał twoim potrzebom. PSS. Ponadto nie mogłem dostać przycisku Anuluj, aby zabić rsync, więc właśnie go usunąłem.

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