comment bip sur l'événement tail -f

Je veux que mon PC émette un bip système à chaque événement de queue

J'ai la commande suivante

tail -f development.log | grep "something rare"

Existe-t-il un moyen simple de le canaliser vers quelque chose qui émet un bip? comme

tail -f development.log | grep "something rare" | beep

si oui, la sortie grep sera-t-elle toujours affichée?

Définissez simplement ce beepqui suit:

beep() { read a || exit; printf "$a\007\n"; beep; }

Ensuite, vous pouvez utiliser votre commande:

tail -f development.log | grep "something rare" | beep

L'écran GNU a une fonction intégrée pour émettre un bip lorsqu'une fenêtre donnée change: voir la section pertinente de la page de manuel .

Résumé du titre:

$ screen
$ tail -f yourfile.log    # inside the screen session
<C-a> M    # "Window 0 (bash) is now being monitored for all activity."

Comme indiqué dans les commentaires, cela émettra un bip à chaque nouvelle entrée de journal, pas seulement celles qui correspondent à "quelque chose de rare", donc cela ne fait pas tout à fait ce que l'OP a demandé. Encore une astuce utile pour connaître IMHO.

Vous pouvez tirer le meilleur parti des deux mondes en ouvrant deux screenfenêtres ( <C-a> cpour ouvrir une fenêtre, <C-a> <C-a>pour basculer entre deux fenêtres):

1. surveillé, avec tail -f yourfile.log | grep 'something rare'
2. sans surveillance, avec une plaine tail -f yourfile.log

Ensuite, vous pouvez vous asseoir en regardant le journal défiler dans la fenêtre 2, et vous obtiendrez un bip de la fenêtre 1 lorsque "quelque chose de rare" se produit.

screen est incroyablement polyvalent - je recommande fortement de le lire.

Vous pouvez empêcher la sortie d'être mise en mémoire tampon dans la commande grep. Voir man grep pour plus de détails.

Vous pouvez diriger la sortie grep vers un bip.

L'exemple suivant est tiré du bip de l'homme ...

   As part of a log-watching pipeline

          tail -f /var/log/xferlog | grep --line-buffered passwd | \
          beep -f 1000 -r 5 -s

Il y a beaucoup de bonnes choses dans ces manuels. Si seulement nous n'avions pas à les lire pour le trouver. ;-)

La commande watch a une option --beep, et vous pouvez également définir l'intervalle d'interrogation, mais la norme avec 2 sec devrait être ok

watch --beep 'tail development.log | grep "something rare"'

Vous pouvez utiliser sed pour ajouter le contrôle-G comme suit:

tail -f myFile | sed "s/.*/&\x07/"

ou simplement sur des lignes rares, sans utiliser grep, comme suit:

tail -f myFile | sed -n "/something rare/s/.*/&\x07/p"

qui dit: sur les lignes où se produit quelque chose de rare, s tout ubstitute pour la même chose avec le contrôle-G clouée sur la fin et l' impression (mais ne pas imprimer les lignes qui ne correspondent pas ). Fonctionne très bien!

Hm, délicat. On pourrait peut-être faire quelque chose comme ça?

for i in `find | grep 7171`; do beep; echo $i; done

Ou dans votre cas

for i in `tail -f development.log | grep "something rare"`; do beep; echo $i; done

Il semble cependant faire un tampon. Je vais voir s'il existe un moyen de désactiver cette mise en mémoire tampon par la forboucle.

Apparemment, vous devriez pouvoir ajuster la mise en mémoire tampon du tuyau à l'aide de ulimit -pmais cela continue de me plaindre de l'argument invalide. J'ai également trouvé un article qui prétend que vous devez recompiler le noyau pour modifier cette limite.

Dans un travail précédent, je ne pouvais pas obtenir un veilleur fiable avec commande-fu juste, alors j'avais un script d'emballage comme celui ci - dessous, qui a contrôlé le fichier toutes les poll_duration secondes et les nouvelles lignes rassemblés de pour l'expression intéressé.

#!/bin/bash

file=$1
phrase=$2
poll_duration=$3

typeset -i checked_linecount
typeset -i new_linecount
typeset -i new_lines
let checked_linecount=new_linecount=new_lines=0
echo "Watching file $file for phrase \"$phrase\" every $poll_duration seconds"

while [ 1 ]
do
        let new_linecount=`wc -l $file| awk '{print $1}'`
        if [[ $new_linecount > $checked_linecount ]]; then
                let "new_lines = $new_linecount-$checked_linecount"
                head --lines=$new_linecount "$file" | tail --lines=$new_lines | grep "$phrase" && beep
                let checked_linecount=$new_linecount
        fi
        sleep $poll_duration
done

C'était sur une machine Unix. Sous Linux, vous pouvez faire mieux en utilisant son interface inotify filewatcher. Si ce paquet ( inotify-tools sur Ubuntu) est présent, remplacez

sleep $poll_duration 

avec

inotifywait -e modify "$file"  1>/dev/null 2>&1

Cet appel bloque jusqu'à ce que le fichier soit modifié. La version bloquante est presque aussi efficace que ce que vous obtiendriez avec la tail -fversion si le tube pouvait être configuré pour fonctionner sans mise en mémoire tampon.

Remarque: Le script fait d'abord un head --lines=$new_linecountpour s'assurer que les lignes ajoutées au fichier après l'avoir vérifié ne biaisent pas le morceau du fichier qui est vérifié dans cette boucle.