def test_leading_zero(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': '02'}}
selector = 'request.body.parsed.dict.key'
self.assertEqual(context, is_numeric(context, selector=selector))
def test_set(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': 'value'}}
context_exp = get_default_context({})
context_exp['request']['body']['parsed'] = {
'dict': {
'key': 'anothervalue'
}
}
selector = 'request.body.parsed.dict.key'
set_to = 'anothervalue'
self.assertEqual(context_exp,
set_value(context, selector=selector, set_to=set_to))
def test_string(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': 'a'}}
selector = 'request.body.parsed.dict.key'
self.assertRaises(ValueError, is_numeric, context, selector=selector)
def get_config_context():
return get_default_context({
'config': {
'internal': {
'vardb_path': app.config['juggler']['vardb_path']
}
}
})
def test_load(self):
context = get_default_context({})
context['request']['body']['parsed'] = 'parsed'
search_path = str(Path('resources').resolve())
file_name = 'template.yaml'
expected = {'expand': 'parsed', 'key': 'value', 'list': ['test']}
expanded = load_yaml_tpl(search_path, file_name, context)
self.assertDictEqual(expected, expanded)
def test_match(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': 'StartEnd'}}
selector = 'request.body.parsed.dict.key'
start = 'Start'
self.assertEqual(context,
starts_with(context, selector=selector, start=start))
def test_match(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': 'AString'}}
selector = 'request.body.parsed.dict.key'
pattern = '.Str.*'
self.assertEqual(
context, matches_regex(context, selector=selector,
pattern=pattern))
def test_ordered(self):
context = get_default_context({})
context['request']['body']['parsed'] = 'parsed'
search_path = str(Path('resources').resolve())
file_name = 'template.yaml'
expected = OrderedDict([('key', 'value'), ('list', ['test']),
('expand', 'parsed')])
expanded = load_yaml_tpl(search_path, file_name, context)
self.assertEqual(expected, expanded)
def transform() -> dict:
ctx = get_default_context({})
ctx['response']['body']['raw'] = request.json['text']
split = request.json['transformer'].split('.')
mod = importlib.import_module('.'.join(split[:len(split) - 1]))
fun = getattr(mod, split[len(split) - 1:len(split)][0])
ctx = fun(ctx)
yaml.add_representer(OrderedDict, lambda self, data: self.represent_mapping('tag:yaml.org,2002:map', data.items()))
return jsonify({'text': yaml.dump(ctx['response']['body']['parsed'], default_flow_style=False)})
def test_no_match(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': 'AString'}}
selector = 'request.body.parsed.dict.key'
pattern = 'Foo.*'
self.assertRaises(AssertionError,
matches_regex,
context,
selector=selector,
pattern=pattern)
def test_no_match(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': 'StartEnd'}}
selector = 'request.body.parsed.dict.key'
start = 'End'
self.assertRaises(AssertionError,
starts_with,
context,
selector=selector,
start=start)
def translate_file(file: Path, action: str) -> OrderedDict:
ctx = get_default_context({})
with file.open() as f:
ctx['response']['body']['raw'] = f.read()
split = action.split('.')
mod = importlib.import_module('.'.join(split[:len(split) - 1]))
fun = getattr(mod, split[len(split) - 1:len(split)][0])
ctx = fun(ctx)
return ctx['response']['body']['parsed']
def test_equal(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': 'value'}}
selector = 'request.body.parsed.dict.key'
compare_to = 'value'
self.assertEqual(
context,
compare(context,
selector=selector,
comparator='==',
compare_to=compare_to))
def test_smaller(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': 1}}
selector = 'request.body.parsed.dict.key'
compare_to = 2
self.assertEqual(
context,
compare(context,
selector=selector,
comparator='<',
compare_to=compare_to))
def test_greater(self):
context = get_default_context({})
context['request']['body']['parsed'] = {'dict': {'key': 2}}
selector = 'request.body.parsed.dict.key'
compare_to = 1
self.assertRaises(AssertionError,
compare,
context,
selector=selector,
comparator='<',
compare_to=compare_to)
def test_no_header(self):
eventstore.insert = self.insert
context = get_default_context({})
context['environment']['recipe'] = {'workflow': []}
context['environment']['tasks'] = []
context['environment']['config'] = {'internal': {'db_path': ''}}
listener_process = Process(group=None,
target=listener,
args=[context],
kwargs={'port': 8080})
listener_process.start()
sleep(1)
r = requests.get('http://localhost:8080')
listener_process.terminate()
self.assertEqual('', r.text)
def run_gaukl(config_file_path: str) -> None:
path = Path(config_file_path)
config = load_yaml_tpl(str(path.parent), str(path.name), None)
for sub_path in ['recipes_path', 'rulesets_path', 'responses_path']:
if not Path(config['paths'][sub_path]).is_absolute():
config['paths'][sub_path] = str(
path.parent.joinpath(config['paths'][sub_path]).resolve())
recipes = path.parent.joinpath(
config['paths']['recipes_path']).glob('*.yaml')
logging.basicConfig(level=config['internal']['logging']['log_level'],
format=config['internal']['logging']['log_format'])
logger = logging.getLogger('gaukl.global')
listener_processes = {}
recipe_names = []
for recipe in recipes:
listener_process = mp.Process(group=None,
target=run_recipe,
args=[config, recipe.name])
listener_process.start()
logger.info(f'Loading recipe {recipe.name}')
recipe_names.append(recipe.name)
listener_processes[recipe.name] = listener_process.pid
# Register with juggler
if config['internal']['juggler']['enabled']:
requests.put(
f'http://{config["internal"]["juggler"]["path"]}/api/services',
json={
'host': '',
'port': config['internal']['api']['server.socket_port']
})
# Start internal REST API
logger.info('Starting API')
api.run(get_default_context({'config': config}), recipe_names,
listener_processes)
def run_recipe(config: dict, recipe_file_name: str) -> None:
"""Loads the recipe with which gaukl is started. This is the entry point for everything.
Starts the listener as defined in the recipe as well as the internal API.
Also constructs the environment which defines relevant extensions etc. as defined in the config.
"""
recipe = load_yaml_tpl(config['paths']['recipes_path'], recipe_file_name,
None)
config['active_recipe'] = recipe_file_name
logging.basicConfig(level=config['internal']['logging']['log_level'],
format=config['internal']['logging']['log_format'])
logger = logging.getLogger('gaukl.global')
# Import all tasks, functions and listeners
[[importlib.import_module(ext) for ext in config[entry]]
for entry in ['extensions', 'listeners']]
# Build all workflows
build = lambda tasks: {
reg.shortname or reg.__module__ + '.' + reg.__name__: reg
for reg in tasks
}
task_map = build(_tasks)
listener = build(_listener)
context = get_default_context({
'tasks': task_map,
'recipe': recipe,
'config': config,
'environ': os.environ
})
# Clear the databases
eventstore.purge(context)
kvstore.purge(context)
# Start the listener
call = get_callable(recipe['listen'], listener)
logger.info(f'Started listener for recipe {recipe}')
call['function'](context, **call['options'])
def test_unparse(self):
context = get_default_context({})
context['response']['body']['parsed'] = {'key': 'value'}
self.assertEqual(
'<?xml version="1.0" encoding="utf-8"?>\n<key>value</key>',
response_to_xml(context)['response']['body']['raw'])
def test_parse(self):
context = get_default_context({})
context['request']['body']['raw'] = '<key>value</key>'
self.assertEqual(
{'key': 'value'},
request_from_xml(context)['request']['body']['parsed'])
@app.route('/api/events', methods=['GET'])
def get_events():
service = request.args.get('services')
try:
r = requests.get('http://' + service + '/api/events?event=' +
request.args.get('event')).json()
except Exception:
r = None
return jsonify({'service': service, 'response': r})
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
"config_file_path",
help="Path to the config file, ex. ./examples/config.yaml")
args = parser.parse_args()
config = load_yaml_path(Path(args.config_file_path))
kvstore.purge(
get_default_context(
{'config': {
'internal': {
'vardb_path': config['vardb_path']
}
}}))
gaukl.juggler.api.run(config)
def test_unparse(self):
context = get_default_context({})
context['response']['body']['parsed'] = {'key': 'value'}
self.assertEqual('{"key": "value"}',
response_to_json(context)['response']['body']['raw'])
def test_parse(self):
context = get_default_context({})
context['request']['body']['raw'] = '{"key": "value"}'
self.assertEqual(
{'key': 'value'},
request_from_json(context)['request']['body']['parsed'])
