def os_run(command, status=False, print_stdout=False, print_line_check=None):
if status:
print("Running '{}'".format(command))
try:
if not print_stdout:
proc = os_return(command, status=False)
(stdout, strerr) = proc.communicate()
if proc.returncode != 0:
tools.system_exit({
'code': proc.returncode,
'message': "{}".format(strerr)
})
return
else:
#subprocess.run(parse_command(command), check = True)
print(colorama.Style.RESET_ALL)
asyncio.get_event_loop().run_until_complete(
run_async(command, print_line_check))
print(colorama.Style.RESET_ALL)
return True
except subprocess.CalledProcessError as err:
tools.system_exit({
'code': err.returncode,
'message': "{}".format(err)
})
return False
def postman(file, filter, output_to_json, grouping, delay):
"""EXAMPLE: nlc import postman --filter='name=GET Request' -f exported_collection.json
"""
if not (file and len(file) > 0):
raise cli_exception.CliException("You must use the --file option")
data = None
if is_url(file):
logging.debug("Import file is a URL")
resp = requests.get(file, stream=True)
data = json.load(io.BytesIO(resp.content))
else:
file = os.path.expanduser(file)
if os.path.exists(file):
with open(file) as stm:
data = json.load(stm)
else:
logging.debug("Import file does not exist")
if data is None:
tools.system_exit({
'code': 1,
'message': 'Could not determine data to import'
})
return
filter_parsed = parse_filter_spec(filter)
build = builder_data.BuilderData()
options = {}
options[wrap_requests_in_transactions] = (grouping == "NONE")
options[delay_in_seconds] = delay
options[add_javascript_lib_postman] = False
version = None
if 'info' in data and 'schema' in data['info']:
schema = data['info']['schema']
version = re.search(r"/v(.*?)/", schema).group(1)
if version and version.startswith("2."):
#add_headers(build, get_auth_headers(data), all=True)
process_postman_v2(build, data, filter_parsed, options)
if options[add_javascript_lib_postman] == True:
build.add(
builder_data.VariableTypeJavascript(
name=javascript_lib_postman_var_name,
description=
'A javascript library for running postman tests using the Node sidecar',
script=get_postman_var_script_source(),
change_policy='each_use'))
builder_data.save(build)
output = build if output_to_json else builder_data.convert_builder_to_yaml(
build)
#output = builder_data.get() if output_to_json else builder_data.convert_builder_to_yaml(builder_data.get())
print(output)
def cli(ctx, file):
"""Uses the local NeoLoad installation to try a project
"""
builder_data.register_context(ctx, auto_reset=False)
yaml_str = None
if file is None:
yaml_str = builder_data.convert_builder_to_yaml(builder_data.get())
else:
yaml_str = open(file, encoding="UTF-8").read()
full_path = None
tmp = tempfile.TemporaryDirectory()
dir = tmp.name
full_path = builder_data.write_to_path(dir, yaml_str)
nlg_app = find_nlg_app()
event = SubprocessEvent()
do_it = lambda app=nlg_app, project=full_path, event=event: launch_app(app,project,event)
action_thread = Thread(target=do_it)
# Here we start the thread and we wait 5 seconds before the code continues to execute.
action_thread.start()
action_thread.join(timeout=20)
# We send a signal that the other thread should stop.
event.set()
msg = "This test project is valid."
retcode = event.proc.returncode if event.proc is not None else 0
logging.debug("EXIT_CODE: {}".format(retcode))
if retcode is not None and retcode != 0:
if event.stdout is not None:
msg = event.stdout.decode("UTF-8")
else:
msg = "Check console for error details."
if retcode is None:
event.proc.kill()
tools.system_exit({'code': 0 if retcode is None else retcode,'message':msg})
return
def per_interval(avg_resp_time, avg_elt_per_sec, avg_throughput_per_sec,
errors_per_sec, error_rate, warn, fail):
"""Create a per-interval threshold
"""
if not (avg_resp_time or avg_elt_per_sec or avg_throughput_per_sec
or errors_per_sec or error_rate):
tools.system_exit({
'code': 1,
'message': "At least one KPY flag must be provided"
})
return
if warn is None and fail is None:
tools.system_exit({
'code':
1,
'message':
"Either one or both 'warn' and 'fail' flags must be provided"
})
return
global current_name
builder = builder_data.get() \
.add(builder_data.SLAThreshold(
name=current_name,
scope="per interval",
warn=warn,
fail=fail,
kpis={
'avg-resp-time': avg_resp_time,
'avg-elt-per-sec': avg_elt_per_sec,
'avg-throughput-per-sec': avg_throughput_per_sec,
'errors-per-sec': errors_per_sec,
'error-rate': error_rate
}
)
) \
.save()
def cli(ctx, name_or_id, zone, scenario, save, just_report_last):
"""Runs whatever is in the current buffer
"""
builder_data.register_context(ctx, auto_reset=False)
neoload_base_cmd = "neoload " + ("--debug " if common.get_debug() else "")
template = get_resource(__name__,
"resources/dist/jinja/builtin-console-summary.j2")
if template is not None:
logging.debug("Using template: {}".format(template))
if not just_report_last:
if name_or_id and save:
config.test_setting(name_or_id)
if zone and save:
config.zone(zone)
if not name_or_id:
name_or_id = profile.get().default_test_setting
if not name_or_id:
tools.system_exit({
'code':
3,
'message':
"No test settings [name_or_id] provided and no default test-setting configured!"
})
return
if not zone:
zone = profile.get().default_zone
if zone == "any":
proc = os_return(neoload_base_cmd + " zones", status=False)
(stdout, strerr) = proc.communicate()
result = json.loads(stdout)
availables = list(
filter(
lambda z: any(
filter(lambda c: c['status'] == "AVAILABLE", z[
'controllers'])) and any(
filter(lambda lg: lg['status'] == "AVAILABLE",
z['loadgenerators'])), result))
if len(availables) > 0:
availables = sorted(availables,
key=lambda z: 0
if z['type'] == "STATIC" else 1)
zone = availables[0]['id']
print(
"Because zone is 'any', the zone '{}' ({}) has been automatically selected."
.format(zone, availables[0]['name']))
else:
tools.system_exit({
'code':
3,
'message':
"There are no zones with available load generators and controllers!!!"
})
return
if not zone:
tools.system_exit({
'code':
3,
'message':
"No --zone provided and no default zone configured!"
})
return
if not os_run(neoload_base_cmd + " status", status=False):
return
yaml_str = builder_data.convert_builder_to_yaml(builder_data.get())
data = yaml.safe_load(yaml_str)
if not scenario:
scenario = data['scenarios'][0]['name']
dir = None
with tempfile.TemporaryDirectory() as tmp:
dir = tmp
builder_data.write_to_path(dir, yaml_str)
if not os_run(
neoload_base_cmd +
" test-settings --zone {} --lgs 1 --scenario {} createorpatch {}"
.format(zone, scenario, name_or_id),
status=True):
return
if not os_run(
neoload_base_cmd + " project --path {} up".format(dir),
status=True):
return
if not os_run(neoload_base_cmd + " run".format(scenario),
print_stdout=True,
print_line_check=check_run_line):
print("Test failed.")
proc = os_return(neoload_base_cmd + " report --help", status=False)
(stdout, strerr) = proc.communicate()
outtext = stdout.decode("UTF-8")
if proc.returncode != 0 or 'Error:' in outtext or 'failed to start' in outtext:
print(
"Test ran, but could not produce final (pretty) report. {}".format(
"" if strerr is None else strerr))
else:
if template is not None:
if not os_run(
neoload_base_cmd +
" report --template {} --filter '{}' cur".format(
template,
'exclude=events,slas,all_requests,ext_data,controller_points'
),
status=True,
print_stdout=True):
return