[KVM-AUTOTEST,05/17] Remove kvm_spawn and run_bg() from kvm_utils.py.

Commit Message

Michael Goldish July 20, 2009, 3:07 p.m. UTC

These are now provided by kvm_subprocess.py.

Signed-off-by: Michael Goldish <[e-mail]>
---
 client/tests/kvm/kvm_utils.py |  477 +----------------------------------------
 1 files changed, 2 insertions(+), 475 deletions(-)

Comments

Lucas Meneghel Rodrigues July 23, 2009, 4:04 a.m. UTC | #1

Applied.

On Mon, Jul 20, 2009 at 12:07 PM, Michael Goldish<[e-mail]> wrote:
> These are now provided by kvm_subprocess.py.
>
> Signed-off-by: Michael Goldish <[e-mail]>
> ---
>  client/tests/kvm/kvm_utils.py |  477 +----------------------------------------
>  1 files changed, 2 insertions(+), 475 deletions(-)
>
> diff --git a/client/tests/kvm/kvm_utils.py b/client/tests/kvm/kvm_utils.py
> index fb587c5..9391874 100644
> --- a/client/tests/kvm/kvm_utils.py
> +++ b/client/tests/kvm/kvm_utils.py
> @@ -227,390 +227,8 @@ def check_kvm_source_dir(source_dir):
>         raise error.TestError("Unknown source dir layout, cannot proceed.")
>
>
> -# The following are a class and functions used for SSH, SCP and Telnet
> -# communication with guests.
> -
> -class kvm_spawn:
> -    """
> -    This class is used for spawning and controlling a child process.
> -    """
> -
> -    def __init__(self, command, linesep="\n"):
> -        """
> -        Initialize the class and run command as a child process.
> -
> -        @param command: Command that will be run.
> -        @param linesep: Line separator for the given platform.
> -        """
> -        self.exitstatus = None
> -        self.linesep = linesep
> -        (pid, fd) = pty.fork()
> -        if pid == 0:
> -            os.execv("/bin/sh", ["/bin/sh", "-c", command])
> -        else:
> -            self.pid = pid
> -            self.fd = fd
> -
> -
> -    def set_linesep(self, linesep):
> -        """
> -        Sets the line separator string (usually "\\n").
> -
> -        @param linesep: Line separator character.
> -        """
> -        self.linesep = linesep
> -
> -
> -    def is_responsive(self, timeout=5.0):
> -        """
> -        Return True if the session is responsive.
> -
> -        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: Timeout that will happen before we consider the
> -                process unresponsive
> -        """
> -        self.read_nonblocking(timeout=0.1)
> -        self.sendline()
> -        output = self.read_nonblocking(timeout=timeout)
> -        if output.strip():
> -            return True
> -        return False
> -
> -
> -    def poll(self):
> -        """
> -        If the process exited, return its exit status. Otherwise return None.
> -        The exit status is stored for use in subsequent calls.
> -        """
> -        if self.exitstatus != None:
> -            return self.exitstatus
> -        pid, status = os.waitpid(self.pid, os.WNOHANG)
> -        if pid:
> -            self.exitstatus = os.WEXITSTATUS(status)
> -            return self.exitstatus
> -        else:
> -            return None
> -
> -
> -    def close(self):
> -        """
> -        Close the session (close the process filedescriptors and kills the
> -        process ID), and return the exit status.
> -        """
> -        try:
> -            os.close(self.fd)
> -            os.kill(self.pid, signal.SIGTERM)
> -        except OSError:
> -            pass
> -        return self.poll()
> -
> -
> -    def sendline(self, str=""):
> -        """
> -        Sends a string followed by a line separator to the child process.
> -
> -        @param str: String that will be sent to the child process.
> -        """
> -        try:
> -            os.write(self.fd, str + self.linesep)
> -        except OSError:
> -            pass
> -
> -
> -    def read_nonblocking(self, timeout=1.0):
> -        """
> -        Read from child until there is nothing to read for timeout seconds.
> -
> -        @param timeout: Time (seconds) of wait before we give up reading from
> -                the child process.
> -        """
> -        data = ""
> -        while True:
> -            r, w, x = select.select([self.fd], [], [], timeout)
> -            if self.fd in r:
> -                try:
> -                    data += os.read(self.fd, 1024)
> -                except OSError:
> -                    return 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
> -            exp = re.compile(patterns[i])
> -            if exp.search(str):
> -                return i
> -
> -
> -    def read_until_output_matches(self, patterns, filter=lambda(x):x,
> -                                  timeout=30.0, internal_timeout=1.0,
> -                                  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 (or None if no match was
> -                found) and the data read so far.
> -        """
> -        match = None
> -        data = ""
> -
> -        end_time = time.time() + timeout
> -        while time.time() < end_time:
> -            # Read data from child
> -            newdata = self.read_nonblocking(internal_timeout)
> -            # Print it if necessary
> -            if print_func and newdata:
> -                map(print_func, newdata.splitlines())
> -            data += newdata
> -
> -            done = False
> -            # Look for patterns
> -            match = self.match_patterns(filter(data), patterns)
> -            if match != None:
> -                done = True
> -            # Check if child has died
> -            if self.poll() != None:
> -                logging.debug("Process terminated with status %d", self.poll())
> -                done = True
> -            # Are we done?
> -            if done: break
> -
> -        # Print some debugging info
> -        if match == None and self.poll() != 0:
> -            logging.debug("Timeout elapsed or process terminated. Output: %s",
> -                          format_str_for_message(data.strip()))
> -
> -        return (match, data)
> -
> -
> -    def get_last_word(self, str):
> -        """
> -        Return the last word in str.
> -
> -        @param str: String that will be analyzed.
> -        """
> -        if str:
> -            return str.split()[-1]
> -        else:
> -            return ""
> -
> -
> -    def get_last_line(self, str):
> -        """
> -        Return the last non-empty line in str.
> -
> -        @param str: String that will be analyzed.
> -        """
> -        last_line = ""
> -        for line in str.splitlines():
> -            if line != "":
> -                last_line = line
> -        return last_line
> -
> -
> -    def read_until_last_word_matches(self, patterns, timeout=30.0,
> -                                     internal_timeout=1.0, 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 (or None if no match was
> -                found) and the data read so far.
> -        """
> -        return self.read_until_output_matches(patterns, self.get_last_word,
> -                                              timeout, internal_timeout,
> -                                              print_func)
> -
> -
> -    def read_until_last_line_matches(self, patterns, timeout=30.0,
> -                                     internal_timeout=1.0, 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 self.read_until_output_matches(patterns, self.get_last_line,
> -                                              timeout, internal_timeout,
> -                                              print_func)
> -
> -
> -    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 read_up_to_prompt(self, timeout=30.0, internal_timeout=1.0,
> -                          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: A tuple containing True/False indicating whether the prompt
> -                was found, and the data read so far.
> -        """
> -        (match, output) = self.read_until_last_line_matches([self.prompt],
> -                                                            timeout,
> -                                                            internal_timeout,
> -                                                            print_func)
> -        if match == None:
> -            return (False, output)
> -        else:
> -            return (True, output)
> -
> -
> -    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 get_command_status_output(self, command, timeout=30.0,
> -                                  internal_timeout=1.0, print_func=None):
> -        """
> -        Send a command and return its exit status and output.
> -
> -        @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 or
> -                None if no exit status is available (e.g. timeout elapsed), and
> -                output is the output of command.
> -        """
> -        # Print some debugging info
> -        logging.debug("Sending command: %s" % command)
> -
> -        # Read everything that's waiting to be read
> -        self.read_nonblocking(0.1)
> -
> -        # Send the command and get its output
> -        self.sendline(command)
> -        (match, output) = self.read_up_to_prompt(timeout, internal_timeout,
> -                                                 print_func)
> -        if not match:
> -            return (None, "\n".join(output.splitlines()[1:]))
> -        output = "\n".join(output.splitlines()[1:-1])
> -
> -        # 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 = int("\n".join(status.splitlines()[1:-1]).strip())
> -
> -        # Print some debugging info
> -        if status != 0:
> -            logging.debug("Command failed; status: %d, output:%s", status,
> -                          format_str_for_message(output.strip()))
> -
> -        return (status, output)
> -
> -
> -    def get_command_status(self, command, timeout=30.0, internal_timeout=1.0,
> -                           print_func=None):
> -        """
> -        Send a command and return its exit status.
> -
> -        @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: Exit status or None if no exit status is available (e.g.
> -                timeout elapsed).
> -        """
> -        (status, output) = self.get_command_status_output(command, timeout,
> -                                                          internal_timeout,
> -                                                          print_func)
> -        return status
> -
> -
> -    def get_command_output(self, command, timeout=30.0, internal_timeout=1.0,
> -                           print_func=None):
> -        """
> -        Send a command and return its output.
> -
> -        @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)
> -        """
> -        (status, output) = self.get_command_status_output(command, timeout,
> -                                                          internal_timeout,
> -                                                          print_func)
> -        return output
> -
> +# The following are functions used for SSH, SCP and Telnet communication with
> +# guests.
>
>  def remote_login(command, password, prompt, linesep="\n", timeout=10):
>     """
> @@ -810,97 +428,6 @@ def telnet(host, port, username, password, prompt, timeout=10):
>     return remote_login(command, password, prompt, "\r\n", timeout)
>
>
> -# The following are functions used for running commands in the background.
> -
> -def track_process(sub, status_output=None, term_func=None, stdout_func=None,
> -                  prefix=""):
> -    """
> -    Read lines from the stdout pipe of the subprocess. Pass each line to
> -    stdout_func prefixed by prefix. Place the lines in status_output[1].
> -    When the subprocess exits, call term_func. Place the exit status in
> -    status_output[0].
> -
> -    @brief Track a subprocess and report its output and termination.
> -
> -    @param sub: An object returned by subprocess.Popen
> -    @param status_output: A list in which the exit status and output are to be
> -            stored.
> -    @param term_func: A function to call when the process terminates
> -            (should take no parameters)
> -    @param stdout_func: A function to call with each line of output from the
> -            subprocess (should take a string parameter)
> -
> -    @param prefix -- a string to pre-pend to each line of the output, before
> -            passing it to stdout_func
> -    """
> -    while True:
> -        # Read a single line from stdout
> -        text = sub.stdout.readline()
> -        # If the subprocess exited...
> -        if text == "":
> -            # Get exit code
> -            status = sub.wait()
> -            # Report it
> -            if status_output:
> -                status_output[0] = status
> -            # Call term_func
> -            if term_func:
> -                term_func()
> -            return
> -        # Report the text
> -        if status_output:
> -            status_output[1] += text
> -        # Call stdout_func with the returned text
> -        if stdout_func:
> -            text = prefix + text.strip()
> -            # We need to sanitize the text before passing it to the logging
> -            # system
> -            text = text.decode('utf-8', 'replace')
> -            stdout_func(text)
> -
> -
> -def run_bg(command, term_func=None, stdout_func=None, prefix="", timeout=1.0):
> -    """
> -    Run command as a subprocess. Call stdout_func with each line of output from
> -    the subprocess (prefixed by prefix). Call term_func when the subprocess
> -    terminates. If timeout expires and the subprocess is still running, return.
> -
> -    @brief: Run a subprocess in the background and collect its output and
> -            exit status.
> -
> -    @param command: The shell command to execute
> -    @param term_func: A function to call when the process terminates
> -            (should take no parameters)
> -    @param stdout_func: A function to call with each line of output from
> -            the subprocess (should take a string parameter)
> -    @param 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 3-tuple containing the exit status (None if the subprocess is
> -            still running), the PID of the subprocess (None if the subprocess
> -            terminated), and the output collected so far.
> -    """
> -    # Start the process
> -    sub = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE,
> -                           stderr=subprocess.STDOUT)
> -    # Start the tracking thread
> -    status_output = [None, ""]
> -    thread.start_new_thread(track_process, (sub, status_output, term_func,
> -                                            stdout_func, prefix))
> -    # Wait up to timeout secs for the process to exit
> -    end_time = time.time() + timeout
> -    while time.time() < end_time:
> -        # If the process exited, return
> -        if status_output[0] != None:
> -            return (status_output[0], None, status_output[1])
> -        # Otherwise, sleep for a while
> -        time.sleep(0.1)
> -    # Report the PID and the output collected so far
> -    return (None, sub.pid, status_output[1])
> -
> -
>  # The following are utility functions related to ports.
>
>  def is_sshd_running(host, port, timeout=10.0):
> --
> 1.5.4.1
>
> _______________________________________________
> Autotest mailing list
> [e-mail]
> http://test.kernel.org/cgi-bin/mailman/listinfo/autotest
>

Patch

diff --git a/client/tests/kvm/kvm_utils.py b/client/tests/kvm/kvm_utils.py
index fb587c5..9391874 100644
--- a/client/tests/kvm/kvm_utils.py
+++ b/client/tests/kvm/kvm_utils.py
@@ -227,390 +227,8 @@  def check_kvm_source_dir(source_dir):
         raise error.TestError("Unknown source dir layout, cannot proceed.")
 
 
-# The following are a class and functions used for SSH, SCP and Telnet
-# communication with guests.
-
-class kvm_spawn:
-    """
-    This class is used for spawning and controlling a child process.
-    """
-
-    def __init__(self, command, linesep="\n"):
-        """
-        Initialize the class and run command as a child process.
-
-        @param command: Command that will be run.
-        @param linesep: Line separator for the given platform.
-        """
-        self.exitstatus = None
-        self.linesep = linesep
-        (pid, fd) = pty.fork()
-        if pid == 0:
-            os.execv("/bin/sh", ["/bin/sh", "-c", command])
-        else:
-            self.pid = pid
-            self.fd = fd
-
-
-    def set_linesep(self, linesep):
-        """
-        Sets the line separator string (usually "\\n").
-
-        @param linesep: Line separator character.
-        """
-        self.linesep = linesep
-
-
-    def is_responsive(self, timeout=5.0):
-        """
-        Return True if the session is responsive.
-
-        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: Timeout that will happen before we consider the
-                process unresponsive
-        """
-        self.read_nonblocking(timeout=0.1)
-        self.sendline()
-        output = self.read_nonblocking(timeout=timeout)
-        if output.strip():
-            return True
-        return False
-
-
-    def poll(self):
-        """
-        If the process exited, return its exit status. Otherwise return None.
-        The exit status is stored for use in subsequent calls.
-        """
-        if self.exitstatus != None:
-            return self.exitstatus
-        pid, status = os.waitpid(self.pid, os.WNOHANG)
-        if pid:
-            self.exitstatus = os.WEXITSTATUS(status)
-            return self.exitstatus
-        else:
-            return None
-
-
-    def close(self):
-        """
-        Close the session (close the process filedescriptors and kills the
-        process ID), and return the exit status.
-        """
-        try:
-            os.close(self.fd)
-            os.kill(self.pid, signal.SIGTERM)
-        except OSError:
-            pass
-        return self.poll()
-
-
-    def sendline(self, str=""):
-        """
-        Sends a string followed by a line separator to the child process.
-
-        @param str: String that will be sent to the child process.
-        """
-        try:
-            os.write(self.fd, str + self.linesep)
-        except OSError:
-            pass
-
-
-    def read_nonblocking(self, timeout=1.0):
-        """
-        Read from child until there is nothing to read for timeout seconds.
-
-        @param timeout: Time (seconds) of wait before we give up reading from
-                the child process.
-        """
-        data = ""
-        while True:
-            r, w, x = select.select([self.fd], [], [], timeout)
-            if self.fd in r:
-                try:
-                    data += os.read(self.fd, 1024)
-                except OSError:
-                    return 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
-            exp = re.compile(patterns[i])
-            if exp.search(str):
-                return i
-
-
-    def read_until_output_matches(self, patterns, filter=lambda(x):x,
-                                  timeout=30.0, internal_timeout=1.0,
-                                  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 (or None if no match was
-                found) and the data read so far.
-        """
-        match = None
-        data = ""
-
-        end_time = time.time() + timeout
-        while time.time() < end_time:
-            # Read data from child
-            newdata = self.read_nonblocking(internal_timeout)
-            # Print it if necessary
-            if print_func and newdata:
-                map(print_func, newdata.splitlines())
-            data += newdata
-
-            done = False
-            # Look for patterns
-            match = self.match_patterns(filter(data), patterns)
-            if match != None:
-                done = True
-            # Check if child has died
-            if self.poll() != None:
-                logging.debug("Process terminated with status %d", self.poll())
-                done = True
-            # Are we done?
-            if done: break
-
-        # Print some debugging info
-        if match == None and self.poll() != 0:
-            logging.debug("Timeout elapsed or process terminated. Output: %s",
-                          format_str_for_message(data.strip()))
-
-        return (match, data)
-
-
-    def get_last_word(self, str):
-        """
-        Return the last word in str.
-
-        @param str: String that will be analyzed.
-        """
-        if str:
-            return str.split()[-1]
-        else:
-            return ""
-
-
-    def get_last_line(self, str):
-        """
-        Return the last non-empty line in str.
-
-        @param str: String that will be analyzed.
-        """
-        last_line = ""
-        for line in str.splitlines():
-            if line != "":
-                last_line = line
-        return last_line
-
-
-    def read_until_last_word_matches(self, patterns, timeout=30.0,
-                                     internal_timeout=1.0, 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 (or None if no match was
-                found) and the data read so far.
-        """
-        return self.read_until_output_matches(patterns, self.get_last_word,
-                                              timeout, internal_timeout,
-                                              print_func)
-
-
-    def read_until_last_line_matches(self, patterns, timeout=30.0,
-                                     internal_timeout=1.0, 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 self.read_until_output_matches(patterns, self.get_last_line,
-                                              timeout, internal_timeout,
-                                              print_func)
-
-
-    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 read_up_to_prompt(self, timeout=30.0, internal_timeout=1.0,
-                          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: A tuple containing True/False indicating whether the prompt
-                was found, and the data read so far.
-        """
-        (match, output) = self.read_until_last_line_matches([self.prompt],
-                                                            timeout,
-                                                            internal_timeout,
-                                                            print_func)
-        if match == None:
-            return (False, output)
-        else:
-            return (True, output)
-
-
-    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 get_command_status_output(self, command, timeout=30.0,
-                                  internal_timeout=1.0, print_func=None):
-        """
-        Send a command and return its exit status and output.
-
-        @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 or
-                None if no exit status is available (e.g. timeout elapsed), and
-                output is the output of command.
-        """
-        # Print some debugging info
-        logging.debug("Sending command: %s" % command)
-
-        # Read everything that's waiting to be read
-        self.read_nonblocking(0.1)
-
-        # Send the command and get its output
-        self.sendline(command)
-        (match, output) = self.read_up_to_prompt(timeout, internal_timeout,
-                                                 print_func)
-        if not match:
-            return (None, "\n".join(output.splitlines()[1:]))
-        output = "\n".join(output.splitlines()[1:-1])
-
-        # 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 = int("\n".join(status.splitlines()[1:-1]).strip())
-
-        # Print some debugging info
-        if status != 0:
-            logging.debug("Command failed; status: %d, output:%s", status,
-                          format_str_for_message(output.strip()))
-
-        return (status, output)
-
-
-    def get_command_status(self, command, timeout=30.0, internal_timeout=1.0,
-                           print_func=None):
-        """
-        Send a command and return its exit status.
-
-        @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: Exit status or None if no exit status is available (e.g.
-                timeout elapsed).
-        """
-        (status, output) = self.get_command_status_output(command, timeout,
-                                                          internal_timeout,
-                                                          print_func)
-        return status
-
-
-    def get_command_output(self, command, timeout=30.0, internal_timeout=1.0,
-                           print_func=None):
-        """
-        Send a command and return its output.
-
-        @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)
-        """
-        (status, output) = self.get_command_status_output(command, timeout,
-                                                          internal_timeout,
-                                                          print_func)
-        return output
-
+# The following are functions used for SSH, SCP and Telnet communication with
+# guests.
 
 def remote_login(command, password, prompt, linesep="\n", timeout=10):
     """
@@ -810,97 +428,6 @@  def telnet(host, port, username, password, prompt, timeout=10):
     return remote_login(command, password, prompt, "\r\n", timeout)
 
 
-# The following are functions used for running commands in the background.
-
-def track_process(sub, status_output=None, term_func=None, stdout_func=None,
-                  prefix=""):
-    """
-    Read lines from the stdout pipe of the subprocess. Pass each line to
-    stdout_func prefixed by prefix. Place the lines in status_output[1].
-    When the subprocess exits, call term_func. Place the exit status in
-    status_output[0].
-
-    @brief Track a subprocess and report its output and termination.
-
-    @param sub: An object returned by subprocess.Popen
-    @param status_output: A list in which the exit status and output are to be
-            stored.
-    @param term_func: A function to call when the process terminates
-            (should take no parameters)
-    @param stdout_func: A function to call with each line of output from the
-            subprocess (should take a string parameter)
-
-    @param prefix -- a string to pre-pend to each line of the output, before
-            passing it to stdout_func
-    """
-    while True:
-        # Read a single line from stdout
-        text = sub.stdout.readline()
-        # If the subprocess exited...
-        if text == "":
-            # Get exit code
-            status = sub.wait()
-            # Report it
-            if status_output:
-                status_output[0] = status
-            # Call term_func
-            if term_func:
-                term_func()
-            return
-        # Report the text
-        if status_output:
-            status_output[1] += text
-        # Call stdout_func with the returned text
-        if stdout_func:
-            text = prefix + text.strip()
-            # We need to sanitize the text before passing it to the logging
-            # system
-            text = text.decode('utf-8', 'replace')
-            stdout_func(text)
-
-
-def run_bg(command, term_func=None, stdout_func=None, prefix="", timeout=1.0):
-    """
-    Run command as a subprocess. Call stdout_func with each line of output from
-    the subprocess (prefixed by prefix). Call term_func when the subprocess
-    terminates. If timeout expires and the subprocess is still running, return.
-
-    @brief: Run a subprocess in the background and collect its output and
-            exit status.
-
-    @param command: The shell command to execute
-    @param term_func: A function to call when the process terminates
-            (should take no parameters)
-    @param stdout_func: A function to call with each line of output from
-            the subprocess (should take a string parameter)
-    @param 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 3-tuple containing the exit status (None if the subprocess is
-            still running), the PID of the subprocess (None if the subprocess
-            terminated), and the output collected so far.
-    """
-    # Start the process
-    sub = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE,
-                           stderr=subprocess.STDOUT)
-    # Start the tracking thread
-    status_output = [None, ""]
-    thread.start_new_thread(track_process, (sub, status_output, term_func,
-                                            stdout_func, prefix))
-    # Wait up to timeout secs for the process to exit
-    end_time = time.time() + timeout
-    while time.time() < end_time:
-        # If the process exited, return
-        if status_output[0] != None:
-            return (status_output[0], None, status_output[1])
-        # Otherwise, sleep for a while
-        time.sleep(0.1)
-    # Report the PID and the output collected so far
-    return (None, sub.pid, status_output[1])
-
-
 # The following are utility functions related to ports.
 
 def is_sshd_running(host, port, timeout=10.0):