1 # subprocess - Subprocesses with accessible I/O streams 2 # 3 # For more information about this module, see PEP 324. 4 # 5 # This module should remain compatible with Python 2.2, see PEP 291. 6 # 7 # Copyright (c) 2003-2005 by Peter Astrand <astrand (at] lysator.liu.se> 8 # 9 # Licensed to PSF under a Contributor Agreement. 10 # See http://www.python.org/2.4/license for licensing details. 11 12 r"""subprocess - Subprocesses with accessible I/O streams 13 14 This module allows you to spawn processes, connect to their 15 input/output/error pipes, and obtain their return codes. This module 16 intends to replace several other, older modules and functions, like: 17 18 os.system 19 os.spawn* 20 os.popen* 21 popen2.* 22 commands.* 23 24 Information about how the subprocess module can be used to replace these 25 modules and functions can be found below. 26 27 28 29 Using the subprocess module 30 =========================== 31 This module defines one class called Popen: 32 33 class Popen(args, bufsize=0, executable=None, 34 stdin=None, stdout=None, stderr=None, 35 preexec_fn=None, close_fds=False, shell=False, 36 cwd=None, env=None, universal_newlines=False, 37 startupinfo=None, creationflags=0): 38 39 40 Arguments are: 41 42 args should be a string, or a sequence of program arguments. The 43 program to execute is normally the first item in the args sequence or 44 string, but can be explicitly set by using the executable argument. 45 46 On UNIX, with shell=False (default): In this case, the Popen class 47 uses os.execvp() to execute the child program. args should normally 48 be a sequence. A string will be treated as a sequence with the string 49 as the only item (the program to execute). 50 51 On UNIX, with shell=True: If args is a string, it specifies the 52 command string to execute through the shell. If args is a sequence, 53 the first item specifies the command string, and any additional items 54 will be treated as additional shell arguments. 55 56 On Windows: the Popen class uses CreateProcess() to execute the child 57 program, which operates on strings. If args is a sequence, it will be 58 converted to a string using the list2cmdline method. Please note that 59 not all MS Windows applications interpret the command line the same 60 way: The list2cmdline is designed for applications using the same 61 rules as the MS C runtime. 62 63 bufsize, if given, has the same meaning as the corresponding argument 64 to the built-in open() function: 0 means unbuffered, 1 means line 65 buffered, any other positive value means use a buffer of 66 (approximately) that size. A negative bufsize means to use the system 67 default, which usually means fully buffered. The default value for 68 bufsize is 0 (unbuffered). 69 70 stdin, stdout and stderr specify the executed programs' standard 71 input, standard output and standard error file handles, respectively. 72 Valid values are PIPE, an existing file descriptor (a positive 73 integer), an existing file object, and None. PIPE indicates that a 74 new pipe to the child should be created. With None, no redirection 75 will occur; the child's file handles will be inherited from the 76 parent. Additionally, stderr can be STDOUT, which indicates that the 77 stderr data from the applications should be captured into the same 78 file handle as for stdout. 79 80 If preexec_fn is set to a callable object, this object will be called 81 in the child process just before the child is executed. 82 83 If close_fds is true, all file descriptors except 0, 1 and 2 will be 84 closed before the child process is executed. 85 86 if shell is true, the specified command will be executed through the 87 shell. 88 89 If cwd is not None, the current directory will be changed to cwd 90 before the child is executed. 91 92 If env is not None, it defines the environment variables for the new 93 process. 94 95 If universal_newlines is true, the file objects stdout and stderr are 96 opened as a text files, but lines may be terminated by any of '\n', 97 the Unix end-of-line convention, '\r', the Macintosh convention or 98 '\r\n', the Windows convention. All of these external representations 99 are seen as '\n' by the Python program. Note: This feature is only 100 available if Python is built with universal newline support (the 101 default). Also, the newlines attribute of the file objects stdout, 102 stdin and stderr are not updated by the communicate() method. 103 104 The startupinfo and creationflags, if given, will be passed to the 105 underlying CreateProcess() function. They can specify things such as 106 appearance of the main window and priority for the new process. 107 (Windows only) 108 109 110 This module also defines some shortcut functions: 111 112 call(*popenargs, **kwargs): 113 Run command with arguments. Wait for command to complete, then 114 return the returncode attribute. 115 116 The arguments are the same as for the Popen constructor. Example: 117 118 retcode = call(["ls", "-l"]) 119 120 check_call(*popenargs, **kwargs): 121 Run command with arguments. Wait for command to complete. If the 122 exit code was zero then return, otherwise raise 123 CalledProcessError. The CalledProcessError object will have the 124 return code in the returncode attribute. 125 126 The arguments are the same as for the Popen constructor. Example: 127 128 check_call(["ls", "-l"]) 129 130 check_output(*popenargs, **kwargs): 131 Run command with arguments and return its output as a byte string. 132 133 If the exit code was non-zero it raises a CalledProcessError. The 134 CalledProcessError object will have the return code in the returncode 135 attribute and output in the output attribute. 136 137 The arguments are the same as for the Popen constructor. Example: 138 139 output = check_output(["ls", "-l", "/dev/null"]) 140 141 142 Exceptions 143 ---------- 144 Exceptions raised in the child process, before the new program has 145 started to execute, will be re-raised in the parent. Additionally, 146 the exception object will have one extra attribute called 147 'child_traceback', which is a string containing traceback information 148 from the childs point of view. 149 150 The most common exception raised is OSError. This occurs, for 151 example, when trying to execute a non-existent file. Applications 152 should prepare for OSErrors. 153 154 A ValueError will be raised if Popen is called with invalid arguments. 155 156 check_call() and check_output() will raise CalledProcessError, if the 157 called process returns a non-zero return code. 158 159 160 Security 161 -------- 162 Unlike some other popen functions, this implementation will never call 163 /bin/sh implicitly. This means that all characters, including shell 164 metacharacters, can safely be passed to child processes. 165 166 167 Popen objects 168 ============= 169 Instances of the Popen class have the following methods: 170 171 poll() 172 Check if child process has terminated. Returns returncode 173 attribute. 174 175 wait() 176 Wait for child process to terminate. Returns returncode attribute. 177 178 communicate(input=None) 179 Interact with process: Send data to stdin. Read data from stdout 180 and stderr, until end-of-file is reached. Wait for process to 181 terminate. The optional input argument should be a string to be 182 sent to the child process, or None, if no data should be sent to 183 the child. 184 185 communicate() returns a tuple (stdout, stderr). 186 187 Note: The data read is buffered in memory, so do not use this 188 method if the data size is large or unlimited. 189 190 The following attributes are also available: 191 192 stdin 193 If the stdin argument is PIPE, this attribute is a file object 194 that provides input to the child process. Otherwise, it is None. 195 196 stdout 197 If the stdout argument is PIPE, this attribute is a file object 198 that provides output from the child process. Otherwise, it is 199 None. 200 201 stderr 202 If the stderr argument is PIPE, this attribute is file object that 203 provides error output from the child process. Otherwise, it is 204 None. 205 206 pid 207 The process ID of the child process. 208 209 returncode 210 The child return code. A None value indicates that the process 211 hasn't terminated yet. A negative value -N indicates that the 212 child was terminated by signal N (UNIX only). 213 214 215 Replacing older functions with the subprocess module 216 ==================================================== 217 In this section, "a ==> b" means that b can be used as a replacement 218 for a. 219 220 Note: All functions in this section fail (more or less) silently if 221 the executed program cannot be found; this module raises an OSError 222 exception. 223 224 In the following examples, we assume that the subprocess module is 225 imported with "from subprocess import *". 226 227 228 Replacing /bin/sh shell backquote 229 --------------------------------- 230 output=`mycmd myarg` 231 ==> 232 output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0] 233 234 235 Replacing shell pipe line 236 ------------------------- 237 output=`dmesg | grep hda` 238 ==> 239 p1 = Popen(["dmesg"], stdout=PIPE) 240 p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE) 241 output = p2.communicate()[0] 242 243 244 Replacing os.system() 245 --------------------- 246 sts = os.system("mycmd" + " myarg") 247 ==> 248 p = Popen("mycmd" + " myarg", shell=True) 249 pid, sts = os.waitpid(p.pid, 0) 250 251 Note: 252 253 * Calling the program through the shell is usually not required. 254 255 * It's easier to look at the returncode attribute than the 256 exitstatus. 257 258 A more real-world example would look like this: 259 260 try: 261 retcode = call("mycmd" + " myarg", shell=True) 262 if retcode < 0: 263 print >>sys.stderr, "Child was terminated by signal", -retcode 264 else: 265 print >>sys.stderr, "Child returned", retcode 266 except OSError, e: 267 print >>sys.stderr, "Execution failed:", e 268 269 270 Replacing os.spawn* 271 ------------------- 272 P_NOWAIT example: 273 274 pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg") 275 ==> 276 pid = Popen(["/bin/mycmd", "myarg"]).pid 277 278 279 P_WAIT example: 280 281 retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg") 282 ==> 283 retcode = call(["/bin/mycmd", "myarg"]) 284 285 286 Vector example: 287 288 os.spawnvp(os.P_NOWAIT, path, args) 289 ==> 290 Popen([path] + args[1:]) 291 292 293 Environment example: 294 295 os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env) 296 ==> 297 Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"}) 298 299 300 Replacing os.popen* 301 ------------------- 302 pipe = os.popen("cmd", mode='r', bufsize) 303 ==> 304 pipe = Popen("cmd", shell=True, bufsize=bufsize, stdout=PIPE).stdout 305 306 pipe = os.popen("cmd", mode='w', bufsize) 307 ==> 308 pipe = Popen("cmd", shell=True, bufsize=bufsize, stdin=PIPE).stdin 309 310 311 (child_stdin, child_stdout) = os.popen2("cmd", mode, bufsize) 312 ==> 313 p = Popen("cmd", shell=True, bufsize=bufsize, 314 stdin=PIPE, stdout=PIPE, close_fds=True) 315 (child_stdin, child_stdout) = (p.stdin, p.stdout) 316 317 318 (child_stdin, 319 child_stdout, 320 child_stderr) = os.popen3("cmd", mode, bufsize) 321 ==> 322 p = Popen("cmd", shell=True, bufsize=bufsize, 323 stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True) 324 (child_stdin, 325 child_stdout, 326 child_stderr) = (p.stdin, p.stdout, p.stderr) 327 328 329 (child_stdin, child_stdout_and_stderr) = os.popen4("cmd", mode, 330 bufsize) 331 ==> 332 p = Popen("cmd", shell=True, bufsize=bufsize, 333 stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True) 334 (child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout) 335 336 On Unix, os.popen2, os.popen3 and os.popen4 also accept a sequence as 337 the command to execute, in which case arguments will be passed 338 directly to the program without shell intervention. This usage can be 339 replaced as follows: 340 341 (child_stdin, child_stdout) = os.popen2(["/bin/ls", "-l"], mode, 342 bufsize) 343 ==> 344 p = Popen(["/bin/ls", "-l"], bufsize=bufsize, stdin=PIPE, stdout=PIPE) 345 (child_stdin, child_stdout) = (p.stdin, p.stdout) 346 347 Return code handling translates as follows: 348 349 pipe = os.popen("cmd", 'w') 350 ... 351 rc = pipe.close() 352 if rc is not None and rc % 256: 353 print "There were some errors" 354 ==> 355 process = Popen("cmd", 'w', shell=True, stdin=PIPE) 356 ... 357 process.stdin.close() 358 if process.wait() != 0: 359 print "There were some errors" 360 361 362 Replacing popen2.* 363 ------------------ 364 (child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode) 365 ==> 366 p = Popen(["somestring"], shell=True, bufsize=bufsize 367 stdin=PIPE, stdout=PIPE, close_fds=True) 368 (child_stdout, child_stdin) = (p.stdout, p.stdin) 369 370 On Unix, popen2 also accepts a sequence as the command to execute, in 371 which case arguments will be passed directly to the program without 372 shell intervention. This usage can be replaced as follows: 373 374 (child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize, 375 mode) 376 ==> 377 p = Popen(["mycmd", "myarg"], bufsize=bufsize, 378 stdin=PIPE, stdout=PIPE, close_fds=True) 379 (child_stdout, child_stdin) = (p.stdout, p.stdin) 380 381 The popen2.Popen3 and popen2.Popen4 basically works as subprocess.Popen, 382 except that: 383 384 * subprocess.Popen raises an exception if the execution fails 385 * the capturestderr argument is replaced with the stderr argument. 386 * stdin=PIPE and stdout=PIPE must be specified. 387 * popen2 closes all filedescriptors by default, but you have to specify 388 close_fds=True with subprocess.Popen. 389 """ 390 391 import sys 392 mswindows = (sys.platform == "win32") 393 394 import os 395 import types 396 import traceback 397 import gc 398 import signal 399 import errno 400 401 # Exception classes used by this module. 402 class CalledProcessError(Exception): 403 """This exception is raised when a process run by check_call() or 404 check_output() returns a non-zero exit status. 405 The exit status will be stored in the returncode attribute; 406 check_output() will also store the output in the output attribute. 407 """ 408 def __init__(self, returncode, cmd, output=None): 409 self.returncode = returncode 410 self.cmd = cmd 411 self.output = output 412 def __str__(self): 413 return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode) 414 415 416 if mswindows: 417 import threading 418 import msvcrt 419 import _subprocess 420 class STARTUPINFO: 421 dwFlags = 0 422 hStdInput = None 423 hStdOutput = None 424 hStdError = None 425 wShowWindow = 0 426 class pywintypes: 427 error = IOError 428 else: 429 import select 430 _has_poll = hasattr(select, 'poll') 431 import fcntl 432 import pickle 433 434 # When select or poll has indicated that the file is writable, 435 # we can write up to _PIPE_BUF bytes without risk of blocking. 436 # POSIX defines PIPE_BUF as >= 512. 437 _PIPE_BUF = getattr(select, 'PIPE_BUF', 512) 438 439 440 __all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call", 441 "check_output", "CalledProcessError"] 442 443 if mswindows: 444 from _subprocess import (CREATE_NEW_CONSOLE, CREATE_NEW_PROCESS_GROUP, 445 STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, 446 STD_ERROR_HANDLE, SW_HIDE, 447 STARTF_USESTDHANDLES, STARTF_USESHOWWINDOW) 448 449 __all__.extend(["CREATE_NEW_CONSOLE", "CREATE_NEW_PROCESS_GROUP", 450 "STD_INPUT_HANDLE", "STD_OUTPUT_HANDLE", 451 "STD_ERROR_HANDLE", "SW_HIDE", 452 "STARTF_USESTDHANDLES", "STARTF_USESHOWWINDOW"]) 453 try: 454 MAXFD = os.sysconf("SC_OPEN_MAX") 455 except: 456 MAXFD = 256 457 458 _active = [] 459 460 def _cleanup(): 461 for inst in _active[:]: 462 res = inst._internal_poll(_deadstate=sys.maxint) 463 if res is not None: 464 try: 465 _active.remove(inst) 466 except ValueError: 467 # This can happen if two threads create a new Popen instance. 468 # It's harmless that it was already removed, so ignore. 469 pass 470 471 PIPE = -1 472 STDOUT = -2 473 474 475 def _eintr_retry_call(func, *args): 476 while True: 477 try: 478 return func(*args) 479 except (OSError, IOError) as e: 480 if e.errno == errno.EINTR: 481 continue 482 raise 483 484 485 # XXX This function is only used by multiprocessing and the test suite, 486 # but it's here so that it can be imported when Python is compiled without 487 # threads. 488 489 def _args_from_interpreter_flags(): 490 """Return a list of command-line arguments reproducing the current 491 settings in sys.flags and sys.warnoptions.""" 492 flag_opt_map = { 493 'debug': 'd', 494 # 'inspect': 'i', 495 # 'interactive': 'i', 496 'optimize': 'O', 497 'dont_write_bytecode': 'B', 498 'no_user_site': 's', 499 'no_site': 'S', 500 'ignore_environment': 'E', 501 'verbose': 'v', 502 'bytes_warning': 'b', 503 'hash_randomization': 'R', 504 'py3k_warning': '3', 505 } 506 args = [] 507 for flag, opt in flag_opt_map.items(): 508 v = getattr(sys.flags, flag) 509 if v > 0: 510 args.append('-' + opt * v) 511 for opt in sys.warnoptions: 512 args.append('-W' + opt) 513 return args 514 515 516 def call(*popenargs, **kwargs): 517 """Run command with arguments. Wait for command to complete, then 518 return the returncode attribute. 519 520 The arguments are the same as for the Popen constructor. Example: 521 522 retcode = call(["ls", "-l"]) 523 """ 524 return Popen(*popenargs, **kwargs).wait() 525 526 527 def check_call(*popenargs, **kwargs): 528 """Run command with arguments. Wait for command to complete. If 529 the exit code was zero then return, otherwise raise 530 CalledProcessError. The CalledProcessError object will have the 531 return code in the returncode attribute. 532 533 The arguments are the same as for the Popen constructor. Example: 534 535 check_call(["ls", "-l"]) 536 """ 537 retcode = call(*popenargs, **kwargs) 538 if retcode: 539 cmd = kwargs.get("args") 540 if cmd is None: 541 cmd = popenargs[0] 542 raise CalledProcessError(retcode, cmd) 543 return 0 544 545 546 def check_output(*popenargs, **kwargs): 547 r"""Run command with arguments and return its output as a byte string. 548 549 If the exit code was non-zero it raises a CalledProcessError. The 550 CalledProcessError object will have the return code in the returncode 551 attribute and output in the output attribute. 552 553 The arguments are the same as for the Popen constructor. Example: 554 555 >>> check_output(["ls", "-l", "/dev/null"]) 556 'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n' 557 558 The stdout argument is not allowed as it is used internally. 559 To capture standard error in the result, use stderr=STDOUT. 560 561 >>> check_output(["/bin/sh", "-c", 562 ... "ls -l non_existent_file ; exit 0"], 563 ... stderr=STDOUT) 564 'ls: non_existent_file: No such file or directory\n' 565 """ 566 if 'stdout' in kwargs: 567 raise ValueError('stdout argument not allowed, it will be overridden.') 568 process = Popen(stdout=PIPE, *popenargs, **kwargs) 569 output, unused_err = process.communicate() 570 retcode = process.poll() 571 if retcode: 572 cmd = kwargs.get("args") 573 if cmd is None: 574 cmd = popenargs[0] 575 raise CalledProcessError(retcode, cmd, output=output) 576 return output 577 578 579 def list2cmdline(seq): 580 """ 581 Translate a sequence of arguments into a command line 582 string, using the same rules as the MS C runtime: 583 584 1) Arguments are delimited by white space, which is either a 585 space or a tab. 586 587 2) A string surrounded by double quotation marks is 588 interpreted as a single argument, regardless of white space 589 contained within. A quoted string can be embedded in an 590 argument. 591 592 3) A double quotation mark preceded by a backslash is 593 interpreted as a literal double quotation mark. 594 595 4) Backslashes are interpreted literally, unless they 596 immediately precede a double quotation mark. 597 598 5) If backslashes immediately precede a double quotation mark, 599 every pair of backslashes is interpreted as a literal 600 backslash. If the number of backslashes is odd, the last 601 backslash escapes the next double quotation mark as 602 described in rule 3. 603 """ 604 605 # See 606 # http://msdn.microsoft.com/en-us/library/17w5ykft.aspx 607 # or search http://msdn.microsoft.com for 608 # "Parsing C++ Command-Line Arguments" 609 result = [] 610 needquote = False 611 for arg in seq: 612 bs_buf = [] 613 614 # Add a space to separate this argument from the others 615 if result: 616 result.append(' ') 617 618 needquote = (" " in arg) or ("\t" in arg) or not arg 619 if needquote: 620 result.append('"') 621 622 for c in arg: 623 if c == '\\': 624 # Don't know if we need to double yet. 625 bs_buf.append(c) 626 elif c == '"': 627 # Double backslashes. 628 result.append('\\' * len(bs_buf)*2) 629 bs_buf = [] 630 result.append('\\"') 631 else: 632 # Normal char 633 if bs_buf: 634 result.extend(bs_buf) 635 bs_buf = [] 636 result.append(c) 637 638 # Add remaining backslashes, if any. 639 if bs_buf: 640 result.extend(bs_buf) 641 642 if needquote: 643 result.extend(bs_buf) 644 result.append('"') 645 646 return ''.join(result) 647 648 649 class Popen(object): 650 def __init__(self, args, bufsize=0, executable=None, 651 stdin=None, stdout=None, stderr=None, 652 preexec_fn=None, close_fds=False, shell=False, 653 cwd=None, env=None, universal_newlines=False, 654 startupinfo=None, creationflags=0): 655 """Create new Popen instance.""" 656 _cleanup() 657 658 self._child_created = False 659 if not isinstance(bufsize, (int, long)): 660 raise TypeError("bufsize must be an integer") 661 662 if mswindows: 663 if preexec_fn is not None: 664 raise ValueError("preexec_fn is not supported on Windows " 665 "platforms") 666 if close_fds and (stdin is not None or stdout is not None or 667 stderr is not None): 668 raise ValueError("close_fds is not supported on Windows " 669 "platforms if you redirect stdin/stdout/stderr") 670 else: 671 # POSIX 672 if startupinfo is not None: 673 raise ValueError("startupinfo is only supported on Windows " 674 "platforms") 675 if creationflags != 0: 676 raise ValueError("creationflags is only supported on Windows " 677 "platforms") 678 679 self.stdin = None 680 self.stdout = None 681 self.stderr = None 682 self.pid = None 683 self.returncode = None 684 self.universal_newlines = universal_newlines 685 686 # Input and output objects. The general principle is like 687 # this: 688 # 689 # Parent Child 690 # ------ ----- 691 # p2cwrite ---stdin---> p2cread 692 # c2pread <--stdout--- c2pwrite 693 # errread <--stderr--- errwrite 694 # 695 # On POSIX, the child objects are file descriptors. On 696 # Windows, these are Windows file handles. The parent objects 697 # are file descriptors on both platforms. The parent objects 698 # are None when not using PIPEs. The child objects are None 699 # when not redirecting. 700 701 (p2cread, p2cwrite, 702 c2pread, c2pwrite, 703 errread, errwrite) = self._get_handles(stdin, stdout, stderr) 704 705 try: 706 self._execute_child(args, executable, preexec_fn, close_fds, 707 cwd, env, universal_newlines, 708 startupinfo, creationflags, shell, 709 p2cread, p2cwrite, 710 c2pread, c2pwrite, 711 errread, errwrite) 712 except Exception: 713 # Preserve original exception in case os.close raises. 714 exc_type, exc_value, exc_trace = sys.exc_info() 715 716 to_close = [] 717 # Only close the pipes we created. 718 if stdin == PIPE: 719 to_close.extend((p2cread, p2cwrite)) 720 if stdout == PIPE: 721 to_close.extend((c2pread, c2pwrite)) 722 if stderr == PIPE: 723 to_close.extend((errread, errwrite)) 724 725 for fd in to_close: 726 try: 727 os.close(fd) 728 except EnvironmentError: 729 pass 730 731 raise exc_type, exc_value, exc_trace 732 733 if mswindows: 734 if p2cwrite is not None: 735 p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0) 736 if c2pread is not None: 737 c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0) 738 if errread is not None: 739 errread = msvcrt.open_osfhandle(errread.Detach(), 0) 740 741 if p2cwrite is not None: 742 self.stdin = os.fdopen(p2cwrite, 'wb', bufsize) 743 if c2pread is not None: 744 if universal_newlines: 745 self.stdout = os.fdopen(c2pread, 'rU', bufsize) 746 else: 747 self.stdout = os.fdopen(c2pread, 'rb', bufsize) 748 if errread is not None: 749 if universal_newlines: 750 self.stderr = os.fdopen(errread, 'rU', bufsize) 751 else: 752 self.stderr = os.fdopen(errread, 'rb', bufsize) 753 754 755 def _translate_newlines(self, data): 756 data = data.replace("\r\n", "\n") 757 data = data.replace("\r", "\n") 758 return data 759 760 761 def __del__(self, _maxint=sys.maxint, _active=_active): 762 # If __init__ hasn't had a chance to execute (e.g. if it 763 # was passed an undeclared keyword argument), we don't 764 # have a _child_created attribute at all. 765 if not getattr(self, '_child_created', False): 766 # We didn't get to successfully create a child process. 767 return 768 # In case the child hasn't been waited on, check if it's done. 769 self._internal_poll(_deadstate=_maxint) 770 if self.returncode is None and _active is not None: 771 # Child is still running, keep us alive until we can wait on it. 772 _active.append(self) 773 774 775 def communicate(self, input=None): 776 """Interact with process: Send data to stdin. Read data from 777 stdout and stderr, until end-of-file is reached. Wait for 778 process to terminate. The optional input argument should be a 779 string to be sent to the child process, or None, if no data 780 should be sent to the child. 781 782 communicate() returns a tuple (stdout, stderr).""" 783 784 # Optimization: If we are only using one pipe, or no pipe at 785 # all, using select() or threads is unnecessary. 786 if [self.stdin, self.stdout, self.stderr].count(None) >= 2: 787 stdout = None 788 stderr = None 789 if self.stdin: 790 if input: 791 try: 792 self.stdin.write(input) 793 except IOError as e: 794 if e.errno != errno.EPIPE and e.errno != errno.EINVAL: 795 raise 796 self.stdin.close() 797 elif self.stdout: 798 stdout = _eintr_retry_call(self.stdout.read) 799 self.stdout.close() 800 elif self.stderr: 801 stderr = _eintr_retry_call(self.stderr.read) 802 self.stderr.close() 803 self.wait() 804 return (stdout, stderr) 805 806 return self._communicate(input) 807 808 809 def poll(self): 810 return self._internal_poll() 811 812 813 if mswindows: 814 # 815 # Windows methods 816 # 817 def _get_handles(self, stdin, stdout, stderr): 818 """Construct and return tuple with IO objects: 819 p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite 820 """ 821 if stdin is None and stdout is None and stderr is None: 822 return (None, None, None, None, None, None) 823 824 p2cread, p2cwrite = None, None 825 c2pread, c2pwrite = None, None 826 errread, errwrite = None, None 827 828 if stdin is None: 829 p2cread = _subprocess.GetStdHandle(_subprocess.STD_INPUT_HANDLE) 830 if p2cread is None: 831 p2cread, _ = _subprocess.CreatePipe(None, 0) 832 elif stdin == PIPE: 833 p2cread, p2cwrite = _subprocess.CreatePipe(None, 0) 834 elif isinstance(stdin, int): 835 p2cread = msvcrt.get_osfhandle(stdin) 836 else: 837 # Assuming file-like object 838 p2cread = msvcrt.get_osfhandle(stdin.fileno()) 839 p2cread = self._make_inheritable(p2cread) 840 841 if stdout is None: 842 c2pwrite = _subprocess.GetStdHandle(_subprocess.STD_OUTPUT_HANDLE) 843 if c2pwrite is None: 844 _, c2pwrite = _subprocess.CreatePipe(None, 0) 845 elif stdout == PIPE: 846 c2pread, c2pwrite = _subprocess.CreatePipe(None, 0) 847 elif isinstance(stdout, int): 848 c2pwrite = msvcrt.get_osfhandle(stdout) 849 else: 850 # Assuming file-like object 851 c2pwrite = msvcrt.get_osfhandle(stdout.fileno()) 852 c2pwrite = self._make_inheritable(c2pwrite) 853 854 if stderr is None: 855 errwrite = _subprocess.GetStdHandle(_subprocess.STD_ERROR_HANDLE) 856 if errwrite is None: 857 _, errwrite = _subprocess.CreatePipe(None, 0) 858 elif stderr == PIPE: 859 errread, errwrite = _subprocess.CreatePipe(None, 0) 860 elif stderr == STDOUT: 861 errwrite = c2pwrite 862 elif isinstance(stderr, int): 863 errwrite = msvcrt.get_osfhandle(stderr) 864 else: 865 # Assuming file-like object 866 errwrite = msvcrt.get_osfhandle(stderr.fileno()) 867 errwrite = self._make_inheritable(errwrite) 868 869 return (p2cread, p2cwrite, 870 c2pread, c2pwrite, 871 errread, errwrite) 872 873 874 def _make_inheritable(self, handle): 875 """Return a duplicate of handle, which is inheritable""" 876 return _subprocess.DuplicateHandle(_subprocess.GetCurrentProcess(), 877 handle, _subprocess.GetCurrentProcess(), 0, 1, 878 _subprocess.DUPLICATE_SAME_ACCESS) 879 880 881 def _find_w9xpopen(self): 882 """Find and return absolut path to w9xpopen.exe""" 883 w9xpopen = os.path.join( 884 os.path.dirname(_subprocess.GetModuleFileName(0)), 885 "w9xpopen.exe") 886 if not os.path.exists(w9xpopen): 887 # Eeek - file-not-found - possibly an embedding 888 # situation - see if we can locate it in sys.exec_prefix 889 w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix), 890 "w9xpopen.exe") 891 if not os.path.exists(w9xpopen): 892 raise RuntimeError("Cannot locate w9xpopen.exe, which is " 893 "needed for Popen to work with your " 894 "shell or platform.") 895 return w9xpopen 896 897 898 def _execute_child(self, args, executable, preexec_fn, close_fds, 899 cwd, env, universal_newlines, 900 startupinfo, creationflags, shell, 901 p2cread, p2cwrite, 902 c2pread, c2pwrite, 903 errread, errwrite): 904 """Execute program (MS Windows version)""" 905 906 if not isinstance(args, types.StringTypes): 907 args = list2cmdline(args) 908 909 # Process startup details 910 if startupinfo is None: 911 startupinfo = STARTUPINFO() 912 if None not in (p2cread, c2pwrite, errwrite): 913 startupinfo.dwFlags |= _subprocess.STARTF_USESTDHANDLES 914 startupinfo.hStdInput = p2cread 915 startupinfo.hStdOutput = c2pwrite 916 startupinfo.hStdError = errwrite 917 918 if shell: 919 startupinfo.dwFlags |= _subprocess.STARTF_USESHOWWINDOW 920 startupinfo.wShowWindow = _subprocess.SW_HIDE 921 comspec = os.environ.get("COMSPEC", "cmd.exe") 922 args = '{} /c "{}"'.format (comspec, args) 923 if (_subprocess.GetVersion() >= 0x80000000 or 924 os.path.basename(comspec).lower() == "command.com"): 925 # Win9x, or using command.com on NT. We need to 926 # use the w9xpopen intermediate program. For more 927 # information, see KB Q150956 928 # (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp) 929 w9xpopen = self._find_w9xpopen() 930 args = '"%s" %s' % (w9xpopen, args) 931 # Not passing CREATE_NEW_CONSOLE has been known to 932 # cause random failures on win9x. Specifically a 933 # dialog: "Your program accessed mem currently in 934 # use at xxx" and a hopeful warning about the 935 # stability of your system. Cost is Ctrl+C wont 936 # kill children. 937 creationflags |= _subprocess.CREATE_NEW_CONSOLE 938 939 # Start the process 940 try: 941 hp, ht, pid, tid = _subprocess.CreateProcess(executable, args, 942 # no special security 943 None, None, 944 int(not close_fds), 945 creationflags, 946 env, 947 cwd, 948 startupinfo) 949 except pywintypes.error, e: 950 # Translate pywintypes.error to WindowsError, which is 951 # a subclass of OSError. FIXME: We should really 952 # translate errno using _sys_errlist (or similar), but 953 # how can this be done from Python? 954 raise WindowsError(*e.args) 955 finally: 956 # Child is launched. Close the parent's copy of those pipe 957 # handles that only the child should have open. You need 958 # to make sure that no handles to the write end of the 959 # output pipe are maintained in this process or else the 960 # pipe will not close when the child process exits and the 961 # ReadFile will hang. 962 if p2cread is not None: 963 p2cread.Close() 964 if c2pwrite is not None: 965 c2pwrite.Close() 966 if errwrite is not None: 967 errwrite.Close() 968 969 # Retain the process handle, but close the thread handle 970 self._child_created = True 971 self._handle = hp 972 self.pid = pid 973 ht.Close() 974 975 def _internal_poll(self, _deadstate=None, 976 _WaitForSingleObject=_subprocess.WaitForSingleObject, 977 _WAIT_OBJECT_0=_subprocess.WAIT_OBJECT_0, 978 _GetExitCodeProcess=_subprocess.GetExitCodeProcess): 979 """Check if child process has terminated. Returns returncode 980 attribute. 981 982 This method is called by __del__, so it can only refer to objects 983 in its local scope. 984 985 """ 986 if self.returncode is None: 987 if _WaitForSingleObject(self._handle, 0) == _WAIT_OBJECT_0: 988 self.returncode = _GetExitCodeProcess(self._handle) 989 return self.returncode 990 991 992 def wait(self): 993 """Wait for child process to terminate. Returns returncode 994 attribute.""" 995 if self.returncode is None: 996 _subprocess.WaitForSingleObject(self._handle, 997 _subprocess.INFINITE) 998 self.returncode = _subprocess.GetExitCodeProcess(self._handle) 999 return self.returncode 1000 1001 1002 def _readerthread(self, fh, buffer): 1003 buffer.append(fh.read()) 1004 1005 1006 def _communicate(self, input): 1007 stdout = None # Return 1008 stderr = None # Return 1009 1010 if self.stdout: 1011 stdout = [] 1012 stdout_thread = threading.Thread(target=self._readerthread, 1013 args=(self.stdout, stdout)) 1014 stdout_thread.setDaemon(True) 1015 stdout_thread.start() 1016 if self.stderr: 1017 stderr = [] 1018 stderr_thread = threading.Thread(target=self._readerthread, 1019 args=(self.stderr, stderr)) 1020 stderr_thread.setDaemon(True) 1021 stderr_thread.start() 1022 1023 if self.stdin: 1024 if input is not None: 1025 try: 1026 self.stdin.write(input) 1027 except IOError as e: 1028 if e.errno != errno.EPIPE: 1029 raise 1030 self.stdin.close() 1031 1032 if self.stdout: 1033 stdout_thread.join() 1034 if self.stderr: 1035 stderr_thread.join() 1036 1037 # All data exchanged. Translate lists into strings. 1038 if stdout is not None: 1039 stdout = stdout[0] 1040 if stderr is not None: 1041 stderr = stderr[0] 1042 1043 # Translate newlines, if requested. We cannot let the file 1044 # object do the translation: It is based on stdio, which is 1045 # impossible to combine with select (unless forcing no 1046 # buffering). 1047 if self.universal_newlines and hasattr(file, 'newlines'): 1048 if stdout: 1049 stdout = self._translate_newlines(stdout) 1050 if stderr: 1051 stderr = self._translate_newlines(stderr) 1052 1053 self.wait() 1054 return (stdout, stderr) 1055 1056 def send_signal(self, sig): 1057 """Send a signal to the process 1058 """ 1059 if sig == signal.SIGTERM: 1060 self.terminate() 1061 elif sig == signal.CTRL_C_EVENT: 1062 os.kill(self.pid, signal.CTRL_C_EVENT) 1063 elif sig == signal.CTRL_BREAK_EVENT: 1064 os.kill(self.pid, signal.CTRL_BREAK_EVENT) 1065 else: 1066 raise ValueError("Unsupported signal: {}".format(sig)) 1067 1068 def terminate(self): 1069 """Terminates the process 1070 """ 1071 try: 1072 _subprocess.TerminateProcess(self._handle, 1) 1073 except OSError as e: 1074 # ERROR_ACCESS_DENIED (winerror 5) is received when the 1075 # process already died. 1076 if e.winerror != 5: 1077 raise 1078 rc = _subprocess.GetExitCodeProcess(self._handle) 1079 if rc == _subprocess.STILL_ACTIVE: 1080 raise 1081 self.returncode = rc 1082 1083 kill = terminate 1084 1085 else: 1086 # 1087 # POSIX methods 1088 # 1089 def _get_handles(self, stdin, stdout, stderr): 1090 """Construct and return tuple with IO objects: 1091 p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite 1092 """ 1093 p2cread, p2cwrite = None, None 1094 c2pread, c2pwrite = None, None 1095 errread, errwrite = None, None 1096 1097 if stdin is None: 1098 pass 1099 elif stdin == PIPE: 1100 p2cread, p2cwrite = self.pipe_cloexec() 1101 elif isinstance(stdin, int): 1102 p2cread = stdin 1103 else: 1104 # Assuming file-like object 1105 p2cread = stdin.fileno() 1106 1107 if stdout is None: 1108 pass 1109 elif stdout == PIPE: 1110 c2pread, c2pwrite = self.pipe_cloexec() 1111 elif isinstance(stdout, int): 1112 c2pwrite = stdout 1113 else: 1114 # Assuming file-like object 1115 c2pwrite = stdout.fileno() 1116 1117 if stderr is None: 1118 pass 1119 elif stderr == PIPE: 1120 errread, errwrite = self.pipe_cloexec() 1121 elif stderr == STDOUT: 1122 errwrite = c2pwrite 1123 elif isinstance(stderr, int): 1124 errwrite = stderr 1125 else: 1126 # Assuming file-like object 1127 errwrite = stderr.fileno() 1128 1129 return (p2cread, p2cwrite, 1130 c2pread, c2pwrite, 1131 errread, errwrite) 1132 1133 1134 def _set_cloexec_flag(self, fd, cloexec=True): 1135 try: 1136 cloexec_flag = fcntl.FD_CLOEXEC 1137 except AttributeError: 1138 cloexec_flag = 1 1139 1140 old = fcntl.fcntl(fd, fcntl.F_GETFD) 1141 if cloexec: 1142 fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag) 1143 else: 1144 fcntl.fcntl(fd, fcntl.F_SETFD, old & ~cloexec_flag) 1145 1146 1147 def pipe_cloexec(self): 1148 """Create a pipe with FDs set CLOEXEC.""" 1149 # Pipes' FDs are set CLOEXEC by default because we don't want them 1150 # to be inherited by other subprocesses: the CLOEXEC flag is removed 1151 # from the child's FDs by _dup2(), between fork() and exec(). 1152 # This is not atomic: we would need the pipe2() syscall for that. 1153 r, w = os.pipe() 1154 self._set_cloexec_flag(r) 1155 self._set_cloexec_flag(w) 1156 return r, w 1157 1158 1159 def _close_fds(self, but): 1160 if hasattr(os, 'closerange'): 1161 os.closerange(3, but) 1162 os.closerange(but + 1, MAXFD) 1163 else: 1164 for i in xrange(3, MAXFD): 1165 if i == but: 1166 continue 1167 try: 1168 os.close(i) 1169 except: 1170 pass 1171 1172 1173 def _execute_child(self, args, executable, preexec_fn, close_fds, 1174 cwd, env, universal_newlines, 1175 startupinfo, creationflags, shell, 1176 p2cread, p2cwrite, 1177 c2pread, c2pwrite, 1178 errread, errwrite): 1179 """Execute program (POSIX version)""" 1180 1181 if isinstance(args, types.StringTypes): 1182 args = [args] 1183 else: 1184 args = list(args) 1185 1186 if shell: 1187 args = ["/bin/sh", "-c"] + args 1188 if executable: 1189 args[0] = executable 1190 1191 if executable is None: 1192 executable = args[0] 1193 1194 # For transferring possible exec failure from child to parent 1195 # The first char specifies the exception type: 0 means 1196 # OSError, 1 means some other error. 1197 errpipe_read, errpipe_write = self.pipe_cloexec() 1198 try: 1199 try: 1200 gc_was_enabled = gc.isenabled() 1201 # Disable gc to avoid bug where gc -> file_dealloc -> 1202 # write to stderr -> hang. http://bugs.python.org/issue1336 1203 gc.disable() 1204 try: 1205 self.pid = os.fork() 1206 except: 1207 if gc_was_enabled: 1208 gc.enable() 1209 raise 1210 self._child_created = True 1211 if self.pid == 0: 1212 # Child 1213 try: 1214 # Close parent's pipe ends 1215 if p2cwrite is not None: 1216 os.close(p2cwrite) 1217 if c2pread is not None: 1218 os.close(c2pread) 1219 if errread is not None: 1220 os.close(errread) 1221 os.close(errpipe_read) 1222 1223 # When duping fds, if there arises a situation 1224 # where one of the fds is either 0, 1 or 2, it 1225 # is possible that it is overwritten (#12607). 1226 if c2pwrite == 0: 1227 c2pwrite = os.dup(c2pwrite) 1228 if errwrite == 0 or errwrite == 1: 1229 errwrite = os.dup(errwrite) 1230 1231 # Dup fds for child 1232 def _dup2(a, b): 1233 # dup2() removes the CLOEXEC flag but 1234 # we must do it ourselves if dup2() 1235 # would be a no-op (issue #10806). 1236 if a == b: 1237 self._set_cloexec_flag(a, False) 1238 elif a is not None: 1239 os.dup2(a, b) 1240 _dup2(p2cread, 0) 1241 _dup2(c2pwrite, 1) 1242 _dup2(errwrite, 2) 1243 1244 # Close pipe fds. Make sure we don't close the 1245 # same fd more than once, or standard fds. 1246 closed = { None } 1247 for fd in [p2cread, c2pwrite, errwrite]: 1248 if fd not in closed and fd > 2: 1249 os.close(fd) 1250 closed.add(fd) 1251 1252 # Close all other fds, if asked for 1253 if close_fds: 1254 self._close_fds(but=errpipe_write) 1255 1256 if cwd is not None: 1257 os.chdir(cwd) 1258 1259 if preexec_fn: 1260 preexec_fn() 1261 1262 if env is None: 1263 os.execvp(executable, args) 1264 else: 1265 os.execvpe(executable, args, env) 1266 1267 except: 1268 exc_type, exc_value, tb = sys.exc_info() 1269 # Save the traceback and attach it to the exception object 1270 exc_lines = traceback.format_exception(exc_type, 1271 exc_value, 1272 tb) 1273 exc_value.child_traceback = ''.join(exc_lines) 1274 os.write(errpipe_write, pickle.dumps(exc_value)) 1275 1276 # This exitcode won't be reported to applications, so it 1277 # really doesn't matter what we return. 1278 os._exit(255) 1279 1280 # Parent 1281 if gc_was_enabled: 1282 gc.enable() 1283 finally: 1284 # be sure the FD is closed no matter what 1285 os.close(errpipe_write) 1286 1287 if p2cread is not None and p2cwrite is not None: 1288 os.close(p2cread) 1289 if c2pwrite is not None and c2pread is not None: 1290 os.close(c2pwrite) 1291 if errwrite is not None and errread is not None: 1292 os.close(errwrite) 1293 1294 # Wait for exec to fail or succeed; possibly raising exception 1295 # Exception limited to 1M 1296 data = _eintr_retry_call(os.read, errpipe_read, 1048576) 1297 finally: 1298 # be sure the FD is closed no matter what 1299 os.close(errpipe_read) 1300 1301 if data != "": 1302 try: 1303 _eintr_retry_call(os.waitpid, self.pid, 0) 1304 except OSError as e: 1305 if e.errno != errno.ECHILD: 1306 raise 1307 child_exception = pickle.loads(data) 1308 raise child_exception 1309 1310 1311 def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED, 1312 _WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED, 1313 _WEXITSTATUS=os.WEXITSTATUS): 1314 # This method is called (indirectly) by __del__, so it cannot 1315 # refer to anything outside of its local scope.""" 1316 if _WIFSIGNALED(sts): 1317 self.returncode = -_WTERMSIG(sts) 1318 elif _WIFEXITED(sts): 1319 self.returncode = _WEXITSTATUS(sts) 1320 else: 1321 # Should never happen 1322 raise RuntimeError("Unknown child exit status!") 1323 1324 1325 def _internal_poll(self, _deadstate=None, _waitpid=os.waitpid, 1326 _WNOHANG=os.WNOHANG, _os_error=os.error, _ECHILD=errno.ECHILD): 1327 """Check if child process has terminated. Returns returncode 1328 attribute. 1329 1330 This method is called by __del__, so it cannot reference anything 1331 outside of the local scope (nor can any methods it calls). 1332 1333 """ 1334 if self.returncode is None: 1335 try: 1336 pid, sts = _waitpid(self.pid, _WNOHANG) 1337 if pid == self.pid: 1338 self._handle_exitstatus(sts) 1339 except _os_error as e: 1340 if _deadstate is not None: 1341 self.returncode = _deadstate 1342 if e.errno == _ECHILD: 1343 # This happens if SIGCLD is set to be ignored or 1344 # waiting for child processes has otherwise been 1345 # disabled for our process. This child is dead, we 1346 # can't get the status. 1347 # http://bugs.python.org/issue15756 1348 self.returncode = 0 1349 return self.returncode 1350 1351 1352 def wait(self): 1353 """Wait for child process to terminate. Returns returncode 1354 attribute.""" 1355 while self.returncode is None: 1356 try: 1357 pid, sts = _eintr_retry_call(os.waitpid, self.pid, 0) 1358 except OSError as e: 1359 if e.errno != errno.ECHILD: 1360 raise 1361 # This happens if SIGCLD is set to be ignored or waiting 1362 # for child processes has otherwise been disabled for our 1363 # process. This child is dead, we can't get the status. 1364 pid = self.pid 1365 sts = 0 1366 # Check the pid and loop as waitpid has been known to return 1367 # 0 even without WNOHANG in odd situations. issue14396. 1368 if pid == self.pid: 1369 self._handle_exitstatus(sts) 1370 return self.returncode 1371 1372 1373 def _communicate(self, input): 1374 if self.stdin: 1375 # Flush stdio buffer. This might block, if the user has 1376 # been writing to .stdin in an uncontrolled fashion. 1377 self.stdin.flush() 1378 if not input: 1379 self.stdin.close() 1380 1381 if _has_poll: 1382 stdout, stderr = self._communicate_with_poll(input) 1383 else: 1384 stdout, stderr = self._communicate_with_select(input) 1385 1386 # All data exchanged. Translate lists into strings. 1387 if stdout is not None: 1388 stdout = ''.join(stdout) 1389 if stderr is not None: 1390 stderr = ''.join(stderr) 1391 1392 # Translate newlines, if requested. We cannot let the file 1393 # object do the translation: It is based on stdio, which is 1394 # impossible to combine with select (unless forcing no 1395 # buffering). 1396 if self.universal_newlines and hasattr(file, 'newlines'): 1397 if stdout: 1398 stdout = self._translate_newlines(stdout) 1399 if stderr: 1400 stderr = self._translate_newlines(stderr) 1401 1402 self.wait() 1403 return (stdout, stderr) 1404 1405 1406 def _communicate_with_poll(self, input): 1407 stdout = None # Return 1408 stderr = None # Return 1409 fd2file = {} 1410 fd2output = {} 1411 1412 poller = select.poll() 1413 def register_and_append(file_obj, eventmask): 1414 poller.register(file_obj.fileno(), eventmask) 1415 fd2file[file_obj.fileno()] = file_obj 1416 1417 def close_unregister_and_remove(fd): 1418 poller.unregister(fd) 1419 fd2file[fd].close() 1420 fd2file.pop(fd) 1421 1422 if self.stdin and input: 1423 register_and_append(self.stdin, select.POLLOUT) 1424 1425 select_POLLIN_POLLPRI = select.POLLIN | select.POLLPRI 1426 if self.stdout: 1427 register_and_append(self.stdout, select_POLLIN_POLLPRI) 1428 fd2output[self.stdout.fileno()] = stdout = [] 1429 if self.stderr: 1430 register_and_append(self.stderr, select_POLLIN_POLLPRI) 1431 fd2output[self.stderr.fileno()] = stderr = [] 1432 1433 input_offset = 0 1434 while fd2file: 1435 try: 1436 ready = poller.poll() 1437 except select.error, e: 1438 if e.args[0] == errno.EINTR: 1439 continue 1440 raise 1441 1442 for fd, mode in ready: 1443 if mode & select.POLLOUT: 1444 chunk = input[input_offset : input_offset + _PIPE_BUF] 1445 try: 1446 input_offset += os.write(fd, chunk) 1447 except OSError as e: 1448 if e.errno == errno.EPIPE: 1449 close_unregister_and_remove(fd) 1450 else: 1451 raise 1452 else: 1453 if input_offset >= len(input): 1454 close_unregister_and_remove(fd) 1455 elif mode & select_POLLIN_POLLPRI: 1456 data = os.read(fd, 4096) 1457 if not data: 1458 close_unregister_and_remove(fd) 1459 fd2output[fd].append(data) 1460 else: 1461 # Ignore hang up or errors. 1462 close_unregister_and_remove(fd) 1463 1464 return (stdout, stderr) 1465 1466 1467 def _communicate_with_select(self, input): 1468 read_set = [] 1469 write_set = [] 1470 stdout = None # Return 1471 stderr = None # Return 1472 1473 if self.stdin and input: 1474 write_set.append(self.stdin) 1475 if self.stdout: 1476 read_set.append(self.stdout) 1477 stdout = [] 1478 if self.stderr: 1479 read_set.append(self.stderr) 1480 stderr = [] 1481 1482 input_offset = 0 1483 while read_set or write_set: 1484 try: 1485 rlist, wlist, xlist = select.select(read_set, write_set, []) 1486 except select.error, e: 1487 if e.args[0] == errno.EINTR: 1488 continue 1489 raise 1490 1491 if self.stdin in wlist: 1492 chunk = input[input_offset : input_offset + _PIPE_BUF] 1493 try: 1494 bytes_written = os.write(self.stdin.fileno(), chunk) 1495 except OSError as e: 1496 if e.errno == errno.EPIPE: 1497 self.stdin.close() 1498 write_set.remove(self.stdin) 1499 else: 1500 raise 1501 else: 1502 input_offset += bytes_written 1503 if input_offset >= len(input): 1504 self.stdin.close() 1505 write_set.remove(self.stdin) 1506 1507 if self.stdout in rlist: 1508 data = os.read(self.stdout.fileno(), 1024) 1509 if data == "": 1510 self.stdout.close() 1511 read_set.remove(self.stdout) 1512 stdout.append(data) 1513 1514 if self.stderr in rlist: 1515 data = os.read(self.stderr.fileno(), 1024) 1516 if data == "": 1517 self.stderr.close() 1518 read_set.remove(self.stderr) 1519 stderr.append(data) 1520 1521 return (stdout, stderr) 1522 1523 1524 def send_signal(self, sig): 1525 """Send a signal to the process 1526 """ 1527 os.kill(self.pid, sig) 1528 1529 def terminate(self): 1530 """Terminate the process with SIGTERM 1531 """ 1532 self.send_signal(signal.SIGTERM) 1533 1534 def kill(self): 1535 """Kill the process with SIGKILL 1536 """ 1537 self.send_signal(signal.SIGKILL) 1538 1539 1540 def _demo_posix(): 1541 # 1542 # Example 1: Simple redirection: Get process list 1543 # 1544 plist = Popen(["ps"], stdout=PIPE).communicate()[0] 1545 print "Process list:" 1546 print plist 1547 1548 # 1549 # Example 2: Change uid before executing child 1550 # 1551 if os.getuid() == 0: 1552 p = Popen(["id"], preexec_fn=lambda: os.setuid(100)) 1553 p.wait() 1554 1555 # 1556 # Example 3: Connecting several subprocesses 1557 # 1558 print "Looking for 'hda'..." 1559 p1 = Popen(["dmesg"], stdout=PIPE) 1560 p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE) 1561 print repr(p2.communicate()[0]) 1562 1563 # 1564 # Example 4: Catch execution error 1565 # 1566 print 1567 print "Trying a weird file..." 1568 try: 1569 print Popen(["/this/path/does/not/exist"]).communicate() 1570 except OSError, e: 1571 if e.errno == errno.ENOENT: 1572 print "The file didn't exist. I thought so..." 1573 print "Child traceback:" 1574 print e.child_traceback 1575 else: 1576 print "Error", e.errno 1577 else: 1578 print >>sys.stderr, "Gosh. No error." 1579 1580 1581 def _demo_windows(): 1582 # 1583 # Example 1: Connecting several subprocesses 1584 # 1585 print "Looking for 'PROMPT' in set output..." 1586 p1 = Popen("set", stdout=PIPE, shell=True) 1587 p2 = Popen('find "PROMPT"', stdin=p1.stdout, stdout=PIPE) 1588 print repr(p2.communicate()[0]) 1589 1590 # 1591 # Example 2: Simple execution of program 1592 # 1593 print "Executing calc..." 1594 p = Popen("calc") 1595 p.wait() 1596 1597 1598 if __name__ == "__main__": 1599 if mswindows: 1600 _demo_windows() 1601 else: 1602 _demo_posix() 1603
