def run(self, result): """execute the benchmark""" if not self.setup_done: self.setup() network_id = op_utils.get_network_id(self.neutron_client, self.external_network) image_id = op_utils.get_image_id(self.glance_client, self.image) flavor_id = op_utils.get_flavor_id(self.nova_client, "yardstick-pinned-flavor") # Create multiple VMs to test CPU ran out LOG.debug("Creating server instance: test_server") json_body = { 'flavor': flavor_id, 'image': image_id, 'nics': [{ "net-id": network_id }], 'name': "test_server" } self.instance = op_utils.create_instance(json_body) status = op_utils.check_status("ERROR", "test_server", 10, 5) if status: LOG.info("Create test_server failed: lack of resources.") else: LOG.info("Create test_server successful.") op_utils.delete_instance(self.nova_client, self.instance.id)
def test_get_network_id_no_network(self): mock_shade_client = mock.Mock() mock_shade_client.list_networks = mock.Mock() mock_shade_client.list_networks.return_value = None output = openstack_utils.get_network_id(mock_shade_client, 'network_name') self.assertIsNone(output)
def test_get_network_id(self): _uuid = uuidutils.generate_uuid() mock_shade_client = mock.Mock() mock_shade_client.list_networks = mock.Mock() mock_shade_client.list_networks.return_value = [{'id': _uuid}] output = openstack_utils.get_network_id(mock_shade_client, 'network_name') self.assertEqual(_uuid, output)
def run(self, result): """execute the benchmark""" network_id = op_utils.get_network_id(self.neutron_client, self.external_network) image_id = op_utils.get_image_id(self.glance_client, self.image) LOG.debug("Creating NUMA-pinned-instance-1...") self.instance = op_utils.create_instance_and_wait_for_active( "yardstick-pinned-flavor", image_id, network_id, instance_name="NUMA-pinned-instance-1") cmd = "virsh dumpxml %s" % self.instance.id LOG.debug("Dumping VM configrations: %s", cmd) status, stdout, stderr = self.client.execute(cmd) if status: raise RuntimeError(stderr) pinning = [] root = ET.fromstring(stdout) for memnode in root.iter('memnode'): pinning.append(memnode.attrib) result.update({"pinning": pinning}) # Create multiple VMs to test CPU ran out LOG.debug("Creating NUMA-pinned-instance-2...") self.instance_2 = op_utils.create_instance( "yardstick-pinned-flavor", image_id, network_id, instance_name="NUMA-pinned-instance-2") status = op_utils.check_status("ERROR", "NUMA-pinned-instance-2", 10, 5) if status: print("Create NUMA-pinned-instance-2 failed: lack of resources.") if len(pinning) == 1 and status: result.update({"Test": 1}) print("Test passed!") else: result.update({"Test": 0}) print("Test failed!") op_utils.delete_instance(self.nova_client, self.instance.id) op_utils.delete_instance(self.nova_client, self.instance_2.id)
def run(self, result): """execute the test""" if not self.setup_done: self.setup() net_id = op_utils.get_network_id(self.neutron_client, self.ext_net) status = op_utils.add_gateway_router(self.neutron_client, ext_net_id=net_id, router_id=self.router_id) if status: result.update({"router_add_interface": 1}) LOG.info("Set router gateway successful!") else: result.update({"subnet_create": 0}) LOG.error("Set router gateway failed!")
def run(self, result): """execute the test""" if not self.setup_done: self.setup() id = op_utils.get_network_id(self.neutron_client, self.network_name) keys = self.scenario_cfg.get('output', '').split() if id: LOG.info("Get network ID successful!") values = [0, id] else: LOG.info("Get network ID failed!") values = [1] return self._push_to_outputs(keys, values)
def run(self, *args): """execute the test""" if not self.setup_done: self.setup() net_id = op_utils.get_network_id(self.shade_client, self.ext_net_id) floating_info = op_utils.create_floating_ip(self.neutron_client, extnet_id=net_id) if not floating_info: LOG.error("Creating floating ip failed!") return LOG.info("Creating floating ip successful!") keys = self.scenario_cfg.get('output', '').split() values = [floating_info["fip_id"], floating_info["fip_addr"]] return self._push_to_outputs(keys, values)
def run(self, result): """execute the benchmark""" network_id = op_utils.get_network_id(self.neutron_client, self.external_network) image_id = op_utils.get_image_id(self.glance_client, self.image) LOG.debug("Creating Virtaul machine: cpu-pinned-instance") self.instance = op_utils.create_instance_and_wait_for_active( "yardstick-pinned-flavor", image_id, network_id, instance_name="cpu-pinned-instance") cmd = "virsh dumpxml %s" % self.instance.id LOG.debug("Dumping VM configrations: %s", cmd) status, stdout, stderr = self.client.execute(cmd) if status: raise RuntimeError(stderr) pinning = [] test_status = 1 root = ET.fromstring(stdout) for vcpupin in root.iter('vcpupin'): pinning.append(vcpupin.attrib) for item in pinning: if str(item["cpuset"]) not in self.cpu_set: test_status = 0 print("Test failed: VM CPU not pinned correctly!") break print("Test passed: VM CPU pinned correctly!") result.update({"Test": test_status}) result.update({"pinning": pinning}) op_utils.delete_instance(self.nova_client, self.instance.id)
def run(self, result): """execute the test""" if not self.setup_done: self.setup() network_id = op_utils.get_network_id(self.neutron_client, self.external_network) cmd = "openstack server create %s --nic net-id=%s" % (self.server_name, network_id) args_payload_list = ["flavor", "volume"] for argument in args_payload_list: try: cmd += " --" + argument + " " + self.options[argument] except KeyError: pass try: p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, cwd='/home/opnfv/repos/yardstick') print(p.communicate()[0]) LOG.info("Create server from volume successful!") except Exception: LOG.info("Create server from volume failed!") raise RuntimeError("Create server from volume failed!") op_utils.check_status("ACTIVE", self.server_name, 10, 5) server = op_utils.get_instance_by_name(self.nova_client, self.server_name) values = [server.id] keys = self.scenario_cfg.get('output', '').split() return self._push_to_outputs(keys, values)
def run(self, result): """execute the benchmark""" # flavor1 network_id = op_utils.get_network_id(self.neutron_client, self.external_network) image_id = op_utils.get_image_id(self.glance_client, self.image) free_mem_before = self._check_compute_node_free_hugepage( self.compute_node_name[0]) self.instance = op_utils.create_instance_and_wait_for_active( self.flavor1, image_id, network_id, instance_name="hugepages-2M-VM") free_mem_after = self._check_compute_node_free_hugepage( self.compute_node_name[0]) LOG.debug("free_mem_before: %s, after: %s", free_mem_before, free_mem_after) op_utils.delete_instance(self.nova_client, self.instance.id) result.update({ "hugepagesz-2M": self._pof(free_mem_before == free_mem_after + 512) }) result.update({"2M-free-mem_before": free_mem_before}) result.update({"2M-free-mem_after": free_mem_after}) # flavor2 network_id = op_utils.get_network_id(self.neutron_client, self.external_network) LOG.debug("self.external_network: %s, self.image: %s, flavor:%s", self.external_network, self.image, self.flavor1) image_id = op_utils.get_image_id(self.glance_client, self.image) free_mem_before = self._check_compute_node_free_hugepage( self.compute_node_name[1]) # config hugepages to be 1G and reboot status, stdout, stderr = self.client.execute( "sudo bash hugepages_config.sh") # wait to reeboot LOG.info("node restarting... wait 120s") time.sleep(120) LOG.info("node restarting... wait ends") self._ssh_host(self.compute_node_name[1]) self.instance = op_utils.create_instance_and_wait_for_active( self.flavor2, image_id, network_id, instance_name="hugepages-1G-VM") free_mem_after = self._check_compute_node_free_hugepage( self.compute_node_name[1]) LOG.debug("free_mem_before: %s, after: %s", free_mem_before, free_mem_after) op_utils.delete_instance(self.nova_client, self.instance.id) result.update({ "hugepagesz-1G": self._pof(free_mem_before == free_mem_after + 1) }) result.update({"1G-free-mem_before": free_mem_before}) result.update({"1G-free-mem_after": free_mem_after})