Unix: why I need to close the input FIFO to my program before I can read from its output FIFO

Question

I've got a problem: I have one program running in a shell that does some calculations based on user input, and I can launch this program in an interactive way so it will keep asking for input and it outputs its calculations after user press enter. So it remains open inside the shell till user types the exit-word.

What I want to do is to create an interface in such a way that user has to type input somewhere else off the shell and using pipe, fifo and so on, input is carried away to that program, and its output goes to this interface.

In a few word: I have a long running process and I need to attach, when needed, my interface to its stdin and stdout.

For this kind of problem, I was thinking to use a FIFO file made by mkfifo command (we are in Unix, especially for Mac user) and redirect program stdin and stdout to this file:

my_program < fifofile > fifofile

But I've found some difficulties about reading and writing to this fifo file. So I decided to use 2 fifo files, one for input and one for output. So:

exec my_program < fifofile_in > fifofile_out

(don't know why I use exec for redirection, but it works... and I'm okay with exec ;) )

If I launch this command in a shell, and in another one I wrote:

echo -n "date()" > fifofile_in

The echoing process is succesful, and if I do:

cat fifofile_out

I'm able to see my_program output. Ok! But I don't want to deal with shell, instead I want to deal with a program written by me, like this python script:

import os, time;

text="";
OUT=os.open("sample_out",os.O_RDONLY | os.O_NONBLOCK)
out=os.fdopen(OUT);
while(1):
  #IN=open("sample_in",'w' );
  IN=os.open("sample_in",os.O_WRONLY)
  #OUT=os.fdopen(os.open("sample_out",os.O_RDONLY| os.O_NONBLOCK |os.O_APPEND));
  #OUT=open("sample_out","r");
  print "Write your mess:";
  text=raw_input();
  if (text=="exit"):
    break;
  os.write(IN,text);
  os.close(IN);
  #os.fsync(IN);
  time.sleep(0.05);
  try:
    while True:
        #c=os.read(OUT,1);
        c=out.readline();
        print "Read: ", c#, " -- ", ord(c);
        if not c:
            print "End of file";
            quit();
            #break;
  except OSError as e:
    continue;
    #print "OSError"
  except IOError as e:
    continue;
    #print "IOError"

Where:

sample_in, sample_out are respectively fifo files used for redirections to stdin and stdout (so I write to stdin in order to give input to my_program and I read from stdout in order to get my_program output)

out is my os.fdopen file descriptor used for getting lines with out.readline() instead of using OUT.read(1) (char by char)

time.sleep(0.05) is for delay some time before go reading my_program output (needed for calculations, else I got nothing to read).

Whit this script and my_program running in background from the shell, I'm able to write to stdin and read from stdout correctly, but the journey to achieve this code wasn't easy: after have read all posts about fifo and reading/writing from/to fifo files, I came with this solution of closing the IN fd before reading from OUT even if the fifo files are different! From what I read around internet and in Stackoverflow articles, I thought that this procedure was for handle only one fifo file, but here I deal with two (different!). I think it is something related to how I write into sample_in: I tried to flush to look like echo -n command, but it seems useless.

So I would like to ask you if this behaviour is normal, and how can achieve the same thing with echo -n "...." > sample_in and in other shell cat sample_out? In particular, cat is outputting data continuously as soon as I echo input in sample_in, but my way of reading is with data blocks.

Thanks so much, I hope everything it's clear enough!