Revert "Merge remote branch 'cros/upstream' into autotest-rebase"

client/tests/kvm/tests/physical_resources_check.py

 import re, string, logging
 from autotest_lib.client.common_lib import error
 import kvm_test_utils, kvm_utils, kvm_monitor
 
 
 def run_physical_resources_check(test, params, env):
     """
     Check physical resources assigned to KVM virtual machines:
     1) Log into the guest
     2) Verify whether cpu counts ,memory size, nics' model,
@@ skipping 33 matching lines @@
     actual_mem = vm.get_memory_size()
     if actual_mem != expected_mem:
         n_fail += 1
         logging.error("Memory size mismatch:")
         logging.error("    Assigned to VM: %s" % expected_mem)
         logging.error("    Reported by OS: %s" % actual_mem)
 
     # Define a function for checking number of hard drivers & NICs
     def check_num(devices, info_cmd, check_str):
         f_fail = 0
-        expected_num = params.objects(devices).__len__()
+        expected_num = kvm_utils.get_sub_dict_names(params, devices).__len__()
         try:
             o = vm.monitor.info(info_cmd)
         except kvm_monitor.MonitorError, e:
             f_fail += 1
             logging.error(e)
             logging.error("info/query monitor command failed (%s)", info_cmd)
 
         actual_num = string.count(o, check_str)
         if expected_num != actual_num:
             f_fail += 1
             logging.error("%s number mismatch:")
             logging.error("    Assigned to VM: %d" % expected_num)
             logging.error("    Reported by OS: %d" % actual_num)
         return expected_num, f_fail
 
     logging.info("Hard drive count check")
     drives_num, f_fail = check_num("images", "block", "type=hd")
     n_fail += f_fail
 
     logging.info("NIC count check")
     nics_num, f_fail = check_num("nics", "network", "model=")
     n_fail += f_fail
 
     # Define a function for checking hard drives & NICs' model
     def chk_fmt_model(device, fmt_model, info_cmd, str):
         f_fail = 0
-        devices = params.objects(device)
+        devices = kvm_utils.get_sub_dict_names(params, device)
         for chk_device in devices:
-            expected = params.object_params(chk_device).get(fmt_model)
+            expected = kvm_utils.get_sub_dict(params, chk_device).get(fmt_model)
             if not expected:
                 expected = "rtl8139"
             try:
                 o = vm.monitor.info(info_cmd)
             except kvm_monitor.MonitorError, e:
                 f_fail += 1
                 logging.error(e)
                 logging.error("info/query monitor command failed (%s)",
                               info_cmd)
 
@@ skipping 22 matching lines @@
     logging.info("Network card MAC check")
     try:
         o = vm.monitor.info("network")
     except kvm_monitor.MonitorError, e:
         n_fail += 1
         logging.error(e)
         logging.error("info/query monitor command failed (network)")
     found_mac_addresses = re.findall("macaddr=(\S+)", o)
     logging.debug("Found MAC adresses: %s" % found_mac_addresses)
 
-    num_nics = len(params.objects("nics"))
+    num_nics = len(kvm_utils.get_sub_dict_names(params, "nics"))
     for nic_index in range(num_nics):
         mac = vm.get_mac_address(nic_index)
         if not string.lower(mac) in found_mac_addresses:
             n_fail += 1
             logging.error("MAC address mismatch:")
             logging.error("    Assigned to VM (not found): %s" % mac)
 
     # Define a function to verify UUID & Serial number
     def verify_device(expect, name, verify_cmd):
         f_fail = 0
         if verify_cmd:
-            actual = session.cmd_output(verify_cmd)
+            actual = session.get_command_output(verify_cmd)
             if not string.upper(expect) in actual:
                 f_fail += 1
                 logging.error("%s mismatch:")
                 logging.error("    Assigned to VM: %s" % string.upper(expect))
                 logging.error("    Reported by OS: %s" % actual)
         return f_fail
 
     logging.info("UUID check")
     if vm.get_uuid():
         f_fail = verify_device(vm.get_uuid(), "UUID",
                                params.get("catch_uuid_cmd"))
         n_fail += f_fail
 
     logging.info("Hard Disk serial number check")
     catch_serial_cmd = params.get("catch_serial_cmd")
     f_fail = verify_device(params.get("drive_serial"), "Serial",
                            catch_serial_cmd)
     n_fail += f_fail
 
     if n_fail != 0:
         raise error.TestFail("Physical resources check test reported %s "
                              "failures. Please verify the test logs." % n_fail)
 
     session.close()