Merge autotest upstream from @5318 ~ @5336

client/virt/tests/ethtool.py

 import logging, re
 from autotest_lib.client.common_lib import error
 from autotest_lib.client.bin import utils
-import kvm_test_utils, kvm_utils, kvm_subprocess
+from autotest_lib.client.virt import virt_test_utils, virt_utils, aexpect
 
 
 def run_ethtool(test, params, env):
     """
     Test offload functions of ethernet device by ethtool
 
     1) Log into a guest.
     2) Initialize the callback of sub functions.
     3) Enable/disable sub function of NIC.
     4) Execute callback function.
@@ skipping 85 matching lines @@
         dd_cmd = ("dd if=/dev/urandom of=%s bs=1M count=%s" %
                   (filename, params.get("filesize")))
         failure = (False, "Failed to create file using dd, cmd: %s" % dd_cmd)
         logging.info("Creating file in source host, cmd: %s", dd_cmd)
         tcpdump_cmd = "tcpdump -lep -s 0 tcp -vv port ssh"
         if src == "guest":
             tcpdump_cmd += " and src %s" % guest_ip
             copy_files_from = vm.copy_files_from
             try:
                 session.cmd_output(dd_cmd, timeout=360)
-            except kvm_subprocess.ShellCmdError, e:
+            except aexpect.ShellCmdError, e:
                 return failure
         else:
             tcpdump_cmd += " and dst %s" % guest_ip
             copy_files_from = vm.copy_files_to
             try:
                 utils.system(dd_cmd)
             except error.CmdError, e:
                 return failure
 
         # only capture the new tcp port after offload setup
         original_tcp_ports = re.findall("tcp.*:(\d+).*%s" % guest_ip,
                                       utils.system_output("/bin/netstat -nap"))
         for i in original_tcp_ports:
             tcpdump_cmd += " and not port %s" % i
         logging.debug("Listen using command: %s", tcpdump_cmd)
         session2.sendline(tcpdump_cmd)
-        if not kvm_utils.wait_for(
+        if not virt_utils.wait_for(
                            lambda:session.cmd_status("pgrep tcpdump") == 0, 30):
             return (False, "Tcpdump process wasn't launched")
 
         logging.info("Start to transfer file")
         try:
             copy_files_from(filename, filename)
-        except kvm_utils.SCPError, e:
+        except virt_utils.SCPError, e:
             return (False, "File transfer failed (%s)" % e)
         logging.info("Transfer file completed")
         session.cmd("killall tcpdump")
         try:
             tcpdump_string = session2.read_up_to_prompt(timeout=60)
-        except kvm_subprocess.ExpectError:
+        except aexpect.ExpectError:
             return (False, "Fail to read tcpdump's output")
 
         if not compare_md5sum(filename):
             return (False, "Files' md5sum mismatched")
         return (True, tcpdump_string)
 
 
     def tx_callback(status="on"):
         s, o = transfer_file(src="guest")
         if not s:
@@ skipping 32 matching lines @@
     vm = env.get_vm(params["main_vm"])
     vm.verify_alive()
     session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
     # Let's just error the test if we identify that there's no ethtool installed
     session.cmd("ethtool -h")
     session2 = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
     mtu = 1514
     feature_status = {}
     filename = "/tmp/ethtool.dd"
     guest_ip = vm.get_address()
-    ethname = kvm_test_utils.get_linux_ifname(session, vm.get_mac_address(0))
+    ethname = virt_test_utils.get_linux_ifname(session, vm.get_mac_address(0))
     supported_features = params.get("supported_features")
     if supported_features:
         supported_features = supported_features.split()
     else:
         supported_features = []
     test_matrix = {
         # type:(callback,    (dependence), (exclude)
         "tx":  (tx_callback, (), ()),
         "rx":  (rx_callback, (), ()),
         "sg":  (tx_callback, ("tx",), ()),
@@ skipping 22 matching lines @@
                 logging.error("Fail to disable %s", f_type)
                 success = False
             if not callback(status="off"):
                 raise error.TestFail("Test failed, %s: off", f_type)
         if not success:
             raise error.TestError("Enable/disable offload function fail")
     finally:
         ethtool_restore_params()
         session.close()
         session2.close()