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 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 __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 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
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")
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 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