def export_stubs(handler, scenario_name):
from stubo.model.exporter import YAML_FORMAT_SUBDIR
# export stubs in the old format
command_links = export_stubs_to_commands_format(handler, scenario_name)
# continue stub export in the new format
cache = Cache(get_hostname(handler.request))
scenario_name_key = cache.scenario_key_name(scenario_name)
exporter = Exporter(static_dir=handler.settings['static_path'])
runnable = asbool(handler.get_argument('runnable', False))
playback_session = handler.get_argument('playback_session', None)
export_dir_path, files, runnable_info = exporter.export(
scenario_name_key,
runnable=runnable,
playback_session=playback_session,
session_id=handler.get_argument('session_id', None),
export_dir=handler.get_argument('export_dir', None))
# getting export links
yaml_links = get_export_links(handler,
scenario_name_key + "/" + YAML_FORMAT_SUBDIR,
files)
payload = dict(scenario=scenario_name,
export_dir_path=export_dir_path,
command_links=command_links,
yaml_links=yaml_links)
if runnable_info:
payload['runnable'] = runnable_info
return dict(version=version, data=payload)
def get_status(handler):
"""Check status.
query args:
scenario=name
session=name
check_database=true|false (default true)
local_cache=true|false (default true)
"""
request = handler.request
cache = Cache(get_hostname(request))
response = dict(version=version, data={})
args = dict(
(key, value[0]) for key, value in request.arguments.iteritems())
local_cache = asbool(args.get('local_cache', True))
redis_server = get_redis_server(local_cache)
response['data']['cache_server'] = {'local': local_cache}
response['data']['info'] = {
'cluster': handler.settings.get('cluster_name'),
'graphite_host': handler.settings.get('graphite.host')
}
try:
result = redis_server.ping()
response['data']['cache_server']['status'] = 'ok' if result else 'bad'
except Exception, e:
response['data']['cache_server']['status'] = 'bad'
response['data']['cache_server']['error'] = str(e)
return response
def export_stubs(handler, scenario_name):
from stubo.model.exporter import YAML_FORMAT_SUBDIR
# export stubs in the old format
command_links = export_stubs_to_commands_format(handler, scenario_name)
# continue stub export in the new format
cache = Cache(get_hostname(handler.request))
scenario_name_key = cache.scenario_key_name(scenario_name)
exporter = Exporter(static_dir = handler.settings['static_path'])
runnable = asbool(handler.get_argument('runnable', False))
playback_session = handler.get_argument('playback_session', None)
export_dir_path, files, runnable_info = exporter.export(scenario_name_key,
runnable=runnable,
playback_session=playback_session,
session_id=handler.get_argument('session_id', None),
export_dir=handler.get_argument('export_dir', None))
# getting export links
yaml_links = get_export_links(handler, scenario_name_key+"/"+YAML_FORMAT_SUBDIR, files)
payload = dict(scenario=scenario_name, export_dir_path=export_dir_path,
command_links=command_links, yaml_links=yaml_links)
if runnable_info:
payload['runnable'] = runnable_info
return dict(version=version, data=payload)
def get_status(handler):
"""Check status.
query args:
scenario=name
session=name
check_database=true|false (default true)
local_cache=true|false (default true)
"""
request = handler.request
cache = Cache(get_hostname(request))
response = dict(version=version, data={})
args = dict((key, value[0]) for key, value in request.arguments.iteritems())
local_cache = asbool(args.get('local_cache', True))
redis_server = get_redis_server(local_cache)
response['data']['cache_server'] = {'local' : local_cache}
response['data']['info'] = {
'cluster' : handler.settings.get('cluster_name'),
'graphite_host' : handler.settings.get('graphite.host')
}
try:
result = redis_server.ping()
response['data']['cache_server']['status'] = 'ok' if result else 'bad'
except Exception, e:
response['data']['cache_server']['status'] = 'bad'
response['data']['cache_server']['error'] = str(e)
return response
def _begin_session(self):
"""
Begins session
:raise exception_response:
Example output:
Record new session
{
"version": "0.6.3",
"data":
{"status": "record",
"scenario": "localhost:scenario_rest_api",
"scenarioRef": "/stubo/api/v2/scenarios/objects/localhost:scenario_rest_api",
"scenario_id": "55acba53fc456205eaf7e258",
"session": "new_session_rest2",
"message": "Record mode initiated...."}
}
"""
warm_cache = asbool(self.get_argument('warm_cache', False))
if not self.mode:
raise exception_response(
400, title="'mode' of playback or record required")
# passing parameters to api v2 handler, it avoids creating scenario if there is an existing one,
# since all scenarios should be existing!
response = api_v2_begin_session(self, self.scenario_name,
self.session_name, self.mode,
self.get_argument('system_date',
None), warm_cache)
# adding scenarioRef key for easier resource access.
response['data'][
'scenarioRef'] = '/stubo/api/v2/scenarios/objects/%s' % response[
'data']['scenario']
self.write(response)
def _begin_session(self):
"""
Begins session
:raise exception_response:
Example output:
Record new session
{
"version": "0.6.3",
"data":
{"status": "record",
"scenario": "localhost:scenario_rest_api",
"scenarioRef": "/stubo/api/v2/scenarios/objects/localhost:scenario_rest_api",
"scenario_id": "55acba53fc456205eaf7e258",
"session": "new_session_rest2",
"message": "Record mode initiated...."}
}
"""
warm_cache = asbool(self.get_argument('warm_cache', False))
if not self.mode:
raise exception_response(400,
title="'mode' of playback or record required")
# passing parameters to api v2 handler, it avoids creating scenario if there is an existing one,
# since all scenarios should be existing!
response = api_v2_begin_session(self, self.scenario_name,
self.session_name,
self.mode,
self.get_argument('system_date', None),
warm_cache)
# adding scenarioRef key for easier resource access.
response['data']['scenarioRef'] = '/stubo/api/v2/scenarios/objects/%s' % response['data']['scenario']
self.write(response)
def export_stubs_request(handler):
scenario_name = get_scenario_arg(handler)
response = export_stubs(handler, scenario_name)
html = asbool(handler.get_argument('html', False))
if html:
response = handler.render_string("export_stubs.html",
page_title='Exported Stubs',
**response['data'])
return response
def begin_session_request(handler):
scenario = handler.track.scenario = get_scenario_arg(handler)
session = get_session_arg(handler)
mode = handler.get_argument('mode', None)
warm_cache = asbool(handler.get_argument('warm_cache', False))
if not mode:
raise exception_response(400,
title="'mode' of playback or record required")
return begin_session(handler, scenario, session, mode,
handler.get_argument('system_date', None), warm_cache)
def begin_session_request(handler):
scenario = handler.track.scenario = get_scenario_arg(handler)
session = get_session_arg(handler)
mode = handler.get_argument('mode', None)
warm_cache = asbool(handler.get_argument('warm_cache', False))
if not mode:
raise exception_response(400,
title="'mode' of playback or record required")
return begin_session(handler, scenario, session, mode,
handler.get_argument('system_date', None), warm_cache)
def export_stubs_request(handler):
scenario_name = get_scenario_arg(handler)
handler.track.scenario = scenario_name
response = export_stubs(handler, scenario_name)
html = asbool(handler.get_argument('html', False))
if html:
payload = response['data']
title = 'Exported files for Scenario'
if 'runnable' in payload:
title = 'Exported files for Runnable Scenario'
response = handler.render_string("export_stubs.html",
page_title=title, **payload)
return response
def export_stubs_request(handler):
scenario_name = get_scenario_arg(handler)
handler.track.scenario = scenario_name
response = export_stubs(handler, scenario_name)
html = asbool(handler.get_argument('html', False))
if html:
payload = response['data']
title = 'Exported files for Scenario'
if 'runnable' in payload:
title = 'Exported files for Runnable Scenario'
response = handler.render_string("export_stubs.html",
page_title=title, **payload)
return response
def put_stub_request(handler):
session = get_session_arg(handler)
delay_policy = handler.get_argument('delay_policy', None)
stateful = asbool(handler.get_argument('stateful', True))
recorded = handler.get_argument('stub_created_date', None)
module_name = handler.get_argument('ext_module', None)
if not module_name:
# legacy
module_name = handler.get_argument('stubbedSystem', None)
recorded_module_system_date = handler.get_argument('stubbedSystemDate',
None)
priority = int(handler.get_argument('priority', -1))
return put_stub(handler, session, delay_policy=delay_policy,
stateful=stateful, priority=priority, recorded=recorded,
module_name=module_name,
recorded_module_system_date=recorded_module_system_date)
def put_stub_request(handler):
session = get_session_arg(handler)
delay_policy = handler.get_argument('delay_policy', None)
stateful = asbool(handler.get_argument('stateful', True))
recorded = handler.get_argument('stub_created_date', None)
module_name = handler.get_argument('ext_module', None)
if not module_name:
# legacy
module_name = handler.get_argument('stubbedSystem', None)
recorded_module_system_date = handler.get_argument('stubbedSystemDate',
None)
priority = int(handler.get_argument('priority', -1))
return put_stub(handler, session, delay_policy=delay_policy,
stateful=stateful, priority=priority, recorded=recorded,
module_name=module_name,
recorded_module_system_date=recorded_module_system_date)
def __init__(self, config_path):
cfg = ObjectDict(read_config(config_path))
cfg.db_name = cfg['mongo.db']
cfg['num_processes'] = int(cfg.get('num_processes', 0))
cfg['stubo_version'] = version
cfg['debug'] = asbool(cfg.get('debug', False))
max_workers = int(cfg.get('max_workers', 100))
log.info('started with {0} worker threads'.format(max_workers))
cfg['executor'] = ThreadPoolExecutor(max_workers)
try:
cfg['statsd_client'] = StatsClient(host=cfg.get('statsd.host',
'localhost'), prefix=cfg.get('statsd.prefix', 'stubo'))
cfg['stats'] = StatsdStats()
log.info('statsd host addr={0}, prefix={1}'.format(
cfg['statsd_client']._addr, cfg['statsd_client']._prefix))
except socket.gaierror, e:
log.warn("unable to connect to statsd: {0}".format(e))
def put_stub_request(request):
session = get_session_arg(request)
delay_policy = request.get_argument('delay_policy', None)
stateful = asbool(request.get_argument('stateful', True))
recorded = request.get_argument('stub_created_date', None)
module_name = request.get_argument('ext_module', None)
if not module_name:
# legacy
module_name = request.get_argument('stubbedSystem', None)
recorded_module_system_date = request.get_argument('stubbedSystemDate',
None)
return put_stub(request,
session,
delay_policy=delay_policy,
stateful=stateful,
recorded=recorded,
module_name=module_name,
recorded_module_system_date=recorded_module_system_date)
def export_stubs(handler, scenario_name):
cache = Cache(get_hostname(handler.request))
scenario_name_key = cache.scenario_key_name(scenario_name)
exporter = Exporter(static_dir = handler.settings['static_path'])
runnable = asbool(handler.get_argument('runnable', False))
playback_session = handler.get_argument('playback_session', None)
export_dir_path, files, runnable_info = exporter.export(scenario_name_key,
runnable=runnable,
playback_session=playback_session,
session_id=handler.get_argument('session_id', None),
export_dir=handler.get_argument('export_dir', None))
links = get_export_links(handler, scenario_name_key, files)
payload = dict(scenario=scenario_name, export_dir_path=export_dir_path,
links=links)
if runnable_info:
payload['runnable'] = runnable_info
return dict(version=version, data=payload)
def manage_request_api(handler):
"""
Generate data for /manage page.
:param handler: instance of RequestHandler or TrackRequest
:return: dictionary with information about stubo instance - modules, delays, sessions..
"""
cache = Cache(get_hostname(handler.request))
action = handler.get_argument('action', None)
all_hosts = asbool(handler.get_argument("all_hosts", False))
message = error_message = ""
module_info = {}
if action is not None:
# handle btn action
try:
name = handler.get_argument('name')
# It would be nice to really track these actions
handler.track = DummyModel()
if action == 'delete':
_type = handler.get_argument('type')
if _type == 'module':
result = delete_module(handler.request, [name])
elif _type == 'delay_policy':
result = delete_delay_policy(handler, [name])
elif _type == 'stubs':
result = delete_stubs(handler,
scenario_name=name,
host=all_hosts)
else:
result = 'error: unexpected action type={0}'.format(_type)
elif action == 'end_sessions':
result = end_sessions(handler, name)
else:
result = 'error: unexpected action={0}'.format(action)
if 'error' not in result:
message = result
else:
error_message = result
except MissingArgumentError, e:
error_message = "Error: {0}".format(e)
except StuboException, e:
error_message = "Error: {0}".format(e.title)
def __init__(self, config_path):
cfg = ObjectDict(read_config(config_path))
cfg.db_name = cfg["mongo.db"]
cfg["num_processes"] = int(cfg.get("num_processes", 0))
cfg["stubo_version"] = version
cfg["debug"] = asbool(cfg.get("debug", False))
max_workers = int(cfg.get("max_workers", 100))
log.info("started with {0} worker threads".format(max_workers))
cfg["executor"] = ThreadPoolExecutor(max_workers)
try:
cfg["statsd_client"] = StatsClient(
host=cfg.get("statsd.host", "localhost"), prefix=cfg.get("statsd.prefix", "stubo")
)
cfg["stats"] = StatsdStats()
log.info(
"statsd host addr={0}, prefix={1}".format(cfg["statsd_client"]._addr, cfg["statsd_client"]._prefix)
)
except socket.gaierror, e:
log.warn("unable to connect to statsd: {0}".format(e))
def delete(self, scenario_name):
"""
Deletes specified scenario. If force is not supplied - checks for active sessions and if there are any - stops
deletion. If force is supplied or there are no active sessions - deletes all stubs for scenario
:param scenario_name:
:return:
"""
response = {
'version': version
}
# checking for supplied headers
host = None
force = False
if 'target_host' in self.request.headers:
host = self.request.headers['target_host']
if 'force' in self.request.headers:
force = asbool(self.request.headers['force'])
# getting full scenario database
scenario_name = _get_scenario_full_name(self, scenario_name, host)
host, scenario = scenario_name.split(':')
cache = Cache(host)
# if force is False or absent - checking for active sessions and if there are any - aborting deletion
if not force:
active_sessions = cache.get_active_sessions(scenario,
local=False)
if active_sessions:
self.set_status(409)
error = 'Sessons in playback/record, can not delete. Found the ' \
'following active sessions: {0} for scenario: {1}'.format(active_sessions, scenario_name)
response['error'] = error
self.write(response)
return
# asynchronous deletion of stubs, returns two params - "ok" and "n" (deleted items count)
result = yield self.db.scenario_stub.remove({'scenario': scenario_name})
# deleting scenario from cache
cache.delete_caches(scenario)
response['data'] = "Deleted stubs count: %s" % result['n']
self.write(response)
def manage_request_api(handler):
"""
Generate data for /manage page.
:param handler: instance of RequestHandler or TrackRequest
:return: dictionary with information about stubo instance - modules, delays, sessions..
"""
cache = Cache(get_hostname(handler.request))
action = handler.get_argument('action', None)
all_hosts = asbool(handler.get_argument("all_hosts", False))
message = error_message = ""
module_info = {}
if action is not None:
# handle btn action
try:
name = handler.get_argument('name')
# It would be nice to really track these actions
handler.track = DummyModel()
if action == 'delete':
_type = handler.get_argument('type')
if _type == 'module':
result = delete_module(handler.request, [name])
elif _type == 'delay_policy':
result = delete_delay_policy(handler, [name])
elif _type == 'stubs':
result = delete_stubs(handler, scenario_name=name,
host=all_hosts)
else:
result = 'error: unexpected action type={0}'.format(_type)
elif action == 'end_sessions':
result = end_sessions(handler, name)
else:
result = 'error: unexpected action={0}'.format(action)
if 'error' not in result:
message = result
else:
error_message = result
except MissingArgumentError, e:
error_message = "Error: {0}".format(e)
except StuboException, e:
error_message = "Error: {0}".format(e.title)
def export_stubs(handler, scenario_name):
cache = Cache(get_hostname(handler.request))
scenario_name_key = cache.scenario_key_name(scenario_name)
exporter = Exporter(static_dir=handler.settings['static_path'])
runnable = asbool(handler.get_argument('runnable', False))
playback_session = handler.get_argument('playback_session', None)
export_dir_path, files, runnable_info = exporter.export(
scenario_name_key,
runnable=runnable,
playback_session=playback_session,
session_id=handler.get_argument('session_id', None),
export_dir=handler.get_argument('export_dir', None))
links = get_export_links(handler, scenario_name_key, files)
payload = dict(scenario=scenario_name,
export_dir_path=export_dir_path,
links=links)
if runnable_info:
payload['runnable'] = runnable_info
return dict(version=version, data=payload)
def delete(self, scenario_name):
"""
Deletes specified scenario. If force is not supplied - checks for active sessions and if there are any - stops
deletion. If force is supplied or there are no active sessions - deletes all stubs for scenario
:param scenario_name:
:return:
"""
response = {'version': version}
# checking for supplied headers
host = None
force = False
if 'target_host' in self.request.headers:
host = self.request.headers['target_host']
if 'force' in self.request.headers:
force = asbool(self.request.headers['force'])
# getting full scenario database
scenario_name = _get_scenario_full_name(self, scenario_name, host)
host, scenario = scenario_name.split(':')
cache = Cache(host)
# if force is False or absent - checking for active sessions and if there are any - aborting deletion
if not force:
active_sessions = cache.get_active_sessions(scenario, local=False)
if active_sessions:
self.set_status(409)
error = 'Sessons in playback/record, can not delete. Found the ' \
'following active sessions: {0} for scenario: {1}'.format(active_sessions, scenario_name)
response['error'] = error
self.write(response)
return
# asynchronous deletion of stubs, returns two params - "ok" and "n" (deleted items count)
result = yield self.db.scenario_stub.remove(
{'scenario': scenario_name})
# deleting scenario from cache
cache.delete_caches(scenario)
response['data'] = "Deleted stubs count: %s" % result['n']
self.write(response)
def coerce_mongo_param(k, v):
if k in ('port', 'max_pool_size'):
return int(v)
elif k in ('tz_aware',):
return asbool(v)
return v
def tracker_request(handler):
http_req = handler.request
host = http_req.host.split(":")[0]
scenario_filter = handler.get_argument('scenario_filter', '')
session_filter = handler.get_argument('session_filter', '')
start_time = handler.get_argument('start_time', '')
latency = int(handler.get_argument('latency', 0))
show_only_errors = asbool(handler.get_argument("show_only_errors",
False))
all_hosts = asbool(handler.get_argument("all_hosts", False))
function = handler.get_argument('function', 'all')
skip = int(handler.get_argument('skip', 0))
limit = int(handler.get_argument('limit', 100))
results = get_tracks(handler, scenario_filter, session_filter, show_only_errors, skip,
limit, start_time, latency, all_hosts, function)
total_tracks = results.count()
log.debug('track count: {0}'.format(total_tracks))
def format_response(stubo_response):
if isinstance(stubo_response, dict) and 'version' in stubo_response:
# assume it's one of ours
if 'data' in stubo_response:
stubo_response = stubo_response['data'].get('message')
elif 'error' in stubo_response:
error = stubo_response['error']
if isinstance(error, dict):
stubo_response = 'message: <em>{0}</em>'.format(
error.get('message'))
else:
stubo_response = error
if not stubo_response:
stubo_response = ""
return stubo_response
uri = handler.request.uri
urlargs = parse_qs(urlparse(uri).query)
urlargs.pop('limit', None)
urlargs.pop('skip', None)
query = '&'.join('{0}={1}'.format(k, v[0]) for k, v in urlargs.items())
def pagination(total_tracks, skip, limit, url_params):
page_no = int(skip/float(limit))+1
total_pages = int(float(total_tracks)/limit)+1
page_class = 'disabled' if page_no >= total_pages else ''
previous_page_class = 'disabled' if page_no <= 1 else ''
if page_no > 1:
prev_pg = '<a href="/tracker?skip=' + str(skip-limit) + \
'&limit=' + str(limit) + '&' + url_params + \
'"><<<</a>'
else:
prev_pg = ""
if page_no < total_pages:
next_pg = '<a href="/tracker?skip=' + str(skip+limit) + \
'&limit=' + str(limit) + '&' + url_params + \
'">>>></a>'
else:
next_pg = ""
return """
<div class="pagination pagination-right">
{8} <span>Page {3} of {4}</span> {9}
</div>""".format(skip+limit, limit, url_params, page_no,
total_pages, page_class, previous_page_class, skip-limit,
prev_pg, next_pg)
def get_option(option, function):
return '<option{0}>{1}</option>'.format(' selected="selected"' \
if option == function else "", option)
response = dict(raw_data=results,
scenario_filter=scenario_filter,
session_filter=session_filter,
errors_value='checked' if show_only_errors else '',
pagination=pagination(total_tracks, skip, limit, query),
start_time=start_time,
latency=latency or 0,
function_options="\n".join(get_option(x, function) \
for x in ['all'] + sorted(verbs)),
stubo_version=version,
host=host,
format_response=format_response,
max_response=TrackRequest.max_response_size,
total=total_tracks)
return handler.render_string("tracker.html", **response)
def tracker_request(handler):
http_req = handler.request
host = http_req.host.split(":")[0]
scenario_filter = handler.get_argument('scenario_filter', '')
session_filter = handler.get_argument('session_filter', '')
start_time = handler.get_argument('start_time', '')
latency = int(handler.get_argument('latency', 0))
show_only_errors = asbool(handler.get_argument("show_only_errors", False))
all_hosts = asbool(handler.get_argument("all_hosts", False))
function = handler.get_argument('function', 'all')
skip = int(handler.get_argument('skip', 0))
limit = int(handler.get_argument('limit', 100))
results = get_tracks(handler, scenario_filter, session_filter,
show_only_errors, skip, limit, start_time, latency,
all_hosts, function)
total_tracks = results.count()
log.debug('track count: {0}'.format(total_tracks))
def format_response(stubo_response):
if isinstance(stubo_response, dict) and 'version' in stubo_response:
# assume it's one of ours
if 'data' in stubo_response:
stubo_response = stubo_response['data'].get('message')
elif 'error' in stubo_response:
error = stubo_response['error']
if isinstance(error, dict):
stubo_response = 'message: <em>{0}</em>'.format(
error.get('message'))
else:
stubo_response = error
if not stubo_response:
stubo_response = ""
return stubo_response
uri = handler.request.uri
urlargs = parse_qs(urlparse(uri).query)
urlargs.pop('limit', None)
urlargs.pop('skip', None)
query = '&'.join('{0}={1}'.format(k, v[0]) for k, v in urlargs.items())
def pagination(total_tracks, skip, limit, url_params):
page_no = int(skip / float(limit)) + 1
total_pages = int(float(total_tracks) / limit) + 1
page_class = 'disabled' if page_no >= total_pages else ''
previous_page_class = 'disabled' if page_no <= 1 else ''
if page_no > 1:
prev_pg = '<a href="/tracker?skip=' + str(skip - limit) + \
'&limit=' + str(limit) + '&' + url_params + \
'"><<<</a>'
else:
prev_pg = ""
if page_no < total_pages:
next_pg = '<a href="/tracker?skip=' + str(skip + limit) + \
'&limit=' + str(limit) + '&' + url_params + \
'">>>></a>'
else:
next_pg = ""
return """
<div class="pagination pagination-right">
{8} <span>Page {3} of {4}</span> {9}
</div>""".format(skip + limit, limit, url_params, page_no, total_pages,
page_class, previous_page_class, skip - limit, prev_pg,
next_pg)
def get_option(option, function):
return '<option{0}>{1}</option>'.format(' selected="selected"' \
if option == function else "", option)
response = dict(raw_data=results,
scenario_filter=scenario_filter,
session_filter=session_filter,
errors_value='checked' if show_only_errors else '',
pagination=pagination(total_tracks, skip, limit, query),
start_time=start_time,
latency=latency or 0,
function_options="\n".join(get_option(x, function) \
for x in ['all'] + sorted(verbs)),
stubo_version=version,
host=host,
format_response=format_response,
max_response=TrackRequest.max_response_size,
total=total_tracks)
return handler.render_string("tracker.html", **response)
def delete_stubs_request(handler):
return delete_stubs(handler,
scenario_name=handler.get_argument('scenario', None),
host=handler.get_argument('host', None),
force=asbool(handler.get_argument('force', False)))
def blacklisted(self):
return asbool(self.get_stubo_setting('blacklisted'))
def put(self, scenario_name):
"""
Inserts stub into selected scenario
Example request headers:
session: session_test
Example request JSON body:
{
"request": {
"method": "POST",
"bodyPatterns": [
{ "contains": ["<status>IS_OK2</status>"] }
]
},
"response": {
"status": 200,
"body": "<response>YES</response>"
}
}
Example output:
{
version: "0.6.6"
data: {
message: "updated with stateful response"
}-
}
or:
{
version: "0.6.6"
data: {
message: "inserted scenario_stub: 55d5e7ebfc4562fb398dc697"
}-
After new stub insertion - it returns stub's ID in database
"""
session = self.request.headers.get('session', None)
delay_policy = self.request.headers.get('delay_policy', None)
stateful = asbool(self.request.headers.get('stateful', True))
recorded = self.request.headers.get('stub_created_date', None)
module_name = self.request.headers.get('ext_module', None)
# if not module_name:
# # legacy
# module_name = handler.get_argument('stubbedSystem', None)
recorded_module_system_date = self.request.headers.get(
'stubbedSystemDate', None)
priority = int(self.request.headers.get('priority', -1))
response = put_stub(
self,
session,
delay_policy=delay_policy,
stateful=stateful,
priority=priority,
recorded=recorded,
module_name=module_name,
recorded_module_system_date=recorded_module_system_date)
# adding status code based on response
status = response['data']['message']['status']
if status == 'created':
self.set_status(201)
elif status == 'updated':
self.set_status(200)
elif status == 'ignored':
# this status code could be changed
self.set_status(200)
return response
def delete_stubs_request(handler):
return delete_stubs(handler,
scenario_name=handler.get_argument('scenario', None),
host=handler.get_argument('host', None),
force=asbool(handler.get_argument('force', False)))
scenario_name = args.get('scenario')
session_name = args.get('session')
# session takes precedence
if session_name:
scenario_key = cache.get_scenario_key(session_name)
session = {}
if scenario_key:
session = cache.get_session(scenario_key.partition(':')[-1],
session_name)
response['data']['session'] = session
elif scenario_name:
sessions = list(cache.get_sessions_status(scenario_name,
local=local_cache))
response['data']['sessions'] = sessions
check_database = asbool(args.get('check_database', True))
if check_database:
response['data']['database_server'] = {'status' : 'bad'}
try:
if get_mongo_client().connection.alive():
response['data']['database_server']['status'] = 'ok'
except:
response['data']['database_server']['error'] = "mongo down"
return response
def put_bookmark(handler, session_name, name):
cache = Cache(get_hostname(handler.request))
response = dict(version=version, data = {})
if not session_name:
raise exception_response(400, title="No session provided")
def coerce_mongo_param(k, v):
if k in ('port', 'max_pool_size'):
return int(v)
elif k in ('tz_aware',):
return asbool(v)
return v
scenario_name = args.get('scenario')
session_name = args.get('session')
# session takes precedence
if session_name:
scenario_key = cache.get_scenario_key(session_name)
session = {}
if scenario_key:
session = cache.get_session(
scenario_key.partition(':')[-1], session_name)
response['data']['session'] = session
elif scenario_name:
sessions = list(
cache.get_sessions_status(scenario_name, local=local_cache))
response['data']['sessions'] = sessions
check_database = asbool(args.get('check_database', True))
if check_database:
response['data']['database_server'] = {'status': 'bad'}
try:
if get_mongo_client().connection.alive():
response['data']['database_server']['status'] = 'ok'
except:
response['data']['database_server']['error'] = "mongo down"
return response
def put_bookmark(handler, session_name, name):
cache = Cache(get_hostname(handler.request))
response = dict(version=version, data={})
if not session_name:
raise exception_response(400, title="No session provided")
def put(self, scenario_name):
"""
Inserts stub into selected scenario
Example request headers:
session: session_test
Example request JSON body:
{
"request": {
"method": "POST",
"bodyPatterns": [
{ "contains": ["<status>IS_OK2</status>"] }
]
},
"response": {
"status": 200,
"body": "<response>YES</response>"
}
}
Example output:
{
version: "0.6.6"
data: {
message: "updated with stateful response"
}-
}
or:
{
version: "0.6.6"
data: {
message: "inserted scenario_stub: 55d5e7ebfc4562fb398dc697"
}-
After new stub insertion - it returns stub's ID in database
"""
session = self.request.headers.get('session', None)
delay_policy = self.request.headers.get('delay_policy', None)
stateful = asbool(self.request.headers.get('stateful', True))
recorded = self.request.headers.get('stub_created_date', None)
module_name = self.request.headers.get('ext_module', None)
# if not module_name:
# # legacy
# module_name = handler.get_argument('stubbedSystem', None)
recorded_module_system_date = self.request.headers.get('stubbedSystemDate', None)
priority = int(self.request.headers.get('priority', -1))
response = put_stub(self, session, delay_policy=delay_policy,
stateful=stateful, priority=priority, recorded=recorded,
module_name=module_name,
recorded_module_system_date=recorded_module_system_date)
# adding status code based on response
status = response['data']['message']['status']
if status == 'created':
self.set_status(201)
elif status == 'updated':
self.set_status(200)
elif status == 'ignored':
# this status code could be changed
self.set_status(200)
return response
def export_stubs_to_commands_format(handler, scenario_name):
"""
Exports scenario to .commands file format.
:param handler:
:param scenario_name: <string> Scenario name
:return: :raise exception_response:
"""
cache = Cache(get_hostname(handler.request))
scenario_name_key = cache.scenario_key_name(scenario_name)
# use user arg or epoch time
session_id = handler.get_argument('session_id', int(time.time()))
session = u'{0}_{1}'.format(scenario_name, session_id)
cmds = [
'delete/stubs?scenario={0}'.format(scenario_name),
'begin/session?scenario={0}&session={1}&mode=record'.format(
scenario_name, session)
]
files = []
scenario = Scenario()
# get scenario pre stubs for specified scenario
stubs = list(scenario.get_pre_stubs(scenario_name_key))
if stubs:
for i in range(len(stubs)):
entry = stubs[i]
stub = Stub(entry['stub'], scenario_name_key)
# if stub is rest - matcher may be None, checking that
if stub.contains_matchers() is None:
cmds.append(
'# Stub skipped since no matchers were found. Consider using .yaml format for additional '
'capabilities')
# skipping to next stub, this stub is not compatible with .commands format
continue
matchers = [('{0}_{1}_{2}.textMatcher'.format(session, i, x),
stub.contains_matchers()[x])
for x in range(len(stub.contains_matchers()))]
matchers_str = ",".join(x[0] for x in matchers)
url_args = stub.args()
url_args['session'] = session
module_info = stub.module()
if module_info:
# Note: not including put/module in the export, modules are shared
# by multiple scenarios.
url_args['ext_module'] = module_info['name']
url_args['stub_created_date'] = stub.recorded()
url_args['stubbedSystemDate'] = module_info.get(
'recorded_system_date')
url_args['system_date'] = module_info.get('system_date')
url_args = urlencode(url_args)
responses = stub.response_body()
assert (len(responses) == 1)
response = responses[0]
response = ('{0}_{1}.response'.format(session, i), response)
cmds.append('put/stub?{0},{1},{2}'.format(url_args, matchers_str,
response[0]))
files.append(response)
files.extend(matchers)
else:
cmds.append(
'put/stub?session={0},text=a_dummy_matcher,text=a_dummy_response'.
format(session))
cmds.append('end/session?session={0}'.format(session))
runnable = asbool(handler.get_argument('runnable', False))
runnable_info = dict()
if runnable:
playback_session = handler.get_argument('playback_session', None)
if not playback_session:
raise exception_response(
400,
title="'playback_session' argument required with 'runnable")
runnable_info['playback_session'] = playback_session
tracker = Tracker()
last_used = tracker.session_last_used(scenario_name_key,
playback_session, 'playback')
if not last_used:
raise exception_response(400,
title="Unable to find playback session")
runnable_info['last_used'] = dict(remote_ip=last_used['remote_ip'],
start_time=str(
last_used['start_time']))
playback = tracker.get_last_playback(scenario_name, playback_session,
last_used['start_time'])
playback = list(playback)
if not playback:
raise exception_response(
400,
title=
"Unable to find a playback for scenario='{0}', playback_session='{1}'"
.format(scenario_name, playback_session))
cmds.append(
'begin/session?scenario={0}&session={1}&mode=playback'.format(
scenario_name, session))
number_of_requests = len(playback)
runnable_info['number_of_playback_requests'] = number_of_requests
for nrequest in range(number_of_requests):
track = playback[nrequest]
request_text = track.get('request_text')
if not request_text:
raise exception_response(
400,
title=
'Unable to obtain playback details, was full tracking enabled?'
)
request_file_name = '{0}_{1}.request'.format(session, nrequest)
files.append((request_file_name, request_text))
stubo_response_text = track['stubo_response']
if not isinstance(stubo_response_text, basestring):
stubo_response_text = unicode(stubo_response_text)
stubo_response_file_name = '{0}_{1}.stubo_response'.format(
session, nrequest)
files.append((stubo_response_file_name, stubo_response_text))
url_args = track['request_params']
url_args['session'] = session
url_args = urlencode(url_args)
cmds.append(u'get/response?{0},{1}'.format(url_args,
request_file_name))
cmds.append('end/session?session={0}'.format(session))
files.append(('{0}.commands'.format(scenario_name), b"\r\n".join(cmds)))
static_dir = handler.settings['static_path']
export_dir = handler.get_argument('export_dir',
scenario_name_key).replace(':', '_')
export_dir_path = os.path.join(static_dir, 'exports', export_dir)
if os.path.exists(export_dir_path):
shutil.rmtree(export_dir_path)
os.makedirs(export_dir_path)
archive_name = os.path.join(export_dir_path, scenario_name)
zout = zipfile.ZipFile(archive_name + '.zip', "w")
tar = tarfile.open(archive_name + ".tar.gz", "w:gz")
for finfo in files:
fname, contents = finfo
file_path = os.path.join(export_dir_path, fname)
with codecs.open(file_path, mode='wb', encoding='utf-8') as f:
f.write(contents)
f.close()
tar.add(file_path, fname)
zout.write(file_path, fname)
tar.close()
zout.close()
shutil.copy(archive_name + '.zip', archive_name + '.jar')
files.extend([(scenario_name + '.zip', ), (scenario_name + '.tar.gz', ),
(scenario_name + '.jar', )])
# getting links
links = get_export_links(handler, scenario_name_key, files)
return links
def export_stubs_to_commands_format(handler, scenario_name):
"""
Exports scenario to .commands file format.
:param handler:
:param scenario_name: <string> Scenario name
:return: :raise exception_response:
"""
cache = Cache(get_hostname(handler.request))
scenario_name_key = cache.scenario_key_name(scenario_name)
# use user arg or epoch time
session_id = handler.get_argument('session_id', int(time.time()))
session = u'{0}_{1}'.format(scenario_name, session_id)
cmds = [
'delete/stubs?scenario={0}'.format(scenario_name),
'begin/session?scenario={0}&session={1}&mode=record'.format(
scenario_name, session)
]
files = []
scenario = Scenario()
# get scenario pre stubs for specified scenario
stubs = list(scenario.get_pre_stubs(scenario_name_key))
if stubs:
for i in range(len(stubs)):
entry = stubs[i]
stub = Stub(entry['stub'], scenario_name_key)
# if stub is rest - matcher may be None, checking that
if stub.contains_matchers() is None:
cmds.append('# Stub skipped since no matchers were found. Consider using .yaml format for additional '
'capabilities')
# skipping to next stub, this stub is not compatible with .commands format
continue
matchers = [('{0}_{1}_{2}.textMatcher'.format(session, i, x), stub.contains_matchers()[x])
for x in range(len(stub.contains_matchers()))]
matchers_str = ",".join(x[0] for x in matchers)
url_args = stub.args()
url_args['session'] = session
module_info = stub.module()
if module_info:
# Note: not including put/module in the export, modules are shared
# by multiple scenarios.
url_args['ext_module'] = module_info['name']
url_args['stub_created_date'] = stub.recorded()
url_args['stubbedSystemDate'] = module_info.get('recorded_system_date')
url_args['system_date'] = module_info.get('system_date')
url_args = urlencode(url_args)
responses = stub.response_body()
assert(len(responses) == 1)
response = responses[0]
response = ('{0}_{1}.response'.format(session, i), response)
cmds.append('put/stub?{0},{1},{2}'.format(url_args, matchers_str,
response[0]))
files.append(response)
files.extend(matchers)
else:
cmds.append('put/stub?session={0},text=a_dummy_matcher,text=a_dummy_response'.format(session))
cmds.append('end/session?session={0}'.format(session))
runnable = asbool(handler.get_argument('runnable', False))
runnable_info = dict()
if runnable:
playback_session = handler.get_argument('playback_session', None)
if not playback_session:
raise exception_response(400,
title="'playback_session' argument required with 'runnable")
runnable_info['playback_session'] = playback_session
tracker = Tracker()
last_used = tracker.session_last_used(scenario_name_key,
playback_session, 'playback')
if not last_used:
raise exception_response(400,
title="Unable to find playback session")
runnable_info['last_used'] = dict(remote_ip=last_used['remote_ip'],
start_time=str(last_used['start_time']))
playback = tracker.get_last_playback(scenario_name, playback_session,
last_used['start_time'])
playback = list(playback)
if not playback:
raise exception_response(400,
title="Unable to find a playback for scenario='{0}', playback_session='{1}'".format(scenario_name, playback_session))
cmds.append('begin/session?scenario={0}&session={1}&mode=playback'.format(
scenario_name, session))
number_of_requests = len(playback)
runnable_info['number_of_playback_requests'] = number_of_requests
for nrequest in range(number_of_requests):
track = playback[nrequest]
request_text = track.get('request_text')
if not request_text:
raise exception_response(400, title='Unable to obtain playback details, was full tracking enabled?')
request_file_name = '{0}_{1}.request'.format(session, nrequest)
files.append((request_file_name, request_text))
stubo_response_text = track['stubo_response']
if not isinstance(stubo_response_text, basestring):
stubo_response_text = unicode(stubo_response_text)
stubo_response_file_name = '{0}_{1}.stubo_response'.format(session, nrequest)
files.append((stubo_response_file_name, stubo_response_text))
url_args = track['request_params']
url_args['session'] = session
url_args = urlencode(url_args)
cmds.append(u'get/response?{0},{1}'.format(url_args,
request_file_name))
cmds.append('end/session?session={0}'.format(session))
try:
bookmarks = cache.get_all_saved_request_index_data()
if bookmarks:
cmds.append('import/bookmarks?location=bookmarks')
files.append(('bookmarks', json.dumps(bookmarks)))
except Exception as ex:
log.warn("failed to export bookmarks, error: %s" % ex)
pass
files.append(('{0}.commands'.format(scenario_name),
b"\r\n".join(cmds)))
static_dir = handler.settings['static_path']
export_dir = handler.get_argument('export_dir', scenario_name_key).replace(':', '_')
export_dir_path = os.path.join(static_dir, 'exports', export_dir)
if os.path.exists(export_dir_path):
shutil.rmtree(export_dir_path)
os.makedirs(export_dir_path)
archive_name = os.path.join(export_dir_path, scenario_name)
zout = zipfile.ZipFile(archive_name+'.zip', "w")
tar = tarfile.open(archive_name+".tar.gz", "w:gz")
for finfo in files:
fname, contents = finfo
file_path = os.path.join(export_dir_path, fname)
with codecs.open(file_path, mode='wb', encoding='utf-8') as f:
f.write(contents)
f.close()
tar.add(file_path, fname)
zout.write(file_path, fname)
tar.close()
zout.close()
shutil.copy(archive_name+'.zip', archive_name+'.jar')
files.extend([(scenario_name+'.zip',), (scenario_name+'.tar.gz',),
(scenario_name+'.jar',)])
# getting links
links = get_export_links(handler, scenario_name_key, files)
return links
def blacklisted(self):
return asbool(self.get_stubo_setting('blacklisted'))
def coerce_mongo_param(k, v):
if k in ("port", "max_pool_size"):
return int(v)
elif k in ("tz_aware",):
return asbool(v)
return v