Merge autotest upstream from @5318 ~ @5336

client/virt/tests/whql_submission.py

 import logging, os, re
 from autotest_lib.client.common_lib import error
-import kvm_subprocess, kvm_utils, rss_file_transfer
+from autotest_lib.client.virt import virt_utils, rss_client, aexpect
 
 
 def run_whql_submission(test, params, env):
     """
     WHQL submission test:
     1) Log into the client machines and into a DTM server machine
     2) Copy the automation program binary (dsso_test_binary) to the server machine
     3) Run the automation program
     4) Pass the program all relevant parameters (e.g. device_data)
     5) Wait for the program to terminate
@@ skipping 21 matching lines @@
             s.close()
 
     # Collect parameters
     server_address = params.get("server_address")
     server_shell_port = int(params.get("server_shell_port"))
     server_file_transfer_port = int(params.get("server_file_transfer_port"))
     server_studio_path = params.get("server_studio_path", "%programfiles%\\ "
                                     "Microsoft Driver Test Manager\\Studio")
     dsso_test_binary = params.get("dsso_test_binary",
                                   "deps/whql_submission_15.exe")
-    dsso_test_binary = kvm_utils.get_path(test.bindir, dsso_test_binary)
+    dsso_test_binary = virt_utils.get_path(test.bindir, dsso_test_binary)
     dsso_delete_machine_binary = params.get("dsso_delete_machine_binary",
                                             "deps/whql_delete_machine_15.exe")
-    dsso_delete_machine_binary = kvm_utils.get_path(test.bindir,
+    dsso_delete_machine_binary = virt_utils.get_path(test.bindir,
                                                     dsso_delete_machine_binary)
     test_timeout = float(params.get("test_timeout", 600))
 
     # Copy dsso binaries to the server
     for filename in dsso_test_binary, dsso_delete_machine_binary:
-        rss_file_transfer.upload(server_address, server_file_transfer_port,
+        rss_client.upload(server_address, server_file_transfer_port,
                                  filename, server_studio_path, timeout=60)
 
     # Open a shell session with the server
-    server_session = kvm_utils.remote_login("nc", server_address,
+    server_session = virt_utils.remote_login("nc", server_address,
                                             server_shell_port, "", "",
                                             sessions[0].prompt,
                                             sessions[0].linesep)
     server_session.set_status_test_command(sessions[0].status_test_command)
 
     # Get the computer names of the server and clients
     cmd = "echo %computername%"
     server_name = server_session.cmd_output(cmd).strip()
     client_names = [session.cmd_output(cmd).strip() for session in sessions]
 
     # Delete all client machines from the server's data store
     server_session.cmd("cd %s" % server_studio_path)
     for client_name in client_names:
         cmd = "%s %s %s" % (os.path.basename(dsso_delete_machine_binary),
                             server_name, client_name)
         server_session.cmd(cmd, print_func=logging.debug)
 
     # Reboot the client machines
-    sessions = kvm_utils.parallel((vm.reboot, (session,))
+    sessions = virt_utils.parallel((vm.reboot, (session,))
                                   for vm, session in zip(vms, sessions))
 
     # Check the NICs again
     for vm in vms:
         nics = vm.params.objects("nics")
         for nic_index in range(len(nics)):
             s = vm.wait_for_login(nic_index, 600)
             s.close()
 
     # Run whql_pre_command and close the sessions
@@ skipping 76 matching lines @@
                 find_prompt(r"Parameter name\b.*:")
         server_session.sendline()
 
     # Wait for the automation program to terminate
     try:
         o = server_session.read_up_to_prompt(print_func=logging.info,
                                              timeout=test_timeout + 300)
         # (test_timeout + 300 is used here because the automation program is
         # supposed to terminate cleanly on its own when test_timeout expires)
         done = True
-    except kvm_subprocess.ExpectError, e:
+    except aexpect.ExpectError, e:
         o = e.output
         done = False
     server_session.close()
 
     # Look for test results in the automation program's output
     result_summaries = re.findall(r"---- \[.*?\] ----", o, re.DOTALL)
     if not result_summaries:
         raise error.TestError("The automation program did not return any "
                               "results")
     results = result_summaries[-1].strip("-")
     results = eval("".join(results.splitlines()))
 
     # Download logs and HTML reports from the server
     for i, r in enumerate(results):
         if "report" in r:
             try:
-                rss_file_transfer.download(server_address,
+                rss_client.download(server_address,
                                            server_file_transfer_port,
                                            r["report"], test.debugdir)
-            except rss_file_transfer.FileTransferNotFoundError:
+            except rss_client.FileTransferNotFoundError:
                 pass
         if "logs" in r:
             try:
-                rss_file_transfer.download(server_address,
+                rss_client.download(server_address,
                                            server_file_transfer_port,
                                            r["logs"], test.debugdir)
-            except rss_file_transfer.FileTransferNotFoundError:
+            except rss_client.FileTransferNotFoundError:
                 pass
             else:
                 try:
                     # Create symlinks to test log dirs to make it easier
                     # to access them (their original names are not human
                     # readable)
                     link_name = "logs_%s" % r["report"].split("\\")[-1]
                     link_name = link_name.replace(" ", "_")
                     link_name = link_name.replace("/", "_")
                     os.symlink(r["logs"].split("\\")[-1],
@@ skipping 35 matching lines @@
         for r in results:
             print_summary_line(f, fmt % (r["id"], r["job"], r["status"],
                                          r["pass"], r["fail"], r["notrun"],
                                          r["notapplicable"]))
         f.close()
         logging.info("(see logs and HTML reports in %s)", test.debugdir)
 
     # Kill the client VMs and fail if the automation program did not terminate
     # on time
     if not done:
-        kvm_utils.parallel(vm.destroy for vm in vms)
+        virt_utils.parallel(vm.destroy for vm in vms)
         raise error.TestFail("The automation program did not terminate "
                              "on time")
 
     # Fail if there are failed or incomplete jobs (kill the client VMs if there
     # are incomplete jobs)
     failed_jobs = [r["job"] for r in results
                    if r["status"].lower() == "investigate"]
     running_jobs = [r["job"] for r in results
                     if r["status"].lower() == "inprogress"]
     errors = []
     if failed_jobs:
         errors += ["Jobs failed: %s." % failed_jobs]
     if running_jobs:
         for vm in vms:
             vm.destroy()
         errors += ["Jobs did not complete on time: %s." % running_jobs]
     if errors:
         raise error.TestFail(" ".join(errors))