Merge autotest upstream from @5318 ~ @5336

client/virt/aexpect.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 168 matching lines @@
         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 common, kvm_utils
+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:
@@ skipping 178 matching lines @@
         @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 kvm_utils.generate_random_string(8)
+        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,
@@ skipping 171 matching lines @@
 
 
     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():
-            kvm_utils.kill_process_tree(self.get_pid(), sig)
+            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:
@@ skipping 393 matching lines @@
             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 kvm_utils.wait_for(lambda: not self.is_alive(), 5, 0, 0.1):
+        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
@@ skipping 337 matching lines @@
         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)