| # 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 DRS on a cluster |
| """ |
| |
| import logging |
| import time |
| from collections.abc import Iterable |
| |
| from marvin.codes import FAILED |
| from marvin.cloudstackTestCase import cloudstackTestCase |
| from marvin.cloudstackAPI import (migrateSystemVm, listRouters, listSystemVms) |
| from marvin.lib.base import (Cluster, Configurations, Host, Network, NetworkOffering, ServiceOffering, VirtualMachine, |
| Zone) |
| from marvin.lib.common import (get_domain, get_zone, get_test_template) |
| from marvin.lib.utils import wait_until |
| from marvin import jsonHelper |
| from nose.plugins.attrib import attr |
| |
| |
| class TestClusterDRS(cloudstackTestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| cls.testClient = super(TestClusterDRS, 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.hypervisor = cls.testClient.getHypervisorInfo() |
| cls.template = get_test_template( |
| cls.apiclient, |
| cls.zone.id, |
| cls.hypervisor |
| ) |
| if cls.template == FAILED: |
| assert False, "get_test_template() failed to return template\ |
| with hypervisor %s" % cls.hypervisor |
| cls._cleanup = [] |
| |
| cls.logger = logging.getLogger("TestClusterDRS") |
| cls.stream_handler = logging.StreamHandler() |
| cls.logger.setLevel(logging.DEBUG) |
| cls.logger.addHandler(cls.stream_handler) |
| |
| cls.skipTests = False |
| clusters = Cluster.list(cls.apiclient, zoneid=cls.zone.id, allocationstate='Enabled') |
| |
| if not clusters or not isinstance(clusters, list) or len(clusters) < 1: |
| cls.logger.debug("This test requires at least 1 (Up and Enabled) cluster in the zone") |
| cls.skipTests = True |
| return |
| |
| for cluster in clusters: |
| cls.hosts = Host.list(cls.apiclient, zoneid=cls.zone.id, clusterid=cluster.id, state='Up', |
| resourcestate='Enabled') |
| if not cls.hosts or not isinstance(cls.hosts, list) or len(cls.hosts) < 2: |
| cls.logger.debug("This test requires at least two (Up and Enabled) hosts in the zone") |
| cls.skipTests = True |
| return |
| else: |
| cls.cluster = Cluster(jsonHelper.jsonDump.dump(cluster)) |
| break |
| |
| cls.domain = get_domain(cls.apiclient) |
| |
| # 1. Create large service offering |
| cls.service_offering = ServiceOffering.create(cls.apiclient, cls.services["service_offerings"]["large"]) |
| cls._cleanup.append(cls.service_offering) |
| |
| # 2. Create a network |
| cls.services["network"]["name"] = "Test Network" |
| cls.network_offering = NetworkOffering.create( |
| cls.apiclient, |
| cls.services["l2-network_offering"] |
| ) |
| cls._cleanup.append(cls.network_offering) |
| NetworkOffering.update( |
| cls.network_offering, |
| cls.apiclient, |
| id=cls.network_offering.id, |
| state="enabled" |
| ) |
| |
| cls.network = Network.create( |
| cls.apiclient, |
| cls.services["l2-network"], |
| networkofferingid=cls.network_offering.id, |
| zoneid=cls.zone.id, |
| accountid="admin", |
| domainid=cls.domain.id, |
| ) |
| cls._cleanup.append(cls.network) |
| |
| cls.hypervisor = cls.testClient.getHypervisorInfo() |
| if cls.hypervisor.lower() not in ['simulator']: |
| cls.migrateSvms(cls.cluster) |
| |
| @classmethod |
| def migrateSvms(cls, cluster): |
| """ |
| for testing the balanced algorithm we must make sure there is at least as more free memory on host[1] than on |
| host[0]. As a grude measure we migrate any and all system vms to host[0] before the testing commences |
| |
| :param cluster: the cluser to check |
| :return: None |
| """ |
| |
| systemVmIds = [] |
| cmds = listSystemVms.listSystemVmsCmd() |
| responseS = cls.apiclient.listSystemVms(cmds) |
| if isinstance(responseS, Iterable): |
| for svm in responseS: |
| if svm.hostid != cls.hosts[0].id: |
| systemVmIds.append(svm.id) |
| cmdv = listRouters.listRoutersCmd() |
| responseR = cls.apiclient.listRouters(cmdv) |
| if isinstance(responseR, Iterable): |
| for svm in responseR: |
| if svm.hostid != cls.hosts[0].id: |
| systemVmIds.append(svm.id) |
| numToMigrate = len(systemVmIds) |
| cls.logger.debug(f'system vms and routers to migrate -- {numToMigrate}') |
| cmdM = migrateSystemVm.migrateSystemVmCmd() |
| cmdM.hostId=cls.hosts[0].id |
| for id in systemVmIds: |
| cmdM.virtualmachineid=id |
| responseM = cls.apiclient.migrateSystemVm(cmdM) |
| cls.logger.debug(f'migrated {responseM}') |
| |
| |
| @classmethod |
| def tearDownClass(cls): |
| super(TestClusterDRS, cls).tearDownClass() |
| |
| def setUp(self): |
| if self.skipTests: |
| self.skipTest("This test requires at least two (Up and Enabled) hosts in the zone") |
| self.apiclient = self.testClient.getApiClient() |
| self.cleanup = [] |
| |
| def tearDown(self): |
| super(TestClusterDRS, self).tearDown() |
| |
| def get_vm_host_id(cls, vm_id): |
| list_vms = VirtualMachine.list(cls.apiclient, id=vm_id) |
| vm = list_vms[0] |
| return vm.hostid |
| |
| def wait_for_vm_start(self, vm): |
| """ Wait until vm is Running """ |
| def check_vm_state(): |
| vms = VirtualMachine.list( |
| self.apiclient, |
| id=vm.id, |
| listall=True |
| ) |
| if isinstance(vms, list): |
| if vms[0].state == 'Running': |
| return True, vms[0].state |
| return False, vms[0].state |
| |
| res = wait_until(10, 30, check_vm_state) |
| if not res: |
| raise Exception("Failed to wait for VM %s (%s) to be Running" % (vm.name, vm.id)) |
| return res |
| |
| def wait_for_plan_completion(self, plan): |
| """ Wait until plan is completed """ |
| def check_plan_status(): |
| plans = self.cluster.listDrsPlans(self.apiclient, id=plan.id) |
| if isinstance(plans, list): |
| if plans[0].status == 'COMPLETED': |
| return True, plans[0].status |
| return False, plans[0].status |
| |
| res = wait_until(10, 30, check_plan_status) |
| if not res: |
| raise Exception("Failed to wait for completion of plan %s" % (plan.id)) |
| return res |
| |
| def get_migrations(self): |
| """ Wait until migrations are generated. Sometimes it takes a little bit of time for stats to get updated. We generate migrations |
| until we get at least one migration """ |
| def generate_migrations(): |
| drs_plan = self.cluster.generateDrsPlan(self.apiclient, migrations=4) |
| if len(drs_plan["migrations"]) > 0: |
| return True, drs_plan["migrations"] |
| return False, drs_plan["migrations"] |
| |
| res, migrations = wait_until(10, 30, generate_migrations) |
| if not res: |
| raise Exception("Failed to generate drs migrations") |
| return migrations |
| |
| @attr(tags=["advanced"], required_hardware="false") |
| def test_01_condensed_drs_algorithm(self): |
| """ Verify DRS algorithm - condensed""" |
| # 1. Deploy vm-1 on host 1 |
| # 2. Deploy vm-2 on host 2 |
| # 3. Execute DRS to move all VMs on the same host |
| self.logger.debug("=== Running test_01_condensed_drs_algorithm ===") |
| |
| # 1. Deploy vm-1 on host 1 |
| self.services["virtual_machine"]["name"] = "virtual-machine-1" |
| self.services["virtual_machine"]["displayname"] = "virtual-machine-1" |
| self.virtual_machine_1 = VirtualMachine.create(self.apiclient, self.services["virtual_machine"], |
| serviceofferingid=self.service_offering.id, |
| templateid=self.template.id, zoneid=self.zone.id, |
| networkids=self.network.id, hostid=self.hosts[0].id) |
| self.cleanup.append(self.virtual_machine_1) |
| vm_1_host_id = self.get_vm_host_id(self.virtual_machine_1.id) |
| |
| # 2. Deploy vm-2 on host 2 |
| self.services["virtual_machine"]["name"] = "virtual-machine-2" |
| self.services["virtual_machine"]["displayname"] = "virtual-machine-2" |
| self.virtual_machine_2 = VirtualMachine.create(self.apiclient, self.services["virtual_machine"], |
| serviceofferingid=self.service_offering.id, |
| templateid=self.template.id, zoneid=self.zone.id, |
| networkids=self.network.id, hostid=self.hosts[1].id) |
| self.cleanup.append(self.virtual_machine_2) |
| vm_2_host_id = self.get_vm_host_id(self.virtual_machine_2.id) |
| |
| self.assertNotEqual(vm_1_host_id, vm_2_host_id, msg="Both VMs should be on different hosts") |
| self.wait_for_vm_start(self.virtual_machine_1) |
| self.wait_for_vm_start(self.virtual_machine_2) |
| |
| # 3. Generate & execute DRS to move all VMs on the same host |
| Configurations.update(self.apiclient, "drs.algorithm", "condensed", clusterid=self.cluster.id) |
| Configurations.update(self.apiclient, "drs.imbalance", "1.0", clusterid=self.cluster.id) |
| |
| migrations = self.get_migrations() |
| vm_to_dest_host_map = { |
| migration["virtualmachineid"]: migration["destinationhostid"] for migration in migrations |
| } |
| |
| self.assertEqual(len(vm_to_dest_host_map), 1, msg="DRS plan should have 1 migrations") |
| |
| executed_plan = self.cluster.executeDrsPlan(self.apiclient, vm_to_dest_host_map) |
| self.wait_for_plan_completion(executed_plan) |
| |
| vm_1_host_id = self.get_vm_host_id(self.virtual_machine_1.id) |
| vm_2_host_id = self.get_vm_host_id(self.virtual_machine_2.id) |
| |
| self.assertEqual(vm_1_host_id, vm_2_host_id, msg="Both VMs should be on the same host") |
| |
| @attr(tags=["advanced"], required_hardware="false") |
| def test_02_balanced_drs_algorithm(self): |
| """ |
| Verify DRS algorithm - balanced |
| |
| # 1. Deploy vm-1 on host 1 |
| # 2. Deploy vm-2 on host 2 |
| # 3. Execute DRS to move all VMs on different hosts |
| """ |
| self.logger.debug("=== Running test_02_balanced_drs_algorithm ===") |
| |
| # 1. Deploy vm-1 on host 1 |
| self.services["virtual_machine"]["name"] = "virtual-machine-1" |
| self.services["virtual_machine"]["displayname"] = "virtual-machine-1" |
| self.virtual_machine_1 = VirtualMachine.create(self.apiclient, self.services["virtual_machine"], |
| serviceofferingid=self.service_offering.id, |
| templateid=self.template.id, zoneid=self.zone.id, |
| networkids=self.network.id, hostid=self.hosts[0].id) |
| self.cleanup.append(self.virtual_machine_1) |
| vm_1_host_id = self.get_vm_host_id(self.virtual_machine_1.id) |
| |
| # 2. Deploy vm-2 on host 1 |
| self.services["virtual_machine"]["name"] = "virtual-machine-2" |
| self.services["virtual_machine"]["displayname"] = "virtual-machine-2" |
| self.virtual_machine_2 = VirtualMachine.create(self.apiclient, self.services["virtual_machine"], |
| serviceofferingid=self.service_offering.id, |
| templateid=self.template.id, zoneid=self.zone.id, |
| networkids=self.network.id, hostid=self.hosts[0].id) |
| self.cleanup.append(self.virtual_machine_2) |
| vm_2_host_id = self.get_vm_host_id(self.virtual_machine_2.id) |
| |
| self.assertEqual(vm_1_host_id, vm_2_host_id, msg="Both VMs should be on same hosts") |
| self.wait_for_vm_start(self.virtual_machine_1) |
| self.wait_for_vm_start(self.virtual_machine_2) |
| |
| # 3. Execute DRS to move all VMs on different hosts |
| Configurations.update(self.apiclient, "drs.algorithm", "balanced", clusterid=self.cluster.id) |
| Configurations.update(self.apiclient, "drs.imbalance", "1.0", clusterid=self.cluster.id) |
| |
| migrations = self.get_migrations() |
| vm_to_dest_host_map = { |
| migration["virtualmachineid"]: migration["destinationhostid"] for migration in migrations |
| } |
| |
| # this is one if no svm is considered to be migrated, it might be higher |
| self.assertTrue(len(vm_to_dest_host_map) >= 1, msg="DRS plan should have at least 1 migrations") |
| |
| executed_plan = self.cluster.executeDrsPlan(self.apiclient, vm_to_dest_host_map) |
| self.wait_for_plan_completion(executed_plan) |
| |
| vm_1_host_id = self.get_vm_host_id(self.virtual_machine_1.id) |
| vm_2_host_id = self.get_vm_host_id(self.virtual_machine_2.id) |
| |
| self.assertTrue( |
| vm_1_host_id != self.virtual_machine_1.hostid or vm_2_host_id != self.virtual_machine_2.hostid, |
| msg="At least one VM should have been migrated to a different host") |
