python模块：subprocess

1 # subprocess - Subprocesses with accessible I/O streams
2 #
3 # For more information about this module, see PEP 324.
4 #
5 # Copyright (c) 2003-2005 by Peter Astrand <astrand@lysator.liu.se>
6 #
7 # Licensed to PSF under a Contributor Agreement.
8 # See http://www.python.org/2.4/license for licensing details.
9
10 r"""Subprocesses with accessible I/O streams
11
12 This module allows you to spawn processes, connect to their
13 input/output/error pipes, and obtain their return codes.
14
15 For a complete description of this module see the Python documentation.
16
17 Main API
18 ========
19 run(...): Runs a command, waits for it to complete, then returns a
20           CompletedProcess instance.
21 Popen(...): A class for flexibly executing a command in a new process
22
23 Constants
24 ---------
25 DEVNULL: Special value that indicates that os.devnull should be used
26 PIPE:    Special value that indicates a pipe should be created
27 STDOUT:  Special value that indicates that stderr should go to stdout
28
29
30 Older API
31 =========
32 call(...): Runs a command, waits for it to complete, then returns
33     the return code.
34 check_call(...): Same as call() but raises CalledProcessError()
35     if return code is not 0
36 check_output(...): Same as check_call() but returns the contents of
37     stdout instead of a return code
38 getoutput(...): Runs a command in the shell, waits for it to complete,
39     then returns the output
40 getstatusoutput(...): Runs a command in the shell, waits for it to complete,
41     then returns a (exitcode, output) tuple
42 """
43
44 import sys
45 _mswindows = (sys.platform == "win32")
46
47 import io
48 import os
49 import time
50 import signal
51 import builtins
52 import warnings
53 import errno
54 from time import monotonic as _time
55
56 # Exception classes used by this module.
57 class SubprocessError(Exception): pass
58
59
60 class CalledProcessError(SubprocessError):
61     """Raised when run() is called with check=True and the process
62     returns a non-zero exit status.
63
64     Attributes:
65       cmd, returncode, stdout, stderr, output
66     """
67     def __init__(self, returncode, cmd, output=None, stderr=None):
68         self.returncode = returncode
69         self.cmd = cmd
70         self.output = output
71         self.stderr = stderr
72
73     def __str__(self):
74         if self.returncode and self.returncode < 0:
75             try:
76                 return "Command '%s' died with %r." % (
77                         self.cmd, signal.Signals(-self.returncode))
78             except ValueError:
79                 return "Command '%s' died with unknown signal %d." % (
80                         self.cmd, -self.returncode)
81         else:
82             return "Command '%s' returned non-zero exit status %d." % (
83                     self.cmd, self.returncode)
84
85     @property
86     def stdout(self):
87         """Alias for output attribute, to match stderr"""
88         return self.output
89
90     @stdout.setter
91     def stdout(self, value):
92         # There's no obvious reason to set this, but allow it anyway so
93         # .stdout is a transparent alias for .output
94         self.output = value
95
96
97 class TimeoutExpired(SubprocessError):
98     """This exception is raised when the timeout expires while waiting for a
99     child process.
100
101     Attributes:
102         cmd, output, stdout, stderr, timeout
103     """
104     def __init__(self, cmd, timeout, output=None, stderr=None):
105         self.cmd = cmd
106         self.timeout = timeout
107         self.output = output
108         self.stderr = stderr
109
110     def __str__(self):
111         return ("Command '%s' timed out after %s seconds" %
112                 (self.cmd, self.timeout))
113
114     @property
115     def stdout(self):
116         return self.output
117
118     @stdout.setter
119     def stdout(self, value):
120         # There's no obvious reason to set this, but allow it anyway so
121         # .stdout is a transparent alias for .output
122         self.output = value
123
124
125 if _mswindows:
126     import threading
127     import msvcrt
128     import _winapi
129     class STARTUPINFO:
130         dwFlags = 0
131         hStdInput = None
132         hStdOutput = None
133         hStdError = None
134         wShowWindow = 0
135 else:
136     import _posixsubprocess
137     import select
138     import selectors
139     try:
140         import threading
141     except ImportError:
142         import dummy_threading as threading
143
144     # When select or poll has indicated that the file is writable,
145     # we can write up to _PIPE_BUF bytes without risk of blocking.
146     # POSIX defines PIPE_BUF as >= 512.
147     _PIPE_BUF = getattr(select, 'PIPE_BUF', 512)
148
149     # poll/select have the advantage of not requiring any extra file
150     # descriptor, contrarily to epoll/kqueue (also, they require a single
151     # syscall).
152     if hasattr(selectors, 'PollSelector'):
153         _PopenSelector = selectors.PollSelector
154     else:
155         _PopenSelector = selectors.SelectSelector
156
157
158 __all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call", "getstatusoutput",
159            "getoutput", "check_output", "run", "CalledProcessError", "DEVNULL",
160            "SubprocessError", "TimeoutExpired", "CompletedProcess"]
161            # NOTE: We intentionally exclude list2cmdline as it is
162            # considered an internal implementation detail.  issue10838.
163
164 if _mswindows:
165     from _winapi import (CREATE_NEW_CONSOLE, CREATE_NEW_PROCESS_GROUP,
166                          STD_INPUT_HANDLE, STD_OUTPUT_HANDLE,
167                          STD_ERROR_HANDLE, SW_HIDE,
168                          STARTF_USESTDHANDLES, STARTF_USESHOWWINDOW)
169
170     __all__.extend(["CREATE_NEW_CONSOLE", "CREATE_NEW_PROCESS_GROUP",
171                     "STD_INPUT_HANDLE", "STD_OUTPUT_HANDLE",
172                     "STD_ERROR_HANDLE", "SW_HIDE",
173                     "STARTF_USESTDHANDLES", "STARTF_USESHOWWINDOW",
174                     "STARTUPINFO"])
175
176     class Handle(int):
177         closed = False
178
179         def Close(self, CloseHandle=_winapi.CloseHandle):
180             if not self.closed:
181                 self.closed = True
182                 CloseHandle(self)
183
184         def Detach(self):
185             if not self.closed:
186                 self.closed = True
187                 return int(self)
188             raise ValueError("already closed")
189
190         def __repr__(self):
191             return "%s(%d)" % (self.__class__.__name__, int(self))
192
193         __del__ = Close
194         __str__ = __repr__
195
196
197 # This lists holds Popen instances for which the underlying process had not
198 # exited at the time its __del__ method got called: those processes are wait()ed
199 # for synchronously from _cleanup() when a new Popen object is created, to avoid
200 # zombie processes.
201 _active = []
202
203 def _cleanup():
204     for inst in _active[:]:
205         res = inst._internal_poll(_deadstate=sys.maxsize)
206         if res is not None:
207             try:
208                 _active.remove(inst)
209             except ValueError:
210                 # This can happen if two threads create a new Popen instance.
211                 # It's harmless that it was already removed, so ignore.
212                 pass
213
214 PIPE = -1
215 STDOUT = -2
216 DEVNULL = -3
217
218
219 # XXX This function is only used by multiprocessing and the test suite,
220 # but it's here so that it can be imported when Python is compiled without
221 # threads.
222
223 def _optim_args_from_interpreter_flags():
224     """Return a list of command-line arguments reproducing the current
225     optimization settings in sys.flags."""
226     args = []
227     value = sys.flags.optimize
228     if value > 0:
229         args.append('-' + 'O' * value)
230     return args
231
232
233 def _args_from_interpreter_flags():
234     """Return a list of command-line arguments reproducing the current
235     settings in sys.flags and sys.warnoptions."""
236     flag_opt_map = {
237         'debug': 'd',
238         # 'inspect': 'i',
239         # 'interactive': 'i',
240         'dont_write_bytecode': 'B',
241         'no_user_site': 's',
242         'no_site': 'S',
243         'ignore_environment': 'E',
244         'verbose': 'v',
245         'bytes_warning': 'b',
246         'quiet': 'q',
247         # -O is handled in _optim_args_from_interpreter_flags()
248     }
249     args = _optim_args_from_interpreter_flags()
250     for flag, opt in flag_opt_map.items():
251         v = getattr(sys.flags, flag)
252         if v > 0:
253             args.append('-' + opt * v)
254     for opt in sys.warnoptions:
255         args.append('-W' + opt)
256     return args
257
258
259 def call(*popenargs, timeout=None, **kwargs):
260     """Run command with arguments.  Wait for command to complete or
261     timeout, then return the returncode attribute.
262
263     The arguments are the same as for the Popen constructor.  Example:
264
265     retcode = call(["ls", "-l"])
266     """
267     with Popen(*popenargs, **kwargs) as p:
268         try:
269             return p.wait(timeout=timeout)
270         except:
271             p.kill()
272             p.wait()
273             raise
274
275
276 def check_call(*popenargs, **kwargs):
277     """Run command with arguments.  Wait for command to complete.  If
278     the exit code was zero then return, otherwise raise
279     CalledProcessError.  The CalledProcessError object will have the
280     return code in the returncode attribute.
281
282     The arguments are the same as for the call function.  Example:
283
284     check_call(["ls", "-l"])
285     """
286     retcode = call(*popenargs, **kwargs)
287     if retcode:
288         cmd = kwargs.get("args")
289         if cmd is None:
290             cmd = popenargs[0]
291         raise CalledProcessError(retcode, cmd)
292     return 0
293
294
295 def check_output(*popenargs, timeout=None, **kwargs):
296     r"""Run command with arguments and return its output.
297
298     If the exit code was non-zero it raises a CalledProcessError.  The
299     CalledProcessError object will have the return code in the returncode
300     attribute and output in the output attribute.
301
302     The arguments are the same as for the Popen constructor.  Example:
303
304     >>> check_output(["ls", "-l", "/dev/null"])
305     b'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'
306
307     The stdout argument is not allowed as it is used internally.
308     To capture standard error in the result, use stderr=STDOUT.
309
310     >>> check_output(["/bin/sh", "-c",
311     ...               "ls -l non_existent_file ; exit 0"],
312     ...              stderr=STDOUT)
313     b'ls: non_existent_file: No such file or directory\n'
314
315     There is an additional optional argument, "input", allowing you to
316     pass a string to the subprocess's stdin.  If you use this argument
317     you may not also use the Popen constructor's "stdin" argument, as
318     it too will be used internally.  Example:
319
320     >>> check_output(["sed", "-e", "s/foo/bar/"],
321     ...              input=b"when in the course of fooman events\n")
322     b'when in the course of barman events\n'
323
324     If universal_newlines=True is passed, the "input" argument must be a
325     string and the return value will be a string rather than bytes.
326     """
327     if 'stdout' in kwargs:
328         raise ValueError('stdout argument not allowed, it will be overridden.')
329
330     if 'input' in kwargs and kwargs['input'] is None:
331         # Explicitly passing input=None was previously equivalent to passing an
332         # empty string. That is maintained here for backwards compatibility.
333         kwargs['input'] = '' if kwargs.get('universal_newlines', False) else b''
334
335     return run(*popenargs, stdout=PIPE, timeout=timeout, check=True,
336                **kwargs).stdout
337
338
339 class CompletedProcess(object):
340     """A process that has finished running.
341
342     This is returned by run().
343
344     Attributes:
345       args: The list or str args passed to run().
346       returncode: The exit code of the process, negative for signals.
347       stdout: The standard output (None if not captured).
348       stderr: The standard error (None if not captured).
349     """
350     def __init__(self, args, returncode, stdout=None, stderr=None):
351         self.args = args
352         self.returncode = returncode
353         self.stdout = stdout
354         self.stderr = stderr
355
356     def __repr__(self):
357         args = ['args={!r}'.format(self.args),
358                 'returncode={!r}'.format(self.returncode)]
359         if self.stdout is not None:
360             args.append('stdout={!r}'.format(self.stdout))
361         if self.stderr is not None:
362             args.append('stderr={!r}'.format(self.stderr))
363         return "{}({})".format(type(self).__name__, ', '.join(args))
364
365     def check_returncode(self):
366         """Raise CalledProcessError if the exit code is non-zero."""
367         if self.returncode:
368             raise CalledProcessError(self.returncode, self.args, self.stdout,
369                                      self.stderr)
370
371
372 def run(*popenargs, input=None, timeout=None, check=False, **kwargs):
373     """Run command with arguments and return a CompletedProcess instance.
374
375     The returned instance will have attributes args, returncode, stdout and
376     stderr. By default, stdout and stderr are not captured, and those attributes
377     will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them.
378
379     If check is True and the exit code was non-zero, it raises a
380     CalledProcessError. The CalledProcessError object will have the return code
381     in the returncode attribute, and output & stderr attributes if those streams
382     were captured.
383
384     If timeout is given, and the process takes too long, a TimeoutExpired
385     exception will be raised.
386
387     There is an optional argument "input", allowing you to
388     pass a string to the subprocess's stdin.  If you use this argument
389     you may not also use the Popen constructor's "stdin" argument, as
390     it will be used internally.
391
392     The other arguments are the same as for the Popen constructor.
393
394     If universal_newlines=True is passed, the "input" argument must be a
395     string and stdout/stderr in the returned object will be strings rather than
396     bytes.
397     """
398     if input is not None:
399         if 'stdin' in kwargs:
400             raise ValueError('stdin and input arguments may not both be used.')
401         kwargs['stdin'] = PIPE
402
403     with Popen(*popenargs, **kwargs) as process:
404         try:
405             stdout, stderr = process.communicate(input, timeout=timeout)
406         except TimeoutExpired:
407             process.kill()
408             stdout, stderr = process.communicate()
409             raise TimeoutExpired(process.args, timeout, output=stdout,
410                                  stderr=stderr)
411         except:
412             process.kill()
413             process.wait()
414             raise
415         retcode = process.poll()
416         if check and retcode:
417             raise CalledProcessError(retcode, process.args,
418                                      output=stdout, stderr=stderr)
419     return CompletedProcess(process.args, retcode, stdout, stderr)
420
421
422 def list2cmdline(seq):
423     """
424     Translate a sequence of arguments into a command line
425     string, using the same rules as the MS C runtime:
426
427     1) Arguments are delimited by white space, which is either a
428        space or a tab.
429
430     2) A string surrounded by double quotation marks is
431        interpreted as a single argument, regardless of white space
432        contained within.  A quoted string can be embedded in an
433        argument.
434
435     3) A double quotation mark preceded by a backslash is
436        interpreted as a literal double quotation mark.
437
438     4) Backslashes are interpreted literally, unless they
439        immediately precede a double quotation mark.
440
441     5) If backslashes immediately precede a double quotation mark,
442        every pair of backslashes is interpreted as a literal
443        backslash.  If the number of backslashes is odd, the last
444        backslash escapes the next double quotation mark as
445        described in rule 3.
446     """
447
448     # See
449     # http://msdn.microsoft.com/en-us/library/17w5ykft.aspx 450     # or search http://msdn.microsoft.com for
451     # "Parsing C++ Command-Line Arguments"
452     result = []
453     needquote = False
454     for arg in seq:
455         bs_buf = []
456
457         # Add a space to separate this argument from the others
458         if result:
459             result.append(' ')
460
461         needquote = (" " in arg) or ("\t" in arg) or not arg
462         if needquote:
463             result.append('"')
464
465         for c in arg:
466             if c == '\\':
467                 # Don't know if we need to double yet.
468                 bs_buf.append(c)
469             elif c == '"':
470                 # Double backslashes.
471                 result.append('\\' * len(bs_buf)*2)
472                 bs_buf = []
473                 result.append('\\"')
474             else:
475                 # Normal char
476                 if bs_buf:
477                     result.extend(bs_buf)
478                     bs_buf = []
479                 result.append(c)
480
481         # Add remaining backslashes, if any.
482         if bs_buf:
483             result.extend(bs_buf)
484
485         if needquote:
486             result.extend(bs_buf)
487             result.append('"')
488
489     return ''.join(result)
490
491
492 # Various tools for executing commands and looking at their output and status.
493 #
494
495 def getstatusoutput(cmd):
496     """Return (exitcode, output) of executing cmd in a shell.
497
498     Execute the string 'cmd' in a shell with 'check_output' and
499     return a 2-tuple (status, output). The locale encoding is used
500     to decode the output and process newlines.
501
502     A trailing newline is stripped from the output.
503     The exit status for the command can be interpreted
504     according to the rules for the function 'wait'. Example:
505
506     >>> import subprocess
507     >>> subprocess.getstatusoutput('ls /bin/ls')
508     (0, '/bin/ls')
509     >>> subprocess.getstatusoutput('cat /bin/junk')
510     (1, 'cat: /bin/junk: No such file or directory')
511     >>> subprocess.getstatusoutput('/bin/junk')
512     (127, 'sh: /bin/junk: not found')
513     >>> subprocess.getstatusoutput('/bin/kill $$')
514     (-15, '')
515     """
516     try:
517         data = check_output(cmd, shell=True, universal_newlines=True, stderr=STDOUT)
518         exitcode = 0
519     except CalledProcessError as ex:
520         data = ex.output
521         exitcode = ex.returncode
522     if data[-1:] == '\n':
523         data = data[:-1]
524     return exitcode, data
525
526 def getoutput(cmd):
527     """Return output (stdout or stderr) of executing cmd in a shell.
528
529     Like getstatusoutput(), except the exit status is ignored and the return
530     value is a string containing the command's output.  Example:
531
532     >>> import subprocess
533     >>> subprocess.getoutput('ls /bin/ls')
534     '/bin/ls'
535     """
536     return getstatusoutput(cmd)[1]
537
538
539 _PLATFORM_DEFAULT_CLOSE_FDS = object()
540
541
542 class Popen(object):
543     """ Execute a child program in a new process.
544
545     For a complete description of the arguments see the Python documentation.
546
547     Arguments:
548       args: A string, or a sequence of program arguments.
549
550       bufsize: supplied as the buffering argument to the open() function when
551           creating the stdin/stdout/stderr pipe file objects
552
553       executable: A replacement program to execute.
554
555       stdin, stdout and stderr: These specify the executed programs' standard
556           input, standard output and standard error file handles, respectively.
557
558       preexec_fn: (POSIX only) An object to be called in the child process
559           just before the child is executed.
560
561       close_fds: Controls closing or inheriting of file descriptors.
562
563       shell: If true, the command will be executed through the shell.
564
565       cwd: Sets the current directory before the child is executed.
566
567       env: Defines the environment variables for the new process.
568
569       universal_newlines: If true, use universal line endings for file
570           objects stdin, stdout and stderr.
571
572       startupinfo and creationflags (Windows only)
573
574       restore_signals (POSIX only)
575
576       start_new_session (POSIX only)
577
578       pass_fds (POSIX only)
579
580       encoding and errors: Text mode encoding and error handling to use for
581           file objects stdin, stdout and stderr.
582
583     Attributes:
584         stdin, stdout, stderr, pid, returncode
585     """
586     _child_created = False  # Set here since __del__ checks it
587
588     def __init__(self, args, bufsize=-1, executable=None,
589                  stdin=None, stdout=None, stderr=None,
590                  preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS,
591                  shell=False, cwd=None, env=None, universal_newlines=False,
592                  startupinfo=None, creationflags=0,
593                  restore_signals=True, start_new_session=False,
594                  pass_fds=(), *, encoding=None, errors=None):
595         """Create new Popen instance."""
596         _cleanup()
597         # Held while anything is calling waitpid before returncode has been
598         # updated to prevent clobbering returncode if wait() or poll() are
599         # called from multiple threads at once.  After acquiring the lock,
600         # code must re-check self.returncode to see if another thread just
601         # finished a waitpid() call.
602         self._waitpid_lock = threading.Lock()
603
604         self._input = None
605         self._communication_started = False
606         if bufsize is None:
607             bufsize = -1  # Restore default
608         if not isinstance(bufsize, int):
609             raise TypeError("bufsize must be an integer")
610
611         if _mswindows:
612             if preexec_fn is not None:
613                 raise ValueError("preexec_fn is not supported on Windows "
614                                  "platforms")
615             any_stdio_set = (stdin is not None or stdout is not None or
616                              stderr is not None)
617             if close_fds is _PLATFORM_DEFAULT_CLOSE_FDS:
618                 if any_stdio_set:
619                     close_fds = False
620                 else:
621                     close_fds = True
622             elif close_fds and any_stdio_set:
623                 raise ValueError(
624                         "close_fds is not supported on Windows platforms"
625                         " if you redirect stdin/stdout/stderr")
626         else:
627             # POSIX
628             if close_fds is _PLATFORM_DEFAULT_CLOSE_FDS:
629                 close_fds = True
630             if pass_fds and not close_fds:
631                 warnings.warn("pass_fds overriding close_fds.", RuntimeWarning)
632                 close_fds = True
633             if startupinfo is not None:
634                 raise ValueError("startupinfo is only supported on Windows "
635                                  "platforms")
636             if creationflags != 0:
637                 raise ValueError("creationflags is only supported on Windows "
638                                  "platforms")
639
640         self.args = args
641         self.stdin = None
642         self.stdout = None
643         self.stderr = None
644         self.pid = None
645         self.returncode = None
646         self.universal_newlines = universal_newlines
647         self.encoding = encoding
648         self.errors = errors
649
650         # Input and output objects. The general principle is like
651         # this:
652         #
653         # Parent                   Child
654         # ------                   -----
655         # p2cwrite   ---stdin--->  p2cread
656         # c2pread    <--stdout---  c2pwrite
657         # errread    <--stderr---  errwrite
658         #
659         # On POSIX, the child objects are file descriptors.  On
660         # Windows, these are Windows file handles.  The parent objects
661         # are file descriptors on both platforms.  The parent objects
662         # are -1 when not using PIPEs. The child objects are -1
663         # when not redirecting.
664
665         (p2cread, p2cwrite,
666          c2pread, c2pwrite,
667          errread, errwrite) = self._get_handles(stdin, stdout, stderr)
668
669         # We wrap OS handles *before* launching the child, otherwise a
670         # quickly terminating child could make our fds unwrappable
671         # (see #8458).
672
673         if _mswindows:
674             if p2cwrite != -1:
675                 p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0)
676             if c2pread != -1:
677                 c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0)
678             if errread != -1:
679                 errread = msvcrt.open_osfhandle(errread.Detach(), 0)
680
681         text_mode = encoding or errors or universal_newlines
682
683         self._closed_child_pipe_fds = False
684
685         try:
686             if p2cwrite != -1:
687                 self.stdin = io.open(p2cwrite, 'wb', bufsize)
688                 if text_mode:
689                     self.stdin = io.TextIOWrapper(self.stdin, write_through=True,
690                             line_buffering=(bufsize == 1),
691                             encoding=encoding, errors=errors)
692             if c2pread != -1:
693                 self.stdout = io.open(c2pread, 'rb', bufsize)
694                 if text_mode:
695                     self.stdout = io.TextIOWrapper(self.stdout,
696                             encoding=encoding, errors=errors)
697             if errread != -1:
698                 self.stderr = io.open(errread, 'rb', bufsize)
699                 if text_mode:
700                     self.stderr = io.TextIOWrapper(self.stderr,
701                             encoding=encoding, errors=errors)
702
703             self._execute_child(args, executable, preexec_fn, close_fds,
704                                 pass_fds, cwd, env,
705                                 startupinfo, creationflags, shell,
706                                 p2cread, p2cwrite,
707                                 c2pread, c2pwrite,
708                                 errread, errwrite,
709                                 restore_signals, start_new_session)
710         except:
711             # Cleanup if the child failed starting.
712             for f in filter(None, (self.stdin, self.stdout, self.stderr)):
713                 try:
714                     f.close()
715                 except OSError:
716                     pass  # Ignore EBADF or other errors.
717
718             if not self._closed_child_pipe_fds:
719                 to_close = []
720                 if stdin == PIPE:
721                     to_close.append(p2cread)
722                 if stdout == PIPE:
723                     to_close.append(c2pwrite)
724                 if stderr == PIPE:
725                     to_close.append(errwrite)
726                 if hasattr(self, '_devnull'):
727                     to_close.append(self._devnull)
728                 for fd in to_close:
729                     try:
730                         if _mswindows and isinstance(fd, Handle):
731                             fd.Close()
732                         else:
733                             os.close(fd)
734                     except OSError:
735                         pass
736
737             raise
738
739     def _translate_newlines(self, data, encoding, errors):
740         data = data.decode(encoding, errors)
741         return data.replace("\r\n", "\n").replace("\r", "\n")
742
743     def __enter__(self):
744         return self
745
746     def __exit__(self, type, value, traceback):
747         if self.stdout:
748             self.stdout.close()
749         if self.stderr:
750             self.stderr.close()
751         try:  # Flushing a BufferedWriter may raise an error
752             if self.stdin:
753                 self.stdin.close()
754         finally:
755             # Wait for the process to terminate, to avoid zombies.
756             self.wait()
757
758     def __del__(self, _maxsize=sys.maxsize, _warn=warnings.warn):
759         if not self._child_created:
760             # We didn't get to successfully create a child process.
761             return
762         if self.returncode is None:
763             # Not reading subprocess exit status creates a zombi process which
764             # is only destroyed at the parent python process exit
765             _warn("subprocess %s is still running" % self.pid,
766                   ResourceWarning, source=self)
767         # In case the child hasn't been waited on, check if it's done.
768         self._internal_poll(_deadstate=_maxsize)
769         if self.returncode is None and _active is not None:
770             # Child is still running, keep us alive until we can wait on it.
771             _active.append(self)
772
773     def _get_devnull(self):
774         if not hasattr(self, '_devnull'):
775             self._devnull = os.open(os.devnull, os.O_RDWR)
776         return self._devnull
777
778     def _stdin_write(self, input):
779         if input:
780             try:
781                 self.stdin.write(input)
782             except BrokenPipeError:
783                 pass  # communicate() must ignore broken pipe errors.
784             except OSError as exc:
785                 if exc.errno == errno.EINVAL:
786                     # bpo-19612, bpo-30418: On Windows, stdin.write() fails
787                     # with EINVAL if the child process exited or if the child
788                     # process is still running but closed the pipe.
789                     pass
790                 else:
791                     raise
792
793         try:
794             self.stdin.close()
795         except BrokenPipeError:
796             pass  # communicate() must ignore broken pipe errors.
797         except OSError as exc:
798             if exc.errno == errno.EINVAL:
799                 pass
800             else:
801                 raise
802
803     def communicate(self, input=None, timeout=None):
804         """Interact with process: Send data to stdin.  Read data from
805         stdout and stderr, until end-of-file is reached.  Wait for
806         process to terminate.
807
808         The optional "input" argument should be data to be sent to the
809         child process (if self.universal_newlines is True, this should
810         be a string; if it is False, "input" should be bytes), or
811         None, if no data should be sent to the child.
812
813         communicate() returns a tuple (stdout, stderr).  These will be
814         bytes or, if self.universal_newlines was True, a string.
815         """
816
817         if self._communication_started and input:
818             raise ValueError("Cannot send input after starting communication")
819
820         # Optimization: If we are not worried about timeouts, we haven't
821         # started communicating, and we have one or zero pipes, using select()
822         # or threads is unnecessary.
823         if (timeout is None and not self._communication_started and
824             [self.stdin, self.stdout, self.stderr].count(None) >= 2):
825             stdout = None
826             stderr = None
827             if self.stdin:
828                 self._stdin_write(input)
829             elif self.stdout:
830                 stdout = self.stdout.read()
831                 self.stdout.close()
832             elif self.stderr:
833                 stderr = self.stderr.read()
834                 self.stderr.close()
835             self.wait()
836         else:
837             if timeout is not None:
838                 endtime = _time() + timeout
839             else:
840                 endtime = None
841
842             try:
843                 stdout, stderr = self._communicate(input, endtime, timeout)
844             finally:
845                 self._communication_started = True
846
847             sts = self.wait(timeout=self._remaining_time(endtime))
848
849         return (stdout, stderr)
850
851
852     def poll(self):
853         """Check if child process has terminated. Set and return returncode
854         attribute."""
855         return self._internal_poll()
856
857
858     def _remaining_time(self, endtime):
859         """Convenience for _communicate when computing timeouts."""
860         if endtime is None:
861             return None
862         else:
863             return endtime - _time()
864
865
866     def _check_timeout(self, endtime, orig_timeout):
867         """Convenience for checking if a timeout has expired."""
868         if endtime is None:
869             return
870         if _time() > endtime:
871             raise TimeoutExpired(self.args, orig_timeout)
872
873
874     if _mswindows:
875         #
876         # Windows methods
877         #
878         def _get_handles(self, stdin, stdout, stderr):
879             """Construct and return tuple with IO objects:
880             p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
881             """
882             if stdin is None and stdout is None and stderr is None:
883                 return (-1, -1, -1, -1, -1, -1)
884
885             p2cread, p2cwrite = -1, -1
886             c2pread, c2pwrite = -1, -1
887             errread, errwrite = -1, -1
888
889             if stdin is None:
890                 p2cread = _winapi.GetStdHandle(_winapi.STD_INPUT_HANDLE)
891                 if p2cread is None:
892                     p2cread, _ = _winapi.CreatePipe(None, 0)
893                     p2cread = Handle(p2cread)
894                     _winapi.CloseHandle(_)
895             elif stdin == PIPE:
896                 p2cread, p2cwrite = _winapi.CreatePipe(None, 0)
897                 p2cread, p2cwrite = Handle(p2cread), Handle(p2cwrite)
898             elif stdin == DEVNULL:
899                 p2cread = msvcrt.get_osfhandle(self._get_devnull())
900             elif isinstance(stdin, int):
901                 p2cread = msvcrt.get_osfhandle(stdin)
902             else:
903                 # Assuming file-like object
904                 p2cread = msvcrt.get_osfhandle(stdin.fileno())
905             p2cread = self._make_inheritable(p2cread)
906
907             if stdout is None:
908                 c2pwrite = _winapi.GetStdHandle(_winapi.STD_OUTPUT_HANDLE)
909                 if c2pwrite is None:
910                     _, c2pwrite = _winapi.CreatePipe(None, 0)
911                     c2pwrite = Handle(c2pwrite)
912                     _winapi.CloseHandle(_)
913             elif stdout == PIPE:
914                 c2pread, c2pwrite = _winapi.CreatePipe(None, 0)
915                 c2pread, c2pwrite = Handle(c2pread), Handle(c2pwrite)
916             elif stdout == DEVNULL:
917                 c2pwrite = msvcrt.get_osfhandle(self._get_devnull())
918             elif isinstance(stdout, int):
919                 c2pwrite = msvcrt.get_osfhandle(stdout)
920             else:
921                 # Assuming file-like object
922                 c2pwrite = msvcrt.get_osfhandle(stdout.fileno())
923             c2pwrite = self._make_inheritable(c2pwrite)
924
925             if stderr is None:
926                 errwrite = _winapi.GetStdHandle(_winapi.STD_ERROR_HANDLE)
927                 if errwrite is None:
928                     _, errwrite = _winapi.CreatePipe(None, 0)
929                     errwrite = Handle(errwrite)
930                     _winapi.CloseHandle(_)
931             elif stderr == PIPE:
932                 errread, errwrite = _winapi.CreatePipe(None, 0)
933                 errread, errwrite = Handle(errread), Handle(errwrite)
934             elif stderr == STDOUT:
935                 errwrite = c2pwrite
936             elif stderr == DEVNULL:
937                 errwrite = msvcrt.get_osfhandle(self._get_devnull())
938             elif isinstance(stderr, int):
939                 errwrite = msvcrt.get_osfhandle(stderr)
940             else:
941                 # Assuming file-like object
942                 errwrite = msvcrt.get_osfhandle(stderr.fileno())
943             errwrite = self._make_inheritable(errwrite)
944
945             return (p2cread, p2cwrite,
946                     c2pread, c2pwrite,
947                     errread, errwrite)
948
949
950         def _make_inheritable(self, handle):
951             """Return a duplicate of handle, which is inheritable"""
952             h = _winapi.DuplicateHandle(
953                 _winapi.GetCurrentProcess(), handle,
954                 _winapi.GetCurrentProcess(), 0, 1,
955                 _winapi.DUPLICATE_SAME_ACCESS)
956             return Handle(h)
957
958
959         def _execute_child(self, args, executable, preexec_fn, close_fds,
960                            pass_fds, cwd, env,
961                            startupinfo, creationflags, shell,
962                            p2cread, p2cwrite,
963                            c2pread, c2pwrite,
964                            errread, errwrite,
965                            unused_restore_signals, unused_start_new_session):
966             """Execute program (MS Windows version)"""
967
968             assert not pass_fds, "pass_fds not supported on Windows."
969
970             if not isinstance(args, str):
971                 args = list2cmdline(args)
972
973             # Process startup details
974             if startupinfo is None:
975                 startupinfo = STARTUPINFO()
976             if -1 not in (p2cread, c2pwrite, errwrite):
977                 startupinfo.dwFlags |= _winapi.STARTF_USESTDHANDLES
978                 startupinfo.hStdInput = p2cread
979                 startupinfo.hStdOutput = c2pwrite
980                 startupinfo.hStdError = errwrite
981
982             if shell:
983                 startupinfo.dwFlags |= _winapi.STARTF_USESHOWWINDOW
984                 startupinfo.wShowWindow = _winapi.SW_HIDE
985                 comspec = os.environ.get("COMSPEC", "cmd.exe")
986                 args = '{} /c "{}"'.format (comspec, args)
987
988             # Start the process
989             try:
990                 hp, ht, pid, tid = _winapi.CreateProcess(executable, args,
991                                          # no special security
992                                          None, None,
993                                          int(not close_fds),
994                                          creationflags,
995                                          env,
996                                          os.fspath(cwd) if cwd is not None else None,
997                                          startupinfo)
998             finally:
999                 # Child is launched. Close the parent's copy of those pipe
1000                 # handles that only the child should have open.  You need
1001                 # to make sure that no handles to the write end of the
1002                 # output pipe are maintained in this process or else the
1003                 # pipe will not close when the child process exits and the
1004                 # ReadFile will hang.
1005                 if p2cread != -1:
1006                     p2cread.Close()
1007                 if c2pwrite != -1:
1008                     c2pwrite.Close()
1009                 if errwrite != -1:
1010                     errwrite.Close()
1011                 if hasattr(self, '_devnull'):
1012                     os.close(self._devnull)
1013                 # Prevent a double close of these handles/fds from __init__
1014                 # on error.
1015                 self._closed_child_pipe_fds = True
1016
1017             # Retain the process handle, but close the thread handle
1018             self._child_created = True
1019             self._handle = Handle(hp)
1020             self.pid = pid
1021             _winapi.CloseHandle(ht)
1022
1023         def _internal_poll(self, _deadstate=None,
1024                 _WaitForSingleObject=_winapi.WaitForSingleObject,
1025                 _WAIT_OBJECT_0=_winapi.WAIT_OBJECT_0,
1026                 _GetExitCodeProcess=_winapi.GetExitCodeProcess):
1027             """Check if child process has terminated.  Returns returncode
1028             attribute.
1029
1030             This method is called by __del__, so it can only refer to objects
1031             in its local scope.
1032
1033             """
1034             if self.returncode is None:
1035                 if _WaitForSingleObject(self._handle, 0) == _WAIT_OBJECT_0:
1036                     self.returncode = _GetExitCodeProcess(self._handle)
1037             return self.returncode
1038
1039
1040         def wait(self, timeout=None, endtime=None):
1041             """Wait for child process to terminate.  Returns returncode
1042             attribute."""
1043             if endtime is not None:
1044                 warnings.warn(
1045                     "'endtime' argument is deprecated; use 'timeout'.",
1046                     DeprecationWarning,
1047                     stacklevel=2)
1048                 timeout = self._remaining_time(endtime)
1049             if timeout is None:
1050                 timeout_millis = _winapi.INFINITE
1051             else:
1052                 timeout_millis = int(timeout * 1000)
1053             if self.returncode is None:
1054                 result = _winapi.WaitForSingleObject(self._handle,
1055                                                     timeout_millis)
1056                 if result == _winapi.WAIT_TIMEOUT:
1057                     raise TimeoutExpired(self.args, timeout)
1058                 self.returncode = _winapi.GetExitCodeProcess(self._handle)
1059             return self.returncode
1060
1061
1062         def _readerthread(self, fh, buffer):
1063             buffer.append(fh.read())
1064             fh.close()
1065
1066
1067         def _communicate(self, input, endtime, orig_timeout):
1068             # Start reader threads feeding into a list hanging off of this
1069             # object, unless they've already been started.
1070             if self.stdout and not hasattr(self, "_stdout_buff"):
1071                 self._stdout_buff = []
1072                 self.stdout_thread = \
1073                         threading.Thread(target=self._readerthread,
1074                                          args=(self.stdout, self._stdout_buff))
1075                 self.stdout_thread.daemon = True
1076                 self.stdout_thread.start()
1077             if self.stderr and not hasattr(self, "_stderr_buff"):
1078                 self._stderr_buff = []
1079                 self.stderr_thread = \
1080                         threading.Thread(target=self._readerthread,
1081                                          args=(self.stderr, self._stderr_buff))
1082                 self.stderr_thread.daemon = True
1083                 self.stderr_thread.start()
1084
1085             if self.stdin:
1086                 self._stdin_write(input)
1087
1088             # Wait for the reader threads, or time out.  If we time out, the
1089             # threads remain reading and the fds left open in case the user
1090             # calls communicate again.
1091             if self.stdout is not None:
1092                 self.stdout_thread.join(self._remaining_time(endtime))
1093                 if self.stdout_thread.is_alive():
1094                     raise TimeoutExpired(self.args, orig_timeout)
1095             if self.stderr is not None:
1096                 self.stderr_thread.join(self._remaining_time(endtime))
1097                 if self.stderr_thread.is_alive():
1098                     raise TimeoutExpired(self.args, orig_timeout)
1099
1100             # Collect the output from and close both pipes, now that we know
1101             # both have been read successfully.
1102             stdout = None
1103             stderr = None
1104             if self.stdout:
1105                 stdout = self._stdout_buff
1106                 self.stdout.close()
1107             if self.stderr:
1108                 stderr = self._stderr_buff
1109                 self.stderr.close()
1110
1111             # All data exchanged.  Translate lists into strings.
1112             if stdout is not None:
1113                 stdout = stdout[0]
1114             if stderr is not None:
1115                 stderr = stderr[0]
1116
1117             return (stdout, stderr)
1118
1119         def send_signal(self, sig):
1120             """Send a signal to the process."""
1121             # Don't signal a process that we know has already died.
1122             if self.returncode is not None:
1123                 return
1124             if sig == signal.SIGTERM:
1125                 self.terminate()
1126             elif sig == signal.CTRL_C_EVENT:
1127                 os.kill(self.pid, signal.CTRL_C_EVENT)
1128             elif sig == signal.CTRL_BREAK_EVENT:
1129                 os.kill(self.pid, signal.CTRL_BREAK_EVENT)
1130             else:
1131                 raise ValueError("Unsupported signal: {}".format(sig))
1132
1133         def terminate(self):
1134             """Terminates the process."""
1135             # Don't terminate a process that we know has already died.
1136             if self.returncode is not None:
1137                 return
1138             try:
1139                 _winapi.TerminateProcess(self._handle, 1)
1140             except PermissionError:
1141                 # ERROR_ACCESS_DENIED (winerror 5) is received when the
1142                 # process already died.
1143                 rc = _winapi.GetExitCodeProcess(self._handle)
1144                 if rc == _winapi.STILL_ACTIVE:
1145                     raise
1146                 self.returncode = rc
1147
1148         kill = terminate
1149
1150     else:
1151         #
1152         # POSIX methods
1153         #
1154         def _get_handles(self, stdin, stdout, stderr):
1155             """Construct and return tuple with IO objects:
1156             p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
1157             """
1158             p2cread, p2cwrite = -1, -1
1159             c2pread, c2pwrite = -1, -1
1160             errread, errwrite = -1, -1
1161
1162             if stdin is None:
1163                 pass
1164             elif stdin == PIPE:
1165                 p2cread, p2cwrite = os.pipe()
1166             elif stdin == DEVNULL:
1167                 p2cread = self._get_devnull()
1168             elif isinstance(stdin, int):
1169                 p2cread = stdin
1170             else:
1171                 # Assuming file-like object
1172                 p2cread = stdin.fileno()
1173
1174             if stdout is None:
1175                 pass
1176             elif stdout == PIPE:
1177                 c2pread, c2pwrite = os.pipe()
1178             elif stdout == DEVNULL:
1179                 c2pwrite = self._get_devnull()
1180             elif isinstance(stdout, int):
1181                 c2pwrite = stdout
1182             else:
1183                 # Assuming file-like object
1184                 c2pwrite = stdout.fileno()
1185
1186             if stderr is None:
1187                 pass
1188             elif stderr == PIPE:
1189                 errread, errwrite = os.pipe()
1190             elif stderr == STDOUT:
1191                 if c2pwrite != -1:
1192                     errwrite = c2pwrite
1193                 else: # child's stdout is not set, use parent's stdout
1194                     errwrite = sys.__stdout__.fileno()
1195             elif stderr == DEVNULL:
1196                 errwrite = self._get_devnull()
1197             elif isinstance(stderr, int):
1198                 errwrite = stderr
1199             else:
1200                 # Assuming file-like object
1201                 errwrite = stderr.fileno()
1202
1203             return (p2cread, p2cwrite,
1204                     c2pread, c2pwrite,
1205                     errread, errwrite)
1206
1207
1208         def _execute_child(self, args, executable, preexec_fn, close_fds,
1209                            pass_fds, cwd, env,
1210                            startupinfo, creationflags, shell,
1211                            p2cread, p2cwrite,
1212                            c2pread, c2pwrite,
1213                            errread, errwrite,
1214                            restore_signals, start_new_session):
1215             """Execute program (POSIX version)"""
1216
1217             if isinstance(args, (str, bytes)):
1218                 args = [args]
1219             else:
1220                 args = list(args)
1221
1222             if shell:
1223                 args = ["/bin/sh", "-c"] + args
1224                 if executable:
1225                     args[0] = executable
1226
1227             if executable is None:
1228                 executable = args[0]
1229             orig_executable = executable
1230
1231             # For transferring possible exec failure from child to parent.
1232             # Data format: "exception name:hex errno:description"
1233             # Pickle is not used; it is complex and involves memory allocation.
1234             errpipe_read, errpipe_write = os.pipe()
1235             # errpipe_write must not be in the standard io 0, 1, or 2 fd range.
1236             low_fds_to_close = []
1237             while errpipe_write < 3:
1238                 low_fds_to_close.append(errpipe_write)
1239                 errpipe_write = os.dup(errpipe_write)
1240             for low_fd in low_fds_to_close:
1241                 os.close(low_fd)
1242             try:
1243                 try:
1244                     # We must avoid complex work that could involve
1245                     # malloc or free in the child process to avoid
1246                     # potential deadlocks, thus we do all this here.
1247                     # and pass it to fork_exec()
1248
1249                     if env is not None:
1250                         env_list = []
1251                         for k, v in env.items():
1252                             k = os.fsencode(k)
1253                             if b'=' in k:
1254                                 raise ValueError("illegal environment variable name")
1255                             env_list.append(k + b'=' + os.fsencode(v))
1256                     else:
1257                         env_list = None  # Use execv instead of execve.
1258                     executable = os.fsencode(executable)
1259                     if os.path.dirname(executable):
1260                         executable_list = (executable,)
1261                     else:
1262                         # This matches the behavior of os._execvpe().
1263                         executable_list = tuple(
1264                             os.path.join(os.fsencode(dir), executable)
1265                             for dir in os.get_exec_path(env))
1266                     fds_to_keep = set(pass_fds)
1267                     fds_to_keep.add(errpipe_write)
1268                     self.pid = _posixsubprocess.fork_exec(
1269                             args, executable_list,
1270                             close_fds, tuple(sorted(map(int, fds_to_keep))),
1271                             cwd, env_list,
1272                             p2cread, p2cwrite, c2pread, c2pwrite,
1273                             errread, errwrite,
1274                             errpipe_read, errpipe_write,
1275                             restore_signals, start_new_session, preexec_fn)
1276                     self._child_created = True
1277                 finally:
1278                     # be sure the FD is closed no matter what
1279                     os.close(errpipe_write)
1280
1281                 # self._devnull is not always defined.
1282                 devnull_fd = getattr(self, '_devnull', None)
1283                 if p2cread != -1 and p2cwrite != -1 and p2cread != devnull_fd:
1284                     os.close(p2cread)
1285                 if c2pwrite != -1 and c2pread != -1 and c2pwrite != devnull_fd:
1286                     os.close(c2pwrite)
1287                 if errwrite != -1 and errread != -1 and errwrite != devnull_fd:
1288                     os.close(errwrite)
1289                 if devnull_fd is not None:
1290                     os.close(devnull_fd)
1291                 # Prevent a double close of these fds from __init__ on error.
1292                 self._closed_child_pipe_fds = True
1293
1294                 # Wait for exec to fail or succeed; possibly raising an
1295                 # exception (limited in size)
1296                 errpipe_data = bytearray()
1297                 while True:
1298                     part = os.read(errpipe_read, 50000)
1299                     errpipe_data += part
1300                     if not part or len(errpipe_data) > 50000:
1301                         break
1302             finally:
1303                 # be sure the FD is closed no matter what
1304                 os.close(errpipe_read)
1305
1306             if errpipe_data:
1307                 try:
1308                     pid, sts = os.waitpid(self.pid, 0)
1309                     if pid == self.pid:
1310                         self._handle_exitstatus(sts)
1311                     else:
1312                         self.returncode = sys.maxsize
1313                 except ChildProcessError:
1314                     pass
1315
1316                 try:
1317                     exception_name, hex_errno, err_msg = (
1318                             errpipe_data.split(b':', 2))
1319                     # The encoding here should match the encoding
1320                     # written in by the subprocess implementations
1321                     # like _posixsubprocess
1322                     err_msg = err_msg.decode()
1323                 except ValueError:
1324                     exception_name = b'SubprocessError'
1325                     hex_errno = b'0'
1326                     err_msg = 'Bad exception data from child: {!r}'.format(
1327                                   bytes(errpipe_data))
1328                 child_exception_type = getattr(
1329                         builtins, exception_name.decode('ascii'),
1330                         SubprocessError)
1331                 if issubclass(child_exception_type, OSError) and hex_errno:
1332                     errno_num = int(hex_errno, 16)
1333                     child_exec_never_called = (err_msg == "noexec")
1334                     if child_exec_never_called:
1335                         err_msg = ""
1336                         # The error must be from chdir(cwd).
1337                         err_filename = cwd
1338                     else:
1339                         err_filename = orig_executable
1340                     if errno_num != 0:
1341                         err_msg = os.strerror(errno_num)
1342                         if errno_num == errno.ENOENT:
1343                             err_msg += ': ' + repr(err_filename)
1344                     raise child_exception_type(errno_num, err_msg, err_filename)
1345                 raise child_exception_type(err_msg)
1346
1347
1348         def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED,
1349                 _WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED,
1350                 _WEXITSTATUS=os.WEXITSTATUS, _WIFSTOPPED=os.WIFSTOPPED,
1351                 _WSTOPSIG=os.WSTOPSIG):
1352             """All callers to this function MUST hold self._waitpid_lock."""
1353             # This method is called (indirectly) by __del__, so it cannot
1354             # refer to anything outside of its local scope.
1355             if _WIFSIGNALED(sts):
1356                 self.returncode = -_WTERMSIG(sts)
1357             elif _WIFEXITED(sts):
1358                 self.returncode = _WEXITSTATUS(sts)
1359             elif _WIFSTOPPED(sts):
1360                 self.returncode = -_WSTOPSIG(sts)
1361             else:
1362                 # Should never happen
1363                 raise SubprocessError("Unknown child exit status!")
1364
1365
1366         def _internal_poll(self, _deadstate=None, _waitpid=os.waitpid,
1367                 _WNOHANG=os.WNOHANG, _ECHILD=errno.ECHILD):
1368             """Check if child process has terminated.  Returns returncode
1369             attribute.
1370
1371             This method is called by __del__, so it cannot reference anything
1372             outside of the local scope (nor can any methods it calls).
1373
1374             """
1375             if self.returncode is None:
1376                 if not self._waitpid_lock.acquire(False):
1377                     # Something else is busy calling waitpid.  Don't allow two
1378                     # at once.  We know nothing yet.
1379                     return None
1380                 try:
1381                     if self.returncode is not None:
1382                         return self.returncode  # Another thread waited.
1383                     pid, sts = _waitpid(self.pid, _WNOHANG)
1384                     if pid == self.pid:
1385                         self._handle_exitstatus(sts)
1386                 except OSError as e:
1387                     if _deadstate is not None:
1388                         self.returncode = _deadstate
1389                     elif e.errno == _ECHILD:
1390                         # This happens if SIGCLD is set to be ignored or
1391                         # waiting for child processes has otherwise been
1392                         # disabled for our process.  This child is dead, we
1393                         # can't get the status.
1394                         # http://bugs.python.org/issue15756 1395                         self.returncode = 0
1396                 finally:
1397                     self._waitpid_lock.release()
1398             return self.returncode
1399
1400
1401         def _try_wait(self, wait_flags):
1402             """All callers to this function MUST hold self._waitpid_lock."""
1403             try:
1404                 (pid, sts) = os.waitpid(self.pid, wait_flags)
1405             except ChildProcessError:
1406                 # This happens if SIGCLD is set to be ignored or waiting
1407                 # for child processes has otherwise been disabled for our
1408                 # process.  This child is dead, we can't get the status.
1409                 pid = self.pid
1410                 sts = 0
1411             return (pid, sts)
1412
1413
1414         def wait(self, timeout=None, endtime=None):
1415             """Wait for child process to terminate.  Returns returncode
1416             attribute."""
1417             if self.returncode is not None:
1418                 return self.returncode
1419
1420             if endtime is not None:
1421                 warnings.warn(
1422                     "'endtime' argument is deprecated; use 'timeout'.",
1423                     DeprecationWarning,
1424                     stacklevel=2)
1425             if endtime is not None or timeout is not None:
1426                 if endtime is None:
1427                     endtime = _time() + timeout
1428                 elif timeout is None:
1429                     timeout = self._remaining_time(endtime)
1430
1431             if endtime is not None:
1432                 # Enter a busy loop if we have a timeout.  This busy loop was
1433                 # cribbed from Lib/threading.py in Thread.wait() at r71065.
1434                 delay = 0.0005 # 500 us -> initial delay of 1 ms
1435                 while True:
1436                     if self._waitpid_lock.acquire(False):
1437                         try:
1438                             if self.returncode is not None:
1439                                 break  # Another thread waited.
1440                             (pid, sts) = self._try_wait(os.WNOHANG)
1441                             assert pid == self.pid or pid == 0
1442                             if pid == self.pid:
1443                                 self._handle_exitstatus(sts)
1444                                 break
1445                         finally:
1446                             self._waitpid_lock.release()
1447                     remaining = self._remaining_time(endtime)
1448                     if remaining <= 0:
1449                         raise TimeoutExpired(self.args, timeout)
1450                     delay = min(delay * 2, remaining, .05)
1451                     time.sleep(delay)
1452             else:
1453                 while self.returncode is None:
1454                     with self._waitpid_lock:
1455                         if self.returncode is not None:
1456                             break  # Another thread waited.
1457                         (pid, sts) = self._try_wait(0)
1458                         # Check the pid and loop as waitpid has been known to
1459                         # return 0 even without WNOHANG in odd situations.
1460                         # http://bugs.python.org/issue14396. 1461                         if pid == self.pid:
1462                             self._handle_exitstatus(sts)
1463             return self.returncode
1464
1465
1466         def _communicate(self, input, endtime, orig_timeout):
1467             if self.stdin and not self._communication_started:
1468                 # Flush stdio buffer.  This might block, if the user has
1469                 # been writing to .stdin in an uncontrolled fashion.
1470                 try:
1471                     self.stdin.flush()
1472                 except BrokenPipeError:
1473                     pass  # communicate() must ignore BrokenPipeError.
1474                 if not input:
1475                     try:
1476                         self.stdin.close()
1477                     except BrokenPipeError:
1478                         pass  # communicate() must ignore BrokenPipeError.
1479
1480             stdout = None
1481             stderr = None
1482
1483             # Only create this mapping if we haven't already.
1484             if not self._communication_started:
1485                 self._fileobj2output = {}
1486                 if self.stdout:
1487                     self._fileobj2output[self.stdout] = []
1488                 if self.stderr:
1489                     self._fileobj2output[self.stderr] = []
1490
1491             if self.stdout:
1492                 stdout = self._fileobj2output[self.stdout]
1493             if self.stderr:
1494                 stderr = self._fileobj2output[self.stderr]
1495
1496             self._save_input(input)
1497
1498             if self._input:
1499                 input_view = memoryview(self._input)
1500
1501             with _PopenSelector() as selector:
1502                 if self.stdin and input:
1503                     selector.register(self.stdin, selectors.EVENT_WRITE)
1504                 if self.stdout:
1505                     selector.register(self.stdout, selectors.EVENT_READ)
1506                 if self.stderr:
1507                     selector.register(self.stderr, selectors.EVENT_READ)
1508
1509                 while selector.get_map():
1510                     timeout = self._remaining_time(endtime)
1511                     if timeout is not None and timeout < 0:
1512                         raise TimeoutExpired(self.args, orig_timeout)
1513
1514                     ready = selector.select(timeout)
1515                     self._check_timeout(endtime, orig_timeout)
1516
1517                     # XXX Rewrite these to use non-blocking I/O on the file
1518                     # objects; they are no longer using C stdio!
1519
1520                     for key, events in ready:
1521                         if key.fileobj is self.stdin:
1522                             chunk = input_view[self._input_offset :
1523                                                self._input_offset + _PIPE_BUF]
1524                             try:
1525                                 self._input_offset += os.write(key.fd, chunk)
1526                             except BrokenPipeError:
1527                                 selector.unregister(key.fileobj)
1528                                 key.fileobj.close()
1529                             else:
1530                                 if self._input_offset >= len(self._input):
1531                                     selector.unregister(key.fileobj)
1532                                     key.fileobj.close()
1533                         elif key.fileobj in (self.stdout, self.stderr):
1534                             data = os.read(key.fd, 32768)
1535                             if not data:
1536                                 selector.unregister(key.fileobj)
1537                                 key.fileobj.close()
1538                             self._fileobj2output[key.fileobj].append(data)
1539
1540             self.wait(timeout=self._remaining_time(endtime))
1541
1542             # All data exchanged.  Translate lists into strings.
1543             if stdout is not None:
1544                 stdout = b''.join(stdout)
1545             if stderr is not None:
1546                 stderr = b''.join(stderr)
1547
1548             # Translate newlines, if requested.
1549             # This also turns bytes into strings.
1550             if self.encoding or self.errors or self.universal_newlines:
1551                 if stdout is not None:
1552                     stdout = self._translate_newlines(stdout,
1553                                                       self.stdout.encoding,
1554                                                       self.stdout.errors)
1555                 if stderr is not None:
1556                     stderr = self._translate_newlines(stderr,
1557                                                       self.stderr.encoding,
1558                                                       self.stderr.errors)
1559
1560             return (stdout, stderr)
1561
1562
1563         def _save_input(self, input):
1564             # This method is called from the _communicate_with_*() methods
1565             # so that if we time out while communicating, we can continue
1566             # sending input if we retry.
1567             if self.stdin and self._input is None:
1568                 self._input_offset = 0
1569                 self._input = input
1570                 if input is not None and (
1571                     self.encoding or self.errors or self.universal_newlines):
1572                     self._input = self._input.encode(self.stdin.encoding,
1573                                                      self.stdin.errors)
1574
1575
1576         def send_signal(self, sig):
1577             """Send a signal to the process."""
1578             # Skip signalling a process that we know has already died.
1579             if self.returncode is None:
1580                 os.kill(self.pid, sig)
1581
1582         def terminate(self):
1583             """Terminate the process with SIGTERM
1584             """
1585             self.send_signal(signal.SIGTERM)
1586
1587         def kill(self):
1588             """Kill the process with SIGKILL
1589             """
1590             self.send_signal(signal.SIGKILL)