Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 1 | __all__ = ['create_subprocess_exec', 'create_subprocess_shell'] |
| 2 | |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 3 | import subprocess |
| 4 | |
| 5 | from . import events |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 6 | from . import protocols |
| 7 | from . import streams |
| 8 | from . import tasks |
Victor Stinner | f951d28 | 2014-06-29 00:46:45 +0200 | [diff] [blame] | 9 | from .coroutines import coroutine |
Victor Stinner | acdb782 | 2014-07-14 18:33:40 +0200 | [diff] [blame] | 10 | from .log import logger |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 11 | |
| 12 | |
| 13 | PIPE = subprocess.PIPE |
| 14 | STDOUT = subprocess.STDOUT |
| 15 | DEVNULL = subprocess.DEVNULL |
| 16 | |
| 17 | |
| 18 | class SubprocessStreamProtocol(streams.FlowControlMixin, |
| 19 | protocols.SubprocessProtocol): |
| 20 | """Like StreamReaderProtocol, but for a subprocess.""" |
| 21 | |
| 22 | def __init__(self, limit, loop): |
| 23 | super().__init__(loop=loop) |
| 24 | self._limit = limit |
| 25 | self.stdin = self.stdout = self.stderr = None |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 26 | self._transport = None |
Seth M. Larson | 604faba | 2017-03-02 22:21:18 -0600 | [diff] [blame] | 27 | self._process_exited = False |
| 28 | self._pipe_fds = [] |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 29 | |
Victor Stinner | acdb782 | 2014-07-14 18:33:40 +0200 | [diff] [blame] | 30 | def __repr__(self): |
| 31 | info = [self.__class__.__name__] |
| 32 | if self.stdin is not None: |
| 33 | info.append('stdin=%r' % self.stdin) |
| 34 | if self.stdout is not None: |
| 35 | info.append('stdout=%r' % self.stdout) |
| 36 | if self.stderr is not None: |
| 37 | info.append('stderr=%r' % self.stderr) |
| 38 | return '<%s>' % ' '.join(info) |
| 39 | |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 40 | def connection_made(self, transport): |
| 41 | self._transport = transport |
Victor Stinner | 5ef586f | 2014-11-25 17:20:33 +0100 | [diff] [blame] | 42 | |
| 43 | stdout_transport = transport.get_pipe_transport(1) |
| 44 | if stdout_transport is not None: |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 45 | self.stdout = streams.StreamReader(limit=self._limit, |
| 46 | loop=self._loop) |
Victor Stinner | 5ef586f | 2014-11-25 17:20:33 +0100 | [diff] [blame] | 47 | self.stdout.set_transport(stdout_transport) |
Seth M. Larson | 604faba | 2017-03-02 22:21:18 -0600 | [diff] [blame] | 48 | self._pipe_fds.append(1) |
Victor Stinner | 5ef586f | 2014-11-25 17:20:33 +0100 | [diff] [blame] | 49 | |
| 50 | stderr_transport = transport.get_pipe_transport(2) |
| 51 | if stderr_transport is not None: |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 52 | self.stderr = streams.StreamReader(limit=self._limit, |
| 53 | loop=self._loop) |
Victor Stinner | 5ef586f | 2014-11-25 17:20:33 +0100 | [diff] [blame] | 54 | self.stderr.set_transport(stderr_transport) |
Seth M. Larson | 604faba | 2017-03-02 22:21:18 -0600 | [diff] [blame] | 55 | self._pipe_fds.append(2) |
Victor Stinner | 5ef586f | 2014-11-25 17:20:33 +0100 | [diff] [blame] | 56 | |
| 57 | stdin_transport = transport.get_pipe_transport(0) |
| 58 | if stdin_transport is not None: |
| 59 | self.stdin = streams.StreamWriter(stdin_transport, |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 60 | protocol=self, |
| 61 | reader=None, |
| 62 | loop=self._loop) |
Victor Stinner | f651a60 | 2015-01-14 02:10:33 +0100 | [diff] [blame] | 63 | |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 64 | def pipe_data_received(self, fd, data): |
| 65 | if fd == 1: |
| 66 | reader = self.stdout |
| 67 | elif fd == 2: |
| 68 | reader = self.stderr |
| 69 | else: |
| 70 | reader = None |
| 71 | if reader is not None: |
| 72 | reader.feed_data(data) |
| 73 | |
| 74 | def pipe_connection_lost(self, fd, exc): |
| 75 | if fd == 0: |
| 76 | pipe = self.stdin |
| 77 | if pipe is not None: |
| 78 | pipe.close() |
| 79 | self.connection_lost(exc) |
| 80 | return |
| 81 | if fd == 1: |
| 82 | reader = self.stdout |
| 83 | elif fd == 2: |
| 84 | reader = self.stderr |
| 85 | else: |
| 86 | reader = None |
| 87 | if reader != None: |
| 88 | if exc is None: |
| 89 | reader.feed_eof() |
| 90 | else: |
| 91 | reader.set_exception(exc) |
| 92 | |
Seth M. Larson | 604faba | 2017-03-02 22:21:18 -0600 | [diff] [blame] | 93 | if fd in self._pipe_fds: |
| 94 | self._pipe_fds.remove(fd) |
| 95 | self._maybe_close_transport() |
| 96 | |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 97 | def process_exited(self): |
Seth M. Larson | 604faba | 2017-03-02 22:21:18 -0600 | [diff] [blame] | 98 | self._process_exited = True |
| 99 | self._maybe_close_transport() |
| 100 | |
| 101 | def _maybe_close_transport(self): |
| 102 | if len(self._pipe_fds) == 0 and self._process_exited: |
| 103 | self._transport.close() |
| 104 | self._transport = None |
Victor Stinner | 791009b | 2015-01-15 13:16:02 +0100 | [diff] [blame] | 105 | |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 106 | |
| 107 | class Process: |
| 108 | def __init__(self, transport, protocol, loop): |
| 109 | self._transport = transport |
| 110 | self._protocol = protocol |
| 111 | self._loop = loop |
| 112 | self.stdin = protocol.stdin |
| 113 | self.stdout = protocol.stdout |
| 114 | self.stderr = protocol.stderr |
| 115 | self.pid = transport.get_pid() |
| 116 | |
Victor Stinner | acdb782 | 2014-07-14 18:33:40 +0200 | [diff] [blame] | 117 | def __repr__(self): |
| 118 | return '<%s %s>' % (self.__class__.__name__, self.pid) |
| 119 | |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 120 | @property |
| 121 | def returncode(self): |
| 122 | return self._transport.get_returncode() |
| 123 | |
Victor Stinner | f951d28 | 2014-06-29 00:46:45 +0200 | [diff] [blame] | 124 | @coroutine |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 125 | def wait(self): |
Victor Stinner | 47cd10d | 2015-01-30 00:05:19 +0100 | [diff] [blame] | 126 | """Wait until the process exit and return the process return code. |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 127 | |
Victor Stinner | 47cd10d | 2015-01-30 00:05:19 +0100 | [diff] [blame] | 128 | This method is a coroutine.""" |
Victor Stinner | 1241ecc | 2015-01-30 00:16:14 +0100 | [diff] [blame] | 129 | return (yield from self._transport._wait()) |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 130 | |
| 131 | def send_signal(self, signal): |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 132 | self._transport.send_signal(signal) |
| 133 | |
| 134 | def terminate(self): |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 135 | self._transport.terminate() |
| 136 | |
| 137 | def kill(self): |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 138 | self._transport.kill() |
| 139 | |
Victor Stinner | f951d28 | 2014-06-29 00:46:45 +0200 | [diff] [blame] | 140 | @coroutine |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 141 | def _feed_stdin(self, input): |
Victor Stinner | d55b54d | 2014-07-17 13:12:03 +0200 | [diff] [blame] | 142 | debug = self._loop.get_debug() |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 143 | self.stdin.write(input) |
Victor Stinner | d55b54d | 2014-07-17 13:12:03 +0200 | [diff] [blame] | 144 | if debug: |
Victor Stinner | acdb782 | 2014-07-14 18:33:40 +0200 | [diff] [blame] | 145 | logger.debug('%r communicate: feed stdin (%s bytes)', |
| 146 | self, len(input)) |
Victor Stinner | cc996b5 | 2014-07-17 12:25:27 +0200 | [diff] [blame] | 147 | try: |
| 148 | yield from self.stdin.drain() |
Victor Stinner | d55b54d | 2014-07-17 13:12:03 +0200 | [diff] [blame] | 149 | except (BrokenPipeError, ConnectionResetError) as exc: |
| 150 | # communicate() ignores BrokenPipeError and ConnectionResetError |
| 151 | if debug: |
| 152 | logger.debug('%r communicate: stdin got %r', self, exc) |
Victor Stinner | acdb782 | 2014-07-14 18:33:40 +0200 | [diff] [blame] | 153 | |
Victor Stinner | d55b54d | 2014-07-17 13:12:03 +0200 | [diff] [blame] | 154 | if debug: |
Victor Stinner | acdb782 | 2014-07-14 18:33:40 +0200 | [diff] [blame] | 155 | logger.debug('%r communicate: close stdin', self) |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 156 | self.stdin.close() |
| 157 | |
Victor Stinner | f951d28 | 2014-06-29 00:46:45 +0200 | [diff] [blame] | 158 | @coroutine |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 159 | def _noop(self): |
| 160 | return None |
| 161 | |
Victor Stinner | f951d28 | 2014-06-29 00:46:45 +0200 | [diff] [blame] | 162 | @coroutine |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 163 | def _read_stream(self, fd): |
| 164 | transport = self._transport.get_pipe_transport(fd) |
| 165 | if fd == 2: |
| 166 | stream = self.stderr |
| 167 | else: |
| 168 | assert fd == 1 |
| 169 | stream = self.stdout |
Victor Stinner | acdb782 | 2014-07-14 18:33:40 +0200 | [diff] [blame] | 170 | if self._loop.get_debug(): |
| 171 | name = 'stdout' if fd == 1 else 'stderr' |
| 172 | logger.debug('%r communicate: read %s', self, name) |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 173 | output = yield from stream.read() |
Victor Stinner | acdb782 | 2014-07-14 18:33:40 +0200 | [diff] [blame] | 174 | if self._loop.get_debug(): |
| 175 | name = 'stdout' if fd == 1 else 'stderr' |
| 176 | logger.debug('%r communicate: close %s', self, name) |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 177 | transport.close() |
| 178 | return output |
| 179 | |
Victor Stinner | f951d28 | 2014-06-29 00:46:45 +0200 | [diff] [blame] | 180 | @coroutine |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 181 | def communicate(self, input=None): |
Yury Selivanov | 7657f6b | 2016-05-13 15:35:28 -0400 | [diff] [blame] | 182 | if input is not None: |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 183 | stdin = self._feed_stdin(input) |
| 184 | else: |
| 185 | stdin = self._noop() |
| 186 | if self.stdout is not None: |
| 187 | stdout = self._read_stream(1) |
| 188 | else: |
| 189 | stdout = self._noop() |
| 190 | if self.stderr is not None: |
| 191 | stderr = self._read_stream(2) |
| 192 | else: |
| 193 | stderr = self._noop() |
| 194 | stdin, stdout, stderr = yield from tasks.gather(stdin, stdout, stderr, |
Victor Stinner | 8d0230b | 2014-02-20 10:12:59 +0100 | [diff] [blame] | 195 | loop=self._loop) |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 196 | yield from self.wait() |
| 197 | return (stdout, stderr) |
| 198 | |
| 199 | |
Victor Stinner | f951d28 | 2014-06-29 00:46:45 +0200 | [diff] [blame] | 200 | @coroutine |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 201 | def create_subprocess_shell(cmd, stdin=None, stdout=None, stderr=None, |
| 202 | loop=None, limit=streams._DEFAULT_LIMIT, **kwds): |
| 203 | if loop is None: |
| 204 | loop = events.get_event_loop() |
| 205 | protocol_factory = lambda: SubprocessStreamProtocol(limit=limit, |
| 206 | loop=loop) |
| 207 | transport, protocol = yield from loop.subprocess_shell( |
| 208 | protocol_factory, |
| 209 | cmd, stdin=stdin, stdout=stdout, |
| 210 | stderr=stderr, **kwds) |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 211 | return Process(transport, protocol, loop) |
| 212 | |
Victor Stinner | f951d28 | 2014-06-29 00:46:45 +0200 | [diff] [blame] | 213 | @coroutine |
Yury Selivanov | 5779752 | 2014-02-18 22:56:15 -0500 | [diff] [blame] | 214 | def create_subprocess_exec(program, *args, stdin=None, stdout=None, |
| 215 | stderr=None, loop=None, |
| 216 | limit=streams._DEFAULT_LIMIT, **kwds): |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 217 | if loop is None: |
| 218 | loop = events.get_event_loop() |
| 219 | protocol_factory = lambda: SubprocessStreamProtocol(limit=limit, |
| 220 | loop=loop) |
| 221 | transport, protocol = yield from loop.subprocess_exec( |
| 222 | protocol_factory, |
Victor Stinner | 20e0743 | 2014-02-11 11:44:56 +0100 | [diff] [blame] | 223 | program, *args, |
| 224 | stdin=stdin, stdout=stdout, |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 225 | stderr=stderr, **kwds) |
Victor Stinner | 915bcb0 | 2014-02-01 22:49:59 +0100 | [diff] [blame] | 226 | return Process(transport, protocol, loop) |