Merge autotest upstream from @5318 ~ @5336

client/virt/virt_test_utils.py

 """
 High-level KVM test utility functions.
 
 This module is meant to reduce code size by performing common test procedures.
 Generally, code here should look like test code.
 More specifically:
     - Functions in this module should raise exceptions if things go wrong
       (unlike functions in kvm_utils.py and kvm_vm.py which report failure via
       their returned values).
     - Functions in this module may use logging.info(), in addition to
       logging.debug() and logging.error(), to log messages the user may be
       interested in (unlike kvm_utils.py and kvm_vm.py which use
       logging.debug() for anything that isn't an error).
     - Functions in this module typically use functions and classes from
       lower-level modules (e.g. kvm_utils.py, kvm_vm.py, kvm_subprocess.py).
     - Functions in this module should not be used by lower-level modules.
     - Functions in this module should be used in the right context.
       For example, a function should not be used where it may display
       misleading or inaccurate info or debug messages.
 
 @copyright: 2008-2009 Red Hat Inc.
 """
 
 import time, os, logging, re, signal
 from autotest_lib.client.common_lib import error
 from autotest_lib.client.bin import utils
-import kvm_utils, kvm_vm, kvm_subprocess, scan_results
+from autotest_lib.client.tools import scan_results
+import aexpect, virt_utils, virt_vm
 
 
 def get_living_vm(env, vm_name):
     """
     Get a VM object from the environment and make sure it's alive.
 
     @param env: Dictionary with test environment.
     @param vm_name: Name of the desired VM object.
     @return: A VM object.
     """
@@ skipping 21 matching lines @@
     session = None
     if serial:
         type = 'serial'
         logging.info("Trying to log into guest %s using serial connection,"
                      " timeout %ds", vm.name, timeout)
         time.sleep(start)
         while time.time() < end_time:
             try:
                 session = vm.serial_login()
                 break
-            except kvm_utils.LoginError, e:
+            except virt_utils.LoginError, e:
                 logging.debug(e)
             time.sleep(step)
     else:
         type = 'remote'
         logging.info("Trying to log into guest %s using remote connection,"
                      " timeout %ds", vm.name, timeout)
         time.sleep(start)
         while time.time() < end_time:
             try:
                 session = vm.login(nic_index=nic_index)
                 break
-            except (kvm_utils.LoginError, kvm_vm.VMError), e:
+            except (virt_utils.LoginError, virt_vm.VMError), e:
                 logging.debug(e)
             time.sleep(step)
     if not session:
         raise error.TestFail("Could not log into guest %s using %s connection" %
                              (vm.name, type))
     logging.info("Logged into guest %s using %s connection", vm.name, type)
     return session
 
 
 def reboot(vm, session, method="shell", sleep_before_reset=10, nic_index=0,
@@ skipping 31 matching lines @@
         for m in monitors:
             if not m.get_event("RESET"):
                 raise error.TestFail("RESET QMP event not received after "
                                      "system_reset (monitor '%s')" % m.name)
             else:
                 logging.info("RESET QMP event received")
     else:
         logging.error("Unknown reboot method: %s", method)
 
     # Wait for the session to become unresponsive and close it
-    if not kvm_utils.wait_for(lambda: not session.is_responsive(timeout=30),
+    if not virt_utils.wait_for(lambda: not session.is_responsive(timeout=30),
                               120, 0, 1):
         raise error.TestFail("Guest refuses to go down")
     session.close()
 
     # Try logging into the guest until timeout expires
     logging.info("Guest is down. Waiting for it to go up again, timeout %ds",
                  timeout)
     session = vm.wait_for_login(nic_index, timeout=timeout)
     logging.info("Guest is up again")
     return session
@@ skipping 40 matching lines @@
     def mig_cancelled():
         o = vm.monitor.info("migrate")
         if isinstance(o, str):
             return ("Migration status: cancelled" in o or
                     "Migration status: canceled" in o)
         else:
             return (o.get("status") == "cancelled" or
                     o.get("status") == "canceled")
 
     def wait_for_migration():
-        if not kvm_utils.wait_for(mig_finished, mig_timeout, 2, 2,
+        if not virt_utils.wait_for(mig_finished, mig_timeout, 2, 2,
                                   "Waiting for migration to finish..."):
             raise error.TestFail("Timeout expired while waiting for migration "
                                  "to finish")
 
     if dest_host == 'localhost':
         dest_vm = vm.clone()
 
     if (dest_host == 'localhost') and stable_check:
         # Pause the dest vm after creation
         dest_vm.params['extra_params'] = (dest_vm.params.get('extra_params','')
@@ skipping 14 matching lines @@
             elif mig_protocol == "exec":
                 uri = '"exec:nc localhost %s"' % dest_vm.migration_port
 
             if offline:
                 vm.monitor.cmd("stop")
             vm.monitor.migrate(uri)
 
             if mig_cancel:
                 time.sleep(2)
                 vm.monitor.cmd("migrate_cancel")
-                if not kvm_utils.wait_for(mig_cancelled, 60, 2, 2,
+                if not virt_utils.wait_for(mig_cancelled, 60, 2, 2,
                                           "Waiting for migration "
                                           "cancellation"):
                     raise error.TestFail("Failed to cancel migration")
                 if offline:
                     vm.monitor.cmd("cont")
                 if dest_host == 'localhost':
                     dest_vm.destroy(gracefully=False)
                 return vm
             else:
                 wait_for_migration()
@@ skipping 309 matching lines @@
 
     vm.copy_files_to(control_path, os.path.join(autotest_path, 'control'))
 
     # Run the test
     logging.info("Running autotest control file %s on guest, timeout %ss",
                  os.path.basename(control_path), timeout)
     session.cmd("cd %s" % autotest_path)
     try:
         session.cmd("rm -f control.state")
         session.cmd("rm -rf results/*")
-    except kvm_subprocess.ShellError:
+    except aexpect.ShellError:
         pass
     try:
         bg = None
         try:
             logging.info("---------------- Test output ----------------")
             if migrate_background:
                 mig_timeout = float(params.get("mig_timeout", "3600"))
                 mig_protocol = params.get("migration_protocol", "tcp")
 
-                bg = kvm_utils.Thread(session.cmd_output,
+                bg = virt_utils.Thread(session.cmd_output,
                                       kwargs={'cmd': "bin/autotest control",
                                               'timeout': timeout,
                                               'print_func': logging.info})
 
                 bg.start()
 
                 while bg.is_alive():
                     logging.info("Tests is not ended, start a round of"
                                  "migration ...")
                     vm.migrate(timeout=mig_timeout, protocol=mig_protocol)
             else:
                 session.cmd_output("bin/autotest control", timeout=timeout,
                                    print_func=logging.info)
         finally:
             logging.info("------------- End of test output ------------")
             if migrate_background and bg:
                 bg.join()
-    except kvm_subprocess.ShellTimeoutError:
+    except aexpect.ShellTimeoutError:
         if vm.is_alive():
             get_results()
             get_results_summary()
             raise error.TestError("Timeout elapsed while waiting for job to "
                                   "complete")
         else:
             raise error.TestError("Autotest job on guest failed "
                                   "(VM terminated during job)")
-    except kvm_subprocess.ShellProcessTerminatedError:
+    except aexpect.ShellProcessTerminatedError:
         get_results()
         raise error.TestError("Autotest job on guest failed "
                               "(Remote session terminated during job)")
 
     results = get_results_summary()
     get_results()
 
     # Make a list of FAIL/ERROR/ABORT results (make sure FAIL results appear
     # before ERROR results, and ERROR results appear before ABORT results)
     bad_results = [r[0] for r in results if r[1] == "FAIL"]
@@ skipping 29 matching lines @@
 
 def raw_ping(command, timeout, session, output_func):
     """
     Low-level ping command execution.
 
     @param command: Ping command.
     @param timeout: Timeout of the ping command.
     @param session: Local executon hint or session to execute the ping command.
     """
     if session is None:
-        process = kvm_subprocess.run_bg(command, output_func=output_func,
+        process = aexpect.run_bg(command, output_func=output_func,
                                         timeout=timeout)
 
         # Send SIGINT signal to notify the timeout of running ping process,
         # Because ping have the ability to catch the SIGINT signal so we can
         # always get the packet loss ratio even if timeout.
         if process.is_alive():
-            kvm_utils.kill_process_tree(process.get_pid(), signal.SIGINT)
+            virt_utils.kill_process_tree(process.get_pid(), signal.SIGINT)
 
         status = process.get_status()
         output = process.get_output()
 
         process.close()
         return status, output
     else:
         output = ""
         try:
             output = session.cmd_output(command, timeout=timeout,
                                         print_func=output_func)
-        except kvm_subprocess.ShellTimeoutError:
+        except aexpect.ShellTimeoutError:
             # Send ctrl+c (SIGINT) through ssh session
             session.send("\003")
             try:
                 output2 = session.read_up_to_prompt(print_func=output_func)
                 output += output2
-            except kvm_subprocess.ExpectTimeoutError, e:
+            except aexpect.ExpectTimeoutError, e:
                 output += e.output
                 # We also need to use this session to query the return value
                 session.send("\003")
 
         session.sendline(session.status_test_command)
         try:
             o2 = session.read_up_to_prompt()
-        except kvm_subprocess.ExpectError:
+        except aexpect.ExpectError:
             status = -1
         else:
             try:
                 status = int(re.findall("\d+", o2)[0])
             except:
                 status = -1
 
         return status, output
 
 
@@ skipping 54 matching lines @@
     """
 
     output = session.cmd_output("ifconfig -a")
 
     try:
         ethname = re.findall("(\w+)\s+Link.*%s" % mac_address, output,
                              re.IGNORECASE)[0]
         return ethname
     except:
         return None