def update_delay_policy(handler):
"""Record delay policy in redis to be available globally to any
users for their sessions.
Creates a delay policy. Examples:
{ “name”: “delay_name”,
“delay_type”: “fixed”,
“milliseconds”: 50}
or
{ “name”: “delay_name”,
“delay_type”: “normalvariate”,
“mean”: “mean_val”,
“stddev”: “val”}
:return: :response: <dict> with status code (400 - bad request, 409 - something is wrong, conflict of values,
200 - delay policy updated, 201 - delay policy created)
"""
cache = Cache(get_hostname(handler.request))
response = {
'version': version
}
doc = handler.request.arguments
err = None
status_code = None
# checking name
if 'name' not in doc:
err = "'name' parameter not found in request"
status_code = 400
else:
if " " in doc['name']:
err = "'name' parameter should not contain white space"
status_code = 400
if 'delay_type' not in doc:
err = "'delay_type' param not found in request"
status_code = 400
if not err:
# checking for fixed delays
if doc['delay_type'] == 'fixed':
if 'milliseconds' not in doc:
err = "'milliseconds' param is required for 'fixed' delays"
status_code = 409
# checking for normalvariate delays
elif doc['delay_type'] == 'normalvariate':
if 'mean' not in doc or 'stddev' not in doc:
err = "'mean' and 'stddev' params are required for " \
"'normalvariate' delays"
status_code = 409
# checking for weighted delays
elif doc['delay_type'] == 'weighted':
if 'delays' not in doc:
err = "'delays' are required for 'weighted' delays"
status_code = 409
else:
try:
Delay.parse_args(doc)
except Exception, e:
err = 'Unable to parse weighted delay arguments: {0}'.format(str(e))
status_code = 409
# delay_type not known, creating error
else:
err = 'Unknown delay type: {0}'.format(doc['delay_type'])
status_code = 400
def _get_delay(self, policy):
from stubo.service.delay import Delay
return Delay.parse_args(policy)
def update_delay_policy(handler):
"""Record delay policy in redis to be available globally to any
users for their sessions.
Creates a delay policy. Examples:
{ “name”: “delay_name”,
“delay_type”: “fixed”,
“milliseconds”: 50}
or
{ “name”: “delay_name”,
“delay_type”: “normalvariate”,
“mean”: “mean_val”,
“stddev”: “val”}
:return: :response: <dict> with status code (400 - bad request, 409 - something is wrong, conflict of values,
200 - delay policy updated, 201 - delay policy created)
"""
cache = Cache(get_hostname(handler.request))
response = {'version': version}
doc = handler.request.arguments
err = None
status_code = None
# checking name
if 'name' not in doc:
err = "'name' parameter not found in request"
status_code = 400
else:
if " " in doc['name']:
err = "'name' parameter should not contain white space"
status_code = 400
if 'delay_type' not in doc:
err = "'delay_type' param not found in request"
status_code = 400
if not err:
# checking for fixed delays
if doc['delay_type'] == 'fixed':
if 'milliseconds' not in doc:
err = "'milliseconds' param is required for 'fixed' delays"
status_code = 409
# checking for normalvariate delays
elif doc['delay_type'] == 'normalvariate':
if 'mean' not in doc or 'stddev' not in doc:
err = "'mean' and 'stddev' params are required for " \
"'normalvariate' delays"
status_code = 409
# checking for weighted delays
elif doc['delay_type'] == 'weighted':
if 'delays' not in doc:
err = "'delays' are required for 'weighted' delays"
status_code = 409
else:
try:
Delay.parse_args(doc)
except Exception, e:
err = 'Unable to parse weighted delay arguments: {0}'.format(
str(e))
status_code = 409
# delay_type not known, creating error
else:
err = 'Unknown delay type: {0}'.format(doc['delay_type'])
status_code = 400
def get_response_v2(handler, full_scenario_name, session_name):
# main result dictionary that will be returned
result_dict = {}
request = handler.request
stubo_request = StuboRequest(request)
cache = Cache(get_hostname(request))
scenario_name = full_scenario_name.partition(':')[-1]
handler.track.scenario = scenario_name
request_id = stubo_request.id()
module_system_date = handler.get_argument('system_date', None)
url_args = handler.track.request_params
# trace_matcher = TrackTrace(handler.track, 'matcher')
user_cache = handler.settings['ext_cache']
# check cached requests
cached_request = cache.get_request(scenario_name, session_name, request_id)
if cached_request:
response_ids, delay_policy_name, recorded, system_date, module_info, request_index_key = cached_request
else:
retry_count = 5 if handler.settings.get('is_cluster', False) else 1
session, retries = cache.get_session_with_delay(
scenario_name,
session_name,
retry_count=retry_count,
retry_interval=1)
if retries > 0:
log.warn(
"replication was slow for session: {0} {1}, it took {2} secs!".
format(full_scenario_name, session_name, retries + 1))
if session['status'] != 'playback':
result_dict[
"error"] = 'cache status != playback. session={0}'.format(
session)
result_dict["statusCode"] = 412
return result_dict
system_date = session['system_date']
if not system_date:
result_dict[
"error"] = "slave session {0} not available for scenario {1}".format(
session_name, full_scenario_name)
result_dict["statusCode"] = 412
return result_dict
trace_matcher = TrackTrace(handler.track, 'matcher')
session['ext_cache'] = user_cache
result = match(stubo_request,
session,
trace_matcher,
as_date(system_date),
url_args=url_args,
hooks=handler.settings['hooks'],
module_system_date=module_system_date)
# matching request not found
if not result[0]:
result_dict["error"] = "Not matching request found"
result_dict["statusCode"] = 404
return result_dict
_, stub_number, stub = result
response_ids = stub.response_ids()
delay_policy_name = stub.delay_policy_name()
recorded = stub.recorded()
module_info = stub.module()
request_index_key = add_request(
session, request_id, stub, system_date, stub_number,
handler.settings['request_cache_limit'])
if not stub.response_body():
_response = stub.get_response_from_cache(request_index_key)
stub.set_response_body(_response['body'])
if delay_policy_name:
stub.load_delay_from_cache(delay_policy_name)
if cached_request:
stub = StubCache({}, full_scenario_name, session_name)
stub.load_from_cache(response_ids, delay_policy_name, recorded,
system_date, module_info, request_index_key)
trace_response = TrackTrace(handler.track, 'response')
if module_info:
trace_response.info('module used', str(module_info))
response_text = stub.response_body()
if not response_text:
result_dict[
"error"] = 'Unable to find response in cache using session: {0}:{1}, '
'response_ids: {2}'.format(full_scenario_name, session_name,
response_ids)
result_dict["statusCode"] = 400
return result_dict
# get latest delay policy
delay_policy = stub.delay_policy()
if delay_policy:
delay = Delay.parse_args(delay_policy)
if delay:
delay = delay.calculate()
msg = 'apply delay: {0} => {1}'.format(delay_policy, delay)
log.debug(msg)
handler.track['delay'] = delay
trace_response.info(msg)
trace_response.info('found response')
module_system_date = as_date(module_system_date) if module_system_date \
else module_system_date
stub, _ = transform(stub,
stubo_request,
module_system_date=module_system_date,
system_date=as_date(system_date),
function='get/response',
cache=user_cache,
hooks=handler.settings['hooks'],
stage='response',
trace=trace_response,
url_args=url_args)
transfomed_response_text = stub.response_body()[0]
# Note transformed_response_text can be encoded in utf8
if response_text[0] != transfomed_response_text:
trace_response.diff('response:transformed',
dict(response=response_text[0]),
dict(response=transfomed_response_text))
result_dict["body"] = transfomed_response_text
result_dict["headers"] = stub.response_headers()
result_dict["statusCode"] = stub.response_status()
return result_dict
def _get_delay(self, policy):
from stubo.service.delay import Delay
return Delay.parse_args(policy)
