How to execute a command after the previous non-terminating command prints a certain string?

Question

I want to execute commandA which prints the following:

line1
line2
line3
started successfully
line4
...
...

And when the line started successfully is printed I want to start another command (and possibly multiplex their outputs so that both are printed on the terminal).

How could I achieve this in bash?

Answer 1

Here's one way you can do that:

$ outputfile=output.log
$ commandA | tee "$outputfile" & tail --pid=$! -n+1 -f "$outputfile" |grep -q "started successfully" && commandB; wait

Explanation:

1. Using the tee command you write the output both to STDOUT and to the file named $outputfile.
2. You run the command in the background, so you could now track its output.
3. tail --pid=$! -n+1 -f "$outputfile" - You run tail command on $outputfile and follow its output starting from the first line.
   • The --pid=$! flag is required to ensure that the tail command terminates once commandA completes.
4. grep -q "started successfully" - will exit successfully (and quietly) upon the first occurrence of the required string.
5. && commandB - if grep found the string, it will execute commandB.
   • You should use && and not ; to ensure that commandB is executed only if the string was found in the output of commandA. If commandA finished without writing this string (for instance, if it failed), you don't want to run the second command.
6. wait - In case commandB finishes before commandA, keep waiting for commandA to run before returning to the shell.
   • Alternatively, you could run fg instead of wait to get to let commandA keep running in the foreground if commandB finished before.

Update

Inspired by @PaulPazderski's answer, here's another way to do that without a log file and the tail command:

$ commandA | tee >(grep -q "started successfully" && commandB; cat >/dev/null)

The only downside is that if commandA finishes before commandB, the shell will return to the prompt right after commandA finishes, while commandB might still be running in the background and even writing output to your terminal.

In order to solve this, just pipe the final output to another command, such as cat, to ensure that the shell returns to the prompt only when nothing writes to stdout anymore (which means that the entire command finished, even commandB).

$ commandA | tee >(grep -q "started successfully" && commandB; cat >/dev/null) | cat

Answer 2

I would try a script "track-output" like:

#!/bin/bash

while IFS= read -r line; do
  echo "$line"
  if [[ "$line" == "started successfully" ]]; then
    do_something
    # optional exit but that could disrupt commandA with a SIGPIPE
  fi
done

and call it as

commandA | track-output

or if with tee and process substitution and without the echo line in the script as

commandA | tee >(track-output)

Answer 3

Could be:

{
  commandA 3<&- | perl -pe '
    exec "commandB <&3 3<&-" if !$pid && /started successfully/ && ($pid = fork) == 0;
    END {if ($pid) {wait; exit($? & 127 ? $? + 128 : $? >> 8)}}'
} 3<&0

If using zsh instead of bash, and GNU tee, you could do something similar with the caveat that commandB's exit status will be lost with:

{
  commandA 3<&- |
    tee -p >(grep -q 'started successfully' && commandB <&3 3<&-)
} 3<&0

That would also work in bash (though you'd need to add a exec in front of commandB as bash doesn't always optimise out the fork there) except for the fact that commandB would not be waited for there.

In both approaches we take care that commandA and commandB's stdin be left undisturbed. commandA's stdout is changed from the original to a pipe, but that's necessary if we have to find started successfully in there, but that output is passed along by perl -p or tee. commandB's stdout is undisturbed.

Note that some command buffer their output when stdout is not a terminal device. So with commandA's output here becoming a pipe, you might find that started successfully is only printed as part of a large block, and commandB not started as early as it could be as a result.

With zsh, it can be worked around by using zpty to start commandA with its output connected to pseudo-terminal:

zmodload zsh/zpty

# start commandA with only stdout going to the pseudo-terminal
# stdin and stderr restored.
zpty A 'command A <&3 3<&- 2>&4 4>&-' 3<&0 4>&2

pid=
while zpty -r A line; do
  print -rn - $line
  if (( ! pid )) && [[ $line = *"started successfully" ]]; then
    { commandB <&3 3<&- & } 3<&0
    pid=$!
  fi
done
(( ! pid )) || wait $pid

Answer 4

The code below will execute command2 after command1 prints "Some text" (because on match grep will terminate). After that both command1 and command2 outputs will be printed to stdout:

command1 | tee >(grep -o -m1 "Some text"; command2 )