def delete_caches(self, scenario_name):
key = self.scenario_key_name(scenario_name)
master = get_redis_master()
deleted_responses = self.get_cache_backend()(master).remove(
self.get_response_key(scenario_name))
deleted_requests = self.get_cache_backend()(master).remove(
self.get_request_key(scenario_name))
# delete request indexes
deleted_request_indexes = []
for k in (self.get_request_index_key(scenario_name),
self.get_saved_request_index_key(scenario_name)):
deleted_request_indexes.append(
self.get_cache_backend()(master).remove(k))
session_names = self.get_cache_backend()(master).keys(key)
# log.debug('session_names: {0}'.format(session_names))
deleted_sessions_map = 0
if session_names:
sessions_key = '{0}:sessions'.format(self.host)
for k in session_names:
deleted_sessions_map += self.get_cache_backend()(
master).delete(sessions_key, k)
deleted_sessions = self.get_cache_backend()(master).remove(key)
log.debug('deleted_response: {0}, deleted_requests: {1}, '
', deleted_sessions_map: {2}, deleted_sessions: {3}, '
'deleted_request_indexes: {4}'.format(
deleted_responses, deleted_requests,
deleted_sessions_map, deleted_sessions,
deleted_request_indexes))
def delete_caches(self, scenario_name):
key = self.scenario_key_name(scenario_name)
master = get_redis_master()
deleted_responses = self.get_cache_backend()(master).remove(self.get_response_key(
scenario_name))
deleted_requests = self.get_cache_backend()(master).remove(self.get_request_key(
scenario_name))
# delete request indexes
deleted_request_indexes = []
for k in (self.get_request_index_key(scenario_name),
self.get_saved_request_index_key(scenario_name)):
deleted_request_indexes.append(self.get_cache_backend()(master).remove(k))
session_names = self.get_cache_backend()(master).keys(key)
# log.debug('session_names: {0}'.format(session_names))
deleted_sessions_map = 0
if session_names:
sessions_key = '{0}:sessions'.format(self.host)
for k in session_names:
deleted_sessions_map += self.get_cache_backend()(master).delete(sessions_key, k)
deleted_sessions = self.get_cache_backend()(master).remove(key)
log.debug('deleted_response: {0}, deleted_requests: {1}, '
', deleted_sessions_map: {2}, deleted_sessions: {3}, '
'deleted_request_indexes: {4}'.format(deleted_responses,
deleted_requests, deleted_sessions_map, deleted_sessions,
deleted_request_indexes))
def assert_valid_session(self, scenario_name, session_name):
scenario_key = self.scenario_key_name(scenario_name)
# if session exists it can only be dormant
if self.exists(scenario_key, session_name):
session = self.get_session(scenario_name,
session_name,
local=False)
session_status = session['status']
if session_status != 'dormant':
raise exception_response(400,
title='Session already exists '
'- {0}:{1} in {2} mode.'.format(
scenario_key, session_name,
session_status))
# Limitation: as the session name is not passed in as an arg to get/response
# we need a mapping to find the session for a scenario.
# host:sessions -> session_name->scenario_name
# we can therefore only have one session name per host/scenario
sessions_key = '{0}:sessions'.format(self.host)
scenario_found = self.get_cache_backend()(get_redis_master()).get_raw(
sessions_key, session_name)
if scenario_found and scenario_found != scenario_name:
raise exception_response(
400,
title='Session {0} can not be '
'used for scenario: {1}. This session is already being used '
'with another scenario: {2} on host: {3}.'.format(
session_name, scenario_name, scenario_found, self.host))
def assert_valid_session(self, scenario_name, session_name):
scenario_key = self.scenario_key_name(scenario_name)
# if session exists it can only be dormant
if self.exists(scenario_key, session_name):
session = self.get_session(scenario_name, session_name, local=False)
session_status = session['status']
if session_status != 'dormant':
raise exception_response(400, title='Session already exists '
'- {0}:{1} in {2} mode.'.format(scenario_key, session_name,
session_status))
# Limitation: as the session name is not passed in as an arg to get/response
# we need a mapping to find the session for a scenario.
# host:sessions -> session_name->scenario_name
# we can therefore only have one session name per host/scenario
sessions_key = '{0}:sessions'.format(self.host)
scenario_found = self.get_cache_backend()(get_redis_master()).get_raw(sessions_key,
session_name)
if scenario_found and scenario_found != scenario_name:
raise exception_response(400, title='Session {0} can not be '
'used for scenario: {1}. This session is already being used '
'with another scenario: {2} on host: {3}.'.format(session_name,
scenario_name,
scenario_found,
self.host))
def get_all_saved_request_index_data(self):
master = get_redis_master()
keys = master.keys('{0}:*:saved_request_index'.format(self.host))
info = {}
for key in keys:
scenario_name = key.split(':')[1]
info[scenario_name] = self.get_cache_backend()(master).get_all(key)
return info
def get_all_saved_request_index_data(self):
master = get_redis_master()
keys = master.keys('{0}:*:saved_request_index'.format(self.host))
info = {}
for key in keys:
scenario_name = key.split(':')[1]
info[scenario_name] = self.get_cache_backend()(master).get_all(key)
return info
def delete_session_data(self, scenario_name, session):
master = get_redis_master()
keys = (self.get_request_key(scenario_name),
self.get_response_key(scenario_name),
self.get_request_index_key(scenario_name))
hashes = [x.format(self.scenario_key_name(scenario_name)) for x in keys]
for _hash in hashes:
keys = self.get_cache_backend()(master).keys(_hash)
session_keys = [x for x in keys if x.startswith('{0}:'.format(
session))]
if session_keys:
log.debug('deleting {0} from {1}'.format(session_keys, _hash))
num_deleted = 0
for k in session_keys:
num_deleted += self.get_cache_backend()(master).delete(_hash, k)
log.debug('deleted {0}'.format(num_deleted))
def get_response(self, scenario_name, session_name, response_ids,
request_index_key):
"""
returns response or None
"""
num_responses = len(response_ids)
index = 0
if num_responses > 1:
# stateful response: lookup the response index value stored on master
master = get_redis_master()
request_index_name = self.get_request_index_key(scenario_name)
request_index_key = '{0}:{1}'.format(session_name, request_index_key)
index = self.get(request_index_name, request_index_key)
if not index or index < num_responses:
index = self.get_cache_backend()(master).incr(request_index_name, request_index_key)
index -= 1
response_key = '{0}:{1}'.format(session_name, response_ids[index])
return self.get(self.get_response_key(scenario_name), response_key,
local=True)
def delete_session_data(self, scenario_name, session):
master = get_redis_master()
keys = (self.get_request_key(scenario_name),
self.get_response_key(scenario_name),
self.get_request_index_key(scenario_name))
hashes = [
x.format(self.scenario_key_name(scenario_name)) for x in keys
]
for _hash in hashes:
keys = self.get_cache_backend()(master).keys(_hash)
session_keys = [
x for x in keys if x.startswith('{0}:'.format(session))
]
if session_keys:
log.debug('deleting {0} from {1}'.format(session_keys, _hash))
num_deleted = 0
for k in session_keys:
num_deleted += self.get_cache_backend()(master).delete(
_hash, k)
log.debug('deleted {0}'.format(num_deleted))
def get_response(self, scenario_name, session_name, response_ids,
request_index_key):
"""
returns response or None
"""
num_responses = len(response_ids)
index = 0
if num_responses > 1:
# stateful response: lookup the response index value stored on master
master = get_redis_master()
request_index_name = self.get_request_index_key(scenario_name)
request_index_key = '{0}:{1}'.format(session_name,
request_index_key)
index = self.get(request_index_name, request_index_key)
if not index or index < num_responses:
index = self.get_cache_backend()(master).incr(
request_index_name, request_index_key)
index -= 1
response_key = '{0}:{1}'.format(session_name, response_ids[index])
return self.get(self.get_response_key(scenario_name),
response_key,
local=True)
def get_redis_server(local=True):
return get_redis_slave() if local else get_redis_master()
def set_stubo_setting(self, setting, value, all_hosts=False):
key = 'stubo_setting'
if not all_hosts:
key = '{0}:{1}'.format(self.host, key)
return self.get_cache_backend()(get_redis_master()).set(key, setting, value)
def set_delay_policy(self, name, data):
key = self.get_delay_policy_key()
return self.get_cache_backend()(get_redis_master()).set(
key, name, data)
def delete_saved_request_index(self, scenario_name, name):
master = get_redis_master()
return self.get_cache_backend()(master).delete(self.get_saved_request_index_key(
scenario_name), name)
def get_request_index_data(self, scenario_name):
master = get_redis_master()
return self.get_cache_backend()(master).get_all_raw(self.get_request_index_key(
scenario_name))
def set_delay_policy(self, name, data):
key = self.get_delay_policy_key()
return self.get_cache_backend()(get_redis_master()).set(key, name, data)
def get_request_index_data(self, scenario_name):
master = get_redis_master()
return self.get_cache_backend()(master).get_all_raw(
self.get_request_index_key(scenario_name))
def delete_saved_request_index(self, scenario_name, name):
master = get_redis_master()
return self.get_cache_backend()(master).delete(
self.get_saved_request_index_key(scenario_name), name)
def get_redis_server(local=True):
return get_redis_slave() if local else get_redis_master()
def set_stubo_setting(self, setting, value, all_hosts=False):
key = 'stubo_setting'
if not all_hosts:
key = '{0}:{1}'.format(self.host, key)
return self.get_cache_backend()(get_redis_master()).set(
key, setting, value)
