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