Rsync'deki toplam ilerleme gösteriliyor: bu mümkün mü?

Bu seçeneği zaten aradım, ancak yalnızca özel düzeltme eki içeren çözümler buldum . Yardımda gösterilmemesi ve daha fazla bilgi bulunamaması, muhtemelen cevapların 'hayır' olduğunu gösterir, ancak bunun onaylandığını görmek isterim.

Rsync ile toplam dosya aktarımı ilerlemesini göstermek mümkün mü ?

danakim doğru. Toplam bir ilerleme göstergesi eklemek için önemsiz yollar yoktur.

Bunun nedeni, rsync senkronize edilecek bir dosya listesine baktığında, hangi dosyaların değişmesi gerektiğini önceden bilmemesidir. Delta transferleri yapıyorsanız, yapılması gereken çalışmanın toplam resmini vermek için deltaların önceden hesaplanması gerekir.

Başka bir deyişle, orada ne kadar iş yapılması gerektiğini hesaplamanın en kolay yolu aslında onu yapmaktır.

Şimdi bunu rsync'de yapmanın resmi bir yolu var (sürüm 3.1.0 protokolü sürüm 31, Ubuntu Trusty 14.04 ile test edildi).

#> ./rsync -a --info=progress2 /usr .
    305,002,533  80%   65.69MB/s    0:00:01  xfr#1653, ir-chk=1593/3594)

/usrKlasörümle denedim çünkü bu özelliği tüm dosya sistemlerini /usraktarmak için istedim ve iyi bir temsili örnek gibiydi.

--info=progress2Sadece kısmi bir değer olsa bile, güzel bir genel yüzdesini verir. Aslında, /usrklasörüm 6 konserden fazla:

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

ve rsynchepsini taramak için çok zaman aldı. Neredeyse her zaman gördüğüm yüzde yaklaşık% 90 oranında tamamlandı, ancak yine de bir şeyin kopyalandığını görmek rahatlatıcı.

Referanslar:

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

'Pv' ile yapabilirsiniz ( apt-get install pvDebian ve ubuntu ile). Aktarılan dosyaların sayısını izlemenizi öneririm, çünkü aktarılan veri miktarı dosyaların boyutu ile değil, kaynak ve hedef arasındaki delta ile ilişkilidir. Ve dosyaları saymak, bir büyük delta için bir diğerinin küçük delta ile aynı ilerlemeyi sayar. Bu, her halükarda ETA tahmininin çok uzak olabileceği anlamına gelir. Boyuta dayalı ETA, yalnızca hedefiniz boşsa çalışır, bu durumda delta == kaynağın boyutu.

Genel fikir, rsync'den 'transfer edilen' dosya başına bir satır yayınlamak ve bu satırları 'pv' ile saymaktır:

rsync -ai / source remote: / dest | pv -les [dosya sayısı]> / dev / null

Tüm dosya sistemlerini yedekleme eğilimindeyim (birkaç nedenden ötürü), bu durumda df, dosya sayısını elde etmek için çok daha ucuz kullanabilirsiniz ( kaynak kodlu hiyerarşinizi başka bir zaman geçtikten sonra değiştirmek yerine duveya yerine find). -X seçeneği, rsync'in aynı kaynak dosya sisteminde kaldığından (ve diğer iç montajları takip etmediğinden) emin olmak için görünür:

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

Dosyaları genel olarak kaynak / kaynak olarak saymak istiyorsanız, kullanın find /source|wc -l(tekrar uyarı: G / Ç'de yavaş ve ağır olabilir).

Aşağıdaki sürüm 3.0.0 ve daha üst sürümleri için geçerlidir. Aşağıda açıklanan seçenekler 1 Mart 2008 tarihinde bu sürümde sunulmuştur.

--İnfo = progress2 ile birlikte, artımlı yinelemeyi devre dışı bırakmak için --no-inc-recursive seçeneğini (veya daha kısa - no-ir diğer adını) da kullanabilirsiniz.

Bu, aktarma devam ederken daha fazla dosyayı aşamalı olarak keşfetmek yerine, tüm dosya listesini başlangıçta oluşturacaktır. Başlamadan önce tüm dosyaları bildiğinden, genel ilerleme hakkında daha iyi bir rapor verecektir. Bu dosya sayısı için geçerlidir - dosya boyutlarına göre herhangi bir ilerleme bildirmez.

Bu bir takas içerir. Dosya listesinin tamamını önceden oluşturmak daha fazla maliyetlidir ve gerçek aktarımın başlamasını önemli ölçüde geciktirebilir. Beklediğiniz gibi, ne kadar fazla dosya varsa, gecikme o kadar uzun olacak ve daha fazla bellek gerektirecektir.

Aşağıdakiler rsync kılavuzundandır (kaynak - http://rsync.samba.org/ftp/rsync/rsync.html ):

-r, - özyineli

Bu, rsync'e dizinleri tekrarlı bir şekilde kopyalamasını söyler. Ayrıca bakınız --dirs (-d). Rsync 3.0.0 ile başlayarak, kullanılan özyinelemeli algoritma şimdi öncekinden çok daha az bellek kullanan artımlı bir taramadır ve ilk birkaç dizinin taranması tamamlandıktan sonra aktarımı başlatır. Bu artımlı tarama sadece özyineleme algoritmamızı etkiler ve özyinelemeli olmayan bir aktarımı değiştirmez. Ayrıca, aktarımın her iki ucu da en az 3.0.0 sürümü olduğunda mümkündür.

Bazı seçenekler tam dosya listesini bilmek rsync gerektirir, bu nedenle bu seçenekler artımlı özyineleme modunu devre dışı bırakır. Bunlar: --delete-önce, --delete-sonra, --prune-empty-dirs ve --delay-updates. Bu nedenle, --delete belirttiğinizde varsayılan silme modu şimdi --delete-bağlantının her iki ucu da en az 3.0.0 olduğunda (bu gelişmiş silme modunu istemek için --del veya --delete-sırasını kullanın) açıkça). Ayrıca --delete-after kullanmaktan daha iyi bir seçim olan --delete-delay seçeneğine de bakın.

Artımlı özyineleme, --no-inc-recursive seçeneği veya daha kısa - no-ir diğer adı kullanılarak devre dışı bırakılabilir .

Ayrıca , belirli sürüm farkları için https://rsync.samba.org adresine bakın (aşağı doğru kaydırın ve Haber Bülteni bağlantılarını inceleyin).

Uzun transferler için, du -siki taraftan koşmaktan mutluyum . Hatta watch -n1 du -sgerçekten endişeli hissediyorum.

watch( du -sburada) periyodik olarak bir komut verir ( burada her 1 saniyede bir) ve çıktının tam ekranını gösterir.

Temelde hayır. Dosya başına yalnızca ilerleme durumunu - ilerleme bayrağıyla gösterebilirsiniz, ancak bu onunla ilgilidir.

Sanırım etrafına bir sarmalayıcı yazabilir veya daha önce bulduğunuz yamaları kullanabilirsiniz ancak kendinize gerçekten değer olup olmadığını sormalısınız, gerçekten rsync için toplam bir ilerlemeye mi ihtiyacınız var?

Ben cevabı zerodeux'dan kullandım ve kendi küçük bash betiğimi yazdım:

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

Ayrıca, rsync ile toplam ilerlemenin nasıl gösterileceğini de araştırdım ve bu yazıdan gelen yararlı bir cevap buldum: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

Temel olarak, --info = progress2 komutunu rsync 3.1.0 sürümünün dev sürümünde kullanabilirsiniz . İşte doktorun söylediği:

Ayrı ayrı dosyalar yerine tüm aktarıma dayalı istatistikleri çıkaran bir --info = progress2 seçeneği de vardır. Bir dosya adı çıkarmadan bu bayrağı kullanın (örneğin, -v ya da belirtin --info = isim0.) Eğer bir çok isimle ekranı kaydırmadan aktarımın nasıl yapıldığını görmek istiyorsanız. --info = progress2 kullanmak için progress seçeneği.)

Cevabı zerodeux'dan kullandım ve kendi küçük BASH senaryomu yazdım:

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

TODO'nun kuru çalışmasını değiştirdim

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

Dosya sayısını çok hızlı bulur!

En son rsync'e sahip değilseniz (örneğin, OS X 2.6.9'a sahip) ve kullanamıyorsanız --info=progress2, ilerlemekte olan kaydırma metni sayfalarından kendinizi kurtarmanın başka bir alternatifi:

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

Bu, bir satırda aktarılan en son dosyanın adını yazdıracaktır:

Transferring: the-latest.file

kullanım

lsof -ad3-999 -c rsync

Şu anda hangi dosyaların açık olduğunu görmek için rsync'in yerel olarak gizli bir dosyaya rsync kopyalarını gösterdiğini (dosya boyutunu gösterecek)

Bunu bir yorum yapardım ama yeterince itibarım yok. Naught101'in seçilen cevaba olan yorumuna cevaben --progress seçeneği, transfer edilecek toplam tutardan kaç tane dosya aktarıldığını gösterir. Bunu bu yazıya bakıp çıktıya daha dikkatli bakana kadar fark etmedim.

'Kontrol edilecek' statüsü toplamda kaç dosyanın kaldığını gösterir. Bu, yeni bir hedefe rsync'ing yaparken çoğu kullanım içindir, böylece tüm dosyaların tamamen kopyalanacağını bilirsiniz.

Man sayfasından:

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.

Buradaki uyarıya --info = progress2'nin bile tamamen güvenilir olmadığına dikkat edin; çünkü bu yüzde, ilerleme görüntülendiği sırada rsync'in 'bildiği' dosya sayısına dayanır. Bu mutlaka senkronize edilmesi gereken toplam dosya sayısı değildir (örneğin, derinlemesine yuvalanmış bir dizinde çok sayıda büyük dosyayı bulursa). --İnfo = progress2 öğesinin ilerleme göstergesinde 'geri dönmemesini' sağlamanın bir yolu, senkronizasyon başlamadan önce rsync'i tüm dizinleri tekrar tekrar taramaya zorlamak olacaktır (artımlı olarak yinelemeli tarama yapmak yerine varsayılan davranışı yerine), ayrıca --no-inc-recursive seçeneğini de sunarak. Bununla birlikte, bu seçeneğin rsync bellek kullanımını ve çalışma süresini de artıracağını unutmayın.

Rsync işlemi için (veya bu konuda başka bir işlem için) / proc // io'dan bilgi çıkaran bir komut dosyası kullanıyorum ve aktarılacak toplam tutarı bilmek ilerlemeyi hesaplıyor.

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

Sürümünüz seçeneği rsynckabul etmiyorsa --info=progress2, şunları kullanabilirsiniz tqdm:

Yüklemek:

pip install tqdm

Kullanmak:

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

Belki de pvrsync ile birleştirebilirsiniz . Özellikle parametre --sizefaydalı olabilir. Dokümanlar bir göz alarak, gibi bir şey pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/pathçalışması gerekir.

Burada dokümanları ve yazılımı bulacaksınız.

Bunu kendi başıma denemedim.

Buraya biraz geç kalabilirsiniz, ancak gelecekteki cevap arayanlar fayda sağlayabilir.

Bu da beni rahatsız ediyordu, ben de düşüp kirlenip ilk senaryomu yazacağımı düşündüm. Zenity paketi kurulmalı (sudo apt-get install zenity), ama muhtemelen zaten orada olacağından eminim. Ayrıca, işlem tamamlandığında ilerleme iletişim kutusunun başlığını değiştirmek için wmctrl (pencere yöneticisi denetimi) kullanıyorum, kolayca kurulabilir ancak yapmazsanız fark yaratmaz. Panelimde ne zaman yapıldığını görmeyi seviyorum.

Komut dosyası temel olarak bir kaynak ve hedef dizini sorar, hedef üzerindeki kaynak üzerindeki hedef yüzdesini du kullanarak hesaplar ve bir ilerleme çubuğu görüntüler.

Not: Bu yalnızca tam dizin / dosya senkronizasyonu için çalışır (genellikle uygun önbellek yedeklemelerini yapmak için kullanırım), yani --exclude = / file / in / Source-directory seçeneği yoktur. Kaynak dizinde olmayan Hedef dizininde dosya / dizin varsa da çalışmaz. Uzak kaynaklar / destinasyonlar için işe yarayıp yaramadığından emin değilim çünkü hiçbir zaman ya da test etmek için bu kaynağa ihtiyacım olmadı.

PS. Bu senaryo çok kötü yazılmış veya çok verimsiz olabilir (burada script-virgin), ama en azından amacına hizmet ediyor ve elbette gereksinimlerinize uyacak şekilde düzenlemenizi ve geliştirmenizi bekliyoruz. PSS. Ayrıca, rsync'i öldürmek için iptal düğmesini alamadım, ben de yeni çıkardım.

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