cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From wid...@apache.org
Subject [48/50] [abbrv] git commit: updated refs/heads/statscollector-graphite to 621156c
Date Sun, 28 Sep 2014 09:40:48 GMT
Additional Guest OS support for vGPU Test Automation


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/402a3323
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/402a3323
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/402a3323

Branch: refs/heads/statscollector-graphite
Commit: 402a3323f87cdb7ae456d1486702269463c8b32c
Parents: e921ec6
Author: sailajamada <sailaja.mada@citrix.com>
Authored: Fri Sep 26 17:11:31 2014 +0530
Committer: sailajamada <sailaja.mada@citrix.com>
Committed: Fri Sep 26 17:12:41 2014 +0530

----------------------------------------------------------------------
 .../component/test_deploy_vgpu_vm.py            | 512 +++++++++++++------
 tools/marvin/marvin/config/test_data.py         |  33 +-
 2 files changed, 383 insertions(+), 162 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cloudstack/blob/402a3323/test/integration/component/test_deploy_vgpu_vm.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_deploy_vgpu_vm.py b/test/integration/component/test_deploy_vgpu_vm.py
index 081ab4b..b5af092 100644
--- a/test/integration/component/test_deploy_vgpu_vm.py
+++ b/test/integration/component/test_deploy_vgpu_vm.py
@@ -68,8 +68,14 @@ class TestvGPUWindowsVm(cloudstackTestCase):
              cls.k1passthroughgpuhosts=0
              cls.k2passthroughgpuhosts=0
              cls.nongpuhosts=[]
-             k2hosts=0
-             k1hosts=0
+             cls.k2hosts=0
+             cls.k1hosts=0
+             cls.k100_vgpu_service_offering=[]
+             cls.k200_vgpu_service_offering=[]
+             cls.vm_k1_card=[]
+             cls.vm_k2_card=[]
+             cls.vm2_k2_card=[]
+             cls.vmlifecycletest=0
 
              for ghost in hosts :
                  if ghost.hypervisorversion >= "6.2.0":
@@ -86,7 +92,7 @@ class TestvGPUWindowsVm(cloudstackTestCase):
                     if (k2card==0) and (k1card==0):
                        cls.nongpuhosts.append(ghost.ipaddress)
                     if k2card !=0:
-                          k2hosts=k2hosts+1
+                          cls.k2hosts=cls.k2hosts+1
                           k260q = len(sshClient.execute("xe vgpu-type-list model-name=\"GRID
K260Q\""))
                           k240q = len(sshClient.execute("xe vgpu-type-list model-name=\"GRID
K240Q\""))
                           k220q = len(sshClient.execute("xe vgpu-type-list model-name=\"GRID
K220Q\""))
@@ -107,7 +113,7 @@ class TestvGPUWindowsVm(cloudstackTestCase):
                                   cls.k2passthroughgpuhosts=cls.k2passthroughgpuhosts+1
 
                     if k1card != 0:
-                            k1hosts=k1hosts+1
+                            cls.k1hosts=cls.k1hosts+1
                             k100 = len(sshClient.execute("xe vgpu-type-list model-name=\"GRID
K100\""))
                             k120q = len(sshClient.execute("xe vgpu-type-list model-name=\"GRID
K120Q\""))
                             k140q = len(sshClient.execute("xe vgpu-type-list model-name=\"GRID
K140Q\""))
@@ -123,7 +129,7 @@ class TestvGPUWindowsVm(cloudstackTestCase):
                                    cls.k100gpuhosts=cls.k100gpuhosts+1
                                 if k1passthrough != 0 :
                                    cls.k1passthroughgpuhosts=cls.k1passthroughgpuhosts+1
-        if (k1hosts == 0) and (k2hosts == 0):
+        if (cls.k2hosts == 0) and (cls.k1hosts == 0):
            raise unittest.SkipTest("No XenServer available with GPU Drivers installed")
 
         cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
@@ -139,6 +145,8 @@ class TestvGPUWindowsVm(cloudstackTestCase):
         #cls.template = get_windows_template(cls.apiclient, cls.zone.id ,ostype_desc="Windows
Server 2012 (64-bit)")
 
         if  cls.template == FAILED:
+            if "http://pleaseupdateURL/dummy.vhd" in cls.testdata["vgpu"] ["templateregister1"]["url"]:
+                raise unittest.SkipTest("Check Test Data file if it has the valid template
URL")
             cls.template = Template.register(
                    cls.apiclient,
                    cls.testdata["vgpu"] ["templateregister1"],
@@ -166,86 +174,17 @@ class TestvGPUWindowsVm(cloudstackTestCase):
                   template_response = list_template_response[0]
                   if template_response.isready == True:
                       break
-                  
+
                   if timeout == 0:
-                      raise unittest.SkipTest("Failed to download template(ID: %s)" % template_response.id)
+                      raise unittest.SkipTest("Failed to download template(ID: %s). " % template_response.id)
 
                   timeout = timeout - 1
 
-        """
-        Create Service Offerings for Both K1 and K2 cards to be used for VM life cycle tests
-        """
-
-        if(k1hosts != 0):
-            if(cls.k140qgpuhosts != 0):
-                gtype = "GRID K140Q"
-            elif(cls.k120qgpuhosts != 0):
-                gtype = "GRID K120Q"
-            elif(cls.k100gpuhosts !=0):
-                gtype = "GRID K100"
-            else:
-                gtype = "passthrough"
-
-            cls.testdata["vgpu"]["service_offerings"][gtype]["serviceofferingdetails"] =
[{'pciDevice':'Group of NVIDIA Corporation GK107GL [GRID K1] GPUs'},
-                                                                                       {'vgpuType':gtype}]
-            try:
-               cls.k100_vgpu_service_offering = ServiceOffering.create(
-                                                                    cls.apiclient,
-                                                                    cls.testdata["vgpu"]["service_offerings"][gtype]
-                                                                    )
-            except Exception as e:
-               cls.fail("Failed to create the service offering, %s" % e)
-
-        if(k2hosts != 0):
-            if(cls.k240qgpuhosts != 0):
-                gtype = "GRID K240Q"
-            elif(cls.k220qgpuhosts != 0):
-                gtype = "GRID K220Q"
-            elif(cls.k200gpuhosts !=0):
-                gtype = "GRID K200"
-            else:
-                gtype = "passthrough"
-
-            cls.testdata["vgpu"]["service_offerings"][gtype]["serviceofferingdetails"] =
[{'pciDevice': 'Group of NVIDIA Corporation GK104GL [GRID K2] GPUs'},
-                                                                                       {'vgpuType':gtype}]
-            try:
-               cls.k200_vgpu_service_offering = ServiceOffering.create(
-                                                                    cls.apiclient,
-                                                                    cls.testdata["vgpu"]["service_offerings"][gtype]
-                                                                    )
-            except Exception as e:
-              cls.fail("Failed to create the service offering, %s" % e)
-
-        """
-        Create Virtual Machines for Both K1 and K2 cards to be used for VM life cycle tests
-        """
-
-        if(k1hosts != 0):
-            cls.vm_k1_card = VirtualMachine.create(
-            cls.apiclient,
-            cls.testdata["virtual_machine"],
-            accountid=cls.account.name,
-            zoneid=cls.zone.id,
-            domainid=cls.account.domainid,
-            serviceofferingid=cls.k100_vgpu_service_offering.id,
-            templateid=cls.template.id
-            )
-        if(k2hosts !=0):
-            cls.vm_k2_card = VirtualMachine.create(
-            cls.apiclient,
-            cls.testdata["virtual_machine"],
-            accountid=cls.account.name,
-            zoneid=cls.zone.id,
-            domainid=cls.account.domainid,
-            serviceofferingid=cls.k200_vgpu_service_offering.id,
-            templateid=cls.template.id
-            )
-
 
         cls._cleanup = [
                          cls.account,
-                         cls.k100_vgpu_service_offering,
-                         cls.k200_vgpu_service_offering
+                         #cls.k100_vgpu_service_offering,
+                         #cls.k200_vgpu_service_offering
                         ]
 
     @attr(tags = ['advanced', 'basic', 'vgpu'], required_hardware="true")
@@ -486,6 +425,7 @@ class TestvGPUWindowsVm(cloudstackTestCase):
                         self.fail("Failed to start VM (ID: %s) with %s vGPU card " % (vm.id,vgpucard))
         return(list_vm_response[0])
 
+
     @attr(tags = ['advanced', 'basic' , 'vgpu'], required_hardware="true")
     def destroy_vm(self):
         """Destroy Virtual Machine
@@ -606,6 +546,282 @@ class TestvGPUWindowsVm(cloudstackTestCase):
         return
 
 
+    def new_template_register(self,guestostype):
+
+        template1 = get_windows_template(self.apiclient, self.zone.id ,ostype_desc=guestostype)
+
+        if  template1 == FAILED:
+            if "http://pleaseupdateURL/dummy.vhd" in cls.testdata["vgpu"] [guestostype]["url"]:
+                raise unittest.SkipTest("Check Test Data file if it has the valid template
URL")
+            template1 = Template.register(
+                   self.apiclient,
+                   self.testdata["vgpu"] [guestostype],
+                   hypervisor = "XenServer",
+                   zoneid=cls.zone.id,
+                   domainid=cls.account.domainid,
+                   account=cls.account.name
+                   )
+            timeout = self.testdata["vgpu"]["timeout"]
+
+            while True:
+                  time.sleep(self.testdata["vgpu"]["sleep"])
+                  list_template_response = Template.list(
+                       self.apiclient,
+                       templatefilter=\
+                       self.testdata["templatefilter"],
+                       id=template1.id
+                        )
+                  if (isinstance(list_template_response, list)) is not True:
+                      raise unittest.SkipTest("Check list template api response returns a
valid list")
+
+                  if len(list_template_response) is None :
+                      raise unittest.SkipTest("Check template registered is in List Templates")
+
+                  template_response = list_template_response[0]
+                  if template_response.isready == True:
+                      break
+                  if timeout == 0:
+                      raise unittest.SkipTest("Failed to download template(ID: %s)" % template_response.id)
+
+                  timeout = timeout - 1
+        return(template1.id)
+
+    def deploy_vm_lifecycle(self):
+        """
+        Create Service Offerings for Both K1 and K2 cards to be used for VM life cycle tests
+        """
+
+        if(self.k1hosts != 0):
+            if(self.k140qgpuhosts != 0):
+                gtype = "GRID K140Q"
+            elif(self.k120qgpuhosts != 0):
+                gtype = "GRID K120Q"
+            elif(self.k100gpuhosts !=0):
+                gtype = "GRID K100"
+            else:
+                gtype = "passthrough"
+
+            self.testdata["vgpu"]["service_offerings"][gtype]["serviceofferingdetails"] =
[{'pciDevice':'Group of NVIDIA Corporation GK107GL [GRID K1] GPUs'},
+                                                                                       {'vgpuType':gtype}]
+            try:
+               self.__class__.k100_vgpu_service_offering = ServiceOffering.create(
+                                                                    self.apiclient,
+                                                                    self.testdata["vgpu"]["service_offerings"][gtype]
+                                                                    )
+            except Exception as e:
+               self.fail("Failed to create the service offering, %s" % e)
+
+        if(self.k2hosts != 0):
+            if(self.k240qgpuhosts != 0):
+                gtype = "GRID K240Q"
+            elif(cls.k220qgpuhosts != 0):
+                gtype = "GRID K220Q"
+            elif(self.k200gpuhosts !=0):
+                gtype = "GRID K200"
+            else:
+                gtype = "passthrough"
+
+            self.testdata["vgpu"]["service_offerings"][gtype]["serviceofferingdetails"] =
[{'pciDevice': 'Group of NVIDIA Corporation GK104GL [GRID K2] GPUs'},
+                                                                                       {'vgpuType':gtype}]
+            try:
+               self.__class__.k200_vgpu_service_offering = ServiceOffering.create(
+                                                                    self.apiclient,
+                                                                    self.testdata["vgpu"]["service_offerings"][gtype]
+                                                                    )
+            except Exception as e:
+              self.fail("Failed to create the service offering, %s" % e)
+
+        win8templateid=self.new_template_register("Windows 8 (64-bit)")
+        win2012templateid=self.new_template_register("Windows Server 2012 (64-bit)")
+        win7templateid=self.new_template_register("Windows 7 (64-bit)")
+
+        """
+        Create Virtual Machines for Both K1 and K2 cards to be used for VM life cycle tests
+        """
+
+        if(self.k1hosts != 0):
+            self.__class__.vm_k1_card = VirtualMachine.create(
+            self.apiclient,
+            self.testdata["virtual_machine"],
+            accountid=self.account.name,
+            zoneid=self.zone.id,
+            domainid=self.account.domainid,
+            serviceofferingid=self.k100_vgpu_service_offering.id,
+            templateid=win8templateid
+            )
+        if(self.k2hosts !=0):
+            self.__class__.vm_k2_card = VirtualMachine.create(
+            self.apiclient,
+            self.testdata["virtual_machine"],
+            accountid=self.account.name,
+            zoneid=self.zone.id,
+            domainid=self.account.domainid,
+            serviceofferingid=self.k200_vgpu_service_offering.id,
+            templateid=win2012templateid
+            )
+        if(self.k2hosts !=0):
+            self.__class__.vm2_k2_card = VirtualMachine.create(
+            self.apiclient,
+            self.testdata["virtual_machine"],
+            accountid=self.account.name,
+            zoneid=self.zone.id,
+            domainid=self.account.domainid,
+            serviceofferingid=self.k200_vgpu_service_offering.id,
+            templateid=win7templateid
+            )
+        return
+
+
+    def check_gpu_resources_released_vm(self,gpuhostid,vm_vgpu_type,rcapacity):
+        hhosts = list_hosts(
+               self.apiclient,
+               hypervisor="XenServer",
+               id=gpuhostid
+               )
+        self.assertEqual(
+                            isinstance(hhosts, list),
+                            True,
+                            "Check list hosts response returns a valid list"
+                        )
+
+        self.assertNotEqual(
+                            len(hhosts),
+                            0,
+                            "Check Host details are available in List Hosts"
+                        )
+        for ggroup in hhosts:
+               if ggroup.ipaddress not in self.nongpuhosts:
+                  for gp in ggroup.gpugroup:
+                      #if gp.gpugroupname == "Group of NVIDIA Corporation GK104GL [GRID K2]
GPUs":
+                         for gptype in gp.vgpu:
+                             if gptype.vgputype==vm_vgpu_type:
+                                self.debug("Latest remainingcapacity is %s and before remainingcapacity
is %s"%(gptype.remainingcapacity,rcapacity))
+                                if gptype.remainingcapacity != rcapacity+1:
+                                   self.fail("Host capacity is not updated .GPU resources
should be released when VM is stopped/Destroyed ")
+        return
+
+    def check_vm_state(self,vmid):
+        list_vm_response = list_virtual_machines(
+                                                     self.apiclient,
+                                                     id=vmid
+                                                     )
+
+        if list_vm_response is None:
+            return("Expunge")
+        return(list_vm_response[0].state)
+
+    def check_host_vgpu_remaining_capacity(self,gpuhostid,gtype):
+        gputhosts = list_hosts(
+               self.apiclient,
+               hypervisor="XenServer",
+               id=gpuhostid
+               )
+        vgpucapacity=0
+        for ghost in gputhosts:
+            if ghost.gpugroup is not None:
+                        for gp in ghost.gpugroup:
+                            #if gp.gpugroupname == gpucard:
+                               for gptype in gp.vgpu:
+                                   if gptype.vgputype == gtype:
+                                      vgpucapacity=vgpucapacity+gptype.remainingcapacity
+
+        return(vgpucapacity)
+
+    def verify_vm(self,vm_gpu_card):
+        if(vm_gpu_card):
+          vm_gpu_card.getState(
+                                   self.apiclient,
+                                   "Running")
+
+          self.check_for_vGPU_resource(vm_gpu_card.hostid,vm_gpu_card.instancename,vm_gpu_card.serviceofferingid,vm_gpu_card.vgpu)
+
+    def stop_life_cycle_vm (self,vm_gpu_card):
+
+        if(vm_gpu_card):
+          vm_gpu_card.stop(self.apiclient)
+          time.sleep(self.testdata["vgpu"]["sleep"])
+          vm_gpu_card.getState(
+                                   self.apiclient,
+                                   "Stopped")
+
+    def start_life_cycle_vm(self,vm_gpu_card):
+
+        if(vm_gpu_card):
+          vm_gpu_card.start(self.apiclient)
+          time.sleep(self.testdata["vgpu"]["sleep"])
+
+    def restore_life_cycle_vm(self,vm_gpu_card):
+        if(vm_gpu_card):
+          vm_gpu_card.restore(self.apiclient)
+          time.sleep(self.testdata["vgpu"]["sleep"])
+
+    def reboot_life_cycle_vm(self,vm_gpu_card):
+
+        if(vm_gpu_card):
+          vm_gpu_card.reboot(self.apiclient)
+          time.sleep(self.testdata["vgpu"]["sleep"])
+
+    def delete_vm_life_cycle_vm(self,vm_gpu_card):
+        if(vm_gpu_card):
+          vm_gpu_card.delete(self.apiclient)
+          time.sleep(self.testdata["vgpu"]["sleep"])
+          vm_gpu_card.getState(
+                                   self.apiclient,
+                                   "Destroyed")
+
+    def recover_vm_life_cycle_vm(self,vm_gpu_card):
+        if(vm_gpu_card):
+          vm_gpu_card.recover(self.apiclient)
+          vm_gpu_card.getState(
+                                   self.apiclient,
+                                   "Stopped")
+
+
+    def recovervm(self,vm_gpu_card):
+        if self.check_vm_state(vm_gpu_card.id)=="Expunge":
+            raise unittest.SkipTest("VM is already deleted hence skipping")
+        self.recover_vm_life_cycle_vm(vm_gpu_card)
+        self.start_life_cycle_vm(vm_gpu_card)
+        self.verify_vm(vm_gpu_card)
+        return
+
+
+    def startvm(self,vm_gpu_card):
+
+        self.start_life_cycle_vm(vm_gpu_card)
+        self.verify_vm(vm_gpu_card)
+        return
+
+    def stopvm(self,vm_gpu_card):
+
+        rcapacity=self.check_host_vgpu_remaining_capacity(vm_gpu_card.hostid,vm_gpu_card.vgpu)
+        self.stop_life_cycle_vm(vm_gpu_card)
+        self.check_gpu_resources_released_vm(vm_gpu_card.hostid,vm_gpu_card.vgpu,rcapacity)
+        return
+
+    def deletevm(self,vm_gpu_card):
+
+        rcapacity=self.check_host_vgpu_remaining_capacity(vm_gpu_card.hostid,vm_gpu_card.vgpu)
+        hostid=vm_gpu_card.hostid
+        vgputype=vm_gpu_card.vgpu
+        self.delete_vm_life_cycle_vm(vm_gpu_card)
+        self.check_gpu_resources_released_vm(hostid,vgputype,rcapacity)
+        return
+
+    def restorevm(self,vm_gpu_card):
+
+        self.restore_life_cycle_vm(vm_gpu_card)
+        self.verify_vm(vm_gpu_card)
+        return
+
+
+    def rebootvm(self,vm_vgpu_card):
+
+        self.reboot_life_cycle_vm(vm_vgpu_card)
+        self.verify_vm(vm_vgpu_card)
+        return
+
+
     def test_01_list_vgpu_host_details(self):
         """   list vGPU host details  """
         hhosts = list_hosts(
@@ -909,31 +1125,28 @@ class TestvGPUWindowsVm(cloudstackTestCase):
     def test_12_validate_deployed_vGPU_windows_vm(self):
         """ Test deploy virtual machine
         """
-        self.debug("Check if deployed VMs are in running state?")
-        if(self.vm_k1_card):
-          self.vm_k1_card.getState(
-                                   self.apiclient,
-                                   "Running")
-          self.check_for_vGPU_resource(self.vm_k1_card.hostid,self.vm_k1_card.instancename,self.vm_k1_card.serviceofferingid,self.vm_k1_card.vgpu)
 
-        if(self.vm_k2_card):
-          self.vm_k2_card.getState(
-                                   self.apiclient,
-                                   "Running")
+        self.deploy_vm_lifecycle()
 
-          self.check_for_vGPU_resource(self.vm_k2_card.hostid,self.vm_k2_card.instancename,self.vm_k2_card.serviceofferingid,self.vm_k2_card.vgpu)
+        self.debug("Check if deployed VMs are in running state?")
+
+        self.verify_vm(self.__class__.vm_k1_card)
+        self.verify_vm(self.__class__.vm_k2_card)
+        self.verify_vm(self.__class__.vm2_k2_card)
 
+        self.__class__.vmlifecycletest=1
         return
 
     @attr(tags = ['advanced', 'basic' , 'vgpu'], required_hardware="true")
     def test_13_stop_vGPU_windows_vm(self):
         """ Test stop virtual machine
         """
-        if(self.vm_k1_card):
-          self.vm_k1_card.stop(self.apiclient)
+        if self.__class__.vmlifecycletest==0:
+            raise unittest.SkipTest("VM Life Cycle Deploy VM test failed hence skipping")
 
-        if(self.vm_k2_card):
-          self.vm_k2_card.stop(self.apiclient)
+        self.stopvm(self.__class__.vm_k1_card)
+        self.stopvm(self.__class__.vm_k2_card)
+        self.stopvm(self.__class__.vm2_k2_card)
 
         return
 
@@ -941,15 +1154,12 @@ class TestvGPUWindowsVm(cloudstackTestCase):
     def test_14_start_vGPU_windows_vm(self):
         """ Test start virtual machine
         """
-        if(self.vm_k1_card):
-          self.vm_k1_card.start(self.apiclient)
-          time.sleep(200)
-          self.check_for_vGPU_resource(self.vm_k1_card.hostid,self.vm_k1_card.instancename,self.vm_k1_card.serviceofferingid,self.vm_k1_card.vgpu)
+        if self.__class__.vmlifecycletest==0:
+            raise unittest.SkipTest("VM Life Cycle Deploy VM test failed hence skipping")
 
-        if(self.vm_k2_card):
-          self.vm_k2_card.start(self.apiclient)
-          time.sleep(200)
-          self.check_for_vGPU_resource(self.vm_k2_card.hostid,self.vm_k2_card.instancename,self.vm_k2_card.serviceofferingid,self.vm_k2_card.vgpu)
+        self.startvm(self.__class__.vm_k1_card)
+        self.startvm(self.__class__.vm_k2_card)
+        self.startvm(self.__class__.vm2_k2_card)
 
         return
 
@@ -957,23 +1167,13 @@ class TestvGPUWindowsVm(cloudstackTestCase):
     def test_15_restore_vGPU_windows_vm(self):
         """Test restore Virtual Machine
         """
-        if(self.vm_k1_card):
-          self.vm_k1_card.restore(self.apiclient)
-          time.sleep(200)
-          self.vm_k1_card.getState(
-                                   self.apiclient,
-                                   "Running")
-
-          self.check_for_vGPU_resource(self.vm_k1_card.hostid,self.vm_k1_card.instancename,self.vm_k1_card.serviceofferingid,self.vm_k1_card.vgpu)
 
-        if(self.vm_k2_card):
-          self.vm_k2_card.restore(self.apiclient)
-          time.sleep(200)
-          self.vm_k2_card.getState(
-                                   self.apiclient,
-                                   "Running")
+        if self.__class__.vmlifecycletest==0:
+            raise unittest.SkipTest("VM Life Cycle Deploy VM test failed hence skipping")
 
-          self.check_for_vGPU_resource(self.vm_k2_card.hostid,self.vm_k2_card.instancename,self.vm_k2_card.serviceofferingid,self.vm_k2_card.vgpu)
+        self.restorevm(self.__class__.vm_k1_card)
+        self.restorevm(self.__class__.vm_k2_card)
+        self.restorevm(self.__class__.vm2_k2_card)
 
         return
 
@@ -981,23 +1181,13 @@ class TestvGPUWindowsVm(cloudstackTestCase):
     def test_16_reboot_vGPU_windows_vm(self):
         """ Test reboot virtual machine
         """
-        if(self.vm_k1_card):
-          self.vm_k1_card.reboot(self.apiclient)
-          time.sleep(200)
-          self.vm_k1_card.getState(
-                                   self.apiclient,
-                                   "Running")
-
-          self.check_for_vGPU_resource(self.vm_k1_card.hostid,self.vm_k1_card.instancename,self.vm_k1_card.serviceofferingid,self.vm_k1_card.vgpu)
 
-        if(self.vm_k2_card):
-          self.vm_k2_card.reboot(self.apiclient)
-          time.sleep(200)
-          self.vm_k2_card.getState(
-                                   self.apiclient,
-                                   "Running")
+        if self.__class__.vmlifecycletest==0:
+            raise unittest.SkipTest("VM Life Cycle Deploy VM test failed hence skipping")
 
-          self.check_for_vGPU_resource(self.vm_k2_card.hostid,self.vm_k2_card.instancename,self.vm_k2_card.serviceofferingid,self.vm_k2_card.vgpu)
+        self.rebootvm(self.__class__.vm_k1_card)
+        self.rebootvm(self.__class__.vm_k2_card)
+        self.rebootvm(self.__class__.vm2_k2_card)
 
         return
 
@@ -1005,17 +1195,18 @@ class TestvGPUWindowsVm(cloudstackTestCase):
     def test_17_destroy_vGPU_windows_vm(self):
         """Test destroy Virtual Machine
         """
-        if(self.vm_k1_card):
-          self.vm_k1_card.delete(self.apiclient)
-          self.vm_k1_card.getState(
-                                   self.apiclient,
-                                   "Destroyed")
 
-        if(self.vm_k2_card):
-          self.vm_k2_card.delete(self.apiclient)
-          self.vm_k2_card.getState(
-                                   self.apiclient,
-                                   "Destroyed")
+        if self.__class__.vmlifecycletest==0:
+            raise unittest.SkipTest("VM Life Cycle Deploy VM test failed hence skipping")
+
+
+        self.deletevm(self.__class__.vm_k1_card)
+        self.deletevm(self.__class__.vm_k2_card)
+        self.deletevm(self.__class__.vm2_k2_card)
+
+
+        self.cleanup.append(self.__class__.k100_vgpu_service_offering)
+        self.cleanup.append(self.__class__.k200_vgpu_service_offering)
 
         return
 
@@ -1023,35 +1214,34 @@ class TestvGPUWindowsVm(cloudstackTestCase):
     def test_18_recover_vGPU_windows_vm(self):
         """Test recover Virtual Machine
         """
-        if(self.vm_k1_card):
-          self.vm_k1_card.recover(self.apiclient)
-          self.vm_k1_card.getState(
-                                   self.apiclient,
-                                   "Stopped")
 
+        if self.__class__.vmlifecycletest==0:
+            raise unittest.SkipTest("VM Life Cycle Deploy VM test failed hence skipping")
 
-        if(self.vm_k2_card):
-          self.vm_k2_card.recover(self.apiclient)
-          self.vm_k2_card.getState(
-                                   self.apiclient,
-                                   "Stopped")
+        self.recovervm(self.__class__.vm_k1_card)
+        self.recovervm(self.__class__.vm_k2_card)
+        self.recovervm(self.__class__.vm2_k2_card)
 
         return
 
     def test_19_destroy_vGPU_windows_vm_after_recover(self):
         """Test destroy Virtual Machine
         """
-        if(self.vm_k1_card):
-          self.vm_k1_card.delete(self.apiclient)
-          self.vm_k1_card.getState(
-                                   self.apiclient,
-                                   "Destroyed")
 
-        if(self.vm_k2_card):
-          self.vm_k2_card.delete(self.apiclient)
-          self.vm_k2_card.getState(
-                                   self.apiclient,
-                                   "Destroyed")
+        if self.__class__.vmlifecycletest==0:
+            raise unittest.SkipTest("VM Life Cycle Deploy VM test failed hence skipping")
+
+        if self.check_vm_state(self.__class__.vm_k1_card.id)=="Expunge":
+            raise unittest.SkipTest("VM is already deleted hence skipping")
+        self.deletevm(self.__class__.vm_k1_card)
+
+        if self.check_vm_state(self.__class__.vm_k2_card.id)=="Expunge":
+            raise unittest.SkipTest("VM is already deleted hence skipping")
+        self.deletevm(self.__class__.vm_k2_card)
+
+        if self.check_vm_state(self.__class__.vm2_k1_card.id)=="Expunge":
+            raise unittest.SkipTest("VM is already deleted hence skipping")
+        self.deletevm(self.__class__.vm2_k2_card)
 
         return
 

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/402a3323/tools/marvin/marvin/config/test_data.py
----------------------------------------------------------------------
diff --git a/tools/marvin/marvin/config/test_data.py b/tools/marvin/marvin/config/test_data.py
index b13d8fe..00fa52c 100644
--- a/tools/marvin/marvin/config/test_data.py
+++ b/tools/marvin/marvin/config/test_data.py
@@ -950,12 +950,43 @@ test_data = {
                               "displaytext": "win8withpv",
                               "name": "win8withpv",
                               "passwordenabled": False,
-                              "url": "http://10.147.28.7/templates/Windows8/Windows864.vhd",
+                              "url": "http://pleaseupdateURL/dummy.vhd",
                               "format": "VHD" ,
                               "ostype": "Windows 8 (64-bit)",
                               "ispublic": "true",
                               "hypervisor": "XenServer"
                               },
+    "Windows 8 (64-bit)": {
+                              "displaytext": "Windows 8 (64-bit)",
+                              "name": "win8withpv",
+                              "passwordenabled": False,
+                              "url": "http://pleaseupdateURL/dummy.vhd",
+                              "format": "VHD" ,
+                              "ostype": "Windows 8 (64-bit)",
+                              "ispublic": "true",
+                              "hypervisor": "XenServer"
+                              },
+    "Windows Server 2012 (64-bit)": {
+                              "displaytext": "Windows Server 2012 (64-bit)",
+                              "name": "Windows Server 2012 (64-bit)",
+                              "passwordenabled": False,
+                              "url": "http://pleaseupdateURL/dummy.vhd",
+                              "format": "VHD" ,
+                              "ostype": "Windows Server 2012 (64-bit)",
+                              "ispublic": "true",
+                              "hypervisor": "XenServer"
+                              },
+
+    "Windows 7 (64-bit)": {
+                              "displaytext": "Windows 7 (64-bit)",
+                              "name": "Windows 7 (64-bit)",
+                              "passwordenabled": False,
+                              "url": "http://pleaseupdateURL/dummy.vhd",
+                              "format": "VHD" ,
+                              "ostype": "Windows 7 (64-bit)",
+                              "ispublic": "true",
+                              "hypervisor": "XenServer"
+                              },
     "clusters": {
             "clustername": "Xen Cluster Vgpu",
             "clustertype": "CloudManaged",


Mime
View raw message