Update EbuildIpcDaemon to open files as non-blocking.

bin/ebuild-ipc.py

 #!/usr/bin/python
 # Copyright 2010-2011 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 #
 # This is a helper which ebuild processes can use
 # to communicate with portage's main python process.
 
 import logging
 import os
 import pickle
@@ skipping 116 matching lines @@
                 if not os.WIFEXITED(wait_retval[1]):
                         portage.util.writemsg_level(
                                 "ebuild-ipc: %s: %s\n" % (msg,
                                 portage.localization._('subprocess failure: %s') % \
                                 wait_retval[1]),
                                 level=logging.ERROR, noiselevel=-1)
                         return 2
 
                 return os.WEXITSTATUS(wait_retval[1])
 
-        def _receive_reply(self):
-
-                # File streams are in unbuffered mode since we do atomic
-                # read and write of whole pickles.
-                input_file = open(self.ipc_out_fifo, 'rb', 0)
+        def _receive_reply(self, input_file):
 
                 # For maximum portability, use a single atomic read.
                 buf = None
                 try:
                         buf = input_file.read(self._BUFSIZE)
                 except IOError as e:
                         if not buf:
                                 portage.util.writemsg_level(
                                         "ebuild-ipc: %s\n" % (e,),
                                         level=logging.ERROR, noiselevel=-1)
@@ skipping 33 matching lines @@
                                         portage.util.writemsg(err, noiselevel=-1)
 
                 return retval
 
         def _communicate(self, args):
 
                 if not self._daemon_is_alive():
                         self._no_daemon_msg()
                         return 2
 
+                # File streams are in unbuffered mode since we do atomic
+                # read and write of whole pickles.
+                input_file = open(self.ipc_out_fifo, 'rb', 0)
+
                 # Use forks so that the child process can handle blocking IO
                 # un-interrupted, while the parent handles all timeout
                 # considerations. This helps to avoid possible race conditions
                 # from interference between timeouts and blocking IO operations.
                 pr, pw = os.pipe()
                 pid = os.fork()
 
                 if pid == 0:
                         os.close(pr)
 
@@ skipping 19 matching lines @@
 
                 if not self._daemon_is_alive():
                         self._no_daemon_msg()
                         return 2
 
                 pr, pw = os.pipe()
                 pid = os.fork()
 
                 if pid == 0:
                         os.close(pr)
-                        retval = self._receive_reply()
+                        retval = self._receive_reply(input_file)
                         os._exit(retval)
 
                 os.close(pw)
                 retval = self._wait(pid, pr, portage.localization._('during read'))
                 os.close(pr)
                 return retval
 
 def ebuild_ipc_main(args):
         ebuild_ipc = EbuildIpc()
         return ebuild_ipc.communicate(args)
 
 if __name__ == '__main__':
         sys.exit(ebuild_ipc_main(sys.argv[1:]))