Merge autotest upstream from @5318 ~ @5336

client/virt/virt_utils.py

 """
 KVM test utility functions.
 
 @copyright: 2008-2009 Red Hat Inc.
 """
 
 import time, string, random, socket, os, signal, re, logging, commands, cPickle
-import fcntl, shelve, ConfigParser, rss_file_transfer, threading, sys, UserDict
-import inspect
+import fcntl, shelve, ConfigParser, threading, sys, UserDict, inspect
 from autotest_lib.client.bin import utils, os_dep
 from autotest_lib.client.common_lib import error, logging_config
-import kvm_subprocess
+import rss_client, aexpect
 try:
     import koji
     KOJI_INSTALLED = True
 except ImportError:
     KOJI_INSTALLED = False
 
 
 def _lock_file(filename):
     f = open(filename, "w")
     fcntl.lockf(f, fcntl.LOCK_EX)
@@ skipping 566 matching lines @@
                 raise LoginError("Client said 'connection closed'", text)
             elif match == 4:  # "Connection refused"
                 raise LoginError("Client said 'connection refused'", text)
             elif match == 5:  # "Please wait"
                 logging.debug("Got 'Please wait'")
                 timeout = 30
                 continue
             elif match == 6:  # prompt
                 logging.debug("Got shell prompt -- logged in")
                 break
-        except kvm_subprocess.ExpectTimeoutError, e:
+        except aexpect.ExpectTimeoutError, e:
             raise LoginTimeoutError(e.output)
-        except kvm_subprocess.ExpectProcessTerminatedError, e:
+        except aexpect.ExpectProcessTerminatedError, e:
             raise LoginProcessTerminatedError(e.status, e.output)
 
 
 def remote_login(client, host, port, username, password, prompt, linesep="\n",
                  log_filename=None, timeout=10):
     """
     Log into a remote host (guest) using SSH/Telnet/Netcat.
 
     @param client: The client to use ('ssh', 'telnet' or 'nc')
     @param host: Hostname or IP address
@@ skipping 16 matching lines @@
                "-o PreferredAuthentications=password -p %s %s@%s" %
                (port, username, host))
     elif client == "telnet":
         cmd = "telnet -l %s %s %s" % (username, host, port)
     elif client == "nc":
         cmd = "nc %s %s" % (host, port)
     else:
         raise LoginBadClientError(client)
 
     logging.debug("Trying to login with command '%s'", cmd)
-    session = kvm_subprocess.ShellSession(cmd, linesep=linesep, prompt=prompt)
+    session = aexpect.ShellSession(cmd, linesep=linesep, prompt=prompt)
     try:
         _remote_login(session, username, password, prompt, timeout)
     except:
         session.close()
         raise
     if log_filename:
         session.set_output_func(log_line)
         session.set_output_params((log_filename,))
     return session
 
@@ skipping 80 matching lines @@
                     session.sendline(password_list[password_prompt_count])
                     password_prompt_count += 1
                     timeout = transfer_timeout
                     authentication_done = True
                     continue
                 else:
                     raise SCPAuthenticationError("Got password prompt twice",
                                                  text)
             elif match == 2:  # "lost connection"
                 raise SCPError("SCP client said 'lost connection'", text)
-        except kvm_subprocess.ExpectTimeoutError, e:
+        except aexpect.ExpectTimeoutError, e:
             if authentication_done:
                 raise SCPTransferTimeoutError(e.output)
             else:
                 raise SCPAuthenticationTimeoutError(e.output)
-        except kvm_subprocess.ExpectProcessTerminatedError, e:
+        except aexpect.ExpectProcessTerminatedError, e:
             if e.status == 0:
                 logging.debug("SCP process terminated with status 0")
                 break
             else:
                 raise SCPTransferFailedError(e.status, e.output)
 
 
 def remote_scp(command, password_list, log_filename=None, transfer_timeout=600,
                login_timeout=10):
     """
@@ skipping 13 matching lines @@
     @raise: Whatever _remote_scp() raises
     """
     logging.debug("Trying to SCP with command '%s', timeout %ss",
                   command, transfer_timeout)
     if log_filename:
         output_func = log_line
         output_params = (log_filename,)
     else:
         output_func = None
         output_params = ()
-    session = kvm_subprocess.Expect(command,
+    session = aexpect.Expect(command,
                                     output_func=output_func,
                                     output_params=output_params)
     try:
         _remote_scp(session, password_list, transfer_timeout, login_timeout)
     finally:
         session.close()
 
 
 def scp_to_remote(host, port, username, password, local_path, remote_path,
                   log_filename=None, timeout=600):
@@ skipping 84 matching lines @@
             complete.
     @raise: Whatever remote_scp() raises
     """
     if client == "scp":
         scp_to_remote(address, port, username, password, local_path,
                       remote_path, log_filename, timeout)
     elif client == "rss":
         log_func = None
         if verbose:
             log_func = logging.debug
-        c = rss_file_transfer.FileUploadClient(address, port, log_func)
+        c = rss_client.FileUploadClient(address, port, log_func)
         c.upload(local_path, remote_path, timeout)
         c.close()
 
 
 def copy_files_from(address, client, username, password, port, remote_path,
                     local_path, log_filename=None, verbose=False, timeout=600):
     """
     Copy files from a remote host (guest) using the selected client.
 
     @param client: Type of transfer client
     @param username: Username (if required)
     @param password: Password (if requried)
     @param remote_path: Path on the remote machine where we are copying from
     @param local_path: Path on the local machine where we are copying to
     @param address: Address of remote host(guest)
     @param log_filename: If specified, log all output to this file (SCP only)
     @param verbose: If True, log some stats using logging.debug (RSS only)
     @param timeout: The time duration (in seconds) to wait for the transfer to
     complete.
     @raise: Whatever remote_scp() raises
     """
     if client == "scp":
         scp_from_remote(address, port, username, password, remote_path,
                         local_path, log_filename, timeout)
     elif client == "rss":
         log_func = None
         if verbose:
             log_func = logging.debug
-        c = rss_file_transfer.FileDownloadClient(address, port, log_func)
+        c = rss_client.FileDownloadClient(address, port, log_func)
         c.download(remote_path, local_path, timeout)
         c.close()
 
 
 # The following are utility functions related to ports.
 
 def is_port_free(port, address):
     """
     Return True if the given port is available for use.
 
@@ skipping 393 matching lines @@
     for target in targets:
         if isinstance(target, tuple) or isinstance(target, list):
             t = Thread(*target)
         else:
             t = Thread(target)
         threads.append(t)
         t.start()
     return [t.join() for t in threads]
 
 
-class KvmLoggingConfig(logging_config.LoggingConfig):
+class VirtLoggingConfig(logging_config.LoggingConfig):
     """
     Used with the sole purpose of providing convenient logging setup
     for the KVM test auxiliary programs.
     """
     def configure_logging(self, results_dir=None, verbose=False):
-        super(KvmLoggingConfig, self).configure_logging(use_console=True,
-                                                        verbose=verbose)
+        super(VirtLoggingConfig, self).configure_logging(use_console=True,
+                                                         verbose=verbose)
 
 
 class PciAssignable(object):
     """
     Request PCI assignable devices on host. It will check whether to request
     PF (physical Functions) or VF (Virtual Functions).
     """
     def __init__(self, type="vf", driver=None, driver_option=None,
                  names=None, devices_requested=None):
         """
@@ skipping 964 matching lines @@
         if patch_list:
             host_kernel.patch(patch_list)
         host_kernel.config(kernel_config)
         host_kernel.build()
         host_kernel.install()
         host_kernel.boot()
 
     else:
         logging.info('Chose %s, using the current kernel for the host',
                      install_type)