def map_params_to_obj(module, required_if=None):
obj = []
aggregate = module.params.get("aggregate")
if aggregate:
for item in aggregate:
for key in item:
if item.get(key) is None:
item[key] = module.params[key]
try:
check_required_if(required_if, item)
except TypeError as exc:
module.fail_json(to_text(exc))
obj.append(item.copy())
else:
if module.params["dest"] not in ("host", "file", "user"):
module.params["name"] = None
obj.append({
"dest": module.params["dest"],
"name": module.params["name"],
"facility": module.params["facility"],
"level": module.params["level"],
"state": module.params["state"],
})
return obj
def map_params_to_obj(module, required_if=None):
obj = []
aggregate = module.params.get("aggregate")
if aggregate:
for item in aggregate:
for key in item:
if item.get(key) is None:
item[key] = module.params[key]
try:
check_required_if(required_if, item)
except TypeError as exc:
module.fail_json(to_text(exc))
d = item.copy()
if d["dest"] != "host":
d["name"] = None
if d["dest"] == "buffered":
if "size" in d:
d["size"] = str(validate_size(d["size"], module))
elif "size" not in d:
d["size"] = str(4096)
else:
pass
if d["dest"] != "buffered":
d["size"] = None
obj.append(d)
else:
if module.params["dest"] != "host":
module.params["name"] = None
if module.params["dest"] == "buffered":
if not module.params["size"]:
module.params["size"] = str(4096)
else:
module.params["size"] = None
if module.params["size"] is None:
obj.append({
"dest": module.params["dest"],
"name": module.params["name"],
"size": module.params["size"],
"facility": module.params["facility"],
"level": module.params["level"],
"state": module.params["state"],
})
else:
obj.append({
"dest":
module.params["dest"],
"name":
module.params["name"],
"size":
str(validate_size(module.params["size"], module)),
"facility":
module.params["facility"],
"level":
module.params["level"],
"state":
module.params["state"],
})
return obj
def test_check_required_if_missing_required():
arguments_terms = [["state", "present", ("path", "owner"), True]]
params = {"state": "present"}
expected = "state is present but any of the following are missing: path, owner"
with pytest.raises(TypeError) as e:
check_required_if(arguments_terms, params)
assert to_native(e.value) == expected
def test_check_required_if_multiple():
arguments_terms = [["state", "present", ("path", "owner")]]
params = {
"state": "present",
"path": "/foo",
"owner": "root",
}
options_context = ["foo_context"]
assert check_required_if(arguments_terms, params) == []
assert check_required_if(arguments_terms, params, options_context) == []
def test_check_required_if_missing_multiple_with_context():
arguments_terms = [["state", "present", ("path", "owner")]]
params = {
"state": "present",
}
options_context = ["foo_context"]
expected = "state is present but all of the following are missing: path, owner found in foo_context"
with pytest.raises(TypeError) as e:
check_required_if(arguments_terms, params, options_context)
assert to_native(e.value) == expected
def _check_required_if(self, spec, param=None):
''' ensure that parameters which conditionally required are present '''
if spec is None:
return
if param is None:
param = self.params
try:
check_required_if(spec, param)
except TypeError as e:
msg = to_native(e)
if self._options_context:
msg += " found in %s" % " -> ".join(self._options_context)
self.fail_json(msg=msg)
def main():
"""main entry point for module execution"""
element_spec = dict(
dest=dict(choices=["console", "host", "file", "user"]),
name=dict(),
facility=dict(),
level=dict(),
rotate_frequency=dict(type="int"),
size=dict(type="int"),
files=dict(type="int"),
state=dict(default="present", choices=["present", "absent"]),
active=dict(default=True, type="bool"),
)
aggregate_spec = deepcopy(element_spec)
# remove default in aggregate spec, to handle common arguments
remove_default_spec(aggregate_spec)
argument_spec = dict(
aggregate=dict(type="list", elements="dict", options=aggregate_spec))
argument_spec.update(element_spec)
argument_spec.update(junos_argument_spec)
required_if = [
("dest", "host", ["name", "facility", "level"]),
("dest", "file", ["name", "facility", "level"]),
("dest", "user", ["name", "facility", "level"]),
("dest", "console", ["facility", "level"]),
]
module = AnsibleModule(
argument_spec=argument_spec,
required_if=required_if,
supports_check_mode=True,
)
warnings = list()
result = {"changed": False}
if warnings:
result["warnings"] = warnings
params = to_param_list(module)
requests = list()
for param in params:
# if key doesn't exist in the item, get it from module.params
for key in param:
if param.get(key) is None:
param[key] = module.params[key]
try:
check_required_if(required_if, param)
except TypeError as exc:
module.fail_json(to_text(exc))
item = param.copy()
dest = item.get("dest")
if dest == "console" and item.get("name"):
module.fail_json(msg="%s and %s are mutually exclusive" %
("console", "name"))
top = "system/syslog"
is_facility_key = False
field_top = None
if dest:
if dest == "console":
field_top = dest
is_facility_key = True
else:
field_top = dest + "/contents"
is_facility_key = False
param_to_xpath_map = collections.OrderedDict()
param_to_xpath_map.update([
("name", {
"xpath": "name",
"is_key": True,
"top": dest
}),
(
"facility",
{
"xpath": "name",
"is_key": is_facility_key,
"top": field_top,
},
),
(
"size",
{
"xpath": "size",
"leaf_only": True,
"is_key": True,
"top": "archive",
},
),
(
"files",
{
"xpath": "files",
"leaf_only": True,
"is_key": True,
"top": "archive",
},
),
(
"rotate_frequency",
{
"xpath": "log-rotate-frequency",
"leaf_only": True
},
),
])
if item.get("level"):
param_to_xpath_map["level"] = {
"xpath": item.get("level"),
"tag_only": True,
"top": field_top,
}
validate_param_values(module, param_to_xpath_map, param=item)
want = map_params_to_obj(module, param_to_xpath_map, param=item)
requests.append(map_obj_to_ele(module, want, top, param=item))
diff = None
with locked_config(module):
for req in requests:
diff = load_config(module, tostring(req), warnings, action="merge")
commit = not module.check_mode
if diff:
if commit:
commit_configuration(module)
else:
discard_changes(module)
result["changed"] = True
if module._diff:
result["diff"] = {"prepared": diff}
module.exit_json(**result)
def test_check_required_if():
arguments_terms = {}
params = {}
assert check_required_if(arguments_terms, params) == []
