“watch” the output of a command until a particular string is observed and then exit

Question

I'm looking for a way to programatically watch the output of a command until a particular string is observed and then exit. This is very similar to this question, but instead of tailing a file, I want to 'tail' a command.

Something like:

watch -n1 my_cmd | grep -m 1 "String Im Looking For"

(But this doesn't work for me.)

UPDATE: I need to clarify that 'my_cmd' does not continuously output text but needs to be repeatedly called until the string is found (which is why I thought of the 'watch' command). In this respect, 'my_cmd' is like many other unix commands such as: ps, ls, lsof, last, etc.

Answer 1

Use a loop:

until my_cmd | grep -m 1 "String Im Looking For"; do : ; done

Instead of :, you can use sleep 1 (or 0.2) to ease the CPU.

The loop runs until grep finds the string in the command's output. -m 1 means "one match is enough", i.e. grep stops searching after it finds the first match.

Answer 2

watch -e "! my_cmd | grep -m 1 \"String Im Looking For\""

• ! negates the exit code of the command pipeline
• grep -m 1 exits when string is found
• watch -e returns if any error has occured

But this can be improved to actually display that matched line, which is thrown away so far.

Answer 3

For those who have a program that is continuously writing to stdout, all you need to do is pipe it to grep with the 'single match' option. Once grep finds the matching string, it will exit, which closes stdout on the process that is being piped to grep. This event should naturally cause the program to gracefully exit so long as the process writes again.

What will happen is that the process will receive a SIGPIPE when it tries writing to closed stdout after grep has exited. Here is an example with ping, which would otherwise run indefinitely:

$ ping superuser.com | grep -m 1 "icmp_seq"

This command will match the first successful 'pong', and then exit the next time ping tries writing to stdout.

---

However,

It's not always guaranteed that the process will write to stdout again and therefore might not cause a SIGPIPE to be raised (e.g., this can happen when tailing a log file). The best solution i've managed to come up with for this scenario involves writing to a file; please comment if you think you can improve:

$ { tail -f log_file & echo $! > pid; } | { grep -m1 "find_me" && kill -9 $(cat pid) && rm pid; }

Breaking this down:

1. tail -f log_file & echo $! > pid - tails a file, attaches process to background, and saves the PID ($!) to a file. I tried exporting the PID to a variable instead, but it seems there's a race condition between here and when the PID is used again.
2. { ... ;} - group these commands together so we can pipe the output to grep while keeping the current context (helps when saving and reusing variables, but wasn't able to get that part working)
3. | - pipe left side's stdout to right side's stdin
4. grep -m1 "find_me" - find the target string
5. && kill -9 $(cat pid) - force kill (SIGKILL) the tail process after grep exits once it finds the matching string
6. && rm pid - remove the file we created

Answer 4

my_cmd | tail +1f | sed '/String Im Looking For/q'

If tail doesn't support the +1f syntax, try tail -f -n +1. (The -n +1 tells it to start at the beginning; tail -f by default starts with the last 10 lines of output.)

Answer 5

Append the result of your program calls to a file. Then tail -f that file. That way it should work... I hope.

When you restart calling that program you'll have to erase the file or append some gibberish to it just so it doesn't match again right away what you were looking for.