Bagaimana cara mengeksekusi perintah setiap kali file berubah?

Saya ingin cara cepat dan sederhana untuk mengeksekusi perintah setiap kali file berubah. Saya menginginkan sesuatu yang sangat sederhana, sesuatu yang akan saya tinggalkan berjalan di terminal dan menutupnya setiap kali saya selesai bekerja dengan file itu.

Saat ini, saya menggunakan ini:

while read; do ./myfile.py ; done

Dan kemudian saya harus pergi ke terminal itu dan tekan Enter, setiap kali saya menyimpan file itu di editor saya. Yang saya inginkan adalah sesuatu seperti ini:

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

Atau solusi lain semudah itu.

BTW: Saya menggunakan Vim, dan saya tahu saya bisa menambahkan perintah otomatis untuk menjalankan sesuatu di BufWrite, tapi ini bukan solusi yang saya inginkan sekarang.

Pembaruan: Saya menginginkan sesuatu yang sederhana, jika mungkin dibuang. Terlebih lagi, saya ingin sesuatu berjalan di terminal karena saya ingin melihat output program (saya ingin melihat pesan kesalahan).

Tentang jawabannya: Terima kasih atas semua jawaban Anda! Semuanya sangat baik, dan masing-masing mengambil pendekatan yang sangat berbeda dari yang lain. Karena saya hanya perlu menerima satu, saya menerima yang sudah saya gunakan (itu sederhana, cepat dan mudah diingat), meskipun saya tahu itu bukan yang paling elegan.

Sederhana, menggunakan inotifywait (instal inotify-toolspaket distribusi Anda ):

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

atau

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

Cuplikan pertama lebih sederhana, tetapi memiliki kelemahan signifikan: ia akan kehilangan perubahan yang dilakukan saat inotifywaittidak berjalan (khususnya saat myfilesedang berjalan). Cuplikan kedua tidak memiliki cacat ini. Namun, berhati-hatilah karena ini mengasumsikan bahwa nama file tidak mengandung spasi. Jika itu masalah, gunakan --formatopsi untuk mengubah output untuk tidak menyertakan nama file:

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

Either way, ada batasan: jika beberapa program mengganti myfile.pydengan file yang berbeda, daripada menulis ke yang sudah ada myfile, inotifywaitakan mati. Banyak editor bekerja seperti itu.

Untuk mengatasi batasan ini, gunakan inotifywaitpada direktori:

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

Sebagai alternatif, gunakan alat lain yang menggunakan fungsi dasar yang sama, seperti incron (memungkinkan Anda mendaftarkan acara saat file dimodifikasi) atau fswatch (alat yang juga berfungsi pada banyak varian Unix lainnya, menggunakan analog masing-masing varian dari Linux yang tidak diotifikasi).

entr ( http://entrproject.org/ ) menyediakan antarmuka yang lebih ramah untuk memberitahukan (dan juga mendukung * BSD & Mac OS X).

Itu membuatnya sangat mudah untuk menentukan beberapa file untuk ditonton (dibatasi hanya oleh ulimit -n), menghilangkan kerumitan berurusan dengan file yang diganti, dan membutuhkan sintaksis kurang bash:

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

Saya telah menggunakannya di seluruh pohon sumber proyek saya untuk menjalankan tes unit untuk kode yang saya modifikasi saat ini, dan itu sudah merupakan dorongan besar untuk alur kerja saya.

Panji suka -c(hapus layar di antara menjalankan) dan -d(keluar saat file baru ditambahkan ke direktori yang dipantau) menambah lebih banyak fleksibilitas, misalnya yang dapat Anda lakukan:

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

Pada awal 2018 masih dalam pengembangan aktif dan dapat ditemukan di Debian & Ubuntu ( apt install entr); membangun dari repo penulis itu bebas rasa sakit dalam hal apapun.

Saya menulis sebuah program Python untuk melakukan hal ini dengan tepat yang disebut ketika-diubah .

Penggunaannya sederhana:

when-changed FILE COMMAND...

Atau untuk menonton banyak file:

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

FILEbisa berupa direktori. Tonton secara rekursif dengan -r. Gunakan %funtuk meneruskan nama file ke perintah.

Bagaimana dengan skrip ini? Ia menggunakan statperintah untuk mendapatkan waktu akses file dan menjalankan perintah setiap kali ada perubahan dalam waktu akses (setiap kali file diakses).

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

Solusi menggunakan Vim:

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

Tapi saya tidak ingin solusi ini karena agak menjengkelkan untuk mengetik, agak sulit untuk mengingat apa yang harus diketik, dan agak sulit untuk membatalkan efeknya (perlu dijalankan :au! BufWritePost myfile.py). Selain itu, solusi ini memblokir Vim sampai perintah selesai dieksekusi.

Saya telah menambahkan solusi ini di sini hanya untuk kelengkapan, karena dapat membantu orang lain.

Untuk menampilkan output program (dan benar-benar mengganggu aliran pengeditan Anda, karena output akan menulis di editor Anda selama beberapa detik, sampai Anda menekan Enter), hapus :silentperintah.

Jika Anda telah npmmenginstal, nodemonmungkin cara termudah untuk memulai, terutama pada OS X, yang tampaknya tidak memiliki alat inotify. Ini mendukung menjalankan perintah ketika folder berubah.

Bagi mereka yang tidak dapat menginstal inotify-toolsseperti saya, ini harus bermanfaat:

watch -d -t -g ls -lR

Perintah ini akan keluar ketika output berubah, ls -lRakan mencantumkan setiap file dan direktori dengan ukuran dan tanggalnya, jadi jika file diubah itu harus keluar dari perintah, seperti yang dikatakan manusia:

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

Saya tahu jawaban ini mungkin tidak dibaca oleh siapa pun, tetapi saya berharap seseorang akan mencapainya.

Contoh baris perintah:

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

Buka terminal lain:

~ $ echo "testing" > /tmp/test

Sekarang terminal pertama akan di-output 1,2,3

Contoh skrip sederhana:

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

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

rerun2( on github ) adalah skrip Bash 10-baris dari formulir:

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

Simpan versi github sebagai 'jalankan kembali' di PATH Anda, dan panggil menggunakan:

rerun COMMAND

Ini menjalankan PERINTAH setiap kali ada acara memodifikasi sistem file dalam direktori Anda saat ini (rekursif.)

Hal-hal yang mungkin orang sukai tentang itu:

• Ini menggunakan inotify, jadi lebih responsif daripada polling. Luar biasa untuk menjalankan tes unit sub-milidetik, atau rendering file graphviz dot, setiap kali Anda menekan 'save'.
• Karena begitu cepat, Anda tidak perlu repot-repot mengatakannya untuk mengabaikan subdir besar (seperti node_modules) hanya karena alasan kinerja.
• Ini ekstra super responsif, karena hanya memanggil tidak menunggu satu kali, pada startup, bukan menjalankannya, dan menimbulkan hit mahal membangun jam tangan, pada setiap iterasi.
• Itu hanya 12 baris Bash
• Karena itu Bash, ia mengartikan perintah yang Anda berikan persis seperti jika Anda mengetikkannya di prompt Bash. (Agaknya ini kurang keren jika Anda menggunakan shell lain.)
• Itu tidak kehilangan peristiwa yang terjadi ketika COMMAND sedang mengeksekusi, tidak seperti kebanyakan dari solusi tidak sah lainnya di halaman ini.
• Pada acara pertama, ia memasuki 'periode mati' selama 0,15 detik, di mana peristiwa lain diabaikan, sebelum PERINTAH dijalankan tepat sekali. Ini dimaksudkan agar berbagai peristiwa yang disebabkan oleh tarian buat-tulis-gerak yang dilakukan Vi atau Emacs saat menyimpan buffer tidak menyebabkan banyak eksekusi yang melelahkan dari test suite yang mungkin berjalan lambat. Peristiwa apa pun yang terjadi saat COMMAND sedang dieksekusi tidak diabaikan - mereka akan menyebabkan periode mati kedua dan eksekusi berikutnya.

Hal-hal yang orang mungkin tidak suka tentang itu:

• Ini menggunakan inotify, jadi tidak akan berfungsi di luar Linuxland.
• Karena ia menggunakan inotify, ia akan berusaha untuk mencoba menonton direktori yang berisi lebih banyak file daripada jumlah maksimum pengguna yang memberikan inotify jam tangan. Secara default, ini tampaknya diatur sekitar 5.000 hingga 8.000 pada mesin yang berbeda yang saya gunakan, tetapi mudah untuk ditingkatkan. Lihat https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached
• Gagal menjalankan perintah yang mengandung alias Bash. Saya bersumpah bahwa ini dulu berhasil. Pada prinsipnya, karena ini Bash, tidak mengeksekusi PERINTAH dalam subkulit, saya berharap ini berfungsi. Saya ingin sekali mendengar. Jika ada yang tahu mengapa tidak. Banyak solusi lain di halaman ini yang tidak dapat menjalankan perintah seperti itu juga.
• Secara pribadi saya berharap saya dapat menekan tombol di terminal yang sedang berjalan untuk secara manual menyebabkan eksekusi ekstra PERINTAH. Bisakah saya menambahkan ini entah bagaimana, sederhana? Secara bersamaan menjalankan 'while read -n1' loop yang juga memanggil eksekusi?
• Saat ini saya telah mengkodekannya untuk menghapus terminal dan mencetak PERINTAH yang dieksekusi pada setiap iterasi. Beberapa orang mungkin ingin menambahkan bendera baris perintah untuk mematikan hal-hal seperti ini, dll. Tetapi ini akan meningkatkan ukuran dan kompleksitas berlipat-lipat.

Ini adalah penyempurnaan dari jawaban @ cychoi.

Berikut ini skrip shell Bourne shell sederhana yang:

1. Membawa dua argumen: file yang akan dimonitor dan perintah (dengan argumen, jika perlu)
2. Menyalin file yang Anda pantau ke direktori / tmp
3. Memeriksa setiap dua detik untuk melihat apakah file yang Anda pantau lebih baru dari salinan
4. Jika lebih baru itu menimpa salinan dengan yang lebih baru dan menjalankan perintah

5. Bersihkan setelahnya sendiri saat Anda menekan Rtr-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  
   

Ini berfungsi pada FreeBSD. Satu-satunya masalah portabilitas yang dapat saya pikirkan adalah jika beberapa Unix lain tidak memiliki perintah mktemp (1), tetapi dalam hal ini Anda hanya dapat membuat kode nama file temp yang sulit.

Lihatlah incron . Ini mirip dengan cron, tetapi menggunakan acara yang tidak resmi alih-alih waktu.

Solusi lain dengan NodeJs, fsmonitor :

1. Pasang

   sudo npm install -g fsmonitor
   

2. Dari baris perintah (misalnya, monitor log dan "eceran" jika satu file log berubah)

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

Lihatlah ke Penjaga, khususnya dengan plugin ini:

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

Anda dapat mengaturnya untuk menonton sejumlah pola di direktori proyek Anda, dan menjalankan perintah ketika perubahan terjadi. Kesempatan baik bahkan bahwa ada plugin yang tersedia untuk itu apa yang Anda coba lakukan di tempat pertama.

jika Anda telah menginstal nodemon , maka Anda dapat melakukan ini:

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

Dalam kasus saya, saya mengedit html secara lokal dan mengirimkannya ke server jarak jauh saya ketika file berubah.

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

Di bawah Linux:

man watch

watch -n 2 your_command_to_run

Akan menjalankan perintah setiap 2 detik.

Jika perintah Anda membutuhkan lebih dari 2 detik untuk dijalankan, jam akan menunggu sampai selesai sebelum melakukannya lagi.

Watchdog adalah proyek Python, dan mungkin hanya apa yang Anda cari:

Platform yang didukung

• Linux 2.6 (tidak resmi)
• Mac OS X (FSEvents, kqueue)
• FreeBSD / BSD (kqueue)
• Windows (ReadDirectoryChangesW dengan port penyelesaian I / O; thread pekerja ReadDirectoryChangesW)
• OS-independent (polling disk untuk snapshot direktori dan membandingkannya secara berkala; lambat dan tidak disarankan)

Baru saja menulis pembungkus baris perintah untuk itu watchdog_exec:

Contoh berjalan

Pada acara fs yang melibatkan file dan folder dalam direktori saat ini, jalankan echo $src $dstperintah, kecuali jika acara fs diubah, kemudian jalankan python $srcperintah.

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

Menggunakan argumen pendek, dan membatasi untuk hanya mengeksekusi ketika acara melibatkan " main .py":

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

EDIT: Baru saja ditemukan Watchdog memiliki CLI resmi yang dipanggil watchmedo, jadi periksa juga.

Jika program Anda menghasilkan semacam log / output, Anda dapat membuat Makefile dengan aturan untuk log / output yang tergantung pada skrip Anda dan melakukan sesuatu seperti

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

Sebagai alternatif, Anda dapat membuat target palsu dan memiliki aturan untuk itu baik memanggil skrip Anda dan menyentuh target palsu (sementara masih tergantung pada skrip Anda).

swarminglogic menulis sebuah skrip yang disebut watchfile.sh , juga tersedia sebagai GitHub Gist .

Memperbaiki jawaban Gilles .

Versi ini berjalan inotifywaitsekali dan memonitor acara (.eg:) modifysesudahnya. Tersebut yang inotifywait tidak perlu dieksekusi kembali pada setiap peristiwa yang ditemui.

Cepat dan cepat! _{(bahkan ketika memonitor direktori besar secara rekursif)}

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

Sedikit lagi di sisi pemrograman, tetapi Anda ingin sesuatu seperti tidak masuk akal . Ada banyak implementasi dalam banyak bahasa, seperti jnotify dan pyinotify .

Pustaka ini memungkinkan Anda untuk memantau file tunggal atau seluruh direktori, dan mengembalikan peristiwa ketika suatu tindakan ditemukan. Informasi yang dikembalikan mencakup nama file, tindakan (buat, ubah, ganti nama, hapus) dan jalur file, di antara informasi bermanfaat lainnya.

Bagi Anda yang mencari solusi FreeBSD, berikut adalah portnya:

/usr/ports/sysutils/wait_on

Saya suka kesederhanaan while inotifywait ...; do ...; donenamun memiliki dua masalah:

• Perubahan file yang terjadi selama do ...;akan terlewatkan
• Lambat saat digunakan dalam mode rekursif

Karenanya saya membuat skrip pembantu yang menggunakan inotifywait tanpa batasan-batasan itu: inotifyexec

Saya sarankan Anda meletakkan skrip ini di jalur Anda, seperti di ~/bin/. Penggunaan dijelaskan dengan hanya menjalankan perintah.

Contoh: inotifyexec "echo test" -r .

Solusi Sebastian yang ditingkatkan dengan watchperintah:

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

Contoh panggilan:

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

Berhasil tetapi hati-hati: watchperintah memiliki bug yang diketahui (lihat man): ia bereaksi terhadap perubahan hanya di VISIBLE di bagian terminal -g CMDoutput.

Anda dapat mencoba refleks .

Refleks adalah alat kecil untuk menonton direktori dan menjalankan kembali perintah ketika file tertentu berubah. Ini bagus untuk menjalankan tugas kompilasi / serat / pengujian secara otomatis dan untuk memuat ulang aplikasi Anda ketika kode berubah.

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

Jawaban oneliner yang saya gunakan untuk melacak perubahan file:

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

Anda tidak perlu menginisialisasi BF jika Anda tahu bahwa kencan pertama adalah waktu mulai.

Ini sederhana dan portabel. Ada jawaban lain berdasarkan strategi yang sama menggunakan skrip di sini. Lihatlah juga.

Penggunaan: Saya menggunakan ini untuk men-debug dan mengawasi ~/.kde/share/config/plasma-desktop-appletsrc; bahwa untuk beberapa alasan yang tidak diketahui terus kehilangan sayaSwitchTabsOnHover=false

Saya menggunakan skrip ini untuk melakukannya. Saya menggunakan inotify dalam mode 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

Simpan ini sebagai runatwrite.sh

Usage: runatwrite.sh myfile.sh

itu akan menjalankan myfile.sh di setiap tulisan.

Bagi mereka yang menggunakan OS X, Anda dapat menggunakan LaunchAgent untuk menonton path / file untuk perubahan dan melakukan sesuatu ketika itu terjadi. FYI - LaunchControl adalah aplikasi bagus untuk membuat / memodifikasi / menghapus daemon / agen dengan mudah.

( contoh diambil dari sini )

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

Saya punya GIST untuk ini dan penggunaannya cukup sederhana

watchfiles <cmd> <paths...>

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

Untuk orang-orang yang menemukan ini dengan Googling untuk perubahan pada file tertentu , jawabannya jauh lebih sederhana (terinspirasi oleh jawaban Gilles ).

Jika Anda ingin melakukan sesuatu setelah file tertentu ditulis, berikut caranya:

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

Simpan ini sebagai, misalnya, copy_myfile.shdan masukkan .shfile ke /etc/init.d/folder untuk menjalankannya saat startup.

Alat 'fido' mungkin merupakan pilihan lain untuk kebutuhan ini. Lihat https://www.joedog.org/fido-home/

Seperti yang telah dilakukan beberapa orang lainnya, saya juga telah menulis alat baris perintah yang ringan untuk melakukan ini. Ini sepenuhnya didokumentasikan, diuji, dan modular.

Watch-Do

Instalasi

Anda dapat menginstalnya (jika Anda memiliki Python3 dan pip) menggunakan:

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

Pemakaian

Gunakan langsung dengan menjalankan:

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

Ikhtisar Fitur

• Mendukung penggumpalan file (gunakan -w '*.py'atau-w '**/*.py' )
• Jalankan beberapa perintah pada perubahan file (cukup tentukan -d bendera lagi)
• Secara dinamis mengelola daftar file yang harus diperhatikan jika globbing digunakan (-r untuk mengaktifkannya)
• Berbagai cara untuk "menonton" file:
  • Waktu modifikasi (standar)
  • Hash file
  • Sepele untuk mengimplementasikan Anda sendiri (ini adalah pengamat ModificationTime )
• Desain modular. Jika Anda ingin menjalankan perintah, ketika file diakses, sepele untuk menulis pengamat Anda sendiri (mekanisme yang menentukan apakah pelakunya harus dijalankan).