}
}
+ self.yardstick_conf = {'yardstick': {}}
+
def test_record_result_data_no_target(self):
- influxdb = InfluxdbDispatcher(None)
+ influxdb = InfluxdbDispatcher(None, self.yardstick_conf)
influxdb.target = ''
self.assertEqual(influxdb.record_result_data(self.data1), -1)
def test_record_result_data_no_case_name(self):
- influxdb = InfluxdbDispatcher(None)
+ influxdb = InfluxdbDispatcher(None, self.yardstick_conf)
self.assertEqual(influxdb.record_result_data(self.data2), -1)
@mock.patch('yardstick.dispatcher.influxdb.requests')
def test_record_result_data(self, mock_requests):
type(mock_requests.post.return_value).status_code = 204
- influxdb = InfluxdbDispatcher(None)
+ influxdb = InfluxdbDispatcher(None, self.yardstick_conf)
self.assertEqual(influxdb.record_result_data(self.data1), 0)
self.assertEqual(influxdb.record_result_data(self.data2), 0)
self.assertEqual(influxdb.flush_result_data(), 0)
'mpstat.cpu0.%idle=99.00,mpstat.cpu0.%sys=0.00'
# need to sort for assert to work
line = ",".join(sorted(line.split(',')))
- influxdb = InfluxdbDispatcher(None)
+ influxdb = InfluxdbDispatcher(None, self.yardstick_conf)
flattened_data = influxdb._dict_key_flatten(
self.data3['benchmark']['data'])
result = ",".join(
self.assertEqual(result, line)
def test__get_nano_timestamp(self):
- influxdb = InfluxdbDispatcher(None)
+ influxdb = InfluxdbDispatcher(None, self.yardstick_conf)
results = {'benchmark': {'timestamp': '1451461248.925574'}}
self.assertEqual(influxdb._get_nano_timestamp(results),
'1451461248925574144')
@mock.patch('yardstick.dispatcher.influxdb.time')
def test__get_nano_timestamp_except(self, mock_time):
results = {}
- influxdb = InfluxdbDispatcher(None)
+ influxdb = InfluxdbDispatcher(None, self.yardstick_conf)
mock_time.time.return_value = 1451461248.925574
self.assertEqual(influxdb._get_nano_timestamp(results),
'1451461248925574144')
from yardstick.benchmark.runners import base as base_runner
from yardstick.common.task_template import TaskTemplate
from yardstick.common.utils import source_env
+from yardstick.common import utils
from yardstick.common import constants
output_file_default = "/tmp/yardstick.out"
+config_file = '/etc/yardstick/yardstick.conf'
test_cases_dir_default = "tests/opnfv/test_cases/"
LOG = logging.getLogger(__name__)
Set of commands to manage benchmark tasks.
"""
+ def __init__(self):
+ self.config = {}
+ self.contexts = []
+
def start(self, args, **kwargs):
"""Start a benchmark scenario."""
- atexit.register(atexit_handler)
+ atexit.register(self.atexit_handler)
self.task_id = kwargs.get('task_id', str(uuid.uuid4()))
check_environment()
+ self.config['yardstick'] = utils.parse_ini_file(config_file)
+
total_start_time = time.time()
parser = TaskParser(args.inputfile[0])
for i in range(0, len(task_files)):
one_task_start_time = time.time()
parser.path = task_files[i]
- scenarios, run_in_parallel, meet_precondition = parser.parse_task(
- self.task_id, task_args[i], task_args_fnames[i])
+ scenarios, run_in_parallel, meet_precondition, contexts = \
+ parser.parse_task(self.task_id, task_args[i],
+ task_args_fnames[i])
+
+ self.contexts.extend(contexts)
if not meet_precondition:
LOG.info("meet_precondition is %s, please check envrionment",
if args.keep_deploy:
# keep deployment, forget about stack
# (hide it for exit handler)
- Context.list = []
+ self.contexts = []
else:
- for context in Context.list[::-1]:
+ for context in self.contexts[::-1]:
context.undeploy()
- Context.list = []
+ self.contexts = []
one_task_end_time = time.time()
LOG.info("task %s finished in %d secs", task_files[i],
one_task_end_time - one_task_start_time)
def _run(self, scenarios, run_in_parallel, output_file):
"""Deploys context and calls runners"""
- for context in Context.list:
+ for context in self.contexts:
context.deploy()
background_runners = []
# Start all background scenarios
for scenario in filter(_is_background_scenario, scenarios):
scenario["runner"] = dict(type="Duration", duration=1000000000)
- runner = run_one_scenario(scenario, output_file)
+ runner = self.run_one_scenario(scenario, output_file)
background_runners.append(runner)
runners = []
if run_in_parallel:
for scenario in scenarios:
if not _is_background_scenario(scenario):
- runner = run_one_scenario(scenario, output_file)
+ runner = self.run_one_scenario(scenario, output_file)
runners.append(runner)
# Wait for runners to finish
# run serially
for scenario in scenarios:
if not _is_background_scenario(scenario):
- runner = run_one_scenario(scenario, output_file)
+ runner = self.run_one_scenario(scenario, output_file)
runner_join(runner)
print("Runner ended, output in", output_file)
base_runner.Runner.release(runner)
print("Background task ended")
+ def atexit_handler(self):
+ """handler for process termination"""
+ base_runner.Runner.terminate_all()
+
+ if self.contexts:
+ print("Undeploying all contexts")
+ for context in self.contexts[::-1]:
+ context.undeploy()
+
+ def run_one_scenario(self, scenario_cfg, output_file):
+ """run one scenario using context"""
+ runner_cfg = scenario_cfg["runner"]
+ runner_cfg['output_filename'] = output_file
+
+ # TODO support get multi hosts/vms info
+ context_cfg = {}
+ if "host" in scenario_cfg:
+ context_cfg['host'] = Context.get_server(scenario_cfg["host"])
+
+ if "target" in scenario_cfg:
+ if is_ip_addr(scenario_cfg["target"]):
+ context_cfg['target'] = {}
+ context_cfg['target']["ipaddr"] = scenario_cfg["target"]
+ else:
+ context_cfg['target'] = Context.get_server(
+ scenario_cfg["target"])
+ if self._is_same_heat_context(scenario_cfg["host"],
+ scenario_cfg["target"]):
+ context_cfg["target"]["ipaddr"] = \
+ context_cfg["target"]["private_ip"]
+ else:
+ context_cfg["target"]["ipaddr"] = \
+ context_cfg["target"]["ip"]
+
+ if "targets" in scenario_cfg:
+ ip_list = []
+ for target in scenario_cfg["targets"]:
+ if is_ip_addr(target):
+ ip_list.append(target)
+ context_cfg['target'] = {}
+ else:
+ context_cfg['target'] = Context.get_server(target)
+ if self._is_same_heat_context(scenario_cfg["host"],
+ target):
+ ip_list.append(context_cfg["target"]["private_ip"])
+ else:
+ ip_list.append(context_cfg["target"]["ip"])
+ context_cfg['target']['ipaddr'] = ','.join(ip_list)
+
+ if "nodes" in scenario_cfg:
+ context_cfg["nodes"] = parse_nodes_with_context(scenario_cfg)
+ runner = base_runner.Runner.get(runner_cfg, self.config)
+
+ print("Starting runner of type '%s'" % runner_cfg["type"])
+ runner.run(scenario_cfg, context_cfg)
+
+ return runner
+
+ def _is_same_heat_context(self, host_attr, target_attr):
+ """check if two servers are in the same heat context
+ host_attr: either a name for a server created by yardstick or a dict
+ with attribute name mapping when using external heat templates
+ target_attr: either a name for a server created by yardstick or a dict
+ with attribute name mapping when using external heat templates
+ """
+ return True
+ host = None
+ target = None
+ for context in self.contexts:
+ if context.__context_type__ != "Heat":
+ continue
+
+ host = context._get_server(host_attr)
+ if host is None:
+ continue
+
+ target = context._get_server(target_attr)
+ if target is None:
+ return False
-# TODO: Move stuff below into TaskCommands class !?
+ # Both host and target is not None, then they are in the
+ # same heat context.
+ return True
+
+ return False
class TaskParser(object): # pragma: no cover
else:
context_cfgs = [{"type": "Dummy"}]
+ contexts = []
name_suffix = '-{}'.format(task_id[:8])
for cfg_attrs in context_cfgs:
try:
context = Context.get(context_type)
context.init(cfg_attrs)
+ contexts.append(context)
run_in_parallel = cfg.get("run_in_parallel", False)
pass
# TODO we need something better here, a class that represent the file
- return cfg["scenarios"], run_in_parallel, meet_precondition
+ return cfg["scenarios"], run_in_parallel, meet_precondition, contexts
def _check_schema(self, cfg_schema, schema_type):
"""Check if config file is using the correct schema type"""
return True
-def atexit_handler():
- """handler for process termination"""
- base_runner.Runner.terminate_all()
-
- if len(Context.list) > 0:
- print("Undeploying all contexts")
- for context in Context.list[::-1]:
- context.undeploy()
-
-
def is_ip_addr(addr):
"""check if string addr is an IP address"""
try:
return True
-def _is_same_heat_context(host_attr, target_attr):
- """check if two servers are in the same heat context
- host_attr: either a name for a server created by yardstick or a dict
- with attribute name mapping when using external heat templates
- target_attr: either a name for a server created by yardstick or a dict
- with attribute name mapping when using external heat templates
- """
- host = None
- target = None
- for context in Context.list:
- if context.__context_type__ != "Heat":
- continue
-
- host = context._get_server(host_attr)
- if host is None:
- continue
-
- target = context._get_server(target_attr)
- if target is None:
- return False
-
- # Both host and target is not None, then they are in the
- # same heat context.
- return True
-
- return False
-
-
def _is_background_scenario(scenario):
if "run_in_background" in scenario:
return scenario["run_in_background"]
return False
-def run_one_scenario(scenario_cfg, output_file):
- """run one scenario using context"""
- runner_cfg = scenario_cfg["runner"]
- runner_cfg['output_filename'] = output_file
-
- # TODO support get multi hosts/vms info
- context_cfg = {}
- if "host" in scenario_cfg:
- context_cfg['host'] = Context.get_server(scenario_cfg["host"])
-
- if "target" in scenario_cfg:
- if is_ip_addr(scenario_cfg["target"]):
- context_cfg['target'] = {}
- context_cfg['target']["ipaddr"] = scenario_cfg["target"]
- else:
- context_cfg['target'] = Context.get_server(scenario_cfg["target"])
- if _is_same_heat_context(scenario_cfg["host"],
- scenario_cfg["target"]):
- context_cfg["target"]["ipaddr"] = \
- context_cfg["target"]["private_ip"]
- else:
- context_cfg["target"]["ipaddr"] = \
- context_cfg["target"]["ip"]
-
- if "targets" in scenario_cfg:
- ip_list = []
- for target in scenario_cfg["targets"]:
- if is_ip_addr(target):
- ip_list.append(target)
- context_cfg['target'] = {}
- else:
- context_cfg['target'] = Context.get_server(target)
- if _is_same_heat_context(scenario_cfg["host"], target):
- ip_list.append(context_cfg["target"]["private_ip"])
- else:
- ip_list.append(context_cfg["target"]["ip"])
- context_cfg['target']['ipaddr'] = ','.join(ip_list)
-
- if "nodes" in scenario_cfg:
- context_cfg["nodes"] = parse_nodes_with_context(scenario_cfg)
- runner = base_runner.Runner.get(runner_cfg)
-
- print("Starting runner of type '%s'" % runner_cfg["type"])
- runner.run(scenario_cfg, context_cfg)
-
- return runner
-
-
def parse_nodes_with_context(scenario_cfg):
"""paras the 'nodes' fields in scenario """
nodes = scenario_cfg["nodes"]
import requests
import six
-from oslo_config import cfg
from oslo_serialization import jsonutils
from third_party.influxdb.influxdb_line_protocol import make_lines
LOG = logging.getLogger(__name__)
-CONF = cfg.CONF
-influx_dispatcher_opts = [
- cfg.StrOpt('target',
- default='http://127.0.0.1:8086',
- help='The target where the http request will be sent. '
- 'If this is not set, no data will be posted. For '
- 'example: target = http://hostname:1234/path'),
- cfg.StrOpt('db_name',
- default='yardstick',
- help='The database name to store test results.'),
- cfg.StrOpt('username',
- default='root',
- help='The user name to access database.'),
- cfg.StrOpt('password',
- default='root',
- help='The user password to access database.'),
- cfg.IntOpt('timeout',
- default=5,
- help='The max time in seconds to wait for a request to '
- 'timeout.'),
-]
-
-CONF.register_opts(influx_dispatcher_opts, group="dispatcher_influxdb")
-
class InfluxdbDispatcher(DispatchBase):
"""Dispatcher class for posting data into an influxdb target.
__dispatcher_type__ = "Influxdb"
- def __init__(self, conf):
+ def __init__(self, conf, config):
super(InfluxdbDispatcher, self).__init__(conf)
- self.timeout = CONF.dispatcher_influxdb.timeout
- self.target = CONF.dispatcher_influxdb.target
- self.db_name = CONF.dispatcher_influxdb.db_name
- self.username = CONF.dispatcher_influxdb.username
- self.password = CONF.dispatcher_influxdb.password
+ db_conf = config['yardstick'].get('dispatcher_influxdb', {})
+ self.timeout = int(db_conf.get('timeout', 5))
+ self.target = db_conf.get('target', 'http://127.0.0.1:8086')
+ self.db_name = db_conf.get('db_name', 'yardstick')
+ self.username = db_conf.get('username', 'root')
+ self.password = db_conf.get('password', 'root')
self.influxdb_url = "%s/write?db=%s" % (self.target, self.db_name)
self.raw_result = []
self.case_name = ""
Code Review / yardstick.git / commitdiff