def define_template(request):
action_provider_name = request.POST["action_provider"]
options = action_provider.get_options_for_provider(action_provider_name)
configured_options = dict()
for opt in options:
if opt["name"] in request.POST:
o = dict()
o["name"] = opt["name"]
o["value"] = request.POST[opt["name"]]
o["label"] = opt["label"]
# check for hidden action option customization
if opt["name"] + "_variable" in request.POST:
o["variable"] = request.POST[opt["name"] + "_variable"]
configured_options[o["name"]] = o
else:
context = {"error": "Required option not found in request!"}
return render(request, "error.html", context)
print "Setting configured options to the session %s" % configured_options
request.session["new_template_action_options"] = configured_options
context = {
"options": configured_options,
"action_provider": action_provider_name
}
return render(request, "configTemplates/define_template.html", context)
def configure_action(request):
"""
FIXME - add some validation here
:param request:
:return:
"""
required_fields = set(["action_provider"])
if not required_fields.issubset(request.POST):
return render(request, "error.html",
{"error": "Invalid Parameters in POST"})
provider_name = request.POST["action_provider"]
action_options = action_provider.get_options_for_provider(provider_name)
secrets = aframe_utils.get_secrets_keys()
if action_options == "":
context = {"error": "action provider not found"}
return render(request, "error.html", context)
context = {
"action_options": action_options,
"action_provider": provider_name,
"secrets": secrets
}
return render(request, "configTemplates/configure_action.html", context)
def update(request):
try:
if "id" in request.POST:
template_id = request.POST["id"]
template = get_object_or_404(ConfigTemplate, pk=template_id)
template.name = request.POST["name"]
template.description = request.POST["description"]
template.template = request.POST["template"]
template.type = request.POST["type"]
options = action_provider.get_options_for_provider(
template.action_provider)
configured_options = dict()
for opt in options:
print("Checking %s" % opt["name"])
if opt["name"] in request.POST:
o = dict()
o["name"] = opt["name"]
o["value"] = request.POST[opt["name"]]
o["label"] = opt["label"]
# check for hidden action option customization
if opt["name"] + "_variable" in request.POST:
print("FOUND VARIABLE in tools update!")
print(opt["name"])
if (opt["name"] == "playbook_path"):
template.template_path = request.POST[opt["name"]]
with open(template.template_path) as tmp:
template.template = tmp.read(
) # update displayed template
print("value is %s " % request.POST[opt["name"]])
o["variable"] = request.POST[opt["name"] + "_variable"]
configured_options[o["name"]] = o
else:
context = {
"error": "Required option not found in request!"
}
return render(request, "error.html", context)
template.action_provider_options = json.dumps(configured_options)
template.save()
try:
input_form = InputForm.objects.get(script=template)
return HttpResponseRedirect('/input_forms/edit/%s' %
input_form.id)
except InputForm.DoesNotExist as dne:
return HttpResponseRedirect(
"/input_forms/view_from_template/%s" % template.id)
else:
return render(request, "error.html",
{"error": "Invalid data in POST"})
except KeyError:
return render(request, "error.html",
{"error": "Invalid data in POST - Key error"})
def edit(request, template_id):
template = get_object_or_404(ConfigTemplate, pk=template_id)
default_options = action_provider.get_options_for_provider(template.action_provider)
action_options = json.loads(template.action_provider_options)
context = {"template": template,
"action_options": json.dumps(action_options),
"default_options": default_options
}
return render(request, "configTemplates/edit.html", context)
def edit(request, template_id):
template = get_object_or_404(ConfigTemplate, pk=template_id)
default_options = action_provider.get_options_for_provider(
template.action_provider)
action_options = json.loads(template.action_provider_options)
context = {
"template": template,
"action_options": json.dumps(action_options),
"default_options": default_options
}
return render(request, "configTemplates/edit.html", context)
def update(request):
try:
if "id" in request.POST:
template_id = request.POST["id"]
template = get_object_or_404(ConfigTemplate, pk=template_id)
template.name = request.POST["name"]
template.description = request.POST["description"]
template.template = request.POST["template"]
template.type = request.POST["type"]
options = action_provider.get_options_for_provider(template.action_provider)
configured_options = dict()
for opt in options:
print "Checking %s" % opt["name"]
if opt["name"] in request.POST:
o = dict()
o["name"] = opt["name"]
o["value"] = request.POST[opt["name"]]
o["label"] = opt["label"]
# check for hidden action option customization
if opt["name"] + "_variable" in request.POST:
print "FOUND VARIABLE in tools update!"
print "value is %s " % request.POST[opt["name"] + "_variable"]
o["variable"] = request.POST[opt["name"] + "_variable"]
configured_options[o["name"]] = o
else:
context = {"error": "Required option not found in request!"}
return render(request, "error.html", context)
template.action_provider_options = json.dumps(configured_options)
template.save()
try:
input_form = InputForm.objects.get(script=template)
return HttpResponseRedirect('/input_forms/edit/%s' % input_form.id)
except InputForm.DoesNotExist as dne:
return HttpResponseRedirect("/input_forms/view_from_template/%s" % template.id)
else:
return render(request, "error.html", {
"error": "Invalid data in POST"
})
except KeyError:
return render(request, "error.html", {
"error": "Invalid data in POST - Key error"
})
def configure_action(request):
"""
FIXME - add some validation here
:param request:
:return:
"""
provider_name = request.POST["action_provider"]
action_options = action_provider.get_options_for_provider(provider_name)
if action_options == "":
context = {"error": "action provider not found"}
return render(request, "error.html", context)
context = {"action_options": action_options, "action_provider": provider_name}
return render(request, "configTemplates/configure_action.html", context)
def edit(request, template_id):
template = get_object_or_404(ConfigTemplate, pk=template_id)
default_options = action_provider.get_options_for_provider(
template.action_provider)
action_options = json.loads(template.action_provider_options)
secrets = aframe_utils.get_secrets_keys()
context = {
"template": template,
"action_options": json.dumps(action_options),
"default_options": default_options,
"secrets": secrets
}
if (template.action_provider == "AnsibleAction"):
return render(request, "configTemplates/edit_ansible.html", context)
return render(request, "configTemplates/edit.html", context)
def edit(request, template_id):
template = get_object_or_404(ConfigTemplate, pk=template_id)
default_options = action_provider.get_options_for_provider(template.action_provider)
action_options = json.loads(template.action_provider_options)
try:
input_form = InputForm.objects.get(script=template)
context = {"template": template,
"action_options": json.dumps(action_options),
"default_options": default_options,
"input_form": input_form
}
return render(request, "configTemplates/edit.html", context)
except InputForm.DoesNotExist:
context = {"error": "Required option not found in request!"}
return render(request, "error.html", context)
def configure_action(request):
"""
FIXME - add some validation here
:param request:
:return:
"""
provider_name = request.POST["action_provider"]
action_options = action_provider.get_options_for_provider(provider_name)
if action_options == "":
context = {"error": "action provider not found"}
return render(request, "error.html", context)
context = {
"action_options": action_options,
"action_provider": provider_name
}
return render(request, "configTemplates/configure_action.html", context)
def define_template(request):
action_provider_name = request.POST["action_provider"]
options = action_provider.get_options_for_provider(action_provider_name)
configured_options = dict()
for opt in options:
if "name" in opt and opt["name"] in request.POST:
o = dict()
o["name"] = opt["name"]
o["value"] = request.POST[opt["name"]]
o["label"] = opt["label"]
# check for hidden action option customization
if opt["name"] + "_variable" in request.POST:
o["variable"] = request.POST[opt["name"] + "_variable"]
configured_options[o["name"]] = o
else:
context = {"error": "Required option not found in request!"}
return render(request, "error.html", context)
print("Setting configured options to the session %s" % configured_options)
request.session["new_template_action_options"] = configured_options
if action_provider_name == "AnsibleAction":
with open(configured_options['playbook_path']['value'],
'r') as playbook:
context = {
"options": configured_options,
"action_provider": action_provider_name,
"playbook": playbook.read(),
"playbook_path": configured_options['playbook_path']['value']
}
return render(request, "configTemplates/define_ansible_template.html",
context)
else:
context = {
"options": configured_options,
"action_provider": action_provider_name
}
return render(request, "configTemplates/define_template.html", context)
def define_template(request):
action_provider_name = request.POST["action_provider"]
options = action_provider.get_options_for_provider(action_provider_name)
configured_options = dict()
for opt in options:
if opt["name"] in request.POST:
o = dict()
o["name"] = opt["name"]
o["value"] = request.POST[opt["name"]]
o["label"] = opt["label"]
# check for hidden action option customization
if opt["name"] + "_variable" in request.POST:
o["variable"] = request.POST[opt["name"] + "_variable"]
configured_options[o["name"]] = o
else:
context = {"error": "Required option not found in request!"}
return render(request, "error.html", context)
print "Setting configured options to the session %s" % configured_options
request.session["new_template_action_options"] = configured_options
context = {"options": configured_options, "action_provider": action_provider_name}
return render(request, "configTemplates/define_template.html", context)
def _configure_widget_options(j):
'''
Configures widget specific options if necessary
:param j: input_form configuration object
:return: configured input_form json object
'''
if "widget_config" in j:
logger.debug("jsonifying widget config")
j["widget_config_json"] = json.dumps(j["widget_config"])
if j["widget"] == "preload_list" and "widget_config" in j:
try:
widget_config = j["widget_config"]
template_name = widget_config["template_name"]
key = widget_config["key_name"]
value = widget_config["value_name"]
config_template = ConfigTemplate.objects.get(name=template_name)
except (ObjectDoesNotExist, KeyError):
logger.error('Could not load preloaded_list template name!')
return j
action_name = config_template.action_provider
try:
action_options = json.loads(
config_template.action_provider_options)
except (ValueError, TypeError):
logger.error(
'Could not load action_provider_options from config_template!')
return j
# let's load any secrets if necessary
provider_options = action_provider.get_options_for_provider(
action_name)
for opt in provider_options:
if opt['type'] == 'secret':
opt_name = opt['name']
pw_lookup_key = action_options[opt_name]['value']
pw_lookup_value = aframe_utils.lookup_secret(pw_lookup_key)
action_options[opt_name]['value'] = pw_lookup_value
action = action_provider.get_provider_instance(action_name,
action_options)
try:
results = action.execute_template(
config_template.template.strip().replace('\r\n', '\n'))
print results
results_object = json.loads(results)
print key
print value
d = aframe_utils.get_list_from_json(key, value, results_object,
list(), 0)
print d
j["widget_data"] = d
except Exception as ex:
print str(ex)
return j
def apply_standalone_template(request):
logger.info("__ input_forms apply_standalone_template __")
if "input_form_id" not in request.POST:
logger.error("Did no find all required fields in request")
return render(request, "error.html",
{"error": "Invalid Parameters in POST"})
input_form_id = request.POST["input_form_id"]
input_form = InputForm.objects.get(pk=input_form_id)
json_object = json.loads(input_form.json)
context = dict()
for j in json_object:
if '.' in j["name"]:
# this is a fancy variable name
j_dict = aframe_utils.generate_dict(j["name"],
str(request.POST[j["name"]]))
context.update(j_dict)
else:
logger.debug("setting context %s" % j["name"])
print 'setting context %s' % j['name']
context[j["name"]] = str(request.POST[j["name"]])
config_template = input_form.script
try:
compiled_template = engines['django'].from_string(
config_template.template)
except TemplateSyntaxError as e:
logger.error("Caught a template syntax error!")
logger.error(str(e))
return render(request, "error.html",
{"error": "Invalid Template Syntax: %s" % str(e)})
completed_template = str(compiled_template.render(context))
if "preview" in request.POST:
if request.POST["preview"] == "yes_please":
logger.info("Returning template Preview")
pre_tags = "<html><body><pre>"
post_tags = "</pre></body</html>"
return HttpResponse(pre_tags + completed_template + post_tags)
logger.info(completed_template)
action_name = config_template.action_provider
logger.info(action_name)
action_options = json.loads(config_template.action_provider_options)
logger.info(action_options)
for ao in action_options:
if "action_options_" + str(ao) in request.POST:
logger.debug("Found a customized action option!")
new_val = request.POST["action_options_" + str(ao)]
print new_val
current_value = action_options[ao]["value"]
print current_value
action_options[ao]["value"] = re.sub("{{ .* }}", new_val,
current_value)
logger.debug(action_options[ao]["value"])
# let's load any secrets if necessary
provider_options = action_provider.get_options_for_provider(action_name)
for opt in provider_options:
print opt
if opt['type'] == 'secret':
opt_name = opt['name']
pw_lookup_key = action_options[opt_name]['value']
pw_lookup_value = aframe_utils.lookup_secret(pw_lookup_key)
action_options[opt_name]['value'] = pw_lookup_value
print "action name is: " + action_name
action = action_provider.get_provider_instance(action_name, action_options)
results = action.execute_template(completed_template)
print type(results)
# the action is passing back extra information about the type of response
if type(results) is dict:
if 'display_inline' in results and results['display_inline'] is False:
if 'cache_key' in results:
# set extra data on the context so we can use it to build a download link downstream
context = {
'results': 'Binary data',
'cache_key': results['cache_key'],
'scheme': request.scheme,
'host': request.get_host()
}
else:
# fixme to ensure contents is always present in results when display_inline is true
# results['content'] is currently unimplemented!
context = {'results': results['contents']}
else:
# results is just a string object, so send it through
context = {"results": results}
if "inline" in request.POST and request.POST["inline"] == 'yes_please':
print "returning INLINE"
context["input_form_name"] = input_form.name
context["input_form_id"] = input_form_id
return render(request, "overlay_results.html", context)
else:
print "returning full results"
return render(request, "input_forms/results.html", context)
def apply_per_endpoint_template(request):
"""
:param request: HTTPRequest from the input form
:return: results of the template execution
"""
logger.info("__ input_forms apply_per_endpoint_template __")
required_fields = set(["input_form_id", "endpoint_id", "group_id"])
if not required_fields.issubset(request.POST):
logger.error("Did no find all required fields in request")
return render(request, "error.html",
{"error": "Invalid Parameters in POST"})
input_form_id = request.POST["input_form_id"]
endpoint_id = request.POST["endpoint_id"]
group_id = request.POST["group_id"]
provider_instance = endpoint_provider.get_provider_instance_from_group(
group_id)
endpoint = provider_instance.get_endpoint_by_id(endpoint_id)
if "username" not in endpoint or endpoint["username"] == "":
if "global_username" in request.POST:
endpoint["username"] = request.POST["global_username"]
else:
raise Exception("Authentication is required!")
if "password" not in endpoint or endpoint["password"] == "":
if "global_password" in request.POST:
endpoint["password"] = request.POST["global_password"]
else:
raise Exception("Authentication is required!")
input_form = InputForm.objects.get(pk=input_form_id)
logger.debug(input_form.json)
json_object = json.loads(input_form.json)
context = dict()
for j in json_object:
if '.' in j["name"]:
# this is a json capable variable name
j_dict = aframe_utils.generate_dict(
j["name"], str(request.POST.get(j["name"], '')))
context.update(j_dict)
else:
logger.debug("setting context %s" % j["name"])
# don't worry about null values here
context[j["name"]] = str(request.POST.get(j['name'], ''))
context["af_endpoint_ip"] = endpoint["ip"]
context["af_endpoint_id"] = endpoint["id"]
context["af_endpoint_name"] = endpoint["name"]
context["af_endpoint_username"] = endpoint["username"]
context["af_endpoint_password"] = endpoint["password"]
context["af_endpoint_type"] = endpoint["type"]
logger.debug(context)
config_template = input_form.script
try:
compiled_template = engines['django'].from_string(
config_template.template)
completed_template = str(compiled_template.render(context))
except TemplateSyntaxError as e:
logger.error("Caught a template syntax error!")
return render(request, "error.html",
{"error": "Invalid Template Syntax: %s" % str(e)})
logger.debug(completed_template)
action_name = config_template.action_provider
action_options = json.loads(config_template.action_provider_options)
logger.debug(action_options)
for ao in action_options:
if "action_options_" + str(ao) in request.POST:
logger.debug("Found a customized action option!")
new_val = request.POST["action_options_" + str(ao)]
current_value = action_options[ao]["value"]
action_options[ao]["value"] = re.sub("{{.*}}", new_val,
current_value)
logger.debug(action_options[ao]["value"])
logger.debug("action name is: " + action_name)
# let's load any secrets if necessary
provider_options = action_provider.get_options_for_provider(action_name)
for opt in provider_options:
print opt
if opt['type'] == 'secret':
opt_name = opt['name']
pw_lookup_key = action_options[opt_name]['value']
pw_lookup_value = aframe_utils.lookup_secret(pw_lookup_key)
action_options[opt_name]['value'] = pw_lookup_value
action = action_provider.get_provider_instance(action_name, action_options)
action.set_endpoint(endpoint)
results = action.execute_template(completed_template)
context = {"results": results}
if "inline" in request.POST and request.POST["inline"] == 'yes_please':
print "returning INLINE"
context["input_form_name"] = input_form.name
context["input_form_id"] = input_form_id
return render(request, "overlay_results.html", context)
return render(request, "input_forms/results.html", context)
def execute_template(post_vars):
"""
Refactored out of tools/views.py as this is used in a couple of different places (tools/views and screens/views)
:param post_vars: copy of all variables passed in via the operation
:return: response object of form {'output': whatever, 'status': 1 }
"""
if 'template_id' not in post_vars and 'template_name' not in post_vars:
error = {
'output':
'missing required template_id or template_name parameter',
'status': 1
}
return error
if 'template_id' in post_vars:
template_id = int(post_vars['template_id'])
config_template = ConfigTemplate.objects.get(pk=template_id)
else:
template_name = str(post_vars['template_name'])
print("GETTING %s" % template_name)
config_template = ConfigTemplate.objects.get(name=template_name)
template_api = get_input_parameters_for_template(config_template)
context = dict()
try:
print(str(template_api["input_parameters"]))
input_parameters = template_api["input_parameters"]
for j in input_parameters:
print("setting context %s" % j)
context[j] = str(post_vars[j])
except Exception as ex:
print(str(ex))
error = {"output": "missing required parameters", "status": 1}
return error
compiled_template = engines['django'].from_string(config_template.template)
# compiled_template = get_template_from_string(config_template.template)
completed_template = str(compiled_template.render(context))
print(completed_template)
action_name = config_template.action_provider
action_options = json.loads(config_template.action_provider_options)
print(post_vars)
for ao in action_options:
print('checking ' + str(ao))
if "action_options_" + str(ao) in post_vars:
print("found a match!")
new_val = post_vars["action_options_" + str(ao)]
print(new_val)
current_value = action_options[ao]["value"]
print(current_value)
action_options[ao]["value"] = re.sub("{{ .* }}", new_val,
current_value)
print(action_options[ao]["value"])
# let's load any secrets if necessary
provider_options = action_provider.get_options_for_provider(action_name)
for opt in provider_options:
if opt['type'] == 'secret':
opt_name = opt['name']
pw_lookup_key = action_options[opt_name]['value']
pw_lookup_value = lookup_secret(pw_lookup_key)
action_options[opt_name]['value'] = pw_lookup_value
print("action name is: " + action_name)
action = action_provider.get_provider_instance(action_name, action_options)
if config_template.type == "per-endpoint":
if "af_endpoint_ip" not in post_vars or "af_endpoint_id" not in post_vars:
error = {
"output": "missing required authentication parameters",
"status": 1
}
return error
endpoint = dict()
endpoint["id"] = post_vars.get("af_endpoint_id", "")
endpoint["name"] = post_vars.get("af_endpoint_name", "")
endpoint["ip"] = post_vars.get("af_endpoint_ip", "")
endpoint["username"] = post_vars.get("af_endpoint_username", "")
endpoint["password"] = post_vars.get("af_endpoint_password", "")
endpoint["type"] = post_vars.get("af_endpoint_type", "")
action.set_endpoint(endpoint)
try:
results = action.execute_template(completed_template.strip().replace(
'\r\n', '\n'))
response = {"output": results.strip(), "status": 0}
except Exception as ex:
print(str(ex))
response = {"output": "Error executing template", "status": 1}
return response
