def adjust_vm_quota(vm_count, con_ssh, backup_info=None): """ Increase the quotas for creating VM if needed for the tenant in testing. The following quotas if any will be changed: instances cores - make sure quota allows 2 cores for each VM ram - make sure 2M for each VM Args: vm_count: - number of VMs con_ssh: - current ssh connection backup_info: - backup options for doing System Backup Return: None """ tenant = backup_info['tenant'] quota_details = vm_helper.get_quota_details_info( 'compute', resources='instances', tenant=tenant)['instances'] min_instances_quota = vm_count + quota_details['in use'] + quota_details[ 'reserved'] if min_instances_quota > quota_details['limit']: LOG.info('Insufficient quota for instances, increase to: {}'.format( min_instances_quota)) vm_helper.ensure_vms_quotas(vms_num=min_instances_quota, tenant=tenant, con_ssh=con_ssh)
def test_lock_with_max_vms_simplex(self, simplex_only): vms_num = host_helper.get_max_vms_supported(host='controller-0') vm_helper.ensure_vms_quotas(vms_num=vms_num) LOG.tc_step( "Boot {} vms with various storage settings".format(vms_num)) vms = vm_helper.boot_vms_various_types(cleanup='function', vms_num=vms_num) LOG.tc_step("Lock vm host on simplex system") HostsToRecover.add('controller-0') host_helper.lock_host('controller-0') LOG.tc_step("Ensure vms are in {} state after locked host come " "online".format(VMStatus.STOPPED)) vm_helper.wait_for_vms_values(vms, value=VMStatus.STOPPED, fail_ok=False) LOG.tc_step("Unlock host on simplex system") host_helper.unlock_host(host='controller-0') LOG.tc_step("Ensure vms are Active and Pingable from NatBox") vm_helper.wait_for_vms_values(vms, value=VMStatus.ACTIVE, fail_ok=False, timeout=600) for vm in vms: vm_helper.wait_for_vm_pingable_from_natbox( vm, timeout=VMTimeout.DHCP_RETRY)
def pre_check(request): """ This is to adjust the quota return: code 0/1 """ hypervisors = host_helper.get_up_hypervisors() if len(hypervisors) < 3: skip('Large heat tests require 3+ hypervisors') # disable remote cli for these testcases remote_cli = ProjVar.get_var('REMOTE_CLI') if remote_cli: ProjVar.set_var(REMOTE_CLI=False) def revert(): ProjVar.set_var(REMOTE_CLI=remote_cli) request.addfinalizer(revert) vm_helper.set_quotas(networks=100) vm_helper.ensure_vms_quotas(cores_num=100, vols_num=100, vms_num=100) def list_status(): LOG.fixture_step("Listing heat resources and nova migrations") stacks = heat_helper.get_stacks(auth_info=Tenant.get('admin')) for stack in stacks: heat_helper.get_stack_resources(stack=stack, auth_info=Tenant.get('admin')) nova_helper.get_migration_list_table() request.addfinalizer(list_status)
def check_system(): storage_backing, hosts = host_helper.get_storage_backing_with_max_hosts() up_hypervisors = host_helper.get_up_hypervisors() if not up_hypervisors: skip('No up hypervisor on system') vm_helper.ensure_vms_quotas(vms_num=10, cores_num=20, vols_num=10) return hosts, storage_backing, up_hypervisors
def skip_test_if_less_than_two_hosts(no_simplex): hypervisors = host_helper.get_up_hypervisors() if len(hypervisors) < 2: skip(SkipHypervisor.LESS_THAN_TWO_HYPERVISORS) LOG.fixture_step( "Update instance and volume quota to at least 10 and 20 respectively") vm_helper.ensure_vms_quotas(vms_num=10) return len(hypervisors)
def hosts_pci_device_info(): # get lab host list actual_hosts_device_info = {} compute_hosts = host_helper.get_up_hypervisors() for host in compute_hosts: device_info = host_helper.get_host_pci_devices(host, dev_class='Co-processor') if device_info: actual_hosts_device_info[host] = device_info LOG.info("Hosts device info: {}".format(actual_hosts_device_info)) if not actual_hosts_device_info: skip("co-processor PCI device not found") hosts_device_info = {} sys_host_fields = ('address', 'name', 'vendor id', 'device id') for host in actual_hosts_device_info: sys_devs = host_helper.get_host_devices(host, field=sys_host_fields) actual_pci_devs = actual_hosts_device_info[host] hosts_device_info[host] = [] for dev_info in actual_pci_devs: actual_pci_addr, actual_vendor_name, actual_dev_name, vf_dev_id, vf_count = dev_info actual_pci_addr = '0000:{}'.format(actual_pci_addr) assert actual_pci_addr in sys_devs[0], "Existing Co-processor pci device is not " \ "listed in system host-device-list" hosts_with_dev = [host_ for host_, devs_ in actual_hosts_device_info.items() if actual_dev_name in [dev[2] for dev in devs_]] if len(hosts_with_dev) < len(actual_hosts_device_info): LOG.info('QAT dev {} is only configured on {}'.format(actual_dev_name, hosts_with_dev)) continue dev_name = actual_dev_name.split(maxsplit=1)[0].lower() index = sys_devs[0].index(actual_pci_addr) pci_addr, name, vendor_id, device_id = list(zip(*sys_devs))[index] dev_info_dict = {'pci_address': pci_addr, 'pci_name': name, 'vendor_id': vendor_id, 'device_id': device_id, 'vf_device_id': vf_dev_id, 'vf_count': vf_count, 'pci_alias': 'qat-{}-vf'.format(dev_name), } hosts_device_info[host].append(dev_info_dict) hosts_device_info = {k: v for k, v in hosts_device_info.items() if v} if not hosts_device_info: skip('No common QAT device configured on computes. Skip test.') LOG.info('QAT devices to use for test: {}'.format(hosts_device_info)) vm_helper.ensure_vms_quotas(vms_num=20) return hosts_device_info
def _vms(): vm_helper.ensure_vms_quotas(vms_num=8) glance_helper.get_guest_image(guest_os=GUEST_OS, cleanup='module') LOG.fixture_step("Create a favor with dedicated cpu policy") flavor_id = nova_helper.create_flavor(name='dedicated-ubuntu', guest_os=GUEST_OS)[1] ResourceCleanup.add('flavor', flavor_id, scope='module') nova_helper.set_flavor(flavor_id, **{FlavorSpec.CPU_POLICY: 'dedicated'}) mgmt_net_id = network_helper.get_mgmt_net_id() internal_net_id = network_helper.get_internal_net_id() tenant_net_ids = network_helper.get_tenant_net_ids() if len(tenant_net_ids) < VMS_COUNT: tenant_net_ids += tenant_net_ids assert len(tenant_net_ids) >= VMS_COUNT vif = 'avp' if system_helper.is_avs() else 'virtio' vm_vif_models = { 'virtio_vm1': ('virtio', tenant_net_ids[0]), '{}_vm1'.format(vif): (vif, tenant_net_ids[1]), 'virtio_vm2': ('virtio', tenant_net_ids[2]), '{}_vm2'.format(vif): (vif, tenant_net_ids[3]) } vms = [] for vm_name, vifs in vm_vif_models.items(): vif_model, tenant_net_id = vifs nics = [{ 'net-id': mgmt_net_id }, { 'net-id': tenant_net_id, 'vif-model': vif_model }, { 'net-id': internal_net_id, 'vif-model': vif_model }] LOG.fixture_step( "Boot a ubuntu14 vm with {} nics from above flavor and volume". format(vif_model)) vm_id = vm_helper.boot_vm(vm_name, flavor=flavor_id, source='volume', cleanup='module', nics=nics, guest_os=GUEST_OS)[1] vms.append(vm_id) return vms
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 setups(no_simplex): vm_helper.ensure_vms_quotas(vms_num=10, cores_num=20, vols_num=10) storage_backing, hosts = keywords.host_helper.get_storage_backing_with_max_hosts() if len(hosts) < 2: skip("Less than two hosts with in same storage aggregate") LOG.fixture_step("Create a flavor with server group messaging enabled") flavor_id = nova_helper.create_flavor('srv_grp_msg', storage_backing=storage_backing)[1] nova_helper.set_flavor(flavor_id, **{FlavorSpec.SRV_GRP_MSG: True}) LOG.fixture_step("Create affinity and anti-affinity server groups") affinity_grp = nova_helper.create_server_group(policy='affinity')[1] policy = 'soft_anti_affinity' if len(hosts) < 3 else 'anti_affinity' anti_affinity_grp = nova_helper.create_server_group(policy=policy)[1] return hosts, flavor_id, {'affinity': affinity_grp, 'anti_affinity': anti_affinity_grp}
def get_cpu_count(hosts_with_backing): LOG.fixture_step("Find suitable vm host and cpu count and backing of host") compute_space_dict = {} vm_host = hosts_with_backing[0] numa0_used_cpus, numa0_total_cpus = host_helper.get_vcpus_per_proc( vm_host)[vm_host][0] numa0_avail_cpus = len(numa0_total_cpus) - len(numa0_used_cpus) for host in hosts_with_backing: free_space = get_disk_avail_least(host) compute_space_dict[host] = free_space LOG.info("{} space on {}".format(free_space, host)) # increase quota LOG.fixture_step("Increase quota of allotted cores") vm_helper.ensure_vms_quotas(cores_num=int(numa0_avail_cpus + 30)) return vm_host, numa0_avail_cpus, compute_space_dict
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_ea_max_vms_with_crypto_vfs(_flavors, hosts_pci_device_info): """ Verify maximum number of guests with Crypto VFs can be launched and stabilized Args: _flavors: hosts_pci_device_info: Returns: """ LOG.info("Pci device {}".format(hosts_pci_device_info)) flavor_id = _flavors['flavor_qat_vf_4'] # Assume we only have 1 coleto creek pci device on system crypto_hosts = list(hosts_pci_device_info.keys()) host = crypto_hosts[0] vf_info = hosts_pci_device_info[host][0] vf_device_id = vf_info['vf_device_id'] vf_count = vf_info['vf_count'] LOG.info("Vf_device_id {}, count: {}".format(vf_device_id, vf_count)) # number of vms to launch to max out the total configured device VFs. Each VM is launched with 4 Vfs. 4 Vfs in each # compute are reserved for resize nova action. number_of_vms = int((vf_count - 4 * len(crypto_hosts)) / 4) mgmt_net_id = network_helper.get_mgmt_net_id() tenant_net_id = network_helper.get_tenant_net_id() vif_type = get_vif_type() nics = [{'net-id': mgmt_net_id}, {'net-id': tenant_net_id, 'vif-model': vif_type}] vm_helper.ensure_vms_quotas(number_of_vms + 10) vms = {} LOG.tc_step("Launch {} vms using flavor flavor_qat_vf_4 and nics {}".format(number_of_vms, nics)) for i in range(1, number_of_vms + 1): vm_name = 'vm_crypto_{}'.format(i) vm_id = vm_helper.boot_vm(cleanup='function', name='vm_crypto_{}'.format(i), nics=nics, flavor=flavor_id)[1] vm_helper.wait_for_vm_pingable_from_natbox(vm_id) vms[vm_name] = vm_id for vm_name_, vm_id_ in vms.items(): vm_host = vm_helper.get_vm_host(vm_id_) host_dev_name = hosts_pci_device_info[vm_host][0]['device_name'] expt_qat_devs = {host_dev_name: 4} check_helper.check_qat_service(vm_id=vm_id_, qat_devs=expt_qat_devs) LOG.info("Checking if other host has room for cold migrate vm {}".format(vm_name_)) for host_ in crypto_hosts: if host_ != vm_host: total_vfs, used_vfs = network_helper.get_pci_device_vfs_counts_for_host( host_, device_id=vf_device_id, fields=('pci_vfs_configured', 'pci_vfs_used')) if int(total_vfs) - int(used_vfs) >= 4: LOG.info("Migrate to other host is possible") expt_res = 0 break else: LOG.info("Migrate to other host is not possible") expt_res = 2 LOG.tc_step("Attempt to cold migrate {} and ensure it {}".format(vm_name_, 'succeeds' if expt_res == '0' else 'fails')) rc, msg = vm_helper.cold_migrate_vm(vm_id=vm_id_, fail_ok=True) assert expt_res == rc, "Expected: {}. Actual: {}".format(expt_res, msg) vm_helper.wait_for_vm_pingable_from_natbox(vm_id_) LOG.tc_step("Suspend/resume VM {} ....".format(vm_name_)) vm_helper.suspend_vm(vm_id_) vm_helper.resume_vm(vm_id_) vm_helper.wait_for_vm_pingable_from_natbox(vm_id_) # vm_host = nova_helper.get_vm_host(vm_id_) # total, used = network_helper.get_pci_device_vfs_counts_for_host(vm_host, vf_device_id)[0] # if (total - int(used)) >= 4: # expt_res = 0 flavor_resize_id = _flavors['flavor_resize_qat_vf_4'] LOG.tc_step("Resize VM {} to new flavor {} with increased memory...".format(vm_name_, flavor_resize_id)) vm_helper.resize_vm(vm_id_, flavor_resize_id) vm_helper.wait_for_vm_pingable_from_natbox(vm_id_) # else: # expt_res = 1 # LOG.info("Resizing of vm {} skipped; host {} max out vfs; used vfs = {}".format(vm_name_, vm_host, used)) LOG.tc_step("Attempt to live migrate {} and ensure it's rejected".format(vm_name_)) rc, msg = vm_helper.live_migrate_vm(vm_id=vm_id_, fail_ok=True) assert 6 == rc, "Expect live migration to fail on vm with pci alias device. Actual: {}".format(msg) vm_helper.wait_for_vm_pingable_from_natbox(vm_id_) check_helper.check_qat_service(vm_id=vm_id_, qat_devs=expt_qat_devs)
def test_lock_with_vms(self, target_hosts, no_simplex, add_admin_role_func): """ Test lock host with vms on it. Args: target_hosts (list): targeted host(s) to lock that was prepared by the target_hosts test fixture. Skip Conditions: - Less than 2 hypervisor hosts on the system Prerequisites: - Hosts storage backing are pre-configured to storage backing under test ie., 2 or more hosts should support the storage backing under test. Test Setups: - Set instances quota to 10 if it was less than 8 - Determine storage backing(s) under test. i.e.,storage backings supported by at least 2 hosts on the system - Create flavors with storage extra specs set based on storage backings under test - Create vms_to_test that can be live migrated using created flavors - Determine target host(s) to perform lock based on which host(s) have the most vms_to_test - Live migrate vms to target host(s) Test Steps: - Lock target host - Verify lock succeeded and vms status unchanged - Repeat above steps if more than one target host Test Teardown: - Delete created vms and volumes - Delete created flavors - Unlock locked target host(s) """ storage_backing, host = target_hosts vms_num = 5 vm_helper.ensure_vms_quotas(vms_num=vms_num) LOG.tc_step( "Boot {} vms with various storage settings".format(vms_num)) vms = vm_helper.boot_vms_various_types(cleanup='function', vms_num=vms_num, storage_backing=storage_backing, target_host=host) LOG.tc_step("Attempt to lock target host {}...".format(host)) HostsToRecover.add(host) host_helper.lock_host(host=host, check_first=False, fail_ok=False, swact=True) LOG.tc_step("Verify lock succeeded and vms still in good state") vm_helper.wait_for_vms_values(vms=vms, fail_ok=False) for vm in vms: vm_host = vm_helper.get_vm_host(vm_id=vm) assert vm_host != host, "VM is still on {} after lock".format(host) vm_helper.wait_for_vm_pingable_from_natbox( vm_id=vm, timeout=VMTimeout.DHCP_RETRY)
def update_instances_quota(): vm_helper.ensure_vms_quotas()
def test_dvr_vms_network_connection(vms_num, srv_grp_policy, server_groups, router_info): """ Test vms East West connection by pinging vms' data network from vm Args: vms_num (int): number of vms to boot srv_grp_policy (str): affinity to boot vms on same host, anti-affinity to boot vms on different hosts server_groups: test fixture to return affinity and anti-affinity server groups router_info (str): id of tenant router Skip Conditions: - Only one nova host on the system Setups: - Enable DVR (module) Test Steps - Update router to distributed if not already done - Boot given number of vms with specific server group policy to schedule vms on same or different host(s) - Ping vms' over data and management networks from one vm to test NS and EW traffic Teardown: - Delete vms - Revert router to """ # Increase instance quota count if needed current_vms = len(vm_helper.get_vms(strict=False)) quota_needed = current_vms + vms_num vm_helper.ensure_vms_quotas(quota_needed) if srv_grp_policy == 'anti-affinity' and len( host_helper.get_up_hypervisors()) == 1: skip("Only one nova host on the system.") LOG.tc_step("Update router to distributed if not already done") router_id = router_info is_dvr = network_helper.get_router_values(router_id, fields='distributed', auth_info=Tenant.get('admin'))[0] if not is_dvr: network_helper.set_router_mode(router_id, distributed=True) LOG.tc_step("Boot {} vms with server group policy {}".format( vms_num, srv_grp_policy)) affinity_grp, anti_affinity_grp = server_groups(soft=True) srv_grp_id = affinity_grp if srv_grp_policy == 'affinity' else anti_affinity_grp vms = [] tenant_net_id = network_helper.get_tenant_net_id() mgmt_net_id = network_helper.get_mgmt_net_id() internal_net_id = network_helper.get_internal_net_id() internal_vif = {'net-id': internal_net_id} if system_helper.is_avs(): internal_vif['vif-model'] = 'avp' nics = [{'net-id': mgmt_net_id}, {'net-id': tenant_net_id}, internal_vif] for i in range(vms_num): vol = cinder_helper.create_volume()[1] ResourceCleanup.add(resource_type='volume', resource_id=vol) vm_id = vm_helper.boot_vm('dvr_ew_traffic', source='volume', source_id=vol, nics=nics, cleanup='function', hint={'group': srv_grp_id})[1] vms.append(vm_id) LOG.tc_step("Wait for vm {} pingable from NatBox".format(vm_id)) vm_helper.wait_for_vm_pingable_from_natbox(vm_id, fail_ok=False) from_vm = vms[0] LOG.tc_step( "Ping vms over management and data networks from vm {}, and verify " "ping successful.".format(from_vm)) vm_helper.ping_vms_from_vm(to_vms=vms, from_vm=from_vm, fail_ok=False, net_types=['data', 'mgmt', 'internal'])
def add_shared_cpu(self, no_simplex, config_host_class, request): """ This fixture ensures at least two hypervisors are configured with shared cpu on proc0 and proc1 It also reverts the configs at the end. Args: no_simplex: config_host_class: request: Returns: """ storage_backing, hosts = keywords.host_helper.get_storage_backing_with_max_hosts() if len(hosts) < 2: skip("Less than two hypervisors with same storage backend") LOG.fixture_step("Ensure at least two hypervisors has shared cpu cores on both p0 and p1") shared_cpu_hosts = [] shared_disabled_hosts = {} modified_hosts = [] for host_ in hosts: shared_cores_for_host = host_helper.get_host_cpu_cores_for_function(hostname=host_, func='shared') if 1 not in shared_cores_for_host: LOG.info("{} has only 1 processor. Ignore.".format(host_)) continue if shared_cores_for_host[0] and shared_cores_for_host[1]: shared_cpu_hosts.append(host_) if len(shared_cpu_hosts) == 2: break else: shared_disabled_hosts[host_] = shared_cores_for_host else: if len(shared_disabled_hosts) + len(shared_cpu_hosts) < 2: skip("Less than two up hypervisors with 2 processors") def _modify(host_to_modify): host_helper.modify_host_cpu(host_to_modify, 'shared', p0=1, p1=1) host_helper.modify_host_memory(host_to_modify, proc=0, gib_1g=4) for host_to_config in shared_disabled_hosts: config_host_class(host=host_to_config, modify_func=_modify) host_helper.wait_for_hypervisors_up(host_to_config) host_helper.wait_for_memory_update(host_to_config) check_host_cpu_and_memory(host_to_config, expt_shared_cpu={0: 1, 1: 1}, expt_1g_page={0: 4}) shared_cpu_hosts.append(host_to_config) modified_hosts.append(host_to_config) if len(shared_cpu_hosts) >= 2: break def revert(): for host_to_revert in modified_hosts: check_host_cpu_and_memory(host_to_revert, expt_shared_cpu={0: 1, 1: 1}, expt_1g_page={0: 4}) p0_shared = len(shared_disabled_hosts[host_to_revert][0]) p1_shared = len(shared_disabled_hosts[host_to_revert][1]) try: LOG.fixture_step("Revert {} shared cpu and memory setting".format(host_to_revert)) host_helper.lock_host(host_to_revert) host_helper.modify_host_cpu(host_to_revert, 'shared', p0=p0_shared, p1=p1_shared) host_helper.modify_host_memory(host_to_revert, proc=0, gib_1g=0) finally: host_helper.unlock_host(host_to_revert) host_helper.wait_for_memory_update(host_to_revert) check_host_cpu_and_memory(host_to_revert, expt_shared_cpu={0: p0_shared, 1: p1_shared}, expt_1g_page={0: 0}) request.addfinalizer(revert) max_vcpus_proc0 = 0 max_vcpus_proc1 = 0 host_max_proc0 = None host_max_proc1 = None LOG.fixture_step("Get VMs cores for each host") for host in shared_cpu_hosts: vm_cores_per_proc = host_helper.get_host_cpu_cores_for_function(host, func='Application', thread=None) if len(vm_cores_per_proc[0]) > max_vcpus_proc0: max_vcpus_proc0 = len(vm_cores_per_proc[0]) host_max_proc0 = host if len(vm_cores_per_proc.get(1, [])) > max_vcpus_proc1: max_vcpus_proc1 = len(vm_cores_per_proc.get(1, [])) host_max_proc1 = host LOG.fixture_step("Increase quota of allotted cores") vm_helper.ensure_vms_quotas(cores_num=(max(max_vcpus_proc0, max_vcpus_proc1) + 1)) return storage_backing, shared_cpu_hosts, [(max_vcpus_proc0, host_max_proc0), (max_vcpus_proc1, host_max_proc1)]
def update_quotas(add_admin_role_module): LOG.fixture_step("Update instance and volume quota to at least 10 and " "20 respectively") vm_helper.ensure_vms_quotas()
def _test_pci_resource_usage(vif_model_check): """ Create a vm under test with specified vifs for tenant network Returns (str): id of vm under test """ vif_model, base_vm, flavor_id, nics_to_test, seg_id, net_type, pnet_name, extra_pcipt_net_name, extra_pcipt_net = \ vif_model_check LOG.tc_step("Ensure core/vm quota is sufficient") if 'sriov' in vif_model: vm_type = 'sriov' resource_param = 'pci_vfs_used' max_resource = 'pci_vfs_configured' else: vm_type = 'pcipt' resource_param = 'pci_pfs_used' max_resource = 'pci_pfs_configured' LOG.tc_step( "Get resource usage for {} interface before booting VM(s)".format( vif_model)) LOG.info("provider net for {} interface: {}".format(vif_model, pnet_name)) assert pnet_name, "provider network for {} interface is not found".format( vif_model) total_val, pre_resource_value = nova_helper.get_pci_interface_stats_for_providernet( pnet_name, fields=(max_resource, resource_param)) LOG.info("Resource Usage {} for {}. Resource configured: {}".format( pre_resource_value, vif_model, total_val)) expt_change = 2 if vif_model == 'pci-passthrough' and extra_pcipt_net else 1 vm_limit = int((total_val - pre_resource_value) / expt_change) if vif_model == 'pci-passthrough' else 5 vm_helper.ensure_vms_quotas(vm_limit + 5) vms_under_test = [] for i in range(vm_limit): LOG.tc_step("Boot a vm with {} vif model on {} net".format( vif_model, net_type)) vm_id = vm_helper.boot_vm(name=vif_model, flavor=flavor_id, cleanup='function', nics=nics_to_test)[1] vms_under_test.append(vm_id) vm_helper.wait_for_vm_pingable_from_natbox(vm_id, fail_ok=False) if vm_type == 'pcipt': LOG.tc_step("Add vlan to pci-passthrough interface for VM.") vm_helper.add_vlan_for_vm_pcipt_interfaces(vm_id=vm_id, net_seg_id=seg_id) LOG.tc_step( "Ping vm over mgmt and {} nets from itself".format(net_type)) vm_helper.ping_vms_from_vm(to_vms=vm_id, from_vm=vm_id, net_types=['mgmt', net_type]) LOG.tc_step( "Check resource usage for {} interface increased by 1".format( vif_model)) resource_value = nova_helper.get_provider_net_info( pnet_name, field=resource_param) assert pre_resource_value + expt_change == resource_value, "Resource usage for {} is not increased by {}". \ format(vif_model, expt_change) pre_resource_value = resource_value for vm_to_del in vms_under_test: LOG.tc_step( "Check resource usage for {} interface reduced by 1 after deleting a vm" .format(vif_model)) vm_helper.delete_vms(vm_to_del, check_first=False, stop_first=False) resource_val = common.wait_for_val_from_func( expt_val=pre_resource_value - expt_change, timeout=30, check_interval=3, func=nova_helper.get_provider_net_info, providernet_id=pnet_name, field=resource_param)[1] assert pre_resource_value - expt_change == resource_val, "Resource usage for {} is not reduced by {}". \ format(vif_model, expt_change) pre_resource_value = resource_val