Як виконати команду, коли файл змінюється?

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

В даний час я використовую це:

while read; do ./myfile.py ; done

І тоді мені потрібно зайти до цього терміналу і натиснути Enter, коли я зберігаю цей файл у своєму редакторі. Я хочу щось таке:

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

Або будь-яке інше таке просте рішення.

BTW: Я використовую 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, використовуючи аналог кожного варіанту Linux inotify).

entr ( http://entrproject.org/ ) забезпечує більш дружній інтерфейс для ініціації (а також підтримує * 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-toolsяк я, це має бути корисним:

watch -d -t -g ls -lR

Ця команда вийде, коли вихід зміниться, ls -lRперерахує кожен файл та каталог з його розмірами та датами, тож якщо файл буде змінено, він повинен вийти з команди, як каже людина:

-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 як "повторну" на своєму PATH та запустіть її, використовуючи:

rerun COMMAND

Він запускається COMMAND щоразу, коли у вашому поточному каталозі відбувається подія зміни файлової системи (рекурсивна.)

Про це можуть сподобатися:

• Він використовує inotify, тому є більш чутливим, ніж опитування. Чудовий для запуску тестів підмілісекундних одиниць або надання файлів крапкових графіків кожного разу, коли ви натискаєте "зберегти".
• Оскільки це так швидко, вам не доведеться заважати йому казати ігнорувати великі підкаталоги (наприклад, node_modules) лише з міркувань продуктивності.
• Це надзвичайно чуйно, тому що він запускає inotifywait лише один раз, при запуску, замість того, щоб запускати його, і завдавати дорогого хіта встановлення годин на кожній ітерації.
• Це всього 12 рядків Баша
• Оскільки це Bash, він інтерпретує команди, які ви передаєте його точно так, як ніби ви їх набрали у запиті Bash. (Імовірно, це менш круто, якщо ви використовуєте іншу оболонку.)
• Він не втрачає подій, які трапляються під час виконання COMMAND, на відміну від більшості інших ініціативних рішень на цій сторінці.
• Під час першої події він вступає у «мертвий період» на 0,15 секунди, протягом якого інші події ігноруються, перш ніж COMMAND запускається рівно один раз. Це так, що шквал подій, спричинений танцем "створити-записати-рухати", який виконує Vi або Emacs під час збереження буфера, не спричинить багаторазових копій можливих повільних тестових наборів. Будь-які події, які потім трапляються під час виконання COMMAND, не ігноруються - вони спричинить другий мертвий період та подальше виконання.

Речі, які можуть не сподобатися в цьому:

• Він використовує inotify, тому не працює за межами Linuxland.
• Оскільки він використовує inotify, він намагатиметься переглядати каталоги, що містять більше файлів, ніж максимальна кількість користувачів, які ініціюють годинник. За замовчуванням це, здається, встановлено приблизно від 5000 до 8000 на різних машинах, які я використовую, але їх легко збільшити. Дивіться https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached
• Він не може виконати команди, що містять псевдоніми Bash. Я міг би поклятися, що це працювало раніше. В принципі, тому що це Bash, а не виконуючи COMMAND в нижній частині, я б очікував, що це спрацює. Я хотів би почути, якщо хтось знає, чому це не так. Багато інших рішень на цій сторінці також не можуть виконувати такі команди.
• Особисто я хотів би, щоб я зміг натиснути клавішу в терміналі, в якому він працює, щоб вручну викликати додаткове виконання COMMAND. Чи можу я додати це якось просто? Одночасно виконується цикл "read -n1", який також виконує дзвінки?
• Зараз я зашифрував його, щоб очистити термінал і надрукувати виконану КОМАНДУ на кожній ітерації. Деякі люди можуть хотіти додати прапори командного рядка, щоб вимкнути подібні речі тощо. Але це збільшить розмір та складність у багато разів.

Це уточнення передвісті @ cychoi.

Ось простий скрипт оболонки Bourne shell, який:

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), але в цьому випадку ви можете просто жорстко кодувати ім'я файлу temp.

Погляньте на інкрон . Він схожий на cron, але замість часу використовує ініціативні події.

Ще одне рішення з 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 (ініціювати)
• Mac OS X (FSEvents, kqueue)
• FreeBSD / BSD (kqueue)
• Windows (ReadDirectoryChangesW з портами завершення вводу / виводу; робочі потоки ReadDirectoryChangesW)
• Незалежна від ОС (опитування диска на знімки каталогів та періодичне їх порівняння; повільне та не рекомендується)

Щойно написав обгортку командного рядка для цього watchdog_exec:

Приклад виконання

У події fs, що включає файли та папки в поточному каталозі, запустіть echo $src $dstкоманду, якщо вона не змінила подія fs, тоді запустіть python $srcкоманду.

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

Використання коротких аргументів та обмеження виконання лише тоді, коли події включають " main .py":

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

EDIT: Щойно знайдений 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

Ще трохи з боку програмування, але ви хочете щось подібне до ініціації . Є реалізація на багатьох мовах, таких як 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 - це невеликий інструмент для перегляду каталогу та повторної роботи команди при зміні певних файлів. Він чудово підходить для автоматичного виконання завдань компіляції / вкладишів / тестів та для перезавантаження програми, коли код змінюється.

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

Відповідь в одній лінійці, яку я використовую для відстеження зміни файлу:

$ 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, щоб переглянути шлях / файл за змінами та зробити щось, коли це станеться. FYI - 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>

У мене є ГІСТ для цього, і використання досить просте

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/папку для запуску при запуску.

Інструмент «фідо» може бути ще одним варіантом для цієї потреби. Дивіться https://www.joedog.org/fido-home/

Як і кілька інших, я також написав легкий інструмент командного рядка для цього. Це повністю документально підтверджене, перевірене та модульне.

Дивіться

Установка

Ви можете встановити його (якщо у вас 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прапор ще раз)
• Динамічно підтримує список файлів для перегляду, якщо використовується глобул (-r щоб увімкнути це)
• Кілька способів "переглянути" файл:
  • Час модифікації (за замовчуванням)
  • Файл хешу
  • Тривіально реалізувати своє власне (це спостерігач ModificationTime )
• Модульний дизайн. Якщо ви хочете запускати команди, коли доступ до файлу, тривіально написати власний вахтувальний механізм (механізм, який визначає, чи потрібно запускати виконавці).