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

client/tests/kvm/kvm_preprocessing.py

 import sys, os, time, commands, re, logging, signal, glob, threading, shutil
 from autotest_lib.client.bin import test, utils
 from autotest_lib.client.common_lib import error
 import kvm_vm, kvm_utils, kvm_subprocess, kvm_monitor, ppm_utils
 try:
     import PIL.Image
 except ImportError:
     logging.warning('No python imaging library installed. PPM image '
                     'conversion to JPEG disabled. In order to enable it, '
                     'please install python-imaging or the equivalent for your '
@@ skipping 32 matching lines @@
     """
     Preprocess a single VM object according to the instructions in params.
     Start the VM if requested and get a screendump.
 
     @param test: An Autotest test object.
     @param params: A dict containing VM preprocessing parameters.
     @param env: The environment (a dict-like object).
     @param name: The name of the VM object.
     """
     logging.debug("Preprocessing VM '%s'..." % name)
-    vm = env.get_vm(name)
+    vm = kvm_utils.env_get_vm(env, name)
     if vm:
         logging.debug("VM object found in environment")
     else:
         logging.debug("VM object does not exist; creating it")
         vm = kvm_vm.VM(name, params, test.bindir, env.get("address_cache"))
-        env.register_vm(name, vm)
+        kvm_utils.env_register_vm(env, name, vm)
 
     start_vm = False
 
-    migration_mode = params.get("migration_mode", None)
-
     if params.get("restart_vm") == "yes":
         logging.debug("'restart_vm' specified; (re)starting VM...")
         start_vm = True
     elif params.get("start_vm") == "yes":
         if not vm.is_alive():
             logging.debug("VM is not alive; starting it...")
             start_vm = True
         elif vm.make_qemu_command() != vm.make_qemu_command(name, params,
                                                             test.bindir):
             logging.debug("VM's qemu command differs from requested one; "
                           "restarting it...")
             start_vm = True
-    elif migration_mode is not None:
-        logging.debug("Starting VM on migration incoming mode...")
-        start_vm = True
 
     if start_vm:
-        if migration_mode is not None:
-            if not vm.create(name, params, test.bindir,
-                             migration_mode=migration_mode):
-                raise error.TestError("Could not start VM for migration")
-        else:
-            # Start the VM (or restart it if it's already up)
-            if not vm.create(name, params, test.bindir):
-                raise error.TestError("Could not start VM")
+        # Start the VM (or restart it if it's already up)
+        if not vm.create(name, params, test.bindir):
+            raise error.TestError("Could not start VM")
     else:
         # Don't start the VM, just update its params
         vm.params = params
 
     scrdump_filename = os.path.join(test.debugdir, "pre_%s.ppm" % name)
     try:
         if vm.monitor:
             vm.monitor.screendump(scrdump_filename)
     except kvm_monitor.MonitorError, e:
         logging.warn(e)
@@ skipping 15 matching lines @@
     """
     Postprocess a single VM object according to the instructions in params.
     Kill the VM if requested and get a screendump.
 
     @param test: An Autotest test object.
     @param params: A dict containing VM postprocessing parameters.
     @param env: The environment (a dict-like object).
     @param name: The name of the VM object.
     """
     logging.debug("Postprocessing VM '%s'..." % name)
-    vm = env.get_vm(name)
+    vm = kvm_utils.env_get_vm(env, name)
     if vm:
         logging.debug("VM object found in environment")
     else:
         logging.debug("VM object does not exist in environment")
         return
 
     scrdump_filename = os.path.join(test.debugdir, "post_%s.ppm" % name)
     try:
         if vm.monitor:
             vm.monitor.screendump(scrdump_filename)
@@ skipping 40 matching lines @@
     Pre- or post-process VMs and images according to the instructions in params.
     Call image_func for each image listed in params and vm_func for each VM.
 
     @param test: An Autotest test object.
     @param params: A dict containing all VM and image parameters.
     @param env: The environment (a dict-like object).
     @param image_func: A function to call for each image.
     @param vm_func: A function to call for each VM.
     """
     # Get list of VMs specified for this test
-    for vm_name in params.objects("vms"):
-        vm_params = params.object_params(vm_name)
+    vm_names = kvm_utils.get_sub_dict_names(params, "vms")
+    for vm_name in vm_names:
+        vm_params = kvm_utils.get_sub_dict(params, vm_name)
         # Get list of images specified for this VM
-        for image_name in vm_params.objects("images"):
-            image_params = vm_params.object_params(image_name)
+        image_names = kvm_utils.get_sub_dict_names(vm_params, "images")
+        for image_name in image_names:
+            image_params = kvm_utils.get_sub_dict(vm_params, image_name)
             # Call image_func for each image
             image_func(test, image_params)
         # Call vm_func for each vm
         vm_func(test, vm_params, env, vm_name)
 
 
 def preprocess(test, params, env):
     """
     Preprocess all VMs and images according to the instructions in params.
     Also, collect some host information, such as the KVM version.
 
     @param test: An Autotest test object.
     @param params: A dict containing all VM and image parameters.
     @param env: The environment (a dict-like object).
     """
     # Start tcpdump if it isn't already running
     if "address_cache" not in env:
         env["address_cache"] = {}
     if "tcpdump" in env and not env["tcpdump"].is_alive():
         env["tcpdump"].close()
         del env["tcpdump"]
     if "tcpdump" not in env and params.get("run_tcpdump", "yes") == "yes":
         cmd = "%s -npvi any 'dst port 68'" % kvm_utils.find_command("tcpdump")
         logging.debug("Starting tcpdump (%s)...", cmd)
-        env["tcpdump"] = kvm_subprocess.Tail(
+        env["tcpdump"] = kvm_subprocess.kvm_tail(
             command=cmd,
             output_func=_update_address_cache,
             output_params=(env["address_cache"],))
         if kvm_utils.wait_for(lambda: not env["tcpdump"].is_alive(),
                               0.1, 0.1, 1.0):
             logging.warn("Could not start tcpdump")
             logging.warn("Status: %s" % env["tcpdump"].get_status())
             logging.warn("Output:" + kvm_utils.format_str_for_message(
                 env["tcpdump"].get_output()))
 
     # Destroy and remove VMs that are no longer needed in the environment
-    requested_vms = params.objects("vms")
+    requested_vms = kvm_utils.get_sub_dict_names(params, "vms")
     for key in env.keys():
         vm = env[key]
         if not kvm_utils.is_vm(vm):
             continue
         if not vm.name in requested_vms:
             logging.debug("VM '%s' found in environment but not required for "
                           "test; removing it..." % vm.name)
             vm.destroy()
             del env[key]
 
@@ skipping 93 matching lines @@
         logging.debug("'keep_screendumps' not specified; removing screendump "
                       "dirs...")
         for d in glob.glob(os.path.join(test.debugdir, "screendumps_*")):
             if os.path.isdir(d) and not os.path.islink(d):
                 shutil.rmtree(d, ignore_errors=True)
 
     # Kill all unresponsive VMs
     if params.get("kill_unresponsive_vms") == "yes":
         logging.debug("'kill_unresponsive_vms' specified; killing all VMs "
                       "that fail to respond to a remote login request...")
-        for vm in env.get_all_vms():
+        for vm in kvm_utils.env_get_all_vms(env):
             if vm.is_alive():
                 session = vm.remote_login()
                 if session:
                     session.close()
                 else:
                     vm.destroy(gracefully=False)
 
     # Kill all kvm_subprocess tail threads
     kvm_subprocess.kill_tail_threads()
 
     # Terminate tcpdump if no VMs are alive
-    living_vms = [vm for vm in env.get_all_vms() if vm.is_alive()]
+    living_vms = [vm for vm in kvm_utils.env_get_all_vms(env) if vm.is_alive()]
     if not living_vms and "tcpdump" in env:
         env["tcpdump"].close()
         del env["tcpdump"]
 
     # Execute any post_commands
     if params.get("post_command"):
         process_command(test, params, env, params.get("post_command"),
                         int(params.get("post_command_timeout", "600")),
                         params.get("post_command_noncritical") == "yes")
 
 
 def postprocess_on_error(test, params, env):
     """
     Perform postprocessing operations required only if the test failed.
 
     @param test: An Autotest test object.
     @param params: A dict containing all VM and image parameters.
     @param env: The environment (a dict-like object).
     """
-    params.update(params.object_params("on_error"))
+    params.update(kvm_utils.get_sub_dict(params, "on_error"))
 
 
 def _update_address_cache(address_cache, line):
     if re.search("Your.IP", line, re.IGNORECASE):
         matches = re.findall(r"\d*\.\d*\.\d*\.\d*", line)
         if matches:
             address_cache["last_seen"] = matches[0]
     if re.search("Client.Ethernet.Address", line, re.IGNORECASE):
         matches = re.findall(r"\w*:\w*:\w*:\w*:\w*:\w*", line)
         if matches and address_cache.get("last_seen"):
             mac_address = matches[0].lower()
-            if time.time() - address_cache.get("time_%s" % mac_address, 0) > 5:
-                logging.debug("(address cache) Adding cache entry: %s ---> %s",
-                              mac_address, address_cache.get("last_seen"))
+            logging.debug("(address cache) Adding cache entry: %s ---> %s",
+                          mac_address, address_cache.get("last_seen"))
             address_cache[mac_address] = address_cache.get("last_seen")
-            address_cache["time_%s" % mac_address] = time.time()
             del address_cache["last_seen"]
 
 
 def _take_screendumps(test, params, env):
     global _screendump_thread_termination_event
     temp_dir = test.debugdir
     if params.get("screendump_temp_dir"):
         temp_dir = kvm_utils.get_path(test.bindir,
                                       params.get("screendump_temp_dir"))
         try:
             os.makedirs(temp_dir)
         except OSError:
             pass
     temp_filename = os.path.join(temp_dir, "scrdump-%s.ppm" %
                                  kvm_utils.generate_random_string(6))
     delay = float(params.get("screendump_delay", 5))
     quality = int(params.get("screendump_quality", 30))
 
     cache = {}
 
     while True:
-        for vm in env.get_all_vms():
+        for vm in kvm_utils.env_get_all_vms(env):
             if not vm.is_alive():
                 continue
             try:
                 vm.monitor.screendump(temp_filename)
             except kvm_monitor.MonitorError, e:
                 logging.warn(e)
                 continue
             if not os.path.exists(temp_filename):
                 logging.warn("VM '%s' failed to produce a screendump", vm.name)
                 continue
@@ skipping 20 matching lines @@
                 try:
                     image = PIL.Image.open(temp_filename)
                     image.save(screendump_filename, format="JPEG", quality=quality)
                     cache[hash] = screendump_filename
                 except NameError:
                     pass
             os.unlink(temp_filename)
         if _screendump_thread_termination_event.isSet():
             break
         _screendump_thread_termination_event.wait(delay)