{
- "id": 6,
+ "id": 42,
"title": "KVMFORNFV-Cyclictest",
"tags": [
"kvmfornfv-cyclictest"
}
],
"time": {
- "from": "now-2d",
- "to": "2016-10-22T04:02:56.969Z"
+ "from": "now-7d",
+ "to": "now"
},
"timepicker": {
"refresh_intervals": [
"annotations": {
"list": []
},
- "refresh": false,
+ "refresh": "1d",
"schemaVersion": 12,
"version": 1,
"links": [],
scripts=['tools/yardstick-img-modify',
'tools/yardstick-img-lxd-modify',
'tools/yardstick-img-dpdk-modify'
- ]
+ ]
)
file_name: opnfv_yardstick_tc012.yaml
-
file_name: opnfv_yardstick_tc014.yaml
--
- file_name: opnfv_yardstick_tc027.yaml
- constraint:
- installer: compass,fuel
- pod: huawei-pod1,lf-pod2,ericsson-pod3,ericsson-pod4
- task_args:
- huawei-pod1: '{"pod_info": "etc/yardstick/nodes/compass_sclab_physical/pod.yaml"}'
- lf-pod2: '{"pod_info": "etc/yardstick/nodes/fuel_baremetal/pod.yaml", "openrc":"/root/openrc", "external_network":"admin_floating_net"}'
- ericsson-pod3: '{"pod_info": "etc/yardstick/nodes/fuel_baremetal/pod.yaml", "openrc":"/root/openrc", "external_network":"admin_floating_net"}'
- ericsson-pod4: '{"pod_info": "etc/yardstick/nodes/fuel_baremetal/pod.yaml", "openrc":"/root/openrc", "external_network":"admin_floating_net"}'
-
file_name: opnfv_yardstick_tc037.yaml
-
task_args:
huawei-pod1: '{"pod_info": "etc/yardstick/nodes/compass_sclab_physical/pod.yaml",
"host": "node1.LF"}'
+-
+ file_name: opnfv_yardstick_tc027.yaml
+ constraint:
+ installer: compass,fuel
+ pod: huawei-pod1,lf-pod2,ericsson-pod3,ericsson-pod4
+ task_args:
+ huawei-pod1: '{"pod_info": "etc/yardstick/nodes/compass_sclab_physical/pod.yaml"}'
+ lf-pod2: '{"pod_info": "etc/yardstick/nodes/fuel_baremetal/pod.yaml", "openrc":"/root/openrc", "external_network":"admin_floating_net"}'
+ ericsson-pod3: '{"pod_info": "etc/yardstick/nodes/fuel_baremetal/pod.yaml", "openrc":"/root/openrc", "external_network":"admin_floating_net"}'
+ ericsson-pod4: '{"pod_info": "etc/yardstick/nodes/fuel_baremetal/pod.yaml", "openrc":"/root/openrc", "external_network":"admin_floating_net"}'
-#!/usr/bin/env python\r
-\r
-##############################################################################\r
-# Copyright (c) 2016 Huawei Technologies Co.,Ltd and others.\r
-#\r
-# All rights reserved. This program and the accompanying materials\r
-# are made available under the terms of the Apache License, Version 2.0\r
-# which accompanies this distribution, and is available at\r
-# http://www.apache.org/licenses/LICENSE-2.0\r
-##############################################################################\r
-\r
-# Unittest for yardstick.benchmark.scenarios.networking.networkcapacity.NetworkCapacity\r
-\r
-import mock\r
-import unittest\r
-import os\r
-import json\r
-\r
-from yardstick.benchmark.scenarios.networking import networkcapacity\r
-\r
-SAMPLE_OUTPUT = '{"Number of connections":"308","Number of frames received": "166503"}'\r
-\r
-@mock.patch('yardstick.benchmark.scenarios.networking.networkcapacity.ssh')\r
-class NetworkCapacityTestCase(unittest.TestCase):\r
-\r
- def setUp(self):\r
- self.ctx = {\r
- 'host': {\r
- 'ip': '172.16.0.137',\r
- 'user': 'cirros',\r
- 'password': "root"\r
- },\r
- }\r
-\r
- self.result = {}\r
-\r
- def test_capacity_successful_setup(self, mock_ssh):\r
- c = networkcapacity.NetworkCapacity({}, self.ctx)\r
- mock_ssh.SSH().execute.return_value = (0, '', '')\r
- c.setup()\r
- self.assertIsNotNone(c.client)\r
- self.assertTrue(c.setup_done)\r
-\r
- def test_capacity_successful(self, mock_ssh):\r
- c = networkcapacity.NetworkCapacity({}, self.ctx)\r
-\r
- mock_ssh.SSH().execute.return_value = (0, SAMPLE_OUTPUT, '')\r
- c.run(self.result)\r
- expected_result = json.loads(SAMPLE_OUTPUT)\r
- self.assertEqual(self.result, expected_result)\r
-\r
- def test_capacity_unsuccessful_script_error(self, mock_ssh):\r
- c = networkcapacity.NetworkCapacity({}, self.ctx)\r
-\r
- mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')\r
- self.assertRaises(RuntimeError, c.run, self.result)\r
+#!/usr/bin/env python
+
+##############################################################################
+# Copyright (c) 2016 Huawei Technologies Co.,Ltd and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+# Unittest for yardstick.benchmark.scenarios.networking.networkcapacity.NetworkCapacity
+
+import mock
+import unittest
+import os
+import json
+
+from yardstick.benchmark.scenarios.networking import networkcapacity
+
+SAMPLE_OUTPUT = '{"Number of connections":"308","Number of frames received": "166503"}'
+
+@mock.patch('yardstick.benchmark.scenarios.networking.networkcapacity.ssh')
+class NetworkCapacityTestCase(unittest.TestCase):
+
+ def setUp(self):
+ self.ctx = {
+ 'host': {
+ 'ip': '172.16.0.137',
+ 'user': 'cirros',
+ 'password': "root"
+ },
+ }
+
+ self.result = {}
+
+ def test_capacity_successful_setup(self, mock_ssh):
+ c = networkcapacity.NetworkCapacity({}, self.ctx)
+ mock_ssh.SSH().execute.return_value = (0, '', '')
+ c.setup()
+ self.assertIsNotNone(c.client)
+ self.assertTrue(c.setup_done)
+
+ def test_capacity_successful(self, mock_ssh):
+ c = networkcapacity.NetworkCapacity({}, self.ctx)
+
+ mock_ssh.SSH().execute.return_value = (0, SAMPLE_OUTPUT, '')
+ c.run(self.result)
+ expected_result = json.loads(SAMPLE_OUTPUT)
+ self.assertEqual(self.result, expected_result)
+
+ def test_capacity_unsuccessful_script_error(self, mock_ssh):
+ c = networkcapacity.NetworkCapacity({}, self.ctx)
+
+ mock_ssh.SSH().execute.return_value = (1, '', 'FOOBAR')
+ self.assertRaises(RuntimeError, c.run, self.result)
'host1': {
'ip': '172.16.0.137',
'user': 'cirros',
+ 'role': "Controller",
'key_filename': "mykey.key",
'password': "root"
},
+ 'host2': {
+ "ip": "172.16.0.138",
+ "key_filename": "/root/.ssh/id_rsa",
+ "role": "Compute",
+ "name": "node3.IPV6",
+ "user": "root"
+ },
}
}
+ def test_get_controller_node(self):
+ args = {
+ 'options': {'host': 'host1','packetsize': 200, 'ping_count': 5},
+ 'sla': {'max_rtt': 50}
+ }
+ p = ping6.Ping6(args, self.ctx)
+ controller_node = p._get_controller_node(['host1','host2'])
+ self.assertEqual(controller_node, 'host1')
+
@mock.patch('yardstick.benchmark.scenarios.networking.ping6.ssh')
def test_ping_successful_setup(self, mock_ssh):
args = {
--- /dev/null
+releng:
+ dir: /home/opnfv/repos/releng
mock_importutils.import_module.assert_called_with('bar.baz')
+class GetParaFromYaml(unittest.TestCase):
+
+ def test_get_para_from_yaml_file_not_exist(self):
+ file_path = '/etc/yardstick/hello.yaml'
+ args = 'hello.world'
+ para = utils.get_para_from_yaml(file_path, args)
+ self.assertIsNone(para)
+
+ def test_get_para_from_yaml_para_not_found(self):
+ file_path = 'config_sample.yaml'
+ file_path = self._get_file_abspath(file_path)
+ args = 'releng.file'
+ self.assertIsNone(utils.get_para_from_yaml(file_path, args))
+
+ def test_get_para_from_yaml_para_exists(self):
+ file_path = 'config_sample.yaml'
+ file_path = self._get_file_abspath(file_path)
+ args = 'releng.dir'
+ para = '/home/opnfv/repos/releng'
+ self.assertEqual(para, utils.get_para_from_yaml(file_path, args))
+
+ def _get_file_abspath(self, filename):
+ curr_path = os.path.dirname(os.path.abspath(__file__))
+ file_path = os.path.join(curr_path, filename)
+ return file_path
+
+
def main():
unittest.main()
class BaremetalAttacker(BaseAttacker):
-
__attacker_type__ = 'bare-metal-down'
def setup(self):
host = self._context.get(self._config['host'], None)
ip = host.get("ip", None)
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename)
+ self.connection = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
self.host_ip = ip
host = self._context.get(jump_host_name, None)
ip = host.get("ip", None)
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
pwd = host.get("pwd", None)
LOG.debug("jump_host ip:%s user:%s" % (ip, user))
- self.jump_connection = ssh.SSH(user, ip, password=pwd)
+ self.jump_connection = ssh.SSH(user, ip, password=pwd,
+ port=ssh_port)
self.jump_connection.wait(timeout=600)
LOG.debug("ssh jump host success!")
host = self._context.get(self._config['host'], None)
ip = host.get("ip", None)
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename)
+ self.connection = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
host = self._context.get(self._config['host'], None)
ip = host.get("ip", None)
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename)
+ self.connection = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
host = self._context[node_name]
ip = host.get("ip", None)
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename)
+ self.connection = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
host = self._context[self._config["host"]]
ip = host.get("ip", None)
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
self.key = self._config["key"]
self.monitor_key = self._config["monitor_key"]
self.monitor_key)
self.monitor_script = self.get_script_fullpath(
self.monitor_cfg['monitor_script'])
- self.connection = ssh.SSH(user, ip, key_filename=key_filename)
+ self.connection = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
host = self._context[self._config["host"]]
ip = host.get("ip", None)
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename)
+ self.connection = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
self.check_script = self.get_script_fullpath(
host = self._context.get(self._config['host'], None)
ip = host.get("ip", None)
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename)
+ self.connection = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
class GeneralResultChecker(BaseResultChecker):
-
__result_checker__type__ = "general-result-checker"
def setup(self):
host = self._context.get(self._config['host'], None)
ip = host.get("ip", None)
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
- self.connection = ssh.SSH(user, ip, key_filename=key_filename)
+ self.connection = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.connection.wait(timeout=600)
LOG.debug("ssh host success!")
host = self.context_cfg['host']
user = host.get('user', 'ubuntu')
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
ip = host.get('ip', None)
key_filename = host.get('key_filename', '~/.ssh/id_rsa')
LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename)
+ self.client = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.client.wait(timeout=600)
# copy scripts to host
nodes = self.context_cfg['nodes']
node = nodes.get('host', None)
host_user = node.get('user', 'ubuntu')
+ ssh_port = node.get('ssh_port', ssh.DEFAULT_PORT)
host_ip = node.get('ip', None)
host_pwd = node.get('password', 'root')
LOG.debug("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd)
+ self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
+ port=ssh_port)
self.client.wait(timeout=600)
# copy script to host
host = self.context_cfg['host']
user = host.get('user', 'ubuntu')
ip = host.get('ip', None)
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
key_filename = host.get('key_filename', '~/.ssh/id_rsa')
LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename)
+ self.client = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.client.wait(timeout=600)
# Check if mpstat prog is installed
host = self.context_cfg["host"]
user = host.get("user", "root")
ip = host.get("ip", None)
+ ssh_port = host.get("ssh_port", 5555)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
LOG.debug("user:%s, host:%s", user, ip)
- self.guest = ssh.SSH(user, ip, port=5555, key_filename=key_filename)
+ self.guest = ssh.SSH(user, ip, port=ssh_port,
+ key_filename=key_filename)
self.guest.wait(timeout=600)
def _run_setup_cmd(self, client, cmd):
Lmbench.LATENCY_CACHE_SCRIPT)
host = self.context_cfg["host"]
user = host.get("user", "ubuntu")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
ip = host.get("ip", None)
key_filename = host.get('key_filename', "~/.ssh/id_rsa")
LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename)
+ self.client = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.client.wait(timeout=600)
# copy scripts to host
"""Scenario setup."""
host = self.context_cfg['host']
user = host.get('user', 'ubuntu')
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
ip = host.get('ip', None)
key_filename = host.get('key_filename', '~/.ssh/id_rsa')
LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename)
+ self.client = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.client.wait(timeout=600)
self.setup_done = True
'yardstick.benchmark.scenarios.compute', Perf.TARGET_SCRIPT)
host = self.context_cfg['host']
user = host.get('user', 'ubuntu')
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
ip = host.get('ip', None)
key_filename = host.get('key_filename', '~/.ssh/id_rsa')
LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename)
+ self.client = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.client.wait(timeout=600)
# copy script to host
nodes = self.context_cfg['nodes']
node = nodes.get('host1', None)
host_user = node.get('user', 'ubuntu')
+ host_ssh_port = node.get('ssh_port', ssh.DEFAULT_PORT)
host_ip = node.get('ip', None)
host_pwd = node.get('password', 'root')
LOG.debug("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd)
+ self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
+ port=host_ssh_port)
self.client.wait(timeout=600)
self.setup_done = True
host = self.context_cfg["host"]
user = host.get("user", "ubuntu")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
ip = host.get("ip", None)
key_filename = host.get('key_filename', "~/.ssh/id_rsa")
LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename)
+ self.client = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.client.wait(timeout=600)
# copy scripts to host
host = self.context_cfg["host"]
user = host.get("user", "ubuntu")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
ip = host.get("ip", None)
key_filename = host.get('key_filename', "~/.ssh/id_rsa")
LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename)
+ self.client = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.client.wait(timeout=600)
# copy scripts to host
p.run(result)
print result
+
if __name__ == '__main__':
_test()
def setup(self):
host = self.context_cfg['host']
host_user = host.get('user', 'ubuntu')
+ host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
host_ip = host.get('ip', None)
host_key_filename = host.get('key_filename', '~/.ssh/id_rsa')
target = self.context_cfg['target']
target_user = target.get('user', 'ubuntu')
+ target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
target_ip = target.get('ip', None)
target_key_filename = target.get('key_filename', '~/.ssh/id_rsa')
LOG.info("user:%s, target:%s", target_user, target_ip)
self.target = ssh.SSH(target_user, target_ip,
- key_filename=target_key_filename)
+ key_filename=target_key_filename,
+ port=target_ssh_port)
self.target.wait(timeout=600)
LOG.info("user:%s, host:%s", host_user, host_ip)
self.host = ssh.SSH(host_user, host_ip,
- key_filename=host_key_filename)
+ key_filename=host_key_filename, port=host_ssh_port)
self.host.wait(timeout=600)
cmd = "iperf3 -s -D"
Netperf.TARGET_SCRIPT)
host = self.context_cfg['host']
host_user = host.get('user', 'ubuntu')
+ host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
host_ip = host.get('ip', None)
host_key_filename = host.get('key_filename', '~/.ssh/id_rsa')
target = self.context_cfg['target']
target_user = target.get('user', 'ubuntu')
+ target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
target_ip = target.get('ip', None)
target_key_filename = target.get('key_filename', '~/.ssh/id_rsa')
# netserver start automatically during the vm boot
LOG.info("user:%s, target:%s", target_user, target_ip)
self.server = ssh.SSH(target_user, target_ip,
- key_filename=target_key_filename)
+ key_filename=target_key_filename,
+ port=target_ssh_port)
self.server.wait(timeout=600)
LOG.info("user:%s, host:%s", host_user, host_ip)
self.client = ssh.SSH(host_user, host_ip,
- key_filename=host_key_filename)
+ key_filename=host_key_filename,
+ port=host_ssh_port)
self.client.wait(timeout=600)
# copy script to host
netperf.run(result)
print result
+
if __name__ == '__main__':
_test()
NetperfNode.TARGET_SCRIPT)
host = self.context_cfg['host']
host_user = host.get('user', 'ubuntu')
+ host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
host_ip = host.get('ip', None)
target = self.context_cfg['target']
target_user = target.get('user', 'ubuntu')
+ target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
target_ip = target.get('ip', None)
self.target_ip = target.get('ip', None)
host_password = host.get('password', None)
# netserver start automatically during the vm boot
LOG.info("user:%s, target:%s", target_user, target_ip)
self.server = ssh.SSH(target_user, target_ip,
- password=target_password)
+ password=target_password, port=target_ssh_port)
self.server.wait(timeout=600)
LOG.info("user:%s, host:%s", host_user, host_ip)
self.client = ssh.SSH(host_user, host_ip,
- password=host_password)
+ password=host_password, port=host_ssh_port)
self.client.wait(timeout=600)
# copy script to host
"""Scenario setup."""
host = self.context_cfg['host']
user = host.get('user', 'ubuntu')
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
ip = host.get('ip', None)
key_filename = host.get('key_filename', '~/.ssh/id_rsa')
LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename)
+ self.client = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.client.wait(timeout=600)
self.setup_done = True
-##############################################################################\r
-# Copyright (c) 2016 Huawei Technologies Co.,Ltd and others.\r
-#\r
-# All rights reserved. This program and the accompanying materials\r
-# are made available under the terms of the Apache License, Version 2.0\r
-# which accompanies this distribution, and is available at\r
-# http://www.apache.org/licenses/LICENSE-2.0\r
-##############################################################################\r
-import pkg_resources\r
-import logging\r
-import json\r
-\r
-import yardstick.ssh as ssh\r
-from yardstick.benchmark.scenarios import base\r
-\r
-LOG = logging.getLogger(__name__)\r
-\r
-\r
-class NetworkCapacity(base.Scenario):\r
- """Measure Network capacity and scale.\r
-\r
- This scenario reads network status including number of connections,\r
- number of frames sent/received.\r
- """\r
- __scenario_type__ = "NetworkCapacity"\r
- TARGET_SCRIPT = "networkcapacity.bash"\r
-\r
- def __init__(self, scenario_cfg, context_cfg):\r
- self.scenario_cfg = scenario_cfg\r
- self.context_cfg = context_cfg\r
- self.setup_done = False\r
-\r
- def setup(self):\r
- """scenario setup"""\r
- self.target_script = pkg_resources.resource_filename(\r
- "yardstick.benchmark.scenarios.networking",\r
- NetworkCapacity.TARGET_SCRIPT)\r
-\r
- host = self.context_cfg['host']\r
- if host is None:\r
- raise RuntimeError('No right node.please check the configuration')\r
- host_user = host.get('user', 'ubuntu')\r
- host_ip = host.get('ip', None)\r
- host_pwd = host.get('password', None)\r
-\r
- LOG.debug("user:%s, host:%s", host_user, host_ip)\r
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd)\r
- self.client.wait(timeout=600)\r
-\r
- # copy script to host\r
- self.client.run("cat > ~/networkcapacity.sh",\r
- stdin=open(self.target_script, 'rb'))\r
-\r
- self.setup_done = True\r
-\r
- def run(self, result):\r
- """execute the benchmark"""\r
-\r
- if not self.setup_done:\r
- self.setup()\r
-\r
- cmd = "sudo bash networkcapacity.sh"\r
-\r
- LOG.debug("Executing command: %s", cmd)\r
- status, stdout, stderr = self.client.execute(cmd)\r
- if status:\r
- raise RuntimeError(stderr)\r
-\r
- result.update(json.loads(stdout))\r
+##############################################################################
+# Copyright (c) 2016 Huawei Technologies Co.,Ltd and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+import pkg_resources
+import logging
+import json
+
+import yardstick.ssh as ssh
+from yardstick.benchmark.scenarios import base
+
+LOG = logging.getLogger(__name__)
+
+
+class NetworkCapacity(base.Scenario):
+ """Measure Network capacity and scale.
+
+ This scenario reads network status including number of connections,
+ number of frames sent/received.
+ """
+ __scenario_type__ = "NetworkCapacity"
+ TARGET_SCRIPT = "networkcapacity.bash"
+
+ def __init__(self, scenario_cfg, context_cfg):
+ self.scenario_cfg = scenario_cfg
+ self.context_cfg = context_cfg
+ self.setup_done = False
+
+ def setup(self):
+ """scenario setup"""
+ self.target_script = pkg_resources.resource_filename(
+ "yardstick.benchmark.scenarios.networking",
+ NetworkCapacity.TARGET_SCRIPT)
+
+ host = self.context_cfg['host']
+ if host is None:
+ raise RuntimeError('No right node.please check the configuration')
+ host_user = host.get('user', 'ubuntu')
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
+ host_ip = host.get('ip', None)
+ host_pwd = host.get('password', None)
+
+ LOG.debug("user:%s, host:%s", host_user, host_ip)
+ self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
+ port=ssh_port)
+ self.client.wait(timeout=600)
+
+ # copy script to host
+ self.client.run("cat > ~/networkcapacity.sh",
+ stdin=open(self.target_script, 'rb'))
+
+ self.setup_done = True
+
+ def run(self, result):
+ """execute the benchmark"""
+
+ if not self.setup_done:
+ self.setup()
+
+ cmd = "sudo bash networkcapacity.sh"
+
+ LOG.debug("Executing command: %s", cmd)
+ status, stdout, stderr = self.client.execute(cmd)
+ if status:
+ raise RuntimeError(stderr)
+
+ result.update(json.loads(stdout))
'yardstick.benchmark.scenarios.networking', Ping.TARGET_SCRIPT)
host = self.context_cfg['host']
user = host.get('user', 'ubuntu')
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
ip = host.get('ip', None)
key_filename = host.get('key_filename', '/root/.ssh/id_rsa')
password = host.get('password', None)
if password is not None:
LOG.info("Log in via pw, user:%s, host:%s, pw:%s",
user, ip, password)
- self.connection = ssh.SSH(user, ip, password=password)
+ self.connection = ssh.SSH(user, ip, password=password,
+ port=ssh_port)
else:
LOG.info("Log in via key, user:%s, host:%s, key_filename:%s",
user, ip, key_filename)
- self.connection = ssh.SSH(user, ip, key_filename=key_filename)
+ self.connection = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.connection.wait()
# ssh host
node = self.nodes.get(node_name, None)
user = node.get('user', 'ubuntu')
+ ssh_port = node.get("ssh_port", ssh.DEFAULT_PORT)
ip = node.get('ip', None)
pwd = node.get('password', None)
key_fname = node.get('key_filename', '/root/.ssh/id_rsa')
-
if pwd is not None:
LOG.debug("Log in via pw, user:%s, host:%s, password:%s",
user, ip, pwd)
- self.client = ssh.SSH(user, ip, password=pwd)
+ self.client = ssh.SSH(user, ip, password=pwd, port=ssh_port)
else:
LOG.debug("Log in via key, user:%s, host:%s, key_filename:%s",
user, ip, key_fname)
- self.client = ssh.SSH(user, ip, key_filename=key_fname)
+ self.client = ssh.SSH(user, ip, key_filename=key_fname,
+ port=ssh_port)
self.client.wait(timeout=60)
def _pre_setup(self):
status, stdout, stderr = self.client.execute(
"sudo bash pre_setup.sh")
+ def _get_controller_node(self, host_list):
+ for host_name in host_list:
+ node = self.nodes.get(host_name, None)
+ node_role = node.get('role', None)
+ if node_role == 'Controller':
+ return host_name
+ return None
+
def setup(self):
'''scenario setup'''
self.setup_script = pkg_resources.resource_filename(
if pre_setup:
self._pre_setup()
- # ssh host1
- self._ssh_host(self.host_list[0])
-
+ # log in a contronller node to setup
+ controller_node_name = self._get_controller_node(self.host_list)
+ LOG.debug("The Controller Node is: %s", controller_node_name)
+ if controller_node_name is None:
+ LOG.exception("Can't find controller node in the context!!!")
+ self._ssh_host(controller_node_name)
self.client.run("cat > ~/metadata.txt",
stdin=open(self.ping6_metadata_script, "rb"))
external_network=$2
echo "openrc=$openrc"
echo "external_network=$external_network"
+echo "nameserver 8.8.4.4" >> /etc/resolv.conf
source $openrc
-wget https://download.fedoraproject.org/pub/fedora/linux/releases/22/Cloud/x86_64/Images/Fedora-Cloud-Base-22-20150521.x86_64.qcow2 >/dev/null 2>&1
+
+fedora_img="Fedora-Cloud-Base-22-20150521.x86_64.qcow2"
+if [ ! -f "$fedora_img" ]; then
+ wget https://download.fedoraproject.org/pub/fedora/linux/releases/22/Cloud/x86_64/Images/${fedora_img} >/dev/null 2>&1
+fi
glance image-create --name 'Fedora22' --disk-format qcow2 \
--container-format bare --file ./Fedora-Cloud-Base-22-20150521.x86_64.qcow2
Pktgen.TARGET_SCRIPT)
host = self.context_cfg['host']
host_user = host.get('user', 'ubuntu')
+ host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
host_ip = host.get('ip', None)
host_key_filename = host.get('key_filename', '~/.ssh/id_rsa')
target = self.context_cfg['target']
target_user = target.get('user', 'ubuntu')
+ target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
target_ip = target.get('ip', None)
target_key_filename = target.get('key_filename', '~/.ssh/id_rsa')
LOG.info("user:%s, target:%s", target_user, target_ip)
self.server = ssh.SSH(target_user, target_ip,
- key_filename=target_key_filename)
+ key_filename=target_key_filename,
+ port=target_ssh_port)
self.server.wait(timeout=600)
LOG.info("user:%s, host:%s", host_user, host_ip)
self.client = ssh.SSH(host_user, host_ip,
- key_filename=host_key_filename)
+ key_filename=host_key_filename,
+ port=host_ssh_port)
self.client.wait(timeout=600)
# copy script to host
p.run(result)
print result
+
if __name__ == '__main__':
_test()
PktgenDPDKLatency.TESTPMD_SCRIPT)
host = self.context_cfg['host']
host_user = host.get('user', 'ubuntu')
+ host_ssh_port = host.get('ssh_port', ssh.DEFAULT_PORT)
host_ip = host.get('ip', None)
host_key_filename = host.get('key_filename', '~/.ssh/id_rsa')
target = self.context_cfg['target']
target_user = target.get('user', 'ubuntu')
+ target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
target_ip = target.get('ip', None)
target_key_filename = target.get('key_filename', '~/.ssh/id_rsa')
LOG.info("user:%s, target:%s", target_user, target_ip)
self.server = ssh.SSH(target_user, target_ip,
- key_filename=target_key_filename)
+ key_filename=target_key_filename,
+ port=target_ssh_port)
self.server.wait(timeout=600)
# copy script to host
LOG.info("user:%s, host:%s", host_user, host_ip)
self.client = ssh.SSH(host_user, host_ip,
- key_filename=host_key_filename)
+ key_filename=host_key_filename,
+ port=host_ssh_port)
self.client.wait(timeout=600)
# copy script to host
target = self.context_cfg['target']
target_user = target.get('user', 'root')
+ target_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
target_pwd = target.get('password', 'opnfv')
target_ip = target.get('ip', None)
''' webserver start automatically during the vm boot '''
LOG.info("user:%s, target:%s", target_user, target_ip)
- self.server = ssh.SSH(target_user, target_ip, password=target_pwd)
+ self.server = ssh.SSH(target_user, target_ip, password=target_pwd,
+ port=target_ssh_port)
self.server.wait(timeout=600)
self.server.run("cat > ~/server.sh",
stdin=open(self.server_script, "rb"))
target = self.context_cfg['target']
SF1_user = target.get('user', 'root')
+ SF1_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
SF1_pwd = target.get('password', 'opnfv')
SF1_ip = ips[0]
LOG.info("user:%s, host:%s", SF1_user, SF1_ip)
- self.server = ssh.SSH(SF1_user, SF1_ip, password=SF1_pwd)
+ self.server = ssh.SSH(SF1_user, SF1_ip, password=SF1_pwd,
+ port=SF1_ssh_port)
self.server.wait(timeout=600)
cmd_SF1 = ("nohup python vxlan_tool.py -i eth0 "
"-d forward -v off -b 80 &")
LOG.debug("HTTP firewall started")
SF2_user = target.get('user', 'root')
+ SF2_ssh_port = target.get('ssh_port', ssh.DEFAULT_PORT)
SF2_pwd = target.get('password', 'opnfv')
SF2_ip = ips[1]
LOG.info("user:%s, host:%s", SF2_user, SF2_ip)
- self.server = ssh.SSH(SF2_user, SF2_ip, password=SF2_pwd)
+ self.server = ssh.SSH(SF2_user, SF2_ip, password=SF2_pwd,
+ port=SF2_ssh_port)
self.server.wait(timeout=600)
cmd_SF2 = ("nohup python vxlan_tool.py -i eth0 "
"-d forward -v off -b 22 &")
''' Creating client and server VMs to perform the test'''
host = self.context_cfg['host']
host_user = host.get('user', 'root')
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
host_pwd = host.get('password', 'opnfv')
host_ip = host.get('ip', None)
LOG.info("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd)
+ self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
+ port=ssh_port)
self.client.wait(timeout=600)
if not self.setup_done: # pragma: no cover
'''scenario setup'''
vsperf = self.context_cfg['host']
vsperf_user = vsperf.get('user', 'ubuntu')
+ vsperf_ssh_port = vsperf.get('ssh_port', ssh.DEFAULT_PORT)
vsperf_password = vsperf.get('password', 'ubuntu')
vsperf_ip = vsperf.get('ip', None)
# copy vsperf conf to VM
LOG.info("user:%s, host:%s", vsperf_user, vsperf_ip)
self.client = ssh.SSH(vsperf_user, vsperf_ip,
- password=vsperf_password)
+ password=vsperf_password, port=vsperf_ssh_port)
# traffic generation could last long
self.client.wait(timeout=1800)
Fio.TARGET_SCRIPT)
host = self.context_cfg["host"]
user = host.get("user", "root")
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
ip = host.get("ip", None)
key_filename = host.get("key_filename", "~/.ssh/id_rsa")
LOG.info("user:%s, host:%s", user, ip)
- self.client = ssh.SSH(user, ip, key_filename=key_filename)
+ self.client = ssh.SSH(user, ip, key_filename=key_filename,
+ port=ssh_port)
self.client.wait(timeout=600)
# copy script to host
if host is None:
raise RuntimeError('No right node.Please check the configuration')
host_user = host.get('user', 'ubuntu')
+ ssh_port = host.get("ssh_port", ssh.DEFAULT_PORT)
host_ip = host.get('ip', None)
host_pwd = host.get('password', 'root')
LOG.debug("user:%s, host:%s", host_user, host_ip)
- self.client = ssh.SSH(host_user, host_ip, password=host_pwd)
+ self.client = ssh.SSH(host_user, host_ip, password=host_pwd,
+ port=ssh_port)
self.client.wait(timeout=600)
# copy script to host
cmd_subparsers = subparser.add_subparsers(title='subcommands')
self._find_actions(cmd_subparsers, command_object)
- def main(self, argv):
- '''run the command line interface'''
+ def _register_cli_opt(self):
# register subcommands to parse additional command line arguments
def parser(subparsers):
handler=parser)
CONF.register_cli_opt(category_opt)
+ def _load_cli_config(self, argv):
+
# load CLI args and config files
CONF(argv, project="yardstick", version=self._version,
default_config_files=find_config_files(CONFIG_SEARCH_PATHS))
+ def _handle_global_opts(self):
+
# handle global opts
logger = logging.getLogger('yardstick')
logger.setLevel(logging.WARNING)
if CONF.debug:
logger.setLevel(logging.DEBUG)
+ def _dispath_func_notask(self):
+
# dispatch to category parser
func = CONF.category.func
func(CONF.category)
+
+ def _dispath_func_task(self, task_id, timestamp):
+
+ # dispatch to category parser
+ func = CONF.category.func
+ func(CONF.category, task_id=task_id, timestamp=timestamp)
+
+ def main(self, argv): # pragma: no cover
+ '''run the command line interface'''
+ self._register_cli_opt()
+
+ self._load_cli_config(argv)
+
+ self._handle_global_opts()
+
+ self._dispath_func_notask()
+
+ def api(self, argv, task_id, timestamp): # pragma: no cover
+ '''run the api interface'''
+ self._register_cli_opt()
+
+ self._load_cli_config(argv)
+
+ self._handle_global_opts()
+
+ self._dispath_func_task(task_id, timestamp)
'yardstick.resources', 'scripts/install/' + target_script)
deployment_user = deployment.get("user")
+ deployment_ssh_port = deployment.get("ssh_port", ssh.DEFAULT_PORT)
deployment_ip = deployment.get("ip")
deployment_password = deployment.get("password")
LOG.info("user:%s, host:%s", deployment_user, installer_ip)
self.client = ssh.SSH(deployment_user, installer_ip,
- password=deployment_password)
+ password=deployment_password,
+ port=deployment_ssh_port)
self.client.wait(timeout=600)
else:
LOG.info("user:%s, host:%s", deployment_user, deployment_ip)
self.client = ssh.SSH(deployment_user, deployment_ip,
- password=deployment_password)
+ password=deployment_password,
+ port=deployment_ssh_port)
self.client.wait(timeout=600)
# copy script to host
'yardstick.resources', 'scripts/remove/' + target_script)
deployment_user = deployment.get("user")
+ deployment_ssh_port = deployment.get("ssh_port", ssh.DEFAULT_PORT)
deployment_ip = deployment.get("ip")
deployment_password = deployment.get("password")
LOG.info("user:%s, host:%s", deployment_user, installer_ip)
self.client = ssh.SSH(deployment_user, installer_ip,
- password=deployment_password)
+ password=deployment_password,
+ port=deployment_ssh_port)
self.client.wait(timeout=600)
else:
LOG.info("user:%s, host:%s", deployment_user, deployment_ip)
self.client = ssh.SSH(deployment_user, deployment_ip,
- password=deployment_password)
+ password=deployment_password,
+ port=deployment_ssh_port)
self.client.wait(timeout=600)
# copy script to host
class PluginParser(object):
'''Parser for plugin configration files in yaml format'''
+
def __init__(self, path):
self.path = path
output_file_default, default=output_file_default)
@cliargs("--suite", help="process test suite file instead of a task file",
action="store_true")
- def do_start(self, args):
+ def do_start(self, args, **kwargs):
'''Start a benchmark scenario.'''
atexit.register(atexit_handler)
--- /dev/null
+CONFIG_SAMPLE = '/etc/yardstick/config.yaml'
+
+RELENG_DIR = 'releng.dir'
import os
import sys
+import yaml
from oslo_utils import importutils
import yardstick
new_package = ".".join(root.split(os.sep)).split("....")[1]
module_name = "%s.%s" % (new_package, filename[:-3])
try_append_module(module_name, sys.modules)
+
+
+def get_para_from_yaml(file_path, args):
+
+ def func(a, b):
+ if a is None:
+ return None
+ return a.get(b)
+
+ if os.path.exists(file_path):
+ with open(file_path) as f:
+ value = yaml.safe_load(f)
+ value = reduce(func, args.split('.'), value)
+
+ if value is None:
+ print 'parameter not found'
+ return None
+
+ return value
+ else:
+ print 'file not exist'
+ return None
LOG = logging.getLogger(__name__)
+DEFAULT_PORT = 22
+
class SSHError(Exception):
pass
class SSH(object):
"""Represent ssh connection."""
- def __init__(self, user, host, port=22, pkey=None,
+ def __init__(self, user, host, port=DEFAULT_PORT, pkey=None,
key_filename=None, password=None):
"""Initialize SSH client.
self.user = user
self.host = host
- self.port = port
+ # we may get text port from YAML, convert to int
+ self.port = int(port)
self.pkey = self._get_pkey(pkey) if pkey else None
self.password = password
self.key_filename = key_filename
Code Review / yardstick.git / commitdiff