Merge remote branch 'cros/upstream' into master

client/tests/kvm/tests/qemu_img.py

Index: client/tests/kvm/tests/qemu_img.py
diff --git a/client/tests/kvm/tests/qemu_img.py b/client/tests/kvm/tests/qemu_img.py
index d3f7ff10523cc46eb4a6ccbcf481fff92b8392bc..c3449f4f7a0ac2767d945668b315504c2b08a51d 100644
--- a/client/tests/kvm/tests/qemu_img.py
+++ b/client/tests/kvm/tests/qemu_img.py
@@ -1,6 +1,6 @@
 import re, os, logging, commands
 from autotest_lib.client.common_lib import utils, error
-import kvm_vm, kvm_utils
+import kvm_vm, kvm_utils, kvm_preprocessing
 
 
 def run_qemu_img(test, params, env):
@@ -162,13 +162,13 @@ def run_qemu_img(test, params, env):
             os.remove(output_filename)
 
 
-    def _info(cmd, img, string=None, fmt=None):
+    def _info(cmd, img, sub_info=None, fmt=None):
         """
         Simple wrapper of 'qemu-img info'.
 
         @param cmd: qemu-img base command.
         @param img: image file
-        @param string: sub info, say 'backing file'
+        @param sub_info: sub info, say 'backing file'
         @param fmt: image format
         """
         cmd += " info"
@@ -182,11 +182,11 @@ def run_qemu_img(test, params, env):
             logging.error("Get info of image '%s' failed: %s", img, str(e))
             return None
 
-        if not string:
+        if not sub_info:
             return output
 
-        string += ": (.*)"
-        matches = re.findall(string, output)
+        sub_info += ": (.*)"
+        matches = re.findall(sub_info, output)
         if matches:
             return matches[0]
         return None
@@ -223,7 +223,7 @@ def run_qemu_img(test, params, env):
             if s != 0:
                 raise error.TestFail("Create snapshot failed via command: %s;"
                                      "Output is: %s" % (crtcmd, o))
-            logging.info("Created snapshot '%s' in '%s'" % (sn_name,image_name))
+            logging.info("Created snapshot '%s' in '%s'", sn_name, image_name)
         listcmd = cmd
         listcmd += " -l %s" % image_name
         s, o = commands.getstatusoutput(listcmd)
@@ -243,10 +243,124 @@ def run_qemu_img(test, params, env):
     def commit_test(cmd):
         """
         Subcommand 'qemu-img commit' test.
+        1) Create a backing file of the qemu harddisk specified by image_name.
+        2) Start a VM using the backing file as its harddisk.
+        3) Touch a file "commit_testfile" in the backing_file, and shutdown the
+           VM.
+        4) Make sure touching the file does not affect the original harddisk.
+        5) Commit the change to the original harddisk by executing
+           "qemu-img commit" command.
+        6) Start the VM using the original harddisk.
+        7) Check if the file "commit_testfile" exists.
 
         @param cmd: qemu-img base command.
         """
-        pass
+        cmd += " commit"
+
+        logging.info("Commit testing started!")
+        image_name = params.get("image_name", "image")
+        image_format = params.get("image_format", "qcow2")
+        backing_file_name = "%s_bak" % (image_name)
+
+        try:
+            # Remove the existing backing file
+            backing_file = "%s.%s" % (backing_file_name, image_format)
+            if os.path.isfile(backing_file):
+                os.remove(backing_file)
+
+            # Create the new backing file
+            create_cmd = "qemu-img create -b %s.%s -f %s %s.%s" % (image_name,
+                                                                  image_format,
+                                                                  image_format,
+                                                             backing_file_name,
+                                                                  image_format)
+            try:
+                utils.system(create_cmd)
+            except error.CmdError, e:
+                raise error.TestFail("Could not create a backing file!")
+            logging.info("backing_file created!")
+
+            # Set the qemu harddisk to the backing file
+            logging.info("Original image_name is: %s", params.get('image_name'))
+            params['image_name'] = backing_file_name
+            logging.info("Param image_name changed to: %s",
+                         params.get('image_name'))
+
+            # Start a new VM, using backing file as its harddisk
+            vm_name = params.get('main_vm')
+            kvm_preprocessing.preprocess_vm(test, params, env, vm_name)
+            vm = env.get_vm(vm_name)
+            vm.create()
+            timeout = int(params.get("login_timeout", 360))
+            session = vm.wait_for_login(timeout=timeout)
+
+            # Do some changes to the backing_file harddisk
+            try:
+                output = session.cmd("touch /commit_testfile")
+                logging.info("Output of touch /commit_testfile: %s", output)
+                output = session.cmd("ls / | grep commit_testfile")
+                logging.info("Output of ls / | grep commit_testfile: %s",
+                             output)
+            except Exception, e:
+                raise error.TestFail("Could not create commit_testfile in the "
+                                     "backing file %s", e)
+            vm.destroy()
+
+            # Make sure there is no effect on the original harddisk
+            # First, set the harddisk back to the original one
+            logging.info("Current image_name is: %s", params.get('image_name'))
+            params['image_name'] = image_name
+            logging.info("Param image_name reverted to: %s",
+                         params.get('image_name'))
+
+            # Second, Start a new VM, using image_name as its harddisk
+            # Here, the commit_testfile should not exist
+            vm_name = params.get('main_vm')
+            kvm_preprocessing.preprocess_vm(test, params, env, vm_name)
+            vm = env.get_vm(vm_name)
+            vm.create()
+            timeout = int(params.get("login_timeout", 360))
+            session = vm.wait_for_login(timeout=timeout)
+            try:
+                output = session.cmd("[ ! -e /commit_testfile ] && echo $?")
+                logging.info("Output of [ ! -e /commit_testfile ] && echo $?: "
+                             "%s", output)
+            except:
+                output = session.cmd("rm -f /commit_testfile")
+                raise error.TestFail("The commit_testfile exists on the "
+                                     "original file")
+            vm.destroy()
+
+            # Excecute the commit command
+            logging.info("Commiting image")
+            cmitcmd = "%s -f %s %s.%s" % (cmd, image_format, backing_file_name,
+                                          image_format)
+            try:
+                utils.system(cmitcmd)
+            except error.CmdError, e:
+                raise error.TestFail("Could not commit the backing file")
+
+            # Start a new VM, using image_name as its harddisk
+            vm_name = params.get('main_vm')
+            kvm_preprocessing.preprocess_vm(test, params, env, vm_name)
+            vm = env.get_vm(vm_name)
+            vm.create()
+            timeout = int(params.get("login_timeout", 360))
+            session = vm.wait_for_login(timeout=timeout)
+            try:
+                output = session.cmd("[ -e /commit_testfile ] && echo $?")
+                logging.info("Output of [ -e /commit_testfile ] && echo $?: %s",
+                             output)
+                session.cmd("rm -f /commit_testfile")
+            except:
+                raise error.TestFail("Could not find commit_testfile after a "
+                                     "commit")
+            vm.destroy()
+
+        finally:
+            # Remove the backing file
+            if os.path.isfile(backing_file):
+                os.remove(backing_file)
 
 
     def _rebase(cmd, img_name, base_img, backing_fmt, mode="unsafe"):
@@ -263,7 +377,7 @@ def run_qemu_img(test, params, env):
         if mode == "unsafe":
             cmd += " -u"
         cmd += " -b %s -F %s %s" % (base_img, backing_fmt, img_name)
-        logging.info("Trying to rebase '%s' to '%s'..." % (img_name, base_img))
+        logging.info("Trying to rebase '%s' to '%s'...", img_name, base_img)
         s, o = commands.getstatusoutput(cmd)
         if s != 0:
             raise error.TestError("Failed to rebase '%s' to '%s': %s" %