Afficher le progrès total en rsync: est-ce possible?

J'ai déjà recherché cette option, mais je n'ai trouvé que des solutions impliquant des correctifs personnalisés . Le fait qu'il n'apparaisse pas dans --help et qu'aucune autre information ne peut être trouvée indique probablement que la réponse est non, mais j'aimerais que cela soit confirmé.

Est-il possible d'afficher la progression totale du transfert de fichiers avec rsync?

Danakim a raison. Il n'y a pas de moyen trivial d'ajouter un indicateur de progression totale.

La raison en est que, lorsque rsync examine une liste de fichiers à synchroniser, il ne sait pas à l’avance quels fichiers devront être modifiés. Si vous effectuez des transferts delta, les deltas eux-mêmes doivent être calculés à l'avance pour donner une image globale du travail à effectuer.

En d’autres termes, le moyen le plus simple de calculer le travail qui reste à faire est de le faire.

Il existe maintenant un moyen officiel de le faire dans rsync (version 31.0 du protocole version 31, testée avec 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)

J'ai essayé avec mon /usrdossier parce que je voulais cette fonctionnalité pour transférer des systèmes de fichiers entiers, et /usrsemblait être un bon échantillon représentatif.

Le --info=progress2donne un bon pourcentage global, même s'il ne s'agit que d'une valeur partielle. En fait, mon /usrdossier contient plus de 6 concerts:

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

et a rsyncpris beaucoup de temps pour tout analyser. Donc presque tout le temps que j'ai vu a été complété à environ 90%, mais néanmoins, il est réconfortant de voir que quelque chose est en train d'être copié :)

Références:

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

Vous pouvez avec 'pv' ( apt-get install pvavec Debian et Ubuntu). Je recommande de surveiller le nombre de fichiers transférés, car la quantité de données transférées n’est pas corrélée à la taille des fichiers mais au delta entre la source et la destination. Et compter les fichiers comptera la même progression pour un grand delta et un autre avec un petit delta. Ce qui signifie que, dans tous les cas, l'estimation de l'ETA pourrait être très éloignée. L’ETA basé sur la taille ne fonctionne que si votre destination est vide, dans ce cas delta == taille de la source.

L'idée générale est d'émettre une ligne par fichier 'transféré' de rsync et de compter ces lignes avec 'pv':

rsync -ai / source distante: / dest | pv -les [nombre de fichiers]> / dev / null

Je tends à des systèmes de fichiers entiers de sauvegarde (pour plusieurs raisons), dans ce cas , vous pouvez utiliser le beaucoup moins cher dfpour obtenir le nombre de fichiers (plutôt que duou findWich traversera la hiérarchie source une autre fois après rsync l' a fait). L'option -x apparaît pour vous assurer que rsync reste sur le même système de fichiers source (et ne suit pas les autres montages internes):

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

Si vous voulez compter les fichiers dans / source de manière générale, utilisez find /source|wc -l(warning à nouveau: peut être lent et lourd sur les E / S).

Ce qui suit s'applique à la version 3.0.0 et ultérieure de rsync. Les options décrites ci-dessous ont été introduites dans cette version le 1er mars 2008.

En plus de --info = progress2, vous pouvez également utiliser l' option --no-inc-récursive (ou son raccourci --no-ir alias) pour désactiver la récursion incrémentielle.

Cela générera la liste de fichiers complète au début, plutôt que de découvrir de manière incrémentielle davantage de fichiers au fur et à mesure du transfert. Puisqu'il connaîtra tous les fichiers avant de commencer, cela donnera un meilleur rapport sur l'avancement général. Ceci s’applique au nombre de fichiers - il ne rapporte aucune progression en fonction de la taille des fichiers.

Cela implique un compromis. Construire la liste de fichiers complète à l’avance est plus coûteux en mémoire et peut retarder considérablement le début du transfert. Comme vous vous en doutez, plus il y a de fichiers, plus le délai est long et plus la mémoire requise est importante.

Ce qui suit est extrait du manuel de rsync (source - http://rsync.samba.org/ftp/rsync/rsync.html ):

-r, --recursive

Cela indique à rsync de copier les répertoires de manière récursive. Voir aussi --dirs (-d). À compter de la version 3.0.0 de rsync, l’algorithme récursif utilisé est désormais une analyse incrémentielle qui utilise beaucoup moins de mémoire qu'auparavant et qui commence le transfert une fois que l’analyse des premiers répertoires est terminée. Cette analyse incrémentielle n'affecte que notre algorithme de récursivité et ne modifie pas un transfert non récursif. Cela n'est également possible que lorsque les deux extrémités du transfert sont au moins la version 3.0.0.

Certaines options nécessitent que rsync connaisse la liste complète des fichiers. Par conséquent, ces options désactivent le mode de récurrence incrémentielle. Ceux-ci incluent: --delete-before, --delete-after, --prune-empty-dirs et --delay-updates. De ce fait, le mode de suppression par défaut lorsque vous spécifiez --delete est désormais --delete-During lorsque les deux extrémités de la connexion sont au moins 3.0.0 (utilisez --del ou --delete-During pour demander ce mode de suppression amélioré.) explicitement). Voir aussi l'option --delete-delay qui est un meilleur choix que d'utiliser --delete-after.

La récursion incrémentielle peut être désactivée à l'aide de l' option --no-inc-récursive ou de son alias plus court --no-ir .

Voir aussi https://rsync.samba.org pour connaître les différences de version spécifiques (faites défiler vers le bas et consultez les liens des nouvelles de publication).

Pour les longs transferts, je suis heureux de courir des du -sdeux côtés. Même watch -n1 du -ssi je me sens vraiment anxieux.

watchexécute une commande ( du -sici) périodiquement (toutes les secondes ici) et affiche la sortie en plein écran.

Fondamentalement non. Vous pouvez uniquement afficher la progression par fichier avec l'indicateur --progress, mais c'est à peu près tout.

J'imagine que vous pouvez écrire un wrapper autour de celui-ci ou utiliser l'un des correctifs que vous avez déjà trouvés, mais vous devez vous demander si cela en vaut vraiment la peine. Avez-vous réellement besoin d'un progrès total pour rsync?

J'ai utilisé la réponse de zerodeux et écrit mon propre petit script 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"

J'ai également cherché comment afficher les progrès totaux avec rsync et j'ai trouvé un répondeur utile à partir de ce post: https://stackoverflow.com/questions/7157973/monitoring-rsync-progress

En gros, vous pouvez utiliser --info = progress2 dans la version dev de rsync 3.1.0 . Voici ce que le doc a dit:

Il existe également une option --info = progress2 qui génère des statistiques basées sur le transfert complet, plutôt que sur des fichiers individuels. Utilisez cet indicateur sans générer de nom de fichier (par exemple, évitez -v ou spécifiez --info = name0 si vous souhaitez savoir comment se déroule le transfert sans faire défiler l'écran avec beaucoup de noms. (Vous n'avez pas besoin de spécifier - option progress pour utiliser --info = progress2.)

J'ai utilisé la réponse de zerodeux et écrit mon propre petit script 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"

J'ai changé le TODO dry-run en

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

Il trouve le nombre de fichiers très vite!

Si vous ne possédez pas la dernière version de rsync (par exemple, OS X est 2.6.9) et que vous ne pouvez pas l'utiliser --info=progress2, voici une autre alternative pour vous enregistrer à partir des pages de texte défilant en cours:

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

Cela affichera sur une ligne le nom du dernier fichier en cours de transfert:

Transferring: the-latest.file

Utilisation

lsof -ad3-999 -c rsync

Pour voir quels fichiers rsync a actuellement ouverts (montrera la taille du fichier), rsync est copié dans un fichier caché localement

J'en ferais un commentaire, mais je n'ai pas assez de réputation. En réponse au commentaire de naught101 sur la réponse choisie, l'option --progress indique le nombre de fichiers transférés sur le montant total à transférer. Je n'avais pas compris cela avant de regarder ce post et de regarder la sortie plus attentivement.

La statistique «à vérifier» indique le nombre de fichiers laissés sur le total. Ceci est très utile lors de la synchronisation vers une nouvelle destination afin que vous sachiez que tous les fichiers seront entièrement copiés.

De la page de manuel:

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.

Notez que même --info = progress2 n'est pas entièrement fiable car ce pourcentage est basé sur le nombre de fichiers que rsync «connaît» au moment où la progression est affichée. Ce n'est pas nécessairement le nombre total de fichiers à synchroniser (par exemple, s'il détecte un grand nombre de fichiers volumineux dans un répertoire profondément imbriqué). Une façon de s’assurer que --info = progress2 ne "saute pas en arrière" dans l’indication de progression serait de forcer rsync à analyser tous les répertoires de manière récursive avant de lancer la synchronisation (au lieu de son comportement par défaut consistant à effectuer une analyse incrémentielle récursive), en fournissant également l'option --no-inc-récursive. Notez cependant que cette option augmentera également l'utilisation de la mémoire rsync et son exécution.

J'utilise un script qui extrait les informations de / proc // io pour le processus rsync (ou tout autre processus) et sachant que le montant total à transférer permet de calculer la progression.

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

Si votre version de rsyncn'accepte pas l' --info=progress2option, vous pouvez utiliser tqdm:

À installer:

pip install tqdm

Utiliser:

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

Peut-être que vous pouvez combiner pvavec rsync. Surtout le paramètre --sizepourrait être utile. En regardant les docs, quelque chose comme pv --size $(du -sb . | awk '{print $1}') | rsync -av . host:/your/pathdevrait fonctionner.

Ici vous trouverez la documentation et des logiciels.

Je n'ai pas essayé cela seul.

Peut-être un peu tard ici, mais les futurs demandeurs de réponses pourraient en bénéficier.

Cela m'ennuyait aussi, alors j'ai pensé que je devrais me salir et écrire mon premier script. Le paquet zenity doit être installé (sudo apt-get install zenity), mais je suis sûr qu'il le sera probablement déjà. De plus, j'utilise wmctrl (contrôle du gestionnaire de fenêtres) pour changer le titre de la boîte de dialogue de progression, une fois celle-ci terminée. Il est facile à installer, mais ne changera rien si vous ne le faites pas. J'aime juste voir quand c'est fait dans mon panel.

Le script demande en gros un répertoire source et un répertoire de destination, calcule le pourcentage de la destination par rapport à la source en utilisant du et affiche une barre de progression.

Note: Ceci ne fonctionne que pour la synchronisation complète de répertoire / fichier (je l'utilise généralement pour faire des sauvegardes de cache d'apt), donc pas d'option --exclude = / file / in / répertoire-source. Cela ne fonctionnera pas non plus s'il y a des fichiers / répertoires dans le répertoire de destination, pas dans le répertoire source. Je ne sais pas si cela fonctionne pour les sources / destinations distantes car je n'en ai jamais eu besoin ni des ressources pour le tester.

PS Ce script peut être très mal écrit ou très inefficace (script-vierge ici), mais au moins il remplit son objectif et vous pouvez bien sûr l'éditer et l'améliorer pour l'adapter à vos besoins. PSS. En outre, impossible d'obtenir le bouton d'annulation pour tuer rsync alors je l'ai simplement supprimé.

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