¿Cómo ejecutar un comando cada vez que cambia un archivo?

Quiero una forma rápida y sencilla de ejecutar un comando cada vez que cambie un archivo. Quiero algo muy simple, algo que dejaré ejecutándose en un terminal y lo cerraré cada vez que termine de trabajar con ese archivo.

Actualmente, estoy usando esto:

while read; do ./myfile.py ; done

Y luego tengo que ir a esa terminal y presionar Enter, cada vez que guardo ese archivo en mi editor. Lo que quiero es algo como esto:

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

O cualquier otra solución tan fácil como eso.

Por cierto: estoy usando Vim, y sé que puedo agregar un autocomando para ejecutar algo en BufWrite, pero este no es el tipo de solución que quiero ahora.

Actualización: quiero algo simple, descartable si es posible. Además, quiero que algo se ejecute en un terminal porque quiero ver la salida del programa (quiero ver mensajes de error).

Sobre las respuestas: ¡ Gracias por todas sus respuestas! Todos ellos son muy buenos, y cada uno adopta un enfoque muy diferente de los demás. Como necesito aceptar solo uno, estoy aceptando el que realmente he usado (fue simple, rápido y fácil de recordar), aunque sé que no es el más elegante.

Simple, usando inotifywait (instale el inotify-toolspaquete de su distribución ):

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

El primer fragmento es más simple, pero tiene una desventaja significativa: perderá los cambios realizados mientras inotifywaitno se está ejecutando (en particular mientras se myfileestá ejecutando). El segundo fragmento no tiene este defecto. Sin embargo, tenga en cuenta que supone que el nombre del archivo no contiene espacios en blanco. Si eso es un problema, use la --formatopción para cambiar la salida para no incluir el nombre del archivo:

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

De cualquier manera, hay una limitación: si algún programa reemplaza myfile.pycon un archivo diferente, en lugar de escribir en el existente myfile, inotifywaitmorirá. Muchos editores trabajan de esa manera.

Para superar esta limitación, use inotifywaiten el directorio:

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

Alternativamente, use otra herramienta que use la misma funcionalidad subyacente, como incron (le permite registrar eventos cuando se modifica un archivo) o fswatch (una herramienta que también funciona en muchas otras variantes de Unix, usando el análogo de cada variante de inotify de Linux).

entr ( http://entrproject.org/ ) proporciona una interfaz más amigable para inotificar (y también es compatible con * BSD y Mac OS X).

Hace que sea muy fácil especificar varios archivos para ver (limitado solo por ulimit -n), elimina la molestia de tratar con los archivos que se reemplazan y requiere menos sintaxis bash:

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

Lo he estado usando en todo el árbol fuente de mi proyecto para ejecutar las pruebas unitarias del código que estoy modificando actualmente, y ya ha sido un gran impulso para mi flujo de trabajo.

Las banderas como -c(borrar la pantalla entre ejecuciones) y -d(salir cuando se agrega un nuevo archivo a un directorio monitoreado) agregan aún más flexibilidad, por ejemplo, puede hacer:

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

A principios de 2018 todavía está en desarrollo activo y se puede encontrar en Debian y Ubuntu ( apt install entr); construir desde el repositorio del autor fue sin dolor en cualquier caso.

Escribí un programa de Python para hacer exactamente esto llamado cuándo se cambió .

El uso es simple:

when-changed FILE COMMAND...

O para ver múltiples archivos:

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

FILEpuede ser un directorio Mira recursivamente con -r. Use %fpara pasar el nombre del archivo al comando.

¿Qué tal este guión? Utiliza el statcomando para obtener el tiempo de acceso de un archivo y ejecuta un comando cada vez que hay un cambio en el tiempo de acceso (cada vez que se accede al archivo).

#!/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

Solución usando Vim:

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

Pero no quiero esta solución porque es un poco molesto escribir, es un poco difícil recordar qué escribir, exactamente, y es un poco difícil deshacer sus efectos (es necesario ejecutar :au! BufWritePost myfile.py). Además, esta solución bloquea Vim hasta que el comando haya terminado de ejecutarse.

He agregado esta solución aquí solo para completar, ya que podría ayudar a otras personas.

Para mostrar la salida del programa (e interrumpir completamente su flujo de edición, ya que la salida sobrescribirá su editor durante unos segundos, hasta que presione Entrar), elimine el :silentcomando.

Si tiene npminstalado, nodemones probablemente la forma más fácil de comenzar, especialmente en OS X, que aparentemente no tiene herramientas de inotify. Admite ejecutar un comando cuando cambia una carpeta.

Para aquellos que no pueden instalar inotify-toolscomo yo, esto debería ser útil:

watch -d -t -g ls -lR

Este comando saldrá cuando cambie la salida, ls -lRenumerará cada archivo y directorio con su tamaño y fechas, por lo que si se cambia un archivo, debería salir del comando, como dice man:

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

Sé que esta respuesta no puede ser leída por nadie, pero espero que alguien llegue a ella.

Ejemplo de línea de comando:

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

Abre otra terminal:

~ $ echo "testing" > /tmp/test

Ahora saldrá el primer terminal 1,2,3

Ejemplo de script simple:

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

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

rerun2( en github ) es un script Bash de 10 líneas de la forma:

#!/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

Guarde la versión de github como 'volver a ejecutar' en su RUTA e invoque usando:

rerun COMMAND

Ejecuta COMMAND cada vez que hay un evento de modificación del sistema de archivos dentro de su directorio actual (recursivo).

Cosas que a uno le pueden gustar:

• Utiliza inotify, por lo que responde mejor que las encuestas. Fabuloso para ejecutar pruebas unitarias por debajo de milisegundos, o renderizar archivos de puntos graphviz, cada vez que presiona 'guardar'.
• Debido a que es tan rápido, no tiene que molestarse en decirle que ignore subdirecciones grandes (como node_modules) solo por razones de rendimiento.
• Es súper receptivo adicional, porque solo llama a inotifywait una vez, al inicio, en lugar de ejecutarlo, e incurre en el costoso éxito de establecer relojes, en cada iteración.
• Son solo 12 líneas de Bash
• Debido a que es Bash, interpreta los comandos que le pasa exactamente como si los hubiera escrito en un indicador de Bash. (Presumiblemente, esto es menos genial si usa otro caparazón).
• No pierde eventos que suceden mientras se ejecuta COMMAND, a diferencia de la mayoría de las otras soluciones de inotify en esta página.
• En el primer evento, entra en un "período muerto" durante 0,15 segundos, durante el cual se ignoran otros eventos, antes de que se ejecute COMMAND exactamente una vez. Esto es para que la ráfaga de eventos causados ​​por el baile de creación-escritura-movimiento que Vi o Emacs hace al guardar un búfer no provoque múltiples ejecuciones laboriosas de un conjunto de pruebas posiblemente lento. Cualquier evento que ocurra mientras se ejecuta COMMAND no se ignora: causarán un segundo período muerto y la ejecución posterior.

Cosas que a uno no le gustarían:

• Utiliza inotify, por lo que no funcionará fuera de Linuxland.
• Debido a que usa inotify, se molestará al tratar de mirar directorios que contienen más archivos que el número máximo de relojes de inotify del usuario. Por defecto, esto parece estar configurado en alrededor de 5,000 a 8,000 en diferentes máquinas que uso, pero es fácil de aumentar. Ver https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached
• No puede ejecutar comandos que contienen alias Bash. Podría jurar que esto solía funcionar. En principio, como se trata de Bash, no se ejecuta COMMAND en una subshell, espero que esto funcione. Me encantaría saber si alguien sabe por qué no. Muchas de las otras soluciones en esta página tampoco pueden ejecutar dichos comandos.
• Personalmente, desearía poder presionar una tecla en el terminal en el que se está ejecutando para provocar manualmente una ejecución adicional de COMMAND. ¿Podría agregar esto de alguna manera, simplemente? ¿Un ciclo simultáneo 'while read -n1' que también llama a execute?
• En este momento lo he codificado para borrar el terminal e imprimir el COMANDO ejecutado en cada iteración. A algunas personas les gustaría agregar banderas de línea de comandos para desactivar cosas como esta, etc. Pero esto aumentaría el tamaño y la complejidad en muchas ocasiones.

Este es un refinamiento de la respuesta de @ cychoi.

Aquí hay un simple script de shell Bourne que:

1. Toma dos argumentos: el archivo a monitorear y un comando (con argumentos, si es necesario)
2. Copia el archivo que está monitoreando en el directorio / tmp
3. Comprueba cada dos segundos para ver si el archivo que está monitoreando es más reciente que la copia
4. Si es más nuevo, sobrescribe la copia con el original más nuevo y ejecuta el comando

5. Se limpia después de sí mismo cuando presiona 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  
   

Esto funciona en FreeBSD. El único problema de portabilidad en el que puedo pensar es si algún otro Unix no tiene el comando mktemp (1), pero en ese caso simplemente puede codificar el nombre del archivo temporal.

Echa un vistazo a incron . Es similar a cron, pero usa eventos inotify en lugar de tiempo.

Otra solución con NodeJs, fsmonitor :

1. Instalar en pc

   sudo npm install -g fsmonitor
   

2. Desde la línea de comando (ejemplo, supervisar registros y "venta minorista" si un archivo de registro cambia)

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

Mira en Guard, en particular con este complemento:

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

Puede configurarlo para ver cualquier número de patrones en el directorio de su proyecto y ejecutar comandos cuando ocurran cambios. Buena posibilidad incluso de que haya un complemento disponible para eso que estás tratando de hacer en primer lugar.

si tiene instalado nodemon , puede hacer esto:

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

En mi caso, edito html localmente y lo envío a mi servidor remoto cuando cambia un archivo.

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

Bajo Linux:

man watch

watch -n 2 your_command_to_run

Ejecutará el comando cada 2 segundos.

Si su comando tarda más de 2 segundos en ejecutarse, el reloj esperará hasta que esté listo antes de hacerlo nuevamente.

Watchdog es un proyecto de Python, y puede ser justo lo que estás buscando:

Plataformas soportadas

• Linux 2.6 (inotify)
• Mac OS X (FSEvents, kqueue)
• FreeBSD / BSD (kqueue)
• Windows (ReadDirectoryChangesW con puertos de finalización de E / S; subprocesos de trabajo ReadDirectoryChangesW)
• Independiente del sistema operativo (sondear el disco en busca de instantáneas de directorio y compararlas periódicamente; lento y no recomendado)

Acabo de escribir un contenedor de línea de comandos para ello watchdog_exec:

Ejecuciones de ejemplo

En el evento fs que involucra archivos y carpetas en el directorio actual, ejecute el echo $src $dstcomando, a menos que se modifique el evento fs, luego ejecute el python $srccomando.

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

Usando argumentos cortos y restringiendo la ejecución solo cuando los eventos involucran " main .py":

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

EDITAR: Acabo de encontrar que Watchdog tiene una CLI oficial llamada watchmedo, así que échale un vistazo también.

Si su programa genera algún tipo de registro / salida, puede crear un Makefile con una regla para ese registro / salida que depende de su script y hacer algo como

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

Alternativamente, puede crear un objetivo falso y tener la regla para que llame a su script y toque el objetivo falso (aunque aún depende de su script).

swarminglogic escribió un script llamado watchfile.sh , también disponible como GitHub Gist .

Mejorado con la respuesta de Gilles .

Esta versión se ejecuta inotifywaituna vez y supervisa los eventos (.eg:) a modifypartir de entonces. Tal que inotifywait no es necesario volver a ejecutarlo en cada evento encontrado.

¡Es rápido y rápido! _{(incluso cuando se supervisa un directorio grande de forma recursiva)}

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 poco más en el lado de la programación, pero quieres algo como inotify . Hay implementaciones en muchos idiomas, como jnotify y pyinotify .

Esta biblioteca le permite monitorear archivos individuales o directorios completos, y devuelve eventos cuando se descubre una acción. La información devuelta incluye el nombre del archivo, la acción (crear, modificar, renombrar, eliminar) y la ruta del archivo, entre otra información útil.

Para aquellos de ustedes que buscan una solución de FreeBSD, este es el puerto:

/usr/ports/sysutils/wait_on

Me gusta la simplicidad, while inotifywait ...; do ...; donesin embargo, tiene dos problemas:

• Cambios en los archivos que suceden durante el do ...;se puede perder
• Lento cuando se usa en modo recursivo

Por lo tanto, hice un script de ayuda que usa inotifywait sin esas limitaciones: inotifyexec

Te sugiero que pongas este script en tu camino, como en ~/bin/. El uso se describe simplemente ejecutando el comando.

Ejemplo: inotifyexec "echo test" -r .

Solución mejorada de 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

Ejemplo de llamada:

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

Funciona pero tenga cuidado: el watchcomando tiene errores conocidos (vea man): reacciona ante cambios solo en VISIBLE en las partes terminales de la -g CMDsalida.

Podrías probar el reflejo .

Reflex es una pequeña herramienta para mirar un directorio y volver a ejecutar un comando cuando cambian ciertos archivos. Es ideal para ejecutar automáticamente tareas de compilación / pelusa / prueba y para volver a cargar su aplicación cuando cambia el código.

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

Una respuesta en línea que estoy usando para realizar un seguimiento de un cambio de archivo:

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

No necesita inicializar BF si sabe que la primera fecha es la hora de inicio.

Esto es simple y portátil. Hay otra respuesta basada en la misma estrategia usando un script aquí. Echa un vistazo también.

Uso: estoy usando esto para depurar y vigilar ~/.kde/share/config/plasma-desktop-appletsrc; que por alguna razón desconocida sigue perdiendo miSwitchTabsOnHover=false

Yo uso este script para hacerlo. Estoy usando inotify en modo 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

Guarde esto como runatwrite.sh

Usage: runatwrite.sh myfile.sh

ejecutará myfile.sh en cada escritura.

Para aquellos que usan OS X, puede usar un LaunchAgent para ver una ruta / archivo en busca de cambios y hacer algo cuando eso suceda. FYI - LaunchControl es una buena aplicación para crear / modificar / eliminar demonios / agentes fácilmente.

( ejemplo tomado de aquí )

<?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>

Tengo un GIST para esto y el uso es bastante simple

watchfiles <cmd> <paths...>

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

Para las personas que encuentran esto buscando en Google los cambios en un archivo en particular , la respuesta es mucho más simple (inspirada en la respuesta de Gilles ).

Si desea hacer algo después de que se haya escrito un archivo en particular, así es como:

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

Guarde esto como, por ejemplo, copy_myfile.shy coloque el .sharchivo en la /etc/init.d/carpeta para que se ejecute al inicio.

La herramienta 'fido' puede ser otra opción para esta necesidad. Ver https://www.joedog.org/fido-home/

Como algunos otros lo han hecho, también he escrito una herramienta de línea de comandos ligera para hacer esto. Está completamente documentado, probado y modular.

Watch-Do

Instalación

Puede instalarlo (si tiene Python3 y pip) usando:

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

Uso

Úselo de inmediato ejecutando:

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

Descripción de las características

• Admite el bloqueo de archivos (uso -w '*.py'o -w '**/*.py')
• Ejecute múltiples comandos en un cambio de archivo (solo especifique la -dbandera nuevamente)
• Mantiene dinámicamente la lista de archivos para ver si se usa globbing ( -rpara activar esto)
• Múltiples formas de "mirar" un archivo:
  • Tiempo de modificación (predeterminado)
  • Archivo hash
  • Trivial para implementar el suyo (este es el Observador ModificationTime )
• Diseño modular. Si desea que se ejecuten comandos, cuando se accede a un archivo, es trivial escribir su propio observador (mecanismo que determina si los ejecutores deben ejecutarse).