# 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);