Como executar um comando sempre que um arquivo é alterado?

Eu quero uma maneira rápida e simples de executar um comando sempre que um arquivo for alterado. Quero algo muito simples, algo que deixarei em execução em um terminal e fechá-lo sempre que terminar de trabalhar com esse arquivo.

Atualmente, estou usando isso:

while read; do ./myfile.py ; done

E então eu preciso ir ao terminal e pressionar Enter, sempre que salvar esse arquivo no meu editor. O que eu quero é algo como isto:

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

Ou qualquer outra solução tão fácil quanto isso.

BTW: Estou usando o Vim e sei que posso adicionar um comando automático para executar algo no BufWrite, mas esse não é o tipo de solução que eu quero agora.

Atualização: eu quero algo simples, descartável, se possível. Além do mais, quero que algo seja executado em um terminal porque quero ver a saída do programa (quero ver mensagens de erro).

Sobre as respostas: Obrigado por todas as suas respostas! Todos eles são muito bons e cada um tem uma abordagem muito diferente dos outros. Como preciso aceitar apenas um, aceito o que realmente usei (era simples, rápido e fácil de lembrar), mesmo sabendo que não é o mais elegante.

Simples, usando inotifywait (instale o inotify-toolspacote da sua distribuição ):

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

ou

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

O primeiro snippet é mais simples, mas tem uma desvantagem significativa: ele perderá as alterações executadas enquanto inotifywaitnão estiver em execução (em particular enquanto myfileestiver em execução). O segundo trecho não possui esse defeito. No entanto, lembre-se de que o nome do arquivo não contenha espaço em branco. Se houver algum problema, use a --formatopção para alterar a saída para não incluir o nome do arquivo:

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

De qualquer maneira, há uma limitação: se algum programa substitui myfile.pycom um arquivo diferente, ao invés de escrever ao existente myfile, inotifywaitvai morrer. Muitos editores trabalham dessa maneira.

Para superar essa limitação, use inotifywaitno diretório:

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

Como alternativa, use outra ferramenta que use a mesma funcionalidade subjacente, como incron (permite registrar eventos quando um arquivo é modificado) ou fswatch (uma ferramenta que também funciona em muitas outras variantes do Unix, usando o análogo de cada variante do inotify do Linux).

entr ( http://entrproject.org/ ) fornece uma interface mais amigável para inotify (e também suporta * BSD e Mac OS X).

Torna muito fácil especificar vários arquivos para assistir (limitado apenas por ulimit -n), elimina o incômodo de lidar com a substituição de arquivos e requer menos sintaxe do bash:

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

Eu o uso em toda a árvore de origem do projeto para executar os testes de unidade do código que estou modificando no momento, e isso já foi um grande impulso para o meu fluxo de trabalho.

Sinalizadores como -c(limpar a tela entre execuções) e -d(sair quando um novo arquivo é adicionado a um diretório monitorado) adicionam ainda mais flexibilidade, por exemplo, você pode:

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

A partir do início de 2018, ele ainda está em desenvolvimento ativo e pode ser encontrado no Debian & Ubuntu ( apt install entr); construção do repositório do autor foi indolor em qualquer caso.

Eu escrevi um programa Python para fazer exatamente isso chamado quando alterado .

O uso é simples:

when-changed FILE COMMAND...

Ou para assistir a vários arquivos:

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

FILEpode ser um diretório Assista recursivamente com -r. Use %fpara passar o nome do arquivo para o comando

E esse script? Ele usa o statcomando para obter o tempo de acesso de um arquivo e executa um comando sempre que houver uma alteração no tempo de acesso (sempre que o arquivo for acessado).

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

Solução usando o Vim:

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

Mas eu não quero essa solução porque é meio chato digitar, é um pouco difícil lembrar o que digitar, exatamente, e é um pouco difícil desfazer seus efeitos (é necessário executar :au! BufWritePost myfile.py). Além disso, esta solução bloqueia o Vim até que o comando termine de executar.

Adicionei esta solução aqui apenas por questões de integridade, pois pode ajudar outras pessoas.

Para exibir a saída do programa (e interromper completamente o fluxo de edição, como a saída gravará sobre seu editor por alguns segundos, até você pressionar Enter), remova o :silentcomando.

Se você npminstalou, nodemonprovavelmente é a maneira mais fácil de começar, especialmente no OS X, que aparentemente não possui ferramentas para inotificação. Ele suporta a execução de um comando quando uma pasta é alterada.

Para aqueles que não podem instalar inotify-toolscomo eu, isso deve ser útil:

watch -d -t -g ls -lR

Este comando sairá quando a saída for alterada, ls -lRlistará todos os arquivos e diretórios com seu tamanho e datas; portanto, se um arquivo for alterado, ele deverá sair do comando, como o homem diz:

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

Sei que esta resposta pode não ser lida por ninguém, mas espero que alguém a atinja.

Exemplo de linha de comando:

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

Abra outro terminal:

~ $ echo "testing" > /tmp/test

Agora o primeiro terminal será emitido 1,2,3

Exemplo de script simples:

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

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

rerun2( no github ) é um script Bash de 10 linhas no formato:

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

Salve a versão do github como 'reexecutar' no seu PATH e invoque-a usando:

rerun COMMAND

Ele executa o COMMAND toda vez que há um evento de modificação do sistema de arquivos no diretório atual (recursivo).

Coisas que alguém pode gostar sobre isso:

• Ele usa inotify, por isso é mais responsivo que a pesquisa. Fabuloso para executar testes de unidade abaixo de milissegundos ou renderizar arquivos de pontos gráficos, sempre que você clicar em 'salvar'.
• Por ser tão rápido, você não precisa se preocupar em dizer para ignorar subdiretórios grandes (como node_modules) apenas por razões de desempenho.
• É extremamente super responsivo, porque só chama inotifywait uma vez, na inicialização, em vez de executá-lo e incorrendo no caro custo de estabelecer relógios, em todas as iterações.
• São apenas 12 linhas de Bash
• Por ser o Bash, ele interpreta os comandos que você passa exatamente como se os tivesse digitado em um prompt do Bash. (Presumivelmente, isso é menos legal se você usar outro shell.)
• Ele não perde eventos que acontecem enquanto o COMMAND está em execução, ao contrário da maioria das outras soluções inotify nesta página.
• No primeiro evento, ele entra em um 'período morto' por 0,15 segundo, durante o qual outros eventos são ignorados, antes que o COMMAND seja executado exatamente uma vez. Isso ocorre para que a enxurrada de eventos causados ​​pela dança de criar-gravar-mover que Vi ou Emacs faz ao salvar um buffer não cause várias execuções trabalhosas de um conjunto de testes possivelmente lento. Quaisquer eventos que ocorrerem enquanto o COMMAND estiver em execução não serão ignorados - eles causarão um segundo período morto e a execução subsequente.

Coisas que alguém pode não gostar:

• Ele usa inotify, portanto não funciona fora do Linuxland.
• Por usar o inotify, ele tentará assistir a diretórios que contêm mais arquivos do que o número máximo de relógios inotify do usuário. Por padrão, isso parece estar definido entre 5.000 e 8.000 em máquinas diferentes que eu uso, mas é fácil aumentar. Consulte https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached
• Falha ao executar comandos contendo aliases do Bash. Eu poderia jurar que isso costumava funcionar. Em princípio, como esse é o Bash, não executando COMMAND em um subshell, eu esperaria que isso funcionasse. Eu adoraria ouvir Se alguém sabe por que não. Muitas das outras soluções nesta página também não podem executar esses comandos.
• Pessoalmente, eu gostaria de poder pressionar uma tecla no terminal em que está sendo executado para causar manualmente uma execução extra do COMMAND. Eu poderia adicionar isso de alguma forma, simplesmente? Um loop 'while read -n1' em execução simultaneamente que também chama de execute?
• No momento, eu o codifiquei para limpar o terminal e imprimir o COMMAND executado em cada iteração. Algumas pessoas podem querer adicionar sinalizadores de linha de comando para desativar coisas assim, etc. Mas isso aumentaria muitas vezes o tamanho e a complexidade.

Este é um refinamento da resposta de @ cychoi.

Aqui está um simples shell shell Bourne que:

1. Leva dois argumentos: o arquivo a ser monitorado e um comando (com argumentos, se necessário)
2. Copia o arquivo que você está monitorando no diretório / tmp
3. Verifica a cada dois segundos se o arquivo que você está monitorando é mais recente que a cópia
4. Se for mais recente, substitui a cópia pelo original mais recente e executa o comando

5. Limpa depois de pressionar quando você pressiona 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  
   

Isso funciona no FreeBSD. O único problema de portabilidade que consigo pensar é se algum outro Unix não possui o comando mktemp (1), mas nesse caso você pode apenas codificar o nome do arquivo temporário.

Dê uma olhada no incron . É semelhante ao cron, mas usa eventos inotify em vez de tempo.

Outra solução com os NodeJs, fsmonitor :

1. Instalar

   sudo npm install -g fsmonitor
   

2. Na linha de comando (exemplo, monitore logs e "revenda" se um arquivo de log for alterado)

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

Veja o Guard, em particular com este plugin:

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

Você pode configurá-lo para assistir a qualquer número de padrões no diretório do seu projeto e executar comandos quando ocorrerem alterações. Boa chance, mesmo que haja um plugin disponível para o que você está tentando fazer em primeiro lugar.

se você tiver o nodemon instalado, poderá fazer o seguinte:

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

No meu caso, edito o html localmente e o envio para o servidor remoto quando um arquivo é alterado.

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

No Linux:

man watch

watch -n 2 your_command_to_run

Irá executar o comando a cada 2 segundos.

Se o seu comando levar mais de 2 segundos para ser executado, o relógio aguardará até que seja concluído antes de executar novamente.

Watchdog é um projeto Python e pode ser exatamente o que você está procurando:

Plataformas suportadas

• Linux 2.6 (inotify)
• Mac OS X (eventos FSE, kqueue)
• FreeBSD / BSD (kqueue)
• Windows (ReadDirectoryChangesW com portas de conclusão de E / S; threads de trabalho ReadDirectoryChangesW)
• Independente do sistema operacional (pesquisando no disco os instantâneos de diretório e comparando-os periodicamente; lento e não recomendado)

Acabei de escrever um wrapper de linha de comando para ele watchdog_exec:

Execuções de exemplo

No evento fs que envolve arquivos e pastas no diretório atual, execute o echo $src $dstcomando, a menos que o evento fs seja modificado, execute o python $srccomando.

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

Usando argumentos curtos e restringindo a execução apenas quando eventos envolvem " main .py":

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

EDIT: Acabei de encontrar Watchdog tem uma CLI oficial chamada watchmedo, então confira também.

Se o seu programa gerar algum tipo de log / saída, você pode criar um Makefile com uma regra para esse log / saída que depende do seu script e fazer algo como

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

Como alternativa, você pode criar um alvo falso e ter a regra de que ele chame seu script e toque no alvo falso (enquanto ainda depende do seu script).

swarminglogic escreveu um script chamado watchfile.sh , também disponível como GistHub Gist .

Melhorado com a resposta de Gilles .

Esta versão é executada inotifywaituma vez e monitora os eventos (.eg:) modifyposteriormente. Tais que inotifywait não precisam ser reexecutados a cada evento encontrado.

É rápido e rápido! _{(mesmo ao monitorar diretório grande recursivamente)}

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

Um pouco mais sobre o lado da programação, mas você deseja algo como inotify . Existem implementações em vários idiomas, como jnotify e pyinotify .

Essa biblioteca permite monitorar arquivos únicos ou diretórios inteiros e retorna eventos quando uma ação é descoberta. As informações retornadas incluem o nome do arquivo, a ação (criar, modificar, renomear, excluir) e o caminho do arquivo, entre outras informações úteis.

Para aqueles que procuram uma solução FreeBSD, aqui está a porta:

/usr/ports/sysutils/wait_on

Eu gosto da simplicidade de, while inotifywait ...; do ...; doneno entanto, tem dois problemas:

• As alterações de arquivo que ocorrerem durante o do ...;serão perdidas
• Lento ao usar no modo recursivo

Para isso, criei um script auxiliar que usa inotifywait sem essas limitações: inotifyexec

Eu sugiro que você coloque esse script no seu caminho, como em ~/bin/. O uso é descrito apenas executando o comando.

Exemplo: inotifyexec "echo test" -r .

Solução aprimorada de Sebastian com 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

Exemplo de chamada:

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

Funciona, mas tenha cuidado: o watchcomando conhece bugs (consulte man): ele reage às alterações apenas no VISÍVEL nas partes terminais da -g CMDsaída.

Você pode tentar reflexo .

O Reflex é uma pequena ferramenta para monitorar um diretório e executar novamente um comando quando certos arquivos são alterados. É ótimo para executar automaticamente tarefas de compilação / limpeza / teste e para recarregar seu aplicativo quando o código é alterado.

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

Uma resposta oneliner que estou usando para acompanhar uma alteração no arquivo:

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

Você não precisa inicializar o BF se souber que a primeira data é a hora de início.

Isso é simples e portátil. Há outra resposta baseada na mesma estratégia usando um script aqui. Dê uma olhada também.

Uso: estou usando isso para depurar e ficar de olho ~/.kde/share/config/plasma-desktop-appletsrc; que por algum motivo desconhecido continua perdendo meuSwitchTabsOnHover=false

Eu uso esse script para fazer isso. Estou usando inotify no 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

Salve isso como runatwrite.sh

Usage: runatwrite.sh myfile.sh

ele executará myfile.sh a cada gravação.

Para aqueles que usam o OS X, você pode usar o LaunchAgent para observar um caminho / arquivo em busca de alterações e fazer algo quando isso acontecer. FYI - LaunchControl é um bom aplicativo para criar / modificar / remover daemons / agentes facilmente.

( exemplo retirado daqui )

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

Eu tenho um GIST para isso e o uso é bastante simples

watchfiles <cmd> <paths...>

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

Para as pessoas que acham isso pesquisando para alterações em um determinado arquivo, a resposta é muito mais simples (inspirado resposta de Gilles ).

Se você deseja fazer algo após a gravação de um arquivo específico, veja 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

Salve isso como, por exemplo, copy_myfile.she coloque o .sharquivo na /etc/init.d/pasta para que ele seja executado na inicialização.

A ferramenta 'fido' pode ser mais uma opção para essa necessidade. Veja https://www.joedog.org/fido-home/

Como algumas outras pessoas fizeram, também escrevi uma ferramenta leve de linha de comando para fazer isso. Está totalmente documentado, testado e modular.

Watch-Do

Instalação

Você pode instalá-lo (se você tiver Python3 e pip) usando:

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

Uso

Use-o imediatamente executando:

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

Visão geral dos recursos

• Suporta globbing de arquivos (use -w '*.py'ou -w '**/*.py')
• Execute vários comandos em uma alteração de arquivo (basta especificar o -dsinalizador novamente)
• Mantém dinamicamente a lista de arquivos para observar se o globbing é usado ( -rpara ativar isso)
• Várias maneiras de "assistir" a um arquivo:
  • Hora da modificação (padrão)
  • Hash de arquivo
  • Trivial para implementar o seu próprio (este é o observador ModificationTime )
• Design modular. Se você deseja executar comandos, quando um arquivo é acessado, é trivial escrever seu próprio observador (mecanismo que determina se os executores devem ser executados).