copier d'abord les plus petits fichiers?

J'ai un grand répertoire contenant des sous-répertoires et des fichiers que je souhaite copier récursivement.

Existe-t-il un moyen de dire cpqu'il doit effectuer l'opération de copie par ordre de taille de fichier, afin que les plus petits fichiers soient copiés en premier?

Cela fait tout le travail en une seule fois - dans tous les répertoires enfants, le tout dans un seul flux sans aucun problème de nom de fichier. Il copiera du plus petit au plus grand chaque fichier que vous avez. Vous devrez le faire mkdir ${DESTINATION}s'il n'existe pas déjà.

find . ! -type d -print0 |
du -b0 --files0-from=/dev/stdin |
sort -zk1,1n | 
sed -zn 's/^[^0-9]*[0-9]*[^.]*//p' |
tar --hard-dereference --null -T /dev/stdin -cf - |
    tar -C"${DESTINATION}" --same-order -xvf -

Mais tu sais quoi? Ce que cela ne fait pas, c'est des répertoires enfants vides . Je pourrais faire une redirection sur ce pipeline, mais ce n'est qu'une condition de concurrence qui attend de se produire. Le plus simple est probablement le meilleur. Alors faites-le juste après:

find . -type d -printf 'mkdir -p "'"${DESTINATION}"'/%p"\n' |
    . /dev/stdin

Ou, puisque Gilles fait un très bon point dans sa réponse pour préserver les autorisations de répertoire, je devrais essayer aussi. Je pense que cela le fera:

find . -type d -printf '[ -d "'"${DESTINATION}"'/%p" ] || 
    cp "%p" -t "'"${DESTINATION}"'"\n' |
. /dev/stdin

Je serais prêt à parier que c'est plus rapide que de mkdirtoute façon.

Voici une méthode rapide et sale à utiliser rsync. Pour cet exemple, je considère que tout ce qui est inférieur à 10 Mo est "petit".

Transférez d'abord uniquement les petits fichiers:

rsync -a --max-size=10m srcdir dstdir

Transférez ensuite les fichiers restants. Les petits fichiers précédemment transférés ne seront pas recopiés sauf s'ils ont été modifiés.

rsync -a srcdir dstdir

De man 1 rsync

   --max-size=SIZE
          This  tells  rsync to avoid transferring any file that is larger
          than the specified SIZE. The SIZE value can be suffixed  with  a
          string  to  indicate  a size multiplier, and may be a fractional
          value (e.g. "--max-size=1.5m").

          This option is a transfer rule, not an exclude,  so  it  doesn’t
          affect  the  data  that  goes  into  the file-lists, and thus it
          doesn’t affect deletions.  It just limits  the  files  that  the
          receiver requests to be transferred.

          The  suffixes  are  as  follows:  "K"  (or  "KiB") is a kibibyte
          (1024), "M" (or "MiB") is a mebibyte (1024*1024),  and  "G"  (or
          "GiB")  is  a gibibyte (1024*1024*1024).  If you want the multi‐
          plier to be 1000 instead of  1024,  use  "KB",  "MB",  or  "GB".
          (Note: lower-case is also accepted for all values.)  Finally, if
          the suffix ends in either "+1" or "-1", the value will be offset
          by one byte in the indicated direction.

          Examples:    --max-size=1.5mb-1    is    1499999    bytes,   and
          --max-size=2g+1 is 2147483649 bytes.

Bien sûr, l'ordre de transfert fichier par fichier n'est pas strictement du plus petit au plus grand, mais je pense que c'est peut-être la solution la plus simple qui répond à l'esprit de vos exigences.

Pas cpdirectement, c'est bien au-delà de ses capacités. Mais vous pouvez vous arranger pour appeler cples fichiers dans le bon ordre.

Zsh permet commodément de trier les fichiers par taille avec un qualificatif glob . Voici un extrait zsh qui copie les fichiers dans un ordre croissant de taille de dessous /path/to/source-directoryen dessous /path/to/destination-directory.

cd /path/to/source-directory
for x in **/*(.oL); do
  mkdir -p /path/to/destination-directory/$x:h
  cp $x /path/to/destination-directory/$x:h
done

Au lieu d'une boucle, vous pouvez utiliser la zcpfonction. Cependant, vous devez d'abord créer les répertoires de destination, ce qui peut être fait dans un oneliner cryptique.

autoload -U zmv; alias zcp='zmv -C'
cd /path/to/source-directory
mkdir **/*(/e\''REPLY=/path/to/destination-directory/$REPLY'\')
zcp -Q '**/*(.oL)' '/path/to/destination-directory/$f'

Cela ne préserve pas la propriété des répertoires source. Si vous le souhaitez, vous devrez enrôler un programme de copie approprié tel que cpioou pax. Si vous faites cela, vous n'avez pas besoin d'appeler cpou zcpen plus.

cd /path/to/source-directory
print -rN **/*(^.) **/*(.oL) | cpio -0 -p /path/to/destination-directory

Je ne pense pas qu'il y ait moyen cp -rde le faire directement. Comme il peut s'écouler une période de temps indéterminée avant d'obtenir une solution find/ assistant awk, voici un script perl rapide:

#!/usr/bin/perl
use strict;
use warnings FATAL => qw(all);

use File::Find;
use File::Basename;

die "No (valid) source directory path given.\n"
    if (!$ARGV[0] || !-d -r "/$ARGV[0]");

die "No (valid) destination directory path given.\n"
    if (!$ARGV[1] || !-d -w "/$ARGV[1]");

my $len = length($ARGV[0]);
my @files;
find (
    sub {
        my $fpath = $File::Find::name;
        return if !-r -f $fpath;
        push @files, [
            substr($fpath, $len),
            (stat($fpath))[7],
        ]
    }, $ARGV[0]
);

foreach (sort { $a->[1] <=> $b->[1] } @files) {
    if ($ARGV[2]) {
        print "$_->[1] $ARGV[0]/$_->[0] -> $ARGV[1]/$_->[0]\n";
    } else {
        my $dest = "$ARGV[1]/$_->[0]";
        my $dir = dirname($dest);
        mkdir $dir if !-e $dir;
        `cp -a "$ARGV[0]/$_->[0]" $dest`;
    }
} 

• Utilisez ceci: ./whatever.pl /src/path /dest/path

• Les arguments doivent être tous deux des chemins absolus ; ~, ou toute autre chose que le shell étend à un chemin absolu est très bien.

• Si vous ajoutez un troisième argument (n'importe quoi, à l'exception d'un littéral 0), au lieu de le copier, il imprimera pour standardiser un rapport de ce qu'il ferait, avec des tailles de fichiers en octets ajoutées, par exemple

  4523 /src/path/file.x -> /dest/path/file.x
  12124 /src/path/file.z -> /dest/path/file.z

  Notez qu'ils sont classés par ordre croissant de taille.

• La cpcommande sur la ligne 34 est une commande shell littérale, vous pouvez donc faire ce que vous voulez avec les commutateurs (je viens de l'utiliser -apour préserver tous les traits).

• File::Findet File::Basenamesont les deux modules de base, c'est-à-dire qu'ils sont disponibles dans toutes les installations de perl.

une autre option serait d'utiliser cp avec la sortie de du:

oldIFS=$IFS
IFS=''
for i in $(du -sk *mpg | sort -n | cut -f 2)
do
    cp $i destination
done
IFS=$oldIFS

Cela pourrait toujours être fait sur une seule ligne, mais je l'ai divisé pour que vous puissiez le lire