ගොනුවක් වෙනස් වන සෑම විටම විධානයක් ක්‍රියාත්මක කරන්නේ කෙසේද?

ගොනුවක් වෙනස් වන සෑම විටම විධානයක් ක්‍රියාත්මක කිරීමට මට ඉක්මන් හා සරල ක්‍රමයක් අවශ්‍යයි. මට ඉතා සරල දෙයක් අවශ්‍යයි, මම ටර්මිනලය මත ධාවනය කර එම ගොනුව සමඟ වැඩ අවසන් වූ සෑම විටම එය වසා දමමි.

දැනට, මම මෙය භාවිතා කරමි:

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

විකල්පයක් ලෙස, ඉන්ක්‍රොන් (ගොනුවක් වෙනස් කළ විට සිදුවීම් ලියාපදිංචි කිරීමට ඔබට ඉඩ සලසයි) හෝ fswatch ( ලිනක්ස්ගේ ඉනෝටිෆයි හි එක් එක් ප්‍රභේදයේ ඇනලොග් භාවිතා කරමින් වෙනත් බොහෝ යුනික්ස් ප්‍රභේදවල ද ක්‍රියා කරන මෙවලමක් ) වැනි එකම යටින් පවතින ක්‍රියාකාරිත්වය භාවිතා කරන තවත් මෙවලමක් භාවිතා කරන්න .

entr ( http://entrproject.org/ ) inotify සඳහා වඩාත් මිත්‍රශීලී අතුරු මුහුණතක් සපයයි (තවද * BSD & Mac OS X සඳහා සහය දක්වයි).

එය නැරඹීමට බහු ලිපිගොනු නියම කිරීම ඉතා පහසු කරයි (සීමා කර ඇත්තේ ulimit -n)

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

මා දැනට වෙනස් කරන කේතය සඳහා ඒකක පරීක්ෂණ ක්‍රියාත්මක කිරීම සඳහා මම එය මගේ සම්පූර්ණ ව්‍යාපෘති ප්‍රභව ගසෙහි භාවිතා කර ඇති අතර එය දැනටමත් මගේ කාර්ය ප්‍රවාහයට විශාල රුකුලක් වී තිබේ.

-c(ධාවකයන් අතර තිරය -dඉවත් කරන්න ) සහ (අධීක්ෂණය කරන ලද නාමාවලියකට නව ගොනුවක් එක් කළ විට පිටවීම ) වැනි ධජ ඊටත් වඩා නම්‍යශීලී බවක් එක් කරයි, උදාහරණයක් ලෙස ඔබට කළ හැකිය:

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

2018 මුල් භාගය වන විට එය තවමත් ක්‍රියාකාරී සංවර්ධනයක පවතින අතර එය ඩේබියන් සහ උබුන්ටු ( apt install entr); කතුවරයාගේ ගබඩාවෙන් ගොඩනැගීම ඕනෑම අවස්ථාවක වේදනා රහිත විය.

වෙනස් වූ විට එය හරියටම කිරීමට මම පයිතන් වැඩසටහනක් ලිව්වෙමි .

භාවිතය සරලයි:

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යනු ඇත, සෑම ගොනුවක්ම සහ නාමාවලියක්ම එහි ප්‍රමාණය හා දිනයන් සමඟ ලැයිස්තුගත කරයි, එබැවින් ගොනුවක් වෙනස් වුවහොත් එය මිනිසා පවසන පරිදි විධානයෙන් පිටවිය යුතුය:

-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 ක බෑෂ් පිටපතකි:

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

ඔබගේ PATH හි 'නැවත ධාවනය' ලෙස ගිතුබ් අනුවාදය සුරකින්න, එය භාවිතා කර එය භාවිතා කරන්න:

rerun COMMAND

ඔබගේ වර්තමාන නාමාවලිය තුළ ගොනු පද්ධති වෙනස් කිරීමේ සිදුවීමක් ඇති සෑම අවස්ථාවකම එය COMMAND ධාවනය කරයි (පුනරාවර්තන.)

ඒ සඳහා යමෙකු කැමති විය හැකි දේවල්:

• එය inotify භාවිතා කරයි, එබැවින් ඡන්ද විමසීමට වඩා ප්‍රතිචාර දක්වයි. ඔබ 'සුරකින්න' පහර දෙන සෑම අවස්ථාවකම උප මිලි තත්පර පරීක්ෂණ ක්‍රියාත්මක කිරීම හෝ ග්‍රැෆ්විස් තිත් ගොනු විදහා දැක්වීම සඳහා විශිෂ්ටයි.
• එය ඉතා වේගවත් බැවින්, කාර්ය සාධන හේතූන් මත විශාල උපසිරැසි (node_modules වැනි) නොසලකා හැරීමට ඔබට එය කරදර විය යුතු නැත.
• එය අතිරේක සුපිරි ප්‍රතිචාරාත්මක වේ, මන්ද එය ආරම්භයේදී එය ක්‍රියාත්මක කිරීම වෙනුවට එක් වරක් පමණක් inotifywait ලෙස හඳුන්වන අතර සෑම නැවතීමේ ක්‍රියාවලියකදීම ඔරලෝසු පිහිටුවීමේ මිල අධික පහරක් එල්ල කරයි.
• එය බාෂ්ගේ පේළි 12 ක් පමණි
• එය Bash නිසා, එය ඔබ විසින් සම්මත කරන ලද විධානයන් හරියටම Bash විමසුමේදී ටයිප් කළ ආකාරයටම අර්ථ නිරූපණය කරයි. (ඔබ වෙනත් කවචයක් භාවිතා කරන්නේ නම් මෙය සිසිල් නොවේ.)
• මෙම පිටුවේ ඇති අනෙකුත් බොහෝ inotify විසඳුම් මෙන් නොව, COMMAND ක්‍රියාත්මක වන විට සිදුවන සිදුවීම් නැති නොවේ.
• පළමු සිදුවීමේදී, එය තත්පර 0.15 ක් සඳහා 'මළ කාල පරිච්ඡේදයකට' ඇතුල් වන අතර, අනෙක් සිදුවීම් නොසලකා හරිනු ලැබේ, COMMAND හරියටම එක් වරක් ක්‍රියාත්මක වීමට පෙර. මෙය එසේ වන්නේ බෆරයක් සුරකින විට Vi හෝ Emacs විසින් නිර්මාණය කරන-ලිවීමේ-චලනය වන නර්තනය නිසා ඇති වන සිදුවීම්වල වේගවත් බව නිසා මන්දගාමී පරීක්ෂණ කට්ටලයක් බහු වෙහෙසකාරී utions ාතන සිදු නොවේ. COMMAND ක්‍රියාත්මක වන විට සිදුවන ඕනෑම සිදුවීමක් නොසලකා හරිනු නොලැබේ - ඒවා දෙවන මළ කාල පරිච්ඡේදයක් හා පසුව ක්‍රියාත්මක කිරීමට හේතු වේ.

යමෙකුට අකමැති විය හැකි දේවල්:

• එය inotify භාවිතා කරයි, එබැවින් ලිනක්ස්ලන්ඩ් වලින් පිටත ක්‍රියා නොකරනු ඇත.
• එය inotify භාවිතා කරන හෙයින්, උපරිම පරිශීලක inotify ඔරලෝසු සංඛ්‍යාවට වඩා වැඩි ලිපිගොනු අඩංගු නාමාවලි නැරඹීමට එය බාධා කරයි. පෙරනිමියෙන්, මෙය මා භාවිතා කරන විවිධ යන්ත්‍ර මත 5,000 සිට 8,000 දක්වා සකසා ඇති බව පෙනේ, නමුත් වැඩි කිරීමට පහසුය. Https://unix.stackexchange.com/questions/13751/kernel-inotify-watch-limit-reached බලන්න
• Bash අන්වර්ථයන් අඩංගු විධාන ක්‍රියාත්මක කිරීමට එය අසමත් වේ. මට දිවුරන්න පුළුවන් මේක වැඩ කළා කියලා. ප්‍රතිපත්තිමය වශයෙන්, මෙය බාෂ් වන අතර, කොමාන්ඩ් උපසිරැසියකින් ක්‍රියාත්මක නොකිරීම නිසා, මෙය ක්‍රියාත්මක වනු ඇතැයි මම අපේක්ෂා කරමි. මම අහන්න කැමතියි එය එසේ නොවන්නේ මන්දැයි යමෙකු දන්නේ නම්. මෙම පිටුවේ ඇති වෙනත් බොහෝ විසඳුම් වලට එවැනි විධානයන් ක්‍රියාත්මක කළ නොහැක.
• පුද්ගලිකව මම ප්‍රාර්ථනා කරන්නේ එය ක්‍රියාත්මක වන පර්යන්තයේ යතුරක් එබීමට මට හැකි වූ බවයි. මට මෙය කෙසේ හෝ එකතු කළ හැකිද? සමගාමීව ක්‍රියාත්මක වන 'කියවන අතරතුර -n1' ලූපය ක්‍රියාත්මක වන ලෙසද හඳුන්වයි?
• මේ මොහොතේ මම එය කේතනය කර ඇත්තේ පර්යන්තය ඉවත් කර ක්‍රියාත්මක කරන ලද COMMAND මුද්‍රණය කිරීමට ය. සමහර අය මේ වගේ දේවල් අක්‍රිය කිරීම සඳහා විධාන රේඛා කොඩි එක් කිරීමට කැමති විය හැකිය. නමුත් මෙය ප්‍රමාණය හා සංකීර්ණත්වය බොහෝ ගුණයකින් වැඩි කරයි.

මෙය @ cychoi's anwer හි ශෝධනයකි.

මෙන්න සරල කවචයක් බෝර්න් ෂෙල් පිටපත:

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 මත ක්‍රියා කරයි. මට සිතිය හැකි එකම අතේ ගෙන යා හැකි ගැටලුව වන්නේ වෙනත් යුනික්ස් වලට mktemp (1) විධානය නොමැති නම්, නමුත් එවැනි අවස්ථාවක ඔබට තාවකාලික ගොනු නාමය තදින් කේත කළ හැකිය.

Incron දෙස බලන්න . එය ක්‍රෝන් වලට සමාන ය, නමුත් කාලය වෙනුවට inotify සිදුවීම් භාවිතා කරයි.

ඔබ නෝඩ්මන් ස්ථාපනය කර ඇත්නම්, ඔබට මෙය කළ හැකිය:

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"

NodeJs සමඟ තවත් විසඳුමක්, fsmonitor :

1. ස්ථාපනය කරන්න

   sudo npm install -g fsmonitor
   

2. විධාන රේඛාවෙන් (උදාහරණයක් ලෙස, එක් ලොග් ගොනුවක් වෙනස් වුවහොත් ලොග් අධීක්ෂණය සහ "සිල්ලර")

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

විශේෂයෙන් මෙම ප්ලගිනය සමඟ ආරක්ෂකයා දෙස බලන්න:

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

ඔබේ ව්‍යාපෘතියේ නාමාවලියෙහි ඇති ඕනෑම රටා ගණනක් බැලීමට ඔබට එය සැකසිය හැකි අතර වෙනස්කම් සිදු වූ විට විධාන ක්‍රියාත්මක කරන්න. ඔබ මුලින් කිරීමට උත්සාහ කරන දේ සඳහා ප්ලගිනයක් තිබීම හොඳ අවස්ථාවක්.

ලිනක්ස් යටතේ:

man watch

watch -n 2 your_command_to_run

සෑම තත්පර 2 කට වරක් විධානය ක්‍රියාත්මක කරයි.

ඔබගේ විධානය ක්‍රියාත්මක වීමට තත්පර 2 කට වඩා ගත වුවහොත්, එය නැවත සිදු කිරීමට පෙර එය අවසන් වන තුරු ඔරලෝසුව රැඳී සිටිනු ඇත.

වොච්ඩෝග් යනු පයිතන් ව්‍යාපෘතියක් වන අතර එය ඔබ සොයන දේ පමණක් විය හැකිය:

සහාය දක්වන වේදිකා

• ලිනක්ස් 2.6 (inotify)
• මැක් ඕඑස් එක්ස් (FSEvents, kqueue)
• FreeBSD / BSD (kqueue)
• වින්ඩෝස් (I / O සම්පුර්ණ කරන ලද වරායන් සහිත ReadDirectoryChangesW; ReadDirectoryChangesW සේවක නූල්)
• ඕඑස්-ස්වාධීන (ඩිරෙක්ටරි ස්නැප්ෂොට් සඳහා තැටිය ඡන්දය දීම සහ වරින් වර සංසන්දනය කිරීම; මන්දගාමී සහ නිර්දේශ නොකරයි)

ඒ සඳහා විධාන රේඛා එතුමක් ලියා ඇත watchdog_exec:

උදාහරණ ධාවනය වේ

වත්මන් ඩිරෙක්ටරියේ ලිපිගොනු සහ ෆෝල්ඩර සම්බන්ධ වන fs සිද්ධියේදී, echo $src $dstවිධානය ක්‍රියාත්මක කරන්න, එය fs සිද්ධිය වෙනස් නොකළහොත් python $srcවිධානය ක්‍රියාත්මක කරන්න.

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

කෙටි තර්ක භාවිතා කිරීම, සහ සිදුවීම් " ප්‍රධාන .py" සම්බන්ධ වූ විට පමණක් ක්‍රියාත්මක කිරීමට සීමා කිරීම :

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

සංස්කරණය කරන්න: වොච්ඩෝග් වෙත නිල සීඑල්අයි නමින් ඇමතුමක් ලැබී ඇති watchmedoබැවින් එයද පරීක්ෂා කරන්න.

ඔබේ වැඩසටහන මඟින් යම් ආකාරයක ලොග් / ප්‍රතිදානයක් ජනනය කරන්නේ නම්, ඔබේ ස්ක්‍රිප්ට් එක මත රඳා පවතින එම ලොග් / ප්‍රතිදානය සඳහා රීතියක් සහිත මේක්ෆයිල් එකක් සාදාගත හැකිය.

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

විකල්පයක් ලෙස, ඔබට ව්‍යාජ ඉලක්කයක් නිර්මාණය කළ හැකි අතර ඒ සඳහා රීතිය ඔබේ ස්ක්‍රිප්ට් අමතා ව්‍යාජ ඉලක්කය ස්පර්ශ කරන්න (තවමත් ඔබගේ ස්ක්‍රිප්ට් මත පදනම්ව).

swarminglogic ලියූ watchfile.sh නමින් තිර රචනය , ද එය GitHub දැන් ලොකු තැනක් ලෙස ලබා ගත .

ගිලෙස්ගේ පිළිතුර මත වැඩි දියුණු විය .

මෙම අනුවාදය inotifywaitඑක් වරක් ක්‍රියාත්මක වන අතර modifyඉන් පසුව සිදුවීම් සඳහා අධීක්ෂණය කරයි (.eg :) . එවැනි සෑම සිදුවීමක්ම නැවත ක්‍රියාත්මක කිරීම අවශ්‍ය 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විධානයට දෝෂ තිබේ (මිනිසා බලන්න): එය ප්‍රතික්‍රියා කරන්නේ -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>

මට මේ සඳහා GIST එකක් ඇති අතර භාවිතය ඉතා සරල ය

watchfiles <cmd> <paths...>

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

තවත් කිහිප දෙනෙක් කර ඇති පරිදි, මම මෙය කිරීමට සැහැල්ලු විධාන රේඛා මෙවලමක් ද ලියා ඇත්තෙමි. එය සම්පුර්ණයෙන්ම ලේඛනගත කර, පරීක්ෂා කර මොඩියුලය.

වොච්-කරන්න

ස්ථාපනය

ඔබට මෙය ස්ථාපනය කළ හැකිය (ඔබට 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මෙය සක්‍රිය කිරීමට)
• ගොනුවක් "නැරඹීම" සඳහා විවිධ ක්‍රම:
  • වෙනස් කිරීමේ කාලය (පෙරනිමි)
  • ගොනු හැෂ්
  • ඔබේම දෑ ක්‍රියාත්මක කිරීමට සුළු දෙයක් (මෙය මෝඩිෆයිම් ටයිම් මුරකරු)
• මොඩියුලර් නිර්මාණය. ඔබට විධාන ක්‍රියාත්මක කිරීමට අවශ්‍ය නම්, ගොනුවකට ප්‍රවේශ වූ විට, ඔබේම මුරකරු ලිවීම ඉතා සුළු කාරණයකි (ක්‍රියා කරන්නන් ක්‍රියාත්මක කළ යුතුද යන්න තීරණය කරන යාන්ත්‍රණය).

හරියටම මෙය සිදු කිරීම සඳහා මම පයිතන් වැඩසටහනක් ලිව්වෙමි rerun.

යාවත්කාලීන කිරීම: මෙම පිළිතුර පයිතන් පිටපතක් වන අතර එය වෙනස්කම් සඳහා ඡන්දය ප්‍රකාශ කරයි, එය සමහර තත්වයන් සඳහා ප්‍රයෝජනවත් වේ. Inotify භාවිතා කරන ලිනක්ස් පමණක් බාෂ් ස්ක්‍රිප්ට් සඳහා, මගේ අනෙක් පිළිතුර බලන්න, 'නැවත ධාවනය 2' සඳහා මෙම පිටුව සොයන්න.

Python2 හෝ Python3 සඳහා ස්ථාපනය කරන්න:

pip install --user rerun

භාවිතය ඉතා සරල ය:

rerun "COMMAND"

විධානය අපේක්ෂා කරන්නේ තනි ආගයක් ලෙස මිස අවකාශයෙන් වෙන් වූ ආරුක්කු අනුක්‍රමයක් ලෙස නොවේ. එබැවින් පෙන්වා ඇති පරිදි එය උපුටා දක්වන්න, එමඟින් ඔබට එකතු කිරීමට සිදුවන අමතර ගැලවීම අඩු කරයි. ඔබ විධාන රේඛාවේ ටයිප් කළ ආකාරයටම විධානය ටයිප් කරන්න, නමුත් එය උපුටා දැක්වීම් වලින් වට කර ඇත.

පෙරනිමියෙන් එය වත්මන් ඩිරෙක්ටරියේ හෝ ඊට යටින් ඇති සියලුම ලිපිගොනු නරඹයි, දන්නා ප්‍රභව පාලන ඩර්ස්, .git, .svn, වැනි දේ මඟ හැරේ.

විකල්ප ධජ වලට '-i NAME' ඇතුළත් වන අතර එය නම් කරන ලද ලිපිගොනු හෝ නාමාවලි වල වෙනස්කම් නොසලකා හරියි. මෙය කිහිප වතාවක් ලබා දිය හැකිය.

එය පයිතන් ස්ක්‍රිප්ට් එකක් බැවින්, එය විධානය උප ක්‍රියාවලියක් ලෙස ක්‍රියාත්මක කළ යුතු අතර, පරිශීලකයාගේ වත්මන් කවචයේ නව අවස්ථාවක් 'කොමන්ඩ්' අර්ථ නිරූපණය කිරීමට සහ සත්‍ය වශයෙන්ම ක්‍රියාත්මක විය යුතු ක්‍රියාවලිය තීරණය කිරීමට අපි භාවිතා කරමු. කෙසේ වෙතත්, ඔබේ විධානයට ෂෙල් අන්වර්ථයන් සහ .bashrc හි අර්ථ දක්වා ඇති දේ තිබේ නම්, මේවා උප කුලකය මඟින් පටවනු නොලැබේ. මෙය නිවැරදි කිරීම සඳහා, ඔබට නැවත ක්‍රියාත්මක කිරීමට '-I' ධජයක් ලබා දිය හැකිය, අන්තර්ක්‍රියාකාරී (හෝ 'පිවිසුම්') උප-ෂෙල් භාවිතා කරන්න. සාමාන්‍ය කවචයක් ආරම්භ කිරීමට වඩා මෙය මන්දගාමී හා දෝෂ සහිත වේ, එයට හේතුව ඔබේ .bashrc ප්‍රභවයයි.

මම එය පයිතන් 3 සමඟ භාවිතා කරමි, නමුත් අවසන් වරට මා නැවත පරීක්ෂා කළේ තවමත් පයිතන් 2 සමඟ වැඩ කර ඇති බවයි.

ද්විත්ව දාර කඩුව යනු එය inotify වෙනුවට ඡන්දය භාවිතා කිරීමයි. උඩු යටිකුරු කිරීමේදී, එයින් අදහස් වන්නේ එය සෑම මෙහෙයුම් පද්ධතියකම ක්‍රියාත්මක වන බවයි. ප්ලස්, මෙහි දක්වා ඇති වෙනත් විසඳුම් වලට වඩා හොඳය, ලබා දී ඇති විධානය ගොනු පද්ධති වෙනස්වීම් සමූහයක් සඳහා එක් වරක් පමණක් නොව, වෙනස් කරන ලද ගොනුවකට එක් වරක් පමණක් නොව, ඕනෑම ගොනුවක් නැවත වෙනස් වුවහොත් දෙවන වරටත් විධානය ක්‍රියාත්මක කරයි. විධානය ක්‍රියාත්මක වන අතරතුර.

අවාසිය නම්, ඡන්දය දීමෙන් තත්පර 0.0 සිට 1.0 දක්වා ප්‍රමාදයක් ඇති අතර ඇත්ත වශයෙන්ම අතිශය විශාල නාමාවලි නිරීක්ෂණය කිරීම මන්දගාමී වේ. එසේ පැවසීමෙන් පසු, ඔබේ virtualenv සහ node_modules වැනි විශාල දේවල් නොසලකා හැරීමට ඔබ '-i' භාවිතා කරන තාක් කල් මෙය සැලකිය යුතු තරම් විශාල ව්‍යාපෘතියක් මට හමු වී නොමැත.

හ්ම්ම්. rerunවසර ගණනාවක් තිස්සේ මට අත්‍යවශ්‍යයි - මම මූලික වශයෙන් සෑම දිනකම පැය අටක් පරීක්ෂණ ක්‍රියාත්මක කිරීම, තිත් ලිපිගොනු සංස්කරණය කරන විට ඒවා නැවත සකස් කිරීම යනාදිය සඳහා භාවිතා කරමි. නමුත් දැන් මම මෙහි ටයිප් කිරීමට පැමිණ සිටිමි, මට විසඳුමකට මාරු විය යුතු බව පැහැදිලිය එය inotify භාවිතා කරයි (මම තවදුරටත් වින්ඩෝස් හෝ ඕඑස්එක්ස් භාවිතා නොකරමි.) එය බාෂ් හි ලියා ඇත (එබැවින් එය අතිරේක විකාරයකින් තොරව අන්වර්ථයන් සමඟ ක්‍රියා කරයි.)

විශේෂිත ගොනුවක වෙනස්කම් සඳහා ගූග්ලිං විසින් මෙය සොයා ගන්නා පුද්ගලයින් සඳහා , පිළිතුර වඩාත් සරල ය ( ගිලෙස්ගේ පිළිතුරෙන් දේවානුභාවයෙන් ).

විශේෂිත ගොනුවක් ලිවීමෙන් පසුව ඔබට යමක් කිරීමට අවශ්‍ය නම් , මෙන්න කෙසේද:

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/එය ආරම්භක මත ධාවනය කිරීමට ෆෝල්ඩරය.