You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by GitBox <gi...@apache.org> on 2022/12/07 10:32:46 UTC
[GitHub] [cloudstack] weizhouapache commented on a diff in pull request #6571: VM Autoscaling with virtual router
weizhouapache commented on code in PR #6571:
URL: https://github.com/apache/cloudstack/pull/6571#discussion_r1042035730
##########
test/integration/smoke/test_vm_autoscaling.py:
##########
@@ -0,0 +1,1103 @@
+# 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 of VM Autoscaling
+"""
+
+import logging
+import time
+import datetime
+
+from nose.plugins.attrib import attr
+from marvin.cloudstackTestCase import cloudstackTestCase
+from marvin.cloudstackAPI import stopVirtualMachine
+
+from marvin.lib.base import (Account,
+ Autoscale,
+ AutoScaleCondition,
+ AutoScalePolicy,
+ AutoScaleVmProfile,
+ AutoScaleVmGroup,
+ Configurations,
+ DiskOffering,
+ Domain,
+ Project,
+ ServiceOffering,
+ VirtualMachine,
+ Volume,
+ Zone,
+ Network,
+ NetworkOffering,
+ PublicIPAddress,
+ LoadBalancerRule,
+ VPC,
+ VpcOffering,
+ SSHKeyPair)
+
+from marvin.lib.common import (get_domain,
+ get_zone,
+ get_template)
+from marvin.lib.utils import wait_until
+
+MIN_MEMBER = 1
+MAX_MEMBER = 2
+DEFAULT_EXPUNGE_VM_GRACE_PERIOD = 60
+DEFAULT_DURATION = 120
+DEFAULT_INTERVAL = 30
+DEFAULT_QUIETTIME = 60
+NAME_PREFIX = "AS-VmGroup-"
+
+CONFIG_NAME_DISK_CONTROLLER = "vmware.root.disk.controller"
+OS_DEFAULT = "osdefault"
+
+class TestVmAutoScaling(cloudstackTestCase):
+ """
+ Test VM autoscaling
+ """
+ @classmethod
+ def setUpClass(cls):
+ cls.testClient = super(
+ TestVmAutoScaling,
+ cls).getClsTestClient()
+ cls.apiclient = cls.testClient.getApiClient()
+ cls.services = cls.testClient.getParsedTestDataConfig()
+
+ cls.initial_vmware_root_disk_controller = Configurations.list(
+ cls.apiclient,
+ name=CONFIG_NAME_DISK_CONTROLLER)[0].value
+ Configurations.update(cls.apiclient,
+ CONFIG_NAME_DISK_CONTROLLER,
+ OS_DEFAULT)
+
+ cls.hypervisor = cls.testClient.getHypervisorInfo()
+ zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
+ cls.zone = Zone(zone.__dict__)
+ cls.template = get_template(cls.apiclient, cls.zone.id)
+ cls.templatesize = int(cls.template.size / (1024 ** 3))
+ cls._cleanup = []
+
+ cls.logger = logging.getLogger("TestVmAutoScaling")
+ cls.stream_handler = logging.StreamHandler()
+ cls.logger.setLevel(logging.DEBUG)
+ cls.logger.addHandler(cls.stream_handler)
+
+ cls.domain = get_domain(cls.apiclient)
+
+ # 1. Create small service offering
+ cls.service_offering = ServiceOffering.create(
+ cls.apiclient,
+ cls.services["service_offerings"]["small"]
+ )
+ cls._cleanup.append(cls.service_offering)
+
+ cls.service_offering_new = ServiceOffering.create(
+ cls.apiclient,
+ cls.services["service_offerings"]["small"]
+ )
+ cls._cleanup.append(cls.service_offering_new)
+
+ # 2. Create disk offerings (fixed and custom)
+ cls.disk_offering_override = DiskOffering.create(
+ cls.apiclient,
+ cls.services["disk_offering"],
+ disksize=cls.templatesize + 1
+ )
+ cls._cleanup.append(cls.disk_offering_override)
+
+ cls.disk_offering_custom = DiskOffering.create(
+ cls.apiclient,
+ cls.services["disk_offering"],
+ custom=True
+ )
+ cls._cleanup.append(cls.disk_offering_custom)
+
+ cls.disk_offering_custom_new = DiskOffering.create(
+ cls.apiclient,
+ cls.services["disk_offering"],
+ custom=True
+ )
+ cls._cleanup.append(cls.disk_offering_custom_new)
+
+ # 3. Create network offering for isolated networks
+ cls.services["isolated_network_offering"]["serviceCapabilityList"] = {
+ "Lb": {
+ "SupportedLbIsolation": 'dedicated',
+ "VmAutoScaling": 'true'
+ },
+ }
+ cls.network_offering_isolated = NetworkOffering.create(
+ cls.apiclient,
+ cls.services["isolated_network_offering"]
+ )
+ cls.network_offering_isolated.update(cls.apiclient, state='Enabled')
+ cls._cleanup.append(cls.network_offering_isolated)
+
+ # 4. Create sub-domain
+ cls.sub_domain = Domain.create(
+ cls.apiclient,
+ cls.services["acl"]["domain1"]
+ )
+ cls._cleanup.append(cls.sub_domain)
+
+ # 5. Create regular user
+ cls.regular_user = Account.create(
+ cls.apiclient,
+ cls.services["acl"]["accountD11A"],
+ domainid=cls.sub_domain.id
+ )
+ cls._cleanup.append(cls.regular_user)
+
+ # 5. Create api clients for regular user
+ cls.regular_user_user = cls.regular_user.user[0]
+ cls.regular_user_apiclient = cls.testClient.getUserApiClient(
+ cls.regular_user_user.username, cls.sub_domain.name
+ )
+
+ # 7. Create networks for regular user
+ cls.services["network"]["name"] = "Test Network Isolated - Regular user - 1"
+ cls.user_network_1 = Network.create(
+ cls.regular_user_apiclient,
+ cls.services["network"],
+ networkofferingid=cls.network_offering_isolated.id,
+ zoneid=cls.zone.id
+ )
+
+ cls.services["network"]["name"] = "Test Network Isolated - Regular user - 2"
+ cls.user_network_2 = Network.create(
+ cls.regular_user_apiclient,
+ cls.services["network"],
+ networkofferingid=cls.network_offering_isolated.id,
+ zoneid=cls.zone.id
+ )
+
+ # 8. Create SSH Keypairs
+ cls.keypair_1 = SSHKeyPair.create(
+ cls.regular_user_apiclient,
+ name="keypair1"
+ )
+ cls.keypair_2 = SSHKeyPair.create(
+ cls.regular_user_apiclient,
+ name="keypair2"
+ )
+
+ # 9. Get counters for cpu and memory
+ counters = Autoscale.listCounters(
+ cls.regular_user_apiclient,
+ provider="VirtualRouter"
+ )
+ for counter in counters:
+ if counter.source == 'CPU':
+ cls.counter_cpu_id = counter.id
+ elif counter.source == 'MEMORY':
+ cls.counter_memory_id = counter.id
+ elif counter.source == 'VIRTUALROUTER' and counter.value == 'public.network.received.average.mbps':
+ cls.counter_network_received_id = counter.id
+ elif counter.source == 'VIRTUALROUTER' and counter.value == 'public.network.transmit.average.mbps':
+ cls.counter_network_transmit_id = counter.id
+ elif counter.source == 'VIRTUALROUTER' and counter.value == 'virtual.network.lb.average.connections':
+ cls.counter_lb_connection_id = counter.id
+
+ if cls.hypervisor.lower() == 'vmware':
+ cls.counter_cpu_or_memory_id = cls.counter_memory_id
+ else:
+ cls.counter_cpu_or_memory_id = cls.counter_cpu_id
+
+ # 10. Create AS conditions
+ cls.scale_up_condition = AutoScaleCondition.create(
+ cls.regular_user_apiclient,
+ counterid = cls.counter_cpu_id,
+ relationaloperator = "GE",
+ threshold = 1
+ )
+
+ cls.scale_down_condition = AutoScaleCondition.create(
+ cls.regular_user_apiclient,
+ counterid = cls.counter_cpu_or_memory_id,
+ relationaloperator = "LE",
+ threshold = 100
+ )
+
+ cls._cleanup.append(cls.scale_up_condition)
+ cls._cleanup.append(cls.scale_down_condition)
+
+ # 11. Create AS policies
+ cls.scale_up_policy = AutoScalePolicy.create(
+ cls.regular_user_apiclient,
+ action='ScaleUp',
+ conditionids=','.join([cls.scale_up_condition.id]),
+ quiettime=DEFAULT_QUIETTIME,
+ duration=DEFAULT_DURATION
+ )
+
+ cls.scale_down_policy = AutoScalePolicy.create(
+ cls.regular_user_apiclient,
+ action='ScaleDown',
+ conditionids=cls.scale_down_condition.id,
+ quiettime=DEFAULT_QUIETTIME,
+ duration=DEFAULT_DURATION
+ )
+
+ cls._cleanup.append(cls.scale_up_policy)
+ cls._cleanup.append(cls.scale_down_policy)
+
+ # 12. Create AS VM Profile
+ cls.otherdeployparams = []
+ cls.addOtherDeployParam(cls.otherdeployparams, "overridediskofferingid", cls.disk_offering_override.id)
+ cls.addOtherDeployParam(cls.otherdeployparams, "diskofferingid", cls.disk_offering_custom.id)
+ cls.addOtherDeployParam(cls.otherdeployparams, "disksize", 3)
+ cls.addOtherDeployParam(cls.otherdeployparams, "keypairs", cls.keypair_1.name + "," + cls.keypair_2.name)
+ cls.addOtherDeployParam(cls.otherdeployparams, "networkids", cls.user_network_1.id + "," + cls.user_network_2.id)
+
+ cls.autoscaling_vmprofile = AutoScaleVmProfile.create(
+ cls.regular_user_apiclient,
+ serviceofferingid=cls.service_offering.id,
+ zoneid=cls.zone.id,
+ templateid=cls.template.id,
+ expungevmgraceperiod=DEFAULT_EXPUNGE_VM_GRACE_PERIOD,
+ otherdeployparams=cls.otherdeployparams
+ )
+
+ cls._cleanup.append(cls.autoscaling_vmprofile)
+
+ # 13. Acquire Public IP and create LoadBalancer rule
+ cls.public_ip_address = PublicIPAddress.create(
+ cls.regular_user_apiclient,
+ services=cls.services["network"],
+ networkid=cls.user_network_1.id
+ )
+
+ cls.services["lbrule"]["openfirewall"] = False
+ cls.load_balancer_rule = LoadBalancerRule.create(
+ cls.regular_user_apiclient,
+ cls.services["lbrule"],
+ ipaddressid=cls.public_ip_address.ipaddress.id,
+ networkid=cls.user_network_1.id
+ )
+
+ # 14. Create AS VM Group
+ cls.autoscaling_vmgroup = AutoScaleVmGroup.create(
+ cls.regular_user_apiclient,
+ name=NAME_PREFIX + format(datetime.datetime.now(), '%Y%m%d-%H%M%S'),
+ lbruleid=cls.load_balancer_rule.id,
+ minmembers=MIN_MEMBER,
+ maxmembers=MAX_MEMBER,
+ scaledownpolicyids=cls.scale_down_policy.id,
+ scaleuppolicyids=cls.scale_up_policy.id,
+ vmprofileid=cls.autoscaling_vmprofile.id,
+ interval=DEFAULT_INTERVAL
+ )
+
+ # 15. Get global config
+ check_interval_config = Configurations.list(cls.apiclient, name="autoscale.stats.interval")
+ cls.check_interval_seconds = int(check_interval_config[0].value)
+
+ # 16. define VMs not be checked
+ cls.excluded_vm_ids = []
+
+ @classmethod
+ def message(cls, msg):
+ cls.logger.debug("=== " + str(datetime.datetime.now()) + " " + msg)
+
+ @classmethod
+ def addOtherDeployParam(cls, otherdeployparams, name, value):
+ otherdeployparams.append({
+ 'name': name,
+ 'value': value
+ })
+
+ @classmethod
+ def tearDownClass(cls):
+ Configurations.update(cls.apiclient,
+ CONFIG_NAME_DISK_CONTROLLER,
+ cls.initial_vmware_root_disk_controller)
+ super(TestVmAutoScaling, cls).tearDownClass()
+
+ def setUp(self):
+ self.apiclient = self.testClient.getApiClient()
+ self.cleanup = []
+
+ def tearDown(self):
+ super(TestVmAutoScaling, self).tearDown()
+
+ def delete_vmgroup(self, vmgroup, apiclient, cleanup=None, expected=True):
+ result = True
+ try:
+ AutoScaleVmGroup.delete(
+ vmgroup,
+ apiclient,
+ cleanup=cleanup
+ )
+ except Exception as ex:
+ result = False
+ if expected:
+ self.fail(f"Failed to remove Autoscaling VM Group, but expected to succeed : {ex}")
+ if result and not expected:
+ self.fail("Autoscaling VM Group is removed successfully, but expected to fail")
+
+ def verifyVmCountAndProfiles(self, vmCount, autoscalevmgroupid=None, autoscalevmprofileid=None, networkid=None, projectid=None):
+ if autoscalevmgroupid is None:
+ autoscalevmgroupid = self.autoscaling_vmgroup.id
+
+ if autoscalevmprofileid is None:
+ autoscalevmprofileid = self.autoscaling_vmprofile.id
+
+ if networkid is None:
+ networkid = self.user_network_1.id
+
+ vms = VirtualMachine.list(
+ self.regular_user_apiclient,
+ autoscalevmgroupid=autoscalevmgroupid,
+ projectid=projectid,
+ listall=True
+ )
+ self.assertEqual(
+ isinstance(vms, list),
+ True,
+ "List virtual machines should return a valid list"
+ )
+
+ new_vm_ids = []
+ for vm in vms:
+ new_vm_ids.append(vm.id)
+ for vm_id in self.excluded_vm_ids:
+ if vm_id not in new_vm_ids:
+ self.logger.debug("VM (id: %s) is not found in VM group" % vm_id)
+ self.excluded_vm_ids.remove(vm_id)
+
+ self.assertEqual(
+ len(vms),
+ vmCount,
+ "The number of virtual machines (%s) should be equal to %s" % (len(vms), vmCount)
+ )
+
+ for vm in vms:
+ if vm.id not in self.excluded_vm_ids:
+ self.excluded_vm_ids.append(vm.id)
+ self.wait_for_vm_start(vm, projectid)
+ self.verifyVmProfile(vm, autoscalevmprofileid, networkid, projectid)
+
+ def verifyVmProfile(self, vm, autoscalevmprofileid, networkid=None, projectid=None):
+ self.message("Verifying profiles of new VM %s (%s)" % (vm.name, vm.id))
+ datadisksizeInBytes = None
+ diskofferingid = None
+ rootdisksizeInBytes = None
+ sshkeypairs = None
+
+ affinitygroupIdsArray = []
+ for affinitygroup in vm.affinitygroup:
+ affinitygroupIdsArray.append(affinitygroup.id)
+ affinitygroupids = ",".join(affinitygroupIdsArray)
+
+ if vm.diskofferingid:
+ diskofferingid = vm.diskofferingid
+ if vm.keypairs:
+ sshkeypairs = vm.keypairs
+ serviceofferingid = vm.serviceofferingid
+ templateid = vm.templateid
+
+ networkIdsArray = []
+ for nic in vm.nic:
+ networkIdsArray.append(nic.networkid)
+ networkids = ",".join(networkIdsArray)
+
+ volumes = Volume.list(
+ self.regular_user_apiclient,
+ virtualmachineid=vm.id,
+ projectid=projectid,
+ listall=True
+ )
+ for volume in volumes:
+ if volume.type == 'ROOT':
+ rootdisksizeInBytes = volume.size
+ elif volume.type == 'DATADISK':
+ datadisksizeInBytes = volume.size
+ diskofferingid = volume.diskofferingid
+
+ vmprofiles_list = AutoScaleVmProfile.list(
+ self.regular_user_apiclient,
+ listall=True,
+ projectid=projectid,
+ id=autoscalevmprofileid
+ )
+ vmprofile = vmprofiles_list[0]
+ vmprofile_otherdeployparams = vmprofile.otherdeployparams
+
+ self.logger.debug("vmprofile_otherdeployparams = " + str(vmprofile_otherdeployparams))
+ self.logger.debug("templateid = " + templateid)
+ self.logger.debug("serviceofferingid = " + serviceofferingid)
+ self.logger.debug("rootdisksizeInBytes = " + str(rootdisksizeInBytes))
+ self.logger.debug("datadisksizeInBytes = " + str(datadisksizeInBytes))
+ self.logger.debug("diskofferingid = " + str(diskofferingid))
+ self.logger.debug("sshkeypairs = " + str(sshkeypairs))
+ self.logger.debug("networkids = " + networkids)
+ self.logger.debug("affinitygroupids = " + affinitygroupids)
+
+ self.assertEquals(templateid, vmprofile.templateid)
+ self.assertEquals(serviceofferingid, vmprofile.serviceofferingid)
+
+ if vmprofile_otherdeployparams.rootdisksize:
+ self.assertEquals(int(rootdisksizeInBytes), int(vmprofile_otherdeployparams.rootdisksize) * (1024 ** 3))
+ elif vmprofile_otherdeployparams.overridediskofferingid:
+ self.assertEquals(vmprofile_otherdeployparams.overridediskofferingid, self.disk_offering_override.id)
+ self.assertEquals(int(rootdisksizeInBytes), int(self.disk_offering_override.disksize) * (1024 ** 3))
+ else:
+ self.assertEquals(int(rootdisksizeInBytes), int(self.templatesize) * (1024 ** 3))
+
+ if vmprofile_otherdeployparams.diskofferingid:
+ self.assertEquals(diskofferingid, vmprofile_otherdeployparams.diskofferingid)
+ if vmprofile_otherdeployparams.disksize:
+ self.assertEquals(int(datadisksizeInBytes), int(vmprofile_otherdeployparams.disksize) * (1024 ** 3))
+
+ if vmprofile_otherdeployparams.keypairs:
+ self.assertEquals(sshkeypairs, vmprofile_otherdeployparams.keypairs)
+ else:
+ self.assertIsNone(sshkeypairs)
+
+ if vmprofile_otherdeployparams.networkids:
+ self.assertEquals(networkids, vmprofile_otherdeployparams.networkids)
+ else:
+ self.assertEquals(networkids, networkid)
+
+ if vmprofile_otherdeployparams.affinitygroupids:
+ self.assertEquals(affinitygroupids, vmprofile_otherdeployparams.affinitygroupids)
+ else:
+ self.assertEquals(affinitygroupids, '')
+
+ def wait_for_vm_start(self, vm=None, project_id=None):
+ """ Wait until vm is Running """
+ def check_user_vm_state():
+ vms = VirtualMachine.list(
+ self.apiclient,
+ id=vm.id,
+ projectid=project_id,
+ listall=True
+ )
+ if isinstance(vms, list):
+ if vms[0].state == 'Running':
+ return True, vms[0].state
+ return False, vms[0].state
+
+ self.message("Waiting for user VM %s (%s) to be Running" % (vm.name, vm.id))
+ res = wait_until(10, 30, check_user_vm_state)
+ if not res:
+ raise Exception("Failed to wait for user VM %s (%s) to be Running" % (vm.name, vm.id))
+ return res
+
+ @attr(tags=["advanced"], required_hardware="false")
+ def test_01_scale_up_verify(self):
+ """ Verify scale up of AutoScaling VM Group """
+ self.message("Running test_01_scale_up_verify")
+
+ # VM count increases from 0 to MIN_MEMBER
+ sleeptime = DEFAULT_INTERVAL * MIN_MEMBER + 5
+ self.message("Waiting %s seconds for %s VM(s) to be created" % (sleeptime, MIN_MEMBER))
+ time.sleep(sleeptime)
+ self.verifyVmCountAndProfiles(MIN_MEMBER)
+
+ # VM count increases from MIN_MEMBER to MAX_MEMBER
+ sleeptime = (self.check_interval_seconds + DEFAULT_DURATION + DEFAULT_QUIETTIME) * (MAX_MEMBER - MIN_MEMBER)
+ self.message("Waiting %s seconds for other %s VM(s) to be created" % (sleeptime, (MAX_MEMBER - MIN_MEMBER)))
+ time.sleep(sleeptime)
+ self.verifyVmCountAndProfiles(MAX_MEMBER)
+
+
+ @attr(tags=["advanced"], required_hardware="false")
+ def test_02_update_vmprofile_and_vmgroup(self):
+ """ Verify update of AutoScaling VM Group and VM Profile"""
+ self.message("Running test_02_update_vmprofile_and_vmgroup")
+
+ vmprofiles_list = AutoScaleVmProfile.list(
+ self.regular_user_apiclient,
+ listall=True,
+ id=self.autoscaling_vmprofile.id
+ )
+ self.assertEqual(
+ isinstance(vmprofiles_list, list),
+ True,
+ "List autoscale profiles should return a valid list"
+ )
+ self.assertEqual(
+ len(vmprofiles_list) == 1,
+ True,
+ "The number of autoscale profiles (%s) should be equal to 1" % (len(vmprofiles_list))
+ )
+
+ # Create new AS VM Profile
+ otherdeployparams_new = []
+ self.addOtherDeployParam(otherdeployparams_new, "rootdisksize", self.templatesize + 2)
+ self.addOtherDeployParam(otherdeployparams_new, "diskofferingid", self.disk_offering_custom_new.id)
+ self.addOtherDeployParam(otherdeployparams_new, "disksize", 5)
+ self.addOtherDeployParam(otherdeployparams_new, "keypairs", self.keypair_1.name)
+ self.addOtherDeployParam(otherdeployparams_new, "networkids", self.user_network_1.id)
+
+ try:
+ Autoscale.updateAutoscaleVMProfile(
+ self.regular_user_apiclient,
+ id = self.autoscaling_vmprofile.id,
+ serviceofferingid = self.service_offering_new.id,
+ expungevmgraceperiod = DEFAULT_EXPUNGE_VM_GRACE_PERIOD + 1,
+ otherdeployparams = otherdeployparams_new
+ )
+ self.fail("Autoscale VM Profile should not be updatable when VM Group is not Disabled")
+ except Exception as ex:
+ pass
+
+ try:
+ Autoscale.updateAutoscaleVMGroup(
+ self.regular_user_apiclient,
+ id = self.autoscaling_vmprofile.id,
+ name=NAME_PREFIX + format(datetime.datetime.now(), '%Y%m%d-%H%M%S'),
+ maxmembers = MAX_MEMBER + 1,
+ minmembers = MIN_MEMBER + 1,
+ interval = DEFAULT_INTERVAL + 1
+ )
+ self.fail("Autoscale VM Group should not be updatable when VM Group is not Disabled")
+ except Exception as ex:
+ pass
+
+ self.autoscaling_vmgroup.disable(self.regular_user_apiclient)
+
+ try:
+ Autoscale.updateAutoscaleVMProfile(
+ self.regular_user_apiclient,
+ id = self.autoscaling_vmprofile.id,
+ serviceofferingid = self.service_offering_new.id,
+ expungevmgraceperiod = DEFAULT_EXPUNGE_VM_GRACE_PERIOD + 1,
+ otherdeployparams = otherdeployparams_new
+ )
+ except Exception as ex:
+ self.fail("Autoscale VM Profile should be updatable when VM Group is Disabled")
+
+ try:
+ Autoscale.updateAutoscaleVMGroup(
+ self.regular_user_apiclient,
+ id = self.autoscaling_vmgroup.id,
+ name=NAME_PREFIX + format(datetime.datetime.now(), '%Y%m%d-%H%M%S'),
+ maxmembers = MAX_MEMBER + 1,
+ minmembers = MIN_MEMBER + 1,
+ interval = DEFAULT_INTERVAL + 1
+ )
+ except Exception as ex:
+ self.fail("Autoscale VM Group should be updatable when VM Group is Disabled")
+
+ self.autoscaling_vmgroup.enable(self.regular_user_apiclient)
+
+ # VM count increases from MAX_MEMBER to MAX_MEMBER+1
+ sleeptime = self.check_interval_seconds + DEFAULT_DURATION + DEFAULT_QUIETTIME
+ self.message("Waiting %s seconds for other %s VM(s) to be created" % (sleeptime, 1))
+ time.sleep(sleeptime)
+ self.verifyVmCountAndProfiles(MAX_MEMBER + 1)
+
+ @attr(tags=["advanced"], required_hardware="false")
+ def test_03_scale_down_verify(self):
+ """ Verify scale down of AutoScaling VM Group """
+ self.message("Running test_03_scale_down_verify")
+
+ self.autoscaling_vmgroup.disable(self.regular_user_apiclient)
+
+ policies = Autoscale.listAutoscalePolicies(
+ self.regular_user_apiclient,
+ action="ScaleUp",
+ vmgroupid=self.autoscaling_vmgroup.id
+ )
+ self.assertEqual(
+ isinstance(policies, list),
+ True,
+ "List autoscale policies should return a valid list"
+ )
+ self.assertEqual(
+ len(policies) == 1,
+ True,
+ "The number of autoscale policies (%s) should be equal to 1" % (len(policies))
+ )
+ scale_up_policy = policies[0]
+
+ conditions = Autoscale.listConditions(
+ self.regular_user_apiclient,
+ policyid=scale_up_policy.id
+ )
+ self.assertEqual(
+ isinstance(conditions, list),
+ True,
+ "List conditions should return a valid list"
+ )
+
+ for condition in conditions:
+ if condition.counterid == self.counter_cpu_id:
+ Autoscale.updateCondition(
+ self.regular_user_apiclient,
+ id=condition.id,
+ relationaloperator="GT",
+ threshold=101
+ )
+
+ policies = Autoscale.listAutoscalePolicies(
+ self.regular_user_apiclient,
+ action="ScaleDown",
+ vmgroupid=self.autoscaling_vmgroup.id
+ )
+ self.assertEqual(
+ isinstance(policies, list),
+ True,
+ "List autoscale policies should return a valid list"
+ )
+ self.assertEqual(
+ len(policies) == 1,
+ True,
+ "The number of autoscale policies (%s) should be equal to 1" % (len(policies))
+ )
+ scale_down_policy = policies[0]
+
+ new_condition_1 = AutoScaleCondition.create(
+ self.regular_user_apiclient,
+ counterid=self.counter_network_received_id,
+ relationaloperator="GE",
+ threshold=0
+ )
+ new_condition_2 = AutoScaleCondition.create(
+ self.regular_user_apiclient,
+ counterid=self.counter_network_transmit_id,
+ relationaloperator="GE",
+ threshold=0
+ )
+ new_condition_3 = AutoScaleCondition.create(
+ self.regular_user_apiclient,
+ counterid=self.counter_lb_connection_id,
+ relationaloperator="GE",
+ threshold=0
+ )
+ Autoscale.updateAutoscalePolicy(
+ self.regular_user_apiclient,
+ id=scale_down_policy.id,
+ conditionids=','.join([new_condition_1.id, new_condition_2.id, new_condition_3.id])
+ )
+
+ self.autoscaling_vmgroup.enable(self.regular_user_apiclient)
+
+ # VM count decreases from MAX_MEMBER+1 to MIN_MEMBER+1
+ sleeptime = (self.check_interval_seconds + DEFAULT_DURATION + DEFAULT_QUIETTIME + DEFAULT_EXPUNGE_VM_GRACE_PERIOD) * (MAX_MEMBER - MIN_MEMBER)
+ self.message("Waiting %s seconds for %s VM(s) to be destroyed" % (sleeptime, MAX_MEMBER - MIN_MEMBER))
+ time.sleep(sleeptime)
+ self.verifyVmCountAndProfiles(MIN_MEMBER+1)
+
+ @attr(tags=["advanced"], required_hardware="false")
+ def test_04_stop_remove_vm_in_vmgroup(self):
+ """ Verify removal of VM in AutoScaling VM Group"""
+ self.message("Running test_04_remove_vm_in_vmgroup")
+
+ vms = VirtualMachine.list(
+ self.regular_user_apiclient,
+ autoscalevmgroupid=self.autoscaling_vmgroup.id,
+ listall=True
+ )
+ self.assertEqual(
+ isinstance(vms, list),
+ True,
+ "List virtual machines should return a valid list"
+ )
+ self.assertEqual(
+ len(vms) >= MIN_MEMBER,
+ True,
+ "The number of virtual machines (%s) should be equal to or greater than %s" % (len(vms), MIN_MEMBER)
+ )
+
+ vm = vms[0]
+ try:
+ cmd = stopVirtualMachine.stopVirtualMachineCmd()
+ cmd.id = vm.id
+ cmd.forced = True
+ self.apiclient.stopVirtualMachine(cmd)
+ self.fail("VM should not be stopped when VM Group is not Disabled")
+ except Exception as ex:
+ pass
+
+ try:
+ VirtualMachine.delete(vm, self.regular_user_apiclient, expunge=False)
+ self.fail("VM should not be destroyed when VM Group is not Disabled")
+ except Exception as ex:
+ pass
+
+ self.autoscaling_vmgroup.disable(self.regular_user_apiclient)
+
+ try:
+ cmd = stopVirtualMachine.stopVirtualMachineCmd()
+ cmd.id = vm.id
+ cmd.forced = True
+ self.apiclient.stopVirtualMachine(cmd)
+ except Exception as ex:
+ self.fail("VM should be stopped when VM Group is Disabled")
+
+ try:
+ VirtualMachine.delete(vm, self.regular_user_apiclient, expunge=False)
+ except Exception as ex:
+ self.fail("VM should be destroyed when VM Group is Disabled")
+
+ self.verifyVmCountAndProfiles(MIN_MEMBER)
+
+ VirtualMachine.delete(vm, self.apiclient, expunge=True)
+
+ @attr(tags=["advanced"], required_hardware="false")
+ def test_05_remove_vmgroup(self):
+ """ Verify removal of AutoScaling VM Group"""
+ self.message("Running test_05_remove_vmgroup")
+
+ self.delete_vmgroup(self.autoscaling_vmgroup, self.regular_user_apiclient, cleanup=False, expected=False)
+ self.delete_vmgroup(self.autoscaling_vmgroup, self.regular_user_apiclient, cleanup=True, expected=True)
+
+ @attr(tags=["advanced"], required_hardware="false")
+ def test_06_autoscaling_vmgroup_on_project_network(self):
+ """ Testing VM autoscaling on project network """
+ self.message("Running test_06_autoscaling_vmgroup_on_project_network")
+
+ # Create project
+ project = Project.create(
+ self.regular_user_apiclient,
+ self.services["project"]
+ )
+ self.cleanup.append(project)
+
+ # Create project network
+ self.services["network"]["name"] = "Test Network Isolated - Project"
+ project_network = Network.create(
+ self.regular_user_apiclient,
+ self.services["network"],
+ networkofferingid=self.network_offering_isolated.id,
+ projectid=project.id,
+ zoneid=self.zone.id
+ )
+ self.cleanup.append(project_network)
+
+ # Acquire Public IP and create LoadBalancer rule for project
+ public_ip_address_project = PublicIPAddress.create(
+ self.regular_user_apiclient,
+ services=self.services["network"],
+ projectid = project.id,
+ networkid=project_network.id
+ )
+
+ load_balancer_rule_project = LoadBalancerRule.create(
+ self.regular_user_apiclient,
+ self.services["lbrule"],
+ projectid = project.id,
+ ipaddressid=public_ip_address_project.ipaddress.id,
+ networkid=project_network.id
+ )
+ self.cleanup.append(load_balancer_rule_project)
+
+ # Create AS conditions for project
+ scale_up_condition_project = AutoScaleCondition.create(
+ self.regular_user_apiclient,
+ projectid = project.id,
+ counterid = self.counter_cpu_id,
+ relationaloperator = "GE",
+ threshold = 1
+ )
+
+ scale_down_condition_project = AutoScaleCondition.create(
+ self.regular_user_apiclient,
+ projectid = project.id,
+ counterid = self.counter_cpu_or_memory_id,
+ relationaloperator = "LE",
+ threshold = 100
+ )
+
+ self.cleanup.append(scale_up_condition_project)
+ self.cleanup.append(scale_down_condition_project)
+
+ # Create AS policies for project
+ scale_up_policy_project = AutoScalePolicy.create(
+ self.regular_user_apiclient,
+ action='ScaleUp',
+ conditionids=scale_up_condition_project.id,
+ quiettime=DEFAULT_QUIETTIME,
+ duration=DEFAULT_DURATION
+ )
+
+ scale_down_policy_project = AutoScalePolicy.create(
+ self.regular_user_apiclient,
+ action='ScaleDown',
+ conditionids=scale_down_condition_project.id,
+ quiettime=DEFAULT_QUIETTIME,
+ duration=DEFAULT_DURATION
+ )
+
+ self.cleanup.append(scale_up_policy_project)
+ self.cleanup.append(scale_down_policy_project)
+
+ # Create AS VM Profile for project
+ autoscaling_vmprofile_project = AutoScaleVmProfile.create(
+ self.regular_user_apiclient,
+ serviceofferingid=self.service_offering.id,
+ zoneid=self.zone.id,
+ templateid=self.template.id,
+ expungevmgraceperiod=DEFAULT_EXPUNGE_VM_GRACE_PERIOD,
+ projectid = project.id
+ )
+
+ # Create AS VM Group for project
+ autoscaling_vmgroup_project = AutoScaleVmGroup.create(
+ self.regular_user_apiclient,
+ name=NAME_PREFIX + format(datetime.datetime.now(), '%Y%m%d-%H%M%S'),
+ lbruleid=load_balancer_rule_project.id,
+ minmembers=MIN_MEMBER,
+ maxmembers=MAX_MEMBER,
+ scaledownpolicyids=scale_down_policy_project.id,
+ scaleuppolicyids=scale_up_policy_project.id,
+ vmprofileid=autoscaling_vmprofile_project.id,
+ interval=DEFAULT_INTERVAL
+ )
Review Comment:
@DaanHoogland
`autoscaling_vmgroup_project` is removed in the test.
I will add `autoscaling_vmprofile_project` to cleanup
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@cloudstack.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org