Отображение общего прогресса в rsync: возможно ли это?

Я уже искал эту опцию, но нашел только решения, которые включают пользовательские исправления . Тот факт, что он не отображается в --help и больше информации не может быть найдено, вероятно, указывает на то, что ответы - «нет», но я бы хотел, чтобы это подтвердилось.

Можно ли показать общий прогресс передачи файлов с помощью rsync?

Данаким это правильно. Нет простых способов добавить индикатор общего прогресса.

Причина этого заключается в том, что, когда rsync просматривает список файлов для синхронизации, он не знает заранее, какие файлы нужно будет изменить. Если вы выполняете дельта-переводы, сами дельты должны быть рассчитаны заранее, чтобы дать полную картину работы, которую необходимо выполнить.

Другими словами, самый простой способ подсчитать, сколько работы предстоит сделать, - это сделать это на самом деле.

Теперь есть официальный способ сделать это в rsync (протокол версии 3.1.0, версия 31, протестировано с 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)

Я попытался с моей /usrпапкой, потому что я хотел эту функцию для передачи целых файловых систем, и, /usrказалось, был хорошим представительным образцом.

Это --info=progress2дает хороший общий процент, даже если это только частичное значение. На самом деле моя /usrпапка более 6 гигов:

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

и rsyncпотребовалось много времени, чтобы просмотреть все это. Таким образом, почти всегда процент, который я видел, был выполнен на 90%, но, тем не менее, приятно видеть, что что-то копируется :)

Рекомендации:

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

Вы можете с помощью 'pv' ( apt-get install pvс Debian и Ubuntu). Я рекомендую отслеживать количество переданных файлов, поскольку объем передаваемых данных зависит не от размера файлов, а от разницы между источником и местом назначения. И подсчет файлов будет считать одинаковый прогресс для одной большой дельты и другой с маленькой дельтой. Это означает, что в любом случае оценка ETA может быть далека. ETA на основе размера работает только в том случае, если пункт назначения пуст, в этом случае delta == размер источника.

Общая идея состоит в том, чтобы выдавать одну строку на файл, «переданный» из rsync, и считать эти строки с помощью «pv»:

rsync -ai / source remote: / dest | pv -les [количество файлов]> / dev / null

Я имею тенденцию делать резервные копии целых файловых систем (по нескольким причинам), в этом случае вы можете использовать гораздо более дешевое dfдля получения количества файлов (а не duили, который findбудет пересекать вашу исходную иерархию в другой раз после того, как rsync это сделал). Опция -x позволяет убедиться, что rsync остается в той же исходной файловой системе (и не следует за другими внутренними монтируемыми файлами):

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

Если вы хотите считать файлы в / source обычным способом, используйте find /source|wc -l(еще раз предупреждение: может быть медленным и тяжелым при вводе / выводе).

Следующее относится к rsync версии 3.0.0 и выше. Опции, описанные ниже, были представлены в этом выпуске 1 марта 2008 года.

Наряду с --info = progress2 вы также можете использовать параметр --no-inc-recursive (или его более короткий псевдоним --no-ir ), чтобы отключить инкрементную рекурсию.

Это создаст весь список файлов в начале, а не будет постепенно обнаруживать больше файлов по мере передачи. Поскольку он будет знать все файлы перед запуском, он даст лучший отчет об общем прогрессе. Это относится к числу файлов - он не сообщает о каком-либо прогрессе в зависимости от размера файла.

Это предполагает компромисс. Создание полного списка файлов заблаговременно требует больших затрат памяти и может значительно задержать начало фактической передачи. Как и следовало ожидать, чем больше файлов, тем больше будет задержка и больше памяти.

Следующее из руководства rsync (источник - http://rsync.samba.org/ftp/rsync/rsync.html ):

-r, --recursive

Это говорит rsync о рекурсивном копировании каталогов. Смотрите также --dirs (-d). Начиная с rsync 3.0.0, используемый рекурсивный алгоритм теперь представляет собой инкрементное сканирование, которое использует намного меньше памяти, чем раньше, и начинает передачу после завершения сканирования первых нескольких каталогов. Это инкрементное сканирование влияет только на наш алгоритм рекурсии и не меняет нерекурсивную передачу. Это также возможно только тогда, когда оба конца переноса имеют версию не ниже 3.0.0.

Некоторые параметры требуют, чтобы rsync знал полный список файлов, поэтому эти параметры отключают режим инкрементной рекурсии. К ним относятся: --delete-before, --delete-after, --prune-empty-dirs и --delay-updates. Из-за этого режим удаления по умолчанию при указании --delete теперь имеет значение --delete-while, когда оба конца соединения имеют как минимум 3.0.0 (используйте --del или --delete-while, чтобы запросить этот улучшенный режим удаления. явно). Смотрите также параметр --delete-delay, который лучше, чем использование --delete-after.

Инкрементную рекурсию можно отключить с помощью параметра --no-inc-recursive или его более короткого псевдонима --no-ir .

См. Также https://rsync.samba.org для конкретных различий в версиях (прокрутите вниз и просмотрите ссылки на Release News).

Для длинных передач я доволен бегом du -sс обеих сторон. Даже watch -n1 du -sесли я действительно беспокоюсь.

watchвыполняет команду ( du -sздесь) периодически (каждую секунду здесь) и показывает вывод в полноэкранном режиме.

В основном нет. Вы можете отображать прогресс для каждого файла с флагом --progress, но это все.

Я предполагаю, что вы можете написать обертку вокруг него или использовать какие-либо патчи, которые вы уже нашли, но вы должны спросить себя, действительно ли это того стоит, вам действительно нужен общий прогресс для rsync?

Я использовал ответ из zerodeux и написал свой собственный маленький скрипт на 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"

Я также искал, как показать общий прогресс с rsync, и я нашел полезный ответ из этого поста: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

По сути, вы можете использовать --info = progress2 в dev-версии rsync 3.1.0 . Вот что сказал доктор :

Существует также опция --info = progress2, которая выводит статистику на основе всей передачи, а не отдельных файлов. Используйте этот флаг без вывода имени файла (например, избегайте -v или укажите --info = name0, если вы хотите увидеть, как происходит передача без прокрутки экрана с большим количеством имен. (Вам не нужно указывать - опция прогресса для использования --info = progress2.)

Я использовал ответ из zerodeux и написал свой собственный маленький 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"

Я изменил TODO всухую в

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

Он находит количество файлов очень быстро!

Если у вас нет последней версии rsync (например, OS X имеет версию 2.6.9) и вы не можете ее использовать --info=progress2, вот еще одна альтернатива, чтобы уберечь себя от страниц прокрутки текста о ходе работы:

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

В одной строке будет напечатано имя последнего передаваемого файла:

Transferring: the-latest.file

использование

lsof -ad3-999 -c rsync

Чтобы увидеть, какие файлы rsync в данный момент открыт (покажет размер файла), rsync копирует в скрытый файл локально

Я бы сделал это комментарий, но мне не хватило репутации. В ответ на комментарий naught101 к выбранному ответу опция --progress показывает, сколько файлов было передано из общей суммы для передачи. Я не осознавал этого, пока не посмотрел этот пост и не посмотрел на результат более внимательно.

Статистика 'to-check' показывает, сколько файлов осталось из общего количества. Это наиболее полезно при rsync'инге в новое место назначения, поэтому вы знаете, что все файлы будут полностью скопированы.

Со страницы руководства:

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.

Обратите внимание на оговорку, что даже --info = progress2 не совсем надежен, так как этот процент основан на количестве файлов, о которых rsync «знает» о том, когда отображается прогресс. Это не обязательно общее количество файлов, которые необходимо синхронизировать (например, если он обнаруживает большое количество больших файлов в глубоко вложенном каталоге). Один из способов убедиться, что --info = progress2 не «отскочил назад» в индикаторе хода выполнения, - заставить rsync рекурсивно сканировать все каталоги перед началом синхронизации (вместо того, чтобы по умолчанию выполнять инкрементно рекурсивное сканирование), также предоставив опцию --no-inc-recursive. Однако обратите внимание, что эта опция также увеличит использование памяти rsync и время выполнения.

Я использую сценарий, который извлекает информацию из / proc // io для процесса rsync (или любого другого процесса в этом отношении), и зная общую сумму, подлежащую передаче, вычисляет прогресс.

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

Если ваша версия rsyncне принимает --info=progress2опцию, вы можете использовать tqdm:

Установить:

pip install tqdm

Использовать:

$ rsync -av / source / dest | tqdm --unit_scale | туалет
10,0 Мит [00:02, 3,58 Мит / с]

Возможно, вы можете комбинировать pvс rsync. Особенно параметр --sizeможет быть полезным. Посмотрите на документы, что-то вроде pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/pathдолжно работать.

Здесь вы найдете документы и программное обеспечение.

Сам не пробовал.

Здесь может быть немного поздно, но будущие ищущие ответа могут выиграть.

Это тоже беспокоило меня, поэтому я подумал, что я опустошусь и напишу свой первый сценарий. Пакет zenity должен быть установлен (sudo apt-get install zenity), но я уверен, что он, вероятно, уже будет там. Кроме того, я использую wmctrl (управление оконным менеджером), чтобы изменить заголовок диалогового окна прогресса, когда оно будет сделано, его легко установить, но если вы этого не сделаете, это не будет иметь никакого значения. Мне просто нравится видеть, когда это будет сделано в моей панели.

Сценарий в основном запрашивает каталог источника и назначения, вычисляет процентное соотношение места назначения и размера источника с использованием du и отображает индикатор выполнения.

Примечание: это работает только для полной синхронизации каталогов / файлов (я обычно использую его для создания резервных копий apt-кэша), поэтому --exclude = / file / in / Source-directory опция отсутствует. Также не будет работать, если есть файлы / каталоги в каталоге назначения, а не в исходном каталоге. Я не уверен, работает ли он для удаленных источников / мест назначения, поскольку у меня никогда не было необходимости в нем или в ресурсах для его проверки.

PS. Этот сценарий может быть очень плохо написан или очень неэффективен (скрипт-девственница здесь), но, по крайней мере, он служит своей цели и, конечно, вы можете редактировать и улучшать его в соответствии с вашими потребностями. PSS. Кроме того, не удалось получить кнопку отмены, чтобы убить rsync, поэтому я просто удалил ее.

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