Merge remote branch 'autotest-upstream/master' into autotest-merge

client/tests/kvm/kvm_preprocessing.py

 import os, time, commands, re, logging, glob, threading, shutil
 from autotest_lib.client.bin import utils
 from autotest_lib.client.common_lib import error
 import kvm_vm, kvm_utils, kvm_subprocess, kvm_monitor, ppm_utils, test_setup
 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 67 matching lines @@
         # Start the VM (or restart it if it's already up)
         vm.create(name, params, test.bindir,
                   migration_mode=params.get("migration_mode"))
     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)
+            vm.monitor.screendump(scrdump_filename, debug=False)
     except kvm_monitor.MonitorError, e:
         logging.warn(e)
 
 
 def postprocess_image(test, params):
     """
     Postprocess a single QEMU image according to the instructions in params.
 
     @param test: An Autotest test object.
     @param params: A dict containing image postprocessing parameters.
@@ skipping 15 matching lines @@
     @param name: The name of the VM object.
     """
     logging.debug("Postprocessing VM '%s'..." % name)
     vm = env.get_vm(name)
     if not vm:
         return
 
     scrdump_filename = os.path.join(test.debugdir, "post_%s.ppm" % name)
     try:
         if vm.monitor:
-            vm.monitor.screendump(scrdump_filename)
+            vm.monitor.screendump(scrdump_filename, debug=False)
     except kvm_monitor.MonitorError, e:
         logging.warn(e)
 
     if params.get("kill_vm") == "yes":
         kill_vm_timeout = float(params.get("kill_vm_timeout", 0))
         if kill_vm_timeout:
             logging.debug("'kill_vm' specified; waiting for VM to shut down "
                           "before killing it...")
             kvm_utils.wait_for(vm.is_dead, kill_vm_timeout, 0, 1)
         else:
@@ skipping 52 matching lines @@
 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).
     """
     error.context("preprocessing")
-
     # 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(
@@ skipping 43 matching lines @@
     else:
         kvm_userspace_version = "Unknown"
         logging.debug("Could not fetch KVM userspace version")
     logging.debug("KVM userspace version: %s" % kvm_userspace_version)
     test.write_test_keyval({"kvm_userspace_version": kvm_userspace_version})
 
     if params.get("setup_hugepages") == "yes":
         h = test_setup.HugePageConfig(params)
         h.setup()
 
-    if params.get("type") == "unattended_install":
-        u = test_setup.UnattendedInstallConfig(test, params)
-        u.setup()
-
-    if params.get("type") == "enospc":
-        e = test_setup.EnospcConfig(test, params)
-        e.setup()
-
     # Execute any pre_commands
     if params.get("pre_command"):
         process_command(test, params, env, params.get("pre_command"),
                         int(params.get("pre_command_timeout", "600")),
                         params.get("pre_command_noncritical") == "yes")
 
     # Preprocess all VMs and images
     process(test, params, env, preprocess_image, preprocess_vm)
 
     # Start the screendump thread
@@ skipping 80 matching lines @@
     # Terminate tcpdump if no VMs are alive
     living_vms = [vm for vm in env.get_all_vms() if vm.is_alive()]
     if not living_vms and "tcpdump" in env:
         env["tcpdump"].close()
         del env["tcpdump"]
 
     if params.get("setup_hugepages") == "yes":
         h = test_setup.HugePageConfig(params)
         h.cleanup()
 
-    if params.get("type") == "enospc":
-        e = test_setup.EnospcConfig(test, params)
-        e.cleanup()
-
     # 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.
@@ skipping 37 matching lines @@
     delay = float(params.get("screendump_delay", 5))
     quality = int(params.get("screendump_quality", 30))
 
     cache = {}
 
     while True:
         for vm in env.get_all_vms():
             if not vm.is_alive():
                 continue
             try:
-                vm.monitor.screendump(temp_filename)
+                vm.monitor.screendump(filename=temp_filename, debug=False)
             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
             if not ppm_utils.image_verify_ppm_file(temp_filename):
                 logging.warn("VM '%s' produced an invalid screendump", vm.name)
                 os.unlink(temp_filename)
                 continue
@@ skipping 17 matching lines @@
                     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():
             _screendump_thread_termination_event = None
             break
         _screendump_thread_termination_event.wait(delay)