def __init__(self, config, scenario, engine, pure_body_file=False):
self.engine = engine
self.log = self.engine.log.getChild(self.__class__.__name__)
super(HTTPRequest, self).__init__(config, scenario)
msg = "Option 'url' is mandatory for request but not found in %s" % config
self.url = self.config.get("url", TaurusConfigError(msg))
self.label = str(self.config.get("label", self.url))
self.method = self.config.get("method", "GET")
if not has_variable_pattern(self.method):
self.method = self.method.upper()
# TODO: add method to join dicts/lists from scenario/request level?
self.headers = self.config.get("headers", {})
self.keepalive = self.config.get('keepalive', None)
self.timeout = self.config.get('timeout', None)
self.follow_redirects = self.config.get('follow-redirects', None)
self.body = self._get_body(pure_body_file=pure_body_file)
def prepare(self):
"""
Preparation in provisioning begins with reading executions list
and instantiating ScenarioExecutor classes for them
"""
super(Provisioning, self).prepare()
exc = TaurusConfigError("No 'execution' is configured. Did you forget to pass config files?")
executions = self.engine.config.get(ScenarioExecutor.EXEC, [])
if not executions and self.disallow_empty_execution:
raise exc
for execution in executions:
instance = self.engine.instantiate_module(execution.get("executor"))
instance.provisioning = self
instance.execution = execution
assert isinstance(instance, ScenarioExecutor)
self.executors.append(instance)
def __prepare_reporters(self):
"""
Instantiate reporters, then prepare them in case they would like to interact
"""
reporting = self.config.get(Reporter.REP, [])
for index, reporter in enumerate(reporting):
reporter = ensure_is_dict(reporting, index, "module")
msg = "reporter 'module' field isn't recognized: %s"
cls = reporter.get('module', TaurusConfigError(msg % reporter))
instance = self.instantiate_module(cls)
instance.parameters = reporter
assert isinstance(instance, Reporter)
self.reporters.append(instance)
# prepare reporters
for module in self.reporters:
self.prepared.append(module)
module.prepare()
def prepare(self):
self.install_required_tools()
scenario = self.get_scenario()
jar_files = []
files = self.execution.get('files', [])
for candidate in files:
candidate = get_full_path(self.engine.find_file(candidate))
if os.path.isfile(candidate) and candidate.lower().endswith('.jar'):
jar_files.append(candidate)
elif os.path.isdir(candidate):
for element in os.listdir(candidate):
element = os.path.join(candidate, element)
if os.path.isfile(element) and element.lower().endswith('.jar'):
jar_files.append(element)
self.log.debug("JAR files list for Gatling: %s", jar_files)
if jar_files:
separator = os.pathsep
self.jar_list = separator + separator.join(jar_files)
if is_windows() or jar_files:
self.log.debug("Building Gatling launcher")
self.launcher = self.__build_launcher()
else:
self.log.debug("Will not build Gatling launcher")
self.launcher = self.settings["path"]
self.script = self.get_script_path()
if not self.script:
if "requests" in scenario:
self.get_scenario()['simulation'], self.script = self.__generate_script()
self.__copy_data_sources()
else:
msg = "There must be a script file or requests for its generation "
msg += "to run Gatling tool (%s)" % self.execution.get('scenario')
raise TaurusConfigError(msg)
self.dir_prefix = self.settings.get('dir_prefix', None)
if self.dir_prefix is None:
self.dir_prefix = 'gatling-%s' % id(self)
self.reader = DataLogReader(self.engine.artifacts_dir, self.log, self.dir_prefix)
if isinstance(self.engine.aggregator, ConsolidatingAggregator):
self.engine.aggregator.add_underling(self.reader)
def prepare(self):
self.install_required_tools()
scenario = self.get_scenario()
self.exec_id = self.label
self.script = self.get_script_path()
if not self.script:
if "requests" in scenario:
self.script = self.__scenario_from_requests()
else:
msg = "There must be a script file or requests for its generation "
msg += "to run Grinder tool (%s)" % self.execution.get(
'scenario')
raise TaurusConfigError(msg)
self.properties_file = self.engine.create_artifact(
"grinder", ".properties")
with open(self.properties_file, 'w') as fds:
self.__write_base_props(fds)
self.__write_scenario_props(fds, scenario)
self.__write_bzt_props(fds)
self.kpi_file = os.path.join(self.engine.artifacts_dir,
self.exec_id + "-kpi.log")
self.reader = DataLogReader(self.kpi_file, self.log)
self.reader.report_by_url = self.settings.get("report-by-url", False)
if isinstance(self.engine.aggregator, ConsolidatingAggregator):
self.engine.aggregator.add_underling(self.reader)
# add logback configurations used by worker processes (logback-worker.xml)
res_dir = os.path.join(get_full_path(__file__, step_up=2), 'resources')
self.env.add_path({"CLASSPATH": res_dir}, finish=True)
self.env.add_path(
{
"CLASSPATH":
TaurusJavaHelper(self.engine.get_http_client()).tool_path
},
finish=True)
self.env.add_path({"CLASSPATH": self.settings.get("path", None)},
finish=True)
self.cmd_line = ["java", "net.grinder.Grinder", self.properties_file]
def gen_setup_method(self):
self.log.debug("Generating setUp test method")
browsers = ["Firefox", "Chrome", "Ie", "Opera"]
browser = self.scenario.get("browser", "Firefox")
if browser not in browsers:
raise TaurusConfigError("Unsupported browser name: %s" % browser)
setup_method_def = self.gen_method_definition("setUp", ["self"])
if browser == 'Firefox':
setup_method_def.append(
self.gen_statement("profile = webdriver.FirefoxProfile()"))
statement = "profile.set_preference('webdriver.log.file', %s)" % repr(
self.wdlog)
log_set = self.gen_statement(statement)
setup_method_def.append(log_set)
setup_method_def.append(
self.gen_statement("self.driver = webdriver.Firefox(profile)"))
elif browser == 'Chrome':
statement = "self.driver = webdriver.Chrome(service_log_path=%s)"
setup_method_def.append(
self.gen_statement(statement % repr(self.wdlog)))
else:
setup_method_def.append(
self.gen_statement("self.driver = webdriver.%s()" % browser))
scenario_timeout = self.scenario.get("timeout", None)
if scenario_timeout is None:
scenario_timeout = '30s'
setup_method_def.append(self.gen_impl_wait(scenario_timeout))
if self.window_size: # FIXME: unused in fact
statement = self.gen_statement(
"self.driver.set_window_position(0, 0)")
setup_method_def.append(statement)
args = (self.window_size[0], self.window_size[1])
statement = self.gen_statement(
"self.driver.set_window_size(%s, %s)" % args)
setup_method_def.append(statement)
else:
pass # TODO: setup_method_def.append(self.gen_statement("self.driver.fullscreen()"))
setup_method_def.append(self.gen_new_line(indent=0))
return setup_method_def
def prepare(self):
super(ApiritifNoseExecutor, self).prepare()
if 'executor' in self.execution.keys():
if self.execution['executor'] == 'nose':
msg = "'nose' keyword is deprecated and will be removed soon. Please use 'apiritif' instead."
self.log.warning(msg)
self.script = self.get_script_path()
if not self.script:
if "requests" in self.get_scenario():
self.script = self.__tests_from_requests()
else:
raise TaurusConfigError("Nothing to test, no requests were provided in scenario")
# todo: requred tools?
# path to taurus dir. It's necessary for bzt usage inside tools/helpers
self.env.add_path({"PYTHONPATH": get_full_path(BZT_DIR, step_up=1)})
self.reporting_setup() # no prefix/suffix because we don't fully control report file names
def _get_timer(req):
think_time = req.get_think_time(full=True)
if not think_time:
return []
if not isinstance(think_time, list): # constant
return JMX.get_constant_timer(delay=ProtocolHandler.safe_time(think_time))
mean = ProtocolHandler.safe_time(think_time[1])
dev = ProtocolHandler.safe_time(think_time[2])
if think_time[0] == "uniform":
return JMX.get_uniform_timer(maximum=dev * 2, offset=mean - dev)
elif think_time[0] == "gaussian":
return JMX.get_gaussian_timer(dev=dev, offset=mean)
elif think_time[0] == "poisson":
return JMX.get_poisson_timer(lam=mean - dev, delay=dev)
else:
raise TaurusConfigError("Wrong timer type: %s" % think_time[0])
def _fix_filenames(self, old_names):
# check for concurrent base names
old_full_names = [self.engine.find_file(x) for x in old_names]
rbases = [os.path.basename(get_full_path(rfile)) for rfile in old_full_names]
rpaths = [get_full_path(rfile, step_up=1) for rfile in old_full_names]
while rbases:
base, path = rbases.pop(), rpaths.pop()
if base in rbases:
index = rbases.index(base)
if path != rpaths[index]:
msg = 'Resource "%s" occurs more than one time, rename to avoid data loss'
raise TaurusConfigError(msg % base)
old_full_names = self.__pack_dirs(old_full_names)
new_base_names = [os.path.basename(f) for f in old_full_names]
self.log.debug('Replace file names in config: %s with %s', old_names, new_base_names)
replace_in_config(self.engine.config, old_names, new_base_names, log=self.log)
old_full_names = list(set(old_full_names))
return old_full_names
def __init__(self, parent_log, label, config, engine):
super(GraphiteClient, self).__init__(parent_log, engine)
self.config = config
exc = TaurusConfigError('Graphite client requires address parameter')
self.address = self.config.get("address", exc)
# interval for client
interval = self.config.get('interval', None)
if not interval:
interval = '5s'
self.interval = int(dehumanize_time(interval))
self.url = self._get_url()
if label:
self.host_label = label
else:
self.host_label = self.address
self.timeout = int(dehumanize_time(self.config.get('timeout', '5s')))
self._cached_data = None
def prepare(self):
"""
Read aggregation options
"""
super(ConsolidatingAggregator, self).prepare()
# make unique & sort
percentiles = self.settings.get("percentiles", self.track_percentiles)
percentiles = list(set(percentiles))
percentiles.sort()
self.track_percentiles = percentiles
self.settings['percentiles'] = percentiles
self.ignored_labels = self.settings.get("ignore-labels", self.ignored_labels)
self.generalize_labels = self.settings.get("generalize-labels", self.generalize_labels)
self.min_buffer_len = dehumanize_time(self.settings.get("min-buffer-len", self.min_buffer_len))
max_buffer_len = self.settings.get("max-buffer-len", self.max_buffer_len)
try: # for max_buffer_len == float('inf')
self.max_buffer_len = dehumanize_time(max_buffer_len)
except TaurusInternalException as exc:
self.log.debug("Exception in dehumanize_time(%s)" % max_buffer_len)
if str(exc).find('inf') != -1:
self.max_buffer_len = max_buffer_len
else:
raise TaurusConfigError("Wrong 'max-buffer-len' value: %s" % max_buffer_len)
self.buffer_multiplier = self.settings.get("buffer-multiplier", self.buffer_multiplier)
percentile = self.settings.get("buffer-scale-choice", 0.5)
count = len(self.track_percentiles)
if count == 1:
self.buffer_scale_idx = str(float(self.track_percentiles[0]))
if count > 1:
percentiles = [i / (count - 1.0) for i in range(count)]
distances = [abs(percentile - percentiles[i]) for i in range(count)]
index_position = distances.index(min(distances))
self.buffer_scale_idx = str(float(self.track_percentiles[index_position]))
debug_str = 'Buffer scaling setup: percentile %s from %s selected'
self.log.debug(debug_str, self.buffer_scale_idx, self.track_percentiles)
self.rtimes_len = self.settings.get("rtimes-len", self.rtimes_len)
def __add_jsr_elements(children, req):
"""
:type children: etree.Element
:type req: Request
"""
jsrs = req.config.get("jsr223", [])
if not isinstance(jsrs, list):
jsrs = [jsrs]
for idx, _ in enumerate(jsrs):
jsr = ensure_is_dict(jsrs, idx, default_key='script-text')
lang = jsr.get("language", "groovy")
script_file = jsr.get("script-file", None)
script_text = jsr.get("script-text", None)
if not script_file and not script_text:
raise TaurusConfigError("jsr223 element must specify one of 'script-file' or 'script-text'")
parameters = jsr.get("parameters", "")
execute = jsr.get("execute", "after")
children.append(JMX._get_jsr223_element(lang, script_file, parameters, execute, script_text))
children.append(etree.Element("hashTree"))
def connect(self):
exc = TaurusConfigError(
'Metric is required in Local monitoring client')
metric_names = self.config.get('metrics', exc)
bad_list = set(metric_names) - set(self.AVAILABLE_METRICS)
if bad_list:
self.log.warning('Wrong metrics found: %s', bad_list)
good_list = set(metric_names) & set(self.AVAILABLE_METRICS)
if not good_list:
raise exc
self.metrics = list(set(good_list))
self.monitor = LocalMonitor(self.log, self.metrics, self.engine)
self.interval = dehumanize_time(self.config.get('interval', None))
if not self.interval:
self.interval = self.engine.check_interval
def prepare(self):
self.install_required_tools()
scenario = self.get_scenario()
self.exec_id = self.label
self.script = self.get_script_path()
if self.script:
self.script = os.path.abspath(self.engine.find_file(self.script))
elif "requests" in scenario:
self.script = self.__scenario_from_requests()
else:
msg = "There must be a script file or requests for its generation "
msg += "to run Grinder tool (%s)" % self.execution.get('scenario')
raise TaurusConfigError(msg)
self.properties_file = self.engine.create_artifact(
"grinder", ".properties")
with open(self.properties_file, 'w') as fds:
self.__write_base_props(fds)
self.__write_scenario_props(fds, scenario)
self.__write_bzt_props(fds)
self.kpi_file = os.path.join(self.engine.artifacts_dir,
self.exec_id + "-kpi.log")
self.reader = DataLogReader(self.kpi_file, self.log)
self.reader.report_by_url = self.settings.get("report-by-url", False)
if isinstance(self.engine.aggregator, ConsolidatingAggregator):
self.engine.aggregator.add_underling(self.reader)
# add logback configurations used by worker processes (logback-worker.xml)
res_dir = os.path.join(get_full_path(__file__, step_up=2), 'resources')
classpath = res_dir
classpath += os.path.pathsep + os.path.join(res_dir,
"grinder-logger-1.0.jar")
path = self.settings.get("path", None)
if path:
classpath += os.path.pathsep + path
self.cmd_line = ["java", "-classpath", classpath]
self.cmd_line += ["net.grinder.Grinder", self.properties_file]
def get_script_path(self, required=False, scenario=None):
"""
:type required: bool
:type scenario: Scenario
"""
if scenario is None:
scenario = self.get_scenario()
if required:
exc = TaurusConfigError("You must provide script for %s" % self)
script = scenario.get(Scenario.SCRIPT, exc)
else:
script = scenario.get(Scenario.SCRIPT)
if script:
script = self.engine.find_file(script)
scenario[Scenario.SCRIPT] = script
return script
def __configure(self, configs):
self.log.info("Starting with configs: %s", configs)
if self.options.no_system_configs is None:
self.options.no_system_configs = False
bzt_rc = os.path.expanduser(os.path.join('~', ".bzt-rc"))
if os.path.exists(bzt_rc):
self.log.debug("Using personal config: %s" % bzt_rc)
else:
self.log.debug("Adding personal config: %s", bzt_rc)
self.log.info("No personal config found, creating one at %s",
bzt_rc)
shutil.copy(
os.path.join(get_full_path(__file__, step_up=1), 'resources',
'base-bzt-rc.yml'), bzt_rc)
merged_config = self.engine.configure(
[bzt_rc] + configs, not self.options.no_system_configs)
# apply aliases
for alias in self.options.aliases:
cli_aliases = self.engine.config.get('cli-aliases')
keys = sorted(cli_aliases.keys())
err = TaurusConfigError(
"'%s' not found in aliases. Available aliases are: %s" %
(alias, ", ".join(keys)))
self.engine.config.merge(cli_aliases.get(alias, err))
if self.options.option:
overrider = ConfigOverrider(self.log)
overrider.apply_overrides(self.options.option, self.engine.config)
settings = self.engine.config.get(SETTINGS)
settings.get('verbose',
bool(self.options.verbose)) # respect value from config
if self.options.verbose: # force verbosity if cmdline asked for it
settings['verbose'] = True
if settings.get('verbose'):
CLI.console_handler.setLevel(logging.DEBUG)
self.engine.create_artifacts_dir(configs, merged_config)
self.engine.default_cwd = os.getcwd()
def gen_setupclass_method(self):
self.log.debug("Generating setUp test method")
browsers = ["Firefox", "Chrome", "Ie", "Opera"]
browser = self.scenario.get("browser", "Firefox")
if browser not in browsers:
raise TaurusConfigError("Unsupported browser name: %s" % browser)
setup_method_def = self.gen_decorator_statement('classmethod')
setup_method_def.append(
self.gen_method_definition("setUpClass", ["cls"]))
if browser == 'Firefox':
setup_method_def.append(
self.gen_statement("profile = webdriver.FirefoxProfile()"))
statement = "profile.set_preference('webdriver.log.file', %s)" % repr(
self.wdlog)
log_set = self.gen_statement(statement)
setup_method_def.append(log_set)
setup_method_def.append(
self.gen_statement("cls.driver = webdriver.Firefox(profile)"))
elif browser == 'Chrome':
statement = "cls.driver = webdriver.Chrome(service_log_path=%s)"
setup_method_def.append(
self.gen_statement(statement % repr(self.wdlog)))
else:
setup_method_def.append(
self.gen_statement("cls.driver = webdriver.%s()" % browser))
scenario_timeout = self.scenario.get("timeout", None)
if scenario_timeout is None:
scenario_timeout = '30s'
setup_method_def.append(
self.gen_impl_wait(scenario_timeout, target='cls'))
if self.window_size:
args = (self.window_size[0], self.window_size[1]) # to force tuple
statement = self.gen_statement(
"cls.driver.set_window_size(%s, %s)" % args)
setup_method_def.append(statement)
else:
setup_method_def.append(
self.gen_statement("cls.driver.maximize_window()"))
setup_method_def.append(self.gen_new_line())
return setup_method_def
def _add_xpath_assertions(self, request, test_method):
jpath_assertions = request.config.get("assert-xpath", [])
for idx, assertion in enumerate(jpath_assertions):
assertion = ensure_is_dict(jpath_assertions, idx, "xpath")
exc = TaurusConfigError('XPath not found in assertion: %s' %
assertion)
query = assertion.get('xpath', exc)
parser_type = 'html' if assertion.get('use-tolerant-parser',
True) else 'xml'
validate = assertion.get('validate-xml', False)
method = "assert_not_xpath" if assertion.get(
'invert', False) else "assert_xpath"
line = "response.{method}({query}, parser_type={parser_type}, validate={validate})".format(
method=method,
query=repr(query),
validate=repr(validate),
parser_type=repr(parser_type),
)
test_method.append(self.gen_statement(line))
def __gen_assertion(self, task, assertion, is_first):
subject = assertion.get("subject", Scenario.FIELD_BODY)
values = [str(_assert) for _assert in assertion['contains']]
if subject == 'body':
content = 'response.content'
elif subject == 'http-code':
content = 'str(response.status_code)'
else:
raise TaurusConfigError('Wrong subject for Locust assertion: %s' %
subject)
if assertion.get('not', False):
attr_not = ''
func_name = 'any'
else:
attr_not = ' not'
func_name = 'all'
if assertion.get("regexp", True):
expression = 'findall(compile(str(val)), %(content)s)' % {
'content': content
}
else:
expression = 'str(val) in %s' % content
statement = 'if%(not)s %(func)s(%(expression)s for val in %(values)s):'
statement = statement % {
'not': attr_not,
'func': func_name,
'expression': expression,
'values': values
}
if not is_first:
statement = 'el' + statement
task.append(self.gen_statement(statement, indent=12))
statement = 'response.failure("%(values)s%(not)s found in %(subject)s")'
statement = statement % {
'values': values,
'not': attr_not,
'subject': subject
}
task.append(self.gen_statement(statement, indent=16))
def prepare(self):
"""
Read aggregation options
"""
super(ConsolidatingAggregator, self).prepare()
# make unique & sort
self.track_percentiles = self.settings.get("percentiles", self.track_percentiles)
self.track_percentiles = list(set(self.track_percentiles))
self.track_percentiles.sort()
self.settings["percentiles"] = self.track_percentiles
self.extend_aggregation = self.settings.get('extend-aggregation')
self.ignored_labels = self.settings.get("ignore-labels", self.ignored_labels)
self.generalize_labels = self.settings.get("generalize-labels", self.generalize_labels)
self.min_buffer_len = dehumanize_time(self.settings.get("min-buffer-len", self.min_buffer_len))
max_buffer_len = self.settings.get("max-buffer-len", self.max_buffer_len)
try:
self.max_buffer_len = dehumanize_time(max_buffer_len)
except TaurusInternalException as exc:
self.log.debug("Exception in dehumanize_time(%s): %s", max_buffer_len, exc)
raise TaurusConfigError("Wrong 'max-buffer-len' value: %s" % max_buffer_len)
self.buffer_multiplier = self.settings.get("buffer-multiplier", self.buffer_multiplier)
count = len(self.track_percentiles)
if count == 1:
self.buffer_scale_idx = str(float(self.track_percentiles[0]))
if count > 1:
percentile = self.settings.get("buffer-scale-choice", 0.5)
percentiles = [i / (count - 1.0) for i in range(count)]
distances = [abs(percentile - percentiles[i]) for i in range(count)]
index_position = distances.index(min(distances))
self.buffer_scale_idx = str(float(self.track_percentiles[index_position]))
debug_str = 'Buffer scaling setup: percentile %s from %s selected'
self.log.debug(debug_str, self.buffer_scale_idx, self.track_percentiles)
self.histogram_max = dehumanize_time(self.settings.get("histogram-initial", self.histogram_max))
self.max_error_count = self.settings.get("max-error-variety", self.max_error_count)
def __configure(self, configs):
if self.options.no_system_configs is None:
self.options.no_system_configs = False
load_hidden_configs = not self.options.no_system_configs
if load_hidden_configs:
bzt_rc = os.path.expanduser(os.path.join('~', ".bzt-rc"))
if os.path.exists(bzt_rc):
self.log.debug("Using personal config: %s" % bzt_rc)
else:
self.log.debug("Adding personal config: %s", bzt_rc)
self.log.info("No personal config found, creating one at %s",
bzt_rc)
shutil.copy(os.path.join(RESOURCES_DIR, 'base-bzt-rc.yml'),
bzt_rc)
configs.insert(0, bzt_rc)
self.log.info("Starting with configs: %s", configs)
merged_config = self.engine.configure(
configs, not self.options.no_system_configs)
# apply aliases
for alias in self.options.aliases:
cli_aliases = self.engine.config.get('cli-aliases')
keys = sorted(cli_aliases.keys())
err = TaurusConfigError(
"'%s' not found in aliases. Available aliases are: %s" %
(alias, ", ".join(keys)))
self.engine.config.merge(cli_aliases.get(alias, err))
if self.options.option:
overrider = ConfigOverrider(self.log)
overrider.apply_overrides(self.options.option, self.engine.config)
if self.__is_verbose():
CLI.console_handler.setLevel(logging.DEBUG)
self.engine.create_artifacts_dir(configs, merged_config)
self.engine.default_cwd = os.getcwd()
self.engine.set_pythonpath()
self.engine.eval_env(
) # yacky, I don't like having it here, but how to apply it after aliases and artif dir?
def prepare(self):
super(VegetaExecutor, self).prepare()
self.scenario = self.get_scenario()
self.install_required_tools()
self.script = self.get_script_path()
print(self.script)
if not self.script:
requests = self.scenario.get_requests()
if not requests:
raise TaurusConfigError(
"Either 'script' or 'scenario' should be present for Vegeta executor"
)
self.script = os.path.join(self.engine.artifacts_dir, "vegeta.txt")
with open(self.script, "w") as f:
i = 0
for request in requests:
f.write("{} {}\n".format(request.method, request.url))
headers = "\n".join([
"{}: {}".format(key, value)
for key, value in request.headers.items()
])
if headers:
f.write("{}\n".format(headers))
if request.body:
json_body_file = os.path.join(
self.engine.artifacts_dir,
"body-{}.json".format(i))
with open(json_body_file, "w") as g:
g.write(json.dumps(request.body))
f.write("@{}\n".format(json_body_file))
f.write("\n")
i += 1
self.stdout = open(self.engine.create_artifact("Vegeta", ".out"), "w")
self.stderr = open(self.engine.create_artifact("Vegeta", ".err"), "w")
self.kpi_file = self.engine.create_artifact("kpi", ".csv")
self.reader = VegetaLogReader(self.kpi_file, self.log)
if isinstance(self.engine.aggregator, ConsolidatingAggregator):
self.engine.aggregator.add_underling(self.reader)
def _get_publish_sampler(request):
mqtt = etree.Element("net.xmeter.samplers.PubSampler",
guiclass="net.xmeter.gui.PubSamplerUI",
testclass="net.xmeter.samplers.PubSampler",
testname=request.label)
topic_missed = TaurusConfigError(
f'Topic is required for request "{request.config}"')
mqtt.append(
JMX._string_prop("mqtt.topic_name",
request.config.get("topic", topic_missed)))
mqtt.append(JMX._string_prop("mqtt.qos_level", "0"))
mqtt.append(JMX._bool_prop("mqtt.add_timestamp", True))
mqtt.append(JMX._string_prop("mqtt.message_type", "String"))
mqtt.append(JMX._string_prop("mqtt.message_type_fixed_length", "1024"))
mqtt.append(
JMX._string_prop("mqtt.message_to_sent",
request.config.get("message", "")))
mqtt.append(JMX._bool_prop("mqtt.retained_message", False))
return mqtt
def load(self, configs, callback=None):
"""
Load and merge JSON/YAML files into current dict
:type callback: callable
:type configs: list[str]
"""
self.log.debug("Configs: %s", configs)
for config_file in configs:
try:
config = self.__read_file(config_file)
except IOError as exc:
raise TaurusConfigError(
"Error when reading config file '%s': %s" %
(config_file, exc))
self.merge(config)
if callback is not None:
callback(config_file)
def prepare(self):
super(Proxy2JMX, self).prepare()
self.output_simple = self.parameters.get(
"simple-output", self.settings.get("simple-output", None))
self.output_smart = self.parameters.get(
"smart-output", self.settings.get("smart-output", None))
blazemeter_cfg = self.engine.config.get("modules").get("blazemeter")
self.proxy.token = self.settings.get("token",
blazemeter_cfg.get("token"))
if not self.proxy.token:
msg = "You must provide your API token in settings of " \
"'proxy2jmx' or 'blazemeter' modules to use Proxy Recorder"
raise TaurusConfigError(msg)
self.proxy.address = self.settings.get(
"address", blazemeter_cfg.get("address", self.proxy.address))
# todo: handle network exceptions (ssl, ...) in next call
self.proxy_addr = self.proxy.get_addr()
def __read_file(self, filename):
"""
Read and parse config file
:param filename: str
:return: list
"""
with open(filename) as fds:
first_line = "#"
while first_line.startswith("#"):
first_line = fds.readline().strip()
fds.seek(0)
if first_line.startswith('---'):
self.log.debug("Reading %s as YAML", filename)
return yaml.load(fds)
elif first_line.strip().startswith('{'):
self.log.debug("Reading %s as JSON", filename)
return json.loads(fds.read())
else:
raise TaurusConfigError("Cannot detect file format for %s" % filename)
def prepare(self):
super(Proxy2JMX, self).prepare()
token = self.settings.get('token')
if not token:
token = self.engine.config.get('modules').get('blazemeter').get(
'token')
if not token:
msg = "You must provide your API token in settings of " \
"'proxy2jmx' or 'blazemeter' modules to use Proxy Recorder"
raise TaurusConfigError(msg)
self.proxy.token = token
bm_api_addr = self.engine.config.get('modules').get('blazemeter').get(
'address', self.proxy.address)
api_addr = self.settings.get('address', bm_api_addr)
self.proxy.address = api_addr
# todo: handle network exceptions (ssl, ...) in next call
self.proxy_addr = self.proxy.get_addr()
def prepare(self):
super(ApiritifNoseExecutor, self).prepare()
self.script = self.get_script_path()
if not self.script:
if "requests" in self.get_scenario():
self.script = self.__tests_from_requests()
else:
raise TaurusConfigError("Nothing to test, no requests were provided in scenario")
# todo: requred tools?
# path to taurus dir. It's necessary for bzt usage inside tools/helpers
self.env.add_path({"PYTHONPATH": get_full_path(BZT_DIR, step_up=1)})
if self.settings.get("plugins-path"):
# add path to plugins directory to Apiritif env vars
self.log.debug(f'Found Apiritif plugins path: {self.settings.get("plugins-path")}')
self.env.add_path({"PLUGINS_PATH": self.settings.get('plugins-path')})
self.reporting_setup() # no prefix/suffix because we don't fully control report file names
def get_load(self):
"""
Helper method to read load specification
"""
prov_type = self.engine.config.get(Provisioning.PROV)
ensure_is_dict(self.execution, ScenarioExecutor.THRPT, prov_type)
throughput = self.execution[ScenarioExecutor.THRPT].get(prov_type, 0)
ensure_is_dict(self.execution, ScenarioExecutor.CONCURR, prov_type)
concurrency = self.execution[ScenarioExecutor.CONCURR].get(prov_type, 0)
iterations = self.execution.get("iterations", None)
ramp_up = self.execution.get(ScenarioExecutor.RAMP_UP, None)
steps = self.execution.get(ScenarioExecutor.STEPS, None)
hold = dehumanize_time(self.execution.get(ScenarioExecutor.HOLD_FOR, 0))
if ramp_up is None:
duration = hold
else:
ramp_up = dehumanize_time(ramp_up)
duration = hold + ramp_up
if duration and not iterations:
iterations = 0 # which means infinite
msg = ''
if not isinstance(concurrency, numeric_types + (type(None),)):
msg += "Invalid concurrency value[%s]: %s " % (type(concurrency).__name__, concurrency)
if not isinstance(throughput, numeric_types + (type(None),)):
msg += "Invalid throughput value[%s]: %s " % (type(throughput).__name__, throughput)
if not isinstance(steps, numeric_types + (type(None),)):
msg += "Invalid throughput value[%s]: %s " % (type(steps).__name__, steps)
if not isinstance(iterations, numeric_types + (type(None),)):
msg += "Invalid throughput value[%s]: %s " % (type(iterations).__name__, iterations)
if msg:
raise TaurusConfigError(msg)
return self.LOAD_FMT(concurrency=concurrency, ramp_up=ramp_up, throughput=throughput, hold=hold,
iterations=iterations, duration=duration, steps=steps)
def prepare(self):
self.install_required_tools()
scenario = self.get_scenario()
cpath = self.get_additional_classpath()
self.log.debug("Classpath for Gatling: %s", cpath)
for element in cpath:
self.env.add_path({"JAVA_CLASSPATH": element})
self.env.add_path({"COMPILATION_CLASSPATH": element})
if is_windows() or cpath:
self.log.debug("Building Gatling launcher")
self.launcher = self.__build_launcher()
else:
self.log.debug("Will not build Gatling launcher")
self.launcher = self.settings["path"]
self.script = self.get_script_path()
if not self.script:
if "requests" in scenario:
self.get_scenario(
)['simulation'], self.script = self.__generate_script()
self.__copy_data_sources()
else:
msg = "There must be a script file or requests for its generation "
msg += "to run Gatling tool (%s)" % self.execution.get(
'scenario')
raise TaurusConfigError(msg)
self.dir_prefix = self.settings.get("dir-prefix", self.dir_prefix)
out = self.engine.create_artifact("gatling-stdout", ".log")
err = self.engine.create_artifact("gatling-stderr", ".log")
self.stdout = open(out, "w")
self.stderr = open(err, "w")
self.reader = DataLogReader(self.engine.artifacts_dir, self.log,
self.dir_prefix)
if isinstance(self.engine.aggregator, ConsolidatingAggregator):
self.engine.aggregator.add_underling(self.reader)