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