Bash Mkfifo Non Blocking Assignment

Redis provides multiple data structures, and lists are one of them. For lists, it provides blocking and non-blocking operations that act on the head of the list as well as the tail of the list. Using these primitives, we're going to implement the reliable queue pattern8 according to the Redis documentation. I've also bumped into an error about connections 9 but was able to overcome it.

So in this instance we have 2 queues, q1 and q2. The producer puts messages on q1, the consumer atomically pops an element off of q1 and puts it onto q2. After it's been processed by the consumer, the message is deleted from q2. The second queue (q2) is used to recover from failures(network problems or consumer crashes). If messages are equipped with a timestamp, then their age can be measured, and if they sit in q2 for too much time, they can be transferred back to q1 to be re-processed again (by a consumer).



#!/bin/bashREDIS_CLI="redis-cli -h"n=1 nmax=1000 q1="queue"q2="processing"clean() { echo"DEL $q1" | $REDIS_CLIecho"DEL $q2" | $REDIS_CLI } produce() { while (($n <= $nmax)); doMSG="message $n"echo"LPUSH $q1 \"$MSG\"" | $REDIS_CLIn=$((n+1)) done } clean produce


#!/bin/bashREDIS_CLI="redis-cli -h"q1="queue"q2="processing"# redis nil replynil=$(echo -n -e '\r\n') consume() { while true; do# move message to processing queueMSG=$(echo"RPOPLPUSH $q1 $q2" | $REDIS_CLI) if [[ -z "$MSG" ]]; thenbreakfi# processing messageecho"$MSG"# remove message from processing queueecho"LREM $q2 1 \"$MSG\"" | $REDIS_CLI >/dev/null done } consume

It's hard to write a bash script of much import without using a pipe or two. Named pipes, on the other hand, are much rarer.

Like un-named/anonymous pipes, named pipes provide a form of IPC (Inter-Process Communication). With anonymous pipes, there's one reader and one writer, but that's not required with named pipes—any number of readers and writers may use the pipe.

Named pipes are visible in the filesystem and can be read and written just as other files are:

$ ls -la /tmp/testpipe prw-r--r-- 1 mitch users 0 2009-03-25 12:06 /tmp/testpipe|

Why might you want to use a named pipe in a shell script? One situation might be when you've got a backup script that runs via cron, and after it's finished, you want to shut down your system. If you do the shutdown from the backup script, cron never sees the backup script finish, so it never sends out the e-mail containing the output from the backup job. You could do the shutdown via another cron job after the backup is "supposed" to finish, but then you run the risk of shutting down too early every now and then, or you have to make the delay much larger than it needs to be most of the time.

Using a named pipe, you can start the backup and the shutdown cron jobs at the same time and have the shutdown just wait till the backup writes to the named pipe. When the shutdown job reads something from the pipe, it then pauses for a few minutes so the cron e-mail can go out, and then it shuts down the system.

Of course, the previous example probably could be done fairly reliably by simply creating a regular file to signal when the backup has completed. A more complex example might be if you have a backup that wakes up every hour or so and reads a named pipe to see if it should run. You then could write something to the pipe each time you've made a lot of changes to the files you want to back up. You might even write the names of the files that you want backed up to the pipe so the backup doesn't have to check everything.

Named pipes are created via or :

$ mkfifo /tmp/testpipe $ mknod /tmp/testpipe p

The following shell script reads from a pipe. It first creates the pipe if it doesn't exist, then it reads in a loop till it sees "quit":

#!/bin/bashpipe=/tmp/testpipe trap"rm -f $pipe" EXIT if[[ ! -p $pipe]]; thenmkfifo $pipefiwhile truedo if read line <$pipe; then if[["$line"=='quit']]; thenbreakfiecho$linefidoneecho"Reader exiting"

The following shell script writes to the pipe created by the read script. First, it checks to make sure the pipe exists, then it writes to the pipe. If an argument is given to the script, it writes it to the pipe; otherwise, it writes "Hello from PID".

#!/bin/bashpipe=/tmp/testpipe if[[ ! -p $pipe]]; thenecho"Reader not running"exit 1 fiif[["$1"]]; thenecho"$1" >$pipeelseecho"Hello from $$" >$pipefi

Running the scripts produces:

$ sh & [3] 23842 $ sh Hello from 23846 $ sh Hello from 23847 $ sh Hello from 23848 $ sh quit Reader exiting

Note: initially I had the command in the read script directly in the while loop of the read script, but the command would usually return a non-zero status after two or three reads causing the loop to terminate.

while read line <$pipedo if[["$line"=='quit']]; thenbreakfiecho$linedone

Mitch Frazier is an Associate Editor for Linux Journal.

One thought on “Bash Mkfifo Non Blocking Assignment

Leave a Reply

Your email address will not be published. Required fields are marked *