| #!/usr/bin/python |
| """ |
| A class and functions used for running and controlling child processes. |
| |
| @copyright: 2008-2009 Red Hat Inc. |
| """ |
| |
| import os, sys, pty, select, termios, fcntl |
| |
| |
| # The following helper functions are shared by the server and the client. |
| |
| def _lock(filename): |
| if not os.path.exists(filename): |
| open(filename, "w").close() |
| fd = os.open(filename, os.O_RDWR) |
| fcntl.lockf(fd, fcntl.LOCK_EX) |
| return fd |
| |
| |
| def _unlock(fd): |
| fcntl.lockf(fd, fcntl.LOCK_UN) |
| os.close(fd) |
| |
| |
| def _locked(filename): |
| try: |
| fd = os.open(filename, os.O_RDWR) |
| except: |
| return False |
| try: |
| fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB) |
| except: |
| os.close(fd) |
| return True |
| fcntl.lockf(fd, fcntl.LOCK_UN) |
| os.close(fd) |
| return False |
| |
| |
| def _wait(filename): |
| fd = _lock(filename) |
| _unlock(fd) |
| |
| |
| def _get_filenames(base_dir, id): |
| return [os.path.join(base_dir, s + id) for s in |
| "shell-pid-", "status-", "output-", "inpipe-", |
| "lock-server-running-", "lock-client-starting-"] |
| |
| |
| def _get_reader_filename(base_dir, id, reader): |
| return os.path.join(base_dir, "outpipe-%s-%s" % (reader, id)) |
| |
| |
| # The following is the server part of the module. |
| |
| if __name__ == "__main__": |
| id = sys.stdin.readline().strip() |
| echo = sys.stdin.readline().strip() == "True" |
| readers = sys.stdin.readline().strip().split(",") |
| command = sys.stdin.readline().strip() + " && echo %s > /dev/null" % id |
| |
| # Define filenames to be used for communication |
| base_dir = "/tmp/kvm_spawn" |
| (shell_pid_filename, |
| status_filename, |
| output_filename, |
| inpipe_filename, |
| lock_server_running_filename, |
| lock_client_starting_filename) = _get_filenames(base_dir, id) |
| |
| # Populate the reader filenames list |
| reader_filenames = [_get_reader_filename(base_dir, id, reader) |
| for reader in readers] |
| |
| # Set $TERM = dumb |
| os.putenv("TERM", "dumb") |
| |
| (shell_pid, shell_fd) = pty.fork() |
| if shell_pid == 0: |
| # Child process: run the command in a subshell |
| os.execv("/bin/sh", ["/bin/sh", "-c", command]) |
| else: |
| # Parent process |
| lock_server_running = _lock(lock_server_running_filename) |
| |
| # Set terminal echo on/off and disable pre- and post-processing |
| attr = termios.tcgetattr(shell_fd) |
| attr[0] &= ~termios.INLCR |
| attr[0] &= ~termios.ICRNL |
| attr[0] &= ~termios.IGNCR |
| attr[1] &= ~termios.OPOST |
| if echo: |
| attr[3] |= termios.ECHO |
| else: |
| attr[3] &= ~termios.ECHO |
| termios.tcsetattr(shell_fd, termios.TCSANOW, attr) |
| |
| # Open output file |
| output_file = open(output_filename, "w") |
| # Open input pipe |
| os.mkfifo(inpipe_filename) |
| inpipe_fd = os.open(inpipe_filename, os.O_RDWR) |
| # Open output pipes (readers) |
| reader_fds = [] |
| for filename in reader_filenames: |
| os.mkfifo(filename) |
| reader_fds.append(os.open(filename, os.O_RDWR)) |
| |
| # Write shell PID to file |
| file = open(shell_pid_filename, "w") |
| file.write(str(shell_pid)) |
| file.close() |
| |
| # Print something to stdout so the client can start working |
| print "Server %s ready" % id |
| sys.stdout.flush() |
| |
| # Initialize buffers |
| buffers = ["" for reader in readers] |
| |
| # Read from child and write to files/pipes |
| while True: |
| check_termination = False |
| # Make a list of reader pipes whose buffers are not empty |
| fds = [fd for (i, fd) in enumerate(reader_fds) if buffers[i]] |
| # Wait until there's something to do |
| r, w, x = select.select([shell_fd, inpipe_fd], fds, [], 0.5) |
| # If a reader pipe is ready for writing -- |
| for (i, fd) in enumerate(reader_fds): |
| if fd in w: |
| bytes_written = os.write(fd, buffers[i]) |
| buffers[i] = buffers[i][bytes_written:] |
| # If there's data to read from the child process -- |
| if shell_fd in r: |
| try: |
| data = os.read(shell_fd, 16384) |
| except OSError: |
| data = "" |
| if not data: |
| check_termination = True |
| # Remove carriage returns from the data -- they often cause |
| # trouble and are normally not needed |
| data = data.replace("\r", "") |
| output_file.write(data) |
| output_file.flush() |
| for i in range(len(readers)): |
| buffers[i] += data |
| # If os.read() raised an exception or there was nothing to read -- |
| if check_termination or shell_fd not in r: |
| pid, status = os.waitpid(shell_pid, os.WNOHANG) |
| if pid: |
| status = os.WEXITSTATUS(status) |
| break |
| # If there's data to read from the client -- |
| if inpipe_fd in r: |
| data = os.read(inpipe_fd, 1024) |
| os.write(shell_fd, data) |
| |
| # Write the exit status to a file |
| file = open(status_filename, "w") |
| file.write(str(status)) |
| file.close() |
| |
| # Wait for the client to finish initializing |
| _wait(lock_client_starting_filename) |
| |
| # Delete FIFOs |
| for filename in reader_filenames + [inpipe_filename]: |
| try: |
| os.unlink(filename) |
| except OSError: |
| pass |
| |
| # Close all files and pipes |
| output_file.close() |
| os.close(inpipe_fd) |
| for fd in reader_fds: |
| os.close(fd) |
| |
| _unlock(lock_server_running) |
| exit(0) |
| |
| |
| # The following is the client part of the module. |
| |
| import subprocess, time, signal, re, threading, logging |
| import virt_utils |
| |
| |
| class ExpectError(Exception): |
| def __init__(self, patterns, output): |
| Exception.__init__(self, patterns, output) |
| self.patterns = patterns |
| self.output = output |
| |
| def _pattern_str(self): |
| if len(self.patterns) == 1: |
| return "pattern %r" % self.patterns[0] |
| else: |
| return "patterns %r" % self.patterns |
| |
| def __str__(self): |
| return ("Unknown error occurred while looking for %s (output: %r)" % |
| (self._pattern_str(), self.output)) |
| |
| |
| class ExpectTimeoutError(ExpectError): |
| def __str__(self): |
| return ("Timeout expired while looking for %s (output: %r)" % |
| (self._pattern_str(), self.output)) |
| |
| |
| class ExpectProcessTerminatedError(ExpectError): |
| def __init__(self, patterns, status, output): |
| ExpectError.__init__(self, patterns, output) |
| self.status = status |
| |
| def __str__(self): |
| return ("Process terminated while looking for %s " |
| "(status: %s, output: %r)" % (self._pattern_str(), |
| self.status, self.output)) |
| |
| |
| class ShellError(Exception): |
| def __init__(self, cmd, output): |
| Exception.__init__(self, cmd, output) |
| self.cmd = cmd |
| self.output = output |
| |
| def __str__(self): |
| return ("Could not execute shell command %r (output: %r)" % |
| (self.cmd, self.output)) |
| |
| |
| class ShellTimeoutError(ShellError): |
| def __str__(self): |
| return ("Timeout expired while waiting for shell command to " |
| "complete: %r (output: %r)" % (self.cmd, self.output)) |
| |
| |
| class ShellProcessTerminatedError(ShellError): |
| # Raised when the shell process itself (e.g. ssh, netcat, telnet) |
| # terminates unexpectedly |
| def __init__(self, cmd, status, output): |
| ShellError.__init__(self, cmd, output) |
| self.status = status |
| |
| def __str__(self): |
| return ("Shell process terminated while waiting for command to " |
| "complete: %r (status: %s, output: %r)" % |
| (self.cmd, self.status, self.output)) |
| |
| |
| class ShellCmdError(ShellError): |
| # Raised when a command executed in a shell terminates with a nonzero |
| # exit code (status) |
| def __init__(self, cmd, status, output): |
| ShellError.__init__(self, cmd, output) |
| self.status = status |
| |
| def __str__(self): |
| return ("Shell command failed: %r (status: %s, output: %r)" % |
| (self.cmd, self.status, self.output)) |
| |
| |
| class ShellStatusError(ShellError): |
| # Raised when the command's exit status cannot be obtained |
| def __str__(self): |
| return ("Could not get exit status of command: %r (output: %r)" % |
| (self.cmd, self.output)) |
| |
| |
| def run_bg(command, termination_func=None, output_func=None, output_prefix="", |
| timeout=1.0): |
| """ |
| Run command as a subprocess. Call output_func with each line of output |
| from the subprocess (prefixed by output_prefix). Call termination_func |
| when the subprocess terminates. Return when timeout expires or when the |
| subprocess exits -- whichever occurs first. |
| |
| @brief: Run a subprocess in the background and collect its output and |
| exit status. |
| |
| @param command: The shell command to execute |
| @param termination_func: A function to call when the process terminates |
| (should take an integer exit status parameter) |
| @param output_func: A function to call with each line of output from |
| the subprocess (should take a string parameter) |
| @param output_prefix: A string to pre-pend to each line of the output, |
| before passing it to stdout_func |
| @param timeout: Time duration (in seconds) to wait for the subprocess to |
| terminate before returning |
| |
| @return: A Tail object. |
| """ |
| process = Tail(command=command, |
| termination_func=termination_func, |
| output_func=output_func, |
| output_prefix=output_prefix) |
| |
| end_time = time.time() + timeout |
| while time.time() < end_time and process.is_alive(): |
| time.sleep(0.1) |
| |
| return process |
| |
| |
| def run_fg(command, output_func=None, output_prefix="", timeout=1.0): |
| """ |
| Run command as a subprocess. Call output_func with each line of output |
| from the subprocess (prefixed by prefix). Return when timeout expires or |
| when the subprocess exits -- whichever occurs first. If timeout expires |
| and the subprocess is still running, kill it before returning. |
| |
| @brief: Run a subprocess in the foreground and collect its output and |
| exit status. |
| |
| @param command: The shell command to execute |
| @param output_func: A function to call with each line of output from |
| the subprocess (should take a string parameter) |
| @param output_prefix: A string to pre-pend to each line of the output, |
| before passing it to stdout_func |
| @param timeout: Time duration (in seconds) to wait for the subprocess to |
| terminate before killing it and returning |
| |
| @return: A 2-tuple containing the exit status of the process and its |
| STDOUT/STDERR output. If timeout expires before the process |
| terminates, the returned status is None. |
| """ |
| process = run_bg(command, None, output_func, output_prefix, timeout) |
| output = process.get_output() |
| if process.is_alive(): |
| status = None |
| else: |
| status = process.get_status() |
| process.close() |
| return (status, output) |
| |
| |
| class Spawn: |
| """ |
| This class is used for spawning and controlling a child process. |
| |
| A new instance of this class can either run a new server (a small Python |
| program that reads output from the child process and reports it to the |
| client and to a text file) or attach to an already running server. |
| When a server is started it runs the child process. |
| The server writes output from the child's STDOUT and STDERR to a text file. |
| The text file can be accessed at any time using get_output(). |
| In addition, the server opens as many pipes as requested by the client and |
| writes the output to them. |
| The pipes are requested and accessed by classes derived from Spawn. |
| These pipes are referred to as "readers". |
| The server also receives input from the client and sends it to the child |
| process. |
| An instance of this class can be pickled. Every derived class is |
| responsible for restoring its own state by properly defining |
| __getinitargs__(). |
| |
| The first named pipe is used by _tail(), a function that runs in the |
| background and reports new output from the child as it is produced. |
| The second named pipe is used by a set of functions that read and parse |
| output as requested by the user in an interactive manner, similar to |
| pexpect. |
| When unpickled it automatically |
| resumes _tail() if needed. |
| """ |
| |
| def __init__(self, command=None, id=None, auto_close=False, echo=False, |
| linesep="\n"): |
| """ |
| Initialize the class and run command as a child process. |
| |
| @param command: Command to run, or None if accessing an already running |
| server. |
| @param id: ID of an already running server, if accessing a running |
| server, or None if starting a new one. |
| @param auto_close: If True, close() the instance automatically when its |
| reference count drops to zero (default False). |
| @param echo: Boolean indicating whether echo should be initially |
| enabled for the pseudo terminal running the subprocess. This |
| parameter has an effect only when starting a new server. |
| @param linesep: Line separator to be appended to strings sent to the |
| child process by sendline(). |
| """ |
| self.id = id or virt_utils.generate_random_string(8) |
| |
| # Define filenames for communication with server |
| base_dir = "/tmp/kvm_spawn" |
| try: |
| os.makedirs(base_dir) |
| except: |
| pass |
| (self.shell_pid_filename, |
| self.status_filename, |
| self.output_filename, |
| self.inpipe_filename, |
| self.lock_server_running_filename, |
| self.lock_client_starting_filename) = _get_filenames(base_dir, |
| self.id) |
| |
| # Remember some attributes |
| self.auto_close = auto_close |
| self.echo = echo |
| self.linesep = linesep |
| |
| # Make sure the 'readers' and 'close_hooks' attributes exist |
| if not hasattr(self, "readers"): |
| self.readers = [] |
| if not hasattr(self, "close_hooks"): |
| self.close_hooks = [] |
| |
| # Define the reader filenames |
| self.reader_filenames = dict( |
| (reader, _get_reader_filename(base_dir, self.id, reader)) |
| for reader in self.readers) |
| |
| # Let the server know a client intends to open some pipes; |
| # if the executed command terminates quickly, the server will wait for |
| # the client to release the lock before exiting |
| lock_client_starting = _lock(self.lock_client_starting_filename) |
| |
| # Start the server (which runs the command) |
| if command: |
| sub = subprocess.Popen("%s %s" % (sys.executable, __file__), |
| shell=True, |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT) |
| # Send parameters to the server |
| sub.stdin.write("%s\n" % self.id) |
| sub.stdin.write("%s\n" % echo) |
| sub.stdin.write("%s\n" % ",".join(self.readers)) |
| sub.stdin.write("%s\n" % command) |
| # Wait for the server to complete its initialization |
| while not "Server %s ready" % self.id in sub.stdout.readline(): |
| pass |
| |
| # Open the reading pipes |
| self.reader_fds = {} |
| try: |
| assert(_locked(self.lock_server_running_filename)) |
| for reader, filename in self.reader_filenames.items(): |
| self.reader_fds[reader] = os.open(filename, os.O_RDONLY) |
| except: |
| pass |
| |
| # Allow the server to continue |
| _unlock(lock_client_starting) |
| |
| |
| # The following two functions are defined to make sure the state is set |
| # exclusively by the constructor call as specified in __getinitargs__(). |
| |
| def __getstate__(self): |
| pass |
| |
| |
| def __setstate__(self, state): |
| pass |
| |
| |
| def __getinitargs__(self): |
| # Save some information when pickling -- will be passed to the |
| # constructor upon unpickling |
| return (None, self.id, self.auto_close, self.echo, self.linesep) |
| |
| |
| def __del__(self): |
| if self.auto_close: |
| self.close() |
| |
| |
| def _add_reader(self, reader): |
| """ |
| Add a reader whose file descriptor can be obtained with _get_fd(). |
| Should be called before __init__(). Intended for use by derived |
| classes. |
| |
| @param reader: The name of the reader. |
| """ |
| if not hasattr(self, "readers"): |
| self.readers = [] |
| self.readers.append(reader) |
| |
| |
| def _add_close_hook(self, hook): |
| """ |
| Add a close hook function to be called when close() is called. |
| The function will be called after the process terminates but before |
| final cleanup. Intended for use by derived classes. |
| |
| @param hook: The hook function. |
| """ |
| if not hasattr(self, "close_hooks"): |
| self.close_hooks = [] |
| self.close_hooks.append(hook) |
| |
| |
| def _get_fd(self, reader): |
| """ |
| Return an open file descriptor corresponding to the specified reader |
| pipe. If no such reader exists, or the pipe could not be opened, |
| return None. Intended for use by derived classes. |
| |
| @param reader: The name of the reader. |
| """ |
| return self.reader_fds.get(reader) |
| |
| |
| def get_id(self): |
| """ |
| Return the instance's id attribute, which may be used to access the |
| process in the future. |
| """ |
| return self.id |
| |
| |
| def get_pid(self): |
| """ |
| Return the PID of the process. |
| |
| Note: this may be the PID of the shell process running the user given |
| command. |
| """ |
| try: |
| file = open(self.shell_pid_filename, "r") |
| pid = int(file.read()) |
| file.close() |
| return pid |
| except: |
| return None |
| |
| |
| def get_status(self): |
| """ |
| Wait for the process to exit and return its exit status, or None |
| if the exit status is not available. |
| """ |
| _wait(self.lock_server_running_filename) |
| try: |
| file = open(self.status_filename, "r") |
| status = int(file.read()) |
| file.close() |
| return status |
| except: |
| return None |
| |
| |
| def get_output(self): |
| """ |
| Return the STDOUT and STDERR output of the process so far. |
| """ |
| try: |
| file = open(self.output_filename, "r") |
| output = file.read() |
| file.close() |
| return output |
| except: |
| return "" |
| |
| |
| def is_alive(self): |
| """ |
| Return True if the process is running. |
| """ |
| return _locked(self.lock_server_running_filename) |
| |
| |
| def close(self, sig=signal.SIGKILL): |
| """ |
| Kill the child process if it's alive and remove temporary files. |
| |
| @param sig: The signal to send the process when attempting to kill it. |
| """ |
| # Kill it if it's alive |
| if self.is_alive(): |
| virt_utils.kill_process_tree(self.get_pid(), sig) |
| # Wait for the server to exit |
| _wait(self.lock_server_running_filename) |
| # Call all cleanup routines |
| for hook in self.close_hooks: |
| hook(self) |
| # Close reader file descriptors |
| for fd in self.reader_fds.values(): |
| try: |
| os.close(fd) |
| except: |
| pass |
| self.reader_fds = {} |
| # Remove all used files |
| for filename in (_get_filenames("/tmp/kvm_spawn", self.id) + |
| self.reader_filenames.values()): |
| try: |
| os.unlink(filename) |
| except OSError: |
| pass |
| |
| |
| def set_linesep(self, linesep): |
| """ |
| Sets the line separator string (usually "\\n"). |
| |
| @param linesep: Line separator string. |
| """ |
| self.linesep = linesep |
| |
| |
| def send(self, str=""): |
| """ |
| Send a string to the child process. |
| |
| @param str: String to send to the child process. |
| """ |
| try: |
| fd = os.open(self.inpipe_filename, os.O_RDWR) |
| os.write(fd, str) |
| os.close(fd) |
| except: |
| pass |
| |
| |
| def sendline(self, str=""): |
| """ |
| Send a string followed by a line separator to the child process. |
| |
| @param str: String to send to the child process. |
| """ |
| self.send(str + self.linesep) |
| |
| |
| _thread_kill_requested = False |
| |
| def kill_tail_threads(): |
| """ |
| Kill all Tail threads. |
| |
| After calling this function no new threads should be started. |
| """ |
| global _thread_kill_requested |
| _thread_kill_requested = True |
| for t in threading.enumerate(): |
| if hasattr(t, "name") and t.name.startswith("tail_thread"): |
| t.join(10) |
| _thread_kill_requested = False |
| |
| |
| class Tail(Spawn): |
| """ |
| This class runs a child process in the background and sends its output in |
| real time, line-by-line, to a callback function. |
| |
| See Spawn's docstring. |
| |
| This class uses a single pipe reader to read data in real time from the |
| child process and report it to a given callback function. |
| When the child process exits, its exit status is reported to an additional |
| callback function. |
| |
| When this class is unpickled, it automatically resumes reporting output. |
| """ |
| |
| def __init__(self, command=None, id=None, auto_close=False, echo=False, |
| linesep="\n", termination_func=None, termination_params=(), |
| output_func=None, output_params=(), output_prefix=""): |
| """ |
| Initialize the class and run command as a child process. |
| |
| @param command: Command to run, or None if accessing an already running |
| server. |
| @param id: ID of an already running server, if accessing a running |
| server, or None if starting a new one. |
| @param auto_close: If True, close() the instance automatically when its |
| reference count drops to zero (default False). |
| @param echo: Boolean indicating whether echo should be initially |
| enabled for the pseudo terminal running the subprocess. This |
| parameter has an effect only when starting a new server. |
| @param linesep: Line separator to be appended to strings sent to the |
| child process by sendline(). |
| @param termination_func: Function to call when the process exits. The |
| function must accept a single exit status parameter. |
| @param termination_params: Parameters to send to termination_func |
| before the exit status. |
| @param output_func: Function to call whenever a line of output is |
| available from the STDOUT or STDERR streams of the process. |
| The function must accept a single string parameter. The string |
| does not include the final newline. |
| @param output_params: Parameters to send to output_func before the |
| output line. |
| @param output_prefix: String to prepend to lines sent to output_func. |
| """ |
| # Add a reader and a close hook |
| self._add_reader("tail") |
| self._add_close_hook(Tail._join_thread) |
| |
| # Init the superclass |
| Spawn.__init__(self, command, id, auto_close, echo, linesep) |
| |
| # Remember some attributes |
| self.termination_func = termination_func |
| self.termination_params = termination_params |
| self.output_func = output_func |
| self.output_params = output_params |
| self.output_prefix = output_prefix |
| |
| # Start the thread in the background |
| self.tail_thread = None |
| if termination_func or output_func: |
| self._start_thread() |
| |
| |
| def __getinitargs__(self): |
| return Spawn.__getinitargs__(self) + (self.termination_func, |
| self.termination_params, |
| self.output_func, |
| self.output_params, |
| self.output_prefix) |
| |
| |
| def set_termination_func(self, termination_func): |
| """ |
| Set the termination_func attribute. See __init__() for details. |
| |
| @param termination_func: Function to call when the process terminates. |
| Must take a single parameter -- the exit status. |
| """ |
| self.termination_func = termination_func |
| if termination_func and not self.tail_thread: |
| self._start_thread() |
| |
| |
| def set_termination_params(self, termination_params): |
| """ |
| Set the termination_params attribute. See __init__() for details. |
| |
| @param termination_params: Parameters to send to termination_func |
| before the exit status. |
| """ |
| self.termination_params = termination_params |
| |
| |
| def set_output_func(self, output_func): |
| """ |
| Set the output_func attribute. See __init__() for details. |
| |
| @param output_func: Function to call for each line of STDOUT/STDERR |
| output from the process. Must take a single string parameter. |
| """ |
| self.output_func = output_func |
| if output_func and not self.tail_thread: |
| self._start_thread() |
| |
| |
| def set_output_params(self, output_params): |
| """ |
| Set the output_params attribute. See __init__() for details. |
| |
| @param output_params: Parameters to send to output_func before the |
| output line. |
| """ |
| self.output_params = output_params |
| |
| |
| def set_output_prefix(self, output_prefix): |
| """ |
| Set the output_prefix attribute. See __init__() for details. |
| |
| @param output_prefix: String to pre-pend to each line sent to |
| output_func (see set_output_callback()). |
| """ |
| self.output_prefix = output_prefix |
| |
| |
| def _tail(self): |
| def print_line(text): |
| # Pre-pend prefix and remove trailing whitespace |
| text = self.output_prefix + text.rstrip() |
| # Pass text to output_func |
| try: |
| params = self.output_params + (text,) |
| self.output_func(*params) |
| except TypeError: |
| pass |
| |
| try: |
| fd = self._get_fd("tail") |
| buffer = "" |
| while True: |
| global _thread_kill_requested |
| if _thread_kill_requested: |
| return |
| try: |
| # See if there's any data to read from the pipe |
| r, w, x = select.select([fd], [], [], 0.05) |
| except: |
| break |
| if fd in r: |
| # Some data is available; read it |
| new_data = os.read(fd, 1024) |
| if not new_data: |
| break |
| buffer += new_data |
| # Send the output to output_func line by line |
| # (except for the last line) |
| if self.output_func: |
| lines = buffer.split("\n") |
| for line in lines[:-1]: |
| print_line(line) |
| # Leave only the last line |
| last_newline_index = buffer.rfind("\n") |
| buffer = buffer[last_newline_index+1:] |
| else: |
| # No output is available right now; flush the buffer |
| if buffer: |
| print_line(buffer) |
| buffer = "" |
| # The process terminated; print any remaining output |
| if buffer: |
| print_line(buffer) |
| # Get the exit status, print it and send it to termination_func |
| status = self.get_status() |
| if status is None: |
| return |
| print_line("(Process terminated with status %s)" % status) |
| try: |
| params = self.termination_params + (status,) |
| self.termination_func(*params) |
| except TypeError: |
| pass |
| finally: |
| self.tail_thread = None |
| |
| |
| def _start_thread(self): |
| self.tail_thread = threading.Thread(target=self._tail, |
| name="tail_thread_%s" % self.id) |
| self.tail_thread.start() |
| |
| |
| def _join_thread(self): |
| # Wait for the tail thread to exit |
| # (it's done this way because self.tail_thread may become None at any |
| # time) |
| t = self.tail_thread |
| if t: |
| t.join() |
| |
| |
| class Expect(Tail): |
| """ |
| This class runs a child process in the background and provides expect-like |
| services. |
| |
| It also provides all of Tail's functionality. |
| """ |
| |
| def __init__(self, command=None, id=None, auto_close=True, echo=False, |
| linesep="\n", termination_func=None, termination_params=(), |
| output_func=None, output_params=(), output_prefix=""): |
| """ |
| Initialize the class and run command as a child process. |
| |
| @param command: Command to run, or None if accessing an already running |
| server. |
| @param id: ID of an already running server, if accessing a running |
| server, or None if starting a new one. |
| @param auto_close: If True, close() the instance automatically when its |
| reference count drops to zero (default False). |
| @param echo: Boolean indicating whether echo should be initially |
| enabled for the pseudo terminal running the subprocess. This |
| parameter has an effect only when starting a new server. |
| @param linesep: Line separator to be appended to strings sent to the |
| child process by sendline(). |
| @param termination_func: Function to call when the process exits. The |
| function must accept a single exit status parameter. |
| @param termination_params: Parameters to send to termination_func |
| before the exit status. |
| @param output_func: Function to call whenever a line of output is |
| available from the STDOUT or STDERR streams of the process. |
| The function must accept a single string parameter. The string |
| does not include the final newline. |
| @param output_params: Parameters to send to output_func before the |
| output line. |
| @param output_prefix: String to prepend to lines sent to output_func. |
| """ |
| # Add a reader |
| self._add_reader("expect") |
| |
| # Init the superclass |
| Tail.__init__(self, command, id, auto_close, echo, linesep, |
| termination_func, termination_params, |
| output_func, output_params, output_prefix) |
| |
| |
| def __getinitargs__(self): |
| return Tail.__getinitargs__(self) |
| |
| |
| def read_nonblocking(self, timeout=None): |
| """ |
| Read from child until there is nothing to read for timeout seconds. |
| |
| @param timeout: Time (seconds) to wait before we give up reading from |
| the child process, or None to use the default value. |
| """ |
| if timeout is None: |
| timeout = 0.1 |
| fd = self._get_fd("expect") |
| data = "" |
| while True: |
| try: |
| r, w, x = select.select([fd], [], [], timeout) |
| except: |
| return data |
| if fd in r: |
| new_data = os.read(fd, 1024) |
| if not new_data: |
| return data |
| data += new_data |
| else: |
| return data |
| |
| |
| def match_patterns(self, str, patterns): |
| """ |
| Match str against a list of patterns. |
| |
| Return the index of the first pattern that matches a substring of str. |
| None and empty strings in patterns are ignored. |
| If no match is found, return None. |
| |
| @param patterns: List of strings (regular expression patterns). |
| """ |
| for i in range(len(patterns)): |
| if not patterns[i]: |
| continue |
| if re.search(patterns[i], str): |
| return i |
| |
| |
| def read_until_output_matches(self, patterns, filter=lambda x: x, |
| timeout=60, internal_timeout=None, |
| print_func=None): |
| """ |
| Read using read_nonblocking until a match is found using match_patterns, |
| or until timeout expires. Before attempting to search for a match, the |
| data is filtered using the filter function provided. |
| |
| @brief: Read from child using read_nonblocking until a pattern |
| matches. |
| @param patterns: List of strings (regular expression patterns) |
| @param filter: Function to apply to the data read from the child before |
| attempting to match it against the patterns (should take and |
| return a string) |
| @param timeout: The duration (in seconds) to wait until a match is |
| found |
| @param internal_timeout: The timeout to pass to read_nonblocking |
| @param print_func: A function to be used to print the data being read |
| (should take a string parameter) |
| @return: Tuple containing the match index and the data read so far |
| @raise ExpectTimeoutError: Raised if timeout expires |
| @raise ExpectProcessTerminatedError: Raised if the child process |
| terminates while waiting for output |
| @raise ExpectError: Raised if an unknown error occurs |
| """ |
| fd = self._get_fd("expect") |
| o = "" |
| end_time = time.time() + timeout |
| while True: |
| try: |
| r, w, x = select.select([fd], [], [], |
| max(0, end_time - time.time())) |
| except (select.error, TypeError): |
| break |
| if not r: |
| raise ExpectTimeoutError(patterns, o) |
| # Read data from child |
| data = self.read_nonblocking(internal_timeout) |
| if not data: |
| break |
| # Print it if necessary |
| if print_func: |
| for line in data.splitlines(): |
| print_func(line) |
| # Look for patterns |
| o += data |
| match = self.match_patterns(filter(o), patterns) |
| if match is not None: |
| return match, o |
| |
| # Check if the child has terminated |
| if virt_utils.wait_for(lambda: not self.is_alive(), 5, 0, 0.1): |
| raise ExpectProcessTerminatedError(patterns, self.get_status(), o) |
| else: |
| # This shouldn't happen |
| raise ExpectError(patterns, o) |
| |
| |
| def read_until_last_word_matches(self, patterns, timeout=60, |
| internal_timeout=None, print_func=None): |
| """ |
| Read using read_nonblocking until the last word of the output matches |
| one of the patterns (using match_patterns), or until timeout expires. |
| |
| @param patterns: A list of strings (regular expression patterns) |
| @param timeout: The duration (in seconds) to wait until a match is |
| found |
| @param internal_timeout: The timeout to pass to read_nonblocking |
| @param print_func: A function to be used to print the data being read |
| (should take a string parameter) |
| @return: A tuple containing the match index and the data read so far |
| @raise ExpectTimeoutError: Raised if timeout expires |
| @raise ExpectProcessTerminatedError: Raised if the child process |
| terminates while waiting for output |
| @raise ExpectError: Raised if an unknown error occurs |
| """ |
| def get_last_word(str): |
| if str: |
| return str.split()[-1] |
| else: |
| return "" |
| |
| return self.read_until_output_matches(patterns, get_last_word, |
| timeout, internal_timeout, |
| print_func) |
| |
| |
| def read_until_last_line_matches(self, patterns, timeout=60, |
| internal_timeout=None, print_func=None): |
| """ |
| Read using read_nonblocking until the last non-empty line of the output |
| matches one of the patterns (using match_patterns), or until timeout |
| expires. Return a tuple containing the match index (or None if no match |
| was found) and the data read so far. |
| |
| @brief: Read using read_nonblocking until the last non-empty line |
| matches a pattern. |
| |
| @param patterns: A list of strings (regular expression patterns) |
| @param timeout: The duration (in seconds) to wait until a match is |
| found |
| @param internal_timeout: The timeout to pass to read_nonblocking |
| @param print_func: A function to be used to print the data being read |
| (should take a string parameter) |
| @return: A tuple containing the match index and the data read so far |
| @raise ExpectTimeoutError: Raised if timeout expires |
| @raise ExpectProcessTerminatedError: Raised if the child process |
| terminates while waiting for output |
| @raise ExpectError: Raised if an unknown error occurs |
| """ |
| def get_last_nonempty_line(str): |
| nonempty_lines = [l for l in str.splitlines() if l.strip()] |
| if nonempty_lines: |
| return nonempty_lines[-1] |
| else: |
| return "" |
| |
| return self.read_until_output_matches(patterns, get_last_nonempty_line, |
| timeout, internal_timeout, |
| print_func) |
| |
| |
| class ShellSession(Expect): |
| """ |
| This class runs a child process in the background. It it suited for |
| processes that provide an interactive shell, such as SSH and Telnet. |
| |
| It provides all services of Expect and Tail. In addition, it |
| provides command running services, and a utility function to test the |
| process for responsiveness. |
| """ |
| |
| def __init__(self, command=None, id=None, auto_close=True, echo=False, |
| linesep="\n", termination_func=None, termination_params=(), |
| output_func=None, output_params=(), output_prefix="", |
| prompt=r"[\#\$]\s*$", status_test_command="echo $?"): |
| """ |
| Initialize the class and run command as a child process. |
| |
| @param command: Command to run, or None if accessing an already running |
| server. |
| @param id: ID of an already running server, if accessing a running |
| server, or None if starting a new one. |
| @param auto_close: If True, close() the instance automatically when its |
| reference count drops to zero (default True). |
| @param echo: Boolean indicating whether echo should be initially |
| enabled for the pseudo terminal running the subprocess. This |
| parameter has an effect only when starting a new server. |
| @param linesep: Line separator to be appended to strings sent to the |
| child process by sendline(). |
| @param termination_func: Function to call when the process exits. The |
| function must accept a single exit status parameter. |
| @param termination_params: Parameters to send to termination_func |
| before the exit status. |
| @param output_func: Function to call whenever a line of output is |
| available from the STDOUT or STDERR streams of the process. |
| The function must accept a single string parameter. The string |
| does not include the final newline. |
| @param output_params: Parameters to send to output_func before the |
| output line. |
| @param output_prefix: String to prepend to lines sent to output_func. |
| @param prompt: Regular expression describing the shell's prompt line. |
| @param status_test_command: Command to be used for getting the last |
| exit status of commands run inside the shell (used by |
| cmd_status_output() and friends). |
| """ |
| # Init the superclass |
| Expect.__init__(self, command, id, auto_close, echo, linesep, |
| termination_func, termination_params, |
| output_func, output_params, output_prefix) |
| |
| # Remember some attributes |
| self.prompt = prompt |
| self.status_test_command = status_test_command |
| |
| |
| def __getinitargs__(self): |
| return Expect.__getinitargs__(self) + (self.prompt, |
| self.status_test_command) |
| |
| |
| def set_prompt(self, prompt): |
| """ |
| Set the prompt attribute for later use by read_up_to_prompt. |
| |
| @param: String that describes the prompt contents. |
| """ |
| self.prompt = prompt |
| |
| |
| def set_status_test_command(self, status_test_command): |
| """ |
| Set the command to be sent in order to get the last exit status. |
| |
| @param status_test_command: Command that will be sent to get the last |
| exit status. |
| """ |
| self.status_test_command = status_test_command |
| |
| |
| def is_responsive(self, timeout=5.0): |
| """ |
| Return True if the process responds to STDIN/terminal input. |
| |
| Send a newline to the child process (e.g. SSH or Telnet) and read some |
| output using read_nonblocking(). |
| If all is OK, some output should be available (e.g. the shell prompt). |
| In that case return True. Otherwise return False. |
| |
| @param timeout: Time duration to wait before the process is considered |
| unresponsive. |
| """ |
| # Read all output that's waiting to be read, to make sure the output |
| # we read next is in response to the newline sent |
| self.read_nonblocking(timeout=0) |
| # Send a newline |
| self.sendline() |
| # Wait up to timeout seconds for some output from the child |
| end_time = time.time() + timeout |
| while time.time() < end_time: |
| time.sleep(0.5) |
| if self.read_nonblocking(timeout=0).strip(): |
| return True |
| # No output -- report unresponsive |
| return False |
| |
| |
| def read_up_to_prompt(self, timeout=60, internal_timeout=None, |
| print_func=None): |
| """ |
| Read using read_nonblocking until the last non-empty line of the output |
| matches the prompt regular expression set by set_prompt, or until |
| timeout expires. |
| |
| @brief: Read using read_nonblocking until the last non-empty line |
| matches the prompt. |
| |
| @param timeout: The duration (in seconds) to wait until a match is |
| found |
| @param internal_timeout: The timeout to pass to read_nonblocking |
| @param print_func: A function to be used to print the data being |
| read (should take a string parameter) |
| |
| @return: The data read so far |
| @raise ExpectTimeoutError: Raised if timeout expires |
| @raise ExpectProcessTerminatedError: Raised if the shell process |
| terminates while waiting for output |
| @raise ExpectError: Raised if an unknown error occurs |
| """ |
| m, o = self.read_until_last_line_matches([self.prompt], timeout, |
| internal_timeout, print_func) |
| return o |
| |
| |
| def cmd_output(self, cmd, timeout=60, internal_timeout=None, |
| print_func=None): |
| """ |
| Send a command and return its output. |
| |
| @param cmd: Command to send (must not contain newline characters) |
| @param timeout: The duration (in seconds) to wait for the prompt to |
| return |
| @param internal_timeout: The timeout to pass to read_nonblocking |
| @param print_func: A function to be used to print the data being read |
| (should take a string parameter) |
| |
| @return: The output of cmd |
| @raise ShellTimeoutError: Raised if timeout expires |
| @raise ShellProcessTerminatedError: Raised if the shell process |
| terminates while waiting for output |
| @raise ShellError: Raised if an unknown error occurs |
| """ |
| def remove_command_echo(str, cmd): |
| if str and str.splitlines()[0] == cmd: |
| str = "".join(str.splitlines(True)[1:]) |
| return str |
| |
| def remove_last_nonempty_line(str): |
| return "".join(str.rstrip().splitlines(True)[:-1]) |
| |
| logging.debug("Sending command: %s" % cmd) |
| self.read_nonblocking(timeout=0) |
| self.sendline(cmd) |
| try: |
| o = self.read_up_to_prompt(timeout, internal_timeout, print_func) |
| except ExpectError, e: |
| o = remove_command_echo(e.output, cmd) |
| if isinstance(e, ExpectTimeoutError): |
| raise ShellTimeoutError(cmd, o) |
| elif isinstance(e, ExpectProcessTerminatedError): |
| raise ShellProcessTerminatedError(cmd, e.status, o) |
| else: |
| raise ShellError(cmd, o) |
| |
| # Remove the echoed command and the final shell prompt |
| return remove_last_nonempty_line(remove_command_echo(o, cmd)) |
| |
| |
| def cmd_status_output(self, cmd, timeout=60, internal_timeout=None, |
| print_func=None): |
| """ |
| Send a command and return its exit status and output. |
| |
| @param cmd: Command to send (must not contain newline characters) |
| @param timeout: The duration (in seconds) to wait for the prompt to |
| return |
| @param internal_timeout: The timeout to pass to read_nonblocking |
| @param print_func: A function to be used to print the data being read |
| (should take a string parameter) |
| |
| @return: A tuple (status, output) where status is the exit status and |
| output is the output of cmd |
| @raise ShellTimeoutError: Raised if timeout expires |
| @raise ShellProcessTerminatedError: Raised if the shell process |
| terminates while waiting for output |
| @raise ShellStatusError: Raised if the exit status cannot be obtained |
| @raise ShellError: Raised if an unknown error occurs |
| """ |
| o = self.cmd_output(cmd, timeout, internal_timeout, print_func) |
| try: |
| # Send the 'echo $?' (or equivalent) command to get the exit status |
| s = self.cmd_output(self.status_test_command, 10, internal_timeout) |
| except ShellError: |
| raise ShellStatusError(cmd, o) |
| |
| # Get the first line consisting of digits only |
| digit_lines = [l for l in s.splitlines() if l.strip().isdigit()] |
| if digit_lines: |
| return int(digit_lines[0].strip()), o |
| else: |
| raise ShellStatusError(cmd, o) |
| |
| |
| def cmd_status(self, cmd, timeout=60, internal_timeout=None, |
| print_func=None): |
| """ |
| Send a command and return its exit status. |
| |
| @param cmd: Command to send (must not contain newline characters) |
| @param timeout: The duration (in seconds) to wait for the prompt to |
| return |
| @param internal_timeout: The timeout to pass to read_nonblocking |
| @param print_func: A function to be used to print the data being read |
| (should take a string parameter) |
| |
| @return: The exit status of cmd |
| @raise ShellTimeoutError: Raised if timeout expires |
| @raise ShellProcessTerminatedError: Raised if the shell process |
| terminates while waiting for output |
| @raise ShellStatusError: Raised if the exit status cannot be obtained |
| @raise ShellError: Raised if an unknown error occurs |
| """ |
| s, o = self.cmd_status_output(cmd, timeout, internal_timeout, |
| print_func) |
| return s |
| |
| |
| def cmd(self, cmd, timeout=60, internal_timeout=None, print_func=None): |
| """ |
| Send a command and return its output. If the command's exit status is |
| nonzero, raise an exception. |
| |
| @param cmd: Command to send (must not contain newline characters) |
| @param timeout: The duration (in seconds) to wait for the prompt to |
| return |
| @param internal_timeout: The timeout to pass to read_nonblocking |
| @param print_func: A function to be used to print the data being read |
| (should take a string parameter) |
| |
| @return: The output of cmd |
| @raise ShellTimeoutError: Raised if timeout expires |
| @raise ShellProcessTerminatedError: Raised if the shell process |
| terminates while waiting for output |
| @raise ShellError: Raised if the exit status cannot be obtained or if |
| an unknown error occurs |
| @raise ShellStatusError: Raised if the exit status cannot be obtained |
| @raise ShellError: Raised if an unknown error occurs |
| @raise ShellCmdError: Raised if the exit status is nonzero |
| """ |
| s, o = self.cmd_status_output(cmd, timeout, internal_timeout, |
| print_func) |
| if s != 0: |
| raise ShellCmdError(cmd, s, o) |
| return o |
| |
| |
| def get_command_output(self, cmd, timeout=60, internal_timeout=None, |
| print_func=None): |
| """ |
| Alias for cmd_output() for backward compatibility. |
| """ |
| return self.cmd_output(cmd, timeout, internal_timeout, print_func) |
| |
| |
| def get_command_status_output(self, cmd, timeout=60, internal_timeout=None, |
| print_func=None): |
| """ |
| Alias for cmd_status_output() for backward compatibility. |
| """ |
| return self.cmd_status_output(cmd, timeout, internal_timeout, |
| print_func) |
| |
| |
| def get_command_status(self, cmd, timeout=60, internal_timeout=None, |
| print_func=None): |
| """ |
| Alias for cmd_status() for backward compatibility. |
| """ |
| return self.cmd_status(cmd, timeout, internal_timeout, print_func) |
