rsync --delete --files-from = liste / dest / ne supprime pas les fichiers indésirables

comme vous pouvez le voir dans le titre j'essaie de synchroniser un dossier avec une liste de fichiers. J'espère que cette commande supprime tous les fichiers dans dest/qui ne sont pas sur la liste, mais il n'a pas.

J'ai donc cherché un peu et de savoir maintenant, que rsync ne peut pas le faire.

Mais j'en ai besoin, donc, connaissez-vous une façon de le faire?

PS: La liste est générée par un script python, il est imaginable que votre solution d'utiliser du code python.

MODIFIER, soyons concrets:

La liste ressemble à ceci:

/home/max/Musik/Coldplay/Parachutes/Trouble.mp3
/home/max/Musik/Coldplay/Parachutes/Yellow.mp3
/home/max/Musik/Coldplay/A Rush of Blood to the Head/Warning Sign.mp3
/home/max/Musik/Coldplay/A Rush of B-Sides to Your Head/Help Is Around the Corner.mp3
/home/max/Musik/Coldplay/B-Sides (disc 3)/Bigger Stronger.mp3

et la commande comme ceci:

rsync --delete --files-from=/tmp/list //home/max/Desktop/foobar/

Cela fonctionne, mais si je supprime une ligne, il n'est pas supprimé dans foobar/.

EDIT 2:

rsync -r --include-from=/tmp/list --exclude=* --delete-excluded //home/max/Desktop/foobar/

Que le travail ni ...

source d'informationauteur dAnjou

rsync

14

Peut-être vous pourriez le faire à l'aide d'une liste d'inclure des motifs au lieu de cela, et d'utiliser --delete-excluded (qui comme son nom l'indique)? Quelque chose comme:
```
rsync -r --include-from=<patternlistfile> --exclude=* --delete-excluded /dest/
```
Si les noms de fichiers sont susceptibles de contenir des caractères génériques (*? et [), alors vous devrez peut-être modifier le Python de leur échapper:
```
re.sub("([[*?])", r"\\\1", "abc[def*ghi?klm")
```
Edit: basée sur les modèles d'appariement fonctionne légèrement différemment à --files-from dans ce rsync de ne pas répéter dans des répertoires qui correspondent à exclure un modèle, pour des raisons d'efficacité. Donc, si vos fichiers sont dans le /some/dir et /some/other/dir alors votre modèle de fichier doit ressembler à:
```
/some/
/some/dir/
/some/dir/file1
/some/dir/file2
/some/other/
/some/other/dir/
/some/other/dir/file3
...
```
Sinon, si tous les fichiers sont dans le même répertoire, vous pouvez réécrire la commande légèrement:
```
rsync -r --include-from=<patternlistfile> --exclude=* --delete-excluded /some/dir/dest/
```
et puis votre schéma devient:
```
/file1
/file2
```
Edit: de Réflexion à ce sujet, vous pouvez inclure tous les répertoires avec un motif:
```
/**/
```
mais alors il faudrait retrouver avec l'ensemble de l'arborescence de répertoires dans dest/ qui n'est probablement pas ce que vous voulez. Mais en la combinant avec -m (qui pruneaux répertoires vides) devrait résoudre que - si la commande se termine quelque chose comme:
```
rsync -m -r --delete-excluded --include-from=<patternfile> --exclude=* /dest/
```
et le fichier de modèle:
```
/**/
/some/dir/file1
/some/other/dir/file3
```
8

Ce n'est pas exactement la solution, mais les gens viennent ici pourrait trouver cela utile: Depuis rsync 3.1.0 il y a un --delete-missing-args paramètre qui supprime les fichiers dans le répertoire de destination lorsque vous synchroniser deux répertoires à l'aide de --files-from. Vous devez spécifier les fichiers supprimés dans la /tmp/list avec des fichiers que vous ne voulez copier:
```
rsync --delete-missing-args --files-from=/tmp/list /source/dir /destination/dir
```
Voir la page de man pour plus de détails.
6

Comme vous l'avez expliqué, la commande
```
rsync -r --delete --files-from=$FILELIST user@server:/$DEST/
```
ne pas supprimer le contenu de la destination lorsqu'une entrée de $FILELIST a été supprimé. Une solution simple est d'utiliser plutôt la suivante.
```
mkdir -p $DEST
rm -rf $TEMP
rsync -r --link-dest=$DEST --files-from=$FILELIST user@server:/$TEMP/
rm -r $DEST
mv $TEMP $DEST
```
Cela indique à rsync d'utiliser un vide de destination. Les fichiers qui sont déjà présents dans le link-dest-répertoire sont localement difficiles liées et non pas copié. Enfin, le vieux de destination est remplacé par le nouveau. La première mkdir crée un vide $DEST si $DEST n'existe pas, pour éviter rsync erreur. ($Variables sont supposées porter le chemin d'accès complet au fichier concerné ou d'un répertoire.)

Il y a quelques petits frais généraux pour les lier entre eux, mais vous n'avez pas besoin de jouer avec complexe d'inclusion/exclusion-stratégies.

Inspiré de m4t, mais à l'aide de ... rsync pour le nettoyage

rsync -r --link-dest=$dst --files-from=filelist.txt user@server:$source/$temp
rsync -ra --delete --link-dest=$temp $temp/$dest

Explicite build --exclude-from=... semble le seul moyen de synchroniser la liste de fichiers.

stdin = subprocess.PIPE
other_params.append("--exclude-from=-") #from stdin 

p = subprocess.Popen( 'rsync -e ssh -zthvcr --compress-level=9 --delete'.split() + other_params + [src, dst], stdin =  PIPE)

if relative_files_list != None:
    #hack: listing of excluded files seems the only way to delete unwanted files at destination
    files = set(map(norm_fn, relative_files_list)) #make hash table, for huge lists
    for path, ds, fs in os.walk(src):
        for f in fs:
            rel_path_f = norm_fn(os.path.relpath(os.path.join(path, f), src))
            if rel_path_f not in files:
                #print 'excluding', rel_path_f.replace('\\', '/')
                p.stdin.write(rel_path_f + '\n')
    p.stdin.close()
assert 0 == p.wait()

Je me rends compte de cette question a été posée il y a longtemps, mais je n'étais pas satisfait de la réponse.

Voici comment j'ai résolu le problème, en supposant une liste de lecture créée par mpd:

#!/bin/bash                                                                 

playlist_path="/home/cpbills/.config/mpd/playlists"
playlist="${playlist_path}/.m3u"
music_src="/home/cpbills/files/music"
music_dst="/mnt/sdcard/music/"

if [[ -e "$playlist" ]]; then
  # Remove old files
  find "$music_dst" -type f | while read file; do
    name="$(echo "$file" | sed -e "s!^$music_dst!!")"
    if ! grep -qF "$name" "$playlist"; then
      rm "$file"
    fi
  done

  # Remove empty directories
  find "$music_dst" -type d -exec rmdir {} \; 2>/dev/null

  rsync -vu \
      --inplace \
      --files-from="$playlist" \
      "$music_src" "$music_dst"
else
  printf "%s does not exist\n" "$playlist" 1>&2
  exit 1
fi

-1

rsync est idéal pour garder les répertoires à synchroniser, parmi d'autres choses utiles. Si vous avez une copie exacte de la SOURCE, et que vous voulez supprimer des fichiers sur la DESTINATION, vous pouvez les supprimer à partir de la SOURCE et de la rsync --delete option supprimer de DEST.

Cependantsi vous avez juste un arbitraire de la liste des fichiers que vous souhaitez supprimer, je vous suggère d'utiliser SSH pour faire:
```
ssh [email protected] rm /path/to/file1 /path/to/file2
```
Exécute le rm de commande sur l'hôte distant.

À l'aide de python, vous pouvez:
```
import subprocess
FileList = ['/path/to/file1', '/path/to/file2']
subprocess.call(['ssh', '[email protected]', 'rm'] + FileList)
```
~profiter de

Vous devez vous connecter pour publier un commentaire.