source: titan/mediathek/localhoster/lib/python2.7/subprocess.py @ 40114

Last change on this file since 40114 was 40094, checked in by obi, 7 years ago

tithek add yoztube-dl support

File size: 58.1 KB
Line 
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
10r"""subprocess - Subprocesses with accessible I/O streams
11
12This module allows you to spawn processes, connect to their
13input/output/error pipes, and obtain their return codes.  This module
14intends to replace several older modules and functions:
15
16os.system
17os.spawn*
18os.popen*
19popen2.*
20commands.*
21
22Information about how the subprocess module can be used to replace these
23modules and functions can be found below.
24
25
26
27Using the subprocess module
28===========================
29This module defines one class called Popen:
30
31class 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
38Arguments are:
39
40args should be a string, or a sequence of program arguments.  The
41program to execute is normally the first item in the args sequence or
42string, but can be explicitly set by using the executable argument.
43
44On UNIX, with shell=False (default): In this case, the Popen class
45uses os.execvp() to execute the child program.  args should normally
46be a sequence.  A string will be treated as a sequence with the string
47as the only item (the program to execute).
48
49On UNIX, with shell=True: If args is a string, it specifies the
50command string to execute through the shell.  If args is a sequence,
51the first item specifies the command string, and any additional items
52will be treated as additional shell arguments.
53
54On Windows: the Popen class uses CreateProcess() to execute the child
55program, which operates on strings.  If args is a sequence, it will be
56converted to a string using the list2cmdline method.  Please note that
57not all MS Windows applications interpret the command line the same
58way: The list2cmdline is designed for applications using the same
59rules as the MS C runtime.
60
61bufsize, if given, has the same meaning as the corresponding argument
62to the built-in open() function: 0 means unbuffered, 1 means line
63buffered, any other positive value means use a buffer of
64(approximately) that size.  A negative bufsize means to use the system
65default, which usually means fully buffered.  The default value for
66bufsize is 0 (unbuffered).
67
68stdin, stdout and stderr specify the executed programs' standard
69input, standard output and standard error file handles, respectively.
70Valid values are PIPE, an existing file descriptor (a positive
71integer), an existing file object, and None.  PIPE indicates that a
72new pipe to the child should be created.  With None, no redirection
73will occur; the child's file handles will be inherited from the
74parent.  Additionally, stderr can be STDOUT, which indicates that the
75stderr data from the applications should be captured into the same
76file handle as for stdout.
77
78If preexec_fn is set to a callable object, this object will be called
79in the child process just before the child is executed.
80
81If close_fds is true, all file descriptors except 0, 1 and 2 will be
82closed before the child process is executed.
83
84if shell is true, the specified command will be executed through the
85shell.
86
87If cwd is not None, the current directory will be changed to cwd
88before the child is executed.
89
90If env is not None, it defines the environment variables for the new
91process.
92
93If universal_newlines is true, the file objects stdout and stderr are
94opened as a text files, but lines may be terminated by any of '\n',
95the Unix end-of-line convention, '\r', the Macintosh convention or
96'\r\n', the Windows convention.  All of these external representations
97are seen as '\n' by the Python program.  Note: This feature is only
98available if Python is built with universal newline support (the
99default).  Also, the newlines attribute of the file objects stdout,
100stdin and stderr are not updated by the communicate() method.
101
102The startupinfo and creationflags, if given, will be passed to the
103underlying CreateProcess() function.  They can specify things such as
104appearance of the main window and priority for the new process.
105(Windows only)
106
107
108This module also defines some shortcut functions:
109
110call(*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
118check_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
128check_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
140Exceptions
141----------
142Exceptions raised in the child process, before the new program has
143started to execute, will be re-raised in the parent.  Additionally,
144the exception object will have one extra attribute called
145'child_traceback', which is a string containing traceback information
146from the child's point of view.
147
148The most common exception raised is OSError.  This occurs, for
149example, when trying to execute a non-existent file.  Applications
150should prepare for OSErrors.
151
152A ValueError will be raised if Popen is called with invalid arguments.
153
154check_call() and check_output() will raise CalledProcessError, if the
155called process returns a non-zero return code.
156
157
158Security
159--------
160Unlike some other popen functions, this implementation will never call
161/bin/sh implicitly.  This means that all characters, including shell
162metacharacters, can safely be passed to child processes.
163
164
165Popen objects
166=============
167Instances of the Popen class have the following methods:
168
169poll()
170    Check if child process has terminated.  Returns returncode
171    attribute.
172
173wait()
174    Wait for child process to terminate.  Returns returncode attribute.
175
176communicate(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
188The following attributes are also available:
189
190stdin
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
194stdout
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
199stderr
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
204pid
205    The process ID of the child process.
206
207returncode
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
213Replacing older functions with the subprocess module
214====================================================
215In this section, "a ==> b" means that b can be used as a replacement
216for a.
217
218Note: All functions in this section fail (more or less) silently if
219the executed program cannot be found; this module raises an OSError
220exception.
221
222In the following examples, we assume that the subprocess module is
223imported with "from subprocess import *".
224
225
226Replacing /bin/sh shell backquote
227---------------------------------
228output=`mycmd myarg`
229==>
230output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
231
232
233Replacing shell pipe line
234-------------------------
235output=`dmesg | grep hda`
236==>
237p1 = Popen(["dmesg"], stdout=PIPE)
238p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
239output = p2.communicate()[0]
240
241
242Replacing os.system()
243---------------------
244sts = os.system("mycmd" + " myarg")
245==>
246p = Popen("mycmd" + " myarg", shell=True)
247pid, sts = os.waitpid(p.pid, 0)
248
249Note:
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
256A more real-world example would look like this:
257
258try:
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
264except OSError, e:
265    print >>sys.stderr, "Execution failed:", e
266
267
268Replacing os.spawn*
269-------------------
270P_NOWAIT example:
271
272pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
273==>
274pid = Popen(["/bin/mycmd", "myarg"]).pid
275
276
277P_WAIT example:
278
279retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
280==>
281retcode = call(["/bin/mycmd", "myarg"])
282
283
284Vector example:
285
286os.spawnvp(os.P_NOWAIT, path, args)
287==>
288Popen([path] + args[1:])
289
290
291Environment example:
292
293os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
294==>
295Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})
296
297
298Replacing os.popen*
299-------------------
300pipe = os.popen("cmd", mode='r', bufsize)
301==>
302pipe = Popen("cmd", shell=True, bufsize=bufsize, stdout=PIPE).stdout
303
304pipe = os.popen("cmd", mode='w', bufsize)
305==>
306pipe = Popen("cmd", shell=True, bufsize=bufsize, stdin=PIPE).stdin
307
308
309(child_stdin, child_stdout) = os.popen2("cmd", mode, bufsize)
310==>
311p = 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==>
320p = 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==>
330p = 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
334On Unix, os.popen2, os.popen3 and os.popen4 also accept a sequence as
335the command to execute, in which case arguments will be passed
336directly to the program without shell intervention.  This usage can be
337replaced as follows:
338
339(child_stdin, child_stdout) = os.popen2(["/bin/ls", "-l"], mode,
340                                        bufsize)
341==>
342p = Popen(["/bin/ls", "-l"], bufsize=bufsize, stdin=PIPE, stdout=PIPE)
343(child_stdin, child_stdout) = (p.stdin, p.stdout)
344
345Return code handling translates as follows:
346
347pipe = os.popen("cmd", 'w')
348...
349rc = pipe.close()
350if rc is not None and rc % 256:
351    print "There were some errors"
352==>
353process = Popen("cmd", 'w', shell=True, stdin=PIPE)
354...
355process.stdin.close()
356if process.wait() != 0:
357    print "There were some errors"
358
359
360Replacing popen2.*
361------------------
362(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
363==>
364p = Popen(["somestring"], shell=True, bufsize=bufsize
365          stdin=PIPE, stdout=PIPE, close_fds=True)
366(child_stdout, child_stdin) = (p.stdout, p.stdin)
367
368On Unix, popen2 also accepts a sequence as the command to execute, in
369which case arguments will be passed directly to the program without
370shell intervention.  This usage can be replaced as follows:
371
372(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize,
373                                            mode)
374==>
375p = Popen(["mycmd", "myarg"], bufsize=bufsize,
376          stdin=PIPE, stdout=PIPE, close_fds=True)
377(child_stdout, child_stdin) = (p.stdout, p.stdin)
378
379The popen2.Popen3 and popen2.Popen4 basically works as subprocess.Popen,
380except 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
389import sys
390mswindows = (sys.platform == "win32")
391
392import os
393import types
394import traceback
395import gc
396import signal
397import errno
398
399# Exception classes used by this module.
400class 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
414if 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
426else:
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
441if 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"])
451try:
452    MAXFD = os.sysconf("SC_OPEN_MAX")
453except:
454    MAXFD = 256
455
456_active = []
457
458def _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
469PIPE = -1
470STDOUT = -2
471
472
473def _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
487def _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
514def 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
525def 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
544def 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
577def 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
647class 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
1567def _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
1608def _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
1625if __name__ == "__main__":
1626    if mswindows:
1627        _demo_windows()
1628    else:
1629        _demo_posix()
Note: See TracBrowser for help on using the repository browser.