Come eseguire un comando ogni volta che cambia un file?

Voglio un modo rapido e semplice per eseguire un comando ogni volta che un file cambia. Voglio qualcosa di molto semplice, qualcosa che lascerò in esecuzione su un terminale e lo chiuderò ogni volta che avrò finito di lavorare con quel file.

Attualmente sto usando questo:

while read; do ./myfile.py ; done

E poi devo andare su quel terminale e premere Enter, ogni volta che salvo quel file sul mio editor. Quello che voglio è qualcosa del genere:

while sleep_until_file_has_changed myfile.py ; do ./myfile.py ; done

O qualsiasi altra soluzione così semplice.

A proposito: sto usando Vim e so di poter aggiungere un autocomando per eseguire qualcosa su BufWrite, ma questo non è il tipo di soluzione che voglio ora.

Aggiornamento: voglio qualcosa di semplice, scartabile se possibile. Inoltre, voglio che qualcosa venga eseguito in un terminale perché voglio vedere l'output del programma (voglio vedere i messaggi di errore).

Informazioni sulle risposte: grazie per tutte le risposte! Sono tutti molto bravi e ognuno ha un approccio molto diverso dagli altri. Dato che devo accettarne solo uno, sto accettando quello che ho effettivamente usato (era semplice, veloce e facile da ricordare), anche se so che non è il più elegante.

Semplice, usando inotifywait (installa il inotify-toolspacchetto della tua distribuzione ):

while inotifywait -e close_write myfile.py; do ./myfile.py; done

o

inotifywait -q -m -e close_write myfile.py |
while read -r filename event; do
  ./myfile.py         # or "./$filename"
done

Il primo frammento è più semplice, ma ha un aspetto negativo significativo: mancherà le modifiche apportate mentre inotifywaitnon è in esecuzione (in particolare mentre myfileè in esecuzione). Il secondo frammento non presenta questo difetto. Tuttavia, attenzione che presuppone che il nome del file non contenga spazi bianchi. In questo caso, utilizzare l' --formatopzione per modificare l'output in modo da non includere il nome del file:

inotifywait -q -m -e close_write --format %e myfile.py |
while read events; do
  ./myfile.py
done

Ad ogni modo, c'è una limitazione: se un programma sostituisce myfile.pyun altro file, anziché scrivere nell'esistente myfile, inotifywaitmorirà. Molti editor funzionano in questo modo.

Per superare questa limitazione, utilizzare inotifywaitnella directory:

inotifywait -e close_write,moved_to,create -m . |
while read -r directory events filename; do
  if [ "$filename" = "myfile.py" ]; then
    ./myfile.py
  fi
done

In alternativa, usa un altro strumento che utilizza la stessa funzionalità sottostante, come incron (ti consente di registrare eventi quando un file viene modificato) o fswatch (uno strumento che funziona anche su molte altre varianti Unix, usando l'analogo di ciascuna variante di inotify di Linux).

entr ( http://entrproject.org/ ) fornisce un'interfaccia più intuitiva per inotificare (e supporta anche * BSD e Mac OS X).

Rende molto semplice specificare più file da guardare (limitato solo da ulimit -n), elimina la seccatura nel gestire i file che vengono sostituiti e richiede meno sintassi bash:

$ find . -name '*.py' | entr ./myfile.py

Lo sto usando sull'intero albero dei sorgenti del progetto per eseguire i test unitari per il codice che sto modificando ed è stato già un enorme impulso al mio flusso di lavoro.

Flag come -c(svuota lo schermo tra le esecuzioni) e -d(esci quando un nuovo file viene aggiunto a una directory monitorata) aggiungono ancora più flessibilità, ad esempio puoi fare:

$ while sleep 1 ; do find . -name '*.py' | entr -d ./myfile.py ; done

All'inizio del 2018 è ancora in fase di sviluppo attivo e può essere trovato in Debian e Ubuntu ( apt install entr); la costruzione dal repository dell'autore era comunque indolore.

Ho scritto un programma Python per fare esattamente questo chiamato quando cambiato .

L'uso è semplice:

when-changed FILE COMMAND...

O per guardare più file:

when-changed FILE [FILE ...] -c COMMAND

FILEpuò essere una directory. Guarda ricorsivamente con -r. Utilizzare %fper passare il nome file al comando.

Che ne dici di questo script? Utilizza il statcomando per ottenere il tempo di accesso di un file ed esegue un comando ogni volta che si verifica una modifica nel tempo di accesso (ogni volta che si accede al file).

#!/bin/bash

### Set initial time of file
LTIME=`stat -c %Z /path/to/the/file.txt`

while true    
do
   ATIME=`stat -c %Z /path/to/the/file.txt`

   if [[ "$ATIME" != "$LTIME" ]]
   then    
       echo "RUN COMMAND"
       LTIME=$ATIME
   fi
   sleep 5
done

Soluzione con Vim:

:au BufWritePost myfile.py :silent !./myfile.py

Ma non voglio questa soluzione perché è un po 'fastidioso digitare, è un po' difficile ricordare esattamente cosa digitare, ed è un po 'difficile annullare i suoi effetti (è necessario eseguirlo :au! BufWritePost myfile.py). Inoltre, questa soluzione blocca Vim fino al termine dell'esecuzione del comando.

Ho aggiunto questa soluzione qui solo per completezza, in quanto potrebbe aiutare altre persone.

Per visualizzare l'output del programma (e interrompere completamente il flusso di modifica, poiché l'output scriverà sull'editor per alcuni secondi, fino a quando non si preme Invio), rimuovere il :silentcomando.

Se ti capita di aver npminstallato, nodemonè probabilmente il modo più semplice per iniziare, specialmente su OS X, che apparentemente non ha strumenti di inotify. Supporta l'esecuzione di un comando quando cambia una cartella.

Per coloro che non possono installare inotify-toolscome me, questo dovrebbe essere utile:

watch -d -t -g ls -lR

Questo comando uscirà quando l'output cambia, ls -lRelencherà ogni file e directory con le sue dimensioni e date, quindi se un file viene modificato dovrebbe uscire dal comando, come dice man:

-g, --chgexit
          Exit when the output of command changes.

So che questa risposta potrebbe non essere letta da nessuno, ma spero che qualcuno la raggiunga.

Esempio da riga di comando:

~ $ cd /tmp
~ $ watch -d -t -g ls -lR && echo "1,2,3"

Apri un altro terminale:

~ $ echo "testing" > /tmp/test

Ora verrà emesso il primo terminale 1,2,3

Esempio di script semplice:

#!/bin/bash
DIR_TO_WATCH=${1}
COMMAND=${2}

watch -d -t -g ls -lR ${DIR_TO_WATCH} && ${COMMAND}

rerun2( su github ) è uno script Bash a 10 righe del modulo:

#!/usr/bin/env bash

function execute() {
    clear
    echo "$@"
    eval "$@"
}

execute "$@"

inotifywait --quiet --recursive --monitor --event modify --format "%w%f" . \
| while read change; do
    execute "$@"
done

Salvare la versione di github come 'riesegui' sul PATH e invocarla usando:

rerun COMMAND

Esegue COMANDO ogni volta che c'è un evento di modifica del filesystem all'interno della directory corrente (ricorsivo).

Le cose che potrebbero interessarti:

• Utilizza inotify, quindi è più reattivo del polling. Favoloso per l'esecuzione di test unitari al di sotto del millisecondo o per il rendering di file dot graphviz, ogni volta che si preme 'salva'.
• Perché è così veloce, non devi preoccuparti di dirgli di ignorare i sottodirectory di grandi dimensioni (come node_modules) solo per motivi di prestazioni.
• È super super reattivo, perché chiama inotifywait solo una volta, all'avvio, invece di eseguirlo e incorrere in un costoso colpo di stabilire orologi, ad ogni iterazione.
• Sono solo 12 linee di Bash
• Poiché è Bash, interpreta i comandi che gli vengono passati esattamente come se li avessi digitati al prompt di Bash. (Presumibilmente questo è meno bello se usi un'altra shell.)
• Non perde eventi che si verificano durante l'esecuzione di COMMAND, a differenza della maggior parte delle altre soluzioni di inotify in questa pagina.
• Al primo evento, inserisce un "periodo morto" per 0,15 secondi, durante il quale vengono ignorati altri eventi, prima che il comando venga eseguito esattamente una volta. Questo è così che la raffica di eventi causati dalla danza create-write-move che Vi o Emacs eseguono durante il salvataggio di un buffer non causano esecuzioni multiple laboriose di una suite di test forse a esecuzione lenta. Tutti gli eventi che si verificano durante l'esecuzione di COMMAND non vengono ignorati, poiché causeranno un secondo periodo morto e la successiva esecuzione.

Cose che potrebbero non piacere a riguardo:

• Usa inotify, quindi non funzionerà al di fuori di Linuxland.
• Poiché utilizza inotify, fallirà nel tentativo di guardare directory contenenti più file rispetto al numero massimo di watch inotify dell'utente. Per impostazione predefinita, questo sembra essere impostato da circa 5.000 a 8.000 su diverse macchine che utilizzo, ma è facile da aumentare. Vedi https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached
• Non riesce a eseguire comandi contenenti alias Bash. Potrei giurare che questo funzionava. In linea di principio, poiché si tratta di Bash, che non esegue COMMAND in una subshell, mi aspetto che funzioni. Mi piacerebbe sapere se qualcuno sa perché non lo fa. Molte delle altre soluzioni in questa pagina non possono neanche eseguire tali comandi.
• Personalmente vorrei poter premere una chiave nel terminale in cui è in esecuzione per causare manualmente un'esecuzione aggiuntiva di COMANDO. Potrei aggiungere questo in qualche modo, semplicemente? Un ciclo 'while read -n1' in esecuzione contemporaneamente che chiama anche esegui?
• In questo momento l'ho codificato per cancellare il terminale e stampare il comando eseguito su ogni iterazione. Alcune persone potrebbero voler aggiungere flag da riga di comando per disattivare cose come questa, ecc. Ma questo aumenterebbe di dimensioni e complessità molte volte.

Questa è una raffinatezza della risposta di @cychoi.

Ecco un semplice script di shell Bourne shell che:

1. Accetta due argomenti: il file da monitorare e un comando (con argomenti, se necessario)
2. Copia il file che stai monitorando nella directory / tmp
3. Controlla ogni due secondi per vedere se il file che stai monitorando è più recente della copia
4. Se è più recente, sovrascrive la copia con l'originale più recente ed esegue il comando

5. Si pulisce da solo quando si preme Ctr-C

   #!/bin/sh  
   f=$1  
   shift  
   cmd=$*  
   tmpf="`mktemp /tmp/onchange.XXXXX`"  
   cp "$f" "$tmpf"  
   trap "rm $tmpf; exit 1" 2  
   while : ; do  
       if [ "$f" -nt "$tmpf" ]; then  
           cp "$f" "$tmpf"  
           $cmd  
       fi  
       sleep 2  
   done  
   

Funziona su FreeBSD. L'unico problema di portabilità che mi viene in mente è se qualche altro Unix non ha il comando mktemp (1), ma in quel caso puoi semplicemente codificare il nome del file temporaneo.

Dai un'occhiata a incron . È simile a cron, ma utilizza gli eventi inotify invece del tempo.

Un'altra soluzione con NodeJs, fsmonitor :

1. Installare

   sudo npm install -g fsmonitor
   

2. Dalla riga di comando (esempio, monitorare i registri e "vendita al dettaglio" se un file di registro cambia)

   fsmonitor -s -p '+*.log' sh -c "clear; tail -q *.log"
   

Guarda in Guard, in particolare con questo plugin:

https://github.com/hawx/guard-shell

Puoi impostarlo per guardare un numero qualsiasi di schemi nella directory del tuo progetto ed eseguire comandi quando si verificano cambiamenti. Buone probabilità anche che ci sia un plugin disponibile per quello che stai cercando di fare in primo luogo.

se hai installato nodemon , puoi farlo:

nodemon -w <watch directory> -x "<shell command>" -e ".html"

Nel mio caso, modifico html localmente e lo spedisco al mio server remoto quando un file cambia.

nodemon -w <watch directory> -x "scp filename jaym@jay-remote.com:/var/www" -e ".html"

Sotto Linux:

man watch

watch -n 2 your_command_to_run

Eseguirà il comando ogni 2 secondi.

Se l'esecuzione del comando richiede più di 2 secondi, l'orologio attenderà fino a quando non viene eseguito prima di ripetere.

Watchdog è un progetto Python e potrebbe essere proprio quello che stai cercando:

Piattaforme supportate

• Linux 2.6 (inotify)
• Mac OS X (FSEvents, kqueue)
• FreeBSD / BSD (kqueue)
• Windows (ReadDirectoryChangesW con porte di completamento I / O; ReadDirectoryChangesW thread di lavoro)
• Indipendente dal sistema operativo (polling del disco per gli snapshot della directory e confronto periodico; lento e sconsigliato)

Ho appena scritto un wrapper a riga di comando per questo watchdog_exec:

L'esempio funziona

Nell'evento fs che coinvolge file e cartelle nella directory corrente, eseguire il echo $src $dstcomando, a meno che non venga modificato l'evento fs, quindi eseguire il python $srccomando.

python -m watchdog_exec . --execute echo --modified python

Utilizzando brevi argomenti e limitando l'esecuzione solo quando gli eventi implicano " main .py":

python -m watchdog_exec . -e echo -a echo -s __main__.py

EDIT: Ho appena scoperto che Watchdog ha una CLI ufficiale chiamata watchmedo, quindi controlla anche questo.

Se il tuo programma genera una sorta di log / output, puoi creare un Makefile con una regola per quel log / output che dipende dal tuo script e fare qualcosa di simile

while true; do make -s my_target; sleep 1; done

In alternativa, puoi creare un target fasullo e avere la regola per esso sia chiamare il tuo script che toccare il target fasullo (pur continuando a dipendere dal tuo script).

swarminglogic ha scritto uno script chiamato watchfile.sh , disponibile anche come GitHub Gist .

Migliorato sulla risposta di Gilles .

Questa versione viene eseguita inotifywaituna volta e monitora gli eventi (.eg:) in modifyseguito. Tale che inotifywait non deve essere rieseguito su ogni evento riscontrato.

È veloce e veloce! _{(anche durante il monitoraggio ricorsivo di directory di grandi dimensioni)}

inotifywait --quiet --monitor --event modify FILE | while read; do
    # trim the trailing space from inotifywait output
    REPLY=${REPLY% }
    filename=${REPLY%% *}
    # do whatever you want with the $filename
done

Un po 'più dal punto di vista della programmazione, ma vuoi qualcosa come inotify . Esistono implementazioni in molte lingue, come jnotify e pyinotify .

Questa libreria consente di monitorare singoli file o intere directory e restituisce eventi quando viene rilevata un'azione. Le informazioni restituite includono il nome del file, l'azione (crea, modifica, rinomina, elimina) e il percorso del file, tra le altre informazioni utili.

Per quelli di voi che cercano una soluzione FreeBSD, ecco la porta:

/usr/ports/sysutils/wait_on

Mi piace la semplicità, while inotifywait ...; do ...; donetuttavia ha due problemi:

• Le modifiche ai file che si verificano durante il do ...;saranno perse
• Lento quando si utilizza in modalità ricorsiva

Pertanto ho creato uno script di supporto che utilizza inotifywait senza tali limitazioni: inotifyexec

Ti suggerisco di mettere questo script nel tuo percorso, come in ~/bin/. L'utilizzo è descritto semplicemente eseguendo il comando.

Esempio: inotifyexec "echo test" -r .

Migliorata la soluzione di Sebastian con watchcomando:

watch_cmd.sh:

#!/bin/bash
WATCH_COMMAND=${1}
COMMAND=${2}

while true; do
  watch -d -g "${WATCH_COMMAND}"
  ${COMMAND}
  sleep 1     # to allow break script by Ctrl+c
done

Chiama esempio:

watch_cmd.sh "ls -lR /etc/nginx | grep .conf$" "sudo service nginx reload"

Funziona ma fai attenzione: il watchcomando ha dei bug noti (vedi man): reagisce alle modifiche solo in VISIBILE nelle parti terminali -g CMDdell'output.

Potresti provare il riflesso .

Reflex è un piccolo strumento per guardare una directory ed eseguire nuovamente un comando quando cambiano determinati file. È ottimo per eseguire automaticamente attività di compilazione / lint / test e per ricaricare l'applicazione quando il codice cambia.

# Rerun make whenever a .c file changes
reflex -r '\.c$' make

Una risposta oneliner che sto usando per tenere traccia di una modifica del file:

$ while true ; do NX=`stat -c %Z file` ; [[ $BF != $NX ]] && date >> ~/tmp/fchg && BF=$NX || sleep 2 ; done

Non è necessario inizializzare BF se si sa che la prima data è l'ora di inizio.

Questo è semplice e portatile. C'è un'altra risposta basata sulla stessa strategia usando uno script qui. Dai anche un'occhiata.

Utilizzo: sto usando questo per eseguire il debug e tenere d'occhio ~/.kde/share/config/plasma-desktop-appletsrc; che per qualche ragione sconosciuta continua a perdere il mioSwitchTabsOnHover=false

Uso questo script per farlo. Sto usando inotify in modalità monitor

#!/bin/bash
MONDIR=$(dirname $1)
ARQ=$(basename $1)

inotifywait -mr -e close_write $MONDIR | while read base event file 
do
  if (echo $file |grep -i "$ARQ") ; then
    $1
  fi
done

Salvalo come runatwrite.sh

Usage: runatwrite.sh myfile.sh

eseguirà myfile.sh ad ogni scrittura.

Per coloro che utilizzano OS X, è possibile utilizzare LaunchAgent per guardare un percorso / file per le modifiche e fare qualcosa quando ciò accade. Cordiali saluti - LaunchControl è una buona app per creare / modificare / rimuovere facilmente demoni / agenti.

( esempio preso da qui )

<?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>test</string>
    <key>ProgramArguments</key>
    <array>
        <string>say</string>
        <string>yy</string>
    </array>
    <key>WatchPaths</key>
    <array>
        <string>~/Desktop/</string>
    </array>
</dict>
</plist>

Ho un GIST per questo e l'utilizzo è piuttosto semplice

watchfiles <cmd> <paths...>

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

Per le persone che lo trovano su Google per le modifiche a un determinato file, la risposta è molto più semplice (ispirata alla risposta di Gilles ).

Se vuoi fare qualcosa dopo che un determinato file è stato scritto, ecco come:

while true; do
  inotifywait -e modify /path/to/file
  # Do something *after* a write occurs, e.g. copy the file
  /bin/cp /path/to/file /new/path
done

Salvalo come, ad esempio, copy_myfile.she inserisci il .shfile nella /etc/init.d/cartella per eseguirlo all'avvio.

Lo strumento "fido" potrebbe essere un'altra opzione per questa esigenza. Vedi https://www.joedog.org/fido-home/

Come pochi altri hanno fatto, ho anche scritto uno strumento a riga di comando leggero per farlo. È completamente documentato, testato e modulare.

Watch-Do

Installazione

Puoi installarlo (se hai Python3 e pip) usando:

pip3 install git+https://github.com/vimist/watch-do

uso

Usalo subito eseguendo:

watch-do -w my_file -d 'echo %f changed'

Panoramica delle funzionalità

• Supporta il globbing dei file (usa -w '*.py'o -w '**/*.py')
• Esegui più comandi su una modifica di file (basta specificare -dnuovamente il flag)
• Mantiene dinamicamente l'elenco dei file da guardare se viene utilizzato il globbing ( -rper attivarlo )
• Diversi modi per "guardare" un file:
  • Tempo di modifica (impostazione predefinita)
  • Hash del file
  • Trivial per implementare il tuo (questo è il watcher ModificationTime )
• Design modulare. Se si desidera che i comandi vengano eseguiti, quando si accede a un file, è banale scrivere il proprio watcher (meccanismo che determina se i responsabili devono essere eseguiti).