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 ' 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 ' 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 ") 322 b'when in the course of barman events ' 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 (" " 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:] == ' ': 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(" ", " ").replace(" ", " ") 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)