add memory reboot step in the end of hotplug/unplug test

Signed-off-by: NXu Tian <xutian@redhat.com>

qemu/tests/hotplug_mem.py

@@ -31,40 +31,35 @@ class MemoryHotplugSimple(MemoryHotplugTest):
         args = (self.test, self.params, self.env, self.params["sub_type"])
         bg_test = BackgroundTest(run_virt_sub_test, args)
         bg_test.start()
-        wait_for(bg_test.is_alive, timeout=60)
+        wait_for(bg_test.is_alive, first=10, step=3, timeout=100)
         return bg_test
 
-    def restore_memory(self, origin_vm, post_vm):
-        mem_devs_post = post_vm.params.objects("mem_devs")
-        mem_devs_origin = origin_vm.params.objects("mem_devs")
-        if len(mem_devs_post) != len(mem_devs_origin):
-            if len(mem_devs_origin) > len(mem_devs_post):
-                mem_devs = set(mem_devs_origin) - set(mem_devs_post)
-                vm, operation = post_vm, "hotplug"
-            else:
-                mem_devs = set(mem_devs_post) - set(mem_devs_origin)
-                vm, operation = origin_vm, "unplug"
-            func = getattr(self, "%s_memory" % operation)
-            for mem_dev in mem_devs:
-                func(vm, mem_dev)
-                self.check_vm_memory(vm)
+    def restore_memory(self, pre_vm, post_vm):
+        mem_devs_post = set(post_vm.params.objects("mem_devs"))
+        mem_devs_origin = set(pre_vm.params.objects("mem_devs"))
+        if mem_devs_post == mem_devs_origin:
+            return
+        if len(mem_devs_origin) > len(mem_devs_post):
+            mem_devs = mem_devs_origin - mem_devs_post
+            vm, operation = post_vm, "hotplug"
+        elif len(mem_devs_origin) < len(mem_devs_post):
+            mem_devs = mem_devs_post - mem_devs_origin
+            vm, operation = pre_vm, "unplug"
+        func = getattr(self, "%s_memory" % operation)
+        map(lambda x: func(vm, x), mem_devs)
 
     def get_mem_by_name(self, vm, name):
         """
         Return memory object and pc-dimm devices by given name
         """
-        devices = []
-        for dtype in ["mem", "dimm"]:
-            dev_qid = "%s-%s" % (dtype, name)
-            devs = vm.devices.get_by_qid(dev_qid)
-            if devs:
-                devices.append(devs[0])
-        return devices
+        dev_ids = map(lambda x: "-".join([x, name]), ["mem", "dimm"])
+        deivces = filter(None, map(vm.devices.get_by_qid, dev_ids))
+        return [_[0] for _ in devices]
 
     def start_test(self):
+        operation = self.params["operation"]
+        target_mem = self.params["target_mem"]
         try:
-            target_mem = self.params["target_mem"]
-            operation = self.params["operation"]
             vm = self.env.get_vm(self.params["main_vm"])
             if self.params.get("stage") == "before":
                 self.run_sub_test()
@@ -78,15 +73,18 @@ class MemoryHotplugSimple(MemoryHotplugTest):
             if self.params.get("stage") == "during":
                 sub_test = self.run_background_test()
             func(vm, target_mem)
+            self.check_memory(vm)
             if self.params.get("stage") == "during":
                 test_timeout = float(self.params.get("sub_test_timeout", 3600))
                 sub_test.join(timeout=test_timeout)
             if self.params.get("stage") == "after":
                 self.run_sub_test()
-            post_vm = self.env.get_vm(self.params["main_vm"])
-            self.restore_memory(vm, post_vm)
+            self.restore_memory(vm, self.env.get_vm(self.params['main_vm']))
         finally:
             self.close_sessions()
+            vm = self.env.get_vm(self.params["main_vm"])
+            vm.verify_alive()
+            vm.reboot()
 
 
 @step_engine.context_aware
@@ -100,6 +98,7 @@ def run(test, params, env):
     5) Check no calltrace in guest/host dmesg
     6) Hotplug/unplug memory device
     7) Run sub test after plug/unplug memory device
+    8) Restore VM and reboot guest
 
     :param test: QEMU test object
     :param params: Dictionary with the test parameters