| 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@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 two shortcut functions: |
| 111 | |
| 112 | call(*args, **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 | |
| 121 | Exceptions |
| 122 | ---------- |
| 123 | Exceptions raised in the child process, before the new program has |
| 124 | started to execute, will be re-raised in the parent. Additionally, |
| 125 | the exception object will have one extra attribute called |
| 126 | 'child_traceback', which is a string containing traceback information |
| 127 | from the childs point of view. |
| 128 | |
| 129 | The most common exception raised is OSError. This occurs, for |
| 130 | example, when trying to execute a non-existent file. Applications |
| 131 | should prepare for OSErrors. |
| 132 | |
| 133 | A ValueError will be raised if Popen is called with invalid arguments. |
| 134 | |
| 135 | |
| 136 | Security |
| 137 | -------- |
| 138 | Unlike some other popen functions, this implementation will never call |
| 139 | /bin/sh implicitly. This means that all characters, including shell |
| 140 | metacharacters, can safely be passed to child processes. |
| 141 | |
| 142 | |
| 143 | Popen objects |
| 144 | ============= |
| 145 | Instances of the Popen class have the following methods: |
| 146 | |
| 147 | poll() |
| 148 | Check if child process has terminated. Returns returncode |
| 149 | attribute. |
| 150 | |
| 151 | wait() |
| 152 | Wait for child process to terminate. Returns returncode attribute. |
| 153 | |
| 154 | communicate(input=None) |
| 155 | Interact with process: Send data to stdin. Read data from stdout |
| 156 | and stderr, until end-of-file is reached. Wait for process to |
| 157 | terminate. The optional stdin argument should be a string to be |
| 158 | sent to the child process, or None, if no data should be sent to |
| 159 | the child. |
| 160 | |
| 161 | communicate() returns a tuple (stdout, stderr). |
| 162 | |
| 163 | Note: The data read is buffered in memory, so do not use this |
| 164 | method if the data size is large or unlimited. |
| 165 | |
| 166 | The following attributes are also available: |
| 167 | |
| 168 | stdin |
| 169 | If the stdin argument is PIPE, this attribute is a file object |
| 170 | that provides input to the child process. Otherwise, it is None. |
| 171 | |
| 172 | stdout |
| 173 | If the stdout argument is PIPE, this attribute is a file object |
| 174 | that provides output from the child process. Otherwise, it is |
| 175 | None. |
| 176 | |
| 177 | stderr |
| 178 | If the stderr argument is PIPE, this attribute is file object that |
| 179 | provides error output from the child process. Otherwise, it is |
| 180 | None. |
| 181 | |
| 182 | pid |
| 183 | The process ID of the child process. |
| 184 | |
| 185 | returncode |
| 186 | The child return code. A None value indicates that the process |
| 187 | hasn't terminated yet. A negative value -N indicates that the |
| 188 | child was terminated by signal N (UNIX only). |
| 189 | |
| 190 | |
| 191 | Replacing older functions with the subprocess module |
| 192 | ==================================================== |
| 193 | In this section, "a ==> b" means that b can be used as a replacement |
| 194 | for a. |
| 195 | |
| 196 | Note: All functions in this section fail (more or less) silently if |
| 197 | the executed program cannot be found; this module raises an OSError |
| 198 | exception. |
| 199 | |
| 200 | In the following examples, we assume that the subprocess module is |
| 201 | imported with "from subprocess import *". |
| 202 | |
| 203 | |
| 204 | Replacing /bin/sh shell backquote |
| 205 | --------------------------------- |
| 206 | output=`mycmd myarg` |
| 207 | ==> |
| 208 | output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0] |
| 209 | |
| 210 | |
| 211 | Replacing shell pipe line |
| 212 | ------------------------- |
| 213 | output=`dmesg | grep hda` |
| 214 | ==> |
| 215 | p1 = Popen(["dmesg"], stdout=PIPE) |
| 216 | p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE) |
| 217 | output = p2.communicate()[0] |
| 218 | |
| 219 | |
| 220 | Replacing os.system() |
| 221 | --------------------- |
| 222 | sts = os.system("mycmd" + " myarg") |
| 223 | ==> |
| 224 | p = Popen("mycmd" + " myarg", shell=True) |
| 225 | sts = os.waitpid(p.pid, 0) |
| 226 | |
| 227 | Note: |
| 228 | |
| 229 | * Calling the program through the shell is usually not required. |
| 230 | |
| 231 | * It's easier to look at the returncode attribute than the |
| 232 | exitstatus. |
| 233 | |
| 234 | A more real-world example would look like this: |
| 235 | |
| 236 | try: |
| 237 | retcode = call("mycmd" + " myarg", shell=True) |
| 238 | if retcode < 0: |
| 239 | print >>sys.stderr, "Child was terminated by signal", -retcode |
| 240 | else: |
| 241 | print >>sys.stderr, "Child returned", retcode |
| 242 | except OSError, e: |
| 243 | print >>sys.stderr, "Execution failed:", e |
| 244 | |
| 245 | |
| 246 | Replacing os.spawn* |
| 247 | ------------------- |
| 248 | P_NOWAIT example: |
| 249 | |
| 250 | pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg") |
| 251 | ==> |
| 252 | pid = Popen(["/bin/mycmd", "myarg"]).pid |
| 253 | |
| 254 | |
| 255 | P_WAIT example: |
| 256 | |
| 257 | retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg") |
| 258 | ==> |
| 259 | retcode = call(["/bin/mycmd", "myarg"]) |
| 260 | |
| 261 | |
| 262 | Vector example: |
| 263 | |
| 264 | os.spawnvp(os.P_NOWAIT, path, args) |
| 265 | ==> |
| 266 | Popen([path] + args[1:]) |
| 267 | |
| 268 | |
| 269 | Environment example: |
| 270 | |
| 271 | os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env) |
| 272 | ==> |
| 273 | Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"}) |
| 274 | |
| 275 | |
| 276 | Replacing os.popen* |
| 277 | ------------------- |
| 278 | pipe = os.popen(cmd, mode='r', bufsize) |
| 279 | ==> |
| 280 | pipe = Popen(cmd, shell=True, bufsize=bufsize, stdout=PIPE).stdout |
| 281 | |
| 282 | pipe = os.popen(cmd, mode='w', bufsize) |
| 283 | ==> |
| 284 | pipe = Popen(cmd, shell=True, bufsize=bufsize, stdin=PIPE).stdin |
| 285 | |
| 286 | |
| 287 | (child_stdin, child_stdout) = os.popen2(cmd, mode, bufsize) |
| 288 | ==> |
| 289 | p = Popen(cmd, shell=True, bufsize=bufsize, |
| 290 | stdin=PIPE, stdout=PIPE, close_fds=True) |
| 291 | (child_stdin, child_stdout) = (p.stdin, p.stdout) |
| 292 | |
| 293 | |
| 294 | (child_stdin, |
| 295 | child_stdout, |
| 296 | child_stderr) = os.popen3(cmd, mode, bufsize) |
| 297 | ==> |
| 298 | p = Popen(cmd, shell=True, bufsize=bufsize, |
| 299 | stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True) |
| 300 | (child_stdin, |
| 301 | child_stdout, |
| 302 | child_stderr) = (p.stdin, p.stdout, p.stderr) |
| 303 | |
| 304 | |
| 305 | (child_stdin, child_stdout_and_stderr) = os.popen4(cmd, mode, bufsize) |
| 306 | ==> |
| 307 | p = Popen(cmd, shell=True, bufsize=bufsize, |
| 308 | stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True) |
| 309 | (child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout) |
| 310 | |
| 311 | |
| 312 | Replacing popen2.* |
| 313 | ------------------ |
| 314 | Note: If the cmd argument to popen2 functions is a string, the command |
| 315 | is executed through /bin/sh. If it is a list, the command is directly |
| 316 | executed. |
| 317 | |
| 318 | (child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode) |
| 319 | ==> |
| 320 | p = Popen(["somestring"], shell=True, bufsize=bufsize |
| 321 | stdin=PIPE, stdout=PIPE, close_fds=True) |
| 322 | (child_stdout, child_stdin) = (p.stdout, p.stdin) |
| 323 | |
| 324 | |
| 325 | (child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize, mode) |
| 326 | ==> |
| 327 | p = Popen(["mycmd", "myarg"], bufsize=bufsize, |
| 328 | stdin=PIPE, stdout=PIPE, close_fds=True) |
| 329 | (child_stdout, child_stdin) = (p.stdout, p.stdin) |
| 330 | |
| 331 | The popen2.Popen3 and popen3.Popen4 basically works as subprocess.Popen, |
| 332 | except that: |
| 333 | |
| 334 | * subprocess.Popen raises an exception if the execution fails |
| 335 | * the capturestderr argument is replaced with the stderr argument. |
| 336 | * stdin=PIPE and stdout=PIPE must be specified. |
| 337 | * popen2 closes all filedescriptors by default, but you have to specify |
| 338 | close_fds=True with subprocess.Popen. |
| 339 | |
| 340 | |
| 341 | """ |
| 342 | |
| 343 | import sys |
| 344 | mswindows = (sys.platform == "win32") |
| 345 | |
| 346 | import os |
| 347 | import types |
| 348 | import traceback |
| 349 | |
| 350 | if mswindows: |
| 351 | import threading |
| 352 | import msvcrt |
| 353 | if 0: # <-- change this to use pywin32 instead of the _subprocess driver |
| 354 | import pywintypes |
| 355 | from win32api import GetStdHandle, STD_INPUT_HANDLE, \ |
| 356 | STD_OUTPUT_HANDLE, STD_ERROR_HANDLE |
| 357 | from win32api import GetCurrentProcess, DuplicateHandle, \ |
| 358 | GetModuleFileName, GetVersion |
| 359 | from win32con import DUPLICATE_SAME_ACCESS, SW_HIDE |
| 360 | from win32pipe import CreatePipe |
| 361 | from win32process import CreateProcess, STARTUPINFO, \ |
| 362 | GetExitCodeProcess, STARTF_USESTDHANDLES, \ |
| 363 | STARTF_USESHOWWINDOW, CREATE_NEW_CONSOLE |
| 364 | from win32event import WaitForSingleObject, INFINITE, WAIT_OBJECT_0 |
| 365 | else: |
| 366 | from _subprocess import * |
| 367 | class STARTUPINFO: |
| 368 | dwFlags = 0 |
| 369 | hStdInput = None |
| 370 | hStdOutput = None |
| 371 | hStdError = None |
| 372 | class pywintypes: |
| 373 | error = IOError |
| 374 | else: |
| 375 | import select |
| 376 | import errno |
| 377 | import fcntl |
| 378 | import pickle |
| 379 | |
| 380 | __all__ = ["Popen", "PIPE", "STDOUT", "call"] |
| 381 | |
| 382 | try: |
| 383 | MAXFD = os.sysconf("SC_OPEN_MAX") |
| 384 | except: |
| 385 | MAXFD = 256 |
| 386 | |
| 387 | # True/False does not exist on 2.2.0 |
| 388 | try: |
| 389 | False |
| 390 | except NameError: |
| 391 | False = 0 |
| 392 | True = 1 |
| 393 | |
| 394 | _active = [] |
| 395 | |
| 396 | def _cleanup(): |
| 397 | for inst in _active[:]: |
| 398 | inst.poll() |
| 399 | |
| 400 | PIPE = -1 |
| 401 | STDOUT = -2 |
| 402 | |
| 403 | |
| 404 | def call(*args, **kwargs): |
| 405 | """Run command with arguments. Wait for command to complete, then |
| 406 | return the returncode attribute. |
| 407 | |
| 408 | The arguments are the same as for the Popen constructor. Example: |
| 409 | |
| 410 | retcode = call(["ls", "-l"]) |
| 411 | """ |
| 412 | return Popen(*args, **kwargs).wait() |
| 413 | |
| 414 | |
| 415 | def list2cmdline(seq): |
| 416 | """ |
| 417 | Translate a sequence of arguments into a command line |
| 418 | string, using the same rules as the MS C runtime: |
| 419 | |
| 420 | 1) Arguments are delimited by white space, which is either a |
| 421 | space or a tab. |
| 422 | |
| 423 | 2) A string surrounded by double quotation marks is |
| 424 | interpreted as a single argument, regardless of white space |
| 425 | contained within. A quoted string can be embedded in an |
| 426 | argument. |
| 427 | |
| 428 | 3) A double quotation mark preceded by a backslash is |
| 429 | interpreted as a literal double quotation mark. |
| 430 | |
| 431 | 4) Backslashes are interpreted literally, unless they |
| 432 | immediately precede a double quotation mark. |
| 433 | |
| 434 | 5) If backslashes immediately precede a double quotation mark, |
| 435 | every pair of backslashes is interpreted as a literal |
| 436 | backslash. If the number of backslashes is odd, the last |
| 437 | backslash escapes the next double quotation mark as |
| 438 | described in rule 3. |
| 439 | """ |
| 440 | |
| 441 | # See |
| 442 | # http://msdn.microsoft.com/library/en-us/vccelng/htm/progs_12.asp |
| 443 | result = [] |
| 444 | needquote = False |
| 445 | for arg in seq: |
| 446 | bs_buf = [] |
| 447 | |
| 448 | # Add a space to separate this argument from the others |
| 449 | if result: |
| 450 | result.append(' ') |
| 451 | |
| 452 | needquote = (" " in arg) or ("\t" in arg) |
| 453 | if needquote: |
| 454 | result.append('"') |
| 455 | |
| 456 | for c in arg: |
| 457 | if c == '\\': |
| 458 | # Don't know if we need to double yet. |
| 459 | bs_buf.append(c) |
| 460 | elif c == '"': |
| 461 | # Double backspaces. |
| 462 | result.append('\\' * len(bs_buf)*2) |
| 463 | bs_buf = [] |
| 464 | result.append('\\"') |
| 465 | else: |
| 466 | # Normal char |
| 467 | if bs_buf: |
| 468 | result.extend(bs_buf) |
| 469 | bs_buf = [] |
| 470 | result.append(c) |
| 471 | |
| 472 | # Add remaining backspaces, if any. |
| 473 | if bs_buf: |
| 474 | result.extend(bs_buf) |
| 475 | |
| 476 | if needquote: |
| 477 | result.extend(bs_buf) |
| 478 | result.append('"') |
| 479 | |
| 480 | return ''.join(result) |
| 481 | |
| 482 | |
| 483 | class Popen(object): |
| 484 | def __init__(self, args, bufsize=0, executable=None, |
| 485 | stdin=None, stdout=None, stderr=None, |
| 486 | preexec_fn=None, close_fds=False, shell=False, |
| 487 | cwd=None, env=None, universal_newlines=False, |
| 488 | startupinfo=None, creationflags=0): |
| 489 | """Create new Popen instance.""" |
| 490 | _cleanup() |
| 491 | |
| 492 | if not isinstance(bufsize, (int, long)): |
| 493 | raise TypeError("bufsize must be an integer") |
| 494 | |
| 495 | if mswindows: |
| 496 | if preexec_fn is not None: |
| 497 | raise ValueError("preexec_fn is not supported on Windows " |
| 498 | "platforms") |
| 499 | if close_fds: |
| 500 | raise ValueError("close_fds is not supported on Windows " |
| 501 | "platforms") |
| 502 | else: |
| 503 | # POSIX |
| 504 | if startupinfo is not None: |
| 505 | raise ValueError("startupinfo is only supported on Windows " |
| 506 | "platforms") |
| 507 | if creationflags != 0: |
| 508 | raise ValueError("creationflags is only supported on Windows " |
| 509 | "platforms") |
| 510 | |
| 511 | self.stdin = None |
| 512 | self.stdout = None |
| 513 | self.stderr = None |
| 514 | self.pid = None |
| 515 | self.returncode = None |
| 516 | self.universal_newlines = universal_newlines |
| 517 | |
| 518 | # Input and output objects. The general principle is like |
| 519 | # this: |
| 520 | # |
| 521 | # Parent Child |
| 522 | # ------ ----- |
| 523 | # p2cwrite ---stdin---> p2cread |
| 524 | # c2pread <--stdout--- c2pwrite |
| 525 | # errread <--stderr--- errwrite |
| 526 | # |
| 527 | # On POSIX, the child objects are file descriptors. On |
| 528 | # Windows, these are Windows file handles. The parent objects |
| 529 | # are file descriptors on both platforms. The parent objects |
| 530 | # are None when not using PIPEs. The child objects are None |
| 531 | # when not redirecting. |
| 532 | |
| 533 | (p2cread, p2cwrite, |
| 534 | c2pread, c2pwrite, |
| 535 | errread, errwrite) = self._get_handles(stdin, stdout, stderr) |
| 536 | |
| 537 | self._execute_child(args, executable, preexec_fn, close_fds, |
| 538 | cwd, env, universal_newlines, |
| 539 | startupinfo, creationflags, shell, |
| 540 | p2cread, p2cwrite, |
| 541 | c2pread, c2pwrite, |
| 542 | errread, errwrite) |
| 543 | |
| 544 | if p2cwrite: |
| 545 | self.stdin = os.fdopen(p2cwrite, 'wb', bufsize) |
| 546 | if c2pread: |
| 547 | if universal_newlines: |
| 548 | self.stdout = os.fdopen(c2pread, 'rU', bufsize) |
| 549 | else: |
| 550 | self.stdout = os.fdopen(c2pread, 'rb', bufsize) |
| 551 | if errread: |
| 552 | if universal_newlines: |
| 553 | self.stderr = os.fdopen(errread, 'rU', bufsize) |
| 554 | else: |
| 555 | self.stderr = os.fdopen(errread, 'rb', bufsize) |
| 556 | |
| 557 | _active.append(self) |
| 558 | |
| 559 | |
| 560 | def _translate_newlines(self, data): |
| 561 | data = data.replace("\r\n", "\n") |
| 562 | data = data.replace("\r", "\n") |
| 563 | return data |
| 564 | |
| 565 | |
| 566 | if mswindows: |
| 567 | # |
| 568 | # Windows methods |
| 569 | # |
| 570 | def _get_handles(self, stdin, stdout, stderr): |
| 571 | """Construct and return tupel with IO objects: |
| 572 | p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite |
| 573 | """ |
| 574 | if stdin == None and stdout == None and stderr == None: |
| 575 | return (None, None, None, None, None, None) |
| 576 | |
| 577 | p2cread, p2cwrite = None, None |
| 578 | c2pread, c2pwrite = None, None |
| 579 | errread, errwrite = None, None |
| 580 | |
| 581 | if stdin == None: |
| 582 | p2cread = GetStdHandle(STD_INPUT_HANDLE) |
| 583 | elif stdin == PIPE: |
| 584 | p2cread, p2cwrite = CreatePipe(None, 0) |
| 585 | # Detach and turn into fd |
| 586 | p2cwrite = p2cwrite.Detach() |
| 587 | p2cwrite = msvcrt.open_osfhandle(p2cwrite, 0) |
| 588 | elif type(stdin) == types.IntType: |
| 589 | p2cread = msvcrt.get_osfhandle(stdin) |
| 590 | else: |
| 591 | # Assuming file-like object |
| 592 | p2cread = msvcrt.get_osfhandle(stdin.fileno()) |
| 593 | p2cread = self._make_inheritable(p2cread) |
| 594 | |
| 595 | if stdout == None: |
| 596 | c2pwrite = GetStdHandle(STD_OUTPUT_HANDLE) |
| 597 | elif stdout == PIPE: |
| 598 | c2pread, c2pwrite = CreatePipe(None, 0) |
| 599 | # Detach and turn into fd |
| 600 | c2pread = c2pread.Detach() |
| 601 | c2pread = msvcrt.open_osfhandle(c2pread, 0) |
| 602 | elif type(stdout) == types.IntType: |
| 603 | c2pwrite = msvcrt.get_osfhandle(stdout) |
| 604 | else: |
| 605 | # Assuming file-like object |
| 606 | c2pwrite = msvcrt.get_osfhandle(stdout.fileno()) |
| 607 | c2pwrite = self._make_inheritable(c2pwrite) |
| 608 | |
| 609 | if stderr == None: |
| 610 | errwrite = GetStdHandle(STD_ERROR_HANDLE) |
| 611 | elif stderr == PIPE: |
| 612 | errread, errwrite = CreatePipe(None, 0) |
| 613 | # Detach and turn into fd |
| 614 | errread = errread.Detach() |
| 615 | errread = msvcrt.open_osfhandle(errread, 0) |
| 616 | elif stderr == STDOUT: |
| 617 | errwrite = c2pwrite |
| 618 | elif type(stderr) == types.IntType: |
| 619 | errwrite = msvcrt.get_osfhandle(stderr) |
| 620 | else: |
| 621 | # Assuming file-like object |
| 622 | errwrite = msvcrt.get_osfhandle(stderr.fileno()) |
| 623 | errwrite = self._make_inheritable(errwrite) |
| 624 | |
| 625 | return (p2cread, p2cwrite, |
| 626 | c2pread, c2pwrite, |
| 627 | errread, errwrite) |
| 628 | |
| 629 | |
| 630 | def _make_inheritable(self, handle): |
| 631 | """Return a duplicate of handle, which is inheritable""" |
| 632 | return DuplicateHandle(GetCurrentProcess(), handle, |
| 633 | GetCurrentProcess(), 0, 1, |
| 634 | DUPLICATE_SAME_ACCESS) |
| 635 | |
| 636 | |
| 637 | def _find_w9xpopen(self): |
| 638 | """Find and return absolut path to w9xpopen.exe""" |
| 639 | w9xpopen = os.path.join(os.path.dirname(GetModuleFileName(0)), |
| 640 | "w9xpopen.exe") |
| 641 | if not os.path.exists(w9xpopen): |
| 642 | # Eeek - file-not-found - possibly an embedding |
| 643 | # situation - see if we can locate it in sys.exec_prefix |
| 644 | w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix), |
| 645 | "w9xpopen.exe") |
| 646 | if not os.path.exists(w9xpopen): |
| 647 | raise RuntimeError("Cannot locate w9xpopen.exe, which is " |
| 648 | "needed for Popen to work with your " |
| 649 | "shell or platform.") |
| 650 | return w9xpopen |
| 651 | |
| 652 | |
| 653 | def _execute_child(self, args, executable, preexec_fn, close_fds, |
| 654 | cwd, env, universal_newlines, |
| 655 | startupinfo, creationflags, shell, |
| 656 | p2cread, p2cwrite, |
| 657 | c2pread, c2pwrite, |
| 658 | errread, errwrite): |
| 659 | """Execute program (MS Windows version)""" |
| 660 | |
| 661 | if not isinstance(args, types.StringTypes): |
| 662 | args = list2cmdline(args) |
| 663 | |
| 664 | # Process startup details |
| 665 | default_startupinfo = STARTUPINFO() |
| 666 | if startupinfo == None: |
| 667 | startupinfo = default_startupinfo |
| 668 | if not None in (p2cread, c2pwrite, errwrite): |
| 669 | startupinfo.dwFlags |= STARTF_USESTDHANDLES |
| 670 | startupinfo.hStdInput = p2cread |
| 671 | startupinfo.hStdOutput = c2pwrite |
| 672 | startupinfo.hStdError = errwrite |
| 673 | |
| 674 | if shell: |
| 675 | default_startupinfo.dwFlags |= STARTF_USESHOWWINDOW |
| 676 | default_startupinfo.wShowWindow = SW_HIDE |
| 677 | comspec = os.environ.get("COMSPEC", "cmd.exe") |
| 678 | args = comspec + " /c " + args |
| 679 | if (GetVersion() >= 0x80000000L or |
| 680 | os.path.basename(comspec).lower() == "command.com"): |
| 681 | # Win9x, or using command.com on NT. We need to |
| 682 | # use the w9xpopen intermediate program. For more |
| 683 | # information, see KB Q150956 |
| 684 | # (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp) |
| 685 | w9xpopen = self._find_w9xpopen() |
| 686 | args = '"%s" %s' % (w9xpopen, args) |
| 687 | # Not passing CREATE_NEW_CONSOLE has been known to |
| 688 | # cause random failures on win9x. Specifically a |
| 689 | # dialog: "Your program accessed mem currently in |
| 690 | # use at xxx" and a hopeful warning about the |
| 691 | # stability of your system. Cost is Ctrl+C wont |
| 692 | # kill children. |
| 693 | creationflags |= CREATE_NEW_CONSOLE |
| 694 | |
| 695 | # Start the process |
| 696 | try: |
| 697 | hp, ht, pid, tid = CreateProcess(executable, args, |
| 698 | # no special security |
| 699 | None, None, |
| 700 | # must inherit handles to pass std |
| 701 | # handles |
| 702 | 1, |
| 703 | creationflags, |
| 704 | env, |
| 705 | cwd, |
| 706 | startupinfo) |
| 707 | except pywintypes.error, e: |
| 708 | # Translate pywintypes.error to WindowsError, which is |
| 709 | # a subclass of OSError. FIXME: We should really |
| 710 | # translate errno using _sys_errlist (or simliar), but |
| 711 | # how can this be done from Python? |
| 712 | raise WindowsError(*e.args) |
| 713 | |
| 714 | # Retain the process handle, but close the thread handle |
| 715 | self._handle = hp |
| 716 | self.pid = pid |
| 717 | ht.Close() |
| 718 | |
| 719 | # Child is launched. Close the parent's copy of those pipe |
| 720 | # handles that only the child should have open. You need |
| 721 | # to make sure that no handles to the write end of the |
| 722 | # output pipe are maintained in this process or else the |
| 723 | # pipe will not close when the child process exits and the |
| 724 | # ReadFile will hang. |
| 725 | if p2cread != None: |
| 726 | p2cread.Close() |
| 727 | if c2pwrite != None: |
| 728 | c2pwrite.Close() |
| 729 | if errwrite != None: |
| 730 | errwrite.Close() |
| 731 | |
| 732 | |
| 733 | def poll(self): |
| 734 | """Check if child process has terminated. Returns returncode |
| 735 | attribute.""" |
| 736 | if self.returncode == None: |
| 737 | if WaitForSingleObject(self._handle, 0) == WAIT_OBJECT_0: |
| 738 | self.returncode = GetExitCodeProcess(self._handle) |
| 739 | _active.remove(self) |
| 740 | return self.returncode |
| 741 | |
| 742 | |
| 743 | def wait(self): |
| 744 | """Wait for child process to terminate. Returns returncode |
| 745 | attribute.""" |
| 746 | if self.returncode == None: |
| 747 | obj = WaitForSingleObject(self._handle, INFINITE) |
| 748 | self.returncode = GetExitCodeProcess(self._handle) |
| 749 | _active.remove(self) |
| 750 | return self.returncode |
| 751 | |
| 752 | |
| 753 | def _readerthread(self, fh, buffer): |
| 754 | buffer.append(fh.read()) |
| 755 | |
| 756 | |
| 757 | def communicate(self, input=None): |
| 758 | """Interact with process: Send data to stdin. Read data from |
| 759 | stdout and stderr, until end-of-file is reached. Wait for |
| 760 | process to terminate. The optional input argument should be a |
| 761 | string to be sent to the child process, or None, if no data |
| 762 | should be sent to the child. |
| 763 | |
| 764 | communicate() returns a tuple (stdout, stderr).""" |
| 765 | stdout = None # Return |
| 766 | stderr = None # Return |
| 767 | |
| 768 | if self.stdout: |
| 769 | stdout = [] |
| 770 | stdout_thread = threading.Thread(target=self._readerthread, |
| 771 | args=(self.stdout, stdout)) |
| 772 | stdout_thread.setDaemon(True) |
| 773 | stdout_thread.start() |
| 774 | if self.stderr: |
| 775 | stderr = [] |
| 776 | stderr_thread = threading.Thread(target=self._readerthread, |
| 777 | args=(self.stderr, stderr)) |
| 778 | stderr_thread.setDaemon(True) |
| 779 | stderr_thread.start() |
| 780 | |
| 781 | if self.stdin: |
| 782 | if input != None: |
| 783 | self.stdin.write(input) |
| 784 | self.stdin.close() |
| 785 | |
| 786 | if self.stdout: |
| 787 | stdout_thread.join() |
| 788 | if self.stderr: |
| 789 | stderr_thread.join() |
| 790 | |
| 791 | # All data exchanged. Translate lists into strings. |
| 792 | if stdout != None: |
| 793 | stdout = stdout[0] |
| 794 | if stderr != None: |
| 795 | stderr = stderr[0] |
| 796 | |
| 797 | # Translate newlines, if requested. We cannot let the file |
| 798 | # object do the translation: It is based on stdio, which is |
| 799 | # impossible to combine with select (unless forcing no |
| 800 | # buffering). |
| 801 | if self.universal_newlines and hasattr(open, 'newlines'): |
| 802 | if stdout: |
| 803 | stdout = self._translate_newlines(stdout) |
| 804 | if stderr: |
| 805 | stderr = self._translate_newlines(stderr) |
| 806 | |
| 807 | self.wait() |
| 808 | return (stdout, stderr) |
| 809 | |
| 810 | else: |
| 811 | # |
| 812 | # POSIX methods |
| 813 | # |
| 814 | def _get_handles(self, stdin, stdout, stderr): |
| 815 | """Construct and return tupel with IO objects: |
| 816 | p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite |
| 817 | """ |
| 818 | p2cread, p2cwrite = None, None |
| 819 | c2pread, c2pwrite = None, None |
| 820 | errread, errwrite = None, None |
| 821 | |
| 822 | if stdin == None: |
| 823 | pass |
| 824 | elif stdin == PIPE: |
| 825 | p2cread, p2cwrite = os.pipe() |
| 826 | elif type(stdin) == types.IntType: |
| 827 | p2cread = stdin |
| 828 | else: |
| 829 | # Assuming file-like object |
| 830 | p2cread = stdin.fileno() |
| 831 | |
| 832 | if stdout == None: |
| 833 | pass |
| 834 | elif stdout == PIPE: |
| 835 | c2pread, c2pwrite = os.pipe() |
| 836 | elif type(stdout) == types.IntType: |
| 837 | c2pwrite = stdout |
| 838 | else: |
| 839 | # Assuming file-like object |
| 840 | c2pwrite = stdout.fileno() |
| 841 | |
| 842 | if stderr == None: |
| 843 | pass |
| 844 | elif stderr == PIPE: |
| 845 | errread, errwrite = os.pipe() |
| 846 | elif stderr == STDOUT: |
| 847 | errwrite = c2pwrite |
| 848 | elif type(stderr) == types.IntType: |
| 849 | errwrite = stderr |
| 850 | else: |
| 851 | # Assuming file-like object |
| 852 | errwrite = stderr.fileno() |
| 853 | |
| 854 | return (p2cread, p2cwrite, |
| 855 | c2pread, c2pwrite, |
| 856 | errread, errwrite) |
| 857 | |
| 858 | |
| 859 | def _set_cloexec_flag(self, fd): |
| 860 | try: |
| 861 | cloexec_flag = fcntl.FD_CLOEXEC |
| 862 | except AttributeError: |
| 863 | cloexec_flag = 1 |
| 864 | |
| 865 | old = fcntl.fcntl(fd, fcntl.F_GETFD) |
| 866 | fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag) |
| 867 | |
| 868 | |
| 869 | def _close_fds(self, but): |
| 870 | for i in range(3, MAXFD): |
| 871 | if i == but: |
| 872 | continue |
| 873 | try: |
| 874 | os.close(i) |
| 875 | except: |
| 876 | pass |
| 877 | |
| 878 | |
| 879 | def _execute_child(self, args, executable, preexec_fn, close_fds, |
| 880 | cwd, env, universal_newlines, |
| 881 | startupinfo, creationflags, shell, |
| 882 | p2cread, p2cwrite, |
| 883 | c2pread, c2pwrite, |
| 884 | errread, errwrite): |
| 885 | """Execute program (POSIX version)""" |
| 886 | |
| 887 | if isinstance(args, types.StringTypes): |
| 888 | args = [args] |
| 889 | |
| 890 | if shell: |
| 891 | args = ["/bin/sh", "-c"] + args |
| 892 | |
| 893 | if executable == None: |
| 894 | executable = args[0] |
| 895 | |
| 896 | # For transferring possible exec failure from child to parent |
| 897 | # The first char specifies the exception type: 0 means |
| 898 | # OSError, 1 means some other error. |
| 899 | errpipe_read, errpipe_write = os.pipe() |
| 900 | self._set_cloexec_flag(errpipe_write) |
| 901 | |
| 902 | self.pid = os.fork() |
| 903 | if self.pid == 0: |
| 904 | # Child |
| 905 | try: |
| 906 | # Close parent's pipe ends |
| 907 | if p2cwrite: |
| 908 | os.close(p2cwrite) |
| 909 | if c2pread: |
| 910 | os.close(c2pread) |
| 911 | if errread: |
| 912 | os.close(errread) |
| 913 | os.close(errpipe_read) |
| 914 | |
| 915 | # Dup fds for child |
| 916 | if p2cread: |
| 917 | os.dup2(p2cread, 0) |
| 918 | if c2pwrite: |
| 919 | os.dup2(c2pwrite, 1) |
| 920 | if errwrite: |
| 921 | os.dup2(errwrite, 2) |
| 922 | |
| 923 | # Close pipe fds. Make sure we doesn't close the same |
| 924 | # fd more than once. |
| 925 | if p2cread: |
| 926 | os.close(p2cread) |
| 927 | if c2pwrite and c2pwrite not in (p2cread,): |
| 928 | os.close(c2pwrite) |
| 929 | if errwrite and errwrite not in (p2cread, c2pwrite): |
| 930 | os.close(errwrite) |
| 931 | |
| 932 | # Close all other fds, if asked for |
| 933 | if close_fds: |
| 934 | self._close_fds(but=errpipe_write) |
| 935 | |
| 936 | if cwd != None: |
| 937 | os.chdir(cwd) |
| 938 | |
| 939 | if preexec_fn: |
| 940 | apply(preexec_fn) |
| 941 | |
| 942 | if env == None: |
| 943 | os.execvp(executable, args) |
| 944 | else: |
| 945 | os.execvpe(executable, args, env) |
| 946 | |
| 947 | except: |
| 948 | exc_type, exc_value, tb = sys.exc_info() |
| 949 | # Save the traceback and attach it to the exception object |
| 950 | exc_lines = traceback.format_exception(exc_type, |
| 951 | exc_value, |
| 952 | tb) |
| 953 | exc_value.child_traceback = ''.join(exc_lines) |
| 954 | os.write(errpipe_write, pickle.dumps(exc_value)) |
| 955 | |
| 956 | # This exitcode won't be reported to applications, so it |
| 957 | # really doesn't matter what we return. |
| 958 | os._exit(255) |
| 959 | |
| 960 | # Parent |
| 961 | os.close(errpipe_write) |
| 962 | if p2cread and p2cwrite: |
| 963 | os.close(p2cread) |
| 964 | if c2pwrite and c2pread: |
| 965 | os.close(c2pwrite) |
| 966 | if errwrite and errread: |
| 967 | os.close(errwrite) |
| 968 | |
| 969 | # Wait for exec to fail or succeed; possibly raising exception |
| 970 | data = os.read(errpipe_read, 1048576) # Exceptions limited to 1 MB |
| 971 | os.close(errpipe_read) |
| 972 | if data != "": |
| 973 | os.waitpid(self.pid, 0) |
| 974 | child_exception = pickle.loads(data) |
| 975 | raise child_exception |
| 976 | |
| 977 | |
| 978 | def _handle_exitstatus(self, sts): |
| 979 | if os.WIFSIGNALED(sts): |
| 980 | self.returncode = -os.WTERMSIG(sts) |
| 981 | elif os.WIFEXITED(sts): |
| 982 | self.returncode = os.WEXITSTATUS(sts) |
| 983 | else: |
| 984 | # Should never happen |
| 985 | raise RuntimeError("Unknown child exit status!") |
| 986 | |
| 987 | _active.remove(self) |
| 988 | |
| 989 | |
| 990 | def poll(self): |
| 991 | """Check if child process has terminated. Returns returncode |
| 992 | attribute.""" |
| 993 | if self.returncode == None: |
| 994 | try: |
| 995 | pid, sts = os.waitpid(self.pid, os.WNOHANG) |
| 996 | if pid == self.pid: |
| 997 | self._handle_exitstatus(sts) |
| 998 | except os.error: |
| 999 | pass |
| 1000 | return self.returncode |
| 1001 | |
| 1002 | |
| 1003 | def wait(self): |
| 1004 | """Wait for child process to terminate. Returns returncode |
| 1005 | attribute.""" |
| 1006 | if self.returncode == None: |
| 1007 | pid, sts = os.waitpid(self.pid, 0) |
| 1008 | self._handle_exitstatus(sts) |
| 1009 | return self.returncode |
| 1010 | |
| 1011 | |
| 1012 | def communicate(self, input=None): |
| 1013 | """Interact with process: Send data to stdin. Read data from |
| 1014 | stdout and stderr, until end-of-file is reached. Wait for |
| 1015 | process to terminate. The optional input argument should be a |
| 1016 | string to be sent to the child process, or None, if no data |
| 1017 | should be sent to the child. |
| 1018 | |
| 1019 | communicate() returns a tuple (stdout, stderr).""" |
| 1020 | read_set = [] |
| 1021 | write_set = [] |
| 1022 | stdout = None # Return |
| 1023 | stderr = None # Return |
| 1024 | |
| 1025 | if self.stdin: |
| 1026 | # Flush stdio buffer. This might block, if the user has |
| 1027 | # been writing to .stdin in an uncontrolled fashion. |
| 1028 | self.stdin.flush() |
| 1029 | if input: |
| 1030 | write_set.append(self.stdin) |
| 1031 | else: |
| 1032 | self.stdin.close() |
| 1033 | if self.stdout: |
| 1034 | read_set.append(self.stdout) |
| 1035 | stdout = [] |
| 1036 | if self.stderr: |
| 1037 | read_set.append(self.stderr) |
| 1038 | stderr = [] |
| 1039 | |
| 1040 | while read_set or write_set: |
| 1041 | rlist, wlist, xlist = select.select(read_set, write_set, []) |
| 1042 | |
| 1043 | if self.stdin in wlist: |
| 1044 | # When select has indicated that the file is writable, |
| 1045 | # we can write up to PIPE_BUF bytes without risk |
| 1046 | # blocking. POSIX defines PIPE_BUF >= 512 |
| 1047 | bytes_written = os.write(self.stdin.fileno(), input[:512]) |
| 1048 | input = input[bytes_written:] |
| 1049 | if not input: |
| 1050 | self.stdin.close() |
| 1051 | write_set.remove(self.stdin) |
| 1052 | |
| 1053 | if self.stdout in rlist: |
| 1054 | data = os.read(self.stdout.fileno(), 1024) |
| 1055 | if data == "": |
| 1056 | self.stdout.close() |
| 1057 | read_set.remove(self.stdout) |
| 1058 | stdout.append(data) |
| 1059 | |
| 1060 | if self.stderr in rlist: |
| 1061 | data = os.read(self.stderr.fileno(), 1024) |
| 1062 | if data == "": |
| 1063 | self.stderr.close() |
| 1064 | read_set.remove(self.stderr) |
| 1065 | stderr.append(data) |
| 1066 | |
| 1067 | # All data exchanged. Translate lists into strings. |
| 1068 | if stdout != None: |
| 1069 | stdout = ''.join(stdout) |
| 1070 | if stderr != None: |
| 1071 | stderr = ''.join(stderr) |
| 1072 | |
| 1073 | # Translate newlines, if requested. We cannot let the file |
| 1074 | # object do the translation: It is based on stdio, which is |
| 1075 | # impossible to combine with select (unless forcing no |
| 1076 | # buffering). |
| 1077 | if self.universal_newlines and hasattr(open, 'newlines'): |
| 1078 | if stdout: |
| 1079 | stdout = self._translate_newlines(stdout) |
| 1080 | if stderr: |
| 1081 | stderr = self._translate_newlines(stderr) |
| 1082 | |
| 1083 | self.wait() |
| 1084 | return (stdout, stderr) |
| 1085 | |
| 1086 | |
| 1087 | def _demo_posix(): |
| 1088 | # |
| 1089 | # Example 1: Simple redirection: Get process list |
| 1090 | # |
| 1091 | plist = Popen(["ps"], stdout=PIPE).communicate()[0] |
| 1092 | print "Process list:" |
| 1093 | print plist |
| 1094 | |
| 1095 | # |
| 1096 | # Example 2: Change uid before executing child |
| 1097 | # |
| 1098 | if os.getuid() == 0: |
| 1099 | p = Popen(["id"], preexec_fn=lambda: os.setuid(100)) |
| 1100 | p.wait() |
| 1101 | |
| 1102 | # |
| 1103 | # Example 3: Connecting several subprocesses |
| 1104 | # |
| 1105 | print "Looking for 'hda'..." |
| 1106 | p1 = Popen(["dmesg"], stdout=PIPE) |
| 1107 | p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE) |
| 1108 | print repr(p2.communicate()[0]) |
| 1109 | |
| 1110 | # |
| 1111 | # Example 4: Catch execution error |
| 1112 | # |
| 1113 | print |
| 1114 | print "Trying a weird file..." |
| 1115 | try: |
| 1116 | print Popen(["/this/path/does/not/exist"]).communicate() |
| 1117 | except OSError, e: |
| 1118 | if e.errno == errno.ENOENT: |
| 1119 | print "The file didn't exist. I thought so..." |
| 1120 | print "Child traceback:" |
| 1121 | print e.child_traceback |
| 1122 | else: |
| 1123 | print "Error", e.errno |
| 1124 | else: |
| 1125 | print >>sys.stderr, "Gosh. No error." |
| 1126 | |
| 1127 | |
| 1128 | def _demo_windows(): |
| 1129 | # |
| 1130 | # Example 1: Connecting several subprocesses |
| 1131 | # |
| 1132 | print "Looking for 'PROMPT' in set output..." |
| 1133 | p1 = Popen("set", stdout=PIPE, shell=True) |
| 1134 | p2 = Popen('find "PROMPT"', stdin=p1.stdout, stdout=PIPE) |
| 1135 | print repr(p2.communicate()[0]) |
| 1136 | |
| 1137 | # |
| 1138 | # Example 2: Simple execution of program |
| 1139 | # |
| 1140 | print "Executing calc..." |
| 1141 | p = Popen("calc") |
| 1142 | p.wait() |
| 1143 | |
| 1144 | |
| 1145 | if __name__ == "__main__": |
| 1146 | if mswindows: |
| 1147 | _demo_windows() |
| 1148 | else: |
| 1149 | _demo_posix() |