def create_custom_disk(cls, apiclient, services, size = None, miniops = None, maxiops =None, diskofferingid=None, zoneid=None, account=None, domainid=None, snapshotid=None):
"""Create Volume from Custom disk offering"""
cmd = createVolume.createVolumeCmd()
cmd.name = services["diskname"]
if diskofferingid:
cmd.diskofferingid = diskofferingid
if size:
cmd.size = size
if miniops:
cmd.miniops = miniops
if maxiops:
cmd.maxiops = maxiops
if account:
cmd.account = account
if domainid:
cmd.domainid = domainid
if snapshotid:
cmd.snapshotid = snapshotid
cmd.zoneid = zoneid
return Volume(apiclient.createVolume(cmd).__dict__)
def create_volume(self, apiclient, zoneid=None, snapshotid=None):
"""Create Volume"""
cmd = createVolume.createVolumeCmd()
cmd.name = "Test"
if zoneid:
cmd.zoneid = zoneid
if snapshotid:
cmd.snapshotid = snapshotid
return Volume(apiclient.createVolume(cmd).__dict__)
def runner(self, provisioning_type):
self.services["disk_offering"]['provisioningtype'] = provisioning_type
self.services["small"]['size'] = "1"
disk_offering = DiskOffering.create(
self.apiclient,
self.services["disk_offering"],
custom=True,
)
self.cleanup.append(disk_offering)
self.debug("Created Disk offering with ID: %s" % disk_offering.id)
self.services["service_offerings"]["small"][
"provisioningtype"] = provisioning_type
small_offering = ServiceOffering.create(
self.apiclient, self.services["service_offerings"]["small"])
self.cleanup.append(small_offering)
self.debug("Created service offering with ID: %s" % small_offering.id)
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["small"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=small_offering.id,
diskofferingid=disk_offering.id,
mode=self.services["mode"])
self.debug("Created virtual machine with ID: %s" % virtual_machine.id)
volumes = Volume.list(self.apiclient,
virtualMachineId=virtual_machine.id,
listAll='true')
for volume in volumes:
if volume["type"] == "DATADISK":
VirtualMachine.detach_volume(virtual_machine, self.apiclient,
volume)
currentVolume = Volume({})
currentVolume.id = volume.id
Volume.resize(currentVolume, self.apiclient, size='2')
VirtualMachine.attach_volume(virtual_machine, self.apiclient,
volume)
def create_from_snapshot(cls, apiclient, snapshot_id, services,
account=None, domainid=None):
"""Create volume from snapshot"""
cmd = createVolume.createVolumeCmd()
cmd.isAsync = "false"
cmd.name = "-".join([services["diskname"], random_gen()])
cmd.snapshotid = snapshot_id
cmd.zoneid = services["zoneid"]
if "size" in services:
cmd.size = services["size"]
if services["ispublic"]:
cmd.ispublic = services["ispublic"]
else:
cmd.ispublic = False
if account:
cmd.account = account
else:
cmd.account = services["account"]
if domainid:
cmd.domainid = domainid
else:
cmd.domainid = services["domainid"]
return Volume(apiclient.createVolume(cmd).__dict__)
def test_06_create_volume_from_non_native_snapshot(self):
old_supports_resign = self.supports_resign
self._set_supports_resign(False)
primary_storage_db_id = self._get_cs_storage_pool_db_id(
self.primary_storage)
virtual_machine = VirtualMachine.create(
self.apiClient,
self.testdata[TestData.virtualMachine],
accountid=self.account.name,
zoneid=self.zone.id,
serviceofferingid=self.compute_offering.id,
templateid=self.template.id,
domainid=self.domain.id,
startvm=True)
self.assertEqual(virtual_machine.state.lower(), "running",
TestSnapshots._vm_not_in_running_state_err_msg)
list_volumes_response = list_volumes(
self.apiClient, virtualmachineid=virtual_machine.id, listall=True)
self._check_list(
list_volumes_response, 1,
TestSnapshots._should_only_be_one_volume_in_list_err_msg)
vm_1_root_volume = list_volumes_response[0]
dt_volume_1 = self._get_dt_volume_for_cs_volume(vm_1_root_volume)
self.assertNotEqual(dt_volume_1, None,
TestSnapshots._should_be_a_valid_volume_err)
vol_snap_a = self._create_and_test_non_native_snapshot(
vm_1_root_volume.id, primary_storage_db_id, 1,
TestSnapshots._should_only_be_one_snapshot_in_list_err_msg)
services = {
"diskname": "Vol-1",
"zoneid": self.testdata[TestData.zoneId],
"size": 100,
"ispublic": True
}
volume_created_from_snapshot = Volume.create_from_snapshot(
self.apiClient,
vol_snap_a.id,
services,
account=self.account.name,
domainid=self.domain.id)
dt_snapshot_volume = self._get_dt_volume_for_cs_volume(
volume_created_from_snapshot)
self.assertNotEqual(dt_snapshot_volume, None,
TestSnapshots._should_be_a_valid_volume_err)
volume_created_from_snapshot = virtual_machine.attach_volume(
self.apiClient, volume_created_from_snapshot)
self._delete_and_test_non_native_snapshot(vol_snap_a)
virtual_machine.delete(self.apiClient, True)
list_volumes_response = list_volumes(self.apiClient, listall=True)
self._check_list(
list_volumes_response, 1,
TestSnapshots._should_only_be_one_volume_in_list_err_msg)
data_volume = list_volumes_response[0]
data_volume_2 = Volume(data_volume.__dict__)
data_volume_2.delete(self.apiClient)
self._get_dt_volume_for_cs_volume(data_volume, should_exist=False)
self._set_supports_resign(old_supports_resign)
def test_08_increase_volume_size_within_account_limit(self):
"""Test increasing volume size within the account limit and verify
primary storage usage
# Validate the following
# 1. Create a domain and its admin account
# 2. Set account primary storage limit well beyond (20 GB volume +
# template size of VM)
# 3. Deploy a VM without any disk offering (only root disk)
#
# 4. Increase (resize) the volume to 20 GB
# 6. Resize operation should be successful and primary storage count
# for account should be updated successfully"""
# Setting up account and domain hierarchy
result = self.setupAccounts()
self.assertEqual(result[0], PASS, result[1])
apiclient = self.testClient.getUserApiClient(
UserName=self.parentd_admin.name,
DomainName=self.parentd_admin.domain)
self.assertNotEqual(
apiclient, FAILED, "Failed to get api client\
of account: %s" % self.parentd_admin.name)
templateSize = (self.template.size / (1024**3))
accountLimit = (templateSize + 20)
response = self.updateResourceLimits(accountLimit=accountLimit)
self.assertEqual(response[0], PASS, response[1])
try:
if self.updateclone:
self.virtual_machine = VirtualMachine.create(
apiclient,
self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.services_offering_vmware.id)
else:
self.virtual_machine = VirtualMachine.create(
apiclient,
self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.service_offering.id)
list_vms = VirtualMachine.list(apiclient,
id=self.virtual_machine.id)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s" \
% self.virtual_machine.id
)
self.assertEqual(isinstance(list_vms, list), True,
"List VM response was not a valid list")
self.cleanup.append(self.virtual_machine)
self.cleanup.reverse()
vm = list_vms[0]
list_volume_response = Volume.list(
apiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall='True')
res = validateList(list_volume_response)
self.assertNotEqual(
res[2], INVALID_INPUT,
"listVolumes returned invalid object in response")
if vm.state == "Running" and vm.hypervisor.lower() == "xenserver":
self.virtual_machine.stop(self.apiclient)
time.sleep(self.services["sleep"])
rootvolume = list_volume_response[0]
# converting json response to Volume Object
rootvol = Volume(rootvolume.__dict__)
newsize = (rootvolume.size >> 30) + 20
if rootvolume is not None:
try:
rootvol.resize(apiclient, size=newsize)
response = matchResourceCount(
self.apiclient,
newsize,
RESOURCE_PRIMARY_STORAGE,
accountid=self.parentd_admin.id)
if response[0] == FAIL:
raise Exception(response[1])
except Exception as e:
self.fail("Failed with exception: %s" % e)
except Exception as e:
raise Exception("Warning: Exception while checking primary"
" storage capacity after root "
"volume resize : %s" % e)
return
def test_07_usage_events_after_rootvolume_resized_(self):
"""Test check usage events after root volume resize
# Validate the following
# 1. Deploy a VM without any disk offering (only root disk)
# 2. Perform(resize) of the root volume
# 3. Check the corresponding usage events
"""
# deploy a vm
try:
if self.updateclone:
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.services_offering_vmware.id,
mode=self.zone.networktype)
else:
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype)
# listVirtual macine
time.sleep(self.services["sleep"])
list_vms = VirtualMachine.list(self.apiclient,
id=self.virtual_machine.id)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s" %
self.virtual_machine.id)
res = validateList(list_vms)
self.assertNotEqual(res[2], INVALID_INPUT, "Invalid list response")
self.cleanup.append(self.virtual_machine)
vm = list_vms[0]
self.assertEqual(vm.id, self.virtual_machine.id,
"Virtual Machine ids do not match")
# get root vol from created vm, verify it is correct size
list_volume_response = Volume.list(
self.apiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall='True')
res = validateList(list_volume_response)
self.assertNotEqual(
res[2], INVALID_INPUT,
"listVolumes returned invalid object in response")
if vm.state == "Running" and vm.hypervisor.lower() == "xenserver":
self.virtual_machine.stop(self.apiclient)
time.sleep(self.services["sleep"])
rootvolume = list_volume_response[0]
# converting json response to Volume Object
rootvol = Volume(rootvolume.__dict__)
newsize = (rootvolume.size >> 30) + 2
success = False
if rootvolume is not None:
try:
rootvol.resize(self.apiclient, size=newsize)
qresultset = self.dbclient.execute(
"select id from account where uuid = '%s';" %
self.parentd_admin.id)
res = validateList(qresultset)
self.assertNotEqual(res[2], INVALID_INPUT,
"Check DB Query result set")
qresult = qresultset[0]
account_id = qresult[0]
self.debug("select type,size from usage_event"
" where account_id = '%s';" % account_id)
qresultsize = self.dbclient.execute(
"select size from usage_event where account_id = '%s' "
"and type='VOLUME.RESIZE' ORDER BY ID DESC LIMIT 1;" %
account_id)
res = validateList(qresultsize)
self.assertNotEqual(res[2], INVALID_INPUT,
"Check DB Query result set")
qresult = int(qresultsize[0][0])
self.debug("Query result: %s" % qresult)
self.assertEqual(
qresult, (newsize * 1024 * 1024 * 1024),
"Usage event not logged properly with right volume"
" size please check ")
except Exception as e:
raise Exception("Warning: Exception while checking usage "
"event for the root volume resize : %s" %
e)
except Exception as e:
raise Exception(
"Warning: Exception performing "
"usage_events_after_rootvolume_resized Test : %s" % e)
def test_06_resized_rootvolume_with_lessvalue(self):
"""Test resize root volume with less than original volume size
# Validate the following
# 1. Deploy a VM without any disk offering (only root disk)
# 2. Perform(resize) of the root volume with less
than current root volume
# 3. Check for proper error message
"""
# deploy a vm
try:
if self.updateclone:
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.services_offering_vmware.id,
mode=self.zone.networktype)
else:
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.parentd_admin.name,
domainid=self.parent_domain.id,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype)
# listVirtual macine
time.sleep(self.services["sleep"])
list_vms = VirtualMachine.list(self.apiclient,
id=self.virtual_machine.id)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s" \
% self.virtual_machine.id
)
res = validateList(list_vms)
self.assertNotEqual(res[2], INVALID_INPUT, "Invalid list response")
self.cleanup.append(self.virtual_machine)
vm = list_vms[0]
self.assertEqual(vm.id, self.virtual_machine.id,
"Virtual Machine ids do not match")
# get root vol from created vm, verify it is correct size
list_volume_response = Volume.list(
self.apiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall='True')
res = validateList(list_volume_response)
self.assertNotEqual(
res[2], INVALID_INPUT,
"listVolumes returned invalid object in response")
if vm.state == "Running" and vm.hypervisor.lower() == "xenserver":
self.virtual_machine.stop(self.apiclient)
time.sleep(self.services["sleep"])
rootvolume = list_volume_response[0]
# converting json response to Volume Object
rootvol = Volume(rootvolume.__dict__)
newsize = (rootvolume.size >> 30) - 1
success = False
if rootvolume is not None and 'vmware' in vm.hypervisor.lower():
try:
rootvol.resize(self.apiclient, size=newsize)
except Exception as e:
assert "Shrink operation on ROOT volume not supported" \
in e.message, \
"TestCase Failed,able to resize root volume or error message is not matched"
except Exception as e:
raise Exception("Warning: Exception "
"during executing test resize"
" volume with less value : %s" % e)
if rootvol is not None and 'kvm' or 'xenserver' in vm.hypervisor.lower(
):
rootvol.resize(self.apiclient, size=newsize)
def chk_volume_resize(self, apiclient, vm):
self.assertEqual(vm.state, "Running", msg="VM is not in Running state")
# get root vol from created vm, verify its size
list_volume_response = Volume.list(apiclient,
virtualmachineid=vm.id,
type='ROOT',
listall='True')
rootvolume = list_volume_response[0]
if vm.state == "Running" and vm.hypervisor.lower() == "xenserver":
self.virtual_machine.stop(apiclient)
time.sleep(self.services["sleep"])
if vm.hypervisor.lower() == "vmware":
rootdiskcontroller = self.getDiskController(vm)
if rootdiskcontroller != "scsi":
raise Exception(
"root volume resize only supported on scsi disk ,"
"please check rootdiskcontroller type")
rootvolobj = Volume(rootvolume.__dict__)
newsize = (rootvolume.size >> 30) + 2
success = False
if rootvolume is not None:
try:
rootvolobj.resize(apiclient, size=newsize)
if vm.hypervisor.lower() == "xenserver":
self.virtual_machine.start(apiclient)
time.sleep(self.services["sleep"])
ssh = SshClient(self.virtual_machine.ssh_ip, 22, "root",
"password")
newsizeinbytes = newsize * 1024 * 1024 * 1024
if vm.hypervisor.lower() == "xenserver":
volume_name = "/dev/xvd" + \
chr(ord('a') +
int(
list_volume_response[0].deviceid))
self.debug(" Using XenServer"
" volume_name: %s" % volume_name)
ret = checkVolumeSize(ssh_handle=ssh,
volume_name=volume_name,
size_to_verify=newsizeinbytes)
success = True
elif vm.hypervisor.lower() == "kvm":
volume_name = "/dev/vd" + chr(
ord('a') + int(list_volume_response[0].deviceid))
self.debug(" Using KVM volume_name:" " %s" % volume_name)
ret = checkVolumeSize(ssh_handle=ssh,
volume_name=volume_name,
size_to_verify=newsizeinbytes)
success = True
elif vm.hypervisor.lower() == "vmware":
ret = checkVolumeSize(ssh_handle=ssh,
volume_name="/dev/sdb",
size_to_verify=newsizeinbytes)
success = True
self.debug(" Volume Size Expected %s "
" Actual :%s" % (newsizeinbytes, ret[1]))
except Exception as e:
# need to write the rootdisk controller code.
if vm.hypervisor == "vmware" and rootdiskcontroller == "ide":
assert "Found unsupported root disk " \
"controller :ide" in e.message, \
"able to resize ide root volume Testcase failed"
else:
raise Exception("fail to resize the volume: %s" % e)
else:
self.debug("hypervisor %s unsupported for test "
", verifying it errors properly" % self.hypervisor)
success = False
return success
def test_01_upload_and_download_snapshot(self):
list_volumes_response = list_volumes(
self.apiClient,
virtualmachineid=self.virtual_machine.id,
listall=True)
sf_util.check_list(list_volumes_response, 1, self,
"There should only be one volume in this list.")
vm_root_volume = list_volumes_response[0]
### Perform tests related to uploading a QCOW2 file to secondary storage and then moving it to managed storage
volume_name = "Volume-A"
services = {"format": TestData.file_type, "diskname": volume_name}
uploaded_volume = Volume.upload(self.apiClient,
services,
self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
url=TestData.volume_url,
diskofferingid=self.disk_offering.id)
self._wait_for_volume_state(uploaded_volume.id, "Uploaded")
uploaded_volume_id = sf_util.get_cs_volume_db_id(
self.dbConnection, uploaded_volume)
result = self._get_volume_store_ref_row(uploaded_volume_id)
self.assertEqual(len(result), 1, TestUploadDownload.assertText)
install_path = self._get_install_path(
result[0][TestData.install_path_index])
self._verify_uploaded_volume_present(install_path)
uploaded_volume = self.virtual_machine.attach_volume(
self.apiClient, uploaded_volume)
uploaded_volume = sf_util.check_and_get_cs_volume(
self, uploaded_volume.id, volume_name, self)
sf_account_id = sf_util.get_sf_account_id(
self.cs_api, self.account.id, self.primary_storage.id, self,
"The SolidFire account ID should be a non-zero integer.")
sf_volumes = sf_util.get_active_sf_volumes(self.sfe, sf_account_id)
self.assertNotEqual(
len(sf_volumes), 0,
"The length of the response for the SolidFire-volume query should not be zero."
)
sf_volume = sf_util.check_and_get_sf_volume(sf_volumes,
uploaded_volume.name, self)
sf_volume_size = sf_util.get_volume_size_with_hsr(
self.cs_api, uploaded_volume, self)
sf_util.check_size_and_iops(sf_volume, uploaded_volume, sf_volume_size,
self)
sf_vag_id = sf_util.get_vag_id(self.cs_api, self.cluster.id,
self.primary_storage.id, self)
sf_util.check_vag(sf_volume, sf_vag_id, self)
result = self._get_volume_store_ref_row(uploaded_volume_id)
self.assertEqual(len(result), 0, TestUploadDownload.assertText2)
self._verify_uploaded_volume_not_present(install_path)
### Perform tests related to extracting the contents of a volume on managed storage to a QCOW2 file
### and downloading the file
try:
# for data disk
Volume.extract(self.apiClient, uploaded_volume.id, self.zone.id,
TestData.download_mode)
raise Exception(
"The volume extraction (for the data disk) did not fail (as expected)."
)
except Exception as e:
if TestUploadDownload.errorText in str(e):
pass
else:
raise
vm_root_volume_id = sf_util.get_cs_volume_db_id(
self.dbConnection, vm_root_volume)
try:
# for root disk
Volume.extract(self.apiClient, vm_root_volume.id, self.zone.id,
TestData.download_mode)
raise Exception(
"The volume extraction (for the root disk) did not fail (as expected)."
)
except Exception as e:
if TestUploadDownload.errorText in str(e):
pass
else:
raise
self.virtual_machine.stop(self.apiClient)
self._extract_volume_and_verify(
uploaded_volume_id,
"Unable to locate the extracted file for the data disk (attached)")
result = self._get_volume_store_ref_row(vm_root_volume_id)
self.assertEqual(len(result), 0, TestUploadDownload.assertText2)
self._extract_volume_and_verify(
vm_root_volume_id,
"Unable to locate the extracted file for the root disk")
uploaded_volume = self.virtual_machine.detach_volume(
self.apiClient, uploaded_volume)
self._extract_volume_and_verify(
uploaded_volume_id,
"Unable to locate the extracted file for the data disk (detached)")
uploaded_volume = Volume(uploaded_volume.__dict__)
uploaded_volume.delete(self.apiClient)
