Revert "Merge remote branch 'cros/upstream' into autotest-rebase"

client/tests/kvm/kvm_subprocess.py

 #!/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
 
 
@@ skipping 171 matching lines @@
         _unlock(lock_server_running)
         exit(0)
 
 
 # The following is the client part of the module.
 
 import subprocess, time, signal, re, threading, logging
 import common, kvm_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 %r to "
-                "complete (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 %r to "
-                "complete (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 %r failed with status %d (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.
+    @return: A kvm_tail object.
     """
-    process = Tail(command=command,
-                   termination_func=termination_func,
-                   output_func=output_func,
-                   output_prefix=output_prefix)
+    process = kvm_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):
     """
@@ skipping 20 matching lines @@
     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:
+class kvm_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.
+    The pipes are requested and accessed by classes derived from kvm_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
@@ skipping 263 matching lines @@
 
         @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.
+    Kill all kvm_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):
+class kvm_tail(kvm_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.
+    See kvm_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,
@@ skipping 20 matching lines @@
         @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)
+        self._add_close_hook(kvm_tail._join_thread)
 
         # Init the superclass
-        Spawn.__init__(self, command, id, auto_close, echo, linesep)
+        kvm_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)
+        return kvm_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
@@ skipping 111 matching lines @@
 
     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):
+class kvm_expect(kvm_tail):
     """
     This class runs a child process in the background and provides expect-like
     services.
 
-    It also provides all of Tail's functionality.
+    It also provides all of kvm_tail's functionality.
     """
 
-    def __init__(self, command=None, id=None, auto_close=True, echo=False,
+    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
@@ skipping 12 matching lines @@
                 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)
+        kvm_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)
+        return kvm_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:
@@ skipping 25 matching lines @@
         @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,
+                                  timeout=30.0, 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
+        @return: Tuple containing the match index (or None if no match was
+                found) and the data read so far.
         """
+        match = None
+        data = ""
+
         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)
+            if fd not in r:
+                break
             # Read data from child
-            data = self.read_nonblocking(internal_timeout)
-            if not data:
-                break
+            newdata = self.read_nonblocking(internal_timeout)
             # Print it if necessary
-            if print_func:
-                for line in data.splitlines():
+            if print_func and newdata:
+                str = newdata
+                if str.endswith("\n"):
+                    str = str[:-1]
+                for line in str.split("\n"):
                     print_func(line)
+            data += newdata
+
+            done = False
             # Look for patterns
-            o += data
-            match = self.match_patterns(filter(o), patterns)
+            match = self.match_patterns(filter(data), patterns)
             if match is not None:
-                return match, o
+                done = True
+            # Check if child has died
+            if not self.is_alive():
+                logging.debug("Process terminated with status %s" %
+                              self.get_status())
+                done = True
+            # Are we done?
+            if done: break
 
-        # Check if the child has terminated
-        if kvm_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)
+        # Print some debugging info
+        if match is None and (self.is_alive() or self.get_status() != 0):
+            logging.debug("Timeout elapsed or process terminated. Output:" +
+                          kvm_utils.format_str_for_message(data.strip()))
+
+        return (match, data)
 
 
-    def read_until_last_word_matches(self, patterns, timeout=60,
+    def read_until_last_word_matches(self, patterns, timeout=30.0,
                                      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
+        @return: A tuple containing the match index (or None if no match was
+                found) and the data read so far.
         """
         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,
+    def read_until_last_line_matches(self, patterns, timeout=30.0,
                                      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):
+class kvm_shell_session(kvm_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
+    It provides all services of kvm_expect and kvm_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.
@@ skipping 16 matching lines @@
         @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).
+                get_command_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)
+        kvm_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)
+        return kvm_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
 
@@ skipping 28 matching lines @@
         # 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,
+    def read_up_to_prompt(self, timeout=30.0, 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
+        @return: A tuple containing True/False indicating whether the prompt
+                was found, and the data read so far.
         """
-        m, o = self.read_until_last_line_matches([self.prompt], timeout,
-                                                 internal_timeout, print_func)
-        return o
+        (match, output) = self.read_until_last_line_matches([self.prompt],
+                                                            timeout,
+                                                            internal_timeout,
+                                                            print_func)
+        return (match is not None, output)
 
 
-    def cmd_output(self, cmd, timeout=60, internal_timeout=None,
-                   print_func=None):
+    def get_command_status_output(self, command, timeout=30.0,
+                                  internal_timeout=None, print_func=None):
         """
-        Send a command and return its output.
+        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 command: Command to send (must not contain newline characters)
+        @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 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
+        @return: A tuple (status, output) where status is the exit status or
+                None if no exit status is available (e.g. timeout elapsed), and
+                output is the output of command.
         """
         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)
+        # Print some debugging info
+        logging.debug("Sending command: %s" % command)
+
+        # Read everything that's waiting to be read
         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))
+        # Send the command and get its output
+        self.sendline(command)
+        (match, output) = self.read_up_to_prompt(timeout, internal_timeout,
+                                                 print_func)
+        # Remove the echoed command from the output
+        output = remove_command_echo(output, command)
+        # If the prompt was not found, return the output so far
+        if not match:
+            return (None, output)
+        # Remove the final shell prompt from the output
+        output = remove_last_nonempty_line(output)
+
+        # Send the 'echo ...' command to get the last exit status
+        self.sendline(self.status_test_command)
+        (match, status) = self.read_up_to_prompt(10.0, internal_timeout)
+        if not match:
+            return (None, output)
+        status = remove_command_echo(status, self.status_test_command)
+        status = remove_last_nonempty_line(status)
+        # Get the first line consisting of digits only
+        digit_lines = [l for l in status.splitlines() if l.strip().isdigit()]
+        if not digit_lines:
+            return (None, output)
+        status = int(digit_lines[0].strip())
+
+        # Print some debugging info
+        if status != 0:
+            logging.debug("Command failed; status: %d, output:%s", status,
+                          kvm_utils.format_str_for_message(output.strip()))
+
+        return (status, output)
 
 
-    def cmd_status_output(self, cmd, timeout=60, internal_timeout=None,
-                          print_func=None):
+    def get_command_status(self, command, timeout=30.0, internal_timeout=None,
+                           print_func=None):
         """
-        Send a command and return its exit status and output.
+        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 command: Command to send
+        @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 (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
+        @return: Exit status or None if no exit status is available (e.g.
+                timeout elapsed).
         """
-        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)
+        (status, output) = self.get_command_status_output(command, timeout,
+                                                          internal_timeout,
+                                                          print_func)
+        return status
 
 
-    def cmd_status(self, cmd, timeout=60, internal_timeout=None,
-                   print_func=None):
+    def get_command_output(self, command, timeout=30.0, internal_timeout=None,
+                           print_func=None):
         """
-        Send a command and return its exit status.
+        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 command: Command to send
+        @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 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)
+        (status, output) = self.get_command_status_output(command, timeout,
+                                                          internal_timeout,
+                                                          print_func)
+        return output