Suppression des fichiers dans un repertoire avec un temps de pause automatique avec shell/Linux

salut,

il n'était pas question de s'arrêter sur un fichier "xxxx.dat" dans le premier post ?

sinon de ce que j'ai compris, on pourrait aussi bien faire :

Code:

---

1 2 3 4

while true; do find . -maxdepth 1 -name "*.dat" | head -n2000 | xargs -r rm sleep 300 done

---

l'option xargs -r permet de ne pas exécuter la commande si elle est vide (ça remplace le test au -f)
au besoin on doit même pouvoir rajouter -n 2000 pour tout supprimer en une seule passe

et pour peu qu'on vire la boucle while, on met le tout dans un cron */5 et c'est marre...

Citation:

---

Envoyé par N_BaH

(...) dont la publicité (...)

---

la promotion/le plébiscite ? ;) (c'est dans le même rayon)


ps: tiens paf, discussion fermée et j'te crée une nouvelle page en plus, deal with it :lol:

Balkany et N_BaH,

comme j'ai dit depuis le début que je suis débutant, j'aimerais ajouter une boucle while dans ce programme, qui fait:

Tant que $f différent de a00005000.dat alors recommencer

ce que je voudrai avoir est de stopper la suppression quand on arrive au fichier a00005000.dat

Code:

---

1 2 3 4 5 6 7 8 9

a=0 for f in *.dat; do rm "$f" ((a++)) if ((a==2000)); then sleep 300 a=0 fi done

---

j'ai fait ceci mais ça ne marche pas: je suis novice :)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

a=0 for f in *.dat; do while [ $f != 'a00005000.dat' ] do rm "$f" ((a++)) if ((a==2000)); then sleep 300 a=0 fi done done

---

Par avance merci,
TMamp

non, pas besoin de boucle while : la boucle for itère déjà sur chaque élément du répertoire.
il suffit de tester que "$f" vaut "nomCherché", alors quitter le script - si tu n'as rien d'autre à y faire.

Est-il possible de mettre plusieurs condition avec la boucle for ?

par exemple:

Code:

---

1 2 3 4 5 6 7 8 9

a=0 for f in *.dat && f != 'a00005000.dat'; do rm "$f" ((a++)) if ((a==2000)); then sleep 300 a=0 fi done

---

non.

donc le script devient comme ceci ? :

Code:

---

1 2 3 4 5 6 7 8 9 10

a=0 for f in *.dat; do rm "$f" ((a++)) if ((a==2000)); then sleep 300 a=0 test "$f" = "a00005000.dat"; exit fi done

---

Citation:

---

Envoyé par N_BaH

ah, oui, d'accord, tu réutilises $cmd, je cherchais cmd+="$f".

"eval is evil" : il interprète toutes les données en tant que commande.
un petit malin peut toujours passer des commandes dans les données.

il y a des choses, comme ça, dont l'usage en privé est libre, mais dont la publicité ne peut être encouragée. :sm:

---

Ok, merci pour ces précisions « d'ordre moral » :). Par contre (si l'oubli n'est pas volontaire), je pense qu'il manque à ton code un petit bout du genre de celui que j'ai rajouté au mien à la fin : le rm "${ar[@]}" final, pour l'éventuel dernier lot de fichiers dont le nombre n'atteint pas 2000.

est-ce qu'il n'y a pas moyen d'inclure ça directement dans le globbing (comme a0000{{1..4}*,5000}.dat par exemple) de manière à ne sélectionner que les fichiers concernés ?

Citation:

---

Envoyé par BufferBob

Code:

---

1 2 3 4

while true; do find . -maxdepth 1 -name "*.dat" | head -n2000 | xargs -r rm sleep 300 done

---

---

Boucle infinie, non ?

Citation:

---

Envoyé par balkany

Boucle infinie, non ?

---

oui, donc s'il n'y a rien à faire le programme attend 5 mins, puis retente indéfiniment, si entre temps de nouveaux fichiers arrivent ils seront automatiquement virés au prochain tour de boucle

sinon pour couper court sur un fichier précis on peut peut-être envisager :

Code:

---

find . -maxdepth 1 -name "*.dat" -print -name "a00005000.dat" -quit | head -n2000 | xargs -r rm

---

par contre le fichier a00005000.dat est inclus dans le traitement

Citation:

---

Envoyé par TMampionona

donc le script devient comme ceci ? :

Code:

---

1 2 3 4 5 6 7 8 9 10

a=0 for f in *.dat; do rm "$f" ((a++)) if ((a==2000)); then sleep 300 a=0 test "$f" = "a00005000.dat"; exit fi done

---

---

Si ce que tu veux faire est bien de sortir dès lors que tu rencontres le fichier a00005000.dat, alors tu dois remonter ta condition en haut de boucle :

Code:

---

1 2 3 4 5 6 7 8 9 10

a=0 for f in *.dat; do test "$f" = "a00005000.dat" && exit rm "$f" ((a++)) if ((a==2000)); then sleep 300 a=0 fi done

---

Ceci dit sans oublier toutes les critiques que ce code a déjà reçues…

ça marche bien, c'est résolu ! Merciiii beaucoup!! merci Balkany et merci à tous!!!!!

Cordialement,
TMamp

Citation:

---

Envoyé par balkany

(si l'oubli n'est pas volontaire), je pense qu'il manque à ton code un petit bout du genre de celui que j'ai rajouté au mien à la fin : le rm "${ar[@]}" final, pour l'éventuel dernier lot de fichiers dont le nombre n'atteint pas 2000.

---

je ne savais pas ce que voulais TMampionona, alors je ne l'ai pas mis...

bon je rebondis sur ma propre réponse, find . -maxdepth 1 -name "*.dat" -print -name "a00005000.dat" -quit c'est en fait pas une bonne idée vu qu'on a aucune garantie sur l'ordre des fichiers

un truc comme ça fait le job :

Code:

---

1 2 3

while find . -maxdepth 1 -name "*.dat" | sort | awk '/a00005000.dat/{exit} 1' | head -n2000 | xargs rm; do sleep 300 done

---

sexyness non-incluse. :calim2:

Citation:

---

sexyness non-incluse.

---

tu m'étonnes;
je ne suis même pas sûr de l'efficience.

Citation:

---

Envoyé par N_BaH

tu m'étonnes;
je ne suis même pas sûr de l'efficience.

---

ça fonctionne. le script termine par une erreur (attendue) sur le rm mais ça fonctionne comme voulu :aie:

après s'il est question de millions de fichiers... je sais pas ce qui ira le plus vite/consommera le moins de mémoire entre les différentes approches (find vs globbing, for vs ls -1 etc.)

je ne mets pas en doute l'efficacité (je sais que tu ne donnerais pas quelque chose qui ne fonctionne pas), je doute que ça fonctionne de façon optimale, par rapport à un simple script bash :
find est plus rapide que bash, c'est sûr
c'est le reste des pipes de commandes externes qui je suspecte de faire perdre en efficience. :koi:

et, non, PAS ls !!! :)

Quelque chose comme ceci l'aurai aussi certainement fait (pas testé) :

Code:

---

echo *.dat | sed 's/a00005000\.dat.*//' | xargs -n 2000 | while read arg line ; do [ -f "${arg}" ] && rm -f $arg $line ; sleep 300; done

---

bon, j'ai revu ma copie pour de meilleures perfs :mrgreen:

sur un lot test de taille moyenne (~3x90k fichiers, j'ai été obligé de découper en plusieurs commandes sinon on se fait pourrir comme quoi la liste d'arguments est trop longue) :

Code:

---

1 2 3 4 5

time touch a0000{0..1}{{0..9},{a..z}}{{0..9},{a..z}}{{0..9},{a..z}}.dat # real 0m5.680s time touch a0000{2..3}{{0..9},{a..z}}{{0..9},{a..z}}{{0..9},{a..z}}.dat # real 0m5.435s time touch a0000{4..5}{{0..9},{a..z}}{{0..9},{a..z}}{{0..9},{a..z}}.dat # real 0m5.398s $ find . -name "*.dat" | wc -l 279936

---

j'ai d'abord testé différentes façons de s'y prendre (3 mesures successives à chaque fois) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

$ time find . -name "*.dat" >/dev/null real 0m0.466s real 0m0.386s real 0m0.413s   $ time echo *.dat >/dev/null real 0m2.514s real 0m2.418s real 0m2.589s   time for i in *.dat; do :; done real 0m3.101s real 0m3.119s real 0m3.090s   time find . -name "*.dat" | sort >/dev/null real 0m2.598s real 0m2.460s real 0m2.551s   time find . -name "*.dat" | awk '$0 < "./a00005000.dat"' >/dev/null real 0m0.524s real 0m0.445s real 0m0.435s

---

la dernière méthode est intéressante, on s'épargne le tri en mémoire de l'intégralité de la liste et on utilise à la place une simple comparaison lexicographique fichier < "a00005000.dat".

la solution qui en découle find+awk+xargs :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

#!/bin/bash   fichier_stop="a00005000.dat" duree_sleep=300 limite_fichiers=2000   find . -name "*.dat" | awk -vTIME=$duree_sleep -vLIMIT=$limite_fichiers -vFILE="./${fichier_stop}" ' BEGIN { FILE = tolower(FILE) }   tolower($0) < FILE { tab[cpt++] = $0 }   cpt == LIMIT { for (i in tab) { print tab[i] } system("sleep " TIME) delete tab cpt = 0 tab[0] = $0 }   END { for (i in tab) print tab[i] } ' | xargs -rn${limite_fichiers} rm

---

sur un petit lot de test pour vérifier que ça fonctionne comme prévu :

Code:

---

1 2 3 4 5 6 7

$ touch a0000{4..5}00{0..9}.dat $ ls a00004000.dat a00004002.dat a00004004.dat a00004006.dat a00004008.dat a00005000.dat a00005002.dat a00005004.dat a00005006.dat a00005008.dat script a00004001.dat a00004003.dat a00004005.dat a00004007.dat a00004009.dat a00005001.dat a00005003.dat a00005005.dat a00005007.dat a00005009.dat $ ./script $ ls a00005000.dat a00005001.dat a00005002.dat a00005003.dat a00005004.dat a00005005.dat a00005006.dat a00005007.dat a00005008.dat a00005009.dat script

---

puis un test grandeur nature avec ~500K fichiers, sans le sleep, sans les mains :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

$ time touch a0000{0..1}{{0..9},{a..z}}{{0..9},{a..z}}{{0..9},{a..z}}.dat # real 0m5.471s $ time touch a0000{2..3}{{0..9},{a..z}}{{0..9},{a..z}}{{0..9},{a..z}}.dat # real 0m5.454s $ time touch a0000{4..5}{{0..9},{a..z}}{{0..9},{a..z}}{{0..9},{a..z}}.dat # real 0m5.525s $ time touch a0000{6..7}{{0..9},{a..z}}{{0..9},{a..z}}{{0..9},{a..z}}.dat # real 0m5.455s $ time touch a0000{8..9}{{0..9},{a..z}}{{0..9},{a..z}}{{0..9},{a..z}}.dat # real 0m5.587s $ find . -name "*.dat" | wc -l 466560 $ time ./script # sans sleep real 0m26.274s $ find . -name "*.dat" | wc -l 233280 $ ls -1 *.dat | head -10 bash: /bin/ls: Liste d'arguments trop longue

---

par contre la limite à 2000 fichiers c'est une contrainte assez pourrie, si on parle vraiment de "millions" de fichiers ça représente énormément de pauses de 5 mins, et donc autant de durée totale pour le traitement.

find | sans -print0, et des développements de variables sans guillemets, c'est "deux" peu casse-gueule.
là, ça marche; ajoutez un fait chier, ça devrait ne plus.