def setUpClass(cls):
cls.api_client = super(TestSnapshotOnRootVolume,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"])
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=cls.domain.id)
# pdb.set_trace()
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"])
cls.disk_offering = DiskOffering.create(
cls.api_client,
cls.services["disk_offering"],
domainid=cls.domain.id)
cls.service_offering2 = ServiceOffering.create(
cls.api_client,
cls.services["service_offering2"])
cls.disk_offering2 = DiskOffering.create(
cls.api_client,
cls.services["disk_offering2"],
domainid=cls.domain.id)
cls._cleanup = [cls.account,
cls.service_offering,
cls.disk_offering,
cls.service_offering2,
cls.disk_offering2]
def setUpClass(cls):
cls.api_client = super(TestSnapshotOnRootVolume,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=cls.domain.id)
# pdb.set_trace()
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
cls.disk_offering = DiskOffering.create(cls.api_client,
cls.services["disk_offering"],
domainid=cls.domain.id)
cls.service_offering2 = ServiceOffering.create(
cls.api_client, cls.services["service_offering2"])
cls.disk_offering2 = DiskOffering.create(
cls.api_client,
cls.services["disk_offering2"],
domainid=cls.domain.id)
cls._cleanup = [
cls.account, cls.service_offering, cls.disk_offering,
cls.service_offering2, cls.disk_offering2
]
def setUpClass(cls):
cls.api_client = super(TestServiceOfferings, cls).getClsTestClient().getApiClient()
cls.services = Services().services
domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.services['mode'] = cls.zone.networktype
cls.service_offering_1 = ServiceOffering.create(
cls.api_client,
cls.services["off"]
)
cls.service_offering_2 = ServiceOffering.create(
cls.api_client,
cls.services["off"]
)
template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
# Set Zones and disk offerings
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["small"]["template"] = template.id
cls.services["medium"]["zoneid"] = cls.zone.id
cls.services["medium"]["template"] = template.id
# Create VMs, NAT Rules etc
cls.account = Account.create(
cls.api_client,
cls.services["account"],
domainid=domain.id
)
cls.small_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offerings"]["small"]
)
cls.medium_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offerings"]["medium"]
)
cls.medium_virtual_machine = VirtualMachine.create(
cls.api_client,
cls.services["medium"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.medium_offering.id,
mode=cls.services["mode"]
)
cls._cleanup = [
cls.small_offering,
cls.medium_offering,
cls.account
]
return
def setUpClass(cls):
cls.api_client = super(TestBaseImageUpdate,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering_with_reset = ServiceOffering.create(
cls.api_client, cls.services["service_offering_with_reset"])
cls.service_offering_without_reset = ServiceOffering.create(
cls.api_client, cls.services["service_offering_without_reset"])
cls.account = Account.create(cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
cls.vm_with_reset = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_with_reset.id,
)
cls.vm_with_reset_root_disk_id = cls.get_root_device_uuid_for_vm(
cls.vm_with_reset.id, cls.vm_with_reset.rootdeviceid)
cls.vm_without_reset = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_without_reset.id,
)
cls.vm_without_reset_root_disk_id = cls.get_root_device_uuid_for_vm(
cls.vm_without_reset.id, cls.vm_without_reset.rootdeviceid)
cls._cleanup = [
cls.account,
cls.service_offering_with_reset,
cls.service_offering_without_reset,
]
return
def setUpClass(cls):
# We want to fail quicker if it's failure
socket.setdefaulttimeout(60)
cls.api_client = super(
TestVPCNetworkPFRules,
cls
).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls._cleanup = [cls.service_offering]
return
def setUp(self):
self.testdata = TestData().testdata
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.testdata)
self.zone = get_zone(self.apiclient, self.testdata)
self.testdata["mode"] = self.zone.networktype
self.template = get_template(self.apiclient, self.zone.id, self.testdata["ostype"])
# for testing with specific template
# self.template = get_template(self.apiclient, self.zone.id, self.testdata["ostype"], templatetype='USER', services = {"template":'31f52a4d-5681-43f7-8651-ad4aaf823618'})
#create a user account
self.account = Account.create(
self.apiclient,
self.testdata["account"],
domainid=self.domain.id
)
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient,
self.testdata["service_offering"]["small"]
)
#build cleanup list
self.cleanup = [
self.service_offering,
self.account
]
def setUpClass(cls):
cls.apiClient = super(TestDeployVmWithUserData,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
cls.zone = get_zone(cls.apiClient, cls.services)
if cls.zone.localstorageenabled:
#For devcloud since localstroage is enabled
cls.services["service_offering"]["storagetype"] = "local"
cls.service_offering = ServiceOffering.create(
cls.apiClient, cls.services["service_offering"])
cls.account = Account.create(cls.apiClient,
services=cls.services["account"])
cls.cleanup = [cls.account]
cls.template = get_template(cls.apiClient, cls.zone.id,
cls.services["ostype"])
cls.debug("Successfully created account: %s, id: \
%s" % (cls.account.name,\
cls.account.id))
# Generate userdata of 2500 bytes. This is larger than the 2048 bytes limit.
# CS however allows for upto 4K bytes in the code. So this must succeed.
# Overall, the query length must not exceed 4K, for then the json decoder
# will fail this operation at the marvin client side itcls.
user_data = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in range(2500))
cls.services["virtual_machine"]["userdata"] = user_data
def setUpClass(cls):
cls.api_client = super(TestMemoryLimits,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.services["mode"] = cls.zone.networktype
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls._cleanup = [cls.service_offering, ]
return
def test_deployvm_firstfit(self):
"""Test to deploy vm with a first fit offering
"""
# FIXME: How do we know that first fit actually happened?
self.service_offering_firstfit = ServiceOffering.create(
self.apiclient, self.services["service_offering"], deploymentplanner="FirstFitPlanner"
)
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_firstfit.id,
templateid=self.template.id,
)
list_vms = VirtualMachine.list(self.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.assertNotEqual(len(list_vms), 0, "List VM response was empty")
vm = list_vms[0]
self.assertEqual(vm.state, "Running", msg="VM is not in Running state")
def setUpClass(cls):
cls.api_client = super(TestNonContiguousVLANRanges, cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, pod, domain
cls.zone = get_zone(cls.api_client, cls.services)
cls.pod = get_pod(cls.api_client, cls.zone.id, cls.services)
cls.domain = get_domain(cls.api_client, cls.services)
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["template"] = cls.template.id
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls._cleanup = [cls.service_offering]
return
def test_deployvm_firstfit(self):
"""Test to deploy vm with a first fit offering
"""
#FIXME: How do we know that first fit actually happened?
self.service_offering_firstfit = ServiceOffering.create(
self.apiclient,
self.services["service_offering"],
deploymentplanner='FirstFitPlanner')
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_firstfit.id,
templateid=self.template.id)
list_vms = VirtualMachine.list(self.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.assertNotEqual(len(list_vms), 0, "List VM response was empty")
vm = list_vms[0]
self.assertEqual(vm.state, "Running", msg="VM is not in Running state")
def setUp(self):
self.testdata = TestData().testdata
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.testdata)
self.zone = get_zone(self.apiclient, self.testdata)
self.testdata["mode"] = self.zone.networktype
self.template = get_template(self.apiclient, self.zone.id, self.testdata["ostype"])
#create a user account
self.account = Account.create(
self.apiclient,
self.testdata["account"],
domainid=self.domain.id
)
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient,
self.testdata["service_offering"]["small"]
)
#build cleanup list
self.cleanup = [
self.service_offering,
self.account
]
def setUp(self):
self.services = Services().services
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.services)
self.zone = get_zone(self.apiclient, self.services)
self.services["mode"] = self.zone.networktype
# Before running this test, register a windows template with ostype as 'Windows 7 (32-bit)'
self.template = get_template(self.apiclient, self.zone.id, self.services["ostype"], templatetype='USER')
#create a user account
self.account = Account.create(
self.apiclient,
self.services["account"],
domainid=self.domain.id
)
self.services["vgpu260q"]["zoneid"] = self.zone.id
self.services["vgpu260q"]["template"] = self.template.id
self.services["vgpu140q"]["zoneid"] = self.zone.id
self.services["vgpu140q"]["template"] = self.template.id
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient,
self.services["service_offerings"]["vgpu260qwin"],
serviceofferingdetails={'pciDevice': 'VGPU'}
)
#build cleanup list
self.cleanup = [
self.service_offering,
self.account
]
def setUpClass(cls):
cls.apiClient = super(TestDeployVmWithUserData, cls).getClsTestClient().getApiClient()
cls.services = Services().services
cls.zone = get_zone(cls.apiClient, cls.services)
if cls.zone.localstorageenabled:
#For devcloud since localstroage is enabled
cls.services["service_offering"]["storagetype"] = "local"
cls.service_offering = ServiceOffering.create(
cls.apiClient,
cls.services["service_offering"]
)
cls.account = Account.create(cls.apiClient, services=cls.services["account"])
cls.cleanup = [cls.account]
cls.template = get_template(
cls.apiClient,
cls.zone.id,
cls.services["ostype"]
)
cls.debug("Successfully created account: %s, id: \
%s" % (cls.account.name,\
cls.account.id))
# Generate userdata of 2500 bytes. This is larger than the 2048 bytes limit.
# CS however allows for upto 4K bytes in the code. So this must succeed.
# Overall, the query length must not exceed 4K, for then the json decoder
# will fail this operation at the marvin client side itcls.
user_data = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(2500))
cls.services["virtual_machine"]["userdata"] = user_data
def setUpClass(cls):
# We want to fail quicker if it's failure
socket.setdefaulttimeout(60)
cls.api_client = super(
TestVPCNetworkPFRules,
cls
).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls._cleanup = [cls.service_offering]
return
def test_03_deploy_vm_project_limit_reached(self):
"""Test TTry to deploy VM with admin account where account has not used
the resources but @ project they are not available"""
# Validate the following
# 1. Try to deploy VM with admin account where account has not used the
# resources but @ project they are not available
# 2. Deploy VM should error out saying ResourceAllocationException
# with "resource limit exceeds"
self.debug("Creating service offering with 3 CPU cores")
self.services["service_offering"]["cpunumber"] = 3
self.service_offering = ServiceOffering.create(
self.apiclient, self.services["service_offering"])
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Setting up account and domain hierarchy")
self.setupAccounts(account_limit=4, domain_limit=4, project_limit=2)
api_client_admin = self.testClient.createUserApiClient(
UserName=self.child_do_admin.name,
DomainName=self.child_do_admin.domain)
self.debug("Deploying instance in account 2 when CPU limit is reached")
with self.assertRaises(Exception):
self.createInstance(project=self.project,
service_off=self.service_offering,
api_client=api_client_admin)
return
def test_04_deploy_multiple_vm_with_multiple_cpus(self):
"""Test Deploy multiple VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create compute offering with 4 core CPU
# 2. Deploy multiple VMs with this service offering
# 3. List Resource count for the root admin CPU usage
# 4. CPU usage should list properly
# 5. Destroy one VM among multiple VM's and verify the resource count
# 6. Migrate VM from & verify resource updates
# 7. List resource count for Root Admin
# 8. Failed to deploy VM and verify the resource usage
self.debug("Creating service offering with 4 CPU cores")
self.service_offering = ServiceOffering.create(
self.apiclient, self.services["service_offering"])
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(service_off=self.service_offering)
vm_2 = self.createInstance(service_off=self.service_offering)
self.createInstance(service_off=self.service_offering)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(
self.services["service_offering"]["cpunumber"]) * 4 #Total 4 Vms
self.assertTrue(resource_count == expected_resource_count,
"Resource count does not match the expected vavlue")
return
def setUpClass(cls):
cls._cleanup = []
cls.api_client = super(TestEgressFWRules,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone Domain and create Domains and sub Domains.
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.services['mode'] = cls.zone.networktype
# Get and set template id for VM creation.
cls.template = get_template(cls.api_client,
cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
parentDomain = None
cls.domain = Domain.create(cls.api_client,
cls.services["domain"],
parentdomainid=parentDomain.id if parentDomain else None)
cls._cleanup.append(cls.domain)
# Create an Account associated with domain
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=cls.domain.id)
cls._cleanup.append(cls.account)
# Create service offerings.
cls.service_offering = ServiceOffering.create(cls.api_client,
cls.services["service_offering"])
# Cleanup
cls._cleanup.append(cls.service_offering)
def test_04_deploy_multiple_vm_with_multiple_cpus(self):
"""Test Deploy multiple VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create compute offering with 4 core CPU
# 2. Deploy multiple VMs with this service offering
# 3. List Resource count for the root admin CPU usage
# 4. CPU usage should list properly
# 5. Destroy one VM among multiple VM's and verify the resource count
# 6. Migrate VM from & verify resource updates
# 7. List resource count for Root Admin
# 8. Failed to deploy VM and verify the resource usage
self.debug("Creating service offering with 4 CPU cores")
self.service_offering = ServiceOffering.create(
self.apiclient, self.services["service_offering"])
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(service_off=self.service_offering)
vm_2 = self.createInstance(service_off=self.service_offering)
self.createInstance(service_off=self.service_offering)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(
self.services["service_offering"]["cpunumber"]) * 4 #Total 4 Vms
self.assertTrue(resource_count == expected_resource_count,
"Resource count does not match the expected vavlue")
return
def setUpClass(cls):
cls.api_client = super(
TestCreateSnapshot,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
# Create VMs, NAT Rules etc
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls._cleanup = [
cls.service_offering,
]
return
def test_03_deploy_vm_project_limit_reached(self):
"""Test TTry to deploy VM with admin account where account has not used
the resources but @ project they are not available"""
# Validate the following
# 1. Try to deploy VM with admin account where account has not used the
# resources but @ project they are not available
# 2. Deploy VM should error out saying ResourceAllocationException
# with "resource limit exceeds"
self.debug("Creating service offering with 3 CPU cores")
self.services["service_offering"]["cpunumber"] = 3
self.service_offering = ServiceOffering.create(
self.apiclient,
self.services["service_offering"]
)
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Setting up account and domain hierarchy")
self.setupAccounts(account_limit=4, domain_limit=4, project_limit=2)
api_client_admin = self.testClient.createUserApiClient(
UserName=self.child_do_admin.name,
DomainName=self.child_do_admin.domain)
self.debug("Deploying instance in account 2 when CPU limit is reached")
with self.assertRaises(Exception):
self.createInstance(project=self.project,
service_off=self.service_offering, api_client=api_client_admin)
return
def test_01_create_service_offering(self):
"""Test to create service offering"""
# Validate the following:
# 1. createServiceOfferings should return a valid information for newly created offering
# 2. The Cloud Database contains the valid information
service_offering = ServiceOffering.create(
self.apiclient,
self.services["off"]
)
self.cleanup.append(service_offering)
self.debug("Created service offering with ID: %s" % service_offering.id)
list_service_response = list_service_offering(
self.apiclient,
id=service_offering.id
)
self.assertEqual(
isinstance(list_service_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_service_response),
0,
"Check Service offering is created"
)
service_response = list_service_response[0]
self.assertEqual(
list_service_response[0].cpunumber,
self.services["off"]["cpunumber"],
"Check server id in createServiceOffering"
)
self.assertEqual(
list_service_response[0].cpuspeed,
self.services["off"]["cpuspeed"],
"Check cpuspeed in createServiceOffering"
)
self.assertEqual(
list_service_response[0].displaytext,
self.services["off"]["displaytext"],
"Check server displaytext in createServiceOfferings"
)
self.assertEqual(
list_service_response[0].memory,
self.services["off"]["memory"],
"Check memory in createServiceOffering"
)
self.assertEqual(
list_service_response[0].name,
self.services["off"]["name"],
"Check name in createServiceOffering"
)
return
def test_deployvm_userdispersing(self):
"""Test deploy VMs using user dispersion planner
"""
self.service_offering_userdispersing = ServiceOffering.create(
self.apiclient,
self.services["service_offering"],
deploymentplanner='UserDispersingPlanner'
)
self.virtual_machine_1 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_userdispersing.id,
templateid=self.template.id
)
self.virtual_machine_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_userdispersing.id,
templateid=self.template.id
)
list_vm_1 = VirtualMachine.list(self.apiclient, id=self.virtual_machine_1.id)
list_vm_2 = VirtualMachine.list(self.apiclient, id=self.virtual_machine_2.id)
self.assertEqual(
isinstance(list_vm_1, list),
True,
"List VM response was not a valid list"
)
self.assertEqual(
isinstance(list_vm_2, list),
True,
"List VM response was not a valid list"
)
vm1 = list_vm_1[0]
vm2 = list_vm_2[0]
self.assertEqual(
vm1.state,
"Running",
msg="VM is not in Running state"
)
self.assertEqual(
vm2.state,
"Running",
msg="VM is not in Running state"
)
vm1clusterid = filter(lambda c: c.id == vm1.hostid, self.hosts)[0].clusterid
vm2clusterid = filter(lambda c: c.id == vm2.hostid, self.hosts)[0].clusterid
if vm1clusterid == vm2clusterid:
self.debug("VMs (%s, %s) meant to be dispersed are deployed in the same cluster %s" % (
vm1.id, vm2.id, vm1clusterid))
def test_deployvm_userconcentrated(self):
"""Test deploy VMs using user concentrated planner
"""
self.service_offering_userconcentrated = ServiceOffering.create(
self.apiclient,
self.services["service_offering"],
deploymentplanner='UserConcentratedPodPlanner'
)
self.virtual_machine_1 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_userconcentrated.id,
templateid=self.template.id
)
self.virtual_machine_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_userconcentrated.id,
templateid=self.template.id
)
list_vm_1 = VirtualMachine.list(self.apiclient, id=self.virtual_machine_1.id)
list_vm_2 = VirtualMachine.list(self.apiclient, id=self.virtual_machine_2.id)
self.assertEqual(
isinstance(list_vm_1, list),
True,
"List VM response was not a valid list"
)
self.assertEqual(
isinstance(list_vm_2, list),
True,
"List VM response was not a valid list"
)
vm1 = list_vm_1[0]
vm2 = list_vm_2[0]
self.assertEqual(
vm1.state,
"Running",
msg="VM is not in Running state"
)
self.assertEqual(
vm2.state,
"Running",
msg="VM is not in Running state"
)
self.assertNotEqual(
vm1.hostid,
vm2.hostid,
msg="VMs meant to be concentrated are deployed on the different hosts"
)
def setUpClass(cls):
cls.api_client = super(TestBaseImageUpdate, cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering_with_reset = ServiceOffering.create(
cls.api_client, cls.services["service_offering_with_reset"]
)
cls.service_offering_without_reset = ServiceOffering.create(
cls.api_client, cls.services["service_offering_without_reset"]
)
cls.account = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.domain.id)
cls.vm_with_reset = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_with_reset.id,
)
cls.vm_with_reset_root_disk_id = cls.get_root_device_uuid_for_vm(
cls.vm_with_reset.id, cls.vm_with_reset.rootdeviceid
)
cls.vm_without_reset = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering_without_reset.id,
)
cls.vm_without_reset_root_disk_id = cls.get_root_device_uuid_for_vm(
cls.vm_without_reset.id, cls.vm_without_reset.rootdeviceid
)
cls._cleanup = [cls.account, cls.service_offering_with_reset, cls.service_offering_without_reset]
return
def test_deployvm_userconcentrated(self):
"""Test deploy VMs using user concentrated planner
"""
self.service_offering_userconcentrated = ServiceOffering.create(
self.apiclient,
self.services["service_offering"],
deploymentplanner='UserConcentratedPodPlanner')
self.virtual_machine_1 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_userconcentrated.id,
templateid=self.template.id)
self.virtual_machine_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_userconcentrated.id,
templateid=self.template.id)
list_vm_1 = VirtualMachine.list(self.apiclient,
id=self.virtual_machine_1.id)
list_vm_2 = VirtualMachine.list(self.apiclient,
id=self.virtual_machine_2.id)
self.assertEqual(isinstance(list_vm_1, list), True,
"List VM response was not a valid list")
self.assertEqual(isinstance(list_vm_2, list), True,
"List VM response was not a valid list")
vm1 = list_vm_1[0]
vm2 = list_vm_2[0]
self.assertEqual(vm1.state,
"Running",
msg="VM is not in Running state")
self.assertEqual(vm2.state,
"Running",
msg="VM is not in Running state")
vm1clusterid = filter(lambda c: c.id == vm1.hostid,
self.hosts)[0].clusterid
vm2clusterid = filter(lambda c: c.id == vm2.hostid,
self.hosts)[0].clusterid
vm1podid = filter(lambda p: p.id == vm1clusterid,
self.clusters)[0].podid
vm2podid = filter(lambda p: p.id == vm2clusterid,
self.clusters)[0].podid
self.assertEqual(
vm1podid,
vm2podid,
msg=
"VMs (%s, %s) meant to be pod concentrated are deployed on different pods (%s, %s)"
% (vm1.id, vm2.id, vm1clusterid, vm2clusterid))
def test_deploy_virtual_machines_static_offering(self, value):
"""Test deploy VM with static offering"""
# Steps:
# 1. Create admin/user account and create its user api client
# 2. Create a static compute offering
# 3. Deploy a VM with account api client and static service offering
# 4. Repeat step 3 but also pass custom values for cpu number, cpu speed and memory
# while deploying VM
# Validations:
# 1. Step 3 should succeed
# 2. Step 4 should fail
isadmin=True
if value == USER_ACCOUNT:
isadmin=False
# Create Account
self.account = Account.create(self.apiclient,self.services["account"],domainid=self.domain.id, admin=isadmin)
apiclient = self.testClient.createUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
self.cleanup.append(self.account)
# Create service offering
self.services["service_offering"]["cpunumber"] = 2
self.services["service_offering"]["cpuspeed"] = 256
self.services["service_offering"]["memory"] = 128
serviceOffering = ServiceOffering.create(self.apiclient,
self.services["service_offering"])
self.cleanup_co.append(serviceOffering)
# Deploy VM with static service offering
try:
VirtualMachine.create(apiclient,self.services["virtual_machine"],
serviceofferingid=serviceOffering.id,
accountid=self.account.name,domainid=self.account.domainid)
except Exception as e:
self.fail("vm creation failed: %s" % e)
# Deploy VM with static service offering, also with custom values
try:
VirtualMachine.create(apiclient,self.services["virtual_machine"],
serviceofferingid=serviceOffering.id,
customcpunumber=4,
customcpuspeed=512,
custommemory=256,
accountid=self.account.name,domainid=self.account.domainid)
self.fail("VM creation should have failed, it succeeded")
except Exception as e:
self.debug("vm creation failed as expected: %s" % e)
return
def setUpClass(cls):
cls.services = Services().services
cls.apiclient = super(TestDeployVM, cls).getClsTestClient().getApiClient()
# Get Zone, Domain and templates
domain = get_domain(cls.apiclient, cls.services)
cls.zone = get_zone(cls.apiclient, cls.services)
cls.services['mode'] = cls.zone.networktype
#If local storage is enabled, alter the offerings to use localstorage
#this step is needed for devcloud
if cls.zone.localstorageenabled == True:
cls.services["service_offerings"]["tiny"]["storagetype"] = 'local'
cls.services["service_offerings"]["small"]["storagetype"] = 'local'
cls.services["service_offerings"]["medium"]["storagetype"] = 'local'
template = get_template(
cls.apiclient,
cls.zone.id,
cls.services["ostype"]
)
# Set Zones and disk offerings
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["small"]["template"] = template.id
cls.services["medium"]["zoneid"] = cls.zone.id
cls.services["medium"]["template"] = template.id
cls.services["iso"]["zoneid"] = cls.zone.id
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
domainid=domain.id
)
cls.debug(cls.account.id)
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["service_offerings"]["tiny"]
)
cls.virtual_machine = VirtualMachine.create(
cls.apiclient,
cls.services["small"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
mode=cls.services['mode']
)
cls.cleanup = [
cls.service_offering,
cls.account
]
def setUpClass(cls):
cls.api_client = super(TestServiceOfferings,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.services['mode'] = cls.zone.networktype
cls.service_offering_1 = ServiceOffering.create(
cls.api_client, cls.services["off"])
cls.service_offering_2 = ServiceOffering.create(
cls.api_client, cls.services["off"])
template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
# Set Zones and disk offerings
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["small"]["template"] = template.id
cls.services["medium"]["zoneid"] = cls.zone.id
cls.services["medium"]["template"] = template.id
# Create VMs, NAT Rules etc
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=domain.id)
cls.small_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offerings"]["small"])
cls.medium_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offerings"]["medium"])
cls.medium_virtual_machine = VirtualMachine.create(
cls.api_client,
cls.services["medium"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.medium_offering.id,
mode=cls.services["mode"])
cls._cleanup = [cls.small_offering, cls.medium_offering, cls.account]
return
def setUp(self):
self.testdata = TestData().testdata
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.testdata)
self.zone = get_zone(self.apiclient, self.testdata)
self.testdata["mode"] = self.zone.networktype
self.template = get_template(self.apiclient, self.zone.id,
self.testdata["ostype"])
#create a user account
self.account = Account.create(self.apiclient,
self.testdata["account"],
domainid=self.domain.id)
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient, self.testdata["service_offering"]["small"])
#build cleanup list
self.cleanup = [self.service_offering, self.account]
# Validate the following:
# 1. Virtual Machine is accessible via SSH
# 2. listVirtualMachines returns accurate information
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
templateid=self.template.id)
list_vms = VirtualMachine.list(self.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.assertNotEqual(len(list_vms), 0, "List VM response was empty")
vm = list_vms[0]
self.assertEqual(vm.id, self.virtual_machine.id,
"Virtual Machine ids do not match")
self.assertEqual(vm.name, self.virtual_machine.name,
"Virtual Machine names do not match")
self.assertEqual(vm.state, "Running", msg="VM is not in Running state")
def test_deployvm_userdispersing(self):
"""Test deploy VMs using user dispersion planner
"""
self.service_offering_userdispersing = ServiceOffering.create(
self.apiclient,
self.services["service_offering"],
deploymentplanner='UserDispersingPlanner')
self.virtual_machine_1 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_userdispersing.id,
templateid=self.template.id)
self.virtual_machine_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering_userdispersing.id,
templateid=self.template.id)
list_vm_1 = VirtualMachine.list(self.apiclient,
id=self.virtual_machine_1.id)
list_vm_2 = VirtualMachine.list(self.apiclient,
id=self.virtual_machine_2.id)
self.assertEqual(isinstance(list_vm_1, list), True,
"List VM response was not a valid list")
self.assertEqual(isinstance(list_vm_2, list), True,
"List VM response was not a valid list")
vm1 = list_vm_1[0]
vm2 = list_vm_2[0]
self.assertEqual(vm1.state,
"Running",
msg="VM is not in Running state")
self.assertEqual(vm2.state,
"Running",
msg="VM is not in Running state")
vm1clusterid = filter(lambda c: c.id == vm1.hostid,
self.hosts)[0].clusterid
vm2clusterid = filter(lambda c: c.id == vm2.hostid,
self.hosts)[0].clusterid
if vm1clusterid == vm2clusterid:
self.debug(
"VMs (%s, %s) meant to be dispersed are deployed in the same cluster %s"
% (vm1.id, vm2.id, vm1clusterid))
def setUpClass(cls):
cls.api_client = super(TestVMPlacement, cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.pod = get_pod(cls.api_client, zoneid=cls.zone.id, services=cls.services)
cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"], offerha=True)
cls._cleanup = [cls.service_offering]
return
def setUpClass(cls):
cls.api_client = super(TestVPCNetworkLBRules,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
cls._cleanup = [cls.service_offering]
return
def setUpClass(cls):
cls.api_client = super(TestAntiAffinityRules, cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"], offerha=True)
cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id)
cls._cleanup = [cls.account]
return
def setUpClass(cls):
cls.services = Services().services
cls.apiclient = super(TestDeployVM,
cls).getClsTestClient().getApiClient()
# Get Zone, Domain and templates
domain = get_domain(cls.apiclient, cls.services)
cls.zone = get_zone(cls.apiclient, cls.services)
cls.services['mode'] = cls.zone.networktype
#If local storage is enabled, alter the offerings to use localstorage
#this step is needed for devcloud
if cls.zone.localstorageenabled == True:
cls.services["service_offerings"]["tiny"]["storagetype"] = 'local'
cls.services["service_offerings"]["small"]["storagetype"] = 'local'
cls.services["service_offerings"]["medium"][
"storagetype"] = 'local'
template = get_template(cls.apiclient, cls.zone.id,
cls.services["ostype"])
# Set Zones and disk offerings
cls.services["small"]["zoneid"] = cls.zone.id
cls.services["small"]["template"] = template.id
cls.services["medium"]["zoneid"] = cls.zone.id
cls.services["medium"]["template"] = template.id
cls.services["iso"]["zoneid"] = cls.zone.id
cls.account = Account.create(cls.apiclient,
cls.services["account"],
domainid=domain.id)
cls.debug(cls.account.id)
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.services["service_offerings"]["tiny"])
cls.virtual_machine = VirtualMachine.create(
cls.apiclient,
cls.services["small"],
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
mode=cls.services['mode'])
cls.cleanup = [cls.service_offering, cls.account]
def test_create_dynamic_compute_offering_no_memory(self):
""" Create dynamic compute offering with only memory unspecified"""
# Validations:
# 1. Compute offering creation should fail
self.services["service_offering"]["cpunumber"] = 2
self.services["service_offering"]["cpuspeed"] = 256
self.services["service_offering"]["memory"] = ""
try:
serviceOffering = ServiceOffering.create(self.api_client,
self.services["service_offering"]
)
self.cleanup_co.append(serviceOffering)
self.fail("Compute Offering creation succeded, it should have failed")
except Exception:
self.debug("Compute Offering Creation failed as expected")
return
def setUpClass(cls):
cls.api_client = super(TestDomainCPULimitsConfiguration,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.services["mode"] = cls.zone.networktype
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls._cleanup = [
cls.service_offering,
]
return
def setUp(self):
self.testdata = TestData().testdata
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.testdata)
self.zone = get_zone(self.apiclient, self.testdata)
self.testdata["mode"] = self.zone.networktype
self.template = get_template(self.apiclient, self.zone.id,
self.testdata["ostype"])
#create a user account
self.account = Account.create(self.apiclient,
self.testdata["account"],
domainid=self.domain.id)
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient, self.testdata["service_offering"]["small"])
#build cleanup list
self.cleanup = [self.service_offering, self.account]
def setUpClass(cls):
cloudstackTestClient = super(TestBasicOperations,cls).getClsTestClient()
cls.api_client = cloudstackTestClient.getApiClient()
# Fill services from the external config file
cls.services = cloudstackTestClient.getConfigParser().parsedDict
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.mode = str(cls.zone.networktype).lower()
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls._cleanup = [cls.service_offering]
cls.services["shared_network_offering"]["specifyVlan"] = "True"
cls.services["shared_network_offering"]["specifyIpRanges"] = "True"
cls.shared_network_offering = CreateEnabledNetworkOffering(cls.api_client,
cls.services["shared_network_offering"])
cls._cleanup.append(cls.shared_network_offering)
if cls.mode == "advanced":
cls.isolated_network_offering = CreateEnabledNetworkOffering(cls.api_client,
cls.services["isolated_network_offering"])
cls._cleanup.append(cls.isolated_network_offering)
cls.isolated_network_offering_vpc = CreateEnabledNetworkOffering(cls.api_client,
cls.services["nw_offering_isolated_vpc"])
cls._cleanup.append(cls.isolated_network_offering_vpc)
cls.vpc_off = VpcOffering.create(cls.api_client, cls.services["vpc_offering"])
cls.vpc_off.update(cls.api_client, state='Enabled')
cls._cleanup.append(cls.vpc_off)
return
def setUpClass(cls):
cls.api_client = super(TestAntiAffinityRules,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"], offerha=True)
cls.account = Account.create(cls.api_client,
cls.services["account"],
domainid=cls.domain.id)
cls._cleanup = [cls.account]
return
def setUpClass(cls):
cls.api_client = super(TestVMPlacement,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.pod = get_pod(cls.api_client,
zoneid=cls.zone.id,
services=cls.services)
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"], offerha=True)
cls._cleanup = [
cls.service_offering,
]
return
def test_01_create_service_offering(self):
"""Test to create service offering"""
# Validate the following:
# 1. createServiceOfferings should return a valid information for newly created offering
# 2. The Cloud Database contains the valid information
service_offering = ServiceOffering.create(self.apiclient,
self.services["off"])
self.cleanup.append(service_offering)
self.debug("Created service offering with ID: %s" %
service_offering.id)
list_service_response = list_service_offering(self.apiclient,
id=service_offering.id)
self.assertEqual(isinstance(list_service_response, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(list_service_response), 0,
"Check Service offering is created")
service_response = list_service_response[0]
self.assertEqual(list_service_response[0].cpunumber,
self.services["off"]["cpunumber"],
"Check server id in createServiceOffering")
self.assertEqual(list_service_response[0].cpuspeed,
self.services["off"]["cpuspeed"],
"Check cpuspeed in createServiceOffering")
self.assertEqual(list_service_response[0].displaytext,
self.services["off"]["displaytext"],
"Check server displaytext in createServiceOfferings")
self.assertEqual(list_service_response[0].memory,
self.services["off"]["memory"],
"Check memory in createServiceOffering")
self.assertEqual(list_service_response[0].name,
self.services["off"]["name"],
"Check name in createServiceOffering")
return
def test_create_dynamic_compute_offering(self):
""" Create dynamic compute offering with cpunumber, cpuspeed and memory
not specified"""
# Steps:
# 1. Create dynamic compute offering with values for cpu number,
# cpu speed, memory not specified
# Validations:
# 1. Compute offering should be created
self.services["service_offering"]["cpunumber"] = ""
self.services["service_offering"]["cpuspeed"] = ""
self.services["service_offering"]["memory"] = ""
serviceOffering = ServiceOffering.create(self.api_client,
self.services["service_offering"]
)
self.assertEqual(verifyComputeOfferingCreation(self.apiclient, serviceOffering.id),
PASS, "Compute Offering verification failed")
self.cleanup_co.append(serviceOffering)
return
def test_create_normal_compute_offering(self):
""" Create normal compute offering with non zero values for cpu,
cpu number and memory"""
# Steps:
# 1. Create normal compute offering with non zero values for cpu number,
# cpu speed, memory
# Validations:
# 1. Compute offering should be created
self.services["service_offering"]["cpunumber"] = 2
self.services["service_offering"]["cpuspeed"] = 256
self.services["service_offering"]["memory"] = 128
serviceOffering = ServiceOffering.create(self.api_client,
self.services["service_offering"]
)
self.assertEqual(verifyComputeOfferingCreation(self.apiclient, serviceOffering.id),
PASS, "Compute Offering verification failed")
self.cleanup_co.append(serviceOffering)
return
def test_01_multiple_child_domains(self):
"""Test CPU limits with multiple child domains"""
# Validate the following
# 1. Create Domain1 with 10 core CPU and 2 child domains with 4 core
# each.Assign 2 cores for Domain1 admin1 & Domain1 User1 .Assign 2
# cores for Domain2 admin1 & Domain2 User1
# 2. Deploy VM's by Domain1 admin1/user1/ Domain2 user1/Admin1 account
# and verify the resource updates
# 3. Deploy VM by admin account after reaching max parent domain limit
# 4. Deploy VM with child account after reaching max child domain limit
# 5. Destroy user/admin account VM's and verify the child & Parent
# domain resource updates
self.debug("Creating service offering with 2 CPU cores")
self.services["service_offering"]["cpunumber"] = 2
self.service_offering = ServiceOffering.create(
self.apiclient,
self.services["service_offering"]
)
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
api_client_cadmin_1 = self.testClient.createUserApiClient(
UserName=self.cadmin_1.name,
DomainName=self.cadmin_1.domain)
api_client_cadmin_2 = self.testClient.createUserApiClient(
UserName=self.cadmin_2.name,
DomainName=self.cadmin_2.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(account=self.cadmin_1,
service_off=self.service_offering, api_client=api_client_cadmin_1)
vm_2 = self.createInstance(account=self.cadmin_2,
service_off=self.service_offering, api_client=api_client_cadmin_2)
self.debug("Checking resource count for account: %s" % self.cadmin_1.name)
account_list = Account.list(self.apiclient, id=self.cadmin_1.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_cadmin_1 = account_list[0].cputotal
self.debug(resource_count_cadmin_1)
self.debug("Checking resource count for account: %s" % self.cadmin_2.name)
account_list = Account.list(self.apiclient, id=self.cadmin_2.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_cadmin_2 = account_list[0].cputotal
self.debug(resource_count_cadmin_2)
self.debug(
"Creating instance when CPU limit is fully used in child domain 1")
with self.assertRaises(Exception):
self.createInstance(account=self.cadmin_1,
service_off=self.service_offering, api_client=api_client_cadmin_1)
self.debug(
"Creating instance when CPU limit is fully used in child domain 2")
with self.assertRaises(Exception):
self.createInstance(account=self.cadmin_2,
service_off=self.service_offering, api_client=api_client_cadmin_2)
self.debug("Destroying instances: %s, %s" % (vm_1.name, vm_2.name))
try:
vm_1.delete(self.apiclient)
vm_2.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
self.debug("Checking resource count for account: %s" % self.cadmin_1.name)
account_list = Account.list(self.apiclient, id=self.cadmin_1.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_cadmin_1 = account_list[0].cputotal
self.debug(resource_count_cadmin_1)
self.assertEqual(resource_count_cadmin_1, 0, "Resource count for %s should be 0" % get_resource_type(resource_id=8))#CPU
self.debug("Checking resource count for account: %s" % self.cadmin_2.name)
account_list = Account.list(self.apiclient, id=self.cadmin_2.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_cadmin_2 = account_list[0].cputotal
self.debug(resource_count_cadmin_2)
self.assertEqual(resource_count_cadmin_2, 0, "Resource count for %s should be 0" % get_resource_type(resource_id=8))#CPU
return
def setUpClass(cls):
cls._cleanup = []
cls.api_client = super(TestVMOwnership,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone Domain and create Domains and sub Domains.
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.services['mode'] = cls.zone.networktype
# Get and set template id for VM creation.
cls.template = get_template(cls.api_client,
cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
def create_domain_account_user(parentDomain=None):
domain = Domain.create(cls.api_client,
cls.services["domain"],
parentdomainid=parentDomain.id if parentDomain else None)
cls._cleanup.append(domain)
# Create an Account associated with domain
account = Account.create(cls.api_client,
cls.services["account"],
domainid=domain.id)
cls._cleanup.append(account)
# Create an User, Project, Volume associated with account
user = User.create(cls.api_client,
cls.services["user"],
account=account.name,
domainid=account.domainid)
cls._cleanup.append(user)
project = Project.create(cls.api_client,
cls.services["project"],
account=account.name,
domainid=account.domainid)
cls._cleanup.append(project)
volume = Volume.create(cls.api_client,
cls.services["volume"],
zoneid=cls.zone.id,
account=account.name,
domainid=account.domainid,
diskofferingid=cls.disk_offering.id)
cls._cleanup.append(volume)
return {'domain':domain, 'account':account, 'user':user, 'project':project, 'volume':volume}
# Create disk offerings.
try:
cls.disk_offering = DiskOffering.create(cls.api_client,
cls.services["disk_offering"])
# Create service offerings.
cls.service_offering = ServiceOffering.create(cls.api_client,
cls.services["service_offering"])
# Cleanup
cls._cleanup = [cls.service_offering]
# Create domain, account, user, project and volumes.
cls.domain_account_user1 = create_domain_account_user()
cls.domain_account_user2 = create_domain_account_user()
cls.sdomain_account_user1 = create_domain_account_user(cls.domain_account_user1['domain'])
cls.sdomain_account_user2 = create_domain_account_user(cls.domain_account_user2['domain'])
cls.ssdomain_account_user2 = create_domain_account_user(cls.sdomain_account_user2['domain'])
except Exception as e:
raise e
return
def setUp(self):
self.testdata = TestData().testdata
self.apiclient = self.testClient.getApiClient()
# Get Zone, Domain and Default Built-in template
self.domain = get_domain(self.apiclient, self.testdata)
self.zone = get_zone(self.apiclient, self.testdata)
self.testdata["mode"] = self.zone.networktype
self.template = get_template(self.apiclient, self.zone.id, self.testdata["ostype"])
self.hosts = []
suitablecluster = None
clusters = Cluster.list(self.apiclient)
self.assertTrue(isinstance(clusters, list) and len(clusters) > 0, msg = "No clusters found")
for cluster in clusters:
self.hosts = Host.list(self.apiclient, clusterid=cluster.id, type='Routing')
if isinstance(self.hosts, list) and len(self.hosts) >= 2:
suitablecluster = cluster
break
self.assertTrue(isinstance(self.hosts, list) and len(self.hosts) >= 2, msg = "Atleast 2 hosts required in cluster for VM HA test")
#update host tags
for host in self.hosts:
Host.update(self.apiclient, id=host.id, hosttags=self.testdata["service_offering"]["hasmall"]["hosttags"])
#create a user account
self.account = Account.create(
self.apiclient,
self.testdata["account"],
domainid=self.domain.id
)
#create a service offering
self.service_offering = ServiceOffering.create(
self.apiclient,
self.testdata["service_offering"]["hasmall"]
)
#deploy ha vm
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
templateid=self.template.id
)
list_vms = VirtualMachine.list(self.apiclient, id=self.virtual_machine.id)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s"\
% self.virtual_machine.id
)
self.assertTrue(isinstance(list_vms, list) and len(list_vms) == 1, msg = "List VM response was empty")
self.virtual_machine = list_vms[0]
self.mock_checkhealth = SimulatorMock.create(
apiclient=self.apiclient,
command="CheckHealthCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
clusterid=suitablecluster.id,
hostid=self.virtual_machine.hostid,
value="result:fail")
self.mock_ping = SimulatorMock.create(
apiclient=self.apiclient,
command="PingCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
clusterid=suitablecluster.id,
hostid=self.virtual_machine.hostid,
value="result:fail")
self.mock_checkvirtualmachine = SimulatorMock.create(
apiclient=self.apiclient,
command="CheckVirtualMachineCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
clusterid=suitablecluster.id,
hostid=self.virtual_machine.hostid,
value="result:fail")
self.mock_pingtest = SimulatorMock.create(
apiclient=self.apiclient,
command="PingTestCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
value="result:fail")
self.mock_checkonhost_list = []
for host in self.hosts:
if host.id != self.virtual_machine.hostid:
self.mock_checkonhost_list.append(SimulatorMock.create(
apiclient=self.apiclient,
command="CheckOnHostCommand",
zoneid=suitablecluster.zoneid,
podid=suitablecluster.podid,
clusterid=suitablecluster.id,
hostid=host.id,
value="result:fail"))
#build cleanup list
self.cleanup = [
self.service_offering,
self.account,
self.mock_checkhealth,
self.mock_ping,
self.mock_checkvirtualmachine,
self.mock_pingtest
]
self.cleanup = self.cleanup + self.mock_checkonhost_list
def test_04_deploy_multiple_vm_with_multiple_core(self):
"""Test Deploy multiple VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create compute offering with 4 core CPU
# 2. Deploy multiple VMs within domain with this service offering
# 3. Update Resource count for the domain
# 4. CPU usage should list properly
self.debug("Creating service offering with 4 CPU cores")
self.service_offering = ServiceOffering.create(
self.apiclient,
self.services["service_offering"]
)
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {self.domain: self.admin,
self.child_domain: self.child_do_admin
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
api_client = self.testClient.createUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(service_off=self.service_offering, api_client=api_client)
vm_2 = self.createInstance(service_off=self.service_offering, api_client=api_client)
self.createInstance(service_off=self.service_offering, api_client=api_client)
self.createInstance(service_off=self.service_offering, api_client=api_client)
self.debug("Deploying instance - CPU capacity is fully utilized")
with self.assertRaises(Exception):
self.createInstance(service_off=self.service_offering, api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].cputotal
expected_resource_count = int(self.services["service_offering"]["cpunumber"]) * 4 #Total 4 VMs
self.assertEqual(resource_count, expected_resource_count,
"Initial resource count should be 4")
self.debug("Destroying instance: %s" % vm_1.name)
try:
vm_1.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_delete = account_list[0].cputotal
expected_resource_count -= int(self.services["service_offering"]["cpunumber"])
self.assertEqual(resource_count_after_delete, expected_resource_count,
"Resource count should match with the expected count")
host = findSuitableHostForMigration(self.apiclient, vm_2.id)
if host is None:
self.skipTest(ERROR_NO_HOST_FOR_MIGRATION)
self.debug("Migrating instance: %s to host: %s" % (vm_2.name,
host.name))
try:
vm_2.migrate(self.apiclient, host.id)
except Exception as e:
self.fail("Failed to migrate instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_migrate = account_list[0].cputotal
self.assertEqual(resource_count_after_migrate, resource_count_after_delete,
"Resource count should not change after migrating the instance")
return
def test_01_change_service_offering(self):
"""Test Deploy VM with 5 GB RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with 5 GB RAM & Deploy VM in the created domain
# 2. List Resource count for the root admin Memory usage
# 3. Upgrade and downgrade service offering
# 4. Resource count should list properly for the domain
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = { self.domain: self.admin,
self.child_domain: self.child_do_admin
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
api_client = self.testClient.createUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
vm = self.createInstance(service_off=self.service_offering, api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count = account_list[0].memorytotal
expected_resource_count = int(self.services["service_offering"]["memory"])
self.assertEqual(resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Stopping instance: %s" % vm.name)
try:
vm.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_stop = account_list[0].memorytotal
self.asserEqual(resource_count_after_stop, expected_resource_count,
"Resource count should be same after stopping the instance")
self.debug("Creating service offering with 7 GB RAM")
self.services["service_offering"]["memory"] = 7168
self.service_offering_7gb = ServiceOffering.create(
self.apiclient,
self.services["service_offering"]
)
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering_7gb)
self.debug(
"Upgrade service offering of instance %s from %s to %s" %
(vm.name,
self.service_offering.name,
self.service_offering_7gb.name))
try:
vm.change_service_offering(self.apiclient,
serviceOfferingId=self.service_offering_7gb.id)
except Exception as e:
self.fail("Failed to change service offering of vm %s - %s" %
(vm.name, e))
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_upgrade = account_list[0].memorytotal
self.debug(resource_count_after_upgrade)
self.assertTrue(resource_count_after_upgrade > resource_count_after_stop,
"Resource count should be more than before, after upgrading service offering")
self.debug(
"Down grade service offering of instance %s from %s to %s" %
(vm.name,
self.service_offering_7gb.name,
self.service_offering.name))
try:
vm.change_service_offering(self.apiclient,
serviceOfferingId=self.service_offering.id)
except Exception as e:
self.fail("Failed to change service offering of vm %s - %s" %
(vm.name, e))
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_downgrade = account_list[0].memorytotal
self.assertTrue(resource_count_after_downgrade < resource_count_after_upgrade,
"Resource count should be less than before, after downgrading service offering")
self.debug("Starting instance: %s" % vm.name)
try:
vm.start(self.apiclient)
except Exception as e:
self.fail("Failed to start instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(account_list,
list,
"List Accounts should return a valid response"
)
resource_count_after_start = account_list[0].memorytotal
self.assertTrue(resource_count_after_start == resource_count_after_downgrade,
"Resource count should be same after starting the instance")
return
def test_01_change_service_offering(self):
"""Test Deploy VM with specified RAM & verify the usage"""
# Validate the following
# 1. Create compute offering with specified RAM & Deploy VM in the created domain
# 2. List Resource count for the root admin Memory usage
# 3. Upgrade and downgrade service offering
# 4. Resource count should list properly for the domain
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
#Resetting memory count in service offering
self.services["service_offering"]["memory"] = 2048
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
vm = self.createInstance(service_off=self.service_offering,
api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].memorytotal
expected_resource_count = int(
self.services["service_offering"]["memory"])
self.assertEqual(
resource_count, expected_resource_count,
"Resource count should match with the expected resource count")
self.debug("Stopping instance: %s" % vm.name)
try:
vm.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_stop = account_list[0].memorytotal
self.assertEqual(
resource_count_after_stop, expected_resource_count,
"Resource count should be same after stopping the instance")
self.debug("Creating service offering with 5 GB RAM")
self.services["service_offering"]["memory"] = 5120
self.service_offering_5gb = ServiceOffering.create(
self.apiclient, self.services["service_offering"])
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering_5gb)
self.debug(
"Upgrade service offering of instance %s from %s to %s" %
(vm.name, self.service_offering.name,
self.service_offering_5gb.name))
try:
vm.change_service_offering(
self.apiclient,
serviceOfferingId=self.service_offering_5gb.id)
except Exception as e:
self.fail("Failed to change service offering of vm %s - %s" %
(vm.name, e))
update_resource_count(self.apiclient,
domainid=self.domain.id,
rtype=9) #RAM
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_upgrade = account_list[0].memorytotal
self.debug(resource_count_after_upgrade)
self.assertTrue(
resource_count_after_upgrade > resource_count_after_stop,
"Resource count should be more than before, after upgrading service offering"
)
self.debug(
"Down grade service offering of instance %s from %s to %s" %
(vm.name, self.service_offering_5gb.name,
self.service_offering.name))
try:
vm.change_service_offering(
self.apiclient, serviceOfferingId=self.service_offering.id)
except Exception as e:
self.fail("Failed to change service offering of vm %s - %s" %
(vm.name, e))
update_resource_count(self.apiclient,
domainid=self.domain.id,
rtype=9) #RAM
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_downgrade = account_list[0].memorytotal
self.debug(resource_count_after_downgrade)
self.assertTrue(
resource_count_after_downgrade < resource_count_after_upgrade,
"Resource count should be less than before, after downgrading service offering"
)
self.debug("Starting instance: %s" % vm.name)
try:
vm.start(self.apiclient)
except Exception as e:
self.fail("Failed to start instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_start = account_list[0].memorytotal
self.assertTrue(
resource_count_after_start == resource_count_after_downgrade,
"Resource count should be same after starting the instance")
return
def test_vm_creation_in_fully_automated_mode(self):
""" Test VM Creation in automation mode = Fully automated
This test requires following preconditions:
- DRS Cluster is configured in "Fully automated" mode
"""
# Validate the following
# 1. Create a new VM in a host which is almost fully utilized
# 2 Automatically places VM on the other host
# 3. VM state is running after deployment
hosts = Host.list(self.apiclient,
zoneid=self.zone.id,
resourcestate='Enabled',
type='Routing')
self.assertEqual(isinstance(hosts, list), True,
"List hosts should return valid host response")
self.assertGreaterEqual(
len(hosts), 2, "There must be two hosts present in a cluster")
host_1 = hosts[0]
#Convert available memory( Keep some margin) into MBs and assign to service offering
self.services["service_offering_max_memory"]["memory"] = int(
(int(hosts[0].memorytotal) - int(hosts[0].memoryused)) / 1048576 -
1024)
self.debug("max memory: %s" %
self.services["service_offering_max_memory"]["memory"])
service_offering_max_memory = ServiceOffering.create(
self.apiclient, self.services["service_offering_max_memory"])
VirtualMachine.create(self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=service_offering_max_memory.id,
hostid=host_1.id)
# Host 1 has only 1024 MB memory available now after deploying the instance
# We are trying to deploy an instance with 2048 MB memory, this should automatically
# get deployed on other host which has the enough capacity
self.debug(
"Trying to deploy instance with memory requirement more than that is available on\
the first host")
self.debug("Deploying VM in account: %s" % self.account.name)
# Spawn an instance in that network
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
vms = VirtualMachine.list(self.apiclient,
id=virtual_machine.id,
listall=True)
self.assertEqual(
isinstance(vms, list), True,
"List VMs should return valid response for deployed VM")
self.assertNotEqual(
len(vms), 0,
"List VMs should return valid response for deployed VM")
vm = vms[0]
self.assertEqual(vm.state, "Running",
"Deployed VM should be in RUnning state")
self.assertNotEqual(
vm.hostid, host_1.id,
"Host Ids of two should not match as one host is full")
self.debug(
"The host ids of two virtual machines are different as expected\
they are %s and %s" % (vm.hostid, host_1.id))
return
def setUpClass(cls):
cls._cleanup = []
cls.api_client = super(TestVMOwnership,
cls).getClsTestClient().getApiClient()
cls.services = Services().services
# Get Zone Domain and create Domains and sub Domains.
cls.domain = get_domain(cls.api_client, cls.services)
cls.zone = get_zone(cls.api_client, cls.services)
cls.services['mode'] = cls.zone.networktype
# Get and set template id for VM creation.
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
def create_domain_account_user(parentDomain=None):
domain = Domain.create(
cls.api_client,
cls.services["domain"],
parentdomainid=parentDomain.id if parentDomain else None)
cls._cleanup.append(domain)
# Create an Account associated with domain
account = Account.create(cls.api_client,
cls.services["account"],
domainid=domain.id)
cls._cleanup.append(account)
# Create an User, Project, Volume associated with account
user = User.create(cls.api_client,
cls.services["user"],
account=account.name,
domainid=account.domainid)
cls._cleanup.append(user)
project = Project.create(cls.api_client,
cls.services["project"],
account=account.name,
domainid=account.domainid)
cls._cleanup.append(project)
volume = Volume.create(cls.api_client,
cls.services["volume"],
zoneid=cls.zone.id,
account=account.name,
domainid=account.domainid,
diskofferingid=cls.disk_offering.id)
cls._cleanup.append(volume)
return {
'domain': domain,
'account': account,
'user': user,
'project': project,
'volume': volume
}
# Create disk offerings.
try:
cls.disk_offering = DiskOffering.create(
cls.api_client, cls.services["disk_offering"])
# Create service offerings.
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
# Cleanup
cls._cleanup.append(cls.service_offering)
# Create domain, account, user, project and volumes.
cls.domain_account_user1 = create_domain_account_user()
cls.domain_account_user2 = create_domain_account_user()
cls.sdomain_account_user1 = create_domain_account_user(
cls.domain_account_user1['domain'])
cls.sdomain_account_user2 = create_domain_account_user(
cls.domain_account_user2['domain'])
cls.ssdomain_account_user2 = create_domain_account_user(
cls.sdomain_account_user2['domain'])
except Exception as e:
raise e
return
def test_04_deploy_multiple_vm_with_multiple_core(self):
"""Test Deploy multiple VM with 4 core CPU & verify the usage"""
# Validate the following
# 1. Create compute offering with 4 core CPU
# 2. Deploy multiple VMs within domain with this service offering
# 3. Update Resource count for the domain
# 4. CPU usage should list properly
self.debug("Creating service offering with 4 CPU cores")
self.service_offering = ServiceOffering.create(
self.apiclient, self.services["service_offering"])
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.domain: self.admin,
self.child_domain: self.child_do_admin
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(service_off=self.service_offering,
api_client=api_client)
vm_2 = self.createInstance(service_off=self.service_offering,
api_client=api_client)
self.createInstance(service_off=self.service_offering,
api_client=api_client)
self.createInstance(service_off=self.service_offering,
api_client=api_client)
self.debug("Deploying instance - CPU capacity is fully utilized")
with self.assertRaises(Exception):
self.createInstance(service_off=self.service_offering,
api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(self.services["service_offering"]
["cpunumber"]) * 4 #Total 4 VMs
self.assertEqual(resource_count, expected_resource_count,
"Initial resource count should be 4")
self.debug("Destroying instance: %s" % vm_1.name)
try:
vm_1.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_delete = account_list[0].cputotal
expected_resource_count -= int(
self.services["service_offering"]["cpunumber"])
self.assertEqual(
resource_count_after_delete, expected_resource_count,
"Resource count should match with the expected count")
host = find_suitable_host(self.apiclient, vm_2)
self.debug("Migrating instance: %s to host: %s" %
(vm_2.name, host.name))
try:
vm_2.migrate(self.apiclient, host.id)
except Exception as e:
self.fail("Failed to migrate instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_migrate = account_list[0].cputotal
self.assertEqual(
resource_count_after_migrate, resource_count_after_delete,
"Resource count should not change after migrating the instance"
)
return
def test_01_multiple_child_domains(self):
"""Test CPU limits with multiple child domains"""
# Validate the following
# 1. Create Domain1 with 10 core CPU and 2 child domains with 4 core
# each.Assign 2 cores for Domain1 admin1 & Domain1 User1 .Assign 2
# cores for Domain2 admin1 & Domain2 User1
# 2. Deploy VM's by Domain1 admin1/user1/ Domain2 user1/Admin1 account
# and verify the resource updates
# 3. Deploy VM by admin account after reaching max parent domain limit
# 4. Deploy VM with child account after reaching max child domain limit
# 5. Destroy user/admin account VM's and verify the child & Parent
# domain resource updates
self.debug("Creating service offering with 2 CPU cores")
self.services["service_offering"]["cpunumber"] = 2
self.service_offering = ServiceOffering.create(
self.apiclient, self.services["service_offering"])
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
api_client_cadmin_1 = self.testClient.createUserApiClient(
UserName=self.cadmin_1.name, DomainName=self.cadmin_1.domain)
api_client_cadmin_2 = self.testClient.createUserApiClient(
UserName=self.cadmin_2.name, DomainName=self.cadmin_2.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(account=self.cadmin_1,
service_off=self.service_offering,
api_client=api_client_cadmin_1)
vm_2 = self.createInstance(account=self.cadmin_2,
service_off=self.service_offering,
api_client=api_client_cadmin_2)
self.debug("Checking resource count for account: %s" %
self.cadmin_1.name)
account_list = Account.list(self.apiclient, id=self.cadmin_1.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_cadmin_1 = account_list[0].cputotal
self.debug(resource_count_cadmin_1)
self.debug("Checking resource count for account: %s" %
self.cadmin_2.name)
account_list = Account.list(self.apiclient, id=self.cadmin_2.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_cadmin_2 = account_list[0].cputotal
self.debug(resource_count_cadmin_2)
self.debug(
"Creating instance when CPU limit is fully used in child domain 1")
with self.assertRaises(Exception):
self.createInstance(account=self.cadmin_1,
service_off=self.service_offering,
api_client=api_client_cadmin_1)
self.debug(
"Creating instance when CPU limit is fully used in child domain 2")
with self.assertRaises(Exception):
self.createInstance(account=self.cadmin_2,
service_off=self.service_offering,
api_client=api_client_cadmin_2)
self.debug("Destroying instances: %s, %s" % (vm_1.name, vm_2.name))
try:
vm_1.delete(self.apiclient)
vm_2.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
self.debug("Checking resource count for account: %s" %
self.cadmin_1.name)
account_list = Account.list(self.apiclient, id=self.cadmin_1.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_cadmin_1 = account_list[0].cputotal
self.debug(resource_count_cadmin_1)
self.assertEqual(resource_count_cadmin_1, 0,
"Resource count for %s should be 0" %
get_resource_type(resource_id=8)) #CPU
self.debug("Checking resource count for account: %s" %
self.cadmin_2.name)
account_list = Account.list(self.apiclient, id=self.cadmin_2.id)
self.assertIsInstance(account_list, list,
"List Accounts should return a valid response")
resource_count_cadmin_2 = account_list[0].cputotal
self.debug(resource_count_cadmin_2)
self.assertEqual(resource_count_cadmin_2, 0,
"Resource count for %s should be 0" %
get_resource_type(resource_id=8)) #CPU
return
def test_04_deploy_multiple_vm_with_multiple_cpus(self):
"""Test Deploy multiple VM with 4 core CPU & verify the usage"""
#keep the configuration value - max.account.cpus number = 16
# Validate the following
# 1. Create compute offering with 4 core CPU
# 2. Deploy multiple VMs with this service offering
# 3. List Resource count for the root admin CPU usage
# 4. CPU usage should list properly
self.debug("Creating service offering with 4 CPU cores")
self.service_offering = ServiceOffering.create(
self.apiclient, self.services["service_offering"])
# Adding to cleanup list after execution
self.cleanup.append(self.service_offering)
self.debug("Setting up account and domain hierarchy")
self.setupAccounts()
users = {
self.child_domain_1: self.child_do_admin_1,
self.child_domain_2: self.child_do_admin_2
}
for domain, admin in users.items():
self.account = admin
self.domain = domain
cpu_account_gc = Resources.list(
self.apiclient,
resourcetype=8, #CPU
account=self.account.name,
domainid=self.domain.id)
if cpu_account_gc[0].max != 16:
self.skipTest(
"This test case requires configuration value max.account.cpus to be 16"
)
api_client = self.testClient.createUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
self.debug("Creating an instance with service offering: %s" %
self.service_offering.name)
vm_1 = self.createInstance(service_off=self.service_offering,
api_client=api_client)
vm_2 = self.createInstance(service_off=self.service_offering,
api_client=api_client)
self.createInstance(service_off=self.service_offering,
api_client=api_client)
self.createInstance(service_off=self.service_offering,
api_client=api_client)
self.debug("Deploying instance - CPU capacity is fully utilized")
with self.assertRaises(Exception):
self.createInstance(service_off=self.service_offering,
api_client=api_client)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count = account_list[0].cputotal
expected_resource_count = int(self.services["service_offering"]
["cpunumber"]) * 4 #Total 4 vms
self.assertEqual(
resource_count, expected_resource_count,
"Initial resource count should with the expected resource count"
)
self.debug("Destroying instance: %s" % vm_1.name)
try:
vm_1.delete(self.apiclient)
except Exception as e:
self.fail("Failed to delete instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_delete = account_list[0].cputotal
expected_resource_count -= int(
self.services["service_offering"]["cpunumber"])
self.assertEqual(
resource_count_after_delete, expected_resource_count,
"Resource count should be less than before after deleting the instance"
)
host = find_suitable_host(self.apiclient, vm_2)
self.debug("Migrating instance: %s to host: %s" %
(vm_2.name, host.name))
try:
vm_2.migrate(self.apiclient, host.id)
except Exception as e:
self.fail("Failed to migrate instance: %s" % e)
account_list = Account.list(self.apiclient, id=self.account.id)
self.assertIsInstance(
account_list, list,
"List Accounts should return a valid response")
resource_count_after_migrate = account_list[0].cputotal
self.debug(resource_count_after_migrate)
self.assertEqual(
resource_count_after_delete, resource_count_after_migrate,
"Resource count should be same after migrating the instance")
