Showing total progress in rsync: is it possible?

Question

I have searched for this option already, but have only found solutions that involve custom patching. The fact that it does not show in --help and no more info can be found probably indicates the answers is 'no', but I'd like to see this confirmed.

Is it possible to show total file transfer progress with rsync?

Since rsync 3.1.0 there is now a basic total file transfer progress included. See answer http://serverfault.com/a/441724/107793 for details. — Florian Feldhaus, Jan 14 '14 at 15:14
Please change the accepted answer. @David's answer is completely useless. — Navin, Feb 01 '16 at 18:56

score 552 · Accepted Answer · edited Jan 10 '21 at 20:28

552

There is now an official way to do this in rsync (version 3.1.0 protocol version 31, tested with 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)

I tried with my /usr folder because I wanted this feature for transferring whole filesystems, and /usr seemed to be a good representative sample.

The --info=progress2 gives a nice overall percentage, even if it's just a partial value. In fact, my /usr folder is more than 6 gigs:

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

and rsync took a lot of time to scan it all. So almost all the time the percentage I've seen was about 90% completed, but nonetheless it's comforting to see that something is being copied :)

References:

edited Jan 10 '21 at 20:28

Pang

273
3
8

answered Oct 24 '12 at 11:13

Avio

5,842
2
16
8

23

Note that this has landed in 3.1.0. It is also important to note that this isn't necessarily accurate in the time perspective. It is essentially showing the amount of data that has been verified to exist on the remote end. And the rate is the rate at which the data is being learned to be correct on the remote end (whether it was already that way or the new data was transferred and made it correct). So although very useful you need to understand the caveats. – Kevin Cox Nov 28 '13 at 21:11
26

Worth noting that `--info=progress2` doesn't work with `-v` – sanmai Mar 08 '15 at 15:09
8

@sanmai: Yes it does! It displays verbose output (which file is being worked on at the current time), but instead of showing the relative progress percentage for that individual file, it shows the absolute progress of the entire rsync operation. – Milos Ivanovic May 02 '15 at 19:16
Option added to the stable version (version 3.1.0 protocol version 31) as for today. Maybe you could edit yuor answer, Avio. – Sopalajo de Arrierez May 09 '15 at 21:17
1

But incremental backup not show correct progressbar – LOKESH Oct 14 '15 at 11:12
67

Add the `--no-i-r` switch aswell, so `rsync` does not scan incrementally but completely before copying and knows+displays how much work is left. – Alex Nov 19 '15 at 13:17
4

Be sure not to use `-v` or `-i`, else individual files will be printed out – Geremia Sep 08 '16 at 18:39
29

Note that you can use `--human-readable` (or `-h`) to see total size in MB/GB.. in progress. – Nux Aug 23 '17 at 10:22
4

For OSX with homebrew, `brew tap homebrew/dupes` is no longer needed as those formulae have been merged into the homebrew core repo. So now you only need to `brew install rsync` – Josh Davenport-Smith Feb 21 '18 at 20:23
Not very useful if only a few files have changed. – JohnMudd May 23 '19 at 21:35
Does it work with --files-from option? (when rsync downloading specified paths defined in txt file) – klapeyron Apr 22 '20 at 10:59
5

So combining the helpful comments I ended up with `rsync -ah --no-i-r --info=progress2 source dest` (and it makes a difference if there is a trailing `/` or not at the source) – Arsenal Mar 22 '21 at 22:26
`rsync: --info=progress2: unknown option` `rsync error: syntax or usage error (code 1) at ...` – Soheil Sep 21 '21 at 07:06

Nate · Answer 2 · 2019-03-21T18:15:43.880

The following applies to rsync version 3.0.0 and above. The options described below were introduced in that release on March 1st, 2008.

Along with --info=progress2 you can also use --no-inc-recursive option (or its shorter --no-i-r alias) to disable incremental recursion.

This will build the entire file list at the beginning, rather than incrementally discovering more files as the transfer goes on. Since it will know all files before starting, it will give a better report of the overall progress. This applies to the number of files - it does not report any progress based on file sizes.

This involves a trade-off. Building the entire file list ahead of time is more memory-costly and it can significantly delay the start of the actual transfer. As you would expect, the more files there are, the longer the delay will be and the more memory it will require.

The following is from the rsync manual (source - http://rsync.samba.org/ftp/rsync/rsync.html ):

-r, --recursive

This tells rsync to copy directories recursively. See also --dirs (-d). Beginning with rsync 3.0.0, the recursive algorithm used is now an incremental scan that uses much less memory than before and begins the transfer after the scanning of the first few directories have been completed. This incremental scan only affects our recursion algorithm, and does not change a non-recursive transfer. It is also only possible when both ends of the transfer are at least version 3.0.0.

Some options require rsync to know the full file list, so these options disable the incremental recursion mode. These include: --delete-before, --delete-after, --prune-empty-dirs, and --delay-updates. Because of this, the default delete mode when you specify --delete is now --delete-during when both ends of the connection are at least 3.0.0 (use --del or --delete-during to request this improved deletion mode explicitly). See also the --delete-delay option that is a better choice than using --delete-after.

Incremental recursion can be disabled using the --no-inc-recursive option or its shorter --no-i-r alias.

See also https://rsync.samba.org for specific version differences (scroll down and check out the Release News links).

Thanks for this, the other answers result in a %age that keeps going up and down! — artfulrobot, Nov 29 '16 at 16:05
Not quite perfect yet, as the percentage is always the ratio of the current transfer to the total amount of data. So if one transfer is interrupted at 40%, the next transfer will start at 0% and finish at 60%, which is a little confusing. Nevertheless, this is a lot clearer than the accepted answer, in my opinion. — iFreilicht, Oct 17 '20 at 21:18

score 49 · Answer 3 · answered Jun 10 '11 at 10:22

You can with 'pv' (apt-get install pv with Debian and ubuntu). I recommend to monitor the number of files transferred, since the amount of data transferred is not correlated to the size of files but on the delta between the source and destination. And counting files will count the same progress for one big delta and another one with small delta. Which means that in any case the ETA estimation might be far off. The size-based ETA only works if your destination is empty, in this case delta == size of source.

The general idea is to emit one line per file 'transferred' from rsync, and count those lines with 'pv':

rsync -ai /source remote:/dest | pv -les [number of files] >/dev/null

I tend to backup whole filesystems (for several reasons), in this case you can use the much cheaper df to get the number of files (rather than du or find wich will traverse your source hierarchy another time after rsync did it). The -x option appears to make sure rsync stays on the same source filesystem (and does not follow other inner mounts):

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

If you want to count files in /source in a general way, use find /source|wc -l (warning again: might be slow and heavy on I/O).

As zerodeuz specified, use "df" only when you are rsyncing the whole partition, as `df -i /source` gets the number of inodes (files) from all the partition in which /source reside. Otherwise use ['find' to count files inside a directory](http://stackoverflow.com/questions/1427032/fast-linux-file-count-for-a-large-number-of-files) inside the "$()" expression. — lepe, Sep 17 '15 at 01:43
An alternative to `du` or `find` - let's say you're finishing an incomplete copy or doing an in-place update with deletes - is to use `rsync -ai --dry-run` to get the same file list the main run will be passing to `pv` — Izkata, Apr 24 '16 at 06:07

score 40 · Answer 4 · answered Jan 06 '11 at 04:10

40

danakim is correct. There are no trivial ways to add a total progress indicator.

The reason for this is that when rsync looks at a list of files to sync, it doesn't know ahead of time which files will need to change. If you are doing delta transfers, the deltas themselves have to be calculated ahead of time to give a total picture of the work that needs to be done.

In other words, the easiest way to calculate how much work there is to be done is to actually do it.

answered Jan 06 '11 at 04:10

David Mackintosh

14,223
6
46
77

44

You could still have a simple indicator like (data transferred + data skipped)/(total data in source), or (# files transferred or skipped)/(# files in source). It's not going to be particularly accurate, but it'd give an idea. Good for when you're doing a big transfer at the end of the day, and you're wondering whether to wait around and turn off the computer, or let it run for the night... – naught101 May 29 '12 at 06:52
3

I don't believe that conclusion is right. I think @naught101 is being more fair to the question, and I think predicating an answer on not using `--size-only` or the like is further inaccurate. – Evan Carroll May 24 '14 at 00:11
3

At the time when I wrote the reply, it was accurate -- rsync did not have a mechanism for a total progress indicator. And yes, you could write your own, but very few people would. – David Mackintosh Jun 16 '14 at 21:11
6

Comment for newcomers: It's now possible: https://serverfault.com/a/441724/422003 – imposeren Jun 25 '17 at 23:09
using two passes, first with "--dry-run" (total expected file count) and second with detailed output logged to a file (and counting lines complete or using a pipe to 'pv'), allows easily estimating completion. The downside is scanning large nested directories twice. Depending on the need, i.e. ensuring safe customer data migrations, this might be acceptable. – ives Jan 28 '19 at 18:52

score 31 · Answer 5 · edited Jan 16 '13 at 10:23

31

For long transfers, I'm happy with running du -s on both sides. Even watch -n1 du -s, if I feel really anxious.

watch executes a command (du -s here) periodically (every 1 second here) and shows the output fullscreen.

edited Jan 16 '13 at 10:23

dunxd

9,482
21
80
117

answered Jan 05 '11 at 16:30

funollet

587
3
3

4

Thanks for the example of the `watch` command! – Cam Sep 17 '12 at 04:40
2

// , Clever! According to linfo.org: "The du (i.e., disk usage) command reports the sizes of directory trees inclusive of all of their contents and the sizes of individual files. This makes it useful for tracking down space hogs, i.e., directories and files that consume large or excessive amounts of space on a hard disk drive (HDD) or other storage media." – Nathan Basanese Jul 21 '15 at 01:44
10

I don't know what kind of long transfers you do, where du is viable. du is slow as hell when the result will be in TB and M of files. – Nobody Apr 30 '16 at 10:47
3

For my "long transfers" a du operation takes about an hour to complete, during which rsync is running much slower, because they're fighting over access to the disk. – Abhi Beckert Feb 01 '17 at 04:24

score 13 · Answer 6 · answered Jan 05 '11 at 15:50

13

Basically no. You can only show progress per-file with the --progress flag, but that is about it.

I am guessing you can write a wrapper around it or use any of the patches that you already find but you must ask yourself if it is really worth it, do you actually need a total progress for rsync?

answered Jan 05 '11 at 15:50

danakim

410
2
8

Here is a wrapper script which shows the total progress and file progress as a nice progress bar: https://gist.github.com/JohannesBuchner/4d61eb5a42aeaad6ce90 – j13r Oct 21 '15 at 17:47
2

You can change the way `--progress` work using `--info=progress2`, it'll show you the global progress. You will need to disable the incremental recursive algorithm for it to be useful, so `--info=progress2 --no-inc-recursive` – mat Mar 21 '16 at 10:37
@j13r you can share this gist as an answer as well! its great option! – skywinder Feb 18 '17 at 13:36
I'm using `rsync` to transfer 400+ GB of data from one server to another. I would like to know how much progress is being made on the total transfer. I have resorted to SSHing into the destination machine and running `du -hs` on the target directory every 60 seconds with `watch` – intcreator Feb 12 '22 at 16:52

score 9 · Answer 7 · edited May 23 '17 at 12:41

I also searched for how to show the total progress with rsync and I've found a useful answser from this post: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

Basicly, you can use --info=progress2 in the dev version of rsync 3.1.0. Here is what the doc has said:

There is also a --info=progress2 option that outputs statistics based on the whole transfer, rather than individual files. Use this flag without outputting a filename (e.g. avoid -v or specify --info=name0 if you want to see how the transfer is doing without scrolling the screen with a lot of names. (You don't need to specify the --progress option in order to use --info=progress2.)

score 8 · Answer 8 · edited Apr 06 '15 at 19:15

I used the answer from zerodeux and wrote my own little bash script:

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

score 8 · Answer 9 · answered Mar 20 '14 at 10:20

8

Use

lsof -ad3-999 -c rsync

To see what files rsync currently has open (will show filesize) rsync copies into a hidden file locally

answered Mar 20 '14 at 10:20

Cloom Magoo

181
1
1

I wanted to post this `for i in $(pgrep 'rsync'); do ls -l /proc/$i/fd; done` but your solution is simpler. – Aalex Gabi Aug 25 '19 at 15:03
interesting approach :) – Victor Jan 31 '21 at 00:56

score 8 · Answer 10 · answered May 02 '16 at 09:18

If you don’t have the latest rsync (e.g., OS X has 2.6.9) and can’t use --info=progress2, here’s another alternative to save yourself from pages of scrolling text on progress:

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

That will print out, on one line, the name of the latest file being transferred:

Transferring: the-latest.file

score 6 · Answer 11 · edited Apr 06 '15 at 18:57

6

I used the answer from zerodeux and wrote my own little BASH script:

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

I changed the TODO dry-run to

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

It finds the number of files very fast!

edited Apr 06 '15 at 18:57

William Entriken

543
5
12

answered Jan 03 '13 at 12:00

user151779

61
1
1

find works *so* much better than rsync --dry-run! – hopeseekr Jan 05 '13 at 02:11
4

`find` only works if you're `rsync`-ing locally. `rsync --dry-run` works with remote sources too... – voretaq7 May 08 '13 at 17:29

score 4 · Answer 12 · edited Feb 28 '18 at 19:17

I'd make this a comment but don't have enough reputation. In response to naught101's comment to the chosen answer, the --progress option shows how many files have been transfered out of the total amount to transfer. I didn't realize this until looking at this post and looking at the output more carefully.

The 'to-check' stat shows how many files are left out of the total. This is of most use when rsync'ing to a new destination so you know all files will be fully copied.

From the man page:

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.

laktak · Answer 13 · 2020-11-17T21:47:39.820

3

I made a progress bar for rsync in a wrapper. With --info=progress2 from new versions of rsync no patching is necessary.

Usage - replace rsync with rsyncy:

rsyncy -a FROM/ TO

rsyncy

More info on GitHub, install with pip3 install --user rsyncy

edited Nov 17 '20 at 21:47

answered Nov 16 '20 at 21:18

laktak

626
2
9
16

score 3 · Answer 14 · answered Feb 25 '14 at 04:44

Note the caveat here that even --info=progress2 is not entirely reliable since this is percentage is based on the number of files rsync 'knows' about at the time when the progress is being displayed. This is not necessarily the total number of files that needed to be sync'd (for instance, if it discovers a large number of large files in a deeply nested directory). One way to ensure that --info=progress2 doesn't 'jump back' in the progress indication would be to force rsync to scan all the directories recursively before starting the sync (instead of its default behavior of doing an incrementally recursive scan), by also providing the --no-inc-recursive option. Note however that this option will also increase rsync memory usage and run-time.

Incremental recursion can be disabled using the `--no-inc-recursive` option or its shorter `--no-i-r` alias. (See other answer) — koppor, Jan 13 '19 at 08:17

score 3 · Answer 15 · answered Jul 26 '17 at 20:12

3

If your version of rsync does not accept the --info=progress2 option, you can use tqdm:

To install:

pip install tqdm

To use:

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

answered Jul 26 '17 at 20:12

ostrokach

140
4

score 2 · Answer 16 · answered Sep 16 '14 at 20:17

I use a script that extracts the information from /proc//io for the rsync process (or any other process for that matter) and knowing the total amount to be transferred is calculates the progress.

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

score 1 · Answer 17 · answered Jan 06 '11 at 08:08

Perhaps you can combine pv with rsync. Especially the parameter --size could by helpful. Taking a look at the docs, something like pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/path should work.

Here you'll find the docs and software.

Haven't tried this on my own.

neill_L · Answer 18 · 2014-01-15T22:14:43.797

Might be a bit late here but future answer-seekers might benefit.

This was bugging me too so I thought I'd get down and dirty and write my first script. The package zenity must be installed (sudo apt-get install zenity), but I'm sure it will probably be there already. Also, I use wmctrl (window manager control) to change the title of the progress dialog when it's done, it's easily installable but won't make a difference if you don't. I just like to see when it's done in my panel.

The script basically asks for a source and destination directory, calculates the percentage of the destination over the source in size using du and displays a progress bar.

Note: This only works for complete directory/file syncing (I usually use it to make backups of apt cache), so no --exclude=/file/in/Source-directory option. Also won't work if there are files/directories in Destination directory not in the source directory. I'm not sure if it works for remote sources/destinations since never I've had the need for it or the resources to test it.

PS. This script might be very badly written or very inefficient, (script-virgin here), but at least it serves it's purpose and of course you're welcome to edit and improve it to suit your needs. PSS. Also, couldn't get the cancel button to kill rsync so I just removed it.

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

Take a look at YAD. It's a fork(rewrite?) of Zenity and is like Zenity... but on steroids. My scripts use it for everything with fallback to Zenity since I have a machine with only Zenity on it. The command options are similar enough for that but you just loose a lot of niceties with Zenity. — DocSalvager, Mar 10 '18 at 16:26

score 0 · Answer 19 · answered May 19 '22 at 10:03

0

If you don’t have the latest rsync (e.g., OS X has 2.6.9) and can’t upgrade with brew upgrade rsync , you don't .use --info=progress2, or another alternativeyou only can see files output without addicional commands:

rsync -avh

answered May 19 '22 at 10:03

Roberto

1
1

Showing total progress in rsync: is it possible?

19 Answers19

Linked