Comment exécuter une commande à chaque fois qu'un fichier est modifié ?

L'outil "fido" peut constituer une autre option pour répondre à ce besoin. Voir https://www.joedog.org/fido-home/

Description

Cela surveillera les changements dans un fichier et exécutera n'importe quelle commande. (y compris d'autres arguments) a été donné comme deuxième déclaration. Elle efface également l'écran et imprime l'heure de la dernière exécution. Remarque : vous pouvez rendre la fonction plus (ou moins) réactive en modifiant le nombre de secondes pendant lesquelles la fonction doit dormir après chaque cycle de la boucle while.

Exemple d'utilisation

watch_file my_file.php php my_file.php

Cette ligne va surveiller un fichier php my_file.php et passer par php l'interprète à chaque fois qu'il change.

Définition de la fonction

function watch_file (){

### Set initial time of file
LTIME=`stat -c %Z $1`
printf "\033c"
echo -e "watching: $1 ---- $(date '+%Y-%m-%d %H:%M:%S')\n-------------------------------------------\n"
${@:2}

while true
do
   ATIME=`stat -c %Z $1`

   if [[ "$ATIME" != "$LTIME" ]]
   then
    printf "\033c"
    echo -e "watching: $1 ---- $(date '+%Y-%m-%d %H:%M:%S')\n-------------------------------------------\n"
    ${@:2}
    LTIME=$ATIME
   fi
   sleep 1
done
}

Crédit

Il s'agit en fait d'une version plus générale de la réponse de VDR.

find peut faire l'affaire.

while true; do
    find /path/to/watched/file -ctime 1s | xargs do-what-you-will
done

find -ctime 1s imprime le nom du fichier s'il a été modifié dans le dernier 1s .

J'ai connu une situation légèrement différente. Mais je pense que cela peut être utile à quelqu'un qui lit cette question.

J'avais besoin d'être informé lorsqu'un fichier journal changeait de taille, mais pas nécessairement immédiatement. Et comme cela pouvait se produire des jours ou des semaines plus tard, je ne pouvais pas utiliser l'option inotify (qui n'était pas installé/activé sur ce serveur de toute façon) en ligne de commande (je ne voulais pas utiliser la commande nohup ou similaire). J'ai donc décidé d'exécuter un bash script sur cron pour vérifier

Le script écrit la taille du fichier surveillé dans un fichier texte et sur chaque cron exécute et vérifie si cette valeur a changé et m'envoie la dernière ligne si elle a été modifiée.

#!/bin/bash
FILE_TO_WATCH="/path/to/log_file.log"
FILESIZE_FILE="/path_to/record.txt"
SUBJECT="Log file 'log_file.log' has changed"
MAILTO="info@example.com"
BODY="Last line of log file:\n"
LAST_LINES=1

# get old recorded file size from file
OLD_FILESIZE=$(cat "${FILESIZE_FILE}")
# write current file size into file
stat --printf="%s" "${FILE_TO_WATCH}" > "${FILESIZE_FILE}"
# get new recorded file size from file
NEW_FILESIZE=$(cat "${FILESIZE_FILE}")

if [ "${OLD_FILESIZE}" != "${NEW_FILESIZE}" ]; then
    echo -e "${BODY}"$(tail -${LAST_LINES} ${FILE_TO_WATCH}) | mail -s "${SUBJECT}" "${MAILTO}"
fi

Inotifywait one-liner

Ceci utilise inotifywait tout en évitant l'utilisation de while read -r :

inotifywait -q --format '%f' -e close_write,moved_to -m . |
    grep --line-buffered -F -x 'myfile.py' |
    xargs -l -i './myfile.py'

Explication : inotifywait édite une ligne avec le nom du fichier lorsqu'il détecte un changement, grep filtre le nom du fichier ciblé, et xargs exécute une commande pour chaque nom de fichier.

inotifywait paramètres :

• -q : Supprimer les messages stderr.
• --format '%f' N'affiche que le nom du fichier, nous ne filtrons pas les événements de toute façon.
• -e close_write,moved_to Ne détecte que close_write (le fichier a été écrit), et moved_to (la plupart des éditeurs utilisent des fichiers d'échange, et déplacent la mémoire tampon vers le fichier lors de l'enregistrement).
• -m Continuer à écouter indéfiniment (appuyer sur CTRL+C pour interrompre).
• . Répertoire cible qui contient le fichier ciblé.

grep paramètres :

• --line-buffered : Vider les lignes immédiatement, traiter comme un flux (comme sed ).
• -F : Nom de fichier littéral, n'analyse pas l'expression régulière (sinon il faudrait échapper le point) : myfile\.py ).
• -x : Correspondre à la ligne entière, et pas seulement à une sous-chaîne du nom de fichier.

xargs paramètres :

• -l : Exécuter pour chaque ligne d'entrée, ne pas regrouper les lignes.
• -i : Empêcher le nom de fichier d'être ajouté comme argument à la commande, il remplace {} dans la commande avec la ligne d'entrée.

Fonction générique pour exécuter une commande lors d'un changement de fichier

Pour un cas plus générique, vous pouvez utiliser cette fonction :

exec-onchange()
{
    local file="$1"
    shift

    # strip path
    local filename="${file##*/}"

    # strip filename
    local path="${file%/*}"
    if [ -z "$path" ]; then path="."; fi

    # catch a custom command
    local cmd="$@"
    local literalFlag=""
    if [ -z "$cmd" ]; then cmd="$path/$filename"; literalFlag="-Fx"; fi

    exec inotifywait -q --format '%f' -e close_write,moved_to -m "$path" |
    grep --line-buffered $literalFlag "$filename" |
    xargs -l -i /bin/bash -c "$cmd"
}

Utilisation :

exec-onchange [file-to-watch] [command-to-execute]

Exemple d'utilisation :

exec-onchange myfile.py

Notez que l'argument est littéral, sauf si une commande personnalisée est ajoutée, auquel cas le premier argument devient une expression régulière. Bien que dans ce cas, les expressions régulières ne soient autorisées que pour la correspondance du nom de fichier, et non du chemin.

Cette fonction permet une utilisation plus complexe. Comme la compilation automatique, tout en exécutant l'exécutable compilé dès que la compilation est terminée (en utilisant un exec-onchange séparé, la compilation peut être faite tout en continuant à exécuter build/main) :

exec-onchange 'src/.*\.cpp' 'echo "{} changed"; gcc src/*.cpp -o build/main' &
exec-onchange build/main