def tearDown(self):
try:
for storagePool in self.pools:
StoragePool.update(self.apiclient, id=storagePool.id, tags="")
if hasattr(self, "data_volume_created"):
data_volumes_list = Volume.list(
self.userapiclient,
id=self.data_volume_created.id,
virtualmachineid=self.vm.id
)
if data_volumes_list:
self.vm.detach_volume(
self.userapiclient,
data_volumes_list[0]
)
status = validateList(data_volumes_list)
self.assertEqual(
status[0],
PASS,
"DATA Volume List Validation Failed")
cleanup_resources(self.apiclient, self.cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def tearDownClass(cls):
try:
# Cleanup resources used
if cls.updateclone:
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="false",storageid=cls.storageID)
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="false")
Configurations.update(cls.api_client,
"vmware.root.disk.controller",
value=cls.defaultdiskcontroller)
StoragePool.update(cls.api_client, id=cls.storageID,
tags="")
cls.restartServer()
#Giving 30 seconds to management to warm-up,
#Experienced failures when trying to deploy a VM exactly when management came up
time.sleep(30)
cleanup_resources(cls.api_client, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def test13_update_primary_storage_capacityIops_to_zero(self):
updatedIops = 0
StoragePool.update(self.apiClient,
id=self.primary_storage_id,
capacityiops=updatedIops,
tags=self.primary_tag)
# Verify in cloudsatck
storage_pools_response = list_storage_pools(
self.apiClient, clusterid=self.cluster.id)
for data in storage_pools_response:
if data.id == self.primary_storage_id:
storage_pool = data
self.assertEqual(
storage_pool.capacityiops, updatedIops,
"Primary storage capacityiops not updated")
# Verify in datera
datera_primary_storage_name = "cloudstack-" + self.primary_storage_id
for instance in self.datera_api.app_instances.list():
if instance['name'] == datera_primary_storage_name:
datera_instance = instance
app_instance_response_iops = (
datera_instance['storage_instances']
['storage-1']['volumes']['volume-1']['performance_policy']
['total_iops_max'])
self.assertEqual(
app_instance_response_iops, updatedIops,
"app-instance capacityiops not updated")
StoragePool.delete(self.primary_storage, self.apiClient)
self.cleanup = []
def cleanUpCloudStack(cls):
cfg.logger.info("Cleaning up after the whole test run")
try:
cls.nfs_storage_pool = StoragePool.enableMaintenance(
cls.apiclient, cls.nfs_storage_pool.id)
cls.storage_pool = StoragePool.update(cls.apiclient,
id=cls.primary_storage.id,
tags=["ssd"])
cls.storage_pool2 = StoragePool.update(cls.apiclient,
id=cls.primary_storage2.id,
tags=["ssd2"])
# Cleanup resources used
cleanup_resources(cls.apiclient, cls._cleanup)
except Exception as e:
cfg.logger.info("cleanup_resources failed: %s", e)
os.killpg(cls.mvn_proc_grp, signal.SIGTERM)
raise Exception("Warning: Exception during cleanup : %s" % e)
cfg.logger.info("Stopping CloudStack")
os.killpg(cls.mvn_proc_grp, signal.SIGTERM)
time.sleep(30)
return
def test_02_migrate_vm_from_ceph_to_storpool_live(self):
"""
Migrate VMs/Volumes live
"""
self.storage_pool = StoragePool.update(self.apiclient,
id=self.storage_pool.id,
tags=["ssd, ceph"])
random_data = self.writeToFile(self.vm2)
cmd = listHosts.listHostsCmd()
cmd.type = "Routing"
cmd.state = "Up"
cmd.zoneid = self.zone.id
hosts = self.apiclient.listHosts(cmd)
destinationHost = self.helper.getDestinationHost(
self.vm2.hostid, hosts)
vol_pool_map = {}
volumes = list_volumes(self.apiclient,
virtualmachineid=self.vm2.id,
listall=True)
for v in volumes:
vol_pool_map[v.id] = self.storage_pool.id
# Migrate the vm2
print(vol_pool_map)
vm2 = self.vm2.migrate_vm_with_volume(self.apiclient,
hostid=destinationHost.id,
migrateto=vol_pool_map)
self.checkFileAndContentExists(self.vm2, random_data)
self.storage_pool = StoragePool.update(self.apiclient,
id=self.storage_pool.id,
tags=["ssd"])
def test13_update_primary_storage_capacityIops_to_zero(self):
updatedIops = 0
StoragePool.update(self.apiClient,
id=self.primary_storage_id,
capacityiops=updatedIops,
tags=self.primary_tag)
# Verify in cloudsatck
storage_pools_response = list_storage_pools(self.apiClient,
clusterid=self.cluster.id)
for data in storage_pools_response:
if data.id == self.primary_storage_id:
storage_pool = data
self.assertEqual(storage_pool.capacityiops, updatedIops,
"Primary storage capacityiops not updated")
# Verify in datera
datera_primary_storage_name = "cloudstack-" + self.primary_storage_id
for instance in self.datera_api.app_instances.list():
if instance['name'] == datera_primary_storage_name:
datera_instance = instance
app_instance_response_iops = (
datera_instance['storage_instances']['storage-1']['volumes']
['volume-1']['performance_policy']['total_iops_max'])
self.assertEqual(app_instance_response_iops, updatedIops,
"app-instance capacityiops not updated")
StoragePool.delete(self.primary_storage, self.apiClient)
self.cleanup = []
def test_01_attach_datadisk_to_vm_on_zwps(self):
""" Attach Data Disk To VM on ZWPS
1. Check if zwps storage pool exists.
2. Adding tag to zone wide primary storage
3. Launch a VM on ZWPS
4. Attach data disk to vm which is on zwps.
5. Verify disk is attached.
"""
# Step 1
if len(
list(storagePool for storagePool in self.pools
if storagePool.scope == "ZONE")) < 1:
self.skipTest("There must be at least one zone wide \
storage pools available in the setup")
# Adding tags to Storage Pools
zone_no = 1
for storagePool in self.pools:
if storagePool.scope == "ZONE":
StoragePool.update(self.apiclient,
id=storagePool.id,
tags=[ZONETAG1[:-1] + repr(zone_no)])
zone_no += 1
self.vm = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_zone1.id,
zoneid=self.zone.id)
self.data_volume_created = Volume.create(
self.userapiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id)
self.cleanup.append(self.data_volume_created)
# Step 2
self.vm.attach_volume(self.userapiclient, self.data_volume_created)
data_volumes_list = Volume.list(self.userapiclient,
id=self.data_volume_created.id,
virtualmachineid=self.vm.id)
data_volume = data_volumes_list[0]
status = validateList(data_volume)
# Step 3
self.assertEqual(status[0], PASS,
"Check: Data if Disk is attached to VM")
return
def test_11_migrate_volume_and_change_offering(self):
# Validates the following
#
# 1. Creates a new Volume with a small disk offering
#
# 2. Migrates the Volume to another primary storage and changes the offering
#
# 3. Verifies the Volume has new offering when migrated to the new storage.
small_offering = list_disk_offering(self.apiclient, name="Small")[0]
large_offering = list_disk_offering(self.apiclient, name="Large")[0]
volume = Volume.create(self.apiClient,
self.services,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=small_offering.id)
self.debug("Created a small volume: %s" % volume.id)
self.virtual_machine.attach_volume(self.apiclient, volume=volume)
if self.virtual_machine.hypervisor == "KVM":
self.virtual_machine.stop(self.apiclient)
pools = StoragePool.listForMigration(self.apiclient, id=volume.id)
pool = None
if pools and len(pools) > 0:
pool = pools[0]
else:
raise self.skipTest(
"Not enough storage pools found, skipping test")
if hasattr(pool, 'tags'):
StoragePool.update(self.apiclient, id=pool.id, tags="")
self.debug("Migrating Volume-ID: %s to Pool: %s" %
(volume.id, pool.id))
livemigrate = False
if self.virtual_machine.hypervisor.lower(
) == "vmware" or self.virtual_machine.hypervisor.lower(
) == 'xenserver':
livemigrate = True
Volume.migrate(self.apiclient,
volumeid=volume.id,
storageid=pool.id,
newdiskofferingid=large_offering.id,
livemigrate=livemigrate)
if self.virtual_machine.hypervisor == "KVM":
self.virtual_machine.start(self.apiclient)
migrated_vol = Volume.list(self.apiclient, id=volume.id)[0]
self.assertEqual(migrated_vol.diskofferingname, large_offering.name,
"Offering name did not match with the new one ")
return
def tearDown(self):
try:
for storagePool in self.pools:
StoragePool.update(self.apiclient, id=storagePool.id, tags="")
cleanup_resources(self.apiclient, self.cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def tearDown(self):
try:
for storagePool in self.pools:
StoragePool.update(self.apiclient, id=storagePool.id, tags="")
cleanup_resources(self.apiclient, self.cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def test07_update_primary_storage_capacityBytes(self):
updatedDiskSize = self.testdata[TestData.newCapacityBytes]
StoragePool.update(self.apiClient,
id=self.primary_storage_id,
capacitybytes=updatedDiskSize,
tags=self.primary_tag)
# Verify in cloudsatck
storage_pools_response = list_storage_pools(
self.apiClient, clusterid=self.cluster.id)
for data in storage_pools_response:
if data.id == self.primary_storage_id:
storage_pool = data
self.assertEqual(
storage_pool.disksizetotal, updatedDiskSize,
"Primary storage not updated")
# Verify in datera
datera_primary_storage_name = "cloudstack-" + self.primary_storage_id
for instance in self.datera_api.app_instances.list():
if instance['name'] == datera_primary_storage_name:
datera_instance = instance
app_instance_response_disk_size = (
datera_instance['storage_instances']
['storage-1']['volumes']['volume-1']['size'] * 1073741824)
self.assertEqual(
app_instance_response_disk_size, updatedDiskSize,
"app-instance not updated")
# Verify in xenserver
#for key, value in self.xen_session.xenapi.SR.get_all_records().items():
# if value['name_description'] == self.primary_storage_id:
# xen_sr = value
#Uncomment after xen fix
#print xen_sr
#print xen_sr['physical_size'], updatedDiskSize
#self.assertEqual(
# int(xen_sr['physical_size']) + 12582912, updatedDiskSize,
# "Xen server physical storage not updated")
StoragePool.delete(self.primary_storage, self.apiClient)
self.cleanup = []
def test07_update_primary_storage_capacityBytes(self):
updatedDiskSize = self.testdata[TestData.newCapacityBytes]
StoragePool.update(self.apiClient,
id=self.primary_storage_id,
capacitybytes=updatedDiskSize,
tags=self.primary_tag)
# Verify in cloudsatck
storage_pools_response = list_storage_pools(self.apiClient,
clusterid=self.cluster.id)
for data in storage_pools_response:
if data.id == self.primary_storage_id:
storage_pool = data
self.assertEqual(storage_pool.disksizetotal, updatedDiskSize,
"Primary storage not updated")
# Verify in datera
datera_primary_storage_name = "cloudstack-" + self.primary_storage_id
for instance in self.datera_api.app_instances.list():
if instance['name'] == datera_primary_storage_name:
datera_instance = instance
app_instance_response_disk_size = (
datera_instance['storage_instances']['storage-1']['volumes']
['volume-1']['size'] * 1073741824)
self.assertEqual(app_instance_response_disk_size, updatedDiskSize,
"app-instance not updated")
# Verify in xenserver
#for key, value in self.xen_session.xenapi.SR.get_all_records().items():
# if value['name_description'] == self.primary_storage_id:
# xen_sr = value
#Uncomment after xen fix
#print xen_sr
#print xen_sr['physical_size'], updatedDiskSize
#self.assertEqual(
# int(xen_sr['physical_size']) + 12582912, updatedDiskSize,
# "Xen server physical storage not updated")
StoragePool.delete(self.primary_storage, self.apiClient)
self.cleanup = []
def tearDownClass(cls):
try:
# Cleanup resources used
if cls.updateclone:
Configurations.update(cls.api_client,
"vmware.root.disk.controller",
value=cls.defaultdiskcontroller)
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="false")
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="false", storageid=cls.storageID)
if cls.storageID:
StoragePool.update(cls.api_client, id=cls.storageID,
tags="")
cleanup_resources(cls.api_client, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def tearDownClass(cls):
try:
# Cleanup resources used
if cls.updateclone:
Configurations.update(cls.api_client,
"vmware.root.disk.controller",
value=cls.defaultdiskcontroller)
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="false")
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="false", storageid=cls.storageID)
if cls.storageID:
StoragePool.update(cls.api_client, id=cls.storageID,
tags="")
cleanup_resources(cls.api_client, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def cleanUpCloudStack(cls):
try:
if cls.nfs_storage_pool.state is not "Maintenance":
cls.nfs_storage_pool = StoragePool.enableMaintenance(
cls.apiclient, cls.nfs_storage_pool.id)
if cls.ceph_storage_pool.state is not "Maintenance":
cls.ceph_storage_pool = StoragePool.enableMaintenance(
cls.apiclient, cls.ceph_storage_pool.id)
cls.storage_pool = StoragePool.update(cls.apiclient,
id=cls.storage_pool.id,
tags=["ssd"])
# Cleanup resources used
cleanup_resources(cls.apiclient, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def test_01_multiple_snapshot_in_zwps(self):
""" Test multiple volume snapshot in zwps
# 1. Verify if setup has a ZWPS and 2 CWPS
# 2. Deploy a VM with data disk in ZWPS
# 1. Verify ROOT and DATA Disk of the VM is in ZWPS.
# 2. Take a snapshot of VM.
# 3. Create Multiple Snapshots till operation fails.
"""
try:
self.pools = StoragePool.list(self.apiclient, zoneid=self.zone.id)
status = validateList(self.pools)
self.assertEqual(
status[0],
PASS,
"Check: Failed to list storage pools due to %s" %
status[2])
zonepoolList = list(storagePool for storagePool in self.pools
if storagePool.scope == "ZONE")
if len(zonepoolList) < 1:
self.skipTest("There must be at least one zone wide\
storage pools available in the setup")
if len(list(storagePool for storagePool in self.pools
if storagePool.scope == "CLUSTER")) < 2:
self.skipTest("There must be at atleast two cluster wide\
storage pools available in the setup")
except Exception as e:
self.skipTest(e)
# Adding tags to Storage Pools
zone_no = 1
StoragePool.update(
self.apiclient,
id=zonepoolList[0].id,
tags=[ZONETAG1[:-1] + repr(zone_no)])
self.vm_zwps = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_zwps.id,
diskofferingid=self.disk_offering_zwps.id,
zoneid=self.zone.id,
)
self.cleanup.append(self.vm_zwps)
# Step 1
volumes_root_list = list_volumes(
self.apiclient,
virtualmachineid=self.vm_zwps.id,
type=ROOT,
listall=True
)
status = validateList(volumes_root_list)
self.assertEqual(
status[0],
PASS,
"Check: Failed to list root vloume due to %s" %
status[2])
root_volume = volumes_root_list[0]
if root_volume.storage != zonepoolList[0].name:
self.fail("Root Volume not in Zone-Wide Storage Pool !")
volumes_data_list = list_volumes(
self.apiclient,
virtualmachineid=self.vm_zwps.id,
type=DATA,
listall=True
)
status = validateList(volumes_data_list)
self.assertEqual(
status[0],
PASS,
"Check: Failed to list data vloume due to %s" %
status[2])
data_volume = volumes_data_list[0]
if data_volume.storage != zonepoolList[0].name:
self.fail("Data Volume not in Zone-Wide Storage Pool !")
# Step 2
self.vm_zwps.stop(self.apiclient)
self.debug(
"Creation of Snapshot of Data Volume after VM is stopped.....")
Snapshot.create(
self.apiclient,
data_volume.id)
snapshots_list = Snapshot.list(
self.apiclient,
volumeid=data_volume.id,
listall=True)
snap_list_validation_result = validateList(snapshots_list)
self.assertEqual(
snap_list_validation_result[0],
PASS,
"snapshot list validation failed due to %s" %
snap_list_validation_result[2])
snap_count = len(snapshots_list)
# Step 3
self.debug(
"Creating Multiple Snapshots(Should create more than 10).....")
try:
while snap_count <= 12:
Snapshot.create(
self.apiclient,
data_volume.id)
snapshots_list = Snapshot.list(
self.apiclient,
volumeid=data_volume.id,
listall=True)
snap_list_validation_result = validateList(snapshots_list)
self.assertEqual(
snap_list_validation_result[0],
PASS,
"snapshot list validation failed due to %s" %
snap_list_validation_result[2])
snap_count = len(snapshots_list)
except Exception as e:
snapshots_list = Snapshot.list(
self.apiclient,
volumeid=data_volume.id,
listall=True)
snap_list_validation_result = validateList(snapshots_list)
self.assertEqual(
snap_list_validation_result[0],
PASS,
"snapshot list validation failed due to %s" %
snap_list_validation_result[2])
assert len(snapshots_list) >= 10,\
"Less than 10 snapshots created...."
raise Exception("Snapshot creation failed !: %s" % e)
return
def setUpClass(cls):
cls.testClient = super(TestResizeVolume, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.hypervisor = (cls.testClient.getHypervisorInfo()).lower()
cls.storageID = None
# Fill services from the external config file
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(
cls.api_client,
cls.testClient.getZoneForTests())
cls.services["mode"] = cls.zone.networktype
cls._cleanup = []
cls.unsupportedStorageType = False
cls.unsupportedHypervisorType = False
cls.updateclone = False
if cls.hypervisor not in ['xenserver',"kvm","vmware"]:
cls.unsupportedHypervisorType=True
return
cls.template = get_template(
cls.api_client,
cls.zone.id
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.services["volume"]["zoneid"] = cls.zone.id
try:
cls.parent_domain = Domain.create(cls.api_client,
services=cls.services[
"domain"],
parentdomainid=cls.domain.id)
cls.parentd_admin = Account.create(cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.parent_domain.id)
cls._cleanup.append(cls.parentd_admin)
cls._cleanup.append(cls.parent_domain)
list_pool_resp = list_storage_pools(cls.api_client,
account=cls.parentd_admin.name,domainid=cls.parent_domain.id)
res = validateList(list_pool_resp)
if res[2]== INVALID_INPUT:
raise Exception("Failed to list storage pool-no storagepools found ")
#Identify the storage pool type and set vmware fullclone to true if storage is VMFS
if cls.hypervisor == 'vmware':
for strpool in list_pool_resp:
if strpool.type.lower() == "vmfs" or strpool.type.lower()== "networkfilesystem":
list_config_storage_response = list_configurations(
cls.api_client
, name=
"vmware.create.full.clone",storageid=strpool.id)
res = validateList(list_config_storage_response)
if res[2]== INVALID_INPUT:
raise Exception("Failed to list configurations ")
if list_config_storage_response[0].value == "false":
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="true",storageid=strpool.id)
cls.updateclone = True
StoragePool.update(cls.api_client,id=strpool.id,tags="scsi")
cls.storageID = strpool.id
cls.unsupportedStorageType = False
break
else:
cls.unsupportedStorageType = True
# Creating service offering with normal config
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"])
cls.services_offering_vmware=ServiceOffering.create(
cls.api_client,cls.services["service_offering"],tags="scsi")
cls._cleanup.extend([cls.service_offering,cls.services_offering_vmware])
except Exception as e:
cls.tearDownClass()
return
def setUpClass(cls):
cls.cloudstacktestclient = super(TestDeployVmRootSize,
cls).getClsTestClient()
cls.api_client = cls.cloudstacktestclient.getApiClient()
cls.hypervisor = cls.cloudstacktestclient.getHypervisorInfo().lower()
cls.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__
# Get Zone, Domain and Default Built-in template
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client,
cls.cloudstacktestclient.getZoneForTests())
cls.services = cls.testClient.getParsedTestDataConfig()
cls.services["mode"] = cls.zone.networktype
cls._cleanup = []
cls.updateclone = False
cls.restartreq = False
cls.defaultdiskcontroller = "ide"
cls.template = get_template(cls.api_client, cls.zone.id)
if cls.template == FAILED:
assert False, "get_template() failed to return template "
#create a user account
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=cls.domain.id,
admin=True)
cls._cleanup.append(cls.account)
list_pool_resp = list_storage_pools(cls.api_client,
account=cls.account.name,
domainid=cls.domain.id)
#Identify the storage pool type and set vmware fullclone to
# true if storage is VMFS
if cls.hypervisor == 'vmware':
# please make sure url of templateregister dictionary in
# test_data.config pointing to .ova file
list_config_storage_response = list_configurations(
cls.api_client, name="vmware.root.disk.controller")
cls.defaultdiskcontroller = list_config_storage_response[0].value
if list_config_storage_response[0].value == "ide" or \
list_config_storage_response[0].value == \
"osdefault":
Configurations.update(cls.api_client,
"vmware.root.disk.controller",
value="scsi")
cls.updateclone = True
cls.restartreq = True
list_config_fullclone_global_response = list_configurations(
cls.api_client, name="vmware.create.full.clone")
if list_config_fullclone_global_response[0].value == "false":
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="true")
cls.updateclone = True
cls.restartreq = True
for strpool in list_pool_resp:
if strpool.type.lower() == "vmfs" or strpool.type.lower(
) == "networkfilesystem":
list_config_storage_response = list_configurations(
cls.api_client,
name="vmware.create.full.clone",
storageid=strpool.id)
res = validateList(list_config_storage_response)
if res[2] == INVALID_INPUT:
raise Exception("Failed to list configurations ")
if list_config_storage_response[0].value == "false":
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="true",
storageid=strpool.id)
cls.updateclone = True
StoragePool.update(cls.api_client,
id=strpool.id,
tags="scsi")
cls.storageID = strpool.id
break
if cls.restartreq:
cls.restartServer()
#Giving 30 seconds to management to warm-up,
#Experienced failures when trying to deploy a VM exactly when management came up
time.sleep(30)
#create a service offering
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
#build cleanup list
cls.services_offering_vmware = ServiceOffering.create(
cls.api_client, cls.services["service_offering"], tags="scsi")
cls._cleanup.extend(
[cls.service_offering, cls.services_offering_vmware])
def test_4_migrate_volume_from_ceph_to_storpool(self):
'''Test write on disk before migrating volume from Ceph primary storage
Check that data is on disk after migration'''
try:
# Login to VM and write data to file system
ssh_client = self.vm4.get_ssh_client(reconnect=True)
cmds = [
"echo %s > %s/%s" %
(self.random_data_0, self.test_dir, self.random_data), "sync",
"sleep 1", "sync", "sleep 1",
"cat %s/%s" % (self.test_dir, self.random_data)
]
for c in cmds:
self.debug(c)
result = ssh_client.execute(c)
self.debug(result)
except Exception:
self.fail("SSH failed for Virtual machine: %s" %
self.vm4.ipaddress)
self.assertEqual(self.random_data_0, result[0],
"Check the random data has be write into temp file!")
self.storage_pool = StoragePool.update(self.apiclient,
id=self.storage_pool.id,
tags=["ceph"])
self.vm4.stop(self.apiclient, forced=True)
time.sleep(30)
volumes = list_volumes(self.apiclient,
virtualmachineid=self.vm4.id,
listall=True)
for v in volumes:
cmd = migrateVolume.migrateVolumeCmd()
cmd.storageid = self.storage_pool.id
cmd.volumeid = v.id
volume = self.apiclient.migrateVolume(cmd)
self.assertEqual(volume.storageid, self.storage_pool.id,
"Did not migrate volume from Ceph to StorPool")
volumes = list_volumes(self.apiclient,
virtualmachineid=self.vm4.id,
listall=True)
for v in volumes:
name = v.path.split("/")[3]
try:
sp_volume = self.spapi.volumeList(volumeName="~" + name)
except spapi.ApiError as err:
raise Exception(err)
self.vm4.start(self.apiclient)
try:
ssh_client = self.vm4.get_ssh_client(reconnect=True)
cmds = ["cat %s/%s" % (self.test_dir, self.random_data)]
for c in cmds:
self.debug(c)
result = ssh_client.execute(c)
self.debug(result)
except Exception:
self.fail("SSH failed for Virtual machine: %s" %
self.vm4.ipaddress)
self.assertEqual(
self.random_data_0, result[0],
"Check the random data is equal with the ramdom file!")
def setUpClass(cls):
cls.cloudstacktestclient = super(TestDeployVmRootSize,
cls).getClsTestClient()
cls.api_client = cls.cloudstacktestclient.getApiClient()
cls.hypervisor = cls.cloudstacktestclient.getHypervisorInfo().lower()
cls.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__
# Get Zone, Domain and Default Built-in template
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client,
cls.cloudstacktestclient.getZoneForTests())
cls.services = cls.testClient.getParsedTestDataConfig()
cls.services["mode"] = cls.zone.networktype
cls._cleanup = []
cls.updateclone = False
cls.restartreq = False
cls.defaultdiskcontroller = "ide"
cls.template = get_template(cls.api_client, cls.zone.id)
if cls.template == FAILED:
assert False, "get_template() failed to return template "
#create a user account
cls.account = Account.create(
cls.api_client,
cls.services["account"],
domainid=cls.domain.id,admin=True
)
cls._cleanup.append(cls.account)
list_pool_resp = list_storage_pools(cls.api_client,
account=cls.account.name,
domainid=cls.domain.id)
#Identify the storage pool type and set vmware fullclone to
# true if storage is VMFS
if cls.hypervisor == 'vmware':
# please make sure url of templateregister dictionary in
# test_data.config pointing to .ova file
list_config_storage_response = list_configurations(
cls.api_client
, name=
"vmware.root.disk.controller")
cls.defaultdiskcontroller = list_config_storage_response[0].value
if list_config_storage_response[0].value == "ide" or \
list_config_storage_response[0].value == \
"osdefault":
Configurations.update(cls.api_client,
"vmware.root.disk.controller",
value="scsi")
cls.updateclone = True
cls.restartreq = True
list_config_fullclone_global_response = list_configurations(
cls.api_client
, name=
"vmware.create.full.clone")
if list_config_fullclone_global_response[0].value=="false":
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="true")
cls.updateclone = True
cls.restartreq = True
cls.tempobj = Template.register(cls.api_client,
cls.services["templateregister"],
hypervisor=cls.hypervisor,
zoneid=cls.zone.id,
account=cls.account.name,
domainid=cls.domain.id
)
cls.tempobj.download(cls.api_client)
for strpool in list_pool_resp:
if strpool.type.lower() == "vmfs" or strpool.type.lower()== "networkfilesystem":
list_config_storage_response = list_configurations(
cls.api_client
, name=
"vmware.create.full.clone",storageid=strpool.id)
res = validateList(list_config_storage_response)
if res[2]== INVALID_INPUT:
raise Exception("Failed to list configurations ")
if list_config_storage_response[0].value == "false":
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="true",
storageid=strpool.id)
cls.updateclone = True
StoragePool.update(cls.api_client,id=strpool.id,
tags="scsi")
cls.storageID = strpool.id
break
if cls.restartreq:
cls.restartServer()
#create a service offering
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
#build cleanup list
cls.services_offering_vmware=ServiceOffering.create(
cls.api_client,cls.services["service_offering"],tags="scsi")
cls._cleanup.extend([cls.service_offering,cls.services_offering_vmware])
def setUpClass(cls):
testClient = super(TestPathVolume, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.testdata = testClient.getParsedTestDataConfig()
#Get Zone,Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient)
cls.testdata["mode"] = cls.zone.networktype
cls.template = get_template(cls.apiclient, cls.zone.id, cls.testdata["ostype"])
cls.testdata["template"]["ostypeid"] = cls.template.ostypeid
if cls.template == FAILED:
cls.fail("get_template() failed to return template with description %s" % cls.testdata["ostype"])
cls._cleanup = []
try:
cls.account = Account.create(cls.apiclient,
cls.testdata["account"],
domainid=cls.domain.id
)
cls._cleanup.append(cls.account)
#createa two service offerings
cls.service_offering_1 = ServiceOffering.create(cls.apiclient, cls.testdata["service_offerings"]["small"])
cls._cleanup.append(cls.service_offering_1)
# Create Disk offerings
cls.disk_offering_1 = DiskOffering.create(cls.apiclient, cls.testdata["disk_offering"])
cls._cleanup.append(cls.disk_offering_1)
#check if zone wide storage is enable
cls.list_storage = StoragePool.list(cls.apiclient,
scope="ZONE"
)
if cls.list_storage:
cls.zone_wide_storage = cls.list_storage[0]
cls.debug("zone wide storage id is %s" % cls.zone_wide_storage.id)
cls.testdata["tags"] = "zp"
update1 = StoragePool.update(cls.apiclient,
id=cls.zone_wide_storage.id,
tags=cls.testdata["tags"]
)
cls.debug("Storage %s pool tag%s" % (cls.zone_wide_storage.id, update1.tags))
cls.testdata["service_offerings"]["tags"] = "zp"
cls.tagged_so = ServiceOffering.create(cls.apiclient, cls.testdata["service_offerings"])
cls.testdata["service_offerings"]["tags"] = " "
cls._cleanup.append(cls.tagged_so)
#create tagged disk offerings
cls.testdata["disk_offering"]["tags"] = "zp"
cls.disk_offering_tagged = DiskOffering.create(cls.apiclient, cls.testdata["disk_offering"])
cls._cleanup.append(cls.disk_offering_tagged)
else:
cls.debug("No zone wide storage found")
#check if local storage is enable
if cls.zone.localstorageenabled:
cls.testdata["disk_offering"]["tags"] = " "
cls.testdata["service_offerings"]["storagetype"] = 'local'
cls.service_offering_2 = ServiceOffering.create(cls.apiclient, cls.testdata["service_offerings"])
cls._cleanup.append(cls.service_offering_2)
#craete a compute offering with local storage
cls.testdata["disk_offering"]["storagetype"] = 'local'
cls.disk_offering_local = DiskOffering.create(cls.apiclient, cls.testdata["disk_offering"])
cls._cleanup.append(cls.disk_offering_local)
cls.testdata["disk_offering"]["storagetype"] = ' '
else:
cls.debug("No local storage found")
cls.userapiclient = testClient.getUserApiClient(UserName=cls.account.name,
DomainName=cls.account.domain
)
#Check if login is successful with new account
response = User.login(cls.userapiclient,
username=cls.account.name,
password=cls.testdata["account"]["password"]
)
assert response.sessionkey is not None
#response should have non null value
except Exception as e:
cls.tearDownClass()
raise e
return
def setUpCloudStack(cls):
super(TestMigrationFromUuidToGlobalId, cls).setUpClass()
cls._cleanup = []
cls.helper = HelperUtil(cls)
cls.helper.build_commit(cls.ARGS.uuid, cls.ARGS)
cfg.logger.info("Starting CloudStack")
cls.mvn_proc = subprocess.Popen(
['mvn', '-pl', ':cloud-client-ui', 'jetty:run'],
cwd=cls.ARGS.forked,
preexec_fn=os.setsid,
stdout=cfg.misc,
stderr=subprocess.STDOUT,
)
cls.mvn_proc_grp = os.getpgid(cls.mvn_proc.pid)
cfg.logger.info("Started CloudStack in process group %d",
cls.mvn_proc_grp)
cfg.logger.info("Waiting for a while to give it a chance to start")
proc = subprocess.Popen(["tail", "-f", cfg.misc_name],
shell=False,
bufsize=0,
stdout=subprocess.PIPE)
while True:
line = proc.stdout.readline()
if not line:
cfg.logger.info("tail ended, was this expected?")
cfg.logger.info("Stopping CloudStack")
os.killpg(cls.mvn_proc_grp, signal.SIGINT)
break
if "[INFO] Started Jetty Server" in line:
cfg.logger.info("got it!")
break
proc.terminate()
proc.wait()
time.sleep(15)
cfg.logger.info("Processing with the setup")
cls.obj_marvininit = cls.helper.marvin_init(cls.ARGS.cfg)
cls.testClient = cls.obj_marvininit.getTestClient()
cls.apiclient = cls.testClient.getApiClient()
dbclient = cls.testClient.getDbConnection()
v = dbclient.execute(
"select * from configuration where name='sp.migration.to.global.ids.completed'"
)
cfg.logger.info("Configuration setting for update of db is %s", v)
if len(v) > 0:
update = dbclient.execute(
"update configuration set value='false' where name='sp.migration.to.global.ids.completed'"
)
cfg.logger.info("DB configuration table was updated %s", update)
cls.spapi = spapi.Api.fromConfig(multiCluster=True)
td = TestData()
cls.testdata = td.testdata
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.cluster = list_clusters(cls.apiclient)[0]
cls.hypervisor = get_hypervisor_type(cls.apiclient)
#The version of CentOS has to be supported
cls.template = get_template(cls.apiclient,
cls.zone.id,
account="system")
if cls.template == FAILED:
assert False, "get_template() failed to return template\
with description %s" % cls.services["ostype"]
cls.services["domainid"] = cls.domain.id
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["templates"]["ostypeid"] = cls.template.ostypeid
cls.services["zoneid"] = cls.zone.id
primarystorage = cls.testdata[TestData.primaryStorage]
primarystorage2 = cls.testdata[TestData.primaryStorage2]
serviceOffering = cls.testdata[TestData.serviceOffering]
serviceOffering2 = cls.testdata[TestData.serviceOfferingssd2]
storage_pool = list_storage_pools(cls.apiclient,
name=primarystorage.get("name"))
storage_pool2 = list_storage_pools(cls.apiclient,
name=primarystorage2.get("name"))
cls.primary_storage = storage_pool[0]
cls.primary_storage2 = storage_pool2[0]
disk_offering = list_disk_offering(cls.apiclient, name="Small")
assert disk_offering is not None
service_offering = list_service_offering(cls.apiclient, name="ssd")
if service_offering is not None:
cls.service_offering = service_offering[0]
else:
cls.service_offering = ServiceOffering.create(
cls.apiclient, serviceOffering)
assert cls.service_offering is not None
service_offering2 = list_service_offering(cls.apiclient, name="ssd2")
if service_offering2 is not None:
cls.service_offering2 = service_offering2[0]
else:
cls.service_offering2 = ServiceOffering.create(
cls.apiclient, serviceOffering2)
assert cls.service_offering2 is not None
nfs_service_offerings = {
"name": "nfs",
"displaytext": "NFS service offerings",
"cpunumber": 1,
"cpuspeed": 500,
"memory": 512,
"storagetype": "shared",
"customizediops": False,
"hypervisorsnapshotreserve": 200,
"tags": "nfs"
}
nfs_storage_pool = list_storage_pools(cls.apiclient, name='primary')
nfs_service_offering = list_service_offering(cls.apiclient, name='nfs')
if nfs_service_offering is None:
nfs_service_offering = ServiceOffering.create(
cls.apiclient, nfs_service_offerings)
else:
nfs_service_offering = nfs_service_offering[0]
cls.nfs_service_offering = nfs_service_offering
cls.nfs_storage_pool = nfs_storage_pool[0]
cls.nfs_storage_pool = StoragePool.cancelMaintenance(
cls.apiclient, cls.nfs_storage_pool.id)
cls.disk_offering = disk_offering[0]
account = list_accounts(cls.apiclient, name="admin")
cls.account = account[0]
cls.virtual_machine = VirtualMachine.create(
cls.apiclient, {"name": "StorPool-%s" % uuid.uuid4()},
zoneid=cls.zone.id,
templateid=cls.template.id,
serviceofferingid=cls.nfs_service_offering.id,
hypervisor=cls.hypervisor,
rootdisksize=10)
cls._cleanup.append(cls.virtual_machine)
cls.virtual_machine2 = VirtualMachine.create(
cls.apiclient, {"name": "StorPool-%s" % uuid.uuid4()},
zoneid=cls.zone.id,
templateid=cls.template.id,
serviceofferingid=cls.nfs_service_offering.id,
hypervisor=cls.hypervisor,
rootdisksize=10)
cls._cleanup.append(cls.virtual_machine2)
cls.virtual_machine3 = VirtualMachine.create(
cls.apiclient, {"name": "StorPool-%s" % uuid.uuid4()},
zoneid=cls.zone.id,
templateid=cls.template.id,
serviceofferingid=cls.service_offering.id,
hypervisor=cls.hypervisor,
rootdisksize=10)
cls._cleanup.append(cls.virtual_machine3)
cls.virtual_machine4 = VirtualMachine.create(
cls.apiclient, {"name": "StorPool-%s" % uuid.uuid4()},
zoneid=cls.zone.id,
templateid=cls.template.id,
serviceofferingid=cls.service_offering2.id,
hypervisor=cls.hypervisor,
rootdisksize=10)
cls._cleanup.append(cls.virtual_machine4)
cls.volume = Volume.create(cls.apiclient,
cls.testdata[TestData.volume_1],
account=cls.account.name,
domainid=cls.domain.id,
zoneid=cls.zone.id,
diskofferingid=cls.disk_offering.id)
cls._cleanup.append(cls.volume)
cls.primary_storage = StoragePool.update(cls.apiclient,
id=cls.primary_storage.id,
tags=["ssd, nfs, ssd2"])
cls.primary_storage2 = StoragePool.update(cls.apiclient,
id=cls.primary_storage2.id,
tags=["ssd, ssd2"])
#change to latest commit with globalId implementation
cls.helper.switch_to_globalid_commit(cls.ARGS.globalid, cls.ARGS)
cfg.logger.info("The setup is done, proceeding with the tests")
cls.primary_storage = list_storage_pools(
cls.apiclient, name=primarystorage.get("name"))[0]
cls.primary_storage2 = list_storage_pools(
cls.apiclient, name=primarystorage2.get("name"))[0]
def updateStoragePoolTags(self, poolId, tags):
StoragePool.update(
self.apiclient,
id=poolId,
tags=tags
)
def test_01_recover_VM(self):
""" Test Restore VM on VMWare
1. Deploy a VM without datadisk
2. Restore the VM
3. Verify that VM comes up in Running state
"""
try:
self.pools = StoragePool.list(self.apiclient,
zoneid=self.zone.id,
scope="CLUSTER")
status = validateList(self.pools)
# Step 3
self.assertEqual(
status[0], PASS,
"Check: Failed to list cluster wide storage pools")
if len(self.pools) < 2:
self.skipTest("There must be at atleast two cluster wide\
storage pools available in the setup")
except Exception as e:
self.skipTest(e)
# Adding tags to Storage Pools
cluster_no = 1
StoragePool.update(self.apiclient,
id=self.pools[0].id,
tags=[CLUSTERTAG1[:-1] + repr(cluster_no)])
self.vm = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
accountid=self.account.name,
templateid=self.template.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_cwps.id,
zoneid=self.zone.id,
)
# Step 2
volumes_root_list = list_volumes(self.apiclient,
virtualmachineid=self.vm.id,
type=ROOT,
listall=True)
root_volume = volumes_root_list[0]
# Restore VM till its ROOT disk is recreated on onother Primary Storage
while True:
self.vm.restore(self.apiclient)
volumes_root_list = list_volumes(self.apiclient,
virtualmachineid=self.vm.id,
type=ROOT,
listall=True)
root_volume = volumes_root_list[0]
if root_volume.storage != self.pools[0].name:
break
# Step 3
vm_list = list_virtual_machines(self.apiclient, id=self.vm.id)
state = vm_list[0].state
i = 0
while (state != "Running"):
vm_list = list_virtual_machines(self.apiclient, id=self.vm.id)
time.sleep(10)
i = i + 1
state = vm_list[0].state
if i >= 10:
self.fail("Restore VM Failed")
break
return
def setUpCloudStack(cls):
cls.spapi = spapi.Api.fromConfig(multiCluster=True)
testClient = super(TestStoragePool, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls._cleanup = []
cls.unsupportedHypervisor = False
cls.hypervisor = testClient.getHypervisorInfo()
if cls.hypervisor.lower() in ("hyperv", "lxc"):
cls.unsupportedHypervisor = True
return
cls.services = testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = None
zones = list_zones(cls.apiclient)
for z in zones:
if z.internaldns1 == cls.getClsConfig().mgtSvr[0].mgtSvrIp:
cls.zone = z
td = TestData()
cls.testdata = td.testdata
cls.helper = StorPoolHelper()
storpool_primary_storage = cls.testdata[TestData.primaryStorage]
cls.template_name = storpool_primary_storage.get("name")
storpool_service_offerings = cls.testdata[TestData.serviceOffering]
nfs_service_offerings = cls.testdata[TestData.serviceOfferingsPrimary]
ceph_service_offerings = cls.testdata[TestData.serviceOfferingsCeph]
storage_pool = list_storage_pools(cls.apiclient,
name=cls.template_name)
nfs_storage_pool = list_storage_pools(cls.apiclient, name='primary')
ceph_primary_storage = cls.testdata[TestData.primaryStorage4]
cls.ceph_storage_pool = list_storage_pools(
cls.apiclient, name=ceph_primary_storage.get("name"))[0]
service_offerings = list_service_offering(cls.apiclient,
name=cls.template_name)
nfs_service_offering = list_service_offering(cls.apiclient, name='nfs')
ceph_service_offering = list_service_offering(
cls.apiclient, name=ceph_primary_storage.get("name"))
disk_offerings = list_disk_offering(cls.apiclient, name="Small")
cls.disk_offerings = disk_offerings[0]
if storage_pool is None:
storage_pool = StoragePool.create(cls.apiclient,
storpool_primary_storage)
else:
storage_pool = storage_pool[0]
cls.storage_pool = storage_pool
cls.debug(pprint.pformat(storage_pool))
if service_offerings is None:
service_offerings = ServiceOffering.create(
cls.apiclient, storpool_service_offerings)
else:
service_offerings = service_offerings[0]
if nfs_service_offering is None:
nfs_service_offering = ServiceOffering.create(
cls.apiclient, nfs_service_offerings)
else:
nfs_service_offering = nfs_service_offering[0]
if ceph_service_offering is None:
ceph_service_offering = ServiceOffering.create(
cls.apiclient, ceph_service_offerings)
else:
ceph_service_offering = ceph_service_offering[0]
#The version of CentOS has to be supported
template = get_template(cls.apiclient, cls.zone.id, account="system")
cls.nfs_storage_pool = nfs_storage_pool[0]
if cls.nfs_storage_pool.state == "Maintenance":
cls.nfs_storage_pool = StoragePool.cancelMaintenance(
cls.apiclient, cls.nfs_storage_pool.id)
if cls.ceph_storage_pool.state == "Maintenance":
cls.ceph_storage_pool = StoragePool.cancelMaintenance(
cls.apiclient, cls.ceph_storage_pool.id)
cls.account = cls.helper.create_account(cls.apiclient,
cls.services["account"],
accounttype=1,
domainid=cls.domain.id,
roleid=1)
cls._cleanup.append(cls.account)
securitygroup = SecurityGroup.list(cls.apiclient,
account=cls.account.name,
domainid=cls.account.domainid)[0]
cls.helper.set_securityGroups(cls.apiclient,
account=cls.account.name,
domainid=cls.account.domainid,
id=securitygroup.id)
cls.vm = VirtualMachine.create(
cls.apiclient, {"name": "StorPool-%s" % uuid.uuid4()},
zoneid=cls.zone.id,
templateid=template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=nfs_service_offering.id,
hypervisor=cls.hypervisor,
rootdisksize=10)
cls.vm2 = VirtualMachine.create(
cls.apiclient, {"name": "StorPool-%s" % uuid.uuid4()},
zoneid=cls.zone.id,
templateid=template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=nfs_service_offering.id,
hypervisor=cls.hypervisor,
rootdisksize=10)
cls.vm3 = VirtualMachine.create(
cls.apiclient, {"name": "StorPool-%s" % uuid.uuid4()},
zoneid=cls.zone.id,
templateid=template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=nfs_service_offering.id,
hypervisor=cls.hypervisor,
rootdisksize=10)
cls.vm4 = VirtualMachine.create(
cls.apiclient, {"name": "StorPool-%s" % uuid.uuid4()},
zoneid=cls.zone.id,
templateid=template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=ceph_service_offering.id,
hypervisor=cls.hypervisor,
rootdisksize=10)
cls.vm5 = VirtualMachine.create(
cls.apiclient, {"name": "StorPool-%s" % uuid.uuid4()},
zoneid=cls.zone.id,
templateid=template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=ceph_service_offering.id,
hypervisor=cls.hypervisor,
rootdisksize=10)
cls.storage_pool = StoragePool.update(cls.apiclient,
id=cls.storage_pool.id,
tags=["ssd, nfs"])
cls.debug(pprint.pformat(template))
cls.debug(pprint.pformat(cls.hypervisor))
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["small"]["zoneid"] = cls.zone.id
cls.services["templates"]["ostypeid"] = template.ostypeid
cls.services["zoneid"] = cls.zone.id
cls.service_offering = service_offerings
cls.nfs_service_offering = nfs_service_offering
cls.debug(pprint.pformat(cls.service_offering))
cls.template = template
cls.random_data_0 = random_gen(size=100)
cls.test_dir = "/tmp"
cls.random_data = "random.data"
return
def test_01_multiple_snapshot_in_zwps(self):
""" Test multiple volume snapshot in zwps
# 1. Verify if setup has a ZWPS and 2 CWPS
# 2. Deploy a VM with data disk in ZWPS
# 1. Verify ROOT and DATA Disk of the VM is in ZWPS.
# 2. Take a snapshot of VM.
# 3. Create Multiple Snapshots till operation fails.
"""
try:
self.pools = StoragePool.list(self.apiclient, zoneid=self.zone.id)
status = validateList(self.pools)
self.assertEqual(
status[0], PASS,
"Check: Failed to list storage pools due to %s" % status[2])
zonepoolList = list(storagePool for storagePool in self.pools
if storagePool.scope == "ZONE")
if len(zonepoolList) < 1:
self.skipTest("There must be at least one zone wide\
storage pools available in the setup")
if len(
list(storagePool for storagePool in self.pools
if storagePool.scope == "CLUSTER")) < 2:
self.skipTest("There must be at atleast two cluster wide\
storage pools available in the setup")
except Exception as e:
self.skipTest(e)
# Adding tags to Storage Pools
zone_no = 1
StoragePool.update(self.apiclient,
id=zonepoolList[0].id,
tags=[ZONETAG1[:-1] + repr(zone_no)])
self.vm_zwps = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_zwps.id,
diskofferingid=self.disk_offering_zwps.id,
zoneid=self.zone.id,
)
self.cleanup.append(self.vm_zwps)
# Step 1
volumes_root_list = list_volumes(self.apiclient,
virtualmachineid=self.vm_zwps.id,
type=ROOT,
listall=True)
status = validateList(volumes_root_list)
self.assertEqual(
status[0], PASS,
"Check: Failed to list root vloume due to %s" % status[2])
root_volume = volumes_root_list[0]
if root_volume.storage != zonepoolList[0].name:
self.fail("Root Volume not in Zone-Wide Storage Pool !")
volumes_data_list = list_volumes(self.apiclient,
virtualmachineid=self.vm_zwps.id,
type=DATA,
listall=True)
status = validateList(volumes_data_list)
self.assertEqual(
status[0], PASS,
"Check: Failed to list data vloume due to %s" % status[2])
data_volume = volumes_data_list[0]
if data_volume.storage != zonepoolList[0].name:
self.fail("Data Volume not in Zone-Wide Storage Pool !")
# Step 2
self.vm_zwps.stop(self.apiclient)
self.debug(
"Creation of Snapshot of Data Volume after VM is stopped.....")
Snapshot.create(self.apiclient, data_volume.id)
snapshots_list = Snapshot.list(self.apiclient,
volumeid=data_volume.id,
listall=True)
snap_list_validation_result = validateList(snapshots_list)
self.assertEqual(
snap_list_validation_result[0], PASS,
"snapshot list validation failed due to %s" %
snap_list_validation_result[2])
snap_count = len(snapshots_list)
# Step 3
self.debug(
"Creating Multiple Snapshots(Should create more than 10).....")
try:
while snap_count <= 12:
Snapshot.create(self.apiclient, data_volume.id)
snapshots_list = Snapshot.list(self.apiclient,
volumeid=data_volume.id,
listall=True)
snap_list_validation_result = validateList(snapshots_list)
self.assertEqual(
snap_list_validation_result[0], PASS,
"snapshot list validation failed due to %s" %
snap_list_validation_result[2])
snap_count = len(snapshots_list)
except Exception as e:
snapshots_list = Snapshot.list(self.apiclient,
volumeid=data_volume.id,
listall=True)
snap_list_validation_result = validateList(snapshots_list)
self.assertEqual(
snap_list_validation_result[0], PASS,
"snapshot list validation failed due to %s" %
snap_list_validation_result[2])
assert len(snapshots_list) >= 10,\
"Less than 10 snapshots created...."
raise Exception("Snapshot creation failed !: %s" % e)
return
def test_01_attach_datadisk_to_vm_on_zwps(self):
""" Attach Data Disk on CWPS To VM
1. Check if zwps storage pool exists.
2. Adding tag to zone wide primary storage
3. Launch a VM
4. Attach data disk to vm.
5. Verify disk is attached and in correct storage pool.
"""
# Step 1
if len(list(self.pools)) < 1:
self.skipTest("There must be at least one zone wide \
storage pools available in the setup")
# Step 2
# Adding tags to Storage Pools
StoragePool.update(
self.apiclient,
id=self.pools[0].id,
tags=[CLUSTERTAG1])
# Launch VM
self.vm = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_zone1.id,
zoneid=self.zone.id
)
self.testdata["volume"]["zoneid"] = self.zone.id
self.testdata["volume"]["customdisksize"] = 1
self.data_volume_created = Volume.create_custom_disk(
self.userapiclient,
self.testdata["volume"],
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id,
)
self.cleanup.append(self.data_volume_created)
# Step 4
self.vm.attach_volume(
self.userapiclient,
self.data_volume_created
)
data_volumes_list = Volume.list(
self.userapiclient,
virtualmachineid=self.vm.id,
type="DATA",
listall=True
)
self.debug("list volumes using vm id %s" % dir(data_volumes_list[0]))
data_volumes_list = Volume.list(self.apiclient,
id=self.data_volume_created.id,
listall=True)
data_volume = data_volumes_list[0]
status = validateList(data_volume)
# Step 5
self.assertEqual(
status[0],
PASS,
"Check: volume list is valid")
self.assertEqual(
data_volume.state,
"Ready",
"Check: Data volume is attached to VM")
if data_volume.storage != self.pools[0].name:
self.fail("check if volume is created in correct storage pool")
return
def test_11_migrate_volume_and_change_offering(self):
# Validates the following
#
# 1. Creates a new Volume with a small disk offering
#
# 2. Migrates the Volume to another primary storage and changes the offering
#
# 3. Verifies the Volume has new offering when migrated to the new storage.
small_offering = list_disk_offering(
self.apiclient,
name = "Small"
)[0]
large_offering = list_disk_offering(
self.apiclient,
name = "Large"
)[0]
volume = Volume.create(
self.apiClient,
self.services,
zoneid = self.zone.id,
account = self.account.name,
domainid = self.account.domainid,
diskofferingid = small_offering.id
)
self.debug("Created a small volume: %s" % volume.id)
self.virtual_machine.attach_volume(self.apiclient, volume=volume)
if self.virtual_machine.hypervisor == "KVM":
self.virtual_machine.stop(self.apiclient)
pools = StoragePool.listForMigration(
self.apiclient,
id=volume.id
)
pool = None
if pools and len(pools) > 0:
pool = pools[0]
else:
raise self.skipTest("Not enough storage pools found, skipping test")
if hasattr(pool, 'tags'):
StoragePool.update(self.apiclient, id=pool.id, tags="")
self.debug("Migrating Volume-ID: %s to Pool: %s" % (volume.id, pool.id))
Volume.migrate(
self.apiclient,
volumeid = volume.id,
storageid = pool.id,
newdiskofferingid = large_offering.id
)
if self.virtual_machine.hypervisor == "KVM":
self.virtual_machine.start(self.apiclient
)
migrated_vol = Volume.list(
self.apiclient,
id = volume.id
)[0]
self.assertEqual(
migrated_vol.diskofferingname,
large_offering.name,
"Offering name did not match with the new one "
)
return
def test_01_attach_datadisk_to_vm_on_zwps(self):
""" Attach Data Disk To VM on ZWPS
1. Check if zwps storage pool exists.
2. Adding tag to zone wide primary storage
3. Launch a VM on ZWPS
4. Attach data disk to vm which is on zwps.
5. Verify disk is attached.
"""
# Step 1
if len(list(storagePool for storagePool in self.pools
if storagePool.scope == "ZONE")) < 1:
self.skipTest("There must be at least one zone wide \
storage pools available in the setup")
# Adding tags to Storage Pools
zone_no = 1
for storagePool in self.pools:
if storagePool.scope == "ZONE":
StoragePool.update(
self.apiclient,
id=storagePool.id,
tags=[ZONETAG1[:-1] + repr(zone_no)])
zone_no += 1
self.vm = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_zone1.id,
zoneid=self.zone.id
)
self.data_volume_created = Volume.create(
self.userapiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id
)
self.cleanup.append(self.data_volume_created)
# Step 2
self.vm.attach_volume(
self.userapiclient,
self.data_volume_created
)
data_volumes_list = Volume.list(
self.userapiclient,
id=self.data_volume_created.id,
virtualmachineid=self.vm.id
)
data_volume = data_volumes_list[0]
status = validateList(data_volume)
# Step 3
self.assertEqual(
status[0],
PASS,
"Check: Data if Disk is attached to VM")
return
def test_01_attach_datadisk_to_vm_on_zwps(self):
""" Attach Data Disk on CWPS To VM
1. Check if zwps storage pool exists.
2. Adding tag to zone wide primary storage
3. Launch a VM
4. Attach data disk to vm.
5. Verify disk is attached and in correct storage pool.
"""
# Step 1
if len(list(self.pools)) < 1:
self.skipTest("There must be at least one zone wide \
storage pools available in the setup")
# Step 2
# Adding tags to Storage Pools
StoragePool.update(self.apiclient,
id=self.pools[0].id,
tags=[CLUSTERTAG1])
# Launch VM
self.vm = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_zone1.id,
zoneid=self.zone.id)
self.testdata["volume"]["zoneid"] = self.zone.id
self.testdata["volume"]["customdisksize"] = 1
self.data_volume_created = Volume.create_custom_disk(
self.userapiclient,
self.testdata["volume"],
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id,
)
self.cleanup.append(self.data_volume_created)
# Step 4
self.vm.attach_volume(self.userapiclient, self.data_volume_created)
data_volumes_list = Volume.list(self.userapiclient,
virtualmachineid=self.vm.id,
type="DATA",
listall=True)
self.debug("list volumes using vm id %s" % dir(data_volumes_list[0]))
data_volumes_list = Volume.list(self.apiclient,
id=self.data_volume_created.id,
listall=True)
data_volume = data_volumes_list[0]
status = validateList(data_volume)
# Step 5
self.assertEqual(status[0], PASS, "Check: volume list is valid")
self.assertEqual(data_volume.state, "Ready",
"Check: Data volume is attached to VM")
if data_volume.storage != self.pools[0].name:
self.fail("check if volume is created in correct storage pool")
return
def test_01_recover_VM(self):
""" Test Restore VM on VMWare
1. Deploy a VM without datadisk
2. Restore the VM
3. Verify that VM comes up in Running state
"""
try:
self.pools = StoragePool.list(
self.apiclient,
zoneid=self.zone.id,
scope="CLUSTER")
status = validateList(self.pools)
# Step 3
self.assertEqual(
status[0],
PASS,
"Check: Failed to list cluster wide storage pools")
if len(self.pools) < 2:
self.skipTest("There must be at atleast two cluster wide\
storage pools available in the setup")
except Exception as e:
self.skipTest(e)
# Adding tags to Storage Pools
cluster_no = 1
StoragePool.update(
self.apiclient,
id=self.pools[0].id,
tags=[CLUSTERTAG1[:-1] + repr(cluster_no)])
self.vm = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
accountid=self.account.name,
templateid=self.template.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_cwps.id,
zoneid=self.zone.id,
)
# Step 2
volumes_root_list = list_volumes(
self.apiclient,
virtualmachineid=self.vm.id,
type=ROOT,
listall=True
)
root_volume = volumes_root_list[0]
# Restore VM till its ROOT disk is recreated on onother Primary Storage
while True:
self.vm.restore(self.apiclient)
volumes_root_list = list_volumes(
self.apiclient,
virtualmachineid=self.vm.id,
type=ROOT,
listall=True
)
root_volume = volumes_root_list[0]
if root_volume.storage != self.pools[0].name:
break
# Step 3
vm_list = list_virtual_machines(
self.apiclient,
id=self.vm.id)
state = vm_list[0].state
i = 0
while(state != "Running"):
vm_list = list_virtual_machines(
self.apiclient,
id=self.vm.id)
time.sleep(10)
i = i + 1
state = vm_list[0].state
if i >= 10:
self.fail("Restore VM Failed")
break
return
def setUpClass(cls):
cls.testClient = super(TestResizeVolume, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.hypervisor = (cls.testClient.getHypervisorInfo()).lower()
cls.storageID = None
# Fill services from the external config file
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services["mode"] = cls.zone.networktype
cls._cleanup = []
cls.unsupportedStorageType = False
cls.unsupportedHypervisorType = False
cls.updateclone = False
if cls.hypervisor not in ['xenserver', "kvm", "vmware"]:
cls.unsupportedHypervisorType = True
return
cls.template = get_template(cls.api_client, cls.zone.id)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.services["volume"]["zoneid"] = cls.zone.id
try:
cls.parent_domain = Domain.create(cls.api_client,
services=cls.services["domain"],
parentdomainid=cls.domain.id)
cls.parentd_admin = Account.create(cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.parent_domain.id)
cls._cleanup.append(cls.parentd_admin)
cls._cleanup.append(cls.parent_domain)
list_pool_resp = list_storage_pools(cls.api_client,
account=cls.parentd_admin.name,
domainid=cls.parent_domain.id)
res = validateList(list_pool_resp)
if res[2] == INVALID_INPUT:
raise Exception(
"Failed to list storage pool-no storagepools found ")
#Identify the storage pool type and set vmware fullclone to true if storage is VMFS
if cls.hypervisor == 'vmware':
for strpool in list_pool_resp:
if strpool.type.lower() == "vmfs" or strpool.type.lower(
) == "networkfilesystem":
list_config_storage_response = list_configurations(
cls.api_client,
name="vmware.create.full.clone",
storageid=strpool.id)
res = validateList(list_config_storage_response)
if res[2] == INVALID_INPUT:
raise Exception("Failed to list configurations ")
if list_config_storage_response[0].value == "false":
Configurations.update(cls.api_client,
"vmware.create.full.clone",
value="true",
storageid=strpool.id)
cls.updateclone = True
StoragePool.update(cls.api_client,
id=strpool.id,
tags="scsi")
cls.storageID = strpool.id
cls.unsupportedStorageType = False
break
else:
cls.unsupportedStorageType = True
# Creating service offering with normal config
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
cls.services_offering_vmware = ServiceOffering.create(
cls.api_client, cls.services["service_offering"], tags="scsi")
cls._cleanup.extend(
[cls.service_offering, cls.services_offering_vmware])
except Exception as e:
cls.tearDownClass()
return
