Jak wykonać polecenie przy każdej zmianie pliku?

Chcę szybkiego i prostego sposobu wykonania polecenia przy każdej zmianie pliku. Chcę czegoś bardzo prostego, czegoś, co zostawię uruchomionego na terminalu i zamknę go, gdy skończę pracę z tym plikiem.

Obecnie używam tego:

while read; do ./myfile.py ; done

A potem muszę iść do tego terminala i naciskać Enter, ilekroć zapiszę ten plik w moim edytorze. Chcę czegoś takiego:

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

Lub każde inne rozwiązanie tak proste.

BTW: Używam Vima i wiem, że mogę dodać komendę automatyczną, aby uruchomić coś na BufWrite, ale nie jest to rozwiązanie, którego chcę teraz.

Aktualizacja: Chcę coś prostego, jeśli to możliwe, można je odrzucić. Co więcej, chcę, aby coś działało w terminalu, ponieważ chcę zobaczyć wyjście programu (chcę zobaczyć komunikaty o błędach).

O odpowiedziach: Dziękujemy za wszystkie odpowiedzi! Wszystkie są bardzo dobre i każde z nich ma inne podejście niż inne. Ponieważ muszę zaakceptować tylko jeden, akceptuję ten, którego faktycznie użyłem (był prosty, szybki i łatwy do zapamiętania), mimo że wiem, że nie jest on najbardziej elegancki.

Proste, używając inotifywait (zainstaluj inotify-toolspakiet swojej dystrybucji ):

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

lub

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

Pierwszy fragment kodu jest prostszy, ale ma znaczącą wadę: będzie pomijał zmiany dokonane, gdy inotifywaitnie jest uruchomiony (w szczególności podczas myfiledziałania). Drugi fragment nie ma tej wady. Należy jednak pamiętać, że zakłada, że ​​nazwa pliku nie zawiera spacji. Jeśli to jest problem, użyj --formatopcji, aby zmienić wyjście tak, aby nie zawierało nazwy pliku:

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

Tak czy inaczej, istnieje ograniczenie: jeśli jakiś program zastąpi myfile.pyinnym plikiem, zamiast zapisywać w istniejącym myfile, inotifywaitumrze. Wielu redaktorów działa w ten sposób.

Aby obejść to ograniczenie, użyj inotifywaitw katalogu:

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

Alternatywnie, użyj innego narzędzia, które korzysta z tej samej podstawowej funkcji, takiego jak incron (pozwala rejestrować zdarzenia, gdy plik jest modyfikowany) lub fswatch (narzędzie, które działa również na wielu innych wariantach Uniksa, wykorzystując analogię każdego wariantu inotify Linuksa).

entr ( http://entrproject.org/ ) zapewnia bardziej przyjazny interfejs do inotify (a także obsługuje * BSD i Mac OS X).

Ułatwia to określenie wielu plików do oglądania (ograniczone tylko przez ulimit -n), eliminuje problemy związane z zastępowaniem plików i wymaga mniejszej składni bash:

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

Używałem go w całym drzewie źródeł projektu, aby przeprowadzać testy jednostkowe kodu, który obecnie modyfikuję, i to już znacznie poprawiło mój przepływ pracy.

Flagi takie jak -c(wyczyść ekran między uruchomieniami) i -d(zakończ, gdy nowy plik zostanie dodany do monitorowanego katalogu) zapewniają jeszcze większą elastyczność, na przykład możesz:

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

Od początku 2018 r. Wciąż jest w fazie rozwoju i można go znaleźć w Debian & Ubuntu ( apt install entr); w każdym razie budowanie z repozytorium autora było bezbolesne.

Napisałem program w języku Python, który robi dokładnie to, co nazywa się po zmianie .

Użycie jest proste:

when-changed FILE COMMAND...

Lub obejrzeć wiele plików:

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

FILEmoże być katalogiem. Oglądaj rekurencyjnie za pomocą -r. Służy %fdo przekazania nazwy pliku do polecenia.

Co powiesz na ten skrypt? Używa statpolecenia, aby uzyskać czas dostępu do pliku i uruchamia polecenie, gdy nastąpi zmiana czasu dostępu (przy każdym dostępie do pliku).

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

Rozwiązanie wykorzystujące Vima:

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

Ale nie chcę tego rozwiązania, ponieważ jest trochę denerwujące w pisaniu, trudno jest dokładnie zapamiętać, co dokładnie wpisać, i trochę trudno jest cofnąć jego efekty (trzeba uruchomić :au! BufWritePost myfile.py). Ponadto to rozwiązanie blokuje Vima, dopóki polecenie nie zakończy wykonywania.

Dodałem tutaj to rozwiązanie tylko dla kompletności, ponieważ może pomóc innym ludziom.

Aby wyświetlić dane wyjściowe programu (i całkowicie zakłócić proces edycji, ponieważ dane wyjściowe będą zapisywane w edytorze przez kilka sekund, dopóki nie naciśniesz Enter), usuń :silentpolecenie.

Jeśli zdarzyło Ci się mieć npmzainstalowany, nodemonjest to prawdopodobnie najłatwiejszy sposób na rozpoczęcie pracy, szczególnie w OS X, który najwyraźniej nie ma narzędzi do inotify. Obsługuje uruchamianie polecenia, gdy zmienia się folder.

Dla tych, którzy nie mogą zainstalować inotify-toolsjak ja, powinno to być przydatne:

watch -d -t -g ls -lR

To polecenie zakończy działanie po zmianie danych wyjściowych, ls -lRwyświetli listę wszystkich plików i katalogów wraz z ich rozmiarem i datami, więc jeśli plik zostanie zmieniony, powinien zakończyć polecenie, jak mówi mężczyzna:

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

Wiem, że nikt nie może przeczytać tej odpowiedzi, ale mam nadzieję, że ktoś do niej sięgnie.

Przykład wiersza poleceń:

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

Otwórz inny terminal:

~ $ echo "testing" > /tmp/test

Teraz pierwszy terminal wyjdzie 1,2,3

Prosty przykład skryptu:

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

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

rerun2( na github ) to 10-liniowy skrypt Bash w formie:

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

Zapisz wersję github jako „uruchom ponownie” na swojej ŚCIEŻCE i wywołaj ją, używając:

rerun COMMAND

Uruchamia POLECENIE za każdym razem, gdy w bieżącym katalogu znajduje się zdarzenie modyfikacji systemu plików (rekurencyjne).

Co może się w tym spodobać:

• Używa inotify, więc jest bardziej responsywny niż odpytywanie. Doskonale nadaje się do przeprowadzania testów jednostkowych poniżej milisekund lub renderowania plików grafviz za każdym razem, gdy naciskasz „zapisz”.
• Ponieważ jest tak szybki, nie musisz zawracać sobie głowy nakazaniem mu ignorowania dużych podkatalogów (takich jak moduły_węzłów) tylko ze względu na wydajność.
• Jest wyjątkowo super responsywny, ponieważ wywołuje inotifywait tylko raz, przy uruchomieniu, zamiast go uruchamiać i ponosząc kosztowny hit tworzenia zegarków, przy każdej iteracji.
• To tylko 12 linii Bash
• Ponieważ jest to Bash, interpretuje przekazane polecenia dokładnie tak, jakbyś wpisał je po znaku zachęty Bash. (Prawdopodobnie jest to mniej fajne, jeśli użyjesz innej powłoki).
• Nie traci zdarzeń, które mają miejsce podczas wykonywania polecenia COMMAND, w przeciwieństwie do większości innych rozwiązań inotify na tej stronie.
• Przy pierwszym zdarzeniu przechodzi w „martwy okres” na 0,15 sekundy, podczas którego inne zdarzenia są ignorowane, zanim polecenie POLECENIE zostanie uruchomione dokładnie raz. Dzieje się tak dlatego, że gwałtowny rozwój wydarzeń spowodowany tańcem tworzenia-zapisu-ruchu, który Vi lub Emacs robią podczas zapisywania bufora, nie powoduje wielu żmudnych wykonań prawdopodobnie wolno działającego zestawu testów. Wszelkie zdarzenia, które następnie wystąpią podczas wykonywania polecenia COMMAND, nie są ignorowane - spowodują drugi martwy okres i kolejne wykonanie.

Rzeczy, których można by nie lubić:

• Używa inotify, więc nie będzie działać poza Linuxland.
• Ponieważ używa on inotify, utrudni to próby oglądania katalogów zawierających więcej plików niż maksymalna liczba zegarków inotify użytkownika. Domyślnie wydaje się być ustawiony na około 5000 do 8000 na różnych komputerach, których używam, ale łatwo go zwiększyć. Zobacz https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached
• Nie wykonuje poleceń zawierających aliasy Bash. Mógłbym przysiąc, że to kiedyś działało. Zasadniczo, ponieważ jest to Bash, a nie wykonywanie POLECENIA w podpowłoce, oczekiwałbym, że to zadziała. Chciałbym usłyszeć, jeśli ktoś wie, dlaczego tak nie jest. Wiele innych rozwiązań na tej stronie również nie może wykonywać takich poleceń.
• Osobiście chciałbym móc wcisnąć klucz w terminalu, w którym jest uruchomiony, aby ręcznie spowodować dodatkowe wykonanie polecenia COMMAND. Czy mogę to jakoś dodać, po prostu? Równolegle działająca pętla „podczas odczytu -n1”, która również wywołuje wykonywanie?
• W tej chwili zakodowałem go, aby wyczyścić terminal i drukować wykonane polecenie na każdej iteracji. Niektórzy ludzie mogą chcieć dodać flagi wiersza polecenia, aby wyłączyć takie rzeczy itp. Ale zwiększyłoby to wielokrotnie rozmiar i złożoność.

Jest to udoskonalenie odpowiedzi @'egoioi.

Oto prosty skrypt powłoki Bourne'a, który:

1. Pobiera dwa argumenty: monitorowany plik i polecenie (w razie potrzeby z argumentami)
2. Kopiuje monitorowany plik do katalogu / tmp
3. Sprawdza co dwie sekundy, czy monitorowany plik jest nowszy niż kopia
4. Jeśli jest nowszy, nadpisuje kopię nowszym oryginałem i wykonuje polecenie

5. Czyści po sobie po naciśnięciu 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  
   

Działa to na FreeBSD. Jedynym problemem związanym z przenośnością, jaki mogę wymyślić, jest to, że jakiś inny Uniks nie ma komendy mktemp (1), ale w takim przypadku możesz po prostu na stałe wpisać nazwę pliku tymczasowego.

Spójrz na incron . Jest podobny do crona, ale używa zdarzeń inotify zamiast czasu.

Inne rozwiązanie z NodeJs, fsmonitor :

1. zainstalować

   sudo npm install -g fsmonitor
   

2. Z wiersza poleceń (na przykład monitoruj dzienniki i „sprzedaż detaliczną”, jeśli zmieni się jeden plik dziennika)

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

Zajrzyj do Guard, w szczególności za pomocą tej wtyczki:

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

Możesz go skonfigurować tak, aby obserwował dowolną liczbę wzorców w katalogu twojego projektu i wykonywał polecenia po wystąpieniu zmian. Jest duża szansa, że ​​dostępna jest wtyczka do tego, co próbujesz zrobić w pierwszej kolejności.

jeśli masz zainstalowany nodemon , możesz to zrobić:

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

W moim przypadku edytuję html lokalnie i wysyłam go na mój zdalny serwer, gdy plik się zmienia.

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

W systemie Linux:

man watch

watch -n 2 your_command_to_run

Uruchomi polecenie co 2 sekundy.

Jeśli wykonanie polecenia trwa dłużej niż 2 sekundy, zegarek poczeka, aż zostanie wykonany, zanim wykona to ponownie.

Watchdog to projekt w języku Python i może być właśnie tym, czego szukasz:

Obsługiwane platformy

• Linux 2.6 (inotify)
• Mac OS X (FSEvent, kqueue)
• FreeBSD / BSD (kqueue)
• Windows (ReadDirectoryChangesW z portami zakończenia we / wy; ReadDirectoryChangesW wątki robocze)
• Niezależny od systemu operacyjnego (sondowanie dysku w poszukiwaniu migawek katalogów i okresowe porównywanie; wolne i niezalecane)

Właśnie napisałem dla niego opakowanie wiersza polecenia watchdog_exec:

Przykład działa

W przypadku zdarzenia fs dotyczącego plików i folderów w bieżącym katalogu uruchom echo $src $dstpolecenie, chyba że zdarzenie fs zostanie zmodyfikowane, a następnie uruchom python $srcpolecenie.

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

Używając krótkich argumentów i ograniczając się do wykonywania tylko wtedy, gdy zdarzenia dotyczą „ main .py”:

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

EDYCJA: Właśnie znalazłem, że Watchdog ma oficjalny interfejs CLI watchmedo, więc sprawdź to również.

Jeśli twój program generuje jakiś dziennik / dane wyjściowe, możesz utworzyć plik Makefile z regułą dla tego dziennika / danych wyjściowych zależną od skryptu i zrobić coś takiego

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

Alternatywnie możesz utworzyć fałszywy cel i mieć regułę zarówno wywoływania skryptu, jak i dotykania fałszywego celu (wciąż zależnie od skryptu).

swarminglogic napisał skrypt o nazwie watchfile.sh , dostępny również jako GitHub Gist .

Poprawiono odpowiedź Gillesa .

Ta wersja działa inotifywaitraz i monitoruje zdarzenia (.eg:) modifypóźniej. Takie, które inotifywait nie muszą być ponownie wykonywane przy każdym napotkanym zdarzeniu.

Jest szybki i szybki! _{(nawet podczas rekurencyjnego monitorowania dużego katalogu)}

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

Trochę więcej po stronie programowania, ale chcesz coś takiego jak inotify . Istnieją implementacje w wielu językach, takie jak jnotify i pyinotify .

Ta biblioteka pozwala monitorować pojedyncze pliki lub całe katalogi i zwraca zdarzenia po wykryciu akcji. Zwrócone informacje obejmują między innymi nazwę pliku, akcję (tworzenie, modyfikację, zmianę nazwy, usuwanie) i ścieżkę do pliku, a także inne przydatne informacje.

Dla tych z Was, którzy szukają rozwiązania FreeBSD, oto port:

/usr/ports/sysutils/wait_on

Podoba mi się prostota tego, while inotifywait ...; do ...; doneale ma dwa problemy:

• Zmiany plików zachodzące w trakcie do ...;zostaną pominięte
• Wolno podczas używania w trybie rekurencyjnym

Dlatego stworzyłem skrypt pomocnika, który używa inotifywait bez tych ograniczeń: inotifyexec

Sugeruję, abyś umieścił ten skrypt na swojej ścieżce, jak w ~/bin/. Użycie opisuje się po prostu uruchamiając polecenie.

Przykład: inotifyexec "echo test" -r .

Ulepszone rozwiązanie Sebastiana z watchpoleceniem:

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

Przykład połączenia:

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

Działa, ale bądź ostrożny: watchkomenda zna błędy (patrz man): reaguje na zmiany tylko w WIDOCZNYM w końcowych częściach -g CMDwyjścia.

Możesz spróbować odruchu .

Reflex to małe narzędzie do oglądania katalogu i ponownego uruchamiania polecenia po zmianie niektórych plików. Jest świetny do automatycznego uruchamiania zadań kompilacji / lint / testowania oraz do ponownego ładowania aplikacji, gdy kod się zmienia.

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

Odpowiedź oneliner, której używam do śledzenia zmiany pliku:

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

Nie musisz inicjować BF, jeśli wiesz, że pierwsza data to godzina rozpoczęcia.

To jest proste i przenośne. Istnieje inna odpowiedź oparta na tej samej strategii przy użyciu skryptu tutaj. Spójrz także.

Użycie: Używam tego do debugowania i pilnowania ~/.kde/share/config/plasma-desktop-appletsrc; z jakiegoś nieznanego powodu ciągle gubię mojeSwitchTabsOnHover=false

Używam tego skryptu, aby to zrobić. Używam inotify w trybie monitorowania

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

Zapisz to jako runatwrite.sh

Usage: runatwrite.sh myfile.sh

przy każdym zapisie uruchomi plik myfile.sh.

Dla tych, którzy używają OS X, możesz użyć LaunchAgent, aby obserwować ścieżkę / plik pod kątem zmian i zrobić coś, kiedy to nastąpi. FYI - LaunchControl to dobra aplikacja do łatwego tworzenia / modyfikowania / usuwania demonów / agentów.

( przykład wzięty stąd )

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

Mam do tego GIST, a użycie jest dość proste

watchfiles <cmd> <paths...>

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

Dla osób, które Googling znajdują w poszukiwaniu zmian w konkretnym pliku, odpowiedź jest znacznie prostsza (zainspirowana odpowiedzią Gillesa ).

Jeśli chcesz coś zrobić po zapisaniu określonego pliku, oto jak:

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

Zapisz to, na przykład, copy_myfile.shi umieść .shplik w /etc/init.d/folderze, aby uruchomił się przy starcie.

Narzędzie „fido” może być kolejną opcją dla tej potrzeby. Zobacz https://www.joedog.org/fido-home/

Jak zrobiło to kilka innych, napisałem również lekkie narzędzie wiersza poleceń, aby to zrobić. Jest w pełni udokumentowany, przetestowany i modułowy.

Watch-Do

Instalacja

Możesz go zainstalować (jeśli masz Python3 i pip), używając:

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

Stosowanie

Użyj go od razu, uruchamiając:

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

Przegląd funkcji

• Obsługuje globowanie plików (użyj -w '*.py'lub -w '**/*.py')
• Uruchom wiele poleceń przy zmianie pliku ( -dponownie określ flagę)
• Dynamicznie utrzymuje listę plików do obejrzenia, jeśli używane jest globowanie ( -raby to włączyć)
• Wiele sposobów „oglądania” pliku:
  • Czas modyfikacji (domyślnie)
  • Skrót pliku
  • Trywialne wdrożenie własnego (jest to obserwator ModificationTime )
• Modułowa konstrukcja. Jeśli chcesz, aby komendy były uruchamiane, podczas uzyskiwania dostępu do pliku, trywialne jest napisanie własnego obserwatora (mechanizm, który określa, czy należy wykonać).