Discussion :

[Gros_naze]

Bonjour,
Je cherche à écrire un script qui me permettrait de scruter en permanence un dossier qui contient plusieurs dizaines de milliers de fichiers. Dès qu'un fichier est supprimé (le fichier est supprimé par une application, pas directement par un utilisateur) il faudrait que son nom (au fichier) soit consigné dans un fichier log. Alors j'ai trouvé un bout de code qui permet de scruter un répertoire et qui liste tous les fichiers qui ont été rajoutés mais je n'arrive pas à lister tous les fichiers qui ont été enlevés.

Voilà ce que j'ai trouvé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
#!/bin/sh
# Script qui surveille les répertoires de façon infinie
# Usage: prog rep1 [rep2 ...]
 
# Ecriture de la fonction qui lance un traitement quelconque
# Argument 1: Nom du fichier à traiter
traitement()
{
    (
        # Ici on programme le traitement (un simple "echo" pour l'exemple)
        echo $1
    )
}
 
# Ecriture de la fonction dont le but est de surveiller un répertoire
# Argument 1: Nom du répertoire à surveiller
# Argument 2: Nom du fichier qui sert à conserver les infos
surveillance()
{
    (
        # Balayage de chaque fichier du répertoire donné en argument 1
        ls -a $1 |while read file
        do
            # Si le fichier n'est pas présent dans les infos (donné en argument 2)
            grep "^$file$" $2 1>/dev/null; status=$?
            if test $status -ne 0
            then
                # Le fichier est nouveau - Lancement du traitement
                traitement $1/$file
            fi
 
            # On regénère les infos à partir du "ls"
            ls -a $1 >$2
        done
    )
}
 
# Ecriture du programme principal           
# S'il n'y a pas d'argument, pas la peine de continuer
test $# -eq 0 && exit 1
 
# On diminue la priorité du script (après tout, il n'est pas vraiment primordial)
nice -20
 
# On récupère le nom du script (servira de base aux noms des fichiers de travail)
script=`basename $0 .sh`
 
# Boucle de surveillance infinie
while true
do
    # Traitement de chaque répertoire donné en argument
    for rep in $*
    do
       # Création du nom qui servira à stocker les infos du répertoire
       # On utilise le nom du répertoire en remplaçant "/" par ":"
       info=`echo "$rep" |sed -e "s/\//:/g"`
 
       # Surveillance du répertoire avec le fichier qui servira de mémoire
       surveillance "$rep" "/tmp/$script.$info.bdd"
    done
 
    # Petite tempo parce qu'on ne va pas surveiller à chaque nanoseconde
    sleep 1
done

[ggnore]

ça serait moins couteux en ressources que le processus qui supprime le fichier envoie un signal à ton serveur qu'il a supprimé un fichier en le désignant.
Si tu persistes : inotifywait ou auditctl.

[Gros_naze]

Merci pour le tuyau

[N_BaH]

Bonjour,

pourquoi les fonctions sont-elles exécutées dans un sous-shell ?
ON N'UTILISE PAS ls DANS UN SCRIPT !!! et pourquoi -a ?
si le code de retour d'une commande est utilisé immédiatement après, son enregistrement est inutile.
pourquoi sh, et pas bash ? bash permettrait de se dispenser de basename et sed.

test -ne, test -eq, c'est bien.

à part ça, incron est fait pour ça.

[ggnore]

Bonjour,

pourquoi les fonctions sont-elles exécutées dans un sous-shell ?
ON N'UTILISE PAS ls DANS UN SCRIPT !!! et pourquoi -a ?
si le code de retour d'une commande est utilisé immédiatement après, son enregistrement est inutile.
pourquoi sh, et pas bash ? bash permettrait de se dispenser de basename et sed.

test -ne, test -eq, c'est bien.

à part ça, incron est fait pour ça.

Tu devrais faire un article à ce propos et le linker à chaque fois, tu perdrais moins d'énergie en Allcaps.

[jack-ft]

moi, je ferais un truc avec une boucle toute simple qui examine la liste des fichiers courants avec la dernière version:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/bin/bash
 
DELAY=10
OF=/tmp/lof-$$.txt
NF=/tmp/lnf-$$.txt
LOG=/tmp/log-$$.txt
 
find . -type f | sort > "${OF}"
 
while true; do
  sleep ${DELAY}
  /bin/rm -rf "${NF}" > /dev/null 2>&1
  find . -type f | sort > "${NF}"
  if cmp -s "${OF}" "${NF}" then continue; fi
  if test 0 -ne $(comm -23 "${OF}" "${NF}" | wc -l); then
    DATE=$(date)
    comm -23 "${OF}" "${NF}" | sed -e "s|^|On ${DATE} removed: |" >> "${LOG}"
  fi
  /bin/rm -rf "${OF}" > /dev/null 2>&1
  mv "${NF}" "${OF}"
done

[N_BaH]

la syntaxe de test veut que la partie variable soit à gauche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test $(comm -23 "${OF}" "${NF}" | wc -l) -ne 0

[Flodelarab]

Bonjour

la syntaxe de test veut que la partie variable soit à gauche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test $(comm -23 "${OF}" "${NF}" | wc -l) -ne 0

Et s'il n'y a pas de partie fixe ?

Je ne comprends pas d'où vient l'exigence. Les deux syntaxes marchent.

Nombreux sont les développeurs qui tapent 0==var, car var==0 pourrait devenir var=0 un jour où ils ne sont pas réveillés.
"==" est le test et "=" l'affectation.
0=var renvoie une erreur à l'inverse de var=0 qui laisse passer l'erreur.

[N_BaH]

s'il n'y a pas de partie fixe, c'est test newest == oldest.
autrement, c'est indifférent.

"ça marche" n'est pas une justification suffisante. il y a plein de choses qui "marchent", mais qui ne sont pas correctes pour autant.
"y en a qui le font" n'est pas une justification suffisante, non plus. il y a plein de choses qu'"y en a qui le font", mais qui ne sont pas correctes pour autant.


par contre, je ne retrouve pas l'origine de cette convention.