blob: abd76ee82f8f430476bd9fafee00f4d650308f8d [file] [log] [blame]
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001# subprocess - Subprocesses with accessible I/O streams
2#
Tim Peterse718f612004-10-12 21:51:32 +00003# For more information about this module, see PEP 324.
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00004#
Peter Astrandc26516b2005-02-21 08:13:02 +00005# This module should remain compatible with Python 2.2, see PEP 291.
6#
Peter Astrand3a708df2005-09-23 17:37:29 +00007# Copyright (c) 2003-2005 by Peter Astrand <astrand@lysator.liu.se>
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00008#
Peter Astrand69bf13f2005-02-14 08:56:32 +00009# Licensed to PSF under a Contributor Agreement.
Peter Astrand3a708df2005-09-23 17:37:29 +000010# See http://www.python.org/2.4/license for licensing details.
Fredrik Lundh5b3687d2004-10-12 15:26:28 +000011
Raymond Hettinger837dd932004-10-17 16:36:53 +000012r"""subprocess - Subprocesses with accessible I/O streams
Fredrik Lundh5b3687d2004-10-12 15:26:28 +000013
Fredrik Lundh15aaacc2004-10-17 14:47:05 +000014This module allows you to spawn processes, connect to their
15input/output/error pipes, and obtain their return codes. This module
16intends to replace several other, older modules and functions, like:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +000017
18os.system
19os.spawn*
20os.popen*
21popen2.*
22commands.*
23
24Information about how the subprocess module can be used to replace these
25modules and functions can be found below.
26
27
28
29Using the subprocess module
30===========================
31This module defines one class called Popen:
32
33class 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
40Arguments are:
41
42args should be a string, or a sequence of program arguments. The
43program to execute is normally the first item in the args sequence or
44string, but can be explicitly set by using the executable argument.
45
46On UNIX, with shell=False (default): In this case, the Popen class
47uses os.execvp() to execute the child program. args should normally
48be a sequence. A string will be treated as a sequence with the string
49as the only item (the program to execute).
50
51On UNIX, with shell=True: If args is a string, it specifies the
52command string to execute through the shell. If args is a sequence,
53the first item specifies the command string, and any additional items
54will be treated as additional shell arguments.
55
56On Windows: the Popen class uses CreateProcess() to execute the child
57program, which operates on strings. If args is a sequence, it will be
58converted to a string using the list2cmdline method. Please note that
59not all MS Windows applications interpret the command line the same
60way: The list2cmdline is designed for applications using the same
61rules as the MS C runtime.
62
63bufsize, if given, has the same meaning as the corresponding argument
64to the built-in open() function: 0 means unbuffered, 1 means line
65buffered, any other positive value means use a buffer of
66(approximately) that size. A negative bufsize means to use the system
67default, which usually means fully buffered. The default value for
68bufsize is 0 (unbuffered).
69
70stdin, stdout and stderr specify the executed programs' standard
71input, standard output and standard error file handles, respectively.
72Valid values are PIPE, an existing file descriptor (a positive
73integer), an existing file object, and None. PIPE indicates that a
74new pipe to the child should be created. With None, no redirection
75will occur; the child's file handles will be inherited from the
76parent. Additionally, stderr can be STDOUT, which indicates that the
77stderr data from the applications should be captured into the same
78file handle as for stdout.
79
80If preexec_fn is set to a callable object, this object will be called
81in the child process just before the child is executed.
82
83If close_fds is true, all file descriptors except 0, 1 and 2 will be
84closed before the child process is executed.
85
86if shell is true, the specified command will be executed through the
87shell.
88
89If cwd is not None, the current directory will be changed to cwd
90before the child is executed.
91
92If env is not None, it defines the environment variables for the new
93process.
94
95If universal_newlines is true, the file objects stdout and stderr are
96opened as a text files, but lines may be terminated by any of '\n',
97the Unix end-of-line convention, '\r', the Macintosh convention or
98'\r\n', the Windows convention. All of these external representations
99are seen as '\n' by the Python program. Note: This feature is only
100available if Python is built with universal newline support (the
101default). Also, the newlines attribute of the file objects stdout,
102stdin and stderr are not updated by the communicate() method.
103
104The startupinfo and creationflags, if given, will be passed to the
105underlying CreateProcess() function. They can specify things such as
106appearance of the main window and priority for the new process.
107(Windows only)
108
109
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000110This module also defines some shortcut functions:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000111
Peter Astrand5f5e1412004-12-05 20:15:36 +0000112call(*popenargs, **kwargs):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000113 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
Peter Astrand454f7672005-01-01 09:36:35 +0000120check_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
Peter Astrand7d1d4362006-07-14 14:04:45 +0000124 return code in the returncode attribute.
Peter Astrand454f7672005-01-01 09:36:35 +0000125
126 The arguments are the same as for the Popen constructor. Example:
127
128 check_call(["ls", "-l"])
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000129
Gregory P. Smith26576802008-12-05 02:27:01 +0000130check_output(*popenargs, **kwargs):
Georg Brandl6ab5d082009-12-20 14:33:20 +0000131 Run command with arguments and return its output as a byte string.
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000132
Georg Brandl6ab5d082009-12-20 14:33:20 +0000133 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.
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000136
Georg Brandl6ab5d082009-12-20 14:33:20 +0000137 The arguments are the same as for the Popen constructor. Example:
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000138
Georg Brandl02e7dfd2009-12-28 08:09:32 +0000139 output = check_output(["ls", "-l", "/dev/null"])
140
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000141
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000142Exceptions
143----------
144Exceptions raised in the child process, before the new program has
145started to execute, will be re-raised in the parent. Additionally,
146the exception object will have one extra attribute called
147'child_traceback', which is a string containing traceback information
148from the childs point of view.
149
150The most common exception raised is OSError. This occurs, for
151example, when trying to execute a non-existent file. Applications
152should prepare for OSErrors.
153
154A ValueError will be raised if Popen is called with invalid arguments.
155
Gregory P. Smith26576802008-12-05 02:27:01 +0000156check_call() and check_output() will raise CalledProcessError, if the
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000157called process returns a non-zero return code.
Peter Astrand454f7672005-01-01 09:36:35 +0000158
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000159
160Security
161--------
162Unlike some other popen functions, this implementation will never call
163/bin/sh implicitly. This means that all characters, including shell
164metacharacters, can safely be passed to child processes.
165
166
167Popen objects
168=============
169Instances of the Popen class have the following methods:
170
171poll()
172 Check if child process has terminated. Returns returncode
173 attribute.
174
175wait()
176 Wait for child process to terminate. Returns returncode attribute.
177
178communicate(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
Neal Norwitza186ee22006-12-29 03:01:53 +0000181 terminate. The optional input argument should be a string to be
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000182 sent to the child process, or None, if no data should be sent to
183 the child.
Tim Peterse718f612004-10-12 21:51:32 +0000184
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000185 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
190The following attributes are also available:
191
192stdin
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
196stdout
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
201stderr
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
206pid
207 The process ID of the child process.
208
209returncode
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
215Replacing older functions with the subprocess module
216====================================================
217In this section, "a ==> b" means that b can be used as a replacement
218for a.
219
220Note: All functions in this section fail (more or less) silently if
221the executed program cannot be found; this module raises an OSError
222exception.
223
224In the following examples, we assume that the subprocess module is
225imported with "from subprocess import *".
226
227
228Replacing /bin/sh shell backquote
229---------------------------------
230output=`mycmd myarg`
231==>
232output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
233
234
235Replacing shell pipe line
236-------------------------
237output=`dmesg | grep hda`
238==>
239p1 = Popen(["dmesg"], stdout=PIPE)
Peter Astrand6fdf3cb2004-11-30 18:06:42 +0000240p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000241output = p2.communicate()[0]
242
243
244Replacing os.system()
245---------------------
246sts = os.system("mycmd" + " myarg")
247==>
248p = Popen("mycmd" + " myarg", shell=True)
Neal Norwitz84404832006-07-10 00:05:34 +0000249pid, sts = os.waitpid(p.pid, 0)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000250
251Note:
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
258A more real-world example would look like this:
259
260try:
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
266except OSError, e:
267 print >>sys.stderr, "Execution failed:", e
268
269
270Replacing os.spawn*
271-------------------
Tim Peterse718f612004-10-12 21:51:32 +0000272P_NOWAIT example:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000273
274pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
275==>
276pid = Popen(["/bin/mycmd", "myarg"]).pid
277
278
279P_WAIT example:
280
281retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
282==>
283retcode = call(["/bin/mycmd", "myarg"])
284
285
Tim Peterse718f612004-10-12 21:51:32 +0000286Vector example:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000287
288os.spawnvp(os.P_NOWAIT, path, args)
289==>
290Popen([path] + args[1:])
291
292
Tim Peterse718f612004-10-12 21:51:32 +0000293Environment example:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000294
295os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
296==>
297Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})
298
299
Tim Peterse718f612004-10-12 21:51:32 +0000300Replacing os.popen*
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000301-------------------
Philip Jenvey8b902042009-09-29 19:10:15 +0000302pipe = os.popen("cmd", mode='r', bufsize)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000303==>
Philip Jenvey8b902042009-09-29 19:10:15 +0000304pipe = Popen("cmd", shell=True, bufsize=bufsize, stdout=PIPE).stdout
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000305
Philip Jenvey8b902042009-09-29 19:10:15 +0000306pipe = os.popen("cmd", mode='w', bufsize)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000307==>
Philip Jenvey8b902042009-09-29 19:10:15 +0000308pipe = Popen("cmd", shell=True, bufsize=bufsize, stdin=PIPE).stdin
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000309
310
Philip Jenvey8b902042009-09-29 19:10:15 +0000311(child_stdin, child_stdout) = os.popen2("cmd", mode, bufsize)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000312==>
Philip Jenvey8b902042009-09-29 19:10:15 +0000313p = Popen("cmd", shell=True, bufsize=bufsize,
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000314 stdin=PIPE, stdout=PIPE, close_fds=True)
315(child_stdin, child_stdout) = (p.stdin, p.stdout)
316
317
318(child_stdin,
319 child_stdout,
Philip Jenvey8b902042009-09-29 19:10:15 +0000320 child_stderr) = os.popen3("cmd", mode, bufsize)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000321==>
Philip Jenvey8b902042009-09-29 19:10:15 +0000322p = Popen("cmd", shell=True, bufsize=bufsize,
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000323 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
Philip Jenvey8b902042009-09-29 19:10:15 +0000329(child_stdin, child_stdout_and_stderr) = os.popen4("cmd", mode,
330 bufsize)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000331==>
Philip Jenvey8b902042009-09-29 19:10:15 +0000332p = Popen("cmd", shell=True, bufsize=bufsize,
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000333 stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
334(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)
335
Philip Jenvey8b902042009-09-29 19:10:15 +0000336On Unix, os.popen2, os.popen3 and os.popen4 also accept a sequence as
337the command to execute, in which case arguments will be passed
338directly to the program without shell intervention. This usage can be
339replaced as follows:
340
341(child_stdin, child_stdout) = os.popen2(["/bin/ls", "-l"], mode,
342 bufsize)
343==>
344p = Popen(["/bin/ls", "-l"], bufsize=bufsize, stdin=PIPE, stdout=PIPE)
345(child_stdin, child_stdout) = (p.stdin, p.stdout)
346
347Return code handling translates as follows:
348
349pipe = os.popen("cmd", 'w')
350...
351rc = pipe.close()
Florent Xiclunacf741ce2010-03-08 10:58:12 +0000352if rc is not None and rc % 256:
Philip Jenvey8b902042009-09-29 19:10:15 +0000353 print "There were some errors"
354==>
355process = Popen("cmd", 'w', shell=True, stdin=PIPE)
356...
357process.stdin.close()
358if process.wait() != 0:
359 print "There were some errors"
360
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000361
362Replacing popen2.*
363------------------
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000364(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
365==>
366p = Popen(["somestring"], shell=True, bufsize=bufsize
367 stdin=PIPE, stdout=PIPE, close_fds=True)
368(child_stdout, child_stdin) = (p.stdout, p.stdin)
369
Philip Jenvey8b902042009-09-29 19:10:15 +0000370On Unix, popen2 also accepts a sequence as the command to execute, in
371which case arguments will be passed directly to the program without
372shell intervention. This usage can be replaced as follows:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000373
Philip Jenvey8b902042009-09-29 19:10:15 +0000374(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize,
375 mode)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000376==>
377p = Popen(["mycmd", "myarg"], bufsize=bufsize,
378 stdin=PIPE, stdout=PIPE, close_fds=True)
379(child_stdout, child_stdin) = (p.stdout, p.stdin)
380
Neal Norwitzaa87fb62007-05-11 06:23:01 +0000381The popen2.Popen3 and popen2.Popen4 basically works as subprocess.Popen,
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000382except 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
Tim Peterse718f612004-10-12 21:51:32 +0000388 close_fds=True with subprocess.Popen.
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000389"""
390
391import sys
392mswindows = (sys.platform == "win32")
393
394import os
Peter Astrandc26516b2005-02-21 08:13:02 +0000395import types
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000396import traceback
Gregory P. Smith87d49792008-01-19 20:57:59 +0000397import gc
Christian Heimese74c8f22008-04-19 02:23:57 +0000398import signal
Ross Lagerwall104c3f12011-04-05 15:24:34 +0200399import errno
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000400
Peter Astrand454f7672005-01-01 09:36:35 +0000401# Exception classes used by this module.
Peter Astrand7d1d4362006-07-14 14:04:45 +0000402class CalledProcessError(Exception):
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000403 """This exception is raised when a process run by check_call() or
Gregory P. Smith26576802008-12-05 02:27:01 +0000404 check_output() returns a non-zero exit status.
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000405 The exit status will be stored in the returncode attribute;
Gregory P. Smith26576802008-12-05 02:27:01 +0000406 check_output() will also store the output in the output attribute.
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000407 """
408 def __init__(self, returncode, cmd, output=None):
Peter Astrand7d1d4362006-07-14 14:04:45 +0000409 self.returncode = returncode
410 self.cmd = cmd
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000411 self.output = output
Peter Astrand7d1d4362006-07-14 14:04:45 +0000412 def __str__(self):
413 return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode)
Tim Peters73a9ead2006-07-18 21:55:15 +0000414
Peter Astrand454f7672005-01-01 09:36:35 +0000415
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000416if mswindows:
417 import threading
418 import msvcrt
Brian Curtina2936cf2010-04-24 15:40:11 +0000419 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
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000428else:
429 import select
Gregory P. Smithdd7ca242009-07-04 01:49:29 +0000430 _has_poll = hasattr(select, 'poll')
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000431 import fcntl
432 import pickle
433
Amaury Forgeot d'Arcce32eb72009-07-09 22:37:22 +0000434 # 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
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000440__all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call",
Gregory P. Smith26576802008-12-05 02:27:01 +0000441 "check_output", "CalledProcessError"]
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000442
Brian Curtina2936cf2010-04-24 15:40:11 +0000443if mswindows:
Brian Curtin77b75912011-04-29 16:21:51 -0500444 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)
Brian Curtin20de4582011-04-29 16:28:52 -0500448
Brian Curtin77b75912011-04-29 16:21:51 -0500449 __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"])
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000453try:
454 MAXFD = os.sysconf("SC_OPEN_MAX")
455except:
456 MAXFD = 256
457
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000458_active = []
459
460def _cleanup():
461 for inst in _active[:]:
Georg Brandl02e7dfd2009-12-28 08:09:32 +0000462 res = inst._internal_poll(_deadstate=sys.maxint)
Charles-François Natalib02302c2011-08-18 17:18:28 +0200463 if res is not None:
Martin v. Löwis17de8ff2006-04-10 15:55:37 +0000464 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
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000470
471PIPE = -1
472STDOUT = -2
473
474
Gregory P. Smithcce211f2010-03-01 00:05:08 +0000475def _eintr_retry_call(func, *args):
476 while True:
477 try:
478 return func(*args)
Victor Stinnere7901312011-07-05 14:08:01 +0200479 except (OSError, IOError) as e:
Gregory P. Smithcce211f2010-03-01 00:05:08 +0000480 if e.errno == errno.EINTR:
481 continue
482 raise
483
484
Peter Astrand5f5e1412004-12-05 20:15:36 +0000485def call(*popenargs, **kwargs):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000486 """Run command with arguments. Wait for command to complete, then
487 return the returncode attribute.
488
489 The arguments are the same as for the Popen constructor. Example:
490
491 retcode = call(["ls", "-l"])
492 """
Peter Astrand5f5e1412004-12-05 20:15:36 +0000493 return Popen(*popenargs, **kwargs).wait()
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000494
495
Peter Astrand454f7672005-01-01 09:36:35 +0000496def check_call(*popenargs, **kwargs):
497 """Run command with arguments. Wait for command to complete. If
498 the exit code was zero then return, otherwise raise
499 CalledProcessError. The CalledProcessError object will have the
Peter Astrand7d1d4362006-07-14 14:04:45 +0000500 return code in the returncode attribute.
Peter Astrand454f7672005-01-01 09:36:35 +0000501
502 The arguments are the same as for the Popen constructor. Example:
503
504 check_call(["ls", "-l"])
505 """
506 retcode = call(*popenargs, **kwargs)
Peter Astrand454f7672005-01-01 09:36:35 +0000507 if retcode:
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000508 cmd = kwargs.get("args")
509 if cmd is None:
510 cmd = popenargs[0]
Peter Astrand7d1d4362006-07-14 14:04:45 +0000511 raise CalledProcessError(retcode, cmd)
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000512 return 0
513
514
Gregory P. Smith26576802008-12-05 02:27:01 +0000515def check_output(*popenargs, **kwargs):
Georg Brandl6ab5d082009-12-20 14:33:20 +0000516 r"""Run command with arguments and return its output as a byte string.
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000517
518 If the exit code was non-zero it raises a CalledProcessError. The
519 CalledProcessError object will have the return code in the returncode
520 attribute and output in the output attribute.
521
522 The arguments are the same as for the Popen constructor. Example:
523
Gregory P. Smith26576802008-12-05 02:27:01 +0000524 >>> check_output(["ls", "-l", "/dev/null"])
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000525 'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
526
527 The stdout argument is not allowed as it is used internally.
Georg Brandl02e7dfd2009-12-28 08:09:32 +0000528 To capture standard error in the result, use stderr=STDOUT.
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000529
Gregory P. Smith26576802008-12-05 02:27:01 +0000530 >>> check_output(["/bin/sh", "-c",
Georg Brandl6ab5d082009-12-20 14:33:20 +0000531 ... "ls -l non_existent_file ; exit 0"],
Georg Brandl02e7dfd2009-12-28 08:09:32 +0000532 ... stderr=STDOUT)
Mark Dickinson3e4caeb2009-02-21 20:27:01 +0000533 'ls: non_existent_file: No such file or directory\n'
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000534 """
535 if 'stdout' in kwargs:
536 raise ValueError('stdout argument not allowed, it will be overridden.')
Amaury Forgeot d'Arc5fe420e2009-06-18 22:32:50 +0000537 process = Popen(stdout=PIPE, *popenargs, **kwargs)
Gregory P. Smith97f49f42008-12-04 20:21:09 +0000538 output, unused_err = process.communicate()
539 retcode = process.poll()
540 if retcode:
541 cmd = kwargs.get("args")
542 if cmd is None:
543 cmd = popenargs[0]
544 raise CalledProcessError(retcode, cmd, output=output)
545 return output
Peter Astrand454f7672005-01-01 09:36:35 +0000546
547
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000548def list2cmdline(seq):
549 """
550 Translate a sequence of arguments into a command line
551 string, using the same rules as the MS C runtime:
552
553 1) Arguments are delimited by white space, which is either a
554 space or a tab.
555
556 2) A string surrounded by double quotation marks is
557 interpreted as a single argument, regardless of white space
Jean-Paul Calderoneb33f0c12010-06-18 20:00:17 +0000558 contained within. A quoted string can be embedded in an
559 argument.
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000560
561 3) A double quotation mark preceded by a backslash is
562 interpreted as a literal double quotation mark.
563
564 4) Backslashes are interpreted literally, unless they
565 immediately precede a double quotation mark.
566
567 5) If backslashes immediately precede a double quotation mark,
568 every pair of backslashes is interpreted as a literal
569 backslash. If the number of backslashes is odd, the last
570 backslash escapes the next double quotation mark as
571 described in rule 3.
572 """
573
574 # See
Eric Smithd19915e2009-11-09 15:16:23 +0000575 # http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
576 # or search http://msdn.microsoft.com for
577 # "Parsing C++ Command-Line Arguments"
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000578 result = []
579 needquote = False
580 for arg in seq:
581 bs_buf = []
582
583 # Add a space to separate this argument from the others
584 if result:
585 result.append(' ')
586
Jean-Paul Calderoneb33f0c12010-06-18 20:00:17 +0000587 needquote = (" " in arg) or ("\t" in arg) or not arg
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000588 if needquote:
589 result.append('"')
590
591 for c in arg:
592 if c == '\\':
Tim Peterse718f612004-10-12 21:51:32 +0000593 # Don't know if we need to double yet.
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000594 bs_buf.append(c)
595 elif c == '"':
Gregory P. Smithe047e6d2008-01-19 20:49:02 +0000596 # Double backslashes.
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000597 result.append('\\' * len(bs_buf)*2)
598 bs_buf = []
599 result.append('\\"')
600 else:
601 # Normal char
602 if bs_buf:
603 result.extend(bs_buf)
604 bs_buf = []
605 result.append(c)
606
Gregory P. Smithe047e6d2008-01-19 20:49:02 +0000607 # Add remaining backslashes, if any.
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000608 if bs_buf:
609 result.extend(bs_buf)
610
611 if needquote:
Peter Astrand7e78ade2005-03-03 21:10:23 +0000612 result.extend(bs_buf)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000613 result.append('"')
614
615 return ''.join(result)
616
617
618class Popen(object):
619 def __init__(self, args, bufsize=0, executable=None,
620 stdin=None, stdout=None, stderr=None,
621 preexec_fn=None, close_fds=False, shell=False,
622 cwd=None, env=None, universal_newlines=False,
623 startupinfo=None, creationflags=0):
624 """Create new Popen instance."""
625 _cleanup()
626
Martin v. Löwis17de8ff2006-04-10 15:55:37 +0000627 self._child_created = False
Peter Astrand738131d2004-11-30 21:04:45 +0000628 if not isinstance(bufsize, (int, long)):
629 raise TypeError("bufsize must be an integer")
630
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000631 if mswindows:
Tim Peterse8374a52004-10-13 03:15:00 +0000632 if preexec_fn is not None:
633 raise ValueError("preexec_fn is not supported on Windows "
634 "platforms")
Peter Astrand81a191b2007-05-26 22:18:20 +0000635 if close_fds and (stdin is not None or stdout is not None or
636 stderr is not None):
Tim Peterse8374a52004-10-13 03:15:00 +0000637 raise ValueError("close_fds is not supported on Windows "
Peter Astrand81a191b2007-05-26 22:18:20 +0000638 "platforms if you redirect stdin/stdout/stderr")
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000639 else:
640 # POSIX
Tim Peterse8374a52004-10-13 03:15:00 +0000641 if startupinfo is not None:
642 raise ValueError("startupinfo is only supported on Windows "
643 "platforms")
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000644 if creationflags != 0:
Tim Peterse8374a52004-10-13 03:15:00 +0000645 raise ValueError("creationflags is only supported on Windows "
646 "platforms")
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000647
Tim Peterse718f612004-10-12 21:51:32 +0000648 self.stdin = None
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000649 self.stdout = None
650 self.stderr = None
651 self.pid = None
652 self.returncode = None
653 self.universal_newlines = universal_newlines
654
655 # Input and output objects. The general principle is like
656 # this:
657 #
658 # Parent Child
659 # ------ -----
660 # p2cwrite ---stdin---> p2cread
661 # c2pread <--stdout--- c2pwrite
662 # errread <--stderr--- errwrite
663 #
664 # On POSIX, the child objects are file descriptors. On
665 # Windows, these are Windows file handles. The parent objects
666 # are file descriptors on both platforms. The parent objects
667 # are None when not using PIPEs. The child objects are None
668 # when not redirecting.
Tim Peterse718f612004-10-12 21:51:32 +0000669
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000670 (p2cread, p2cwrite,
671 c2pread, c2pwrite,
672 errread, errwrite) = self._get_handles(stdin, stdout, stderr)
673
674 self._execute_child(args, executable, preexec_fn, close_fds,
675 cwd, env, universal_newlines,
676 startupinfo, creationflags, shell,
677 p2cread, p2cwrite,
678 c2pread, c2pwrite,
679 errread, errwrite)
680
Peter Astrand5f9c6ae2007-02-06 15:37:50 +0000681 if mswindows:
Hirokazu Yamamotoeacbbdf2009-03-03 22:18:14 +0000682 if p2cwrite is not None:
683 p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0)
684 if c2pread is not None:
685 c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0)
686 if errread is not None:
687 errread = msvcrt.open_osfhandle(errread.Detach(), 0)
Peter Astrand5f9c6ae2007-02-06 15:37:50 +0000688
Peter Astrandf5400032007-02-02 19:06:36 +0000689 if p2cwrite is not None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000690 self.stdin = os.fdopen(p2cwrite, 'wb', bufsize)
Peter Astrandf5400032007-02-02 19:06:36 +0000691 if c2pread is not None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000692 if universal_newlines:
693 self.stdout = os.fdopen(c2pread, 'rU', bufsize)
694 else:
695 self.stdout = os.fdopen(c2pread, 'rb', bufsize)
Peter Astrandf5400032007-02-02 19:06:36 +0000696 if errread is not None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000697 if universal_newlines:
698 self.stderr = os.fdopen(errread, 'rU', bufsize)
699 else:
700 self.stderr = os.fdopen(errread, 'rb', bufsize)
Tim Peterse718f612004-10-12 21:51:32 +0000701
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000702
703 def _translate_newlines(self, data):
704 data = data.replace("\r\n", "\n")
705 data = data.replace("\r", "\n")
706 return data
707
Martin v. Löwis17de8ff2006-04-10 15:55:37 +0000708
Brett Cannon42a0ba72010-05-14 00:21:48 +0000709 def __del__(self, _maxint=sys.maxint, _active=_active):
Victor Stinner776e69b2011-06-01 01:03:00 +0200710 # If __init__ hasn't had a chance to execute (e.g. if it
711 # was passed an undeclared keyword argument), we don't
712 # have a _child_created attribute at all.
713 if not getattr(self, '_child_created', False):
Martin v. Löwis17de8ff2006-04-10 15:55:37 +0000714 # We didn't get to successfully create a child process.
715 return
716 # In case the child hasn't been waited on, check if it's done.
Brett Cannon42a0ba72010-05-14 00:21:48 +0000717 self._internal_poll(_deadstate=_maxint)
Georg Brandl13cf38c2006-07-20 16:28:39 +0000718 if self.returncode is None and _active is not None:
Martin v. Löwis17de8ff2006-04-10 15:55:37 +0000719 # Child is still running, keep us alive until we can wait on it.
720 _active.append(self)
721
722
Peter Astrand23109f02005-03-03 20:28:59 +0000723 def communicate(self, input=None):
724 """Interact with process: Send data to stdin. Read data from
725 stdout and stderr, until end-of-file is reached. Wait for
726 process to terminate. The optional input argument should be a
727 string to be sent to the child process, or None, if no data
728 should be sent to the child.
Tim Peterseba28be2005-03-28 01:08:02 +0000729
Peter Astrand23109f02005-03-03 20:28:59 +0000730 communicate() returns a tuple (stdout, stderr)."""
731
732 # Optimization: If we are only using one pipe, or no pipe at
733 # all, using select() or threads is unnecessary.
734 if [self.stdin, self.stdout, self.stderr].count(None) >= 2:
Tim Peterseba28be2005-03-28 01:08:02 +0000735 stdout = None
736 stderr = None
Peter Astrand23109f02005-03-03 20:28:59 +0000737 if self.stdin:
738 if input:
Ross Lagerwall104c3f12011-04-05 15:24:34 +0200739 try:
740 self.stdin.write(input)
741 except IOError as e:
742 if e.errno != errno.EPIPE and e.errno != errno.EINVAL:
743 raise
Peter Astrand23109f02005-03-03 20:28:59 +0000744 self.stdin.close()
745 elif self.stdout:
Victor Stinnere7901312011-07-05 14:08:01 +0200746 stdout = _eintr_retry_call(self.stdout.read)
Gregory P. Smith4036fd42008-05-26 20:22:14 +0000747 self.stdout.close()
Peter Astrand23109f02005-03-03 20:28:59 +0000748 elif self.stderr:
Victor Stinnere7901312011-07-05 14:08:01 +0200749 stderr = _eintr_retry_call(self.stderr.read)
Gregory P. Smith4036fd42008-05-26 20:22:14 +0000750 self.stderr.close()
Peter Astrand23109f02005-03-03 20:28:59 +0000751 self.wait()
752 return (stdout, stderr)
Tim Peterseba28be2005-03-28 01:08:02 +0000753
Peter Astrand23109f02005-03-03 20:28:59 +0000754 return self._communicate(input)
755
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000756
Gregory P. Smitha36f8fe2008-08-04 00:13:29 +0000757 def poll(self):
758 return self._internal_poll()
759
760
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000761 if mswindows:
762 #
763 # Windows methods
764 #
765 def _get_handles(self, stdin, stdout, stderr):
Amaury Forgeot d'Arc8318afa2009-07-10 16:47:42 +0000766 """Construct and return tuple with IO objects:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000767 p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
768 """
Peter Astrandd38ddf42005-02-10 08:32:50 +0000769 if stdin is None and stdout is None and stderr is None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000770 return (None, None, None, None, None, None)
Tim Peterse718f612004-10-12 21:51:32 +0000771
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000772 p2cread, p2cwrite = None, None
773 c2pread, c2pwrite = None, None
774 errread, errwrite = None, None
775
Peter Astrandd38ddf42005-02-10 08:32:50 +0000776 if stdin is None:
Brian Curtina2936cf2010-04-24 15:40:11 +0000777 p2cread = _subprocess.GetStdHandle(_subprocess.STD_INPUT_HANDLE)
Hirokazu Yamamotoeacbbdf2009-03-03 22:18:14 +0000778 if p2cread is None:
Brian Curtina2936cf2010-04-24 15:40:11 +0000779 p2cread, _ = _subprocess.CreatePipe(None, 0)
Hirokazu Yamamotoeacbbdf2009-03-03 22:18:14 +0000780 elif stdin == PIPE:
Brian Curtina2936cf2010-04-24 15:40:11 +0000781 p2cread, p2cwrite = _subprocess.CreatePipe(None, 0)
Peter Astrandd38ddf42005-02-10 08:32:50 +0000782 elif isinstance(stdin, int):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000783 p2cread = msvcrt.get_osfhandle(stdin)
784 else:
785 # Assuming file-like object
786 p2cread = msvcrt.get_osfhandle(stdin.fileno())
787 p2cread = self._make_inheritable(p2cread)
788
Peter Astrandd38ddf42005-02-10 08:32:50 +0000789 if stdout is None:
Brian Curtina2936cf2010-04-24 15:40:11 +0000790 c2pwrite = _subprocess.GetStdHandle(_subprocess.STD_OUTPUT_HANDLE)
Hirokazu Yamamotoeacbbdf2009-03-03 22:18:14 +0000791 if c2pwrite is None:
Brian Curtina2936cf2010-04-24 15:40:11 +0000792 _, c2pwrite = _subprocess.CreatePipe(None, 0)
Hirokazu Yamamotoeacbbdf2009-03-03 22:18:14 +0000793 elif stdout == PIPE:
Brian Curtina2936cf2010-04-24 15:40:11 +0000794 c2pread, c2pwrite = _subprocess.CreatePipe(None, 0)
Peter Astrandd38ddf42005-02-10 08:32:50 +0000795 elif isinstance(stdout, int):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000796 c2pwrite = msvcrt.get_osfhandle(stdout)
797 else:
798 # Assuming file-like object
799 c2pwrite = msvcrt.get_osfhandle(stdout.fileno())
800 c2pwrite = self._make_inheritable(c2pwrite)
801
Peter Astrandd38ddf42005-02-10 08:32:50 +0000802 if stderr is None:
Brian Curtina2936cf2010-04-24 15:40:11 +0000803 errwrite = _subprocess.GetStdHandle(_subprocess.STD_ERROR_HANDLE)
Hirokazu Yamamotoeacbbdf2009-03-03 22:18:14 +0000804 if errwrite is None:
Brian Curtina2936cf2010-04-24 15:40:11 +0000805 _, errwrite = _subprocess.CreatePipe(None, 0)
Hirokazu Yamamotoeacbbdf2009-03-03 22:18:14 +0000806 elif stderr == PIPE:
Brian Curtina2936cf2010-04-24 15:40:11 +0000807 errread, errwrite = _subprocess.CreatePipe(None, 0)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000808 elif stderr == STDOUT:
809 errwrite = c2pwrite
Peter Astrandd38ddf42005-02-10 08:32:50 +0000810 elif isinstance(stderr, int):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000811 errwrite = msvcrt.get_osfhandle(stderr)
812 else:
813 # Assuming file-like object
814 errwrite = msvcrt.get_osfhandle(stderr.fileno())
815 errwrite = self._make_inheritable(errwrite)
816
817 return (p2cread, p2cwrite,
818 c2pread, c2pwrite,
819 errread, errwrite)
820
821
822 def _make_inheritable(self, handle):
823 """Return a duplicate of handle, which is inheritable"""
Brian Curtina2936cf2010-04-24 15:40:11 +0000824 return _subprocess.DuplicateHandle(_subprocess.GetCurrentProcess(),
825 handle, _subprocess.GetCurrentProcess(), 0, 1,
826 _subprocess.DUPLICATE_SAME_ACCESS)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000827
828
829 def _find_w9xpopen(self):
830 """Find and return absolut path to w9xpopen.exe"""
Brian Curtina2936cf2010-04-24 15:40:11 +0000831 w9xpopen = os.path.join(
832 os.path.dirname(_subprocess.GetModuleFileName(0)),
Tim Peterse8374a52004-10-13 03:15:00 +0000833 "w9xpopen.exe")
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000834 if not os.path.exists(w9xpopen):
835 # Eeek - file-not-found - possibly an embedding
836 # situation - see if we can locate it in sys.exec_prefix
Tim Peterse8374a52004-10-13 03:15:00 +0000837 w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix),
838 "w9xpopen.exe")
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000839 if not os.path.exists(w9xpopen):
Tim Peterse8374a52004-10-13 03:15:00 +0000840 raise RuntimeError("Cannot locate w9xpopen.exe, which is "
841 "needed for Popen to work with your "
842 "shell or platform.")
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000843 return w9xpopen
844
Tim Peterse718f612004-10-12 21:51:32 +0000845
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000846 def _execute_child(self, args, executable, preexec_fn, close_fds,
847 cwd, env, universal_newlines,
848 startupinfo, creationflags, shell,
849 p2cread, p2cwrite,
850 c2pread, c2pwrite,
851 errread, errwrite):
852 """Execute program (MS Windows version)"""
853
Peter Astrandc26516b2005-02-21 08:13:02 +0000854 if not isinstance(args, types.StringTypes):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000855 args = list2cmdline(args)
856
Peter Astrandc1d65362004-11-07 14:30:34 +0000857 # Process startup details
Peter Astrandd38ddf42005-02-10 08:32:50 +0000858 if startupinfo is None:
Georg Brandlad624892006-06-04 22:15:37 +0000859 startupinfo = STARTUPINFO()
860 if None not in (p2cread, c2pwrite, errwrite):
Brian Curtina2936cf2010-04-24 15:40:11 +0000861 startupinfo.dwFlags |= _subprocess.STARTF_USESTDHANDLES
Peter Astrandc1d65362004-11-07 14:30:34 +0000862 startupinfo.hStdInput = p2cread
863 startupinfo.hStdOutput = c2pwrite
864 startupinfo.hStdError = errwrite
865
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000866 if shell:
Brian Curtina2936cf2010-04-24 15:40:11 +0000867 startupinfo.dwFlags |= _subprocess.STARTF_USESHOWWINDOW
868 startupinfo.wShowWindow = _subprocess.SW_HIDE
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000869 comspec = os.environ.get("COMSPEC", "cmd.exe")
Tim Golden8e4756c2010-08-12 11:00:35 +0000870 args = '{} /c "{}"'.format (comspec, args)
871 if (_subprocess.GetVersion() >= 0x80000000 or
Tim Peterse8374a52004-10-13 03:15:00 +0000872 os.path.basename(comspec).lower() == "command.com"):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000873 # Win9x, or using command.com on NT. We need to
874 # use the w9xpopen intermediate program. For more
875 # information, see KB Q150956
876 # (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp)
877 w9xpopen = self._find_w9xpopen()
878 args = '"%s" %s' % (w9xpopen, args)
879 # Not passing CREATE_NEW_CONSOLE has been known to
880 # cause random failures on win9x. Specifically a
881 # dialog: "Your program accessed mem currently in
882 # use at xxx" and a hopeful warning about the
883 # stability of your system. Cost is Ctrl+C wont
884 # kill children.
Brian Curtina2936cf2010-04-24 15:40:11 +0000885 creationflags |= _subprocess.CREATE_NEW_CONSOLE
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000886
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000887 # Start the process
888 try:
Brian Curtina2936cf2010-04-24 15:40:11 +0000889 hp, ht, pid, tid = _subprocess.CreateProcess(executable, args,
Tim Peterse8374a52004-10-13 03:15:00 +0000890 # no special security
891 None, None,
Peter Astrand81a191b2007-05-26 22:18:20 +0000892 int(not close_fds),
Tim Peterse8374a52004-10-13 03:15:00 +0000893 creationflags,
894 env,
895 cwd,
896 startupinfo)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000897 except pywintypes.error, e:
898 # Translate pywintypes.error to WindowsError, which is
899 # a subclass of OSError. FIXME: We should really
Ezio Melottic2077b02011-03-16 12:34:31 +0200900 # translate errno using _sys_errlist (or similar), but
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000901 # how can this be done from Python?
902 raise WindowsError(*e.args)
Tim Golden431774f2010-08-08 11:17:56 +0000903 finally:
904 # Child is launched. Close the parent's copy of those pipe
905 # handles that only the child should have open. You need
906 # to make sure that no handles to the write end of the
907 # output pipe are maintained in this process or else the
908 # pipe will not close when the child process exits and the
909 # ReadFile will hang.
910 if p2cread is not None:
911 p2cread.Close()
912 if c2pwrite is not None:
913 c2pwrite.Close()
914 if errwrite is not None:
915 errwrite.Close()
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000916
917 # Retain the process handle, but close the thread handle
Martin v. Löwis17de8ff2006-04-10 15:55:37 +0000918 self._child_created = True
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000919 self._handle = hp
920 self.pid = pid
921 ht.Close()
922
Brett Cannon42a0ba72010-05-14 00:21:48 +0000923 def _internal_poll(self, _deadstate=None,
Victor Stinner2b271f72010-05-14 21:52:26 +0000924 _WaitForSingleObject=_subprocess.WaitForSingleObject,
925 _WAIT_OBJECT_0=_subprocess.WAIT_OBJECT_0,
926 _GetExitCodeProcess=_subprocess.GetExitCodeProcess):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000927 """Check if child process has terminated. Returns returncode
Brett Cannon42a0ba72010-05-14 00:21:48 +0000928 attribute.
929
930 This method is called by __del__, so it can only refer to objects
931 in its local scope.
932
933 """
Peter Astrandd38ddf42005-02-10 08:32:50 +0000934 if self.returncode is None:
Brett Cannon42a0ba72010-05-14 00:21:48 +0000935 if _WaitForSingleObject(self._handle, 0) == _WAIT_OBJECT_0:
936 self.returncode = _GetExitCodeProcess(self._handle)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000937 return self.returncode
938
939
940 def wait(self):
941 """Wait for child process to terminate. Returns returncode
942 attribute."""
Peter Astrandd38ddf42005-02-10 08:32:50 +0000943 if self.returncode is None:
Brian Curtina2936cf2010-04-24 15:40:11 +0000944 _subprocess.WaitForSingleObject(self._handle,
945 _subprocess.INFINITE)
946 self.returncode = _subprocess.GetExitCodeProcess(self._handle)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000947 return self.returncode
948
949
950 def _readerthread(self, fh, buffer):
951 buffer.append(fh.read())
952
953
Peter Astrand23109f02005-03-03 20:28:59 +0000954 def _communicate(self, input):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000955 stdout = None # Return
956 stderr = None # Return
957
958 if self.stdout:
959 stdout = []
Tim Peterse8374a52004-10-13 03:15:00 +0000960 stdout_thread = threading.Thread(target=self._readerthread,
961 args=(self.stdout, stdout))
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000962 stdout_thread.setDaemon(True)
963 stdout_thread.start()
964 if self.stderr:
965 stderr = []
Tim Peterse8374a52004-10-13 03:15:00 +0000966 stderr_thread = threading.Thread(target=self._readerthread,
967 args=(self.stderr, stderr))
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000968 stderr_thread.setDaemon(True)
969 stderr_thread.start()
970
971 if self.stdin:
Peter Astrandd38ddf42005-02-10 08:32:50 +0000972 if input is not None:
Ross Lagerwall104c3f12011-04-05 15:24:34 +0200973 try:
974 self.stdin.write(input)
975 except IOError as e:
976 if e.errno != errno.EPIPE:
977 raise
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000978 self.stdin.close()
979
980 if self.stdout:
981 stdout_thread.join()
982 if self.stderr:
983 stderr_thread.join()
984
985 # All data exchanged. Translate lists into strings.
Peter Astrandd38ddf42005-02-10 08:32:50 +0000986 if stdout is not None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000987 stdout = stdout[0]
Peter Astrandd38ddf42005-02-10 08:32:50 +0000988 if stderr is not None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000989 stderr = stderr[0]
990
991 # Translate newlines, if requested. We cannot let the file
992 # object do the translation: It is based on stdio, which is
993 # impossible to combine with select (unless forcing no
994 # buffering).
Neal Norwitza6d01ce2006-05-02 06:23:22 +0000995 if self.universal_newlines and hasattr(file, 'newlines'):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +0000996 if stdout:
997 stdout = self._translate_newlines(stdout)
998 if stderr:
999 stderr = self._translate_newlines(stderr)
1000
1001 self.wait()
1002 return (stdout, stderr)
1003
Christian Heimese74c8f22008-04-19 02:23:57 +00001004 def send_signal(self, sig):
1005 """Send a signal to the process
1006 """
1007 if sig == signal.SIGTERM:
1008 self.terminate()
Brian Curtine5aa8862010-04-02 23:26:06 +00001009 elif sig == signal.CTRL_C_EVENT:
1010 os.kill(self.pid, signal.CTRL_C_EVENT)
1011 elif sig == signal.CTRL_BREAK_EVENT:
1012 os.kill(self.pid, signal.CTRL_BREAK_EVENT)
Christian Heimese74c8f22008-04-19 02:23:57 +00001013 else:
Brian Curtine80513c2010-09-07 13:27:20 +00001014 raise ValueError("Unsupported signal: {}".format(sig))
Christian Heimese74c8f22008-04-19 02:23:57 +00001015
1016 def terminate(self):
1017 """Terminates the process
1018 """
Brian Curtina2936cf2010-04-24 15:40:11 +00001019 _subprocess.TerminateProcess(self._handle, 1)
Christian Heimese74c8f22008-04-19 02:23:57 +00001020
1021 kill = terminate
1022
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001023 else:
1024 #
1025 # POSIX methods
1026 #
1027 def _get_handles(self, stdin, stdout, stderr):
Amaury Forgeot d'Arc8318afa2009-07-10 16:47:42 +00001028 """Construct and return tuple with IO objects:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001029 p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
1030 """
1031 p2cread, p2cwrite = None, None
1032 c2pread, c2pwrite = None, None
1033 errread, errwrite = None, None
1034
Peter Astrandd38ddf42005-02-10 08:32:50 +00001035 if stdin is None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001036 pass
1037 elif stdin == PIPE:
1038 p2cread, p2cwrite = os.pipe()
Peter Astrandd38ddf42005-02-10 08:32:50 +00001039 elif isinstance(stdin, int):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001040 p2cread = stdin
1041 else:
1042 # Assuming file-like object
1043 p2cread = stdin.fileno()
1044
Peter Astrandd38ddf42005-02-10 08:32:50 +00001045 if stdout is None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001046 pass
1047 elif stdout == PIPE:
1048 c2pread, c2pwrite = os.pipe()
Peter Astrandd38ddf42005-02-10 08:32:50 +00001049 elif isinstance(stdout, int):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001050 c2pwrite = stdout
1051 else:
1052 # Assuming file-like object
Tim Peterse718f612004-10-12 21:51:32 +00001053 c2pwrite = stdout.fileno()
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001054
Peter Astrandd38ddf42005-02-10 08:32:50 +00001055 if stderr is None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001056 pass
1057 elif stderr == PIPE:
1058 errread, errwrite = os.pipe()
1059 elif stderr == STDOUT:
1060 errwrite = c2pwrite
Peter Astrandd38ddf42005-02-10 08:32:50 +00001061 elif isinstance(stderr, int):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001062 errwrite = stderr
1063 else:
1064 # Assuming file-like object
1065 errwrite = stderr.fileno()
1066
1067 return (p2cread, p2cwrite,
1068 c2pread, c2pwrite,
1069 errread, errwrite)
1070
1071
Antoine Pitrou91ce0d92011-01-03 18:45:09 +00001072 def _set_cloexec_flag(self, fd, cloexec=True):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001073 try:
1074 cloexec_flag = fcntl.FD_CLOEXEC
1075 except AttributeError:
1076 cloexec_flag = 1
1077
1078 old = fcntl.fcntl(fd, fcntl.F_GETFD)
Antoine Pitrou91ce0d92011-01-03 18:45:09 +00001079 if cloexec:
1080 fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag)
1081 else:
1082 fcntl.fcntl(fd, fcntl.F_SETFD, old & ~cloexec_flag)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001083
1084
1085 def _close_fds(self, but):
Amaury Forgeot d'Arc5fe420e2009-06-18 22:32:50 +00001086 if hasattr(os, 'closerange'):
1087 os.closerange(3, but)
1088 os.closerange(but + 1, MAXFD)
1089 else:
1090 for i in xrange(3, MAXFD):
1091 if i == but:
1092 continue
1093 try:
1094 os.close(i)
1095 except:
1096 pass
Tim Peterse718f612004-10-12 21:51:32 +00001097
1098
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001099 def _execute_child(self, args, executable, preexec_fn, close_fds,
1100 cwd, env, universal_newlines,
1101 startupinfo, creationflags, shell,
1102 p2cread, p2cwrite,
1103 c2pread, c2pwrite,
1104 errread, errwrite):
1105 """Execute program (POSIX version)"""
1106
Peter Astrandc26516b2005-02-21 08:13:02 +00001107 if isinstance(args, types.StringTypes):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001108 args = [args]
Georg Brandl6c0e1e82006-10-29 09:05:04 +00001109 else:
1110 args = list(args)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001111
1112 if shell:
1113 args = ["/bin/sh", "-c"] + args
Stefan Krahe9a6a7d2010-07-19 14:41:08 +00001114 if executable:
1115 args[0] = executable
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001116
Peter Astrandd38ddf42005-02-10 08:32:50 +00001117 if executable is None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001118 executable = args[0]
1119
1120 # For transferring possible exec failure from child to parent
1121 # The first char specifies the exception type: 0 means
1122 # OSError, 1 means some other error.
1123 errpipe_read, errpipe_write = os.pipe()
Gregory P. Smith87d49792008-01-19 20:57:59 +00001124 try:
Gregory P. Smith92ffc632008-01-19 22:23:56 +00001125 try:
Facundo Batista8c826b72009-06-19 18:02:28 +00001126 self._set_cloexec_flag(errpipe_write)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001127
Facundo Batista8c826b72009-06-19 18:02:28 +00001128 gc_was_enabled = gc.isenabled()
1129 # Disable gc to avoid bug where gc -> file_dealloc ->
1130 # write to stderr -> hang. http://bugs.python.org/issue1336
1131 gc.disable()
1132 try:
1133 self.pid = os.fork()
Georg Brandl3e8b8692009-07-16 21:47:51 +00001134 except:
Facundo Batista8c826b72009-06-19 18:02:28 +00001135 if gc_was_enabled:
1136 gc.enable()
Georg Brandl3e8b8692009-07-16 21:47:51 +00001137 raise
Facundo Batista8c826b72009-06-19 18:02:28 +00001138 self._child_created = True
1139 if self.pid == 0:
1140 # Child
1141 try:
1142 # Close parent's pipe ends
1143 if p2cwrite is not None:
1144 os.close(p2cwrite)
1145 if c2pread is not None:
1146 os.close(c2pread)
1147 if errread is not None:
1148 os.close(errread)
1149 os.close(errpipe_read)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001150
Ross Lagerwalld8e39012011-07-27 18:54:53 +02001151 # When duping fds, if there arises a situation
1152 # where one of the fds is either 0, 1 or 2, it
1153 # is possible that it is overwritten (#12607).
1154 if c2pwrite == 0:
1155 c2pwrite = os.dup(c2pwrite)
1156 if errwrite == 0 or errwrite == 1:
1157 errwrite = os.dup(errwrite)
1158
Facundo Batista8c826b72009-06-19 18:02:28 +00001159 # Dup fds for child
Antoine Pitrou91ce0d92011-01-03 18:45:09 +00001160 def _dup2(a, b):
1161 # dup2() removes the CLOEXEC flag but
1162 # we must do it ourselves if dup2()
1163 # would be a no-op (issue #10806).
1164 if a == b:
1165 self._set_cloexec_flag(a, False)
1166 elif a is not None:
1167 os.dup2(a, b)
1168 _dup2(p2cread, 0)
1169 _dup2(c2pwrite, 1)
1170 _dup2(errwrite, 2)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001171
Antoine Pitrou91ce0d92011-01-03 18:45:09 +00001172 # Close pipe fds. Make sure we don't close the
1173 # same fd more than once, or standard fds.
1174 closed = { None }
1175 for fd in [p2cread, c2pwrite, errwrite]:
1176 if fd not in closed and fd > 2:
1177 os.close(fd)
1178 closed.add(fd)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001179
Facundo Batista8c826b72009-06-19 18:02:28 +00001180 # Close all other fds, if asked for
1181 if close_fds:
1182 self._close_fds(but=errpipe_write)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001183
Facundo Batista8c826b72009-06-19 18:02:28 +00001184 if cwd is not None:
1185 os.chdir(cwd)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001186
Facundo Batista8c826b72009-06-19 18:02:28 +00001187 if preexec_fn:
1188 preexec_fn()
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001189
Facundo Batista8c826b72009-06-19 18:02:28 +00001190 if env is None:
1191 os.execvp(executable, args)
1192 else:
1193 os.execvpe(executable, args, env)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001194
Facundo Batista8c826b72009-06-19 18:02:28 +00001195 except:
1196 exc_type, exc_value, tb = sys.exc_info()
1197 # Save the traceback and attach it to the exception object
1198 exc_lines = traceback.format_exception(exc_type,
1199 exc_value,
1200 tb)
1201 exc_value.child_traceback = ''.join(exc_lines)
1202 os.write(errpipe_write, pickle.dumps(exc_value))
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001203
Facundo Batista8c826b72009-06-19 18:02:28 +00001204 # This exitcode won't be reported to applications, so it
1205 # really doesn't matter what we return.
1206 os._exit(255)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001207
Facundo Batista8c826b72009-06-19 18:02:28 +00001208 # Parent
1209 if gc_was_enabled:
1210 gc.enable()
1211 finally:
1212 # be sure the FD is closed no matter what
1213 os.close(errpipe_write)
1214
1215 if p2cread is not None and p2cwrite is not None:
1216 os.close(p2cread)
1217 if c2pwrite is not None and c2pread is not None:
1218 os.close(c2pwrite)
1219 if errwrite is not None and errread is not None:
1220 os.close(errwrite)
1221
1222 # Wait for exec to fail or succeed; possibly raising exception
Gregory P. Smithcce211f2010-03-01 00:05:08 +00001223 # Exception limited to 1M
1224 data = _eintr_retry_call(os.read, errpipe_read, 1048576)
Facundo Batista8c826b72009-06-19 18:02:28 +00001225 finally:
1226 # be sure the FD is closed no matter what
1227 os.close(errpipe_read)
1228
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001229 if data != "":
Gregory P. Smith312efbc2010-12-14 15:02:53 +00001230 try:
1231 _eintr_retry_call(os.waitpid, self.pid, 0)
1232 except OSError as e:
1233 if e.errno != errno.ECHILD:
1234 raise
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001235 child_exception = pickle.loads(data)
Georg Brandlf3715d22009-02-14 17:01:36 +00001236 for fd in (p2cwrite, c2pread, errread):
1237 if fd is not None:
1238 os.close(fd)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001239 raise child_exception
1240
1241
Brett Cannon42a0ba72010-05-14 00:21:48 +00001242 def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED,
1243 _WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED,
1244 _WEXITSTATUS=os.WEXITSTATUS):
1245 # This method is called (indirectly) by __del__, so it cannot
1246 # refer to anything outside of its local scope."""
1247 if _WIFSIGNALED(sts):
1248 self.returncode = -_WTERMSIG(sts)
1249 elif _WIFEXITED(sts):
1250 self.returncode = _WEXITSTATUS(sts)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001251 else:
1252 # Should never happen
1253 raise RuntimeError("Unknown child exit status!")
1254
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001255
Brett Cannon42a0ba72010-05-14 00:21:48 +00001256 def _internal_poll(self, _deadstate=None, _waitpid=os.waitpid,
1257 _WNOHANG=os.WNOHANG, _os_error=os.error):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001258 """Check if child process has terminated. Returns returncode
Brett Cannon42a0ba72010-05-14 00:21:48 +00001259 attribute.
1260
1261 This method is called by __del__, so it cannot reference anything
1262 outside of the local scope (nor can any methods it calls).
1263
1264 """
Peter Astrandd38ddf42005-02-10 08:32:50 +00001265 if self.returncode is None:
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001266 try:
Brett Cannon42a0ba72010-05-14 00:21:48 +00001267 pid, sts = _waitpid(self.pid, _WNOHANG)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001268 if pid == self.pid:
1269 self._handle_exitstatus(sts)
Brett Cannon42a0ba72010-05-14 00:21:48 +00001270 except _os_error:
Martin v. Löwis17de8ff2006-04-10 15:55:37 +00001271 if _deadstate is not None:
1272 self.returncode = _deadstate
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001273 return self.returncode
1274
1275
1276 def wait(self):
1277 """Wait for child process to terminate. Returns returncode
1278 attribute."""
Peter Astrandd38ddf42005-02-10 08:32:50 +00001279 if self.returncode is None:
Gregory P. Smith312efbc2010-12-14 15:02:53 +00001280 try:
1281 pid, sts = _eintr_retry_call(os.waitpid, self.pid, 0)
1282 except OSError as e:
1283 if e.errno != errno.ECHILD:
1284 raise
1285 # This happens if SIGCLD is set to be ignored or waiting
1286 # for child processes has otherwise been disabled for our
1287 # process. This child is dead, we can't get the status.
1288 sts = 0
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001289 self._handle_exitstatus(sts)
1290 return self.returncode
1291
1292
Peter Astrand23109f02005-03-03 20:28:59 +00001293 def _communicate(self, input):
Gregory P. Smithdd7ca242009-07-04 01:49:29 +00001294 if self.stdin:
1295 # Flush stdio buffer. This might block, if the user has
1296 # been writing to .stdin in an uncontrolled fashion.
1297 self.stdin.flush()
1298 if not input:
1299 self.stdin.close()
1300
1301 if _has_poll:
1302 stdout, stderr = self._communicate_with_poll(input)
1303 else:
1304 stdout, stderr = self._communicate_with_select(input)
1305
1306 # All data exchanged. Translate lists into strings.
1307 if stdout is not None:
1308 stdout = ''.join(stdout)
1309 if stderr is not None:
1310 stderr = ''.join(stderr)
1311
1312 # Translate newlines, if requested. We cannot let the file
1313 # object do the translation: It is based on stdio, which is
1314 # impossible to combine with select (unless forcing no
1315 # buffering).
1316 if self.universal_newlines and hasattr(file, 'newlines'):
1317 if stdout:
1318 stdout = self._translate_newlines(stdout)
1319 if stderr:
1320 stderr = self._translate_newlines(stderr)
1321
1322 self.wait()
1323 return (stdout, stderr)
1324
1325
1326 def _communicate_with_poll(self, input):
1327 stdout = None # Return
1328 stderr = None # Return
1329 fd2file = {}
1330 fd2output = {}
1331
1332 poller = select.poll()
1333 def register_and_append(file_obj, eventmask):
1334 poller.register(file_obj.fileno(), eventmask)
1335 fd2file[file_obj.fileno()] = file_obj
1336
1337 def close_unregister_and_remove(fd):
1338 poller.unregister(fd)
1339 fd2file[fd].close()
1340 fd2file.pop(fd)
1341
1342 if self.stdin and input:
1343 register_and_append(self.stdin, select.POLLOUT)
1344
1345 select_POLLIN_POLLPRI = select.POLLIN | select.POLLPRI
1346 if self.stdout:
1347 register_and_append(self.stdout, select_POLLIN_POLLPRI)
1348 fd2output[self.stdout.fileno()] = stdout = []
1349 if self.stderr:
1350 register_and_append(self.stderr, select_POLLIN_POLLPRI)
1351 fd2output[self.stderr.fileno()] = stderr = []
1352
1353 input_offset = 0
1354 while fd2file:
1355 try:
1356 ready = poller.poll()
1357 except select.error, e:
1358 if e.args[0] == errno.EINTR:
1359 continue
1360 raise
1361
1362 for fd, mode in ready:
1363 if mode & select.POLLOUT:
1364 chunk = input[input_offset : input_offset + _PIPE_BUF]
Ross Lagerwall104c3f12011-04-05 15:24:34 +02001365 try:
1366 input_offset += os.write(fd, chunk)
1367 except OSError as e:
1368 if e.errno == errno.EPIPE:
1369 close_unregister_and_remove(fd)
1370 else:
1371 raise
1372 else:
1373 if input_offset >= len(input):
1374 close_unregister_and_remove(fd)
Gregory P. Smithdd7ca242009-07-04 01:49:29 +00001375 elif mode & select_POLLIN_POLLPRI:
1376 data = os.read(fd, 4096)
1377 if not data:
1378 close_unregister_and_remove(fd)
1379 fd2output[fd].append(data)
1380 else:
1381 # Ignore hang up or errors.
1382 close_unregister_and_remove(fd)
1383
1384 return (stdout, stderr)
1385
1386
1387 def _communicate_with_select(self, input):
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001388 read_set = []
1389 write_set = []
1390 stdout = None # Return
1391 stderr = None # Return
1392
Gregory P. Smithdd7ca242009-07-04 01:49:29 +00001393 if self.stdin and input:
1394 write_set.append(self.stdin)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001395 if self.stdout:
1396 read_set.append(self.stdout)
Tim Peterse718f612004-10-12 21:51:32 +00001397 stdout = []
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001398 if self.stderr:
1399 read_set.append(self.stderr)
1400 stderr = []
1401
Peter Astrand1812f8c2007-01-07 14:34:16 +00001402 input_offset = 0
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001403 while read_set or write_set:
Gregory P. Smithf4140642008-07-06 07:16:40 +00001404 try:
1405 rlist, wlist, xlist = select.select(read_set, write_set, [])
1406 except select.error, e:
1407 if e.args[0] == errno.EINTR:
1408 continue
1409 raise
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001410
1411 if self.stdin in wlist:
Gregory P. Smithdd7ca242009-07-04 01:49:29 +00001412 chunk = input[input_offset : input_offset + _PIPE_BUF]
Ross Lagerwall104c3f12011-04-05 15:24:34 +02001413 try:
1414 bytes_written = os.write(self.stdin.fileno(), chunk)
1415 except OSError as e:
1416 if e.errno == errno.EPIPE:
1417 self.stdin.close()
1418 write_set.remove(self.stdin)
1419 else:
1420 raise
1421 else:
1422 input_offset += bytes_written
1423 if input_offset >= len(input):
1424 self.stdin.close()
1425 write_set.remove(self.stdin)
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001426
1427 if self.stdout in rlist:
1428 data = os.read(self.stdout.fileno(), 1024)
1429 if data == "":
1430 self.stdout.close()
1431 read_set.remove(self.stdout)
1432 stdout.append(data)
1433
1434 if self.stderr in rlist:
1435 data = os.read(self.stderr.fileno(), 1024)
1436 if data == "":
1437 self.stderr.close()
1438 read_set.remove(self.stderr)
1439 stderr.append(data)
1440
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001441 return (stdout, stderr)
1442
Gregory P. Smithdd7ca242009-07-04 01:49:29 +00001443
Christian Heimese74c8f22008-04-19 02:23:57 +00001444 def send_signal(self, sig):
1445 """Send a signal to the process
1446 """
1447 os.kill(self.pid, sig)
1448
1449 def terminate(self):
1450 """Terminate the process with SIGTERM
1451 """
1452 self.send_signal(signal.SIGTERM)
1453
1454 def kill(self):
1455 """Kill the process with SIGKILL
1456 """
1457 self.send_signal(signal.SIGKILL)
1458
Fredrik Lundh5b3687d2004-10-12 15:26:28 +00001459
1460def _demo_posix():
1461 #
1462 # Example 1: Simple redirection: Get process list
1463 #
1464 plist = Popen(["ps"], stdout=PIPE).communicate()[0]
1465 print "Process list:"
1466 print plist
1467
1468 #
1469 # Example 2: Change uid before executing child
1470 #
1471 if os.getuid() == 0:
1472 p = Popen(["id"], preexec_fn=lambda: os.setuid(100))
1473 p.wait()
1474
1475 #
1476 # Example 3: Connecting several subprocesses
1477 #
1478 print "Looking for 'hda'..."
1479 p1 = Popen(["dmesg"], stdout=PIPE)
1480 p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
1481 print repr(p2.communicate()[0])
1482
1483 #
1484 # Example 4: Catch execution error
1485 #
1486 print
1487 print "Trying a weird file..."
1488 try:
1489 print Popen(["/this/path/does/not/exist"]).communicate()
1490 except OSError, e:
1491 if e.errno == errno.ENOENT:
1492 print "The file didn't exist. I thought so..."
1493 print "Child traceback:"
1494 print e.child_traceback
1495 else:
1496 print "Error", e.errno
1497 else:
1498 print >>sys.stderr, "Gosh. No error."
1499
1500
1501def _demo_windows():
1502 #
1503 # Example 1: Connecting several subprocesses
1504 #
1505 print "Looking for 'PROMPT' in set output..."
1506 p1 = Popen("set", stdout=PIPE, shell=True)
1507 p2 = Popen('find "PROMPT"', stdin=p1.stdout, stdout=PIPE)
1508 print repr(p2.communicate()[0])
1509
1510 #
1511 # Example 2: Simple execution of program
1512 #
1513 print "Executing calc..."
1514 p = Popen("calc")
1515 p.wait()
1516
1517
1518if __name__ == "__main__":
1519 if mswindows:
1520 _demo_windows()
1521 else:
1522 _demo_posix()