def reference_stitch_transaction(step): node = world.config['nodeId'] stitch = world.responses['previousTransaction'][node] referencing_address = static.REFERENCING_ADDRESS api = api_utils.prepare_api_call(node) transaction_bundle = transactions.create_transaction_bundle(referencing_address, 'REFERENCE9TAG', 0) def transactions_to_approve(node, arg_list): response = api_utils.fetch_call('getTransactionsToApprove', arg_list['api'], {'depth': 3}) arg_list['responses']['getTransactionsToApprove'][node] = response return response gtta_results = pool.start_pool(transactions_to_approve, 1, {node: {'api': api, 'responses': world.responses}}) branch = pool.fetch_results(gtta_results[0], 30) options = {'trunk': stitch, 'branch': branch, 'trytes': transaction_bundle.as_tryte_strings(), 'min_weight_magnitude': 9} def make_transaction(node, arg_list): response = transactions.attach_store_and_broadcast(arg_list['api'], options) arg_list['responses']['attachToTangle'][node] = response return response transaction_results = pool.start_pool(make_transaction, 1, {node: {'api': api, 'responses': world.responses}}) pool.fetch_results(transaction_results[0], 30)
def threaded_call(step, apiCall, node): logger.info("Creating thread for {}".format(apiCall)) world.config['apiCall'] = apiCall world.config['nodeId'] = node arg_list = step.hashes options = {} api_utils.prepare_options(arg_list, options) api = api_utils.prepare_api_call(node) def make_call(node, arg_list): response = api_utils.fetch_call(apiCall, arg_list['api'], arg_list['options']) arg_list['responses'][apiCall] = {} arg_list['responses'][apiCall][node] = response return response args = { node: { 'api': api, 'options': options, 'responses': world.responses } } future_results = pool.start_pool(make_call, 1, args) if 'future_results' not in world.config: world.config['future_results'] = {} world.config['future_results'][apiCall] = future_results
def spam_call(step, api_call, num_tests, node): """ Spams an API call a number of times among the specified nodes in a cluster :param api_call: The API call you would like to make :param num_tests: The number of iterations you would like to run :param node: The node that the call will be sent to. This can be set to 'all nodes' and it will run the test on all the available nodes. :param step.hashes: A gherkin table present in the feature file specifying the arguments and the associated type. """ start = time() world.config['apiCall'] = api_call arg_list = step.hashes nodes = {} response_val = [] options = {} api_utils.prepare_options(arg_list, options) # See if call will be made on one node or all api_utils.assign_nodes(node, nodes) call_node = world.config['nodeId'] def run_call(node, args): logger.debug('Running Thread on {}'.format(node)) api = args['api'] options = args['options'] response = api_utils.fetch_call(api_call, api, options) return response for current_node in nodes: nodes[current_node]['options'] = options future_results = pool.start_pool(run_call, num_tests, nodes) responses.fetch_future_results(future_results, num_tests, response_val) world.responses[api_call] = {} world.responses[api_call][call_node] = response_val end = time() time_spent = end - start logger.info('Time spent on loop: {}'.format(time_spent))
def spam_call_gtta(step, numTests): """Spams getTransactionsToApprove calls a number of times among available nodes in a cluster""" start = time() node = next(iter(world.machine['nodes'])) apiCall = 'getTransactionsToApprove' world.config['nodeId'] = node world.config['apiCall'] = apiCall nodes = {} for current_node in world.machine['nodes']: api = api_utils.prepare_api_call(current_node) nodes[current_node] = api def run_call(node, api): logger.debug('Running Thread on {}'.format(node)) response = api.get_transactions_to_approve(depth=3) return response logging.info('Calls being made to %s', node) responseVal = [] args = (nodes) future_results = pool.start_pool(run_call, numTests, args) i = 0 for result in future_results: i += 1 if i % 25 == 0: logger.info('Fetching result: {}/{}'.format(i, numTests)) response = pool.fetch_results(result, 30) responseVal.append(response) logger.info(len(responseVal)) world.responses[apiCall] = {} world.responses[apiCall][node] = responseVal end = time() time_spent = end - start logger.info('Time spent on loop: {}'.format(time_spent))
def threaded_call(step, api_call, node): """ Makes an asynchronous API call on the specified node and stores the future result reference in the world.config variable. :param api_call: The API call you would like to make. :param node: The identifier for the node you would like to run the call on. :param step.hashes: A gherkin table present in the feature file specifying the arguments and the associated type. """ logger.info("Creating thread for {}".format(api_call)) world.config['apiCall'] = api_call world.config['nodeId'] = node arg_list = step.hashes options = {} api_utils.prepare_options(arg_list, options) api = api_utils.prepare_api_call(node) def make_call(node, arg_list): response = api_utils.fetch_call(api_call, arg_list['api'], arg_list['options']) arg_list['responses'][api_call] = {} arg_list['responses'][api_call][node] = response return response args = { node: { 'api': api, 'options': options, 'responses': world.responses } } future_results = pool.start_pool(make_call, 1, args) if 'future_results' not in world.config: world.config['future_results'] = {} world.config['future_results'][api_call] = future_results