Je veux regarder un dossier sur mon Mac (Snow Leopard) puis exécuter un script (en lui donnant le nom de fichier de ce qui vient d'être déplacé dans un dossier (comme paramètre ... x.sh "nom de fichier")).

J'ai un script tout écrit en bash (x.sh) qui déplacera certains fichiers et autres choses en entrée $ 1 J'ai juste besoin d'OSX pour me donner le nom du fichier lorsque de nouveaux fichiers / dossiers sont déplacés / créés dans un répertoire.

Une telle commande?

fswatch

fswatch est un petit programme utilisant l'API FSEvents de Mac OS X pour surveiller un répertoire. Lorsqu'un événement concernant une modification de ce répertoire est reçu, la commande shell spécifiée est exécutée par/bin/bash

Si vous êtes sous GNU / Linux, inotifywatch (qui fait partie du inotify-toolspackage sur la plupart des distributions) fournit des fonctionnalités similaires.

Mise à jour: fswatch peut désormais être utilisée sur de nombreuses plates-formes, notamment BSD, Debian et Windows.

Syntaxe / Un exemple simple

La nouvelle façon de regarder plusieurs chemins - pour les versions 1.x et supérieures :

fswatch -o ~/path/to/watch | xargs -n1 -I{} ~/script/to/run/when/files/change.sh

Remarque: Le nombre sorti par -osera ajouté à la fin de la xargscommande si ce n'est pour le -I{}. Si vous choisissez d'utiliser ce numéro, placez-le {}n'importe où dans votre commande.

L'ancienne méthode pour les versions 0.x :

fswatch ~/path/to/watch ~/script/to/run/when/files/change.sh

Installation avec Homebrew

Le 9/12/13, il a été ajouté à homebrew - yay! Donc, mettez à jour votre liste de formules ( brew update) et tout ce que vous avez à faire est de:

brew install fswatch

Installation sans Homebrew

Tapez ces commandes dans Terminal.app

cd /tmp
git clone https://github.com/alandipert/fswatch
cd fswatch/
make
cp fswatch /usr/local/bin/fswatch

Si vous n'avez pas de ccompilateur sur votre système, vous devrez peut-être installer les outils de ligne de commande Xcode ou Xcode - tous deux gratuits. Cependant, si tel est le cas, vous devriez probablement vérifier les homebrews .

Options supplémentaires pour la fswatchversion 1.x

Usage:
fswatch [OPTION] ... path ...

Options:
 -0, --print0          Use the ASCII NUL character (0) as line separator.
 -1, --one-event       Exit fsw after the first set of events is received.
 -e, --exclude=REGEX   Exclude paths matching REGEX.
 -E, --extended        Use exended regular expressions.
 -f, --format-time     Print the event time using the specified format.
 -h, --help            Show this message.
 -i, --insensitive     Use case insensitive regular expressions.
 -k, --kqueue          Use the kqueue monitor.
 -l, --latency=DOUBLE  Set the latency.
 -L, --follow-links    Follow symbolic links.
 -n, --numeric         Print a numeric event mask.
 -o, --one-per-batch   Print a single message with the number of change events.
                       in the current batch.
 -p, --poll            Use the poll monitor.
 -r, --recursive       Recurse subdirectories.
 -t, --timestamp       Print the event timestamp.
 -u, --utc-time        Print the event time as UTC time.
 -v, --verbose         Print verbose output.
 -x, --event-flags     Print the event flags.

See the man page for more information.

Vous pouvez utiliser launchd à cet effet. Launchd peut être configuré pour lancer automatiquement un programme lorsqu'un chemin de fichier est modifié.

Par exemple, le plist de configuration de launchd suivant lancera le programme /usr/bin/loggerlorsque le dossier du bureau de mon compte d'utilisateur est modifié:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>logger</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/bin/logger</string>
        <string>path modified</string>
    </array>
    <key>WatchPaths</key>
    <array>
        <string>/Users/sakra/Desktop/</string>
    </array>
</dict>
</plist>

Pour activer le plist de configuration, enregistrez-le dans le dossier LaunchAgents de votre dossier Library sous le nom "logger.plist".

Depuis le shell, vous pouvez ensuite utiliser la commande launchctlpour activer le logger.plist en exécutant:

$ launchctl load ~/Library/LaunchAgents/logger.plist

Le dossier du bureau est maintenant surveillé. Chaque fois qu'il est modifié, vous devriez voir une sortie dans le system.log (utilisez Console.app). Pour désactiver le logger.plist, exécutez:

$ launchctl unload ~/Library/LaunchAgents/logger.plist

Le fichier de configuration ci-dessus utilise l' WatchPathsoption. Alternativement, vous pouvez également utiliser l' QueueDirectoriesoption. Consultez la page de manuel launchd pour plus d'informations.

Le gardien de Facebook , disponible via Homebrew, a également l'air sympa. Il prend également en charge le filtrage:

Ces deux lignes établissent une surveillance sur un répertoire source, puis définissent un déclencheur nommé "buildme" qui exécutera un outil nommé "minify-css" chaque fois qu'un fichier CSS est modifié. L'outil recevra une liste des noms de fichiers modifiés.

$ watchman watch ~/src

$ watchman -- trigger ~/src buildme '*.css' -- minify-css

Notez que le chemin doit être absolu.

Vous voudrez peut-être jeter un œil à (et peut-être étendre) mon petit outil kqwait. Actuellement, il reste assis et attend un événement d'écriture sur un seul fichier, mais l' architecture kqueue permet un empilement d'événements hiérarchique ...

watchdog est une API python multiplateforme pour regarder les fichiers / répertoires, et il dispose d'un outil "astuces" intégré qui vous permet de déclencher des actions (y compris les commandes shell) lorsque des événements se produisent (y compris un nouveau fichier ajouté, un fichier supprimé et un fichier modifié).

C'est juste pour mentionner entr comme alternative sur OSX pour exécuter des commandes arbitraires lorsque les fichiers changent. Je le trouve simple et utile.

Voici un one-liner utilisant sschoberl' outil de .

$ while true; do kqwait ./file-to-watch.js; script-to-execute.sh; done

Modifier: fsw a été fusionné fswatch. Dans cette réponse, toute référence à fswdevrait maintenant être lue fswatch.

J'ai écrit un fswatchremplacement en C ++ appelé fswqui présente plusieurs améliorations:

• C'est un projet GNU Build System qui s'appuie sur n'importe quelle plate-forme prise en charge (OS X v.> = 10.6) avec

  ./configure && make && sudo make install
  

• Plusieurs chemins peuvent être passés sous différents arguments:

  fsw file-0 ... file-n 
  

• Il sauvegarde un enregistrement détaillé avec toutes les informations sur l'événement, telles que:

  Sat Feb 15 00:53:45 2014 - /path/to/file:inodeMetaMod modified isFile 
  

• Sa sortie est facile à analyser afin que la fswsortie puisse être dirigée vers un autre processus.

• La latence peut être personnalisée avec -l, --latency.
• Des drapeaux d'événements numériques peuvent être écrits au lieu de textuels avec -n, --numeric.
• Le format d'heure peut être personnalisé à l'aide de strftimechaînes de format avec -t, --time-format.
• L'heure peut être l' heure locale de la machine (par défaut) ou l'heure UTC avec -u, --utc-time.

Obtenir fsw:

fswest hébergé sur GitHub et peut être obtenu en clonant son référentiel:

    git clone https://github.com/emcrisostomo/fsw

Installation de fsw:

fsw peut être installé à l'aide des commandes suivantes:

    ./configure && make && sudo make install

Plus d'informations:

J'ai également écrit un billet de blog d' introduction où vous pouvez trouver quelques exemples sur le fswfonctionnement.

Les actions du dossier Apple OSX vous permettent d'automatiser les tâches en fonction des actions prises sur un dossier.

Ma fourchette de fswatch fournit la fonctionnalité inotifywait -mavec un peu moins (pas d'attente, plus! J'ai beaucoup plus de problèmes sur Linux avec inotifywait...) une sortie conviviale pour l'analyse.

C'est une amélioration par rapport à l'original fswatchcar il envoie le chemin réel du fichier modifié sur STDOUT plutôt que de vous obliger à fournir un programme qu'il bifurque.

Cela a été solide comme fondement d'une série de scripts bash effrayants que j'utilise pour automatiser des trucs.

(ceci est hors sujet) inotifywaitsous Linux, d'autre part, nécessite beaucoup de compliments et je n'ai toujours pas trouvé un bon moyen de le gérer, bien que je pense que quelque chose basé sur node.jspourrait être le ticket.

J'ai un GIST pour cela et l'utilisation est assez simple

watchfiles <cmd> <paths...>

Pour illustrer, la commande suivante fera écho à Hello Worldchaque fois que file1OU file2changera; et la vérification de l'intervalle par défaut est de 1 seconde

watchfiles 'echo Hello World' /path/to/file1 /path/to/file2 

Si je veux vérifier toutes les 5 secondes, je peux utiliser le -tdrapeau

watchfiles -t 'echo Hello World' /path/to/file1 /path/to/file2 

• -vactive le verbosemode qui affiche les informations de débogage
• -qfait watchfilesexécuter tranquillement ( #sera affiché pour que l'utilisateur puisse voir que le programme s'exécute)
• -qqfait watchfilesexécuter complètement silencieusement
• -h montre l'aide et l'utilisation

https://gist.github.com/thiagoh/5d8f53bfb64985b94e5bc8b3844dba55

J'ai fini par le faire pour macOS. Je suis sûr que c'est terrible à bien des égards:

#!/bin/sh
# watchAndRun
if [ $# -ne 2 ]; then
    echo "Use like this:"
    echo "   $0 filename-to-watch command-to-run"
    exit 1
fi
if which fswatch >/dev/null; then
    echo "Watching $1 and will run $2"
    while true; do fswatch --one-event $1 >/dev/null && $2; done
else
    echo "You might need to run: brew install fswatch"
fi

Si vous souhaitez utiliser NodeJS, vous pouvez utiliser un package appelé chokidar (ou chokidar-cli en fait) pour l'observation, puis utiliserrsync (inclus avec Mac):

Commande Rsync:

$ rsync -avz --exclude 'some-file' --exclude 'some-dir' './' '/my/destination'

Chokidar cli (installé globalement via npm):

chokidar \"**/*\" -c \"your-rsync-command-above\"

Voici une alternative simple sur une seule ligne pour les utilisateurs qui n'ont pas la watchcommande et qui souhaitent exécuter une commande toutes les 3 secondes:

while :; do your-command; sleep 3; done

C'est une boucle infinie qui est fondamentalement la même que celle qui suit:

watch -n3 your-command