| """Provides an interface like pexpect.spawn interface using subprocess.Popen |
| """ |
| import os |
| import threading |
| import subprocess |
| import sys |
| import time |
| import signal |
| import shlex |
| |
| try: |
| from queue import Queue, Empty # Python 3 |
| except ImportError: |
| from Queue import Queue, Empty # Python 2 |
| |
| from .spawnbase import SpawnBase, PY3 |
| from .exceptions import EOF |
| from .utils import string_types |
| |
| class PopenSpawn(SpawnBase): |
| def __init__(self, cmd, timeout=30, maxread=2000, searchwindowsize=None, |
| logfile=None, cwd=None, env=None, encoding=None, |
| codec_errors='strict', preexec_fn=None): |
| super(PopenSpawn, self).__init__(timeout=timeout, maxread=maxread, |
| searchwindowsize=searchwindowsize, logfile=logfile, |
| encoding=encoding, codec_errors=codec_errors) |
| |
| # Note that `SpawnBase` initializes `self.crlf` to `\r\n` |
| # because the default behaviour for a PTY is to convert |
| # incoming LF to `\r\n` (see the `onlcr` flag and |
| # https://stackoverflow.com/a/35887657/5397009). Here we set |
| # it to `os.linesep` because that is what the spawned |
| # application outputs by default and `popen` doesn't translate |
| # anything. |
| if encoding is None: |
| self.crlf = os.linesep.encode ("ascii") |
| else: |
| self.crlf = self.string_type (os.linesep) |
| |
| kwargs = dict(bufsize=0, stdin=subprocess.PIPE, |
| stderr=subprocess.STDOUT, stdout=subprocess.PIPE, |
| cwd=cwd, preexec_fn=preexec_fn, env=env) |
| |
| if sys.platform == 'win32': |
| startupinfo = subprocess.STARTUPINFO() |
| startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW |
| kwargs['startupinfo'] = startupinfo |
| kwargs['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP |
| |
| if isinstance(cmd, string_types) and sys.platform != 'win32': |
| cmd = shlex.split(cmd, posix=os.name == 'posix') |
| |
| self.proc = subprocess.Popen(cmd, **kwargs) |
| self.pid = self.proc.pid |
| self.closed = False |
| self._buf = self.string_type() |
| |
| self._read_queue = Queue() |
| self._read_thread = threading.Thread(target=self._read_incoming) |
| self._read_thread.setDaemon(True) |
| self._read_thread.start() |
| |
| _read_reached_eof = False |
| |
| def read_nonblocking(self, size, timeout): |
| buf = self._buf |
| if self._read_reached_eof: |
| # We have already finished reading. Use up any buffered data, |
| # then raise EOF |
| if buf: |
| self._buf = buf[size:] |
| return buf[:size] |
| else: |
| self.flag_eof = True |
| raise EOF('End Of File (EOF).') |
| |
| if timeout == -1: |
| timeout = self.timeout |
| elif timeout is None: |
| timeout = 1e6 |
| |
| t0 = time.time() |
| while (time.time() - t0) < timeout and size and len(buf) < size: |
| try: |
| incoming = self._read_queue.get_nowait() |
| except Empty: |
| break |
| else: |
| if incoming is None: |
| self._read_reached_eof = True |
| break |
| |
| buf += self._decoder.decode(incoming, final=False) |
| |
| r, self._buf = buf[:size], buf[size:] |
| |
| self._log(r, 'read') |
| return r |
| |
| def _read_incoming(self): |
| """Run in a thread to move output from a pipe to a queue.""" |
| fileno = self.proc.stdout.fileno() |
| while 1: |
| buf = b'' |
| try: |
| buf = os.read(fileno, 1024) |
| except OSError as e: |
| self._log(e, 'read') |
| |
| if not buf: |
| # This indicates we have reached EOF |
| self._read_queue.put(None) |
| return |
| |
| self._read_queue.put(buf) |
| |
| def write(self, s): |
| '''This is similar to send() except that there is no return value. |
| ''' |
| self.send(s) |
| |
| def writelines(self, sequence): |
| '''This calls write() for each element in the sequence. |
| |
| The sequence can be any iterable object producing strings, typically a |
| list of strings. This does not add line separators. There is no return |
| value. |
| ''' |
| for s in sequence: |
| self.send(s) |
| |
| def send(self, s): |
| '''Send data to the subprocess' stdin. |
| |
| Returns the number of bytes written. |
| ''' |
| s = self._coerce_send_string(s) |
| self._log(s, 'send') |
| |
| b = self._encoder.encode(s, final=False) |
| if PY3: |
| return self.proc.stdin.write(b) |
| else: |
| # On Python 2, .write() returns None, so we return the length of |
| # bytes written ourselves. This assumes they all got written. |
| self.proc.stdin.write(b) |
| return len(b) |
| |
| def sendline(self, s=''): |
| '''Wraps send(), sending string ``s`` to child process, with os.linesep |
| automatically appended. Returns number of bytes written. ''' |
| |
| n = self.send(s) |
| return n + self.send(self.linesep) |
| |
| def wait(self): |
| '''Wait for the subprocess to finish. |
| |
| Returns the exit code. |
| ''' |
| status = self.proc.wait() |
| if status >= 0: |
| self.exitstatus = status |
| self.signalstatus = None |
| else: |
| self.exitstatus = None |
| self.signalstatus = -status |
| self.terminated = True |
| return status |
| |
| def kill(self, sig): |
| '''Sends a Unix signal to the subprocess. |
| |
| Use constants from the :mod:`signal` module to specify which signal. |
| ''' |
| if sys.platform == 'win32': |
| if sig in [signal.SIGINT, signal.CTRL_C_EVENT]: |
| sig = signal.CTRL_C_EVENT |
| elif sig in [signal.SIGBREAK, signal.CTRL_BREAK_EVENT]: |
| sig = signal.CTRL_BREAK_EVENT |
| else: |
| sig = signal.SIGTERM |
| |
| os.kill(self.proc.pid, sig) |
| |
| def sendeof(self): |
| '''Closes the stdin pipe from the writing end.''' |
| self.proc.stdin.close() |