Bir dosya değiştiğinde komut nasıl çalıştırılır?

Bir dosya değiştiğinde komutun hızlı ve basit bir şekilde yürütülmesini istiyorum. Çok basit bir şey istiyorum, bir terminalde çalışmayı bırakacağım ve o dosyayla çalışmayı bitirdiğimde onu kapatacağım.

Şu anda, bunu kullanıyorum:

while read; do ./myfile.py ; done

Sonra o terminale gidip Girmek , o dosyayı ne zaman editörüme kaydedersem. İstediğim şey şunun gibi bir şey:

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

Veya bu kadar kolay başka bir çözüm.

BTW: Vim kullanıyorum ve bufWrite'da bir şeyi çalıştırmak için bir otomatik komut ekleyebileceğimi biliyorum, ama bu şimdi istediğim bir çözüm değil.

Güncelleştirme: Mümkünse basit, anlaşılabilir bir şey istiyorum. Dahası, bir terminalde çalışacak bir şey istiyorum çünkü program çıktısını görmek istiyorum (hata mesajlarını görmek istiyorum).

Cevaplar hakkında: Tüm cevaplarınız için teşekkürler! Hepsi çok iyi ve her biri diğerlerinden çok farklı bir yaklaşım sergiliyor. Sadece birini kabul etmem gerektiğine göre, gerçekten kullandığım birini (basit, hızlı ve hatırlanması kolaydı) kabul ediyorum, en şık olmadığını bilmeme rağmen.

Basit, kullanarak inotifywait (dağıtımınızı yükleyin inotify-tools paket):

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

veya

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

İlk pasaj daha basittir ancak olumsuz bir yönü vardır: inotifywait Çalışmıyor (özellikle myfile çalışıyor). İkinci pasajda bu kusur yok. Ancak, dosya adının boşluk içermediğini varsaydığına dikkat edin. Bu bir problemse, kullan --format çıktıyı dosya adını içermeyecek şekilde değiştirme seçeneği:

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

Her iki durumda da bir sınırlama var: eğer bazı programlar yerini alırsa myfile.py var olana yazmak yerine farklı bir dosyayla myfile, inotifywait ölecek. Birçok editör bu şekilde çalışır.

Bu sınırlamayı aşmak için, inotifywait dizinde:

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

Alternatif olarak, aşağıdaki gibi temel işlevleri kullanan başka bir araç kullanın. incron (bir dosya değiştirildiğinde etkinlik kaydetmenizi sağlar) veya fswatch (Linux'un inotify'ının her bir varyantını kullanarak, diğer birçok Unix varyantında da çalışan bir araç).

entr ( http://entrproject.org/ ), belirtmek için daha kolay bir arayüz sağlar (ve ayrıca * BSD ve Mac OS X'i de destekler).

İzlenecek birden çok dosyayı belirtmeyi çok kolaylaştırır (yalnızca ulimit -n ), değiştirilen dosyalarla uğraşmakta güçlük çeker ve daha az bash sözdizimi gerektirir:

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

Şu anda değiştirdiğim kod için birim sınamalarını çalıştırmak için tüm proje kaynak ağacımda kullanıyorum ve zaten iş akışımda büyük bir artış oldu.

Gibi bayraklar -c (koşular arasındaki ekranı temizleyin) ve -d (izlenen bir dizine yeni bir dosya eklendiğinde çıkın) daha da fazla esneklik ekleyin, örneğin:

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

2018'in başından itibaren hala aktif gelişim içindedir ve Debian'da bulunabilir. Ubuntu ( apt install entr ); Her durumda yazarın deposundan inşa etmek ağrısızdı.

Bunu yapmak için bir Python programı yazdım. zaman-değiştirdi .

Kullanımı basit:

when-changed FILE COMMAND...

Veya birden fazla dosyayı izlemek için:

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

FILE bir dizin olabilir. Tekrarlayarak izleyin -r. kullanım %f dosya adını komuta geçirmek için.

Bu senaryoya ne dersin? Kullanır stat Bir dosyanın erişim zamanını almak için komut ve erişim zamanında bir değişiklik olduğunda (dosyaya erişildiğinde) bir komut çalıştırır.

#!/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 kullanarak çözüm:

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

Ancak bu çözümü istemiyorum çünkü yazmak biraz can sıkıcı, ne yazacağımı hatırlamak biraz zor, tam olarak ve etkilerini geri almak biraz zor (çalışması gerekiyor :au! BufWritePost myfile.py ). Ayrıca, bu çözüm komutun çalışmasını bitirene kadar Vim'i de engeller.

Bu çözümü, diğer insanlara yardımcı olabileceği için sadece tamlık için buraya ekledim.

Program çıktısını görüntülemek (ve düzenleme editörünüzün üzerine birkaç saniye yazacağınız için, Enter tuşuna basana kadar düzenleme akışınızı tamamen kesmek için), :silent Komut.

Eğer olsaydın npm Kurulmuş, nodemon muhtemelen görünüşte araçları inotify olmayan OS X'te başlamak için en kolay yoldur. Bir klasör değiştiğinde komut çalıştırmayı destekler.

rerun2 ( github ), formun 10 satırlık bir Bash komut dosyasıdır:

#!/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 sürümünü PATH'nizde 'yeniden çalıştırma' olarak kaydedin ve aşağıdakileri kullanarak çağırın:

rerun COMMAND

Geçerli dizininizde (özyinelemeli) bir dosya sistemi change olayı olduğu her zaman COMMAND ile çalışır.

Bir insanın hoşuna gidebilecek şeyler:

• İnotify kullanır, yoklamadan daha hassastır. Milisaniye altı birim testlerini yapmak veya 'kaydet' düğmesine her bastığınızda graphviz dot dosyaları oluşturmak için mükemmel.
• Çok hızlı olduğu için, sadece performans nedenlerinden ötürü büyük alt dizinleri (node_modules gibi) yoksaymasını söylemenize gerek yok.
• Ekstra süper duyarlıdır, çünkü çalıştırma yerine, her seferinde inotifywait'i bir kez bekler, her seferinde saatler kurmanın pahalı sonucuna neden olur.
• Sadece 12 satır Bash
• Bash olduğu için, onları bir Bash isteminde yazdığınız gibi tam olarak ilettiğiniz komutları yorumlar. (Başka bir kabuk kullanıyorsanız, bu muhtemelen daha az soğuktur.)
• Bu sayfadaki diğer inotify çözümlerinin çoğunun aksine, COMMAND yürütülürken meydana gelen olayları kaybetmez.
• İlk olayda, COMMAND tam olarak bir kez çalıştırılmadan önce, diğer olayların göz ardı edildiği 0.15 saniye boyunca 'ölü bir döneme' girer. Bu, Vi veya Emacs'in bir tamponu kaydederken yaptığı yazma-yazma-taşıma dansının neden olduğu olayların telaşı, muhtemelen yavaş çalışan bir test takımının birden fazla zahmetli uygulamasına neden olmaz. COMMAND yürütülürken meydana gelen olaylar göz ardı edilmez - ikinci bir ölü döneme ve daha sonra yürütmeye neden olurlar.

Bir kişinin bu konuda sevmediği şeyler:

• İnotify kullanır, bu nedenle Linuxland dışında çalışmaz.
• İnotify kullandığı için, maksimum kullanıcı inotify saati sayısından daha fazla dosya içeren dizinleri izlemeye çalışmaktan öteye gidecektir. Varsayılan olarak, bu kullandığım farklı makinelerde yaklaşık 5.000 ila 8.000 olarak ayarlanmış gibi görünüyor, ancak artması kolay. Görmek https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached
• Bash takma adları içeren komutları yerine getirmiyor. Bunun işe yaradığına yemin edebilirim. Prensip olarak, bu Bash olduğundan, COMMAND'ı bir alt kabukta çalıştırmamak, bunun çalışmasını beklerdim. Neden olduğunu bilmeyen birileri varsa duymak isterim. Bu sayfadaki diğer çözümlerin birçoğu da böyle komutları çalıştıramaz.
• Şahsen, COMMAND'ın ekstra bir şekilde çalıştırılmasına neden olmak için çalıştığı terminalde bir tuşa basabilmeyi diliyorum. Bunu bir şekilde ekleyebilir miyim? Eşzamanlı olarak çalışan '-n1 okurken' döngüsü de çalıştırılan?
• Şu anda terminali temizlemek ve yürütülen her COMMAND komutunu her yinelemeye yazdırmak için kodladım. Bazı insanlar bunun gibi şeyleri kapatmak için komut satırı bayrakları eklemek isteyebilirler. Fakat bu, boyutu ve karmaşıklığı çok kat arttıracaktır.

Bu, @ cychoi'nin anwer ürününün iyileştirilmesidir.

İşte basit bir kabuk Bourne kabuğu betiği:

1. İki argüman alır: izlenecek dosya ve bir komut (gerekirse, argümanlarla)
2. İzlemekte olduğunuz dosyayı / tmp dizinine kopyalar
3. Her iki saniyede bir, izlemekte olduğunuz dosyanın kopyadan daha yeni olup olmadığını kontrol eder
4. Eğer daha yeniyse, kopya yeni yeninin üzerine yazar ve komutu çalıştırır.

5. Ctrl-C tuşlarına bastığınızda kendinden sonra temizler

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

Bu FreeBSD üzerinde çalışır. Aklıma gelen tek taşınabilirlik sorunu, başka bir Unix'in mktemp (1) komutuna sahip olmamasıdır, ancak bu durumda geçici dosya adını yalnızca zor kodlayabilirsiniz.

Yükleyemeyenler için inotify-tools Benim gibi, bu yararlı olmalı:

watch -d -t -g ls -lR

Çıktı değiştiğinde bu komut çıkacaktır, ls -lR Her dosya ve dizini büyüklüğü ve tarihleriyle birlikte listeleyecektir, bu nedenle eğer bir dosya değiştirilirse komuttan çıkması gerekir.

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

Bu cevabın kimse tarafından okunamayacağını biliyorum, ama umarım birileri ona ulaşır.

Komut satırı örneği:

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

Başka bir terminal aç:

~ $ echo "testing" > /tmp/test

Şimdi ilk terminal çıkacak 1,2,3

Basit komut dosyası örneği:

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

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

Şuna bir bak incron . Bu cron'a benzer, ancak zaman yerine inotify olaylarını kullanır.

NodeJs ile başka bir çözüm, fsmonitor :

1. kurmak

   sudo npm install -g fsmonitor
   

2. Komut satırından (örneğin, günlükleri izleyin ve bir günlük dosyası değişirse "perakende")

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

Linux altında:

man watch

watch -n 2 your_command_to_run

Her 2 saniyede bir komutu çalıştıracak.

Komutunuzun çalışması 2 saniyeden uzun sürerse, tekrar yapmadan önce saatiniz bekleyecektir.

Özellikle bu eklenti ile Guard'a bakın:

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

Projenizin dizinindeki herhangi bir sayıda deseni izlemek için ayarlayabilirsiniz ve değişiklikler olduğunda komutları uygulayabilirsiniz. İlk etapta yapmaya çalıştığınız şey için bir eklenti olsa bile iyi bir şans.

eğer varsa nodemon yüklü, o zaman bunu yapabilirsiniz:

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

Benim durumumda html'yi yerel olarak düzenlerim ve bir dosya değiştiğinde uzak sunucuma gönderirim.

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

Programınız bir tür günlük / çıktı oluşturuyorsa, betiğinize bağlı olan bu günlük / çıktı için bir kural içeren bir Makefile oluşturabilir ve bir şey yapabilir

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

Alternatif olarak, bir sahte hedef oluşturabilir ve bununla ilgili kuralın betiğinizi çağırmasını ve sahte hedefe dokunmasını sağlayabilirsiniz (yine de betiğinize bağlı olarak).

swarminglogic yazdı watchfile.sh adlı bir komut dosyası , Ayrıca GitHub Gist olarak mevcut .

bekçi köpeği bir Python projesidir ve tam olarak aradığınız şey olabilir:

Desteklenen platformlar

• Linux 2.6 (belirtilmemiş)
• Mac OS X (FSEvents, sıra)
• FreeBSD / BSD (sıra)
• Windows (G / Ç tamamlama bağlantı noktalarına sahip ReadDirectoryChangesW; ReadDirectoryChangesW çalışan konuları)
• İşletim sisteminden bağımsız (dizini anlık görüntüler için yoklama ve düzenli aralıklarla karşılaştırma yapma; yavaş ve önerilmez)

Sadece bunun için bir komut satırı sarıcı yazdı watchdog_exec:

Örnek çalıştırmalar

Geçerli dizindeki dosya ve klasörleri içeren fs olayında, çalıştır echo $src $dst komutu, fs olayı değiştirilmediği sürece çalıştır python $src Komut.

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

Kısa argümanlar kullanmak ve yalnızca olaylar içerdiğinde yürütmekle kısıtlamak " ana ".Py:

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

EDIT: Sadece Watchdog adında resmi bir CLI var bulundu watchmedo, öyleyse bunu da kontrol et.

Üzerine geliştirilmiş Gilles'in cevabı .

Bu sürüm çalışıyor inotifywait bir kez ve olayları izler (.e.g .: modify ) bundan sonra. Öyle ki inotifywait değil Karşılaşılan her olayda tekrar idam edilmesi gerekiyor.

Hızlı ve hızlı! _{(büyük dizini özyinelemeli olarak izlerken bile)}

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

Programlama tarafında biraz daha, ama gibi bir şey istiyorum Inotify . Gibi birçok dilde uygulamalar vardır, jnotify ve pyinotify .

Bu kitaplık, tek tek dosyaları veya tüm dizinleri izlemenizi sağlar ve bir eylem bulunduğunda olayları döndürür. Dönen bilgiler, diğer faydalı bilgilerin yanı sıra dosya adını, eylemi (oluştur, değiştir, yeniden adlandır, sil) ve dosya yolunu da içerir.

FreeBSD çözümü arayanlar için, işte liman:

/usr/ports/sysutils/wait_on

Sadeliği severim while inotifywait ...; do ...; done ancak iki sorunu var:

• Sırasında gerçekleşen dosya değişiklikleri do ...; irade kaçırılmak, özlenmek
• Yavaş özyinelemeli modda kullanırken

Bu nedenle kullanan bir komut dosyası yaptım inotifywait bu sınırlamalar olmadan: inotifyexec

Bu betiği, kendi ~/bin/. Kullanım sadece komutu çalıştırarak açıklanmaktadır.

Örnek: inotifyexec "echo test" -r .

Gelişmiş Sebastian'ın çözümü ile watch komut:

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

Çağrı örneği:

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

Çalışıyor ama dikkatli olun: watch komutunun bilinen hataları var (erkeğe bakınız): sadece VISIBLE’deki değişikliklere tepki verir. -g CMD çıktı.

Deneyebilirsin refleks .

Refleks, bir dizini izlemek ve belirli dosyalar değiştiğinde komutu yeniden çalıştırmak için kullanılan küçük bir araçtır. Derleme / lint / test görevlerini otomatik olarak çalıştırmak ve kod değiştiğinde uygulamanızı yeniden yüklemek için harika.

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

Bir dosya değişikliğini takip etmek için kullandığım oneliner bir cevap:

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

İlk tarihin başlangıç ​​zamanı olduğunu biliyorsanız, BF'yi başlatmanız gerekmez.

Bu basit ve taşınabilir. Burada bir betiği kullanarak aynı stratejiye dayalı başka bir cevap var. Ayrıca bir göz atın.

Kullanım: Bunu hata ayıklamak ve takip etmek için kullanıyorum ~/.kde/share/config/plasma-desktop-appletsrc; bilinmeyen bir nedenden dolayı benim kaybediyorum SwitchTabsOnHover=false

Bunu yapmak için bu betiği kullanıyorum. Monitör modunda inotify kullanıyorum

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

Bunu runatwrite.sh olarak kaydedin

Usage: runatwrite.sh myfile.sh

her yazımda myfile.sh dosyasını çalıştıracak.

OS X kullananlar için, değişikliklerin yolunu / dosyasını izlemek ve bu olduğunda bir şey yapmak için bir LaunchAgent kullanabilirsiniz. FYI - LaunchControl kolayca daemons / ajanları yapmak / değiştirmek / kaldırmak için iyi bir uygulama.

( buradan alınmış örnek )

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

Bunun için bir GIST var ve kullanımı oldukça basit

watchfiles <cmd> <paths...>

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

Bu değişiklikleri Googling'te bulan kişiler için belirli dosya, cevap çok basittir (tarafından ilham Gilles'in cevabı ).

Bir şey yapmak istiyorsan sonra belirli bir dosyaya yazılmıştır, işte size:

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

Bunu, örneğin copy_myfile.sh ve koymak .sh içine dosya /etc/init.d/ Başlangıçta çalışması için klasör.

'Fido' aracı bu ihtiyaç için başka bir seçenek olabilir. Görmek https://www.joedog.org/fido-home/

Diğer bazılarının yaptığı gibi, bunu yapmak için hafif bir komut satırı aracı da yazdım. Tamamen belgelenmiştir, test edilmiştir ve modülerdir.

İzle-Do

Kurulum

(Python3 ve pip kullanıyorsanız) kullanarak kurabilirsiniz:

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

kullanım

Çalıştırarak hemen kullanın:

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

Özelliklere genel bakış

• Dosya taşmayı destekler (kullanım -w '*.py' veya -w '**/*.py' )
• Bir dosya değişikliğinde birden çok komut çalıştırın (yalnızca -d tekrar işaretleyin)
• Küreselleşme kullanılıyorsa izlenmesi gereken dosyaların listesini dinamik olarak tutar ( -r Bunu açmak için)
• Bir dosyayı "izlemenin" birden çok yolu:
  • Değiştirme zamanı (varsayılan)
  • Dosya karması
  • Kendinizinkini uygulama için önemsiz (bu ModificationTime gözlemcisi)
• Modüler tasarım. Komutların çalıştırılmasını istiyorsanız, bir dosyaya erişildiğinde, kendi izleyicinizi yazmanız önemsizdir (makinelerin çalıştırılıp çalıştırılmayacağını belirleyen mekanizma).