def test_hp_distribution_1g_2m_for_vms(self, env, os_conn, computes_with_mixed_hp, networks, flavors, security_group): """This test checks huge pages 1Gb and 2Mb distribution for vms Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Create vm1 in net1 on compute1 with 1Gb flavor 3. Create vm2 in net2 on compute2 with 2Mb flavor 4. Create vm3 in net2 on compute1 with 2Mb flavor 5. Check instances configuration (about huge pages) 6. Check quantity of HP on computes 7. Check pings from all vms to all vms by all ips """ small_nfv_flavor, medium_nfv_flavor = flavors[0], flavors[1] count_to_allocate_2mb = small_nfv_flavor.ram * 1024 / page_2mb count_to_allocate_1gb = medium_nfv_flavor.ram * 1024 / page_1gb initial_conf = computes_configuration(env) hosts = computes_with_mixed_hp vms_params = [ (hosts[0], networks[0], medium_nfv_flavor, page_1gb), (hosts[1], networks[1], small_nfv_flavor, page_2mb), (hosts[0], networks[1], small_nfv_flavor, page_2mb), ] vms = {} for i, (host, network, flavor, size) in enumerate(vms_params): vm = os_conn.create_server( name='vm{}'.format(i), flavor=flavor.id, nics=[{'net-id': network}], availability_zone='nova:{}'.format(host), security_groups=[security_group.id]) vms.update({vm: size}) for vm, exp_size in vms.items(): assert self.get_instance_page_size(os_conn, vm) == exp_size vms_distribution = [(hosts[0], 1, 1), (hosts[1], 0, 1), ] final_conf = computes_configuration(env) for (host, nr_1gb, nr_2mb) in vms_distribution: exp_free_1g = (initial_conf[host][page_1gb]['total'] - nr_1gb * count_to_allocate_1gb) exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_1g == final_conf[host][page_1gb]['free'] assert exp_free_2m == final_conf[host][page_2mb]['free'] os_conn.wait_servers_ssh_ready(vms.keys()) network_checks.check_vm_connectivity(env, os_conn)
def test_allocation_huge_pages_2m_for_vms(self, env, os_conn, networks, computes_with_hp_2mb, flavors, security_group): """This test checks allocation 2M HugePages for instances Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Launch vm1 and vm2 using net1 on the first compute 3. Launch vm3 using net1 on the second compute 4. Launch vm4 using net2 on the second compute 5. Check instances configuration (about huge pages) 6. Check quantity of HP on computes 7. Associate floating to vm1 8. Check pings from all vms to all vms by all ips """ small_nfv_flavor = flavors[0] count_to_allocate_2mb = small_nfv_flavor.ram * 1024 / page_2mb initial_conf = computes_configuration(env) hosts = computes_with_hp_2mb vms = [] vms_params = [ (hosts[0], networks[0]), (hosts[0], networks[0]), (hosts[0], networks[1]), (hosts[1], networks[1]), ] for i, (host, network) in enumerate(vms_params): vm = os_conn.create_server( name='vm{}'.format(i), flavor=small_nfv_flavor.id, nics=[{'net-id': network}], availability_zone='nova:{}'.format(host), security_groups=[security_group.id]) vms.append(vm) for vm in vms: assert self.get_instance_page_size(os_conn, vm) == page_2mb vms_distribution = [(hosts[0], 3), (hosts[1], 1), ] final_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == final_conf[host][page_2mb]['free'] os_conn.assign_floating_ip(vms[0]) os_conn.wait_servers_ssh_ready(vms) network_checks.check_vm_connectivity(env, os_conn)
def test_vms_connectivity_after_evacuation(self, env, os_conn, volume, computes_with_dpdk_hp, flavors, networks, keypair, devops_env, security_group): """This test checks connectivity between VMs with DPDK after evacuation. Please note we're not able to count DPDK huge pages only, they're added to count of 2Mb huge pages. Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Create flavor for huge pages with 512Mb ram, 1 vcpu and 1Gb disk 3. Launch vm1 (from not empty volume), vm2 on compute-1, vm3 - on compute-2, vm1 in net1, vm2 and vm3 in net2 4. Kill compute2 and evacuate vm3 5. Check vms connectivity 6. Start compute2 7. Check instance page size 8. Check that neutron port has binding:vif_type = vhostuser 9. Check that count of free 2Mb huge pages is expected one for each host """ hosts = computes_with_dpdk_hp initial_conf = computes_configuration(env) vms_param = [(hosts[0], networks[0], {'vda': volume.id}), (hosts[0], networks[1], None), (hosts[1], networks[1], None)] vms = self.create_vms(os_conn, hosts, networks, flavors[0], keypair, security_group, vms_param=vms_param) network_checks.check_vm_connectivity(env, os_conn, vm_keypair=keypair) self.compute_change_state(os_conn, devops_env, hosts[1], state='down') vm_new = self.evacuate(os_conn, devops_env, vms[2], on_shared_storage=False) vm_new_host = getattr(os_conn.nova.servers.get(vm_new), "OS-EXT-SRV-ATTR:host") assert vm_new_host in hosts assert vm_new_host != hosts[1] network_checks.check_vm_connectivity(env, os_conn, vm_keypair=keypair) self.compute_change_state(os_conn, devops_env, hosts[1], state='up') final_conf = computes_configuration(env) exp_hosts_usage = [(hosts[0], 3), (hosts[1], 0)] for (host, nr_2mb) in exp_hosts_usage: exp_free_2m = (initial_conf[host][page_2mb]['free'] - nr_2mb * flavors[0].ram * 1024 / page_2mb) assert exp_free_2m == final_conf[host][page_2mb]['free']
def test_allocation_huge_pages_2m_for_vms_with_old_flavor( self, env, os_conn, networks, computes_with_hp_2mb, flavors, computes_without_hp, security_group): """This test checks that Huge pages set for vm1, vm2 and vm3 shouldn't use Huge pages, connectivity works properly Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Create vm1 in net1 on compute1 with 2Mb flavor 3. Create vm2 in net2 on compute2 with old flavor 4. Create vm3 in net1 on compute1 with old flavor 5. Check huge pages. Check that it was allocated only HP for vm1 6. Check pings from all vms to all vms by all ips """ small_nfv_flavor, old_flavor = flavors[0], flavors[2] count_to_allocate_2mb = small_nfv_flavor.ram * 1024 / page_2mb initial_conf = computes_configuration(env) hosts_hp = computes_with_hp_2mb hosts_no_hp = computes_without_hp vms_params = [ (hosts_hp[0], networks[0], small_nfv_flavor, page_2mb), (hosts_no_hp[0], networks[1], old_flavor, None), (hosts_hp[0], networks[0], old_flavor, None)] vms = {} for i, (host, network, flavor, size) in enumerate(vms_params): vm = os_conn.create_server( name='vm{}'.format(i), flavor=flavor.id, nics=[{'net-id': network}], availability_zone='nova:{}'.format(host), security_groups=[security_group.id]) vms.update({vm: size}) for vm, exp_size in vms.items(): assert self.get_instance_page_size(os_conn, vm) == exp_size vms_distribution = [(hosts_hp[0], 1), (hosts_no_hp[0], 0), ] final_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == final_conf[host][page_2mb]['free'] os_conn.wait_servers_ssh_ready(vms.keys()) network_checks.check_vm_connectivity(env, os_conn)
def test_base_vms_connectivity(self, env, os_conn, computes_with_dpdk_hp, networks, keypair, flavors, security_group): """This test checks base connectivity between VMs with DPDK. Please note we're not able to count DPDK huge pages only, they're added to count of 2Mb huge pages. Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Create flavor for huge pages with 512Mb ram, 1 vcpu and 1Gb disk 3. Launch vm1, vm2, vm3 on compute-1 and vm4 on compute-2, vm1 and vm2 in net1, vm3 and vm4 in net2 4. Check vms connectivity 5. Check instance page size 6. Check that neutron port has binding:vif_type = vhostuser 7. Check that count of 2Mb huge pages is expected for each host """ hosts = computes_with_dpdk_hp initial_conf = computes_configuration(env) vms_param = [(hosts[0], networks[0], None), (hosts[0], networks[0], None), (hosts[0], networks[1], None), (hosts[1], networks[1], None)] vms = self.create_vms(os_conn, hosts, networks, flavors[0], keypair, security_group, vms_param) network_checks.check_vm_connectivity(env, os_conn, vm_keypair=keypair) for vm in vms: self.check_vif_type_for_vm(vm, os_conn) act_size = self.get_instance_page_size(os_conn, env) assert act_size == page_2mb, ( "Unexpected package size. Should be {0} instead of {1}".format( page_2mb, act_size)) final_conf = computes_configuration(env) exp_hosts_usage = [(hosts[0], 3), (hosts[1], 1)] for (host, nr_2mb) in exp_hosts_usage: exp_free_2m = (initial_conf[host][page_2mb]['free'] - nr_2mb * flavors[0].ram * 1024 / page_2mb) assert exp_free_2m == final_conf[host][page_2mb]['free']
def test_vms_connectivity_after_live_migration(self, env, os_conn, computes_with_dpdk_hp, flavors, networks, keypair, security_group): """This test checks connectivity between VMs with DPDK after live migration. Please note we're not able to count DPDK huge pages only, they're added to count of 2Mb huge pages. Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Create flavor for huge pages with 512Mb ram, 1 vcpu and 1Gb disk 3. Launch vm1, vm2 on compute-1, vm3 - on compute-2, vm1 in net1, vm2 and vm3 in net2 4. Live migrate vm1 to compute2 5. Check instance page size 6. Check that neutron port has binding:vif_type = vhostuser 7. Check that count of free 2Mb huge pages is expected one for each host 8. Check vms connectivity """ hosts = computes_with_dpdk_hp initial_conf = computes_configuration(env) vms_param = [(hosts[0], networks[0], None), (hosts[0], networks[1], None), (hosts[1], networks[1], None)] vms = self.create_vms(os_conn, hosts, networks, flavors[0], keypair, security_group, vms_param=vms_param) self.live_migrate(os_conn, vms[0], hosts[1]) network_checks.check_vm_connectivity(env, os_conn, vm_keypair=keypair) final_conf = computes_configuration(env) exp_hosts_usage = [(hosts[0], 1), (hosts[1], 2)] for (host, nr_2mb) in exp_hosts_usage: exp_free_2m = (initial_conf[host][page_2mb]['free'] - nr_2mb * flavors[0].ram * 1024 / page_2mb) assert exp_free_2m == final_conf[host][page_2mb]['free']
def test_vms_connectivity_with_hp_and_numa(self, env, os_conn, computes_for_mixed_hp_and_numa, aggregate, networks, security_group, flavors): """This test checks vms connectivity with huge pages and cpu pinning. At least 2 computes with mixed huge pages and cpu pinning are required. 2 numa nodes should be available per compute. 512 x 2Mb and 1 x 1Gb huge pages should be available for each numa node. Specific distribution of cpus per numa nodes is required for each compute: at least 4 cpus for one node and at least 2 cpus for another one. Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Create vm1 in net1 on host1 using flavor m1.small.hpgs_n-2 (hw:mem_page_size=2048 and hw:numa_nodes=2) 3. Create vm2 in net1 on host1 using flavor m1.small.performance-2 (hw:numa_nodes=2, without huge pages) 4. Create vm3 in net2 on host2 using flavor m1.small.hpgs_n-1 (hw:mem_page_size=2048 and hw:numa_nodes=1) 5. Create vm4 in net2 on host2 using flavor m1.small.hpgs (hw:mem_page_size=1048576 without cpu pinning) 6. Create vm5 in net1 on host1 using flavor m1.small.old (without features) 7. Check cpus allocation for all vms 8. Check page size for all vms 9. Check free huge pages when all vms are running 10. Check connectivity between all vms """ hosts = computes_for_mixed_hp_and_numa initial_conf_hp = computes_configuration(env) cpus = get_cpu_distribition_per_numa_node(env) vms = {} vms_params = [(flavors[3], hosts[0], networks[0], 2, page_2mb), (flavors[4], hosts[0], networks[0], 2, None), (flavors[2], hosts[1], networks[1], 1, page_2mb), (flavors[1], hosts[1], networks[1], None, page_1gb), (flavors[0], hosts[0], networks[0], None, None)] for i, (flv, host, net, numa_count, size) in enumerate(vms_params): vm = os_conn.create_server( name='vm{}'.format(i), flavor=flv.id, nics=[{'net-id': net}], availability_zone='nova:{}'.format(host), security_groups=[security_group.id], wait_for_active=False, wait_for_avaliable=False) vms.update({vm: {'numa': numa_count, 'size': size}}) os_conn.wait_servers_active(vms) os_conn.wait_servers_ssh_ready(vms) for vm, param in vms.items(): self.check_instance_page_size(os_conn, vm, param['size']) if param['numa'] is not None: host = getattr(vm, 'OS-EXT-SRV-ATTR:host') self.check_cpu_for_vm(os_conn, vm, param['numa'], cpus[host]) network_checks.check_vm_connectivity(env, os_conn) final_conf = computes_configuration(env) vms_distribution = [(hosts[0], 0, 1), (hosts[1], 1, 1), ] for (host, nr_1gb, nr_2mb) in vms_distribution: exp_free_1g = initial_conf_hp[host][page_1gb]['total'] - nr_1gb * 1 exp_free_2m = ( initial_conf_hp[host][page_2mb]['total'] - nr_2mb * 512) assert exp_free_1g == final_conf[host][page_1gb]['free'] assert exp_free_2m == final_conf[host][page_2mb]['free']
def test_cold_migration_for_huge_pages_2m( self, env, os_conn, networks, small_nfv_flavor, security_group, computes_with_hp_2mb): """This test checks that cold migration executed successfully for instances created on computes with huge pages 2M Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Launch instance vm1 in net1 with m1.small.hpgs 3. Check that vm1 is created on compute with huge pages 4. Launch instance vm2 in net2 with m1.small.hpgs 5. Check that vm2 is created on compute with huge pages 6. Check vms connectivity 7. Cold migrate vm1 and check that vm moved to other compute with huge pages 8. Check vms connectivity """ count_to_allocate_2mb = small_nfv_flavor.ram * 1024 / page_2mb initial_conf = computes_configuration(env) hosts = computes_with_hp_2mb vms = [] vm_hosts = [] for i in range(2): vm = os_conn.create_server( name='vm{}'.format(i), flavor=small_nfv_flavor.id, security_groups=[security_group.id], nics=[{'net-id': networks[i]}]) vms.append(vm) for vm in vms: host = getattr(vm, "OS-EXT-SRV-ATTR:host") assert host in hosts vm_hosts.append(host) vms_distribution = [(hosts[0], vm_hosts.count(hosts[0])), (hosts[1], vm_hosts.count(hosts[1])), ] current_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == current_conf[host][page_2mb]['free'] for vm in vms: self.check_instance_page_size(os_conn, vm, size=page_2mb) network_checks.check_vm_connectivity(env, os_conn) vm_0_new = self.migrate(os_conn, vms[0]) vm_host_0_new = getattr(vm_0_new, "OS-EXT-SRV-ATTR:host") assert vm_host_0_new in hosts assert vm_host_0_new != vm_hosts.pop(0) vm_hosts.append(vm_host_0_new) vms_distribution = [(hosts[0], vm_hosts.count(hosts[0])), (hosts[1], vm_hosts.count(hosts[1])), ] final_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == final_conf[host][page_2mb]['free'] self.check_instance_page_size(os_conn, vm_0_new, size=page_2mb) network_checks.check_vm_connectivity(env, os_conn)
def test_evacuation_for_huge_pages_2m( self, env, os_conn, devops_env, networks, small_nfv_flavor, security_group, computes_with_hp_2mb): """This test checks that evacuation executed successfully for instances created on computes with huge pages 2M Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Launch instance vm1 in net1 with m1.small.hpgs on compute-1 3. Launch instance vm2 in net2 with m1.small.hpgs on compute-2 4. Check vms connectivity 5. Kill the compute-1 6. Evacuate vm1 from compute-1 7. Check vms connectivity 8. Make compute-1 alive 9. Check that resources for vm1 were deleted from compute-1 """ count_to_allocate_2mb = small_nfv_flavor.ram * 1024 / page_2mb initial_conf = computes_configuration(env) hosts = computes_with_hp_2mb vms = [] for i in range(2): vm = os_conn.create_server( name='vm{}'.format(i), flavor=small_nfv_flavor.id, availability_zone='nova:{}'.format(hosts[i]), security_groups=[security_group.id], nics=[{'net-id': networks[i]}]) vms.append(vm) vms_distribution = [(hosts[0], 1), (hosts[1], 1)] current_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) act_free_2m = current_conf[host][page_2mb]['free'] assert exp_free_2m == act_free_2m, ( "Unexpected count of free 2Mb huge pages: {0} instead of {1} " "for host {2}".format(act_free_2m, exp_free_2m, host)) for vm in vms: self.check_instance_page_size(os_conn, vm, size=page_2mb) network_checks.check_vm_connectivity(env, os_conn) self.compute_change_state(os_conn, devops_env, hosts[0], state='down') vm_0_new = self.evacuate(os_conn, devops_env, vms[0]) assert hosts[1] == getattr(vm_0_new, "OS-EXT-SRV-ATTR:host"), ( "Wrong host found for {0} after evacuation. Expected host is {1}". format(vm_0_new, hosts[1])) network_checks.check_vm_connectivity(env, os_conn) for vm in vms: self.check_instance_page_size(os_conn, vm, size=page_2mb) self.compute_change_state(os_conn, devops_env, hosts[0], state='up') vms_distribution = [(hosts[0], 0), (hosts[1], 2)] current_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) act_free_2m = current_conf[host][page_2mb]['free'] assert exp_free_2m == act_free_2m, ( "Unexpected count of free 2Mb huge pages: {0} instead of {1} " "for host {2}".format(act_free_2m, exp_free_2m, host))
def test_lm_ceph_for_huge_pages(self, env, os_conn, nova_ceph, computes_with_hp_2mb, networks, volume, keypair, small_nfv_flavor, security_group): """This test checks that live migration executed successfully for instances created on computes with ceph and huge pages Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Launch instance vm1 with volume vol1 on compute-1 in net1 with m1.small.hpgs 3. Launch instance vm2 on compute-2 in net2 with m1.small.hpgs 4. Make volume from vm2 volume_vm 5. Launch instance vm3 on compute-2 in net2 with volume_vm with m1.small.hpgs 6. Check vms connectivity 7. Live migrate vm1 on compute-2 and check that vm moved to compute-2 with Active state 8. Check vms connectivity 9. Live migrate vm2 with block-migrate parameter on compute-1 and check that vm moved to compute-2 with Active state 10. Check vms connectivity 11. Live migrate vm3 on compute-1 and check that vm moved to compute-1 with Active state 12. Check vms connectivity """ count_to_allocate_2mb = small_nfv_flavor.ram * 1024 / page_2mb initial_conf = computes_configuration(env) hosts = computes_with_hp_2mb vm_0 = os_conn.create_server( name='vm1', flavor=small_nfv_flavor.id, key_name=keypair.name, nics=[{'net-id': networks[0]}], availability_zone='nova:{}'.format(hosts[0]), security_groups=[security_group.id], block_device_mapping={'vda': volume.id}) vm_1 = os_conn.create_server( name='vm2', flavor=small_nfv_flavor.id, key_name=keypair.name, availability_zone='nova:{}'.format(hosts[1]), security_groups=[security_group.id], nics=[{'net-id': networks[1]}]) volume_vm = self.create_volume_from_vm(os_conn, vm_1) vm_2 = os_conn.create_server( name='vm3', flavor=small_nfv_flavor.id, key_name=keypair.name, nics=[{'net-id': networks[1]}], availability_zone='nova:{}'.format(hosts[1]), security_groups=[security_group.id], block_device_mapping={'vda': volume_vm}) vms = [vm_0, vm_1, vm_2] vms_distribution = [(hosts[0], 1), (hosts[1], 2)] current_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == current_conf[host][page_2mb]['free'] for vm in vms: self.check_instance_page_size(os_conn, vm, size=page_2mb) network_checks.check_vm_connectivity(env, os_conn) self.live_migrate(os_conn, vms[0], hosts[1], block_migration=False) vms_distribution = [(hosts[0], 0), (hosts[1], 3)] current_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == current_conf[host][page_2mb]['free'] network_checks.check_vm_connectivity(env, os_conn) self.live_migrate(os_conn, vms[1], hosts[0]) vms_distribution = [(hosts[0], 1), (hosts[1], 2)] current_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == current_conf[host][page_2mb]['free'] network_checks.check_vm_connectivity(env, os_conn) self.live_migrate(os_conn, vms[2], hosts[0], block_migration=False) vms_distribution = [(hosts[0], 2), (hosts[1], 1)] current_conf = computes_configuration(env) for (host, nr_2mb) in vms_distribution: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == current_conf[host][page_2mb]['free'] for vm in vms: self.check_instance_page_size(os_conn, vm, size=page_2mb) network_checks.check_vm_connectivity(env, os_conn)
def test_lm_cinder_for_cpu_pinning_and_hp(self, env, os_conn, keypair, computes_with_mixed_hp, volume, networks, aggregate, flavors, security_group, ubuntu_image_id): """This test checks that live migration executed successfully for instances created on computes with cinder and 2 Numa nodes and mixed 2Mb and 1Gb huge pages Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Launch instance vm1 with volume vol1 on compute-1 in net1 with flavor m1.m1.small.hpgs_numa 3. Launch instance vm2 on compute-2 in net2 with with flavor m1.small.performance_1 4. Live migrate vm1 with block-migrate parameter on compute-2 and check that vm moved to compute-2 with Active state 5. Run CPU load on vm2 8. Live migrate vm2 on compute-1 and check that vm moved to compute-2 with Active state 9. Check vms connectivity 10. Check size of huge pages for each vm 11. Check vcpus allocation for each vm 12. Check count of free huge pages is correct for each host 13. Delete all vms 14. Repeat actions for flavor m1.small.hpgs_numa-2 """ hosts = list(set(computes_with_mixed_hp) & set(aggregate.hosts)) if len(hosts) < 2: pytest.skip("At least 2 hosts with mixed features are required.") cpus = get_cpu_distribition_per_numa_node(env) initial_conf_hp = computes_configuration(env) flavors_param = [(1, page_2mb, flavors[0]), (2, page_1gb, flavors[1])] for numa, page_size, flavor in flavors_param: vm1 = os_conn.create_server( name='vm1', flavor=flavor.id, nics=[{'net-id': networks[0]}], key_name=keypair.name, availability_zone='nova:{}'.format(hosts[0]), security_groups=[security_group.id], block_device_mapping={'vda': volume.id}, wait_for_active=False, wait_for_avaliable=False) vm2 = os_conn.create_server( name='vm2', image_id=ubuntu_image_id, flavor=flavor.id, key_name=keypair.name, userdata=userdata, availability_zone='nova:{}'.format(hosts[1]), security_groups=[security_group.id], nics=[{'net-id': networks[1]}], wait_for_active=False, wait_for_avaliable=False) os_conn.wait_servers_active([vm1, vm2]) os_conn.wait_servers_ssh_ready([vm1, vm2]) os_conn.wait_marker_in_servers_log([vm2], marker) self.live_migrate(os_conn, vm1, hosts[1], block_migration=False) check_vm_connectivity_cirros_ubuntu(env, os_conn, keypair, cirros=vm1, ubuntu=vm2) self.cpu_load(env, os_conn, vm2, vm_keypair=keypair) self.live_migrate(os_conn, vm2, hosts[0]) check_vm_connectivity_cirros_ubuntu(env, os_conn, keypair, cirros=vm1, ubuntu=vm2) self.cpu_load(env, os_conn, vm2, vm_keypair=keypair, action='stop') expected_hosts = [(hosts[1], vm1), (hosts[0], vm2)] for host, vm in expected_hosts: self.check_instance_page_size(os_conn, vm, page_size) self.check_cpu_for_vm(os_conn, vm, numa, cpus[host]) final_conf_hp = computes_configuration(env) for host in hosts: exp_free = (initial_conf_hp[host][page_size]['total'] - 1 * (flavor.ram * 1024 / page_size)) act_free = final_conf_hp[host][page_size]['free'] assert exp_free == act_free, ( 'Unexpected count of {0} huge pages are free: ' '{1} instead of {2}'.format(page_size, act_free, exp_free)) self.delete_servers(os_conn)
def test_lm_ceph_for_cpu_pinning_and_hp(self, env, os_conn, nova_ceph, computes_with_mixed_hp, keypair, networks, aggregate, flavors, security_group, volume): """This test checks that live migration executed successfully for instances created on computes with ceph and 2 Numa nodes & mixed 2Mb and 1Gb huge page. Required configuration: at least 2 hosts with mixed features, max host's usage is 3 vms Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Launch instance vm1 with volume vol1 on compute-1 in net1 with flavor m1.small.hpgs_numa 3. Launch instance vm2 on compute-2 in net2 with flavor m1.small.hpgs_numa 4. Make volume from vm2 volume_vm2 5. Launch instance vm3 on compute-2 in net2 with volume_vm2 with flavor m1.small.hpgs_numa 6. Live migrate vm1 on compute-2 and check that vm moved to compute-2 with Active state 7. Live migrate vm2 with block-migrate parameter on compute-1 and check that vm moved to compute-1 with Active state 8. Live migrate vm3 on compute-1 and check that vm moved to compute-1 with Active state 9. Check vms connectivity 10. Check page size for all instances 11. Check allocated vcpus for all instances 12. Check count of free huge pages 13. Remove all vms and repeat actions for m1.small.hpgs_numa-2 """ hosts_to_use = list(set(computes_with_mixed_hp) & set(aggregate.hosts)) if len(hosts_to_use) < 2: pytest.skip("At least 2 hosts with mixed features are required.") cpus = get_cpu_distribition_per_numa_node(env) initial_conf_hp = computes_configuration(env) flavors_param = [(1, page_2mb, flavors[0]), (2, page_1gb, flavors[1])] for numa, page_size, flavor in flavors_param: vm1 = os_conn.create_server( name='vm1', flavor=flavor.id, nics=[{'net-id': networks[0]}], key_name=keypair.name, availability_zone='nova:{}'.format(hosts_to_use[0]), security_groups=[security_group.id], block_device_mapping={'vda': volume.id}) vm2 = os_conn.create_server( name='vm2', flavor=flavor.id, nics=[{'net-id': networks[1]}], key_name=keypair.name, availability_zone='nova:{}'.format(hosts_to_use[1]), security_groups=[security_group.id]) volume_vm2 = self.create_volume_from_vm(os_conn, vm2) vm3 = os_conn.create_server( name='vm3', flavor=flavor.id, nics=[{'net-id': networks[1]}], key_name=keypair.name, availability_zone='nova:{}'.format(hosts_to_use[1]), security_groups=[security_group.id], block_device_mapping={'vda': volume_vm2}) self.live_migrate( os_conn, vm1, hosts_to_use[1], block_migration=False) network_checks.check_vm_connectivity(env, os_conn) self.live_migrate(os_conn, vm2, hosts_to_use[0]) network_checks.check_vm_connectivity(env, os_conn) self.live_migrate( os_conn, vm3, hosts_to_use[0], block_migration=False) network_checks.check_vm_connectivity(env, os_conn) expected_hosts = [(hosts_to_use[1], vm1), (hosts_to_use[0], vm2), (hosts_to_use[0], vm3)] for host, vm in expected_hosts: self.check_instance_page_size(os_conn, vm, page_size) self.check_cpu_for_vm(os_conn, vm, numa, cpus[host]) expected_hosts_usage = [(hosts_to_use[0], 2), (hosts_to_use[1], 1)] final_conf_hp = computes_configuration(env) for host, nr in expected_hosts_usage: exp_free = (initial_conf_hp[host][page_size]['total'] - nr * (flavor.ram * 1024 / page_size)) act_free = final_conf_hp[host][page_size]['free'] assert exp_free == act_free, ( 'Unexpected count of {0} huge pages are free:' '{1} instead of {2}'.format(page_size, act_free, exp_free)) self.delete_servers(os_conn)
def test_lm_cinder_lvm_for_huge_pages(self, os_conn, env, computes_with_hp_2mb, networks, volume, small_nfv_flavor, keypair, security_group, ubuntu_image_id): """This test checks that live migration executed successfully for instances created on computes with cinder lvm and huge pages Steps: 1. Create net1 with subnet, net2 with subnet and router1 with interfaces to both nets 2. Launch instance vm1 with volume vol1 on compute-1 in net1 with m1.small.hpgs 3. Launch instance vm2 on compute-2 in net2 with m1.small.hpgs and ubuntu image 4. Check vms connectivity 5. Live migrate vm1 on compute-2 and check that vm moved to compute-2 with Active state 6. Check vms connectivity 7. Live migrate vm2 with block-migrate parameter on compute-1 and check that vm moved to compute-2 with Active state 8. Check vms connectivity 9. Run CPU load on vm2 10. Live migrate vm2 on compute-2 with block-migrate parameter and check that vm moved to compute-2 with Active state 11. Check vms connectivity """ count_to_allocate_2mb = small_nfv_flavor.ram * 1024 / page_2mb initial_conf = computes_configuration(env) hosts = computes_with_hp_2mb vm_0 = os_conn.create_server( name='vm1', flavor=small_nfv_flavor.id, nics=[{'net-id': networks[0]}], key_name=keypair.name, availability_zone='nova:{}'.format(hosts[0]), security_groups=[security_group.id], block_device_mapping={'vda': volume.id}) vm_1 = os_conn.create_server( name='vm2', image_id=ubuntu_image_id, flavor=small_nfv_flavor.id, key_name=keypair.name, userdata=userdata, availability_zone='nova:{}'.format(hosts[1]), security_groups=[security_group.id], nics=[{'net-id': networks[1]}]) vms = [vm_0, vm_1] os_conn.wait_marker_in_servers_log([vm_1], marker) expected_hosts_usage = [(hosts[0], 1), (hosts[1], 1)] current_conf = computes_configuration(env) for (host, nr_2mb) in expected_hosts_usage: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == current_conf[host][page_2mb]['free'] for vm in vms: self.check_instance_page_size(os_conn, vm, size=page_2mb) check_vm_connectivity_cirros_ubuntu( env, os_conn, keypair, cirros=vms[0], ubuntu=vms[1]) self.live_migrate(os_conn, vms[0], hosts[1], block_migration=False) expected_hosts_usage = [(hosts[0], 0), (hosts[1], 2)] current_conf = computes_configuration(env) for (host, nr_2mb) in expected_hosts_usage: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == current_conf[host][page_2mb]['free'] self.live_migrate(os_conn, vms[1], hosts[0]) expected_hosts_usage = [(hosts[0], 1), (hosts[1], 1)] current_conf = computes_configuration(env) for (host, nr_2mb) in expected_hosts_usage: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == current_conf[host][page_2mb]['free'] check_vm_connectivity_cirros_ubuntu( env, os_conn, keypair, cirros=vms[0], ubuntu=vms[1]) self.cpu_load(env, os_conn, vms[1], vm_keypair=keypair) self.live_migrate(os_conn, vms[1], hosts[1]) expected_hosts_usage = [(hosts[0], 0), (hosts[1], 2)] current_conf = computes_configuration(env) for (host, nr_2mb) in expected_hosts_usage: exp_free_2m = (initial_conf[host][page_2mb]['total'] - nr_2mb * count_to_allocate_2mb) assert exp_free_2m == current_conf[host][page_2mb]['free'] for vm in vms: self.check_instance_page_size(os_conn, vm, size=page_2mb) check_vm_connectivity_cirros_ubuntu( env, os_conn, keypair, cirros=vms[0], ubuntu=vms[1]) self.cpu_load(env, os_conn, vms[1], vm_keypair=keypair, action='stop')