Как выполнить команду при изменении файла?

Я хочу быстрый и простой способ выполнить команду при изменении файла. Я хочу что-то очень простое, что-то, что я оставлю работающим на терминале и закрою это всякий раз, когда я закончу работать с этим файлом.

В настоящее время я использую это:

while read; do ./myfile.py ; done

А затем мне нужно перейти к этому терминалу и нажимать Enterвсякий раз, когда я сохраняю этот файл в моем редакторе. Я хочу что-то вроде этого:

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

Или любое другое решение, столь же простое.

Кстати: я использую Vim, и я знаю, что могу добавить автокоманду для запуска чего-либо на BufWrite, но сейчас это не то решение, которое мне нужно.

Обновление: я хочу что-то простое, если возможно, отказаться. Более того, я хочу, чтобы что-то запускалось в терминале, потому что я хочу видеть вывод программы (я хочу видеть сообщения об ошибках).

Об ответах: Спасибо за все ваши ответы! Все они очень хороши, и каждый из них отличается от других. Поскольку мне нужно принять только один, я принимаю тот, который я фактически использовал (это было просто, быстро и легко запомнить), хотя я знаю, что это не самый элегантный.

Просто с помощью inotifywait (установите inotify-toolsпакет вашего дистрибутива ):

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

или же

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

Первый фрагмент проще, но у него есть существенный недостаток: он пропустит изменения, выполненные, когда inotifywaitон не запущен (в частности, во время myfileработы). Второй фрагмент не имеет этого дефекта. Однако следует помнить, что предполагается, что имя файла не содержит пробелов. Если это проблема, используйте --formatопцию, чтобы изменить вывод, чтобы не включать имя файла:

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

В любом случае, есть ограничение: если какая-то программа заменит myfile.pyдругой файл, а не записывает в существующий myfile, inotifywaitумрет. Многие редакторы работают таким образом.

Чтобы преодолеть это ограничение, используйте inotifywaitв каталоге:

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

В качестве альтернативы используйте другой инструмент, который использует те же базовые функции, например, incron (позволяет регистрировать события при изменении файла) или fswatch (инструмент, который также работает во многих других вариантах Unix с использованием аналога каждого варианта inotify Linux).

entr ( http://entrproject.org/ ) предоставляет более дружественный интерфейс для inotify (а также поддерживает * BSD и Mac OS X).

Это позволяет очень легко указать несколько файлов для просмотра (ограничено только ulimit -n), избавляет от необходимости иметь дело с заменяемыми файлами и требует меньше синтаксиса bash:

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

Я использовал его во всем дереве исходного кода проекта для запуска модульных тестов кода, который я сейчас изменяю, и это уже значительно улучшило мой рабочий процесс.

Флаги типа -c(очистка экрана между запусками) и -d(выход при добавлении нового файла в контролируемый каталог) добавляют еще больше гибкости, например, вы можете сделать следующее:

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

По состоянию на начало 2018 года он все еще находится в активной разработке, и его можно найти в Debian & Ubuntu ( apt install entr); Строительство из репо автора было в любом случае безболезненным.

Я написал программу на Python, чтобы сделать именно это, когда-изменился .

Использование простое:

when-changed FILE COMMAND...

Или посмотреть несколько файлов:

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

FILEможет быть каталогом. Смотреть рекурсивно с -r. Используйте %fдля передачи имени файла команде.

Как насчет этого сценария? Он использует statкоманду для получения времени доступа к файлу и запускает команду всякий раз, когда происходит изменение времени доступа (при каждом обращении к файлу).

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

Решение с использованием Vim:

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

Но я не хочу, чтобы это решение, потому что это немного раздражает при наборе, немного сложно вспомнить, что именно печатать, и немного сложно отменить его эффекты (нужно запустить :au! BufWritePost myfile.py). Кроме того, это решение блокирует Vim до завершения выполнения команды.

Я добавил это решение здесь только для полноты, так как оно может помочь другим людям.

Чтобы отобразить вывод программы (и полностью прервать процесс редактирования, поскольку вывод будет записываться в ваш редактор в течение нескольких секунд, пока вы не нажмете Enter), удалите :silentкоманду.

Если у вас npmустановлена ​​программа, nodemonвозможно, это самый простой способ начать работу, особенно в OS X, которая, очевидно, не имеет инструментов inotify. Он поддерживает запуск команды при изменении папки.

Для тех, кто не может установить inotify-toolsкак я, это должно быть полезно:

watch -d -t -g ls -lR

Эта команда завершится при изменении выходных данных, ls -lRперечислит каждый файл и каталог с указанием размера и даты, поэтому, если файл будет изменен, он должен выйти из команды, как говорит man:

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

Я знаю, что этот ответ не может быть прочитан никем, но я надеюсь, что кто-то достигнет его.

Пример командной строки:

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

Откройте другой терминал:

~ $ echo "testing" > /tmp/test

Теперь первый терминал выведет 1,2,3

Простой пример скрипта:

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

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

rerun2( на github ) представляет собой 10-строчный Bash-скрипт вида:

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

Сохраните версию github как 'rerun' в вашей переменной PATH и вызовите ее, используя:

rerun COMMAND

Он запускает COMMAND каждый раз, когда в вашем текущем каталоге происходит событие изменения файловой системы (рекурсивно.)

Вещи, которые могут понравиться об этом:

• Он использует inotify, поэтому более отзывчив, чем опрос. Потрясающе для запуска юнит-тестов с точностью до миллисекунды или рендеринга файлов графических точек каждый раз, когда вы нажимаете «сохранить».
• Поскольку это так быстро, вам не нужно беспокоиться о том, чтобы игнорировать большие подкаталоги (например, node_modules) только из соображений производительности.
• Это очень супер-отзывчивый, потому что он вызывает inotifywait только один раз, при запуске, вместо того, чтобы запускать его, и на каждой итерации возникает дорогостоящий удар по созданию часов.
• Это всего лишь 12 строк Bash
• Поскольку это Bash, он интерпретирует команды, которые вы передаете, точно так же, как если бы вы вводили их в приглашении Bash. (Предположительно, это менее круто, если вы используете другую оболочку.)
• Он не теряет события, которые происходят во время выполнения команды COMMAND, в отличие от большинства других решений inotify на этой странице.
• При первом событии он вводит «мертвый период» на 0,15 секунды, в течение которого другие события игнорируются, прежде чем COMMAND будет запущен ровно один раз. Это происходит из-за того, что поток событий, вызванных танцем create-write-move, который Vi или Emacs делает при сохранении буфера, не вызывает много трудоемких выполнений, возможно, медленного набора тестов. Любые события, которые затем происходят во время выполнения COMMAND, не игнорируются - они вызовут второй мертвый период и последующее выполнение.

Вещи, которые могут не понравиться об этом:

• Он использует inotify, поэтому не будет работать за пределами Linuxland.
• Поскольку он использует inotify, он будет пытаться просмотреть каталоги, содержащие больше файлов, чем максимальное количество пользовательских наблюдений inotify. По умолчанию на разных компьютерах, которые я использую, установлено, что оно составляет от 5000 до 8000, но его легко увеличить. См. Https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached
• Не удается выполнить команды, содержащие псевдонимы Bash. Я могу поклясться, что раньше это работало. В принципе, поскольку это Bash, который не выполняет COMMAND в подоболочке, я ожидал, что это сработает. Я хотел бы услышать, если кто-нибудь знает, почему это не так. Многие другие решения на этой странице также не могут выполнять такие команды.
• Лично я хотел бы нажать клавишу в терминале, в котором он работает, чтобы вручную вызвать дополнительное выполнение команды. Могу ли я добавить это как-нибудь, просто? Параллельно работающий цикл while read -n1, который также вызывает execute?
• Прямо сейчас я кодировал его, чтобы очистить терминал и печатать выполненную КОМАНДУ на каждой итерации. Некоторые люди могут захотеть добавить флаги командной строки, чтобы отключить подобные вещи и т. Д. Но это увеличит размер и сложность во много раз.

Это уточнение ответа @ cychoi.

Вот простой сценарий оболочки Bourne, который:

1. Принимает два аргумента: файл для мониторинга и команду (с аргументами, если необходимо)
2. Копирует файл, который вы отслеживаете, в каталог / tmp
3. Проверяет каждые две секунды, чтобы увидеть, является ли файл, который вы отслеживаете, более новым, чем копия
4. Если он новее, он перезаписывает копию новым оригиналом и выполняет команду

5. Убирает за собой при нажатии 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  
   

Это работает на FreeBSD. Единственная проблема с переносимостью, о которой я могу подумать, это то, что в некоторых других Unix нет команды mktemp (1), но в этом случае вы можете просто жестко закодировать имя временного файла.

Посмотрите на Incron . Это похоже на cron, но использует события inotify вместо времени.

Другое решение с NodeJs, fsmonitor :

1. устанавливать

   sudo npm install -g fsmonitor
   

2. Из командной строки (например, монитор журналов и «розничная торговля», если один файл журнала изменяется)

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

Посмотрите на Guard, в частности, с этим плагином:

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

Вы можете настроить его на просмотр любого количества шаблонов в каталоге вашего проекта и выполнение команд при возникновении изменений. Хороший шанс, даже если есть плагин для того, что вы пытаетесь сделать в первую очередь.

если у вас установлен nodemon , то вы можете сделать это:

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

В моем случае я редактирую html локально и отправляю его на мой удаленный сервер при изменении файла.

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

Под Linux:

man watch

watch -n 2 your_command_to_run

Будет запускать команду каждые 2 секунды.

Если ваша команда выполняется более 2 секунд, часы будут ждать, пока она не будет выполнена, прежде чем делать это снова.

Watchdog - это проект Python, и он может быть именно тем, что вы ищете:

Поддерживаемые платформы

• Linux 2.6 (inotify)
• Mac OS X (FSEvents, kqueue)
• FreeBSD / BSD (kqueue)
• Windows (ReadDirectoryChangesW с портами завершения ввода / вывода; рабочие потоки ReadDirectoryChangesW)
• Независимо от ОС (опрос диска на наличие снимков каталогов и их периодическое сравнение; медленный и не рекомендуется)

Просто написал оболочку для командной строки watchdog_exec:

Пример работает

На событии fs, включающем файлы и папки в текущем каталоге, выполните echo $src $dstкоманду, если она не изменена, а затем выполните python $srcкоманду.

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

Использование коротких аргументов и ограничение на выполнение только тогда, когда в событиях используется « main .py»:

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

РЕДАКТИРОВАТЬ: Только что обнаружил, что Watchdog имеет официальный CLI называется watchmedo, так что проверьте это также.

Если ваша программа генерирует какой-либо журнал / вывод, вы можете создать Makefile с правилом для этого журнала / вывода, который зависит от вашего сценария и сделать что-то вроде

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

Кроме того, вы можете создать фальшивую цель и назначить ей правило, и вызвать ваш скрипт, и коснуться фальшивой цели (хотя все еще зависит от вашего скрипта).

swarminglogic написал скрипт под названием watchfile.sh , также доступный в виде GitHub Gist .

Улучшено после ответа Жиля .

Эта версия запускается inotifywaitодин раз и отслеживает события (.eg:) modifyпосле этого. Такой, inotifywait который не нужно повторять при каждом обнаруженном событии.

Это быстро и быстро! _{(даже при рекурсивном мониторинге большого каталога)}

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

Еще немного о программировании, но вы хотите что-то вроде inotify . Существуют реализации на многих языках, таких как jnotify и pyinotify .

Эта библиотека позволяет отслеживать отдельные файлы или целые каталоги и возвращает события при обнаружении действия. Возвращаемая информация включает в себя имя файла, действие (создание, изменение, переименование, удаление) и путь к файлу, а также другую полезную информацию.

Для тех из вас, кто ищет решение FreeBSD, вот порт:

/usr/ports/sysutils/wait_on

Мне нравится простота, while inotifywait ...; do ...; doneоднако у нее есть две проблемы:

• Изменения файлов, происходящие во время, do ...;будут пропущены
• Медленно при использовании в рекурсивном режиме

Для этого я создал вспомогательный скрипт, который использует inotifywait без этих ограничений: inotifyexec

Я предлагаю вам поставить этот скрипт на вашем пути, как в ~/bin/. Использование описывается просто запуском команды.

Пример: inotifyexec "echo test" -r .

Улучшено решение Себастьяна с помощью watchкоманды:

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

Пример звонка:

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

Это работает, но будьте осторожны: watchкоманда имеет известные ошибки (см. Man): она реагирует на изменения только в VISIBLE в терминальных частях -g CMDвывода.

Вы можете попробовать рефлекс .

Reflex - небольшой инструмент для просмотра каталога и повторного запуска команды при изменении определенных файлов. Он отлично подходит для автоматического запуска задач компиляции / lint / test и для перезагрузки приложения при изменении кода.

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

Ответ oneliner, который я использую, чтобы отслеживать изменения файла:

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

Вам не нужно инициализировать BF, если вы знаете, что первая дата является временем начала.

Это просто и портативно. Здесь есть другой ответ, основанный на той же стратегии с использованием сценария. Посмотрите также.

Использование: я использую это для отладки и слежения за ~/.kde/share/config/plasma-desktop-appletsrc; что по неизвестной причине продолжает терятьSwitchTabsOnHover=false

Я использую этот скрипт, чтобы сделать это. Я использую inotify в режиме монитора

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

Сохраните это как runatwrite.sh

Usage: runatwrite.sh myfile.sh

он будет запускать myfile.sh при каждой записи.

Для тех, кто использует OS X, вы можете использовать LaunchAgent, чтобы отслеживать путь / файл на предмет изменений и что-то делать, когда это происходит. К вашему сведению - LaunchControl - хорошее приложение для простого создания / изменения / удаления демонов / агентов.

( пример взят здесь )

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

У меня есть GIST для этого, и использование довольно просто

watchfiles <cmd> <paths...>

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

Для людей, которые находят это в Google для изменений в конкретном файле, ответ намного проще (вдохновлен ответом Жиля ).

Если вы хотите что-то сделать после записи определенного файла, вот как:

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

Сохраните это как, например, copy_myfile.shи поместите .shфайл в /etc/init.d/папку, чтобы запустить его при запуске.

Инструмент «fido» может быть еще одним вариантом для этой необходимости. Смотрите https://www.joedog.org/fido-home/

Как и некоторые другие, я также написал для этого облегченный инструмент командной строки. Он полностью документирован, протестирован и модульный.

Часы-Do

Монтаж

Вы можете установить его (если у вас есть Python3 и pip), используя:

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

использование

Используйте это сразу, запустив:

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

Обзор возможностей

• Поддержка подстановки файлов (используйте -w '*.py'или -w '**/*.py')
• Запустите несколько команд для изменения файла (просто укажите -dфлаг снова)
• Динамически поддерживает список файлов для просмотра, если используется Globbing ( -rчтобы включить это)
• Несколько способов «посмотреть» файл:
  • Время модификации (по умолчанию)
  • Файловый хеш
  • Тривиально реализовать свой собственный (это наблюдатель ModificationTime )
• Модульная конструкция. Если вы хотите, чтобы команды выполнялись, когда к файлу обращаются, написать свой собственный наблюдатель (механизм, который определяет, должны ли исполнители выполняться), тривиально.