def remove_shared_cpu(self, request, config_host_class): storage_backing, hosts = keywords.host_helper.get_storage_backing_with_max_hosts() assert hosts, "No hypervisor in storage aggregate" avail_zone = None hosts_unconfigured = [] for host in hosts: shared_cores_host = host_helper.get_host_cpu_cores_for_function(hostname=host, func='shared', thread=0) if shared_cores_host[0] or shared_cores_host.get(1, None): hosts_unconfigured.append(host) if not hosts_unconfigured: return storage_backing, avail_zone hosts_configured = list(set(hosts) - set(hosts_unconfigured)) hosts_to_configure = [] if len(hosts_configured) < 2: hosts_to_configure = hosts_unconfigured[:(2-len(hosts_configured))] for host_to_config in hosts_to_configure: shared_cores = host_helper.get_host_cpu_cores_for_function(host_to_config, 'shared', thread=0) p1_config = p1_revert = None if 1 in shared_cores: p1_config = 0 p1_revert = len(shared_cores[1]) def _modify(host_): host_helper.modify_host_cpu(host_, 'shared', p0=0, p1=p1_config) def _revert(host_): host_helper.modify_host_cpu(host_, 'shared', p0=len(shared_cores[0]), p1=p1_revert) config_host_class(host=host_to_config, modify_func=_modify, revert_func=_revert) host_helper.wait_for_hypervisors_up(host_to_config) hosts_configured.append(host_to_config) hosts_unconfigured.remove(host_to_config) if hosts_unconfigured: avail_zone = 'cgcsauto' LOG.fixture_step("({}) Add admin role to user under primary tenant and add configured hosts {} to " "cgcsauto aggregate".format('class', hosts_configured)) nova_helper.create_aggregate(name='cgcsauto', avail_zone='cgcsauto', check_first=True) code = keystone_helper.add_or_remove_role(add_=True, role='admin')[0] def remove_admin(): nova_helper.delete_aggregates(avail_zone, remove_hosts=True) if code != -1: LOG.fixture_step("({}) Remove admin role and cgcsauto aggregate".format('class')) keystone_helper.add_or_remove_role(add_=False, role='admin') request.addfinalizer(remove_admin) nova_helper.add_hosts_to_aggregate(aggregate=avail_zone, hosts=hosts_configured) return storage_backing, avail_zone
def add_host_to_zone(request, add_cgcsauto_zone, add_admin_role_module): nova_zone_hosts = host_helper.get_up_hypervisors() host_to_add = nova_zone_hosts[0] nova_helper.add_hosts_to_aggregate(aggregate='cgcsauto', hosts=host_to_add) def remove_host_from_zone(): nova_helper.remove_hosts_from_aggregate(aggregate='cgcsauto', check_first=False) request.addfinalizer(remove_host_from_zone) return host_to_add
def add_host_to_zone(request, get_hosts_with_backing, add_cgcsauto_zone): storage_backing, host_under_test = get_hosts_with_backing nova_helper.add_hosts_to_aggregate(aggregate='cgcsauto', hosts=host_under_test) def remove_host_from_zone(): nova_helper.remove_hosts_from_aggregate(aggregate='cgcsauto', check_first=False) request.addfinalizer(remove_host_from_zone) return storage_backing, host_under_test
def add_hosts_to_zone(request, add_admin_role_class, add_cgcsauto_zone, reserve_unreserve_all_hosts_module): storage_backing, target_hosts = keywords.host_helper.get_storage_backing_with_max_hosts() if len(target_hosts) < 2: skip("Less than two up hosts have same storage backing") LOG.fixture_step("Update instance and volume quota to at least 10 and 20 respectively") vm_helper.ensure_vms_quotas() hosts_to_add = target_hosts[:2] nova_helper.add_hosts_to_aggregate(aggregate='cgcsauto', hosts=hosts_to_add) def remove_hosts_from_zone(): nova_helper.remove_hosts_from_aggregate(aggregate='cgcsauto', check_first=False) request.addfinalizer(remove_hosts_from_zone) return storage_backing, hosts_to_add
def sriov_prep(self, request, pci_prep, add_cgcsauto_zone): primary_tenant, primary_tenant_name, other_tenant = pci_prep vif_model = 'pci-sriov' net_type, pci_net, pci_net_id, pnet_id, pnet_name = get_pci_net( request, vif_model, primary_tenant, primary_tenant_name, other_tenant) LOG.fixture_step( "Calculate number of vms and number of vcpus for each vm") pci_hosts = get_pci_hosts(vif_model, pnet_name) # TODO: nova provider-show deprecated. Update required. # vfs_conf, vfs_use_init = nova_helper.get_pci_interface_stats_for_providernet( # pnet_id, fields=('pci_vfs_configured', 'pci_vfs_used')) # # TODO vfs configured per host is inaccurate when hosts are configured differently # vfs_conf_per_host = vfs_conf/len(pci_hosts) # if vfs_conf_per_host < 4: # skip('Less than 4 {} interfaces configured on each host'.format(vif_model)) pci_hosts = pci_hosts[:2] vm_num = 4 vfs_use_init = None # vm_num = min(4, int(vfs_conf_per_host / 4) * 2) initial_host, min_cores_per_proc = get_host_with_min_vm_cores_per_proc( pci_hosts) other_host = pci_hosts[0] if initial_host == pci_hosts[ 1] else pci_hosts[1] vm_vcpus = int(min_cores_per_proc / (vm_num / 2)) def remove_host_from_zone(): LOG.fixture_step( "Remove {} hosts from cgcsauto zone".format(vif_model)) nova_helper.remove_hosts_from_aggregate(aggregate='cgcsauto', check_first=False) request.addfinalizer(remove_host_from_zone) LOG.fixture_step("Add {} hosts to cgcsauto zone: {}".format( vif_model, pci_hosts)) nova_helper.add_hosts_to_aggregate(aggregate='cgcsauto', hosts=pci_hosts) nics = get_pci_vm_nics(vif_model, pci_net_id) return net_type, pci_net, pci_hosts, pnet_id, nics, initial_host, other_host, vfs_use_init, vm_num, vm_vcpus
def get_zone(self, request, add_stxauto_zone): if system_helper.is_aio_simplex(): zone = 'nova' return zone zone = 'stxauto' storage_backing, hosts = \ keywords.host_helper.get_storage_backing_with_max_hosts() host = hosts[0] LOG.fixture_step('Select host {} with backing ' '{}'.format(host, storage_backing)) nova_helper.add_hosts_to_aggregate(aggregate='stxauto', hosts=[host]) def remove_hosts_from_zone(): nova_helper.remove_hosts_from_aggregate(aggregate='stxauto', check_first=False) request.addfinalizer(remove_hosts_from_zone) return zone
def add_hosts_to_zone(self, request, add_cgcsauto_zone, get_hosts_per_backing): hosts_per_backing = get_hosts_per_backing avail_hosts = { key: vals[0] for key, vals in hosts_per_backing.items() if vals } if not avail_hosts: skip("No host in any storage aggregate") nova_helper.add_hosts_to_aggregate(aggregate='cgcsauto', hosts=list(avail_hosts.values())) def remove_hosts_from_zone(): nova_helper.remove_hosts_from_aggregate(aggregate='cgcsauto', check_first=False) request.addfinalizer(remove_hosts_from_zone) return avail_hosts
def setup_quota_and_hosts(self, request, add_admin_role_class, add_cgcsauto_zone): vm_helper.ensure_vms_quotas(vms_num=10, cores_num=50, vols_num=20) storage_backing, target_hosts = host_helper.get_storage_backing_with_max_hosts( ) if len(target_hosts) < 2: skip("Less than two up hosts have same storage backing") hosts_to_add = target_hosts[:2] nova_helper.add_hosts_to_aggregate(aggregate='cgcsauto', hosts=hosts_to_add) def remove_hosts_from_zone(): nova_helper.remove_hosts_from_aggregate(aggregate='cgcsauto', check_first=False) request.addfinalizer(remove_hosts_from_zone) return storage_backing, hosts_to_add
def test_dynamic_vxlan_functional(version, mode): """ Vxlan feature test cases Test Steps: - Make sure Vxlan provider net is configured only on Internal net - Find out a internal network that matches the vxlan mode and IP version - Use the mgmt-net and the internal net to create vms for tenant-1 and tenant-2 - Make sure the vms are occupied on separate hosts achieved with host-aggregates - ssh to the compute where the vm is hosted to check the vshell stats - Ping from the vm and check the stats for known-vtep on the compute - Ping from the vm to a unknown IP and check compute for stats Test Teardown: - Delete vms, volumes created """ vxlan_provider_name = 'group0-data0b' vif_model = 'avp' providernets = system_helper.get_data_networks(field='name', network_type='vxlan') if not providernets or (len(providernets) > 1) or (vxlan_provider_name not in providernets): skip("Vxlan provider-net not configured or Vxlan provider-net configured on more than one provider net\ or not configurd on internal net") # get the id of the providr net vxlan_provider_net_id = system_helper.get_data_networks(field='id', type='vxlan') vm_ids = [] # get 2 computes so we can create the aggregate and force vm-ccupancy computes = host_helper.get_up_hypervisors() if len(computes) < 2: skip(" Need at least 2 computes to run the Vxlan test cases") aggregate_name = 'vxlan' vxlan_computes = computes[0:2] # create aggregate with 2 computes ret_val = nova_helper.create_aggregate(name=aggregate_name, avail_zone=aggregate_name)[1] assert ret_val == aggregate_name, "Aggregate is not create as expected." ResourceCleanup.add('aggregate', aggregate_name) nova_helper.add_hosts_to_aggregate(aggregate=aggregate_name, hosts=vxlan_computes) for compute in computes: assert 0 == clear_vxlan_endpoint_stats(compute), "clear stats failed" LOG.tc_step("Getting Internal net ids.") internal_net_ids = network_helper.get_internal_net_ids_on_vxlan(vxlan_provider_net_id=vxlan_provider_net_id, ip_version=version, mode=mode) if not internal_net_ids: skip("No networks found for ip version {} on the vxlan provider net".format(version)) LOG.tc_step("Creating vms for both tenants.") primary_tenant = Tenant.get_primary() other_tenant = Tenant.get_secondary() for auth_info, vm_host in zip([primary_tenant, other_tenant], vxlan_computes): mgmt_net_id = network_helper.get_mgmt_net_id(auth_info=auth_info) nics = [{'net-id': mgmt_net_id}, {'net-id': internal_net_ids[0], 'vif-model': vif_model}] vm_name = common.get_unique_name(name_str='vxlan') vm_ids.append(vm_helper.boot_vm(name=vm_name, vm_host=vm_host, nics=nics, avail_zone=aggregate_name, auth_info=auth_info, cleanup='function')[1]) # make sure VMS are not in the same compute, I don;t need it but just in case (double checking): if vm_helper.get_vm_host(vm_id=vm_ids[0]) == vm_helper.get_vm_host(vm_id=vm_ids[1]): vm_helper.cold_migrate_vm(vm_id=vm_ids[0]) filter_known_vtep = 'packets-unicast' filter_stat_at_boot = 'packets-multicast' filter_unknown_vtep = 'packets-multicast' if mode is 'static': filter_stat_at_boot = 'packets-unicast' filter_unknown_vtep = 'packets-unicast' LOG.tc_step("Checking stats on computes after vms are launched.") for compute in computes: stats_after_boot_vm = get_vxlan_endpoint_stats(compute, field=filter_stat_at_boot) if len(stats_after_boot_vm) is 3: stats = int(stats_after_boot_vm[1]) + int(stats_after_boot_vm[2]) LOG.info("Got the stats for packets {} after vm launched is {}".format(filter_stat_at_boot, stats)) elif len(stats_after_boot_vm) is 2: stats = int(stats_after_boot_vm[1]) LOG.info("Got the stats for packets {} after vm launched is {}".format(filter_stat_at_boot, stats)) else: assert 0, "Failed to get stats from compute" assert 0 < int(stats), "stats are not incremented as expected" # clear stats LOG.tc_step("Clearing vxlan-endpoint-stats on computes: {}".format(computes)) for compute in computes: assert 0 == clear_vxlan_endpoint_stats(compute), "clear stats failed" # Ping b/w vm over Internal nets and check stats, ping from 2nd vm LOG.tc_step("Ping between two vms over internal network") vm_helper.ping_vms_from_vm(to_vms=vm_ids[0], from_vm=vm_ids[1], net_types=['internal']) stats_after_ping = get_vxlan_endpoint_stats(computes[0], field=filter_known_vtep) if not stats_after_ping: assert "Compute stats are empty" LOG.tc_step("Checking stats on computes after vm ping over the internal net.") if len(stats_after_ping) is 3: stats_known_vtep = int(stats_after_ping[1]) + int(stats_after_ping[2]) LOG.info("Got the stats for packets {} after ping {}".format(filter_known_vtep, stats_known_vtep)) elif len(stats_after_ping) is 2: stats_known_vtep = int(stats_after_ping[1]) LOG.info("Got the stats for packets {} after ping {}".format(filter_known_vtep, stats_known_vtep)) else: assert 0, "Failed to get stats from compute" assert 0 < int(stats_known_vtep), "stats are not incremented as expected" # clear stats LOG.tc_step("Clearing vxlan-endpoint-stats on computes: {}".format(computes)) for compute in computes: assert 0 == clear_vxlan_endpoint_stats(compute), "clear stats failed" # ping unknown IP over the internal net and check stats LOG.tc_step("Ping to an unknown IP from vms over internal network") unknown_ip = '10.10.10.30' with vm_helper.ssh_to_vm_from_natbox(vm_ids[1]) as vm2_ssh: LOG.tc_step("Ping unknown ip from guest") cmd = 'ping -I eth1 -c 5 {}'.format(unknown_ip) code, output = vm2_ssh.exec_cmd(cmd=cmd, expect_timeout=60) assert int(code) > 0, "Expected to see 100% ping failure" LOG.tc_step("Checking stats on computes after vm ping on unknown IP.") stats_after_ping_unknown_vtep = get_vxlan_endpoint_stats(computes[1], field=filter_unknown_vtep) if not stats_after_ping_unknown_vtep: assert 0, "Compute stats are empty" if len(stats_after_ping_unknown_vtep) is 3: stats_unknown_vtep = int(stats_after_ping_unknown_vtep[1]) + int(stats_after_ping_unknown_vtep[2]) LOG.info("Got the stats for packets {} after ping unknown vtep {}".format(filter_unknown_vtep, stats_unknown_vtep)) elif len(stats_after_ping_unknown_vtep) is 2: stats_unknown_vtep = int(stats_after_ping_unknown_vtep[1]) LOG.info("Got the stats for packets {} after ping uknown vtep {}".format(filter_unknown_vtep, stats_unknown_vtep)) else: assert 0, "Failed to get stats from compute" assert 0 < int(stats_unknown_vtep), "stats are not incremented as expected"
def add_1g_and_4k_pages(self, request, config_host_class, skip_for_one_proc, add_stxauto_zone, add_admin_role_module): storage_backing, candidate_hosts = \ keywords.host_helper.get_storage_backing_with_max_hosts() if len(candidate_hosts) < 2: skip("Less than two up hosts have same storage backing") LOG.fixture_step("Check mempage configs for hypervisors and select " "host to use or configure") hosts_selected, hosts_to_configure = get_hosts_to_configure( candidate_hosts) if set(hosts_to_configure) != {None}: def _modify(host): is_1g = True if hosts_selected.index(host) == 0 else False proc1_kwargs = {'gib_1g': 2, 'gib_4k_range': (None, 2)} if \ is_1g else {'gib_1g': 0, 'gib_4k_range': (2, None)} kwargs = {'gib_1g': 0, 'gib_4k_range': (None, 2)}, proc1_kwargs actual_mems = host_helper._get_actual_mems(host=host) LOG.fixture_step("Modify {} proc0 to have 0 of 1G pages and " "<2GiB of 4K pages".format(host)) host_helper.modify_host_memory(host, proc=0, actual_mems=actual_mems, **kwargs[0]) LOG.fixture_step("Modify {} proc1 to have >=2GiB of {} " "pages".format(host, '1G' if is_1g else '4k')) host_helper.modify_host_memory(host, proc=1, actual_mems=actual_mems, **kwargs[1]) for host_to_config in hosts_to_configure: if host_to_config: config_host_class(host=host_to_config, modify_func=_modify) LOG.fixture_step( "Check mem pages for {} are modified " "and updated successfully".format(host_to_config)) host_helper.wait_for_memory_update(host=host_to_config) LOG.fixture_step("Check host memories for {} after mem config " "completed".format(hosts_selected)) _, hosts_unconfigured = get_hosts_to_configure(hosts_selected) assert not hosts_unconfigured[0], \ "Failed to configure {}. Expt: proc0:1g<2,4k<2gib;" \ "proc1:1g>=2,4k<2gib".format(hosts_unconfigured[0]) assert not hosts_unconfigured[1], \ "Failed to configure {}. Expt: proc0:1g<2,4k<2gib;" \ "proc1:1g<2,4k>=2gib".format(hosts_unconfigured[1]) LOG.fixture_step('(class) Add hosts to stxauto aggregate: ' '{}'.format(hosts_selected)) nova_helper.add_hosts_to_aggregate(aggregate='stxauto', hosts=hosts_selected) def remove_host_from_zone(): LOG.fixture_step('(class) Remove hosts from stxauto aggregate: ' '{}'.format(hosts_selected)) nova_helper.remove_hosts_from_aggregate(aggregate='stxauto', check_first=False) request.addfinalizer(remove_host_from_zone) return hosts_selected, storage_backing