Comment exécuter automatiquement un script lorsque le contenu d'un répertoire change sous Linux?

Je veux exécuter automatiquement un script chaque fois que de nouveaux fichiers sont copiés dans un répertoire particulier. En d'autres termes, y a-t-il un moyen sous Linux de "surveiller" un répertoire pour les changements, puis d'exécuter quelque chose en réponse au changement?

Si vous êtes assez chanceux d'être sur une distribution basée sur Debian, apt-get install dnotify. D'autres distributions ont probablement quelque chose de similaire - recherchez le dnotifynom.

dnotify est un programme simple basé sur l'API dnotify du noyau Linux 2.4.19 +. dnotify peut exécuter une commande spécifiée à chaque fois que le contenu d'un répertoire spécifique change. Il est exécuté à partir de la ligne de commande et prend deux arguments: un ou plusieurs répertoires à surveiller et une commande à exécuter chaque fois qu'un répertoire a changé. Les options contrôlent les événements à déclencher: quand un fichier a été lu dans le répertoire, quand un a été créé, supprimé, etc.

Si vous souhaitez gérer cela dans votre propre programme, dnotify est également l'API que vous souhaitez utiliser.

Vous pouvez exécuter un script avec les outils inotify, quelque chose comme ça. Il surveillera le répertoire pour les changements dans les fichiers modifiés, les nouveaux fichiers et les fichiers supprimés, puis exécutera le script.

#!/bin/sh
while inotifywait -e modify -e create -e delete /home/me/code; do
    rsync [options] /home/me/code/ /media/nfs/code/ 
done

l'incron est fondamentalement ce que vous voulez, je pense. Il utilise inotify comme mécanisme de notification (qui, comme d'autres l'ont souligné, remplace dnotify), mais ne nécessite pas de script qui s'exécute en continu, en utilisant inotifywait ou similaire (bien que, évidemment, le démon incron fonctionne tout le temps). Les «crontabs» à l'échelle du système et les «crontabs» utilisateur sont pris en charge de la même manière que les cron standard, mais plutôt que de spécifier des heures comme déclencheurs, des événements inotify et des noms de fichiers / répertoires sont utilisés.

incron est packagé pour de nombreuses distributions, y compris Ubuntu et Debian, je crois.

Il existe un logiciel uniquement à cette fin, autoenv Vous voudrez peut-être le vérifier.

entr est l'outil de notification de fichiers le plus simple et le plus composable que j'ai vu. Son utilisation est optimisée pour regarder des fichiers plutôt que des répertoires, mais elle peut également résoudre votre cas.

Pour détecter et agir sur le fichier ajouté, combinez-le avec d'autres outils comme par exemple make. entrn'envoie pas le nom ou quelque chose comme ça, il exécute simplement ce que vous lui avez dit d'exécuter.

Pour vérifier les fichiers ajoutés dans un répertoire:

## entr exits with rc=0 when terminated
## rc=1 when watched files go away or don't exist to begin with
## rc=2 when new files arrive in watched directories
until echo /path/to/directory_to_watch | entr -d do_stuff
do sleep 1; done

Si vous souhaitez également agir lorsqu'un fichier existant change:

## Here's why it comes in handy that entr exits when new files are added --
## find gets re-run.
until find /path/to/directory_to_watch/ -path /path/to/directory_to_watch/* |
    entr -d do_stuff
do sleep 1; done

... et c'est là que le mécanisme de boucle est utile, car l' findexpression s'exécutera à nouveau si un fichier est ajouté.

Si vous voulez une meilleure gestion des erreurs et que vous voulez vous assurer que les choses ne s'exécutent qu'une fois par fichier ajouté / supprimé, les choses deviennent un peu bizarres, mais pour ces cas simples, c'est génial.

EDIT: Si vous voulez faire cela au niveau du système, quelque chose comme incron , ajoutez simplement le script à votre gestionnaire de processus préféré (comme s6 , runit , systemd ou sysvinit et sautez la boucle:

#!/bin/bash
exec entr -d do_stuff < <(find /path/to/directory_to_watch/ -path /path/to/directory_to_watch/*)

Le execet la substitution de processus ( <(...)) sont importants lors de l'exécution à partir d'un gestionnaire de processus, pour gérer correctement la signalisation (c'est-à-dire pour éloigner le shell).