Folyamatosan frissülő fáhl vizsgálata AWK-val?

a tail -f akarmifile| awk miért nem awk megoldás?

Hát szerintem meg egyszerűbb dolog ha mondjuk csak egy mintát és egy risztást kell beállítanod, vagy egy program futtatását egy konfigurációban és semmi mással nem törődni.
Ha változik a bement, vagy a kimenet alakul át, semmit nem kell csinálnod, mint az adott konfigban a mintát átírni. De változhat a reagálás mikéntje is. Én mondjuk az ilyenek helyett:

futtasd parancs | awk > nézem két szép szememmel...jajj le kell futtatnom program > futtat parancs > nézem az awk-s parancssoromat > jajj most más a kimenet, most másik parancsot kell lefuttatnom, hol is van, ja a /könyvtár/másik/script....hú ez megvolt...francba más a minta megint....másik script futtatása.....blablabla

jobban szeretem

ha [regexp minta] futtasd [parancs]
de ha [regexp minta] futtasd [parancs] ....

ezek után ha akarom nézem, ha akarom nemnézem a két szép szememmel.

Azt feltételezem, hogy sorokat kapsz, és nem kell minden új karakternél lefutni a scriptednek. Két változatot küldök. Bár elsőre hasonlónak tűnnek, de van különbség: amikor a "read"-et használjuk és ráirányítjuk a kimenetet, akkor minden sornál lefut a scripted, ha a "head"-et használjuk, akkor előfordulhat, hogy egyszerre jön 3 sor, és csak egyszer fut le a scripted. Az előző biztonságosabb, de te tudod, hogy neked melyik kell. (Nekem kellett a "head"-es megoldás webcam képeknél, ha túl gyorsan jöttek a képek, akkor nem volt gond, ha párat nem jelenítettem meg, az viszont gond lett volna, ha fél napos lemaradásban lett volna.)

Kezdem azzal a megoldással, amit ajánlok.

parancs:

szimulacio | readbyline.sh

readbyline.sh:
#!/bin/bash
rm -f temp.txt
while read; do
        echo "readbyline.sh: read line: "$REPLY
        echo "Calling your script"
        echo $REPLY >> temp.txt
        ./your_script.sh temp.txt
done

A your_script.sh minden új sorra meghívódik, tehát a temp.txt minden hívásnál eggyel több sort fog tartalmazni.

A "head"-es megoldás nem túl elegáns, mert nem minden sornál fut le, de azért nézzük. A script:

head.sh:
#!/bin/bash
while true; do
        line=`head -n 1`
        echo "Calling your script, which might use output.txt"
       ./script.sh
done

Parancsok:

mkfifo output.pipe
szimulacio | tee output.pipe > output.txt

Egy másik terminálban:

./head.sh

Ezzel kész is vagyunk. Ez utóbbi esetben is használható az előző script, ha

./head

helyett ezt adod ki:

cat output.pipe | ./readbyline.sh

Remélem segített. Az mkfifoval létrehozott pipe-ot leginkább akkor találtam hasznosnak, ha a programod mindenképp fájlba akar írni (pl. mert C-ben írták, nincs kedved belenyúlni). Egyébként az átirányítgatással menni szokott minden.

A tail -f a fájl végét, ahogy abba bekerül valami tolja a kimenetére, ha csőbe tolod, akkor az utána következő program bemenetén szépen megjelennek a fájlba írt sorok. Mind, egymás után.

Miért kéne csak az utolsó tíz sor? Ha az a feladat, hogy a legutolsó 10 sor alapján csinálj valamit, akkor az awk pont nem jó választás szerintem, bár a NR/10-zel lehet játszadozni, ez is igaz...

A tail -n 0 -f filenev csak a parancs futtatasa ota bekerult sorokat adja vissza.

bash$ man 1 tail
...
-n, --lines=N
        output the last N lines, instead of the last 10; or use +N to
        output lines starting with the Nth
...


akkor rögtön továbbküld 1-et

próbáld ki, de felhívnám a figyelmedet arra, hogy a legtöbb program alapból az stdio.h függvényeit használja, amik pufferelve írnak.
azaz amíg a puffer meg nem telik, vagy a program explicite nem kéri a puffer ürítését valamilyen módon (pl. a program futásának a végén a close() ezt megcsinálja), addig a kimenetre kerülő dolgok várakoznak szépen a memóriában, és addig a pipe-ban a következő láncszem nem is kapja meg.

namost a legtöbb standard unix utility nem rendelkezik olyan opcióval, amivel ezt a pufferelést ki lehetne kapcsolni, vagy akár csak rá lehetne venni a programot, hogy adott időközönként mindenképpen ürítse a kimeneti puffert.