| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| """ tests for Resource count of only running vms in cloudstack 4.14.0.0 |
| |
| """ |
| # Import Local Modules |
| from nose.plugins.attrib import attr |
| from marvin.cloudstackTestCase import cloudstackTestCase |
| from marvin.lib.utils import (validateList, |
| cleanup_resources) |
| from marvin.lib.base import (Account, |
| Domain, |
| Configurations, |
| Network, |
| NetworkOffering, |
| VirtualMachine, |
| Resources, |
| ServiceOffering, |
| Zone) |
| from marvin.lib.common import (get_domain, |
| get_zone, |
| get_template, |
| matchResourceCount, |
| isAccountResourceCountEqualToExpectedCount) |
| from marvin.codes import (PASS, FAILED, RESOURCE_CPU, RESOURCE_MEMORY) |
| import logging |
| import random |
| import time |
| |
| class TestResourceCountRunningVMs(cloudstackTestCase): |
| @classmethod |
| def setUpClass(cls): |
| cls.testClient = super( |
| TestResourceCountRunningVMs, |
| cls).getClsTestClient() |
| cls.apiclient = cls.testClient.getApiClient() |
| cls.services = cls.testClient.getParsedTestDataConfig() |
| zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) |
| cls.zone = Zone(zone.__dict__) |
| cls._cleanup = [] |
| |
| cls.logger = logging.getLogger("TestResourceCountRunningVMs") |
| cls.stream_handler = logging.StreamHandler() |
| cls.logger.setLevel(logging.DEBUG) |
| cls.logger.addHandler(cls.stream_handler) |
| |
| # Get Domain and templates |
| cls.domain = get_domain(cls.apiclient) |
| |
| cls.template = get_template(cls.apiclient, cls.zone.id, hypervisor="KVM") |
| if cls.template == FAILED: |
| sys.exit(1) |
| cls.templatesize = (cls.template.size / (1024 ** 3)) |
| |
| cls.services['mode'] = cls.zone.networktype |
| # Create Account |
| cls.account = Account.create( |
| cls.apiclient, |
| cls.services["account"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| accounts = Account.list(cls.apiclient, id=cls.account.id) |
| cls.expectedCpu = int(accounts[0].cputotal) |
| cls.expectedMemory = int(accounts[0].memorytotal) |
| |
| if cls.zone.securitygroupsenabled: |
| cls.services["shared_network_offering"]["specifyVlan"] = 'True' |
| cls.services["shared_network_offering"]["specifyIpRanges"] = 'True' |
| |
| cls.network_offering = NetworkOffering.create( |
| cls.apiclient, |
| cls.services["shared_network_offering"] |
| ) |
| cls.network_offering.update(cls.apiclient, state='Enabled') |
| |
| cls.account_network = Network.create( |
| cls.apiclient, |
| cls.services["network2"], |
| networkofferingid=cls.network_offering.id, |
| zoneid=cls.zone.id, |
| accountid=cls.account.name, |
| domainid=cls.account.domainid |
| ) |
| else: |
| cls.network_offering = NetworkOffering.create( |
| cls.apiclient, |
| cls.services["isolated_network_offering"], |
| ) |
| # Enable Network offering |
| cls.network_offering.update(cls.apiclient, state='Enabled') |
| |
| # Create account network |
| cls.services["network"]["zoneid"] = cls.zone.id |
| cls.services["network"]["networkoffering"] = cls.network_offering.id |
| cls.account_network = Network.create( |
| cls.apiclient, |
| cls.services["network"], |
| cls.account.name, |
| cls.account.domainid |
| ) |
| |
| cls._cleanup.append(cls.account); |
| cls._cleanup.append(cls.network_offering) |
| |
| @classmethod |
| def tearDownClass(self): |
| try: |
| cleanup_resources(self.apiclient, self._cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| def setUp(self): |
| self.apiclient = self.testClient.getApiClient() |
| self.cleanup = [] |
| return |
| |
| def tearDown(self): |
| try: |
| cleanup_resources(self.apiclient, self.cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| def verify_resource_count_cpu_memory(self, expectedCpu, expectedMemory, account=None): |
| if account is None: |
| account = self.account |
| response = matchResourceCount( |
| self.apiclient, expectedCpu, |
| RESOURCE_CPU, |
| accountid=account.id) |
| self.assertEqual(response[0], PASS, response[1]) |
| |
| response = matchResourceCount( |
| self.apiclient, expectedMemory, |
| RESOURCE_MEMORY, |
| accountid=account.id) |
| self.assertEqual(response[0], PASS, response[1]) |
| |
| result = isAccountResourceCountEqualToExpectedCount( |
| self.apiclient, account.domainid, account.name, |
| expectedCpu, RESOURCE_CPU) |
| self.assertFalse(result[0], result[1]) |
| self.assertTrue(result[2], "Resource count of cpu does not match") |
| |
| result = isAccountResourceCountEqualToExpectedCount( |
| self.apiclient, account.domainid, account.name, |
| expectedMemory, RESOURCE_MEMORY) |
| self.assertFalse(result[0], result[1]) |
| self.assertTrue(result[2], "Resource count of memory does not match") |
| |
| def update_account_resource_limitation(self, maxCpu, maxMemory): |
| Resources.updateLimit(self.apiclient, |
| resourcetype=RESOURCE_CPU, |
| max=maxCpu, |
| domainid=self.account.domainid, |
| account=self.account.name) |
| |
| Resources.updateLimit(self.apiclient, |
| resourcetype=RESOURCE_MEMORY, |
| max=maxMemory, |
| domainid=self.account.domainid, |
| account=self.account.name) |
| |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") |
| def test_01_resource_count_vm_with_normal_offering_in_all_states(self): |
| """Create VM with normal offering. Take resources of vm in all states into calculation of resource count. |
| |
| Steps: |
| # 1. update resource.count.running.vms.only to false |
| # 2. create normal service offering |
| # 3. deploy vm, resource count of cpu/ram increases |
| # 4. stop vm, resource count of cpu/ram is not changed |
| # 5. update vm with displayvm=false, resource count decreases |
| # 6. update vm with displayvm=true, resource count increases |
| # 7. start vm, resource count of cpu/ram is not changed |
| # 8. reboot vm, resource count of cpu/ram is not changed |
| # 9. destroy vm, resource count of cpu/ram decreases |
| # 10. expunge vm, resource count of cpu/ram is not changed |
| """ |
| |
| Configurations.update(self.apiclient, |
| name="resource.count.running.vms.only", |
| value="false" ) |
| |
| # Create small service offering |
| self.service_offering = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offerings"]["small"] |
| ) |
| self.cleanup.append(self.service_offering) |
| |
| # deploy vm |
| try: |
| virtual_machine_1 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| templateid=self.template.id, |
| zoneid=self.zone.id, |
| mode=self.zone.networktype |
| ) |
| except Exception as e: |
| self.fail("Exception while deploying virtual machine: %s" % e) |
| |
| self.expectedCpu = self.expectedCpu + virtual_machine_1.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_1.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # stop vm |
| virtual_machine_1.stop(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # update vm with displayvm=false |
| virtual_machine_1.update(self.apiclient, displayvm=False) |
| self.expectedCpu = self.expectedCpu - virtual_machine_1.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_1.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # update vm with displayvm=false |
| virtual_machine_1.update(self.apiclient, displayvm=True) |
| self.expectedCpu = self.expectedCpu + virtual_machine_1.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_1.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # start vm |
| virtual_machine_1.start(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # reboot vm |
| virtual_machine_1.reboot(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # destroy vm |
| virtual_machine_1.delete(self.apiclient, expunge=False) |
| self.expectedCpu = self.expectedCpu - virtual_machine_1.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_1.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # expunge vm |
| virtual_machine_1.expunge(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") |
| def test_02_resource_count_vm_with_dynamic_offering_in_all_states(self): |
| """Create VM with dynamic service offering. Take resources of vm in all states into calculation of resource count. |
| |
| Steps: |
| # 1. update resource.count.running.vms.only to false |
| # 2. create dynamic service offering |
| # 3. deploy vm, resource count of cpu/ram increases |
| # 4. stop vm, resource count of cpu/ram is not changed |
| # 5. update vm with displayvm=false, resource count decreases |
| # 6. update vm with displayvm=true, resource count increases |
| # 7. start vm, resource count of cpu/ram is not changed |
| # 8. reboot vm, resource count of cpu/ram is not changed |
| # 9. destroy vm, resource count of cpu/ram decreases |
| # 10. expunge vm, resource count of cpu/ram is not changed |
| """ |
| Configurations.update(self.apiclient, |
| name="resource.count.running.vms.only", |
| value="false" ) |
| |
| # Create dynamic service offering |
| self.services["service_offering"]["cpunumber"] = "" |
| self.services["service_offering"]["cpuspeed"] = "" |
| self.services["service_offering"]["memory"] = "" |
| |
| self.service_offering = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offering"]) |
| self.cleanup.append(self.service_offering) |
| |
| # deploy vm |
| try: |
| virtual_machine_2 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| customcpunumber=1, |
| customcpuspeed=100, |
| custommemory=256, |
| templateid=self.template.id, |
| zoneid=self.zone.id, |
| mode=self.zone.networktype |
| ) |
| except Exception as e: |
| self.fail("Exception while deploying virtual machine: %s" % e) |
| |
| self.expectedCpu = self.expectedCpu + virtual_machine_2.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_2.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # stop vm |
| virtual_machine_2.stop(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # update vm with displayvm=false |
| virtual_machine_2.update(self.apiclient, displayvm=False) |
| self.expectedCpu = self.expectedCpu - virtual_machine_2.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_2.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # update vm with displayvm=false |
| virtual_machine_2.update(self.apiclient, displayvm=True) |
| self.expectedCpu = self.expectedCpu + virtual_machine_2.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_2.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # start vm |
| virtual_machine_2.start(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # reboot vm |
| virtual_machine_2.reboot(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # destroy vm |
| virtual_machine_2.delete(self.apiclient, expunge=False) |
| self.expectedCpu = self.expectedCpu - virtual_machine_2.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_2.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # expunge vm |
| virtual_machine_2.expunge(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") |
| def test_03_resource_count_vm_with_normal_offering_in_running_state(self): |
| """Create VM with normal service offering. Take resources of vm in running state into calculation of resource count. |
| |
| Steps: |
| # 1. update resource.count.running.vms.only to true |
| # 2. create normal service offering |
| # 3. deploy vm, resource count of cpu/ram increases |
| # 4. stop vm, resource count of cpu/ram decreases |
| # 5. start vm, resource count of cpu/ram increases |
| # 6. reboot vm, resource count of cpu/ram is not changed |
| # 7. destroy vm, resource count of cpu/ram decreases |
| # 8. recover vm, resource count of cpu/ram is not changed |
| # 9. update vm with displayvm=false, resource count of cpu/ram is not changed |
| # 10. destroy vm with expunge = true, resource count of cpu/ram is not changed |
| """ |
| Configurations.update(self.apiclient, |
| name="resource.count.running.vms.only", |
| value="true" ) |
| |
| # Create service offering |
| self.service_offering = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offerings"]["small"] |
| ) |
| self.cleanup.append(self.service_offering) |
| |
| # deploy vm |
| try: |
| virtual_machine_3 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| templateid=self.template.id, |
| zoneid=self.zone.id, |
| mode=self.zone.networktype |
| ) |
| except Exception as e: |
| self.fail("Exception while deploying virtual machine: %s" % e) |
| |
| self.expectedCpu = self.expectedCpu + virtual_machine_3.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_3.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # stop vm |
| virtual_machine_3.stop(self.apiclient) |
| self.expectedCpu = self.expectedCpu - virtual_machine_3.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_3.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # start vm |
| virtual_machine_3.start(self.apiclient) |
| self.expectedCpu = self.expectedCpu + virtual_machine_3.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_3.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # reboot vm |
| virtual_machine_3.reboot(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # destroy vm |
| virtual_machine_3.delete(self.apiclient, expunge=False) |
| self.expectedCpu = self.expectedCpu - virtual_machine_3.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_3.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # recover vm |
| virtual_machine_3.recover(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # update vm with displayvm=false |
| virtual_machine_3.update(self.apiclient, displayvm=False) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # expunge vm |
| virtual_machine_3.delete(self.apiclient, expunge=True) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") |
| def test_04_resource_count_vm_with_dynamic_offering_in_running_state(self): |
| """Create VM with dynamic service offering. Take resources of vm in running state into calculation of resource count. |
| |
| Steps: |
| # 1. update resource.count.running.vms.only to true |
| # 2. create dynamic service offering |
| # 3. deploy vm, resource count of cpu/ram increases |
| # 4. stop vm, resource count of cpu/ram decreases |
| # 5. start vm, resource count of cpu/ram increases |
| # 6. reboot vm, resource count of cpu/ram is not changed |
| # 7. destroy vm, resource count of cpu/ram decreases |
| # 8. recover vm, resource count of cpu/ram is not changed |
| # 9. update vm with displayvm=false, resource count of cpu/ram is not changed |
| # 10. destroy vm with expunge = true, resource count of cpu/ram is not changed |
| """ |
| Configurations.update(self.apiclient, |
| name="resource.count.running.vms.only", |
| value="true" ) |
| |
| # Create dynamic service offering |
| self.services["service_offering"]["cpunumber"] = "" |
| self.services["service_offering"]["cpuspeed"] = "" |
| self.services["service_offering"]["memory"] = "" |
| |
| self.service_offering = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offering"]) |
| self.cleanup.append(self.service_offering) |
| |
| # deploy vm |
| try: |
| virtual_machine_4 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| customcpunumber=1, |
| customcpuspeed=100, |
| custommemory=256, |
| templateid=self.template.id, |
| zoneid=self.zone.id, |
| mode=self.zone.networktype |
| ) |
| except Exception as e: |
| self.fail("Exception while deploying virtual machine: %s" % e) |
| |
| self.expectedCpu = self.expectedCpu + virtual_machine_4.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_4.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # stop vm |
| virtual_machine_4.stop(self.apiclient) |
| self.expectedCpu = self.expectedCpu - virtual_machine_4.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_4.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # start vm |
| virtual_machine_4.start(self.apiclient) |
| self.expectedCpu = self.expectedCpu + virtual_machine_4.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_4.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # reboot vm |
| virtual_machine_4.reboot(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # destroy vm |
| virtual_machine_4.delete(self.apiclient, expunge=False) |
| self.expectedCpu = self.expectedCpu - virtual_machine_4.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_4.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # recover vm |
| virtual_machine_4.recover(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # update vm with displayvm=false |
| virtual_machine_4.update(self.apiclient, displayvm=False) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # expunge vm |
| virtual_machine_4.delete(self.apiclient, expunge=True) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") |
| def test_05_resource_count_vm_with_dynamic_offering_in_running_state_failed_cases(self): |
| """Create VM with dynamic service offering. Take resources of vm in running state into calculation of resource count. Test failed cases |
| |
| Steps: |
| # 1. update resource.count.running.vms.only to true |
| # 2. create dynamic service offering |
| # 3. update account cpu/ram limitation to current value |
| # 4. deploy vm (startvm=false), resource count of cpu/ram is not changed |
| # 5. start vm, it should fail |
| # 6. increase cpu limitation, start vm, it should fail |
| # 7. increase memory limitation, start vm, it should succeed. resource count of cpu/ram increases |
| # 8. restore vm, it should succeed. resource count of cpu/ram is not changed |
| # 9. destroy vm, resource count of cpu/ram decreases |
| # 10. expunge vm, resource count of cpu/ram is not changed |
| """ |
| Configurations.update(self.apiclient, |
| name="resource.count.running.vms.only", |
| value="true" ) |
| |
| # Create dynamic service offering |
| self.services["service_offering"]["cpunumber"] = "" |
| self.services["service_offering"]["cpuspeed"] = "" |
| self.services["service_offering"]["memory"] = "" |
| |
| self.service_offering = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offering"]) |
| self.cleanup.append(self.service_offering) |
| |
| # update resource limitation |
| self.update_account_resource_limitation(self.expectedCpu, self.expectedMemory) |
| |
| # deploy vm (startvm=false) |
| try: |
| virtual_machine_5 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| customcpunumber=1, |
| customcpuspeed=100, |
| custommemory=256, |
| templateid=self.template.id, |
| zoneid=self.zone.id, |
| startvm=False, |
| mode=self.zone.networktype |
| ) |
| except Exception as e: |
| self.fail("Exception while deploying virtual machine: %s" % e) |
| |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # start vm |
| try: |
| virtual_machine_5.start(self.apiclient) |
| self.fail("Start VM should fail as there is not enough cpu") |
| except Exception: |
| self.debug("Start VM failed as expected") |
| |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # increase cpu limitation, and start vm |
| self.update_account_resource_limitation(self.expectedCpu + virtual_machine_5.cpunumber, self.expectedMemory) |
| try: |
| virtual_machine_5.start(self.apiclient) |
| self.fail("Start VM should fail as there is not enough memory") |
| except Exception: |
| self.debug("Start VM failed as expected") |
| |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # increase memory limitation, and start vm |
| self.update_account_resource_limitation(self.expectedCpu + virtual_machine_5.cpunumber, self.expectedMemory + virtual_machine_5.memory) |
| try: |
| virtual_machine_5.start(self.apiclient) |
| self.debug("Start VM succeed as expected") |
| except Exception: |
| self.fail("Start VM should succeed as there is enough cpu and memory") |
| |
| self.expectedCpu = self.expectedCpu + virtual_machine_5.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_5.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # restore running vm |
| virtual_machine_5.restore(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # expunge vm |
| virtual_machine_5.delete(self.apiclient, expunge=True) |
| self.expectedCpu = self.expectedCpu - virtual_machine_5.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_5.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") |
| def test_06_resource_count_vm_with_dynamic_offering_in_all_states_failed_cases(self): |
| """Create VM with dynamic service offering. Take resources of vm in all states into calculation of resource count. Test failed cases |
| |
| Steps: |
| # 1. update resource.count.running.vms.only to false |
| # 2. create dynamic service offering |
| # 3. update account cpu/ram limitation to current value |
| # 4. deploy vm (startvm=false), it should fail |
| # 5. increase cpu limitation, deploy vm, it should fail |
| # 6. increase memory limitation, deploy vm, it should succeed. resource count of cpu/ram increases |
| # 7. start vm, resource count of cpu/ram is not changed |
| # 8. restore vm, it should succeed. resource count of cpu/ram is not changed |
| # 9. destroy vm, resource count of cpu/ram decreases |
| # 10. expunge vm, resource count of cpu/ram is not changed |
| """ |
| Configurations.update(self.apiclient, |
| name="resource.count.running.vms.only", |
| value="false" ) |
| |
| # Create dynamic service offering |
| self.services["service_offering"]["cpunumber"] = "" |
| self.services["service_offering"]["cpuspeed"] = "" |
| self.services["service_offering"]["memory"] = "" |
| |
| self.service_offering = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offering"]) |
| self.cleanup.append(self.service_offering) |
| |
| # update resource limitation |
| self.update_account_resource_limitation(self.expectedCpu, self.expectedMemory) |
| |
| # deploy vm (startvm=false) |
| try: |
| virtual_machine_6 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| customcpunumber=1, |
| customcpuspeed=100, |
| custommemory=256, |
| templateid=self.template.id, |
| zoneid=self.zone.id, |
| startvm=False, |
| mode=self.zone.networktype |
| ) |
| self.fail("Deploy VM should fail as there is not enough cpu") |
| except Exception as e: |
| self.debug("Deploy VM failed as expected") |
| |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # increase cpu limitation, and deploy vm |
| self.update_account_resource_limitation(self.expectedCpu + 1, self.expectedMemory) |
| try: |
| virtual_machine_6 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| customcpunumber=1, |
| customcpuspeed=100, |
| custommemory=256, |
| templateid=self.template.id, |
| zoneid=self.zone.id, |
| startvm=False, |
| mode=self.zone.networktype |
| ) |
| self.fail("Deploy VM should fail as there is not enough memory") |
| except Exception as e: |
| self.debug("Deploy VM failed as expected") |
| |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # increase memory limitation, and deploy vm |
| self.update_account_resource_limitation(self.expectedCpu + 1, self.expectedMemory + 256) |
| try: |
| virtual_machine_6 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| customcpunumber=1, |
| customcpuspeed=100, |
| custommemory=256, |
| templateid=self.template.id, |
| zoneid=self.zone.id, |
| startvm=False, |
| mode=self.zone.networktype |
| ) |
| self.debug("Deploy VM succeed as expected") |
| except Exception: |
| self.fail("Deploy VM should succeed as there is enough cpu and memory") |
| |
| self.expectedCpu = self.expectedCpu + virtual_machine_6.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_6.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # start vm |
| virtual_machine_6.start(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # restore running vm |
| virtual_machine_6.restore(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # expunge vm |
| virtual_machine_6.delete(self.apiclient, expunge=True) |
| self.expectedCpu = self.expectedCpu - virtual_machine_6.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_6.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") |
| def test_07_resource_count_vm_in_running_state_and_move_and_upgrade(self): |
| """Create VM with dynamic service offering. Take resources of vm in running state into calculation. Move vm to another account and upgrade it. |
| |
| Steps: |
| # 1. update resource.count.running.vms.only to true |
| # 2. create dynamic service offering |
| # 3. deploy vm, resource count of cpu/ram increases |
| # 4. stop vm, resource count of cpu/ram decreases |
| # 5. create another account |
| # 6. move vm to new account. resource count of cpu/ram of current account is not changed. resource count of cpu/ram of new account is not changed. |
| # 7. create another service offering. |
| # 8. upgrade vm. resource count of cpu/ram of new account is not changed. |
| # 9. start vm, resource count of cpu/ram of new account increases with cpu/ram of new service offering. |
| # 10. destroy vm, resource count of cpu/ram decreases |
| # 11. expunge vm, resource count of cpu/ram is not changed |
| """ |
| Configurations.update(self.apiclient, |
| name="resource.count.running.vms.only", |
| value="true" ) |
| |
| # Create dynamic service offering |
| self.services["service_offering"]["cpunumber"] = "" |
| self.services["service_offering"]["cpuspeed"] = "" |
| self.services["service_offering"]["memory"] = "" |
| |
| self.service_offering = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offering"]) |
| self.cleanup.append(self.service_offering) |
| |
| # deploy vm |
| try: |
| virtual_machine_7 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| customcpunumber=1, |
| customcpuspeed=100, |
| custommemory=256, |
| templateid=self.template.id, |
| zoneid=self.zone.id |
| ) |
| except Exception as e: |
| self.fail("Exception while deploying virtual machine: %s" % e) |
| |
| self.expectedCpu = self.expectedCpu + virtual_machine_7.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_7.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # stop vm |
| virtual_machine_7.stop(self.apiclient) |
| self.expectedCpu = self.expectedCpu - virtual_machine_7.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_7.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # create another account |
| self.account2 = Account.create( |
| self.apiclient, |
| self.services["account2"], |
| admin=True, |
| domainid=self.domain.id |
| ) |
| accounts = Account.list(self.apiclient, id=self.account2.id) |
| self.account2Cpu = int(accounts[0].cputotal) |
| self.account2Memory = int(accounts[0].memorytotal) |
| |
| # move vm to new account. resource count of cpu/ram of current account is not changed. resource count of cpu/ram of new account is not changed. |
| oldcpunumber = virtual_machine_7.cpunumber |
| oldmemory = virtual_machine_7.memory |
| virtual_machine_7.assign_virtual_machine(self.apiclient, self.account2.name, self.account2.domainid) |
| |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| self.verify_resource_count_cpu_memory(self.account2Cpu, self.account2Memory, account=self.account2); |
| |
| # create another service offering |
| self.service_offering_big = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offerings"]["big"] |
| ) |
| self.cleanup.append(self.service_offering_big) |
| |
| # upgrade vm |
| virtual_machine_7.change_service_offering(self.apiclient, self.service_offering_big.id) |
| self.verify_resource_count_cpu_memory(self.account2Cpu, self.account2Memory, account=self.account2); |
| |
| # start vm, resource count of cpu/ram of new account increases with cpu/ram of new service offering. |
| virtual_machine_7.start(self.apiclient) |
| self.account2Cpu = self.account2Cpu + self.service_offering_big.cpunumber |
| self.account2Memory = self.account2Memory + self.service_offering_big.memory |
| self.verify_resource_count_cpu_memory(self.account2Cpu, self.account2Memory, account=self.account2); |
| |
| # expunge vm |
| virtual_machine_7.delete(self.apiclient, expunge=True) |
| self.account2Cpu = self.account2Cpu - self.service_offering_big.cpunumber |
| self.account2Memory = self.account2Memory - self.service_offering_big.memory |
| self.verify_resource_count_cpu_memory(self.account2Cpu, self.account2Memory, account=self.account2); |
| |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") |
| def test_08_resource_count_vm_in_all_states_and_move_and_upgrade(self): |
| """Create VM with dynamic service offering. Take resources of vm in all states into calculation. Move vm to another account and upgrade it. |
| |
| Steps: |
| # 1. update resource.count.running.vms.only to true |
| # 2. create dynamic service offering |
| # 3. deploy vm, resource count of cpu/ram increases |
| # 4. stop vm, resource count of cpu/ram is not changed |
| # 5. create another account |
| # 6. move vm to new account. resource count of cpu/ram of current account decreases. resource count of cpu/ram of new account increases. |
| # 7. create another service offering. |
| # 8. upgrade vm. resource count of cpu/ram of new account is changed. |
| # 9. start vm, resource count of cpu/ram is not changed |
| # 10. destroy vm, resource count of cpu/ram decreases |
| # 11. expunge vm, resource count of cpu/ram is not changed |
| """ |
| Configurations.update(self.apiclient, |
| name="resource.count.running.vms.only", |
| value="false" ) |
| |
| # Create dynamic service offering |
| self.services["service_offering"]["cpunumber"] = "" |
| self.services["service_offering"]["cpuspeed"] = "" |
| self.services["service_offering"]["memory"] = "" |
| |
| self.service_offering = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offering"]) |
| self.cleanup.append(self.service_offering) |
| |
| # deploy vm |
| try: |
| virtual_machine_8 = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| accountid=self.account.name, |
| domainid=self.account.domainid, |
| serviceofferingid=self.service_offering.id, |
| customcpunumber=1, |
| customcpuspeed=100, |
| custommemory=256, |
| templateid=self.template.id, |
| zoneid=self.zone.id |
| ) |
| except Exception as e: |
| self.fail("Exception while deploying virtual machine: %s" % e) |
| |
| self.expectedCpu = self.expectedCpu + virtual_machine_8.cpunumber |
| self.expectedMemory = self.expectedMemory + virtual_machine_8.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # stop vm |
| virtual_machine_8.stop(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| # create another account |
| self.account2 = Account.create( |
| self.apiclient, |
| self.services["account2"], |
| admin=True, |
| domainid=self.domain.id |
| ) |
| self.cleanup.append(self.account2) |
| accounts = Account.list(self.apiclient, id=self.account2.id) |
| self.account2Cpu = int(accounts[0].cputotal) |
| self.account2Memory = int(accounts[0].memorytotal) |
| |
| # move vm to new account. resource count of cpu/ram of current account decreases. resource count of cpu/ram of new account increases. |
| oldcpunumber = virtual_machine_8.cpunumber |
| oldmemory = virtual_machine_8.memory |
| virtual_machine_8.assign_virtual_machine(self.apiclient, self.account2.name, self.account2.domainid) |
| |
| self.expectedCpu = self.expectedCpu - virtual_machine_8.cpunumber |
| self.expectedMemory = self.expectedMemory - virtual_machine_8.memory |
| self.verify_resource_count_cpu_memory(self.expectedCpu, self.expectedMemory); |
| |
| self.account2Cpu = self.account2Cpu + virtual_machine_8.cpunumber |
| self.account2Memory = self.account2Memory + virtual_machine_8.memory |
| self.verify_resource_count_cpu_memory(self.account2Cpu, self.account2Memory, account=self.account2); |
| |
| # create another service offering |
| self.service_offering_big = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offerings"]["big"] |
| ) |
| self.cleanup.append(self.service_offering_big) |
| |
| # upgrade vm |
| virtual_machine_8.change_service_offering(self.apiclient, self.service_offering_big.id) |
| self.account2Cpu = self.account2Cpu + self.service_offering_big.cpunumber - oldcpunumber |
| self.account2Memory = self.account2Memory + self.service_offering_big.memory - oldmemory |
| self.verify_resource_count_cpu_memory(self.account2Cpu, self.account2Memory, account=self.account2); |
| |
| # start vm |
| virtual_machine_8.start(self.apiclient) |
| self.verify_resource_count_cpu_memory(self.account2Cpu, self.account2Memory, account=self.account2); |
| |
| # expunge vm |
| virtual_machine_8.delete(self.apiclient, expunge=True) |
| self.account2Cpu = self.account2Cpu - self.service_offering_big.cpunumber |
| self.account2Memory = self.account2Memory - self.service_offering_big.memory |
| self.verify_resource_count_cpu_memory(self.account2Cpu, self.account2Memory, account=self.account2); |
