Unblock subprocesses waiting for stdin close

Partial fix for #552

BREAKING CHANGE FOR RUNNER IMPLEMENTATIONS:
New method added close_proc_stdin to allow the parent Runner to ask
subclass to close the stream after it finds the end of the stream.

Fix ExceptionHandlingThread.is_dead which before would report dead when
thread was not alive and there was no exception info

This does not fix when pty=True, more significant changes are required for that case

Two test cases were adjusted that were wrongly asserting that the thread
should be "is_dead" after thread.join()

Author: Chris Plock

invoke/runners.py

@@ -656,6 +656,8 @@ def handle_stdin(self, input_, output, echo):
                 elif data is not None:
                     # When reading from file-like objects that aren't "real"
                     # terminal streams, an empty byte signals EOF.
+                    if not self.using_pty:
+                        self._close_proc_stdin()
                     break
                 # Dual all-done signals: program being executed is done
                 # running, *and* we don't seem to be reading anything out of
@@ -863,6 +865,18 @@ def _write_proc_stdin(self, data):
         """
         raise NotImplementedError
 
+    def _close_proc_stdin(self):
+        """
+        Close running process' stdin.
+
+        This should never be called directly; it's for subclasses to implement.
+
+        :returns: ``None``.
+
+        .. versionadded:: 1.1
+        """
+        raise NotImplementedError
+
     def default_encoding(self):
         """
         Return a string naming the expected encoding of subprocess streams.
@@ -1006,6 +1020,13 @@ def _write_proc_stdin(self, data):
             if "Broken pipe" not in str(e):
                 raise
 
+    def _close_proc_stdin(self):
+        if self.using_pty:
+            # there is no working scenario to tell the process that stdin
+            # closed when using pty
+            raise Exception("Cannot close stdin when pty=True")
+        self.process.stdin.close()
+
     def start(self, command, shell, env):
         if self.using_pty:
             if pty is None:  # Encountered ImportError

invoke/util.py

@@ -271,7 +271,8 @@ def is_dead(self):
         # NOTE: it seems highly unlikely that a thread could still be
         # is_alive() but also have encountered an exception. But hey. Why not
         # be thorough?
-        return (not self.is_alive()) and self.exc_info is not None
+        alive = self.is_alive() and (self.exc_info is None)
+        return not alive
 
     def __repr__(self):
         # TODO: beef this up more

tests/_util.py

@@ -277,6 +277,9 @@ def read_proc_stderr(self, num_bytes):
     def _write_proc_stdin(self, data):
         pass
 
+    def _close_proc_stdin(self):
+        pass
+
     @property
     def process_is_finished(self):
         return True

tests/concurrency.py

@@ -39,7 +39,7 @@ def exhibits_is_dead_flag(self):
             t = EHThread(target=self.worker, args=[Queue()])
             t.start()
             t.join()
-            assert not t.is_dead
+            assert t.is_dead
 
     class via_subclassing:
         def setup(self):
@@ -80,4 +80,4 @@ def exhibits_is_dead_flag(self):
             t = self.klass(queue=Queue())
             t.start()
             t.join()
-            assert not t.is_dead
+            assert t.is_dead