Pfthb

I am writing a script that will setup an environment of machines. I have the ability to put a startup script on the machines and so I am trying to use a named pipe mkfifo in unix on my "workstation" machine that will listen for writes from these new machines when they come online.

The problem is, I have no control over when these machines may come online. In total there are over 20 machines that are being started simultaneously and I have tried to simulate the effects of a named pipe being written to multiple times before it has a chance to read and have had startling results....

I wrote two small test scripts:

mkfifogen.sh

#!/bin/bash
mkfifo h
testing=""
sleep 10
for((i=0;i<5;i++));do
 echo $I
 while read line;do
 testing+="$line"
 done < h
done

echo "$testing"
rm -f h

and

mkfifowrite.sh

#!/bin/bash
for((i=0;i<5;i++));do
 echo "this is a test $i" > h
done

When I run the mkfifogen.sh followed by the mkfifowrite.sh the output is as follows

0
1
2

Then the mkfifowrite.sh script exits and the mkfifogen.sh script hangs

I then have to run the mkfifowrite.sh script 3 more times, and each time it will cause the output on the mkfifogen.sh script to increment one more time. The last run will cause the value of testing to be output 4 times, so my output after 4 runs of the mkfifowrite.sh script and once of the mkfifogen.sh script looks like this:

0
1
2
3
4
this is a test 0this is a test 1this is a test 2this is a test 3this is a test 4
this is a test 0this is a test 1this is a test 2this is a test 3this is a test 4
this is a test 0this is a test 1this is a test 2this is a test 3this is a test 4
this is a test 0this is a test 1this is a test 2this is a test 3this is a test 4

What I am expecting to see after running mkfifogen.sh and mkfifowrite.sh once each is simply this:

0
1
2
3
4
this is a test 0this is a test 1this is a test 2this is a test 3this is a test 4

I have looked around online quite a bit and there are some cryptic answers to this, but I can't seem to make much sense out of them. I feel like this link might hold my answer, but I'm not sure https://unix.stackexchange.com/questions/68146/what-are-guarantees-for-concurrent-writes-into-a-named-pipe

TL;DR:

How do I ensure that all writes to a named pipe, regardless of quick in succession they are executed, are handled independently by the read?

The reader reads until EOF, then repeats, until 5 EOFs have been received.

The writer opens and closes the pipe 5 times. Every time the writer closes the pipe, a potential EOF condition exists. It doesn't become an actual EOF until the reader attempts to read it (after reading everything that was written before).

During this potential EOF phase, there's a race. The writer is incrementing i and preparing to open the pipe for writing again, while the reader is completing the read command and processing the result, after which it will try to read again.

If the writer performs an open for writing before the reader attempts the read, the potential EOF condition disappears. If the reader attempts the read while the writer is no longer connected to the pipe, the EOF happens.

As you can see, when there are multiple writers to a pipe (whether sequential or parallel), EOFs are a pain. You can't expect them to reliably show up between messages from different writers. My way out of this would be to design the protocol so that the reader doesn't need EOFs to recognize the end of a message, and then have the reader open the pipe in read+write mode so there will always be at least one existing writer, and EOF will never occur.

Keeping the messages under PIPE_BUF size so they don't get split up is a separate issue, which you also have to pay attention to.