How to ensure a process has started reading a file before continuing?

Question

I'm trying to write a command to test that data is written to a file. My first approach was:

1. Start reading in the background.
2. Write some data to the file.
3. Wait for the reader to find a result.
4. Repeat indefinitely to see if there's a timing issue.

In script form:

while true
do
    grep -q foo <(tail -n0 -f /var/log/syslog) &
    logger foo && logger line && wait
done

(the logger line command is to avoid last message repeated N times lines in the file)

This version will typically loop a once or twice before getting stuck at the wait command, so it looks like tail didn't have time to start reading before logger foo had written to the file.

What is the best way to guarantee that tail is reading before continuing? These workarounds are not ideal:

• Pause before logger (won't work in the case of slow file systems)

      sleep 1 && logger foo && logger line && wait
  

• Start a second reader, and assume that the first one has started reading by the time the second has been shown to. This looped a few thousand times before getting stuck:

      grep -q foo <(tail -n0 -f /var/log/syslog) &
      grep -q bar <(tail -n0 -f /var/log/syslog) &
      while kill -0 $!
      do
          logger bar
          logger line
      done
      logger foo && logger line && wait
  

Answer 1

Here's one way, re-using the reader after establishing that it is indeed reading:

while true
do
    exec 3<> myfifo
    tail -n0 -f /var/log/syslog >&3 &
    tailproc=$!
    while ! grep -q start <&3
    do
        logger start
        logger line
    done
    grep -q end <&3 &
    logger end
    logger line
    wait $!
    exec 3<&-
    exec 3>&-
    kill $tailproc
done

Since the writer is blocked while nobody is reading (between the first and the second grep commands) it shouldn't be possible for the second grep to miss out on the next line.

This has been running for a few tens of thousands of iterations (based on the process IDs in the output) without getting stuck.