Linux: Bloc jusqu'à ce qu'une chaîne est détectée dans un fichier (“queue + grep avec blocage”)

Grâce à la fois pour les réponses, mais l'important est que le processus se bloque jusqu'à ce trouvé, puis se termine. J'ai trouvé ceci:

grep -q 'PATTERN' <(tail -f file.log)

-q n'est pas très portable, mais je n'utilise que Red Hat Enterprise Linux donc c'est ok.
Et avec un délai d'attente:

timeout 180 grep -q 'PATTERN' <(tail -f file.log)

OriginalL'auteur

tail -f file | grep word | head -n1

Publierons snip avec async délai

Pour l'instant: Comment inclure une minuterie dans des Scripts Bash?

Liés réponse définit un " run_or_timeout la fonction qui fait ce que vous êtes à la recherche d'un très bash-savvy façon

OriginalL'auteur

Prendre un coup d'oeil à la --max-count option:

tail -f file.log | grep -m 1 'PATTERN'

Il sortira après la première ligne qui correspond à PATTERN.

---

MODIFIER: prendre note de @Karoly de commentaire ci-dessous. Si le file.log la vitesse est lente, il est possible que le grep processus de bloc jusqu'à ce que le contenu supplémentaire est ajoutée au fichier après la mise en correspondance de la ligne.

echo 'context PATTERN line' >> file.log  ## grep shows the match but doesn't exit

va imprimer la correspondance de la ligne, mais il ne va pas quitter jusqu'à ce que le contenu supplémentaire est ajouté au fichier (même si elle n'a pas un caractère de saut de ligne encore):

echo -n ' ' >> file.log  ## Now the grep process exits

Dans certains cas (comme une haute vitesse de fichier journal), ce n'est pas une grosse affaire, parce que le nouveau contenu est probablement va être ajoutée au fichier bientôt de toute façon.

Également noter que ce comportement ne pas se produire lors de la lecture à partir d'une console comme stdin, de sorte qu'il semble être une différence dans la façon grep lit à partir d'un tuyau:

$ grep -m1 'PATTERN' -      # manually type PATTERN and enter, exits immediately
$ cat | grep -m1 'PATTERN'  # manually type PATTERN and enter, and it hangs

OriginalL'auteur

J'ai eu une demande similaire et est venu avec ce qui suit.

Le one-liner, vous êtes après est la ligne qui commence par "délai d'attente ...." et le reste du code est le travail de préparation nécessaire pour fournir le one-liner avec les informations dont il a besoin et à nettoyer après.

##
## Start up the process whose log file we want to monitor for a specific pattern.
##
touch file_to_log_nohup_output.log
nohup "some_command" "some_args" >> file_to_log_nohup_output.log 2>&1 &
my_cmd_pid=$!


## Specify what our required timeout /pattern and log file to monitor is
my_timeout=10m
my_logfile="/path/to/some_command's/log/file.txt"
my_pattern="Started all modules."


## How does this work?
## - In a bash sub shell, started in the background, we sleep for a second and
##   then execute tail to monitor the application's log file.
## - Via the arguments passed to it, tail has been configured to exit if the
##   process whose log file it is monitoring dies.
## - The above sub shell, is executed within another bash sub shell in which
##   we identify the process id of the above sub shell and echo it to stdout.
## - Lastly, in that sub shell we wait for the sub shell with tail running in
##   it as a child process, to terminate and if it does terminate, we redirect
##   any output from its stderr stream to /dev/null.
## - The stdout output of the above sub shell is piped into another sub shell
##   in which we setup a trap to watch for an EXIT event, use head -1 to read
##   the process id of the tail sub shell and finally start a grep process
##   to grep the stdout for the requested pattern. Grep will quit on the first
##   match found. The EXIT trap will kill the process of the tail sub shell
##   if the sub shell running grep quits.
##
## All of this is needed to tidy up the monitoring child processes for
## tail'ing + grep'ing the application log file.
##
## Logic of implementing the above sourced from: http://superuser.com/a/1052328


timeout ${my_timeout} bash -c '((sleep 1; exec tail -q -n 0 --pid=$0 -F "$1" 2> /dev/null) & echo $! ; wait $! 2>/dev/null ) | (trap "kill ${my_tail_pid} 2>/dev/null" EXIT; my_tail_pid="`head -1`"; grep -q "$2")' "${my_cmd_pid}" "${my_logfile}" "${my_pattern}" 2>/dev/null &


##
## We trap SIGINT (i.e. when someone presses ctrl+c) to clean up child processes.
##
trap 'echo "Interrupt signal caught. Cleaning up child processes: [${my_timeout_pid} ${my_cmd_pid}]." >> "file_to_log_nohup_output.log"; kill ${my_timeout_pid} ${my_cmd_pid} 2> /dev/null' SIGINT
wait ${my_timeout_pid}
my_retval=$?
trap - SIGINT


## If the time out expires, then 'timeout' will exit with status 124 otherwise
## it exits with the status of the executed command (which is grep in this
## case).
if [ ${my_retval} -eq 124 ]; then
    echo "Waited for [${my_timeout}] and the [${my_pattern}] pattern was not encountered in application's log file."
    exit 1
else
    if [ ${my_retval} -ne 0 ]; then
        echo "An issue occurred whilst starting process. Check log files:"
        echo "  * nohup output log file: [file_to_log_nohup_output.log]"
        echo "  * application log file: [${my_logfile}]"
        echo "  * application's console log file (if applicable)"
        exit 1
    else
        info_msg "Success! Pattern was found."
        exit 0
    fi
fi

J'ai mis en place ci-dessus dans un seul script qui peut être utilisé pour exécuter une commande d'attendre de son fichier de log pour avoir la configuration voulue, avec un délai d'attente.

Disponible ici: run_and_wait.sh

OriginalL'auteur