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')