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