def test_04_resize_attached_volume_of_vm_on_remote(self): ''' Test Resize Volume Attached To Running Virtual Machine on remote ''' self.assertEqual(VirtualMachine.RUNNING, self.virtual_machine.state, "Running") volume = self.virtual_machine.attach_volume(self.apiclient, self.volume_1) shrinkOk = False if volume.size > int((self.disk_offering_20.disksize) * (1024**3)): shrinkOk = True cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id cmd.diskofferingid = self.disk_offering_20.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=volume.id, listall=True) self.assertTrue( (new_size[0].size == int( (self.disk_offering_20.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)") volume = new_size[0] shrinkOk = False if volume.size > int((self.disk_offering_100.disksize) * (1024**3)): shrinkOk = True cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id cmd.diskofferingid = self.disk_offering_100.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=volume.id, listall=True) self.assertTrue( (new_size[0].size == int( (self.disk_offering_100.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)") # return to small disk volume = new_size[0] shrinkOk = False if volume.size > int((self.disk_offerings.disksize) * (1024**3)): shrinkOk = True cmd.diskofferingid = self.disk_offerings.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=volume.id, listall=True) self.assertTrue((new_size[0].size == int( (self.disk_offerings.disksize) * (1024**3))), "Could not return to Small disk")
def _resize_volume(self, volume, new_disk_offering): cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume.id cmd.diskofferingid = new_disk_offering.id self.apiClient.resizeVolume(cmd) do_size_bytes = int(new_disk_offering.disksize * (1024**3)) retries = 3 success = False while retries > 0: retries -= 1 list_volumes_response = list_volumes(self.apiClient, id=volume.id) for vol in list_volumes_response: if vol.id == volume.id and \ int(vol.size) == do_size_bytes and \ vol.state == 'Ready': success = True if success: break else: time.sleep(10) self.assertEqual(success, True, self._volume_resize_err)
def resize_volume(cls, apiclient, volume, shrinkOk=None, disk_offering=None, size=None, maxiops=None, miniops=None): cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id if disk_offering: cmd.diskofferingid = disk_offering.id if size: cmd.size = size if maxiops: cmd.maxiops = maxiops if miniops: cmd.miniops cmd.shrinkok = shrinkOk apiclient.resizeVolume(cmd) new_size = Volume.list(apiclient, id=volume.id) volume_size = new_size[0].size return new_size[0]
def resize_volume(cls, volume, shrinkOk, disk_offering =None, size=None): cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id if disk_offering: cmd.diskofferingid = disk_offering.id disk_offering_size = int((disk_offering.disksize) * (1024**3)) if size: cmd.size = size disk_offering_size = size << 30 cmd.shrinkok = shrinkOk cfg.logger.info("resizing volume=%s to size %s" % (volume.id, disk_offering_size)) cls.testClass.apiclient.resizeVolume(cmd) new_size = Volume.list( cls.testClass.apiclient, id=volume.id ) volume_size = new_size[0].size assert_true( volume_size == disk_offering_size, "New size is not int((cls.disk_offering_20) * (1024**3)" ) return new_size[0]
def test_03_resize_root_volume_of_vm_on_remote(self): ''' Test Resize Root volume on Running Virtual Machine on remote ''' self.assertEqual(VirtualMachine.RUNNING, self.virtual_machine2.state, "Running") volume = list_volumes(self.apiclient, virtualmachineid=self.virtual_machine2.id, type="ROOT", listall=True) volume = volume[0] self.assertEqual(volume.type, 'ROOT', "Volume is not of ROOT type") shrinkOk = False if volume.size > int((self.disk_offering_20.disksize) * (1024**3)): shrinkOk = True cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id cmd.size = 20 cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=volume.id, listall=True) self.assertTrue( (new_size[0].size == int( (self.disk_offering_20.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)") volume = new_size[0] shrinkOk = False if volume.size > int((self.disk_offering_100.disksize) * (1024**3)): shrinkOk = True cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id cmd.size = 100 cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=volume.id, listall=True) self.assertTrue( (new_size[0].size == int( (self.disk_offering_100.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)")
def test_CLOUDSTACK_6181_stoppedvm_root_resize(self): """ @Desc: Test root volume resize of stopped VM @Reference: https://issues.apache.org/jira/browse/CLOUDSTACK-6181 @Steps: Step1: Deploy VM in stopped state (startvm=false), resize via 'resizeVolume', start VM. Root is new size. """ # Check whether usage server is running or not if self.hypervisor.lower() != 'kvm': self.skipTest("Test can be run only on KVM hypervisor") # deploy virtual machine in stopped state self.services["virtual_machine"]["zoneid"] = self.zone.id self.services["virtual_machine"]["template"] = self.template.id # Step3: Verifying that VM creation is successful virtual_machine = VirtualMachine.create( self.apiClient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, startvm=False) self.cleanup.append(virtual_machine) # Verify VM state self.assertEqual(virtual_machine.state, 'Stopped', "Check VM state is Stopped or not") volumes = list_volumes(self.apiClient, virtualmachineid=virtual_machine.id, type='ROOT', listall=True) self.assertIsNotNone(volumes, "root volume is not returned properly") newrootsize = (self.template.size >> 30) + 2 cmd = resizeVolume.resizeVolumeCmd() cmd.id = volumes[0].id cmd.size = newrootsize self.apiClient.resizeVolume(cmd) virtual_machine.start(self.apiClient) volumes_after_resize = list_volumes( self.apiClient, virtualmachineid=virtual_machine.id, type='ROOT', listall=True) rootvolume = volumes_after_resize[0] success = False if rootvolume is not None and rootvolume.size == (newrootsize << 30): success = True self.assertEqual(success, True, "Check if the root volume resized appropriately") return
def test_12_resize_volume_with_only_size_parameter(self): """Test resize a volume by providing only size parameter, disk offering id is not mandatory""" # Verify the size is the new size is what we wanted it to be. self.debug("Attaching volume (ID: %s) to VM (ID: %s)" % (self.volume.id, self.virtual_machine.id)) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() == "hyperv": self.skipTest("Resize Volume is unsupported on Hyper-V") # resize the data disk self.debug("Resize Volume ID: %s" % self.volume.id) cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume.id cmd.size = 20 self.apiClient.resizeVolume(cmd) count = 0 success = False while count < 3: list_volume_response = Volume.list(self.apiClient, id=self.volume.id, type='DATADISK') for vol in list_volume_response: if vol.id == self.volume.id and int( vol.size) == (20 * (1024**3)) and vol.state == 'Ready': success = True if success: break else: time.sleep(10) count += 1 self.assertEqual(success, True, "Check if the data volume resized appropriately") # start the vm if it is on xenserver if hosts[0].hypervisor == "XenServer": self.virtual_machine.start(self.apiClient) time.sleep(30) return
def test_07_resize_fail(self): """Test resize (negative) non-existent volume""" # Verify the size is the new size is what we wanted it to be. self.debug("Fail Resize Volume ID: %s" % self.volume.id) # first, an invalid id cmd = resizeVolume.resizeVolumeCmd() cmd.id = "invalid id" cmd.diskofferingid = self.services['customresizeddiskofferingid'] success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: # print str(ex) if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify invalid id is handled appropriately") # Next, we'll try an invalid disk offering id cmd.id = self.volume.id cmd.diskofferingid = "invalid id" success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify disk offering is handled appropriately") # try to resize a root disk with a disk offering, root can only be resized by size= # get root vol from created vm list_volume_response = Volume.list( self.apiClient, virtualmachineid=self.virtual_machine.id, type='ROOT', listall=True) rootvolume = list_volume_response[0] cmd.id = rootvolume.id cmd.diskofferingid = self.services['diskofferingid'] with self.assertRaises(Exception): self.apiClient.resizeVolume(cmd) return
def test_08_resize_volume(self): """Test resize a volume""" # Verify the size is the new size is what we wanted it to be. self.debug( "Attaching volume (ID: %s) to VM (ID: %s)" % ( self.volume.id, self.virtual_machine.id )) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() == "vmware": self.skipTest("Resize Volume is unsupported on VmWare") # resize the data disk self.debug("Resize Volume ID: %s" % self.volume.id) cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume.id cmd.diskofferingid = self.services['resizeddiskofferingid'] self.apiClient.resizeVolume(cmd) count = 0 success = False while count < 3: list_volume_response = Volume.list( self.apiClient, id=self.volume.id, type='DATADISK' ) for vol in list_volume_response: if vol.id == self.volume.id and vol.size == 3221225472L and vol.state == 'Ready': success = True if success: break else: time.sleep(10) count += 1
def test_07_resize_fail(self): """Test resize (negative) non-existent volume""" # Verify the size is the new size is what we wanted it to be. self.debug("Fail Resize Volume ID: %s" % self.volume.id) # first, an invalid id cmd = resizeVolume.resizeVolumeCmd() cmd.id = "invalid id" cmd.diskofferingid = self.services['resizeddiskofferingid'] success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: #print str(ex) if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify invalid id is handled appropriately") # Next, we'll try an invalid disk offering id cmd.id = self.volume.id cmd.diskofferingid = "invalid id" success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify disk offering is handled appropriately") # try to resize a root disk with a disk offering, root can only be resized by size= # get root vol from created vm list_volume_response = Volume.list( self.apiClient, virtualmachineid=self.virtual_machine.id, type='ROOT', listall=True ) rootvolume = list_volume_response[0] cmd.id = rootvolume.id cmd.diskofferingid = self.services['diskofferingid'] success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: if "Can only resize Data volumes" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify root disks cannot be resized by disk offering id") # Ok, now let's try and resize a volume that is not custom. cmd.id = self.volume.id cmd.diskofferingid = self.services['diskofferingid'] cmd.size = 4 currentSize = self.volume.size self.debug( "Attaching volume (ID: %s) to VM (ID: %s)" % ( self.volume.id, self.virtual_machine.id) ) #attach the volume self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True #stop the vm if it is on xenserver hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() == "vmware": self.skipTest("Resize Volume is unsupported on VmWare") self.apiClient.resizeVolume(cmd) count = 0 success = True while count < 10: list_volume_response = Volume.list( self.apiClient, id=self.volume.id, type='DATADISK' ) for vol in list_volume_response: if vol.id == self.volume.id and vol.size != currentSize and vol.state != "Resizing": success = False if success: break else: time.sleep(1) count += 1 self.assertEqual( success, True, "Verify the volume did not resize" ) if hosts[0].hypervisor == "XenServer": self.virtual_machine.start(self.apiClient) time.sleep(30) return
def test_08_resize_volume(self): """Test resize a volume""" # Verify the size is the new size is what we wanted it to be. self.debug("Attaching volume (ID: %s) to VM (ID: %s)" % (self.volume.id, self.virtual_machine.id)) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() in ("vmware"): self.skipTest("Resize Volume is unsupported on VmWare") # resize the data disk self.debug("Resize Volume ID: %s" % self.volume.id) self.services["disk_offering"]["disksize"] = 20 disk_offering_20_GB = DiskOffering.create( self.apiclient, self.services["disk_offering"]) self.cleanup.append(disk_offering_20_GB) cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume.id cmd.diskofferingid = disk_offering_20_GB.id self.apiClient.resizeVolume(cmd) count = 0 success = False while count < 3: list_volume_response = Volume.list(self.apiClient, id=self.volume.id, type='DATADISK') for vol in list_volume_response: if vol.id == self.volume.id and int( vol.size) == (int(disk_offering_20_GB.disksize) * (1024**3)) and vol.state == 'Ready': success = True if success: break else: time.sleep(10) count += 1 self.assertEqual(success, True, "Check if the data volume resized appropriately") can_shrink = False list_volume_response = Volume.list(self.apiClient, id=self.volume.id, type='DATADISK') storage_pool_id = [ x.storageid for x in list_volume_response if x.id == self.volume.id ][0] storage = StoragePool.list(self.apiclient, id=storage_pool_id)[0] # At present only CLVM supports shrinking volumes if storage.type.lower() == "clvm": can_shrink = True if can_shrink: self.services["disk_offering"]["disksize"] = 10 disk_offering_10_GB = DiskOffering.create( self.apiclient, self.services["disk_offering"]) self.cleanup.append(disk_offering_10_GB) cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume.id cmd.diskofferingid = disk_offering_10_GB.id cmd.shrinkok = "true" self.apiClient.resizeVolume(cmd) count = 0 success = False while count < 3: list_volume_response = Volume.list(self.apiClient, id=self.volume.id) for vol in list_volume_response: if vol.id == self.volume.id and int( vol.size) == (int(disk_offering_10_GB.disksize) * (1024**3)) and vol.state == 'Ready': success = True if success: break else: time.sleep(10) count += 1 self.assertEqual(success, True, "Check if the root volume resized appropriately") # start the vm if it is on xenserver if hosts[0].hypervisor == "XenServer": self.virtual_machine.start(self.apiClient) time.sleep(30) return
def test_07_resize_fail(self): """Test resize (negative) non-existent volume""" # Verify the size is the new size is what we wanted it to be. self.debug("Fail Resize Volume ID: %s" % self.volume.id) # first, an invalid id cmd = resizeVolume.resizeVolumeCmd() cmd.id = "invalid id" cmd.diskofferingid = self.services['customresizeddiskofferingid'] success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: # print str(ex) if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify invalid id is handled appropriately") # Next, we'll try an invalid disk offering id cmd.id = self.volume.id cmd.diskofferingid = "invalid id" success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify disk offering is handled appropriately") # try to resize a root disk with a disk offering, root can only be resized by size= # get root vol from created vm list_volume_response = Volume.list( self.apiClient, virtualmachineid=self.virtual_machine.id, type='ROOT', listall=True) rootvolume = list_volume_response[0] cmd.id = rootvolume.id cmd.diskofferingid = self.services['diskofferingid'] with self.assertRaises(Exception): self.apiClient.resizeVolume(cmd) # Ok, now let's try and resize a volume that is not custom. cmd.id = self.volume.id cmd.diskofferingid = self.services['diskofferingid'] cmd.size = 4 self.debug("Attaching volume (ID: %s) to VM (ID: %s)" % (self.volume.id, self.virtual_machine.id)) # attach the volume self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True # stop the vm if it is on xenserver hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() in ("vmware"): self.skipTest("Resize Volume is unsupported on VmWare") # Attempting to resize it should throw an exception, as we're using a non # customisable disk offering, therefore our size parameter should be ignored with self.assertRaises(Exception): self.apiClient.resizeVolume(cmd) if hosts[0].hypervisor == "XenServer": self.virtual_machine.start(self.apiClient) time.sleep(30) return
def test_03_resize_attached_volume_on_working_vm(self): ''' Test Resize Volume Attached To Running Virtual Machine ''' self.assertEqual(VirtualMachine.RUNNING, self.virtual_machine.state, "Running") volume = Volume.list( self.apiclient, id=self.volume_1.id, listall= True )[0] name = volume.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != volume.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) shrinkOk = False if volume.size > int((self.disk_offering_20.disksize) * (1024**3)): shrinkOk= True cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id cmd.diskofferingid = self.disk_offering_20.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=volume.id, listall= True ) self.assertTrue( (new_size[0].size == int((self.disk_offering_20.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)" ) volume = new_size[0] name = volume.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != volume.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) shrinkOk = False if volume.size > int((self.disk_offering_100.disksize) * (1024**3)): shrinkOk= True cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id cmd.diskofferingid = self.disk_offering_100.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=volume.id, listall= True ) self.assertTrue( (new_size[0].size == int((self.disk_offering_100.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)" ) # return to small disk volume = new_size[0] name = volume.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != volume.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) shrinkOk = False if volume.size > int((self.disk_offerings.disksize)* (1024**3)): shrinkOk= True cmd.diskofferingid = self.disk_offerings.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=volume.id, listall= True ) volume = new_size[0] name = volume.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != volume.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) self.assertTrue( (new_size[0].size == int((self.disk_offerings.disksize)*(1024**3))), "Could not return to Small disk" )
def test_05_resize_attached_volume(self): ''' Test Resize Volume Attached To Virtual Machine ''' #======================================================================= # list_volume_response = Volume.list( # self.apiclient, # id = self.volume_1.id # ) # volume =list_volume_response[0] # self.assertIsNotNone(lvolume, "Volume response is None") #======================================================================= shrinkOk = False if self.volume_1.size > int((self.disk_offering_20.disksize) * (1024**3)): shrinkOk= True cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume_1.id cmd.diskofferingid = self.disk_offering_20.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=self.volume_1.id, listall= True ) self.assertTrue( (new_size[0].size == int((self.disk_offering_20.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)" ) self.volume_1 = new_size[0] name = self.volume_1.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != self.volume_1.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) shrinkOk = False if self.volume_1.size > int((self.disk_offering_100.disksize) * (1024**3)): shrinkOk= True cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume_1.id cmd.diskofferingid = self.disk_offering_100.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=self.volume_1.id, listall= True ) self.assertTrue( (new_size[0].size == int((self.disk_offering_100.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)" ) # return to small disk self.volume_1 = new_size[0] name = self.volume_1.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != self.volume_1.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) shrinkOk = False if self.volume_1.size > int((self.disk_offerings.disksize)* (1024**3)): shrinkOk= True cmd.diskofferingid = self.disk_offerings.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=self.volume_1.id, listall= True ) name = new_size[0].path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != new_size[0].size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) self.assertTrue( (new_size[0].size == int((self.disk_offerings.disksize)*(1024**3))), "Could not return to Small disk" )
def test_08_resize_volume(self): """Test resize a volume""" # Verify the size is the new size is what we wanted it to be. self.debug("Attaching volume (ID: %s) to VM (ID: %s)" % (self.volume.id, self.virtual_machine.id)) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() == "vmware": self.skipTest("Resize Volume is unsupported on VmWare") # resize the data disk self.debug("Resize Volume ID: %s" % self.volume.id) self.services["disk_offering"]["disksize"] = 20 disk_offering_20_GB = DiskOffering.create(self.apiclient, self.services["disk_offering"]) self.cleanup.append(disk_offering_20_GB) cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume.id cmd.diskofferingid = disk_offering_20_GB.id self.apiClient.resizeVolume(cmd) count = 0 success = False while count < 3: list_volume_response = Volume.list(self.apiClient, id=self.volume.id, type="DATADISK") for vol in list_volume_response: if ( vol.id == self.volume.id and int(vol.size) == (int(disk_offering_20_GB.disksize) * (1024 ** 3)) and vol.state == "Ready" ): success = True if success: break else: time.sleep(10) count += 1 self.assertEqual(success, True, "Check if the data volume resized appropriately") self.services["disk_offering"]["disksize"] = 10 disk_offering_10_GB = DiskOffering.create(self.apiclient, self.services["disk_offering"]) self.cleanup.append(disk_offering_10_GB) cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume.id cmd.diskofferingid = disk_offering_10_GB.id cmd.shrinkok = "true" self.apiClient.resizeVolume(cmd) count = 0 success = False while count < 3: list_volume_response = Volume.list(self.apiClient, id=self.volume.id) for vol in list_volume_response: if ( vol.id == self.volume.id and int(vol.size) == (int(disk_offering_10_GB.disksize) * (1024 ** 3)) and vol.state == "Ready" ): success = True if success: break else: time.sleep(10) count += 1 self.assertEqual(success, True, "Check if the root volume resized appropriately") # start the vm if it is on xenserver if hosts[0].hypervisor == "XenServer": self.virtual_machine.start(self.apiClient) time.sleep(30) return
def test_07_resize_fail(self): """Test resize (negative) non-existent volume""" # Verify the size is the new size is what we wanted it to be. self.debug("Fail Resize Volume ID: %s" % self.volume.id) # first, an invalid id cmd = resizeVolume.resizeVolumeCmd() cmd.id = "invalid id" cmd.diskofferingid = self.services['customresizeddiskofferingid'] success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: #print str(ex) if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify invalid id is handled appropriately") # Next, we'll try an invalid disk offering id cmd.id = self.volume.id cmd.diskofferingid = "invalid id" success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify disk offering is handled appropriately") # try to resize a root disk with a disk offering, root can only be resized by size= # get root vol from created vm list_volume_response = Volume.list( self.apiClient, virtualmachineid=self.virtual_machine.id, type='ROOT', listall=True ) rootvolume = list_volume_response[0] cmd.id = rootvolume.id cmd.diskofferingid = self.services['diskofferingid'] with self.assertRaises(Exception): self.apiClient.resizeVolume(cmd) # Ok, now let's try and resize a volume that is not custom. cmd.id = self.volume.id cmd.diskofferingid = self.services['diskofferingid'] cmd.size = 4 currentSize = self.volume.size self.debug( "Attaching volume (ID: %s) to VM (ID: %s)" % ( self.volume.id, self.virtual_machine.id) ) #attach the volume self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True #stop the vm if it is on xenserver hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() in ("vmware", "hyperv"): self.skipTest("Resize Volume is unsupported on VmWare and Hyper-V") # Attempting to resize it should throw an exception, as we're using a non # customisable disk offering, therefore our size parameter should be ignored with self.assertRaises(Exception): self.apiClient.resizeVolume(cmd) if hosts[0].hypervisor == "XenServer": self.virtual_machine.start(self.apiClient) time.sleep(30) return
def test_07_resize_fail(self): """Test resize (negative) non-existent volume""" # Verify the size is the new size is what we wanted it to be. self.debug("Fail Resize Volume ID: %s" % self.volume.id) # first, an invalid id cmd = resizeVolume.resizeVolumeCmd() cmd.id = "invalid id" cmd.diskofferingid = self.services['customresizeddiskofferingid'] success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: #print str(ex) if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify invalid id is handled appropriately") # Next, we'll try an invalid disk offering id cmd.id = self.volume.id cmd.diskofferingid = "invalid id" success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify disk offering is handled appropriately") # try to resize a root disk with a disk offering, root can only be resized by size= # get root vol from created vm list_volume_response = Volume.list( self.apiClient, virtualmachineid=self.virtual_machine.id, type='ROOT', listall=True) rootvolume = list_volume_response[0] cmd.id = rootvolume.id cmd.diskofferingid = self.services['diskofferingid'] success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: if "Can only resize Data volumes" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify root disks cannot be resized by disk offering id" ) # Ok, now let's try and resize a volume that is not custom. cmd.id = self.volume.id cmd.diskofferingid = self.services['diskofferingid'] cmd.size = 4 currentSize = self.volume.size self.debug("Attaching volume (ID: %s) to VM (ID: %s)" % (self.volume.id, self.virtual_machine.id)) #attach the volume self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True #stop the vm if it is on xenserver hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() == "vmware": self.skipTest("Resize Volume is unsupported on VmWare") self.apiClient.resizeVolume(cmd) count = 0 success = True while count < 10: list_volume_response = Volume.list(self.apiClient, id=self.volume.id, type='DATADISK') for vol in list_volume_response: if vol.id == self.volume.id and vol.size != currentSize and vol.state != "Resizing": success = False if success: break else: time.sleep(1) count += 1 self.assertEqual(success, True, "Verify the volume did not resize") if hosts[0].hypervisor == "XenServer": self.virtual_machine.start(self.apiClient) time.sleep(30) return
def test_06_resize_detached_volume(self): ''' Test Resize Volume Detached To Virtual Machine ''' list_vm_volumes = Volume.list( self.apiclient, virtualmachineid = self.virtual_machine.id, id= self.volume_2.id, listall= True ) #check that the volume is not attached to VM self.assertIsNone(list_vm_volumes, "List volumes is not None") shrinkOk = False if self.volume_2.size > int((self.disk_offering_20.disksize) * (1024**3)): shrinkOk= True cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume_2.id cmd.diskofferingid = self.disk_offering_20.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=self.volume_2.id, listall= True ) self.assertTrue( (new_size[0].size == int((self.disk_offering_20.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)" ) self.volume_2 = new_size[0] name = self.volume_2.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != self.volume_2.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) shrinkOk = False if self.volume_2.size > int((self.disk_offering_100.disksize) * (1024**3)): shrinkOk= True cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume_2.id cmd.diskofferingid = self.disk_offering_100.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=self.volume_2.id, listall= True ) self.assertTrue( (new_size[0].size == int((self.disk_offering_100.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)" ) # return to small disk self.volume_2 = new_size[0] name = self.volume_2.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != self.volume_2.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) shrinkOk = False if self.volume_2.size > int((self.disk_offerings.disksize)* (1024**3)): shrinkOk= True cmd.diskofferingid = self.disk_offerings.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=self.volume_2.id, listall= True ) name = new_size[0].path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != new_size[0].size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) self.assertTrue( (new_size[0].size == int((self.disk_offerings.disksize)*(1024**3))), "Could not return to Small disk" )
class TestVolumes(cloudstackTestCase): @classmethod def setUpClass(cls): testClient = super(TestVolumes, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.services = testClient.getParsedTestDataConfig() # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype cls.disk_offering = DiskOffering.create( cls.apiclient, cls.services["disk_offering"] ) cls.resized_disk_offering = DiskOffering.create( cls.apiclient, cls.services["resized_disk_offering"] ) cls.custom_resized_disk_offering = DiskOffering.create( cls.apiclient, cls.services["resized_disk_offering"], custom=True ) template = get_template( cls.apiclient, cls.zone.id, cls.services["ostype"] ) if template == FAILED: assert False, "get_template() failed to return template with description %s" % cls.services["ostype"] cls.services["domainid"] = cls.domain.id cls.services["zoneid"] = cls.zone.id cls.services["template"] = template.id cls.services["diskofferingid"] = cls.disk_offering.id cls.services['resizeddiskofferingid'] = cls.resized_disk_offering.id cls.services['customresizeddiskofferingid'] = cls.custom_resized_disk_offering.id # Create VMs, VMs etc cls.account = Account.create( cls.apiclient, cls.services["account"], domainid=cls.domain.id ) cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offerings"] ) cls.virtual_machine = VirtualMachine.create( cls.apiclient, cls.services, accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id, mode=cls.services["mode"] ) cls.volume = Volume.create( cls.apiclient, cls.services, account=cls.account.name, domainid=cls.account.domainid ) cls._cleanup = [ cls.resized_disk_offering, cls.custom_resized_disk_offering, cls.service_offering, cls.disk_offering, cls.volume, cls.account ] @classmethod def tearDownClass(cls): try: cleanup_resources(cls.apiclient, cls._cleanup) except Exception as e: raise Exception("Warning: Exception during cleanup : %s" % e) def setUp(self): self.apiClient = self.testClient.getApiClient() self.dbclient = self.testClient.getDbConnection() self.attached = False self.cleanup = [] def tearDown(self): #Clean up, terminate the created volumes if self.attached: self.virtual_machine.detach_volume(self.apiClient, self.volume) cleanup_resources(self.apiClient, self.cleanup) return @attr(tags = ["advanced", "advancedns", "smoke", "basic", "provisioning"]) def test_02_attach_volume(self): """Attach a created Volume to a Running VM """ # Validate the following # 1. shows list of volumes # 2. "Attach Disk" pop-up box will display with list of instances # 3. disk should be attached to instance successfully self.debug( "Attaching volume (ID: %s) to VM (ID: %s)" % ( self.volume.id, self.virtual_machine.id )) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True list_volume_response = Volume.list( self.apiClient, id=self.volume.id ) self.assertEqual( isinstance(list_volume_response, list), True, "Check list response returns a valid list" ) self.assertNotEqual( list_volume_response, None, "Check if volume exists in ListVolumes" ) volume = list_volume_response[0] self.assertNotEqual( volume.virtualmachineid, None, "Check if volume state (attached) is reflected" ) try: #Format the attached volume to a known fs format_volume_to_ext3(self.virtual_machine.get_ssh_client()) except Exception as e: self.fail("SSH failed for VM: %s - %s" % (self.virtual_machine.ipaddress, e)) return @attr(tags = ["advanced", "advancedns", "smoke", "basic", "selfservice"]) def test_03_download_attached_volume(self): """Download a Volume attached to a VM """ # Validate the following # 1. download volume will fail with proper error message # "Failed - Invalid state of the volume with ID: # It should be either detached or the VM should be in stopped state self.debug("Extract attached Volume ID: %s" % self.volume.id) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True cmd = extractVolume.extractVolumeCmd() cmd.id = self.volume.id cmd.mode = "HTTP_DOWNLOAD" cmd.zoneid = self.services["zoneid"] # A proper exception should be raised; # downloading attach VM is not allowed with self.assertRaises(Exception): self.apiClient.extractVolume(cmd) @attr(tags = ["advanced", "advancedns", "smoke", "basic", "selfservice"]) def test_04_delete_attached_volume(self): """Delete a Volume attached to a VM """ # Validate the following # 1. delete volume will fail with proper error message # "Failed - Invalid state of the volume with ID: # It should be either detached or the VM should be in stopped state self.debug("Trying to delete attached Volume ID: %s" % self.volume.id) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True cmd = deleteVolume.deleteVolumeCmd() cmd.id = self.volume.id #Proper exception should be raised; deleting attach VM is not allowed #with self.assertRaises(Exception): with self.assertRaises(Exception): self.apiClient.deleteVolume(cmd) @attr(tags = ["advanced", "advancedns", "smoke", "basic", "selfservice"]) def test_05_detach_volume(self): """Detach a Volume attached to a VM """ # Validate the following # Data disk should be detached from instance and detached data disk # details should be updated properly self.debug( "Detaching volume (ID: %s) from VM (ID: %s)" % ( self.volume.id, self.virtual_machine.id )) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.virtual_machine.detach_volume(self.apiClient, self.volume) self.attached = False #Sleep to ensure the current state will reflected in other calls time.sleep(self.services["sleep"]) list_volume_response = Volume.list( self.apiClient, id=self.volume.id ) self.assertEqual( isinstance(list_volume_response, list), True, "Check list response returns a valid list" ) self.assertNotEqual( list_volume_response, None, "Check if volume exists in ListVolumes" ) volume = list_volume_response[0] self.assertEqual( volume.virtualmachineid, None, "Check if volume state (detached) is reflected" ) return @attr(tags = ["advanced", "advancedns", "smoke", "basic", "provisioning"]) def test_06_download_detached_volume(self): """Download a Volume unattached to an VM """ # Validate the following # 1. able to download the volume when its not attached to instance self.debug("Extract detached Volume ID: %s" % self.volume.id) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.virtual_machine.detach_volume(self.apiClient, self.volume) self.attached = False cmd = extractVolume.extractVolumeCmd() cmd.id = self.volume.id cmd.mode = "HTTP_DOWNLOAD" cmd.zoneid = self.services["zoneid"] extract_vol = self.apiClient.extractVolume(cmd) #Attempt to download the volume and save contents locally try: formatted_url = urllib.unquote_plus(extract_vol.url) self.debug("Attempting to download volume at url %s" % formatted_url) response = urllib.urlopen(formatted_url) self.debug("response from volume url %s" % response.getcode()) fd, path = tempfile.mkstemp() self.debug("Saving volume %s to path %s" %(self.volume.id, path)) os.close(fd) with open(path, 'wb') as fd: fd.write(response.read()) self.debug("Saved volume successfully") except Exception: self.fail( "Extract Volume Failed with invalid URL %s (vol id: %s)" \ % (extract_vol.url, self.volume.id) ) @attr(tags = ["advanced", "advancedns", "smoke", "basic", "provisioning"]) def test_07_resize_fail(self): """Test resize (negative) non-existent volume""" # Verify the size is the new size is what we wanted it to be. self.debug("Fail Resize Volume ID: %s" % self.volume.id) # first, an invalid id cmd = resizeVolume.resizeVolumeCmd() cmd.id = "invalid id" cmd.diskofferingid = self.services['resizeddiskofferingid'] success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: #print str(ex) if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify invalid id is handled appropriately") # Next, we'll try an invalid disk offering id cmd.id = self.volume.id cmd.diskofferingid = "invalid id" success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: if "invalid" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify disk offering is handled appropriately") # try to resize a root disk with a disk offering, root can only be resized by size= # get root vol from created vm list_volume_response = Volume.list( self.apiClient, virtualmachineid=self.virtual_machine.id, type='ROOT', listall=True ) rootvolume = list_volume_response[0] cmd.id = rootvolume.id cmd.diskofferingid = self.services['diskofferingid'] success = False try: self.apiClient.resizeVolume(cmd) except Exception as ex: if "Can only resize Data volumes" in str(ex): success = True self.assertEqual( success, True, "ResizeVolume - verify root disks cannot be resized by disk offering id") # Ok, now let's try and resize a volume that is not custom. cmd.id = self.volume.id cmd.diskofferingid = self.services['diskofferingid'] cmd.size = 4 currentSize = self.volume.size self.debug( "Attaching volume (ID: %s) to VM (ID: %s)" % ( self.volume.id, self.virtual_machine.id) ) #attach the volume self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True #stop the vm if it is on xenserver hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() == "vmware": self.skipTest("Resize Volume is unsupported on VmWare") self.apiClient.resizeVolume(cmd) count = 0 success = True while count < 10: list_volume_response = Volume.list( self.apiClient, id=self.volume.id, type='DATADISK' ) for vol in list_volume_response: if vol.id == self.volume.id and vol.size != currentSize and vol.state != "Resizing": success = False if success: break else: time.sleep(1) count += 1 self.assertEqual( success, True, "Verify the volume did not resize" ) if hosts[0].hypervisor == "XenServer": self.virtual_machine.start(self.apiClient) time.sleep(30) return @attr(tags = ["advanced", "advancedns", "smoke", "basic", "provisioning"]) def test_08_resize_volume(self): """Test resize a volume""" # Verify the size is the new size is what we wanted it to be. self.debug( "Attaching volume (ID: %s) to VM (ID: %s)" % ( self.volume.id, self.virtual_machine.id )) self.virtual_machine.attach_volume(self.apiClient, self.volume) self.attached = True hosts = Host.list(self.apiClient, id=self.virtual_machine.hostid) self.assertTrue(isinstance(hosts, list)) self.assertTrue(len(hosts) > 0) self.debug("Found %s host" % hosts[0].hypervisor) if hosts[0].hypervisor == "XenServer": self.virtual_machine.stop(self.apiClient) elif hosts[0].hypervisor.lower() == "vmware": self.skipTest("Resize Volume is unsupported on VmWare") # resize the data disk self.debug("Resize Volume ID: %s" % self.volume.id) cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume.id cmd.diskofferingid = self.services['resizeddiskofferingid'] self.apiClient.resizeVolume(cmd) count = 0 success = False while count < 3: list_volume_response = Volume.list( self.apiClient, id=self.volume.id, type='DATADISK' ) for vol in list_volume_response: if vol.id == self.volume.id and vol.size == 3221225472L and vol.state == 'Ready': success = True if success: break else: time.sleep(10) count += 1 self.assertEqual( success, True, "Check if the data volume resized appropriately" ) # resize the root disk self.debug("Resize Root for : %s" % self.virtual_machine.id) # get root vol from created vm list_volume_response = Volume.list( self.apiClient, virtualmachineid=self.virtual_machine.id, type='ROOT', listall=True ) rootvolume = list_volume_response[0] cmd = resizeVolume.resizeVolumeCmd() cmd.id = rootvolume.id cmd.size = 10 cmd.shrinkok = "true" self.apiClient.resizeVolume(cmd) count = 0 success = False while count < 3: list_volume_response = Volume.list( self.apiClient, id=rootvolume.id ) for vol in list_volume_response: if vol.id == rootvolume.id and vol.size == 10737418240L and vol.state == 'Ready': success = True if success: break else: time.sleep(10) count += 1
def test_02_resize_root_volume_on_working_vm(self): ''' Test Resize Root volume on Running Virtual Machine ''' self.assertEqual(VirtualMachine.RUNNING, self.virtual_machine2.state, "Running") volume = list_volumes( self.apiclient, virtualmachineid = self.virtual_machine2.id, type = "ROOT", listall = True ) volume = volume[0] name = volume.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != volume.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) self.assertEqual(volume.type, 'ROOT', "Volume is not of ROOT type") shrinkOk = False if volume.size > int((self.disk_offering_20.disksize) * (1024**3)): shrinkOk= True cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id cmd.size = 20 cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=volume.id, listall= True ) self.assertTrue( (new_size[0].size == int((self.disk_offering_20.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)" ) volume = new_size[0] name = volume.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != volume.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) shrinkOk = False if volume.size > int((self.disk_offering_100.disksize) * (1024**3)): shrinkOk= True cmd = resizeVolume.resizeVolumeCmd() cmd.id = volume.id cmd.size = 100 cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list( self.apiclient, id=volume.id, listall= True ) volume = new_size[0] name = volume.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].size != volume.size: raise Exception("Storpool volume size is not the same as CloudStack db size") except spapi.ApiError as err: raise Exception(err) self.assertTrue( (new_size[0].size == int((self.disk_offering_100.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)" )
def test_CLOUDSTACK_6181_vm_root_resize(self): """ @Desc: Test root volume resize of running VM @Reference: https://issues.apache.org/jira/browse/CLOUDSTACK-6181 @Steps: Step1: Deploy VM, resize root volume via 'resizeVolume'. """ # Check whether usage server is running or not if self.hypervisor.lower() != 'kvm': self.skipTest("Test can be run only on KVM hypervisor") # deploy virtual machine in stopped state self.services["virtual_machine"]["zoneid"] = self.zone.id self.services["virtual_machine"]["template"] = self.template.id # Step3: Verifying that VM creation is successful virtual_machine = VirtualMachine.create( self.apiClient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, ) self.cleanup.append(virtual_machine) # Verify VM state self.assertEqual( virtual_machine.state, 'Running', "Check VM state is Running or not" ) volumes = list_volumes( self.apiClient, virtualmachineid=virtual_machine.id, type='ROOT', listall=True ) self.assertIsNotNone(volumes, "root volume is not returned properly") newrootsize = (self.template.size >> 30) + 2 cmd = resizeVolume.resizeVolumeCmd() cmd.id = volumes[0].id cmd.size = newrootsize self.apiClient.resizeVolume(cmd) volumes_after_resize = list_volumes( self.apiClient, virtualmachineid=virtual_machine.id, type='ROOT', listall=True ) rootvolume = volumes_after_resize[0] success = False if rootvolume is not None and rootvolume.size == (newrootsize << 30): success = True self.assertEqual( success, True, "Check if the root volume resized appropriately" ) return
def test_03_resize_attached_volume(self): ''' Test Resize Volume Attached To Virtual Machine ''' #======================================================================= # list_volume_response = Volume.list( # self.apiclient, # id = self.volume_1.id # ) # volume =list_volume_response[0] # self.assertIsNotNone(lvolume, "Volume response is None") #======================================================================= shrinkOk = False if self.volume_1.size > int( (self.disk_offering_20.disksize) * (1024**3)): shrinkOk = True cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume_1.id cmd.diskofferingid = self.disk_offering_20.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=self.volume_1.id) self.assertTrue( (new_size[0].size == int( (self.disk_offering_20.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)") self.volume_1 = new_size[0] shrinkOk = False if self.volume_1.size > int( (self.disk_offering_100.disksize) * (1024**3)): shrinkOk = True cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume_1.id cmd.diskofferingid = self.disk_offering_100.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=self.volume_1.id) self.assertTrue( (new_size[0].size == int( (self.disk_offering_100.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)") # return to small disk self.volume_1 = new_size[0] shrinkOk = False if self.volume_1.size > int( (self.disk_offerings.disksize) * (1024**3)): shrinkOk = True cmd.diskofferingid = self.disk_offerings.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=self.volume_1.id) self.assertTrue((new_size[0].size == int( (self.disk_offerings.disksize) * (1024**3))), "Could not return to Small disk")
def test_04_resize_detached_volume(self): ''' Test Resize Volume Detached To Virtual Machine ''' list_vm_volumes = Volume.list(self.apiclient, virtualmachineid=self.virtual_machine.id, id=self.volume_2.id) #check that the volume is not attached to VM self.assertIsNone(list_vm_volumes, "List volumes is not None") shrinkOk = False if self.volume_2.size > int( (self.disk_offering_20.disksize) * (1024**3)): shrinkOk = True cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume_2.id cmd.diskofferingid = self.disk_offering_20.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=self.volume_2.id) self.assertTrue( (new_size[0].size == int( (self.disk_offering_20.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)") self.volume_2 = new_size[0] shrinkOk = False if self.volume_2.size > int( (self.disk_offering_100.disksize) * (1024**3)): shrinkOk = True cmd = resizeVolume.resizeVolumeCmd() cmd.id = self.volume_2.id cmd.diskofferingid = self.disk_offering_100.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=self.volume_2.id) self.assertTrue( (new_size[0].size == int( (self.disk_offering_100.disksize) * (1024**3))), "New size is not int((self.disk_offering_20) * (1024**3)") # return to small disk self.volume_2 = new_size[0] shrinkOk = False if self.volume_2.size > int( (self.disk_offerings.disksize) * (1024**3)): shrinkOk = True cmd.diskofferingid = self.disk_offerings.id cmd.shrinkok = shrinkOk self.apiclient.resizeVolume(cmd) new_size = Volume.list(self.apiclient, id=self.volume_2.id) self.assertTrue((new_size[0].size == int( (self.disk_offerings.disksize) * (1024**3))), "Could not return to Small disk")