1
2
3
4
5
6
7
8
9
10
11
12 r"""subprocess - Subprocesses with accessible I/O streams
13
14 This module allows you to spawn processes, connect to their
15 input/output/error pipes, and obtain their return codes. This module
16 intends to replace several other, older modules and functions, like:
17
18 os.system
19 os.spawn*
20 os.popen*
21 popen2.*
22 commands.*
23
24 Information about how the subprocess module can be used to replace these
25 modules and functions can be found below.
26
27
28
29 Using the subprocess module
30 ===========================
31 This module defines one class called Popen:
32
33 class Popen(args, bufsize=0, executable=None,
34 stdin=None, stdout=None, stderr=None,
35 preexec_fn=None, close_fds=False, shell=False,
36 cwd=None, env=None, universal_newlines=False,
37 startupinfo=None, creationflags=0):
38
39
40 Arguments are:
41
42 args should be a string, or a sequence of program arguments. The
43 program to execute is normally the first item in the args sequence or
44 string, but can be explicitly set by using the executable argument.
45
46 On UNIX, with shell=False (default): In this case, the Popen class
47 uses os.execvp() to execute the child program. args should normally
48 be a sequence. A string will be treated as a sequence with the string
49 as the only item (the program to execute).
50
51 On UNIX, with shell=True: If args is a string, it specifies the
52 command string to execute through the shell. If args is a sequence,
53 the first item specifies the command string, and any additional items
54 will be treated as additional shell arguments.
55
56 On Windows: the Popen class uses CreateProcess() to execute the child
57 program, which operates on strings. If args is a sequence, it will be
58 converted to a string using the list2cmdline method. Please note that
59 not all MS Windows applications interpret the command line the same
60 way: The list2cmdline is designed for applications using the same
61 rules as the MS C runtime.
62
63 bufsize, if given, has the same meaning as the corresponding argument
64 to the built-in open() function: 0 means unbuffered, 1 means line
65 buffered, any other positive value means use a buffer of
66 (approximately) that size. A negative bufsize means to use the system
67 default, which usually means fully buffered. The default value for
68 bufsize is 0 (unbuffered).
69
70 stdin, stdout and stderr specify the executed programs' standard
71 input, standard output and standard error file handles, respectively.
72 Valid values are PIPE, an existing file descriptor (a positive
73 integer), an existing file object, and None. PIPE indicates that a
74 new pipe to the child should be created. With None, no redirection
75 will occur; the child's file handles will be inherited from the
76 parent. Additionally, stderr can be STDOUT, which indicates that the
77 stderr data from the applications should be captured into the same
78 file handle as for stdout.
79
80 If preexec_fn is set to a callable object, this object will be called
81 in the child process just before the child is executed.
82
83 If close_fds is true, all file descriptors except 0, 1 and 2 will be
84 closed before the child process is executed.
85
86 if shell is true, the specified command will be executed through the
87 shell.
88
89 If cwd is not None, the current directory will be changed to cwd
90 before the child is executed.
91
92 If env is not None, it defines the environment variables for the new
93 process.
94
95 If universal_newlines is true, the file objects stdout and stderr are
96 opened as a text files, but lines may be terminated by any of '\n',
97 the Unix end-of-line convention, '\r', the Macintosh convention or
98 '\r\n', the Windows convention. All of these external representations
99 are seen as '\n' by the Python program. Note: This feature is only
100 available if Python is built with universal newline support (the
101 default). Also, the newlines attribute of the file objects stdout,
102 stdin and stderr are not updated by the communicate() method.
103
104 The startupinfo and creationflags, if given, will be passed to the
105 underlying CreateProcess() function. They can specify things such as
106 appearance of the main window and priority for the new process.
107 (Windows only)
108
109
110 This module also defines two shortcut functions:
111
112 call(*popenargs, **kwargs):
113 Run command with arguments. Wait for command to complete, then
114 return the returncode attribute.
115
116 The arguments are the same as for the Popen constructor. Example:
117
118 retcode = call(["ls", "-l"])
119
120 check_call(*popenargs, **kwargs):
121 Run command with arguments. Wait for command to complete. If the
122 exit code was zero then return, otherwise raise
123 CalledProcessError. The CalledProcessError object will have the
124 return code in the returncode attribute.
125
126 The arguments are the same as for the Popen constructor. Example:
127
128 check_call(["ls", "-l"])
129
130 Exceptions
131 ----------
132 Exceptions raised in the child process, before the new program has
133 started to execute, will be re-raised in the parent. Additionally,
134 the exception object will have one extra attribute called
135 'child_traceback', which is a string containing traceback information
136 from the childs point of view.
137
138 The most common exception raised is OSError. This occurs, for
139 example, when trying to execute a non-existent file. Applications
140 should prepare for OSErrors.
141
142 A ValueError will be raised if Popen is called with invalid arguments.
143
144 check_call() will raise CalledProcessError, if the called process
145 returns a non-zero return code.
146
147
148 Security
149 --------
150 Unlike some other popen functions, this implementation will never call
151 /bin/sh implicitly. This means that all characters, including shell
152 metacharacters, can safely be passed to child processes.
153
154
155 Popen objects
156 =============
157 Instances of the Popen class have the following methods:
158
159 poll()
160 Check if child process has terminated. Returns returncode
161 attribute.
162
163 wait()
164 Wait for child process to terminate. Returns returncode attribute.
165
166 communicate(input=None)
167 Interact with process: Send data to stdin. Read data from stdout
168 and stderr, until end-of-file is reached. Wait for process to
169 terminate. The optional stdin argument should be a string to be
170 sent to the child process, or None, if no data should be sent to
171 the child.
172
173 communicate() returns a tuple (stdout, stderr).
174
175 Note: The data read is buffered in memory, so do not use this
176 method if the data size is large or unlimited.
177
178 The following attributes are also available:
179
180 stdin
181 If the stdin argument is PIPE, this attribute is a file object
182 that provides input to the child process. Otherwise, it is None.
183
184 stdout
185 If the stdout argument is PIPE, this attribute is a file object
186 that provides output from the child process. Otherwise, it is
187 None.
188
189 stderr
190 If the stderr argument is PIPE, this attribute is file object that
191 provides error output from the child process. Otherwise, it is
192 None.
193
194 pid
195 The process ID of the child process.
196
197 returncode
198 The child return code. A None value indicates that the process
199 hasn't terminated yet. A negative value -N indicates that the
200 child was terminated by signal N (UNIX only).
201
202
203 Replacing older functions with the subprocess module
204 ====================================================
205 In this section, "a ==> b" means that b can be used as a replacement
206 for a.
207
208 Note: All functions in this section fail (more or less) silently if
209 the executed program cannot be found; this module raises an OSError
210 exception.
211
212 In the following examples, we assume that the subprocess module is
213 imported with "from subprocess import *".
214
215
216 Replacing /bin/sh shell backquote
217 ---------------------------------
218 output=`mycmd myarg`
219 ==>
220 output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
221
222
223 Replacing shell pipe line
224 -------------------------
225 output=`dmesg | grep hda`
226 ==>
227 p1 = Popen(["dmesg"], stdout=PIPE)
228 p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
229 output = p2.communicate()[0]
230
231
232 Replacing os.system()
233 ---------------------
234 sts = os.system("mycmd" + " myarg")
235 ==>
236 p = Popen("mycmd" + " myarg", shell=True)
237 pid, sts = os.waitpid(p.pid, 0)
238
239 Note:
240
241 * Calling the program through the shell is usually not required.
242
243 * It's easier to look at the returncode attribute than the
244 exitstatus.
245
246 A more real-world example would look like this:
247
248 try:
249 retcode = call("mycmd" + " myarg", shell=True)
250 if retcode < 0:
251 print >>sys.stderr, "Child was terminated by signal", -retcode
252 else:
253 print >>sys.stderr, "Child returned", retcode
254 except OSError, e:
255 print >>sys.stderr, "Execution failed:", e
256
257
258 Replacing os.spawn*
259 -------------------
260 P_NOWAIT example:
261
262 pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
263 ==>
264 pid = Popen(["/bin/mycmd", "myarg"]).pid
265
266
267 P_WAIT example:
268
269 retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
270 ==>
271 retcode = call(["/bin/mycmd", "myarg"])
272
273
274 Vector example:
275
276 os.spawnvp(os.P_NOWAIT, path, args)
277 ==>
278 Popen([path] + args[1:])
279
280
281 Environment example:
282
283 os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
284 ==>
285 Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})
286
287
288 Replacing os.popen*
289 -------------------
290 pipe = os.popen(cmd, mode='r', bufsize)
291 ==>
292 pipe = Popen(cmd, shell=True, bufsize=bufsize, stdout=PIPE).stdout
293
294 pipe = os.popen(cmd, mode='w', bufsize)
295 ==>
296 pipe = Popen(cmd, shell=True, bufsize=bufsize, stdin=PIPE).stdin
297
298
299 (child_stdin, child_stdout) = os.popen2(cmd, mode, bufsize)
300 ==>
301 p = Popen(cmd, shell=True, bufsize=bufsize,
302 stdin=PIPE, stdout=PIPE, close_fds=True)
303 (child_stdin, child_stdout) = (p.stdin, p.stdout)
304
305
306 (child_stdin,
307 child_stdout,
308 child_stderr) = os.popen3(cmd, mode, bufsize)
309 ==>
310 p = Popen(cmd, shell=True, bufsize=bufsize,
311 stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
312 (child_stdin,
313 child_stdout,
314 child_stderr) = (p.stdin, p.stdout, p.stderr)
315
316
317 (child_stdin, child_stdout_and_stderr) = os.popen4(cmd, mode, bufsize)
318 ==>
319 p = Popen(cmd, shell=True, bufsize=bufsize,
320 stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
321 (child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)
322
323
324 Replacing popen2.*
325 ------------------
326 Note: If the cmd argument to popen2 functions is a string, the command
327 is executed through /bin/sh. If it is a list, the command is directly
328 executed.
329
330 (child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
331 ==>
332 p = Popen(["somestring"], shell=True, bufsize=bufsize
333 stdin=PIPE, stdout=PIPE, close_fds=True)
334 (child_stdout, child_stdin) = (p.stdout, p.stdin)
335
336
337 (child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize, mode)
338 ==>
339 p = Popen(["mycmd", "myarg"], bufsize=bufsize,
340 stdin=PIPE, stdout=PIPE, close_fds=True)
341 (child_stdout, child_stdin) = (p.stdout, p.stdin)
342
343 The popen2.Popen3 and popen3.Popen4 basically works as subprocess.Popen,
344 except that:
345
346 * subprocess.Popen raises an exception if the execution fails
347 * the capturestderr argument is replaced with the stderr argument.
348 * stdin=PIPE and stdout=PIPE must be specified.
349 * popen2 closes all filedescriptors by default, but you have to specify
350 close_fds=True with subprocess.Popen.
351
352
353 """
354
355 import sys
356 mswindows = (sys.platform == "win32")
357
358 import os
359 import string
360 import types
361 import traceback
362
363
365 """This exception is raised when a process run by check_call() returns
366 a non-zero exit status. The exit status will be stored in the
367 returncode attribute."""
369 self.returncode = returncode
370 self.cmd = cmd
372 return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode)
373
374
375 if mswindows:
376 try:
377 import threading
378 except ImportError:
379
380
381
382 pass
383 import msvcrt
384 try:
385
386 from _subprocess import *
388 dwFlags = 0
389 hStdInput = None
390 hStdOutput = None
391 hStdError = None
392 wShowWindow = 0
395 except ImportError:
396
397
398
399 import pywintypes
400 from win32api import GetStdHandle, STD_INPUT_HANDLE, \
401 STD_OUTPUT_HANDLE, STD_ERROR_HANDLE
402 from win32api import GetCurrentProcess, DuplicateHandle, \
403 GetModuleFileName, GetVersion
404 from win32con import DUPLICATE_SAME_ACCESS, SW_HIDE
405 from win32pipe import CreatePipe
406 from win32process import CreateProcess, STARTUPINFO, \
407 GetExitCodeProcess, STARTF_USESTDHANDLES, \
408 STARTF_USESHOWWINDOW, CREATE_NEW_CONSOLE
409 from win32event import WaitForSingleObject, INFINITE, WAIT_OBJECT_0
410
411
412 else:
413 import select
414 import errno
415 import fcntl
416 import pickle
417
418 try:
419 fcntl.F_GETFD
420 except AttributeError:
421 fcntl.F_GETFD = 1
422
423 try:
424 fcntl.F_SETFD
425 except AttributeError:
426 fcntl.F_SETFD = 2
427
428 __all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call", "CalledProcessError"]
429
430 try:
431 MAXFD = os.sysconf("SC_OPEN_MAX")
432 except KeyboardInterrupt:
433 raise
434 except:
435 MAXFD = 256
436
437
438 try:
439 False
440 except NameError:
441 False = 0
442 True = 1
443
444 try:
445 isinstance(1, int)
446 except TypeError:
448 return type(obj) == type(1)
450 return type(obj) in (type(1), type(1L))
451 else:
453 return isinstance(obj, int)
455 return isinstance(obj, (int, long))
456
457 try:
458 types.StringTypes
459 except AttributeError:
460 try:
461 types.StringTypes = (types.StringType, types.UnicodeType)
462 except AttributeError:
463 types.StringTypes = (types.StringType,)
466 else:
469
470 _active = []
471
473 for inst in _active[:]:
474 if inst.poll(_deadstate=sys.maxint) >= 0:
475 try:
476 _active.remove(inst)
477 except ValueError:
478
479
480 pass
481
482 PIPE = -1
483 STDOUT = -2
484
485
486 -def call(*popenargs, **kwargs):
487 """Run command with arguments. Wait for command to complete, then
488 return the returncode attribute.
489
490 The arguments are the same as for the Popen constructor. Example:
491
492 retcode = call(["ls", "-l"])
493 """
494 return apply(Popen, popenargs, kwargs).wait()
495
496
498 """Run command with arguments. Wait for command to complete. If
499 the exit code was zero then return, otherwise raise
500 CalledProcessError. The CalledProcessError object will have the
501 return code in the returncode attribute.
502
503 The arguments are the same as for the Popen constructor. Example:
504
505 check_call(["ls", "-l"])
506 """
507 retcode = apply(call, popenargs, kwargs)
508 cmd = kwargs.get("args")
509 if cmd is None:
510 cmd = popenargs[0]
511 if retcode:
512 raise CalledProcessError(retcode, cmd)
513 return retcode
514
515
517 """
518 Translate a sequence of arguments into a command line
519 string, using the same rules as the MS C runtime:
520
521 1) Arguments are delimited by white space, which is either a
522 space or a tab.
523
524 2) A string surrounded by double quotation marks is
525 interpreted as a single argument, regardless of white space
526 contained within. A quoted string can be embedded in an
527 argument.
528
529 3) A double quotation mark preceded by a backslash is
530 interpreted as a literal double quotation mark.
531
532 4) Backslashes are interpreted literally, unless they
533 immediately precede a double quotation mark.
534
535 5) If backslashes immediately precede a double quotation mark,
536 every pair of backslashes is interpreted as a literal
537 backslash. If the number of backslashes is odd, the last
538 backslash escapes the next double quotation mark as
539 described in rule 3.
540 """
541
542
543
544 result = []
545 needquote = False
546 for arg in seq:
547 bs_buf = []
548
549
550 if result:
551 result.append(' ')
552
553 needquote = (" " in arg) or ("\t" in arg)
554 if needquote:
555 result.append('"')
556
557 for c in arg:
558 if c == '\\':
559
560 bs_buf.append(c)
561 elif c == '"':
562
563 result.append('\\' * len(bs_buf)*2)
564 bs_buf = []
565 result.append('\\"')
566 else:
567
568 if bs_buf:
569 result.extend(bs_buf)
570 bs_buf = []
571 result.append(c)
572
573
574 if bs_buf:
575 result.extend(bs_buf)
576
577 if needquote:
578 result.extend(bs_buf)
579 result.append('"')
580
581 return string.join(result, '')
582
583
584 try:
585 object
586 except NameError:
589
591 - def __init__(self, args, bufsize=0, executable=None,
592 stdin=None, stdout=None, stderr=None,
593 preexec_fn=None, close_fds=False, shell=False,
594 cwd=None, env=None, universal_newlines=False,
595 startupinfo=None, creationflags=0):
596 """Create new Popen instance."""
597 _cleanup()
598
599 self._child_created = False
600 if not is_int_or_long(bufsize):
601 raise TypeError("bufsize must be an integer")
602
603 if mswindows:
604 if preexec_fn is not None:
605 raise ValueError("preexec_fn is not supported on Windows "
606 "platforms")
607 if close_fds:
608 raise ValueError("close_fds is not supported on Windows "
609 "platforms")
610 else:
611
612 if startupinfo is not None:
613 raise ValueError("startupinfo is only supported on Windows "
614 "platforms")
615 if creationflags != 0:
616 raise ValueError("creationflags is only supported on Windows "
617 "platforms")
618
619 self.stdin = None
620 self.stdout = None
621 self.stderr = None
622 self.pid = None
623 self.returncode = None
624 self.universal_newlines = universal_newlines
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641 (p2cread, p2cwrite,
642 c2pread, c2pwrite,
643 errread, errwrite) = self._get_handles(stdin, stdout, stderr)
644
645 self._execute_child(args, executable, preexec_fn, close_fds,
646 cwd, env, universal_newlines,
647 startupinfo, creationflags, shell,
648 p2cread, p2cwrite,
649 c2pread, c2pwrite,
650 errread, errwrite)
651
652 if p2cwrite:
653 self.stdin = os.fdopen(p2cwrite, 'wb', bufsize)
654 if c2pread:
655 if universal_newlines:
656 self.stdout = os.fdopen(c2pread, 'rU', bufsize)
657 else:
658 self.stdout = os.fdopen(c2pread, 'rb', bufsize)
659 if errread:
660 if universal_newlines:
661 self.stderr = os.fdopen(errread, 'rU', bufsize)
662 else:
663 self.stderr = os.fdopen(errread, 'rb', bufsize)
664
665
667 data = data.replace("\r\n", "\n")
668 data = data.replace("\r", "\n")
669 return data
670
671
673 if not self._child_created:
674
675 return
676
677 self.poll(_deadstate=sys.maxint)
678 if self.returncode is None and _active is not None:
679
680 _active.append(self)
681
682
684 """Interact with process: Send data to stdin. Read data from
685 stdout and stderr, until end-of-file is reached. Wait for
686 process to terminate. The optional input argument should be a
687 string to be sent to the child process, or None, if no data
688 should be sent to the child.
689
690 communicate() returns a tuple (stdout, stderr)."""
691
692
693
694 if [self.stdin, self.stdout, self.stderr].count(None) >= 2:
695 stdout = None
696 stderr = None
697 if self.stdin:
698 if input:
699 self.stdin.write(input)
700 self.stdin.close()
701 elif self.stdout:
702 stdout = self.stdout.read()
703 elif self.stderr:
704 stderr = self.stderr.read()
705 self.wait()
706 return (stdout, stderr)
707
708 return self._communicate(input)
709
710
711 if mswindows:
712
713
714
716 """Construct and return tupel with IO objects:
717 p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
718 """
719 if stdin is None and stdout is None and stderr is None:
720 return (None, None, None, None, None, None)
721
722 p2cread, p2cwrite = None, None
723 c2pread, c2pwrite = None, None
724 errread, errwrite = None, None
725
726 if stdin is None:
727 p2cread = GetStdHandle(STD_INPUT_HANDLE)
728 elif stdin == PIPE:
729 p2cread, p2cwrite = CreatePipe(None, 0)
730
731 p2cwrite = p2cwrite.Detach()
732 p2cwrite = msvcrt.open_osfhandle(p2cwrite, 0)
733 elif is_int(stdin):
734 p2cread = msvcrt.get_osfhandle(stdin)
735 else:
736
737 p2cread = msvcrt.get_osfhandle(stdin.fileno())
738 p2cread = self._make_inheritable(p2cread)
739
740 if stdout is None:
741 c2pwrite = GetStdHandle(STD_OUTPUT_HANDLE)
742 elif stdout == PIPE:
743 c2pread, c2pwrite = CreatePipe(None, 0)
744
745 c2pread = c2pread.Detach()
746 c2pread = msvcrt.open_osfhandle(c2pread, 0)
747 elif is_int(stdout):
748 c2pwrite = msvcrt.get_osfhandle(stdout)
749 else:
750
751 c2pwrite = msvcrt.get_osfhandle(stdout.fileno())
752 c2pwrite = self._make_inheritable(c2pwrite)
753
754 if stderr is None:
755 errwrite = GetStdHandle(STD_ERROR_HANDLE)
756 elif stderr == PIPE:
757 errread, errwrite = CreatePipe(None, 0)
758
759 errread = errread.Detach()
760 errread = msvcrt.open_osfhandle(errread, 0)
761 elif stderr == STDOUT:
762 errwrite = c2pwrite
763 elif is_int(stderr):
764 errwrite = msvcrt.get_osfhandle(stderr)
765 else:
766
767 errwrite = msvcrt.get_osfhandle(stderr.fileno())
768 errwrite = self._make_inheritable(errwrite)
769
770 return (p2cread, p2cwrite,
771 c2pread, c2pwrite,
772 errread, errwrite)
773
774
776 """Return a duplicate of handle, which is inheritable"""
777 return DuplicateHandle(GetCurrentProcess(), handle,
778 GetCurrentProcess(), 0, 1,
779 DUPLICATE_SAME_ACCESS)
780
781
783 """Find and return absolut path to w9xpopen.exe"""
784 w9xpopen = os.path.join(os.path.dirname(GetModuleFileName(0)),
785 "w9xpopen.exe")
786 if not os.path.exists(w9xpopen):
787
788
789 w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix),
790 "w9xpopen.exe")
791 if not os.path.exists(w9xpopen):
792 raise RuntimeError("Cannot locate w9xpopen.exe, which is "
793 "needed for Popen to work with your "
794 "shell or platform.")
795 return w9xpopen
796
797
798 - def _execute_child(self, args, executable, preexec_fn, close_fds,
799 cwd, env, universal_newlines,
800 startupinfo, creationflags, shell,
801 p2cread, p2cwrite,
802 c2pread, c2pwrite,
803 errread, errwrite):
804 """Execute program (MS Windows version)"""
805
806 if not isinstance(args, types.StringTypes):
807 args = list2cmdline(args)
808
809
810 if startupinfo is None:
811 startupinfo = STARTUPINFO()
812 if None not in (p2cread, c2pwrite, errwrite):
813 startupinfo.dwFlags = startupinfo.dwFlags | STARTF_USESTDHANDLES
814 startupinfo.hStdInput = p2cread
815 startupinfo.hStdOutput = c2pwrite
816 startupinfo.hStdError = errwrite
817
818 if shell:
819 startupinfo.dwFlags = startupinfo.dwFlags | STARTF_USESHOWWINDOW
820 startupinfo.wShowWindow = SW_HIDE
821 comspec = os.environ.get("COMSPEC", "cmd.exe")
822 args = comspec + " /c " + args
823 if (GetVersion() >= 0x80000000L or
824 os.path.basename(comspec).lower() == "command.com"):
825
826
827
828
829 w9xpopen = self._find_w9xpopen()
830 args = '"%s" %s' % (w9xpopen, args)
831
832
833
834
835
836
837 creationflags = creationflags | CREATE_NEW_CONSOLE
838
839
840 try:
841 hp, ht, pid, tid = CreateProcess(executable, args,
842
843 None, None,
844
845
846 1,
847 creationflags,
848 env,
849 cwd,
850 startupinfo)
851 except pywintypes.error, e:
852
853
854
855
856 raise apply(WindowsError, e.args)
857
858
859 self._child_created = True
860 self._handle = hp
861 self.pid = pid
862 ht.Close()
863
864
865
866
867
868
869
870 if p2cread is not None:
871 p2cread.Close()
872 if c2pwrite is not None:
873 c2pwrite.Close()
874 if errwrite is not None:
875 errwrite.Close()
876
877
878 - def poll(self, _deadstate=None):
879 """Check if child process has terminated. Returns returncode
880 attribute."""
881 if self.returncode is None:
882 if WaitForSingleObject(self._handle, 0) == WAIT_OBJECT_0:
883 self.returncode = GetExitCodeProcess(self._handle)
884 return self.returncode
885
886
888 """Wait for child process to terminate. Returns returncode
889 attribute."""
890 if self.returncode is None:
891 obj = WaitForSingleObject(self._handle, INFINITE)
892 self.returncode = GetExitCodeProcess(self._handle)
893 return self.returncode
894
895
898
899
901 stdout = None
902 stderr = None
903
904 if self.stdout:
905 stdout = []
906 stdout_thread = threading.Thread(target=self._readerthread,
907 args=(self.stdout, stdout))
908 stdout_thread.setDaemon(True)
909 stdout_thread.start()
910 if self.stderr:
911 stderr = []
912 stderr_thread = threading.Thread(target=self._readerthread,
913 args=(self.stderr, stderr))
914 stderr_thread.setDaemon(True)
915 stderr_thread.start()
916
917 if self.stdin:
918 if input is not None:
919 self.stdin.write(input)
920 self.stdin.close()
921
922 if self.stdout:
923 stdout_thread.join()
924 if self.stderr:
925 stderr_thread.join()
926
927
928 if stdout is not None:
929 stdout = stdout[0]
930 if stderr is not None:
931 stderr = stderr[0]
932
933
934
935
936
937 if self.universal_newlines and hasattr(file, 'newlines'):
938 if stdout:
939 stdout = self._translate_newlines(stdout)
940 if stderr:
941 stderr = self._translate_newlines(stderr)
942
943 self.wait()
944 return (stdout, stderr)
945
946 else:
947
948
949
951 """Construct and return tupel with IO objects:
952 p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
953 """
954 p2cread, p2cwrite = None, None
955 c2pread, c2pwrite = None, None
956 errread, errwrite = None, None
957
958 if stdin is None:
959 pass
960 elif stdin == PIPE:
961 p2cread, p2cwrite = os.pipe()
962 elif is_int(stdin):
963 p2cread = stdin
964 else:
965
966 p2cread = stdin.fileno()
967
968 if stdout is None:
969 pass
970 elif stdout == PIPE:
971 c2pread, c2pwrite = os.pipe()
972 elif is_int(stdout):
973 c2pwrite = stdout
974 else:
975
976 c2pwrite = stdout.fileno()
977
978 if stderr is None:
979 pass
980 elif stderr == PIPE:
981 errread, errwrite = os.pipe()
982 elif stderr == STDOUT:
983 errwrite = c2pwrite
984 elif is_int(stderr):
985 errwrite = stderr
986 else:
987
988 errwrite = stderr.fileno()
989
990 return (p2cread, p2cwrite,
991 c2pread, c2pwrite,
992 errread, errwrite)
993
994
996 try:
997 cloexec_flag = fcntl.FD_CLOEXEC
998 except AttributeError:
999 cloexec_flag = 1
1000
1001 old = fcntl.fcntl(fd, fcntl.F_GETFD)
1002 fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag)
1003
1004
1006 for i in xrange(3, MAXFD):
1007 if i == but:
1008 continue
1009 try:
1010 os.close(i)
1011 except KeyboardInterrupt:
1012 raise
1013 except:
1014 pass
1015
1016
1017 - def _execute_child(self, args, executable, preexec_fn, close_fds,
1018 cwd, env, universal_newlines,
1019 startupinfo, creationflags, shell,
1020 p2cread, p2cwrite,
1021 c2pread, c2pwrite,
1022 errread, errwrite):
1023 """Execute program (POSIX version)"""
1024
1025 if is_string(args):
1026 args = [args]
1027
1028 if shell:
1029 args = ["/bin/sh", "-c"] + args
1030
1031 if executable is None:
1032 executable = args[0]
1033
1034
1035
1036
1037 errpipe_read, errpipe_write = os.pipe()
1038 self._set_cloexec_flag(errpipe_write)
1039
1040 self.pid = os.fork()
1041 self._child_created = True
1042 if self.pid == 0:
1043
1044 try:
1045
1046 if p2cwrite:
1047 os.close(p2cwrite)
1048 if c2pread:
1049 os.close(c2pread)
1050 if errread:
1051 os.close(errread)
1052 os.close(errpipe_read)
1053
1054
1055 if p2cread:
1056 os.dup2(p2cread, 0)
1057 if c2pwrite:
1058 os.dup2(c2pwrite, 1)
1059 if errwrite:
1060 os.dup2(errwrite, 2)
1061
1062
1063
1064 try:
1065 set
1066 except NameError:
1067
1068
1069 if p2cread:
1070 os.close(p2cread)
1071 if c2pwrite and c2pwrite not in (p2cread,):
1072 os.close(c2pwrite)
1073 if errwrite and errwrite not in (p2cread, c2pwrite):
1074 os.close(errwrite)
1075 else:
1076 for fd in set((p2cread, c2pwrite, errwrite))-set((0,1,2)):
1077 if fd: os.close(fd)
1078
1079
1080 if close_fds:
1081 self._close_fds(but=errpipe_write)
1082
1083 if cwd is not None:
1084 os.chdir(cwd)
1085
1086 if preexec_fn:
1087 apply(preexec_fn)
1088
1089 if env is None:
1090 os.execvp(executable, args)
1091 else:
1092 os.execvpe(executable, args, env)
1093
1094 except KeyboardInterrupt:
1095 raise
1096
1097 except:
1098 exc_type, exc_value, tb = sys.exc_info()
1099
1100 exc_lines = traceback.format_exception(exc_type,
1101 exc_value,
1102 tb)
1103 exc_value.child_traceback = string.join(exc_lines, '')
1104 os.write(errpipe_write, pickle.dumps(exc_value))
1105
1106
1107
1108 os._exit(255)
1109
1110
1111 os.close(errpipe_write)
1112 if p2cread and p2cwrite:
1113 os.close(p2cread)
1114 if c2pwrite and c2pread:
1115 os.close(c2pwrite)
1116 if errwrite and errread:
1117 os.close(errwrite)
1118
1119
1120 data = os.read(errpipe_read, 1048576)
1121 os.close(errpipe_read)
1122 if data != "":
1123 os.waitpid(self.pid, 0)
1124 child_exception = pickle.loads(data)
1125 raise child_exception
1126
1127
1129 if os.WIFSIGNALED(sts):
1130 self.returncode = -os.WTERMSIG(sts)
1131 elif os.WIFEXITED(sts):
1132 self.returncode = os.WEXITSTATUS(sts)
1133 else:
1134
1135 raise RuntimeError("Unknown child exit status!")
1136
1137
1138 - def poll(self, _deadstate=None):
1139 """Check if child process has terminated. Returns returncode
1140 attribute."""
1141 if self.returncode is None:
1142 try:
1143 pid, sts = os.waitpid(self.pid, os.WNOHANG)
1144 if pid == self.pid:
1145 self._handle_exitstatus(sts)
1146 except os.error:
1147 if _deadstate is not None:
1148 self.returncode = _deadstate
1149 return self.returncode
1150
1151
1153 """Wait for child process to terminate. Returns returncode
1154 attribute."""
1155 if self.returncode is None:
1156 pid, sts = os.waitpid(self.pid, 0)
1157 self._handle_exitstatus(sts)
1158 return self.returncode
1159
1160
1162 read_set = []
1163 write_set = []
1164 stdout = None
1165 stderr = None
1166
1167 if self.stdin:
1168
1169
1170 self.stdin.flush()
1171 if input:
1172 write_set.append(self.stdin)
1173 else:
1174 self.stdin.close()
1175 if self.stdout:
1176 read_set.append(self.stdout)
1177 stdout = []
1178 if self.stderr:
1179 read_set.append(self.stderr)
1180 stderr = []
1181
1182 input_offset = 0
1183 while read_set or write_set:
1184 rlist, wlist, xlist = select.select(read_set, write_set, [])
1185
1186 if self.stdin in wlist:
1187
1188
1189
1190 bytes_written = os.write(self.stdin.fileno(), buffer(input, input_offset, 512))
1191 input_offset = input_offset + bytes_written
1192 if input_offset >= len(input):
1193 self.stdin.close()
1194 write_set.remove(self.stdin)
1195
1196 if self.stdout in rlist:
1197 data = os.read(self.stdout.fileno(), 1024)
1198 if data == "":
1199 self.stdout.close()
1200 read_set.remove(self.stdout)
1201 stdout.append(data)
1202
1203 if self.stderr in rlist:
1204 data = os.read(self.stderr.fileno(), 1024)
1205 if data == "":
1206 self.stderr.close()
1207 read_set.remove(self.stderr)
1208 stderr.append(data)
1209
1210
1211 if stdout is not None:
1212 stdout = string.join(stdout, '')
1213 if stderr is not None:
1214 stderr = string.join(stderr, '')
1215
1216
1217
1218
1219
1220 if self.universal_newlines and hasattr(file, 'newlines'):
1221 if stdout:
1222 stdout = self._translate_newlines(stdout)
1223 if stderr:
1224 stderr = self._translate_newlines(stderr)
1225
1226 self.wait()
1227 return (stdout, stderr)
1231
1232
1233
1234 plist = Popen(["ps"], stdout=PIPE).communicate()[0]
1235 print "Process list:"
1236 print plist
1237
1238
1239
1240
1241 if os.getuid() == 0:
1242 p = Popen(["id"], preexec_fn=lambda: os.setuid(100))
1243 p.wait()
1244
1245
1246
1247
1248 print "Looking for 'hda'..."
1249 p1 = Popen(["dmesg"], stdout=PIPE)
1250 p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
1251 print repr(p2.communicate()[0])
1252
1253
1254
1255
1256 print
1257 print "Trying a weird file..."
1258 try:
1259 print Popen(["/this/path/does/not/exist"]).communicate()
1260 except OSError, e:
1261 if e.errno == errno.ENOENT:
1262 print "The file didn't exist. I thought so..."
1263 print "Child traceback:"
1264 print e.child_traceback
1265 else:
1266 print "Error", e.errno
1267 else:
1268 sys.stderr.write( "Gosh. No error.\n" )
1269
1270
1272
1273
1274
1275 print "Looking for 'PROMPT' in set output..."
1276 p1 = Popen("set", stdout=PIPE, shell=True)
1277 p2 = Popen('find "PROMPT"', stdin=p1.stdout, stdout=PIPE)
1278 print repr(p2.communicate()[0])
1279
1280
1281
1282
1283 print "Executing calc..."
1284 p = Popen("calc")
1285 p.wait()
1286
1287
1288 if __name__ == "__main__":
1289 if mswindows:
1290 _demo_windows()
1291 else:
1292 _demo_posix()
1293
1294
1295
1296
1297
1298
1299