def main():
""" main entry point for module execution
"""
element_spec = dict(
name=dict(),
full_name=dict(),
role=dict(choices=ROLES),
encrypted_password=dict(no_log=True),
sshkey=dict(),
state=dict(choices=['present', 'absent'], default='present'),
active=dict(type='bool', default=True)
)
aggregate_spec = deepcopy(element_spec)
aggregate_spec['name'] = dict(required=True)
# 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, aliases=['collection', 'users']),
purge=dict(default=False, type='bool')
)
argument_spec.update(element_spec)
argument_spec.update(junos_argument_spec)
mutually_exclusive = [['aggregate', 'name']]
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
warnings = list()
result = {'changed': False, 'warnings': warnings}
want = map_params_to_obj(module)
ele = map_obj_to_ele(module, want)
purge_request = None
if module.params['purge']:
purge_request = handle_purge(module, want)
with locked_config(module):
if purge_request:
load_config(module, tostring(purge_request), warnings, action='replace')
diff = load_config(module, tostring(ele), 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 main():
""" main entry point for module execution
"""
argument_spec = dict(
hostname=dict(),
domain_name=dict(),
domain_search=dict(type='list'),
name_servers=dict(type='list'),
state=dict(choices=['present', 'absent'], default='present'),
active=dict(default=True, type='bool')
)
argument_spec.update(junos_argument_spec)
params = ['hostname', 'domain_name', 'domain_search', 'name_servers']
required_if = [('state', 'present', params, True),
('state', 'absent', params, True),
('state', 'active', params, True),
('state', 'suspend', params, True)]
module = AnsibleModule(argument_spec=argument_spec,
required_if=required_if,
supports_check_mode=True)
warnings = list()
result = {'changed': False}
if warnings:
result['warnings'] = warnings
top = 'system'
param_to_xpath_map = collections.OrderedDict()
param_to_xpath_map.update([
('hostname', {'xpath': 'host-name', 'leaf_only': True}),
('domain_name', {'xpath': 'domain-name', 'leaf_only': True}),
('domain_search', {'xpath': 'domain-search', 'leaf_only': True, 'value_req': True}),
('name_servers', {'xpath': 'name-server/name', 'is_key': True})
])
validate_param_values(module, param_to_xpath_map)
want = map_params_to_obj(module, param_to_xpath_map)
ele = map_obj_to_ele(module, want, top)
with locked_config(module):
diff = load_config(module, tostring(ele), 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 execute_module(self):
""" Execute the module
:rtype: A dictionary
:returns: The result from module execution
"""
result = {"changed": False}
warnings = list()
existing_lag_interfaces_facts = self.get_lag_interfaces_facts()
config_xmls = self.set_config(existing_lag_interfaces_facts)
with locked_config(self._module):
for config_xml in to_list(config_xmls):
diff = load_config(self._module, config_xml, warnings)
commit = not self._module.check_mode
if diff:
if commit:
commit_configuration(self._module)
else:
discard_changes(self._module)
result["changed"] = True
if self._module._diff:
result["diff"] = {"prepared": diff}
result["xml"] = config_xmls
changed_lag_interfaces_facts = self.get_lag_interfaces_facts()
result["before"] = existing_lag_interfaces_facts
if result["changed"]:
result["after"] = changed_lag_interfaces_facts
return result
def configure_device(module, warnings, candidate):
kwargs = {}
config_format = None
if module.params["src"]:
config_format = module.params["src_format"] or guess_format(
str(candidate)
)
if config_format == "set":
kwargs.update({"format": "text", "action": "set"})
else:
kwargs.update(
{"format": config_format, "action": module.params["update"]}
)
if isinstance(candidate, string_types):
candidate = candidate.split("\n")
# this is done to filter out `delete ...` statements which map to
# nothing in the config as that will cause an exception to be raised
if any((module.params["lines"], config_format == "set")):
candidate = filter_delete_statements(module, candidate)
kwargs["format"] = "text"
kwargs["action"] = "set"
return load_config(module, candidate, warnings, **kwargs)
def main():
""" main entry point for module execution
"""
neighbors_spec = dict(host=dict(), port=dict())
element_spec = dict(
name=dict(),
description=dict(),
enabled=dict(default=True, type="bool"),
speed=dict(),
mtu=dict(type="int"),
duplex=dict(choices=["full", "half", "auto"]),
tx_rate=dict(),
rx_rate=dict(),
neighbors=dict(type="list", elements="dict", options=neighbors_spec),
delay=dict(default=10, type="int"),
state=dict(
default="present", choices=["present", "absent", "up", "down"]
),
active=dict(default=True, type="bool"),
)
aggregate_spec = deepcopy(element_spec)
aggregate_spec["name"] = dict(required=True)
# 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_one_of = [["name", "aggregate"]]
mutually_exclusive = [["name", "aggregate"]]
module = AnsibleModule(
argument_spec=argument_spec,
required_one_of=required_one_of,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True,
)
warnings = list()
result = {"changed": False}
if warnings:
result["warnings"] = warnings
top = "interfaces/interface"
param_to_xpath_map = collections.OrderedDict()
param_to_xpath_map.update(
[
("name", {"xpath": "name", "is_key": True}),
("description", "description"),
("speed", "speed"),
("mtu", "mtu"),
("duplex", "link-mode"),
("disable", {"xpath": "disable", "tag_only": True}),
]
)
choice_to_value_map = {
"link-mode": {
"full": "full-duplex",
"half": "half-duplex",
"auto": "automatic",
}
}
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]
item = param.copy()
state = item.get("state")
item["disable"] = True if not item.get("enabled") else False
if state in ("present", "up", "down"):
item["state"] = "present"
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, value_map=choice_to_value_map, param=item
)
)
diff = None
with locked_config(module):
for req in requests:
diff = load_config(module, tostring(req), warnings, action="merge")
# issue commit after last configuration change is done
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}
failed_conditions = []
neighbors = None
for item in params:
state = item.get("state")
tx_rate = item.get("tx_rate")
rx_rate = item.get("rx_rate")
want_neighbors = item.get("neighbors")
if (
state not in ("up", "down")
and tx_rate is None
and rx_rate is None
and want_neighbors is None
):
continue
element = Element("get-interface-information")
intf_name = SubElement(element, "interface-name")
intf_name.text = item.get("name")
if result["changed"]:
sleep(item.get("delay"))
reply = exec_rpc(module, tostring(element), ignore_warning=False)
if state in ("up", "down"):
admin_status = reply.xpath(
"interface-information/physical-interface/admin-status"
)
if not admin_status or not conditional(
state, admin_status[0].text.strip()
):
failed_conditions.append("state " + "eq(%s)" % state)
if tx_rate:
output_bps = reply.xpath(
"interface-information/physical-interface/traffic-statistics/output-bps"
)
if not output_bps or not conditional(
tx_rate, output_bps[0].text.strip(), cast=int
):
failed_conditions.append("tx_rate " + tx_rate)
if rx_rate:
input_bps = reply.xpath(
"interface-information/physical-interface/traffic-statistics/input-bps"
)
if not input_bps or not conditional(
rx_rate, input_bps[0].text.strip(), cast=int
):
failed_conditions.append("rx_rate " + rx_rate)
if want_neighbors:
if neighbors is None:
element = Element("get-lldp-interface-neighbors")
intf_name = SubElement(element, "interface-device")
intf_name.text = item.get("name")
reply = exec_rpc(
module, tostring(element), ignore_warning=False
)
have_host = [
item.text
for item in reply.xpath(
"lldp-neighbors-information/lldp-neighbor-information/lldp-remote-system-name"
)
]
have_port = [
item.text
for item in reply.xpath(
"lldp-neighbors-information/lldp-neighbor-information/lldp-remote-port-id"
)
]
for neighbor in want_neighbors:
host = neighbor.get("host")
port = neighbor.get("port")
if host and host not in have_host:
failed_conditions.append("host " + host)
if port and port not in have_port:
failed_conditions.append("port " + port)
if failed_conditions:
msg = "One or more conditional statements have not been satisfied"
module.fail_json(msg=msg, failed_conditions=failed_conditions)
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
neighbors_spec = dict(host=dict(), port=dict())
element_spec = dict(name=dict(),
description=dict(),
enabled=dict(default=True, type='bool'),
speed=dict(),
mtu=dict(type='int'),
duplex=dict(choices=['full', 'half', 'auto']),
tx_rate=dict(),
rx_rate=dict(),
neighbors=dict(type='list',
elements='dict',
options=neighbors_spec),
delay=dict(default=10, type='int'),
state=dict(default='present',
choices=['present', 'absent', 'up',
'down']),
active=dict(default=True, type='bool'))
aggregate_spec = deepcopy(element_spec)
aggregate_spec['name'] = dict(required=True)
# 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_one_of = [['name', 'aggregate']]
mutually_exclusive = [['name', 'aggregate']]
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=required_one_of,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
warnings = list()
result = {'changed': False}
if warnings:
result['warnings'] = warnings
top = 'interfaces/interface'
param_to_xpath_map = collections.OrderedDict()
param_to_xpath_map.update([('name', {
'xpath': 'name',
'is_key': True
}), ('description', 'description'), ('speed', 'speed'), ('mtu', 'mtu'),
('duplex', 'link-mode'),
('disable', {
'xpath': 'disable',
'tag_only': True
})])
choice_to_value_map = {
'link-mode': {
'full': 'full-duplex',
'half': 'half-duplex',
'auto': 'automatic'
}
}
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]
item = param.copy()
state = item.get('state')
item['disable'] = True if not item.get('enabled') else False
if state in ('present', 'up', 'down'):
item['state'] = 'present'
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,
value_map=choice_to_value_map,
param=item))
diff = None
with locked_config(module):
for req in requests:
diff = load_config(module, tostring(req), warnings, action='merge')
# issue commit after last configuration change is done
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}
failed_conditions = []
neighbors = None
for item in params:
state = item.get('state')
tx_rate = item.get('tx_rate')
rx_rate = item.get('rx_rate')
want_neighbors = item.get('neighbors')
if state not in (
'up', 'down'
) and tx_rate is None and rx_rate is None and want_neighbors is None:
continue
element = Element('get-interface-information')
intf_name = SubElement(element, 'interface-name')
intf_name.text = item.get('name')
if result['changed']:
sleep(item.get('delay'))
reply = exec_rpc(module, tostring(element), ignore_warning=False)
if state in ('up', 'down'):
admin_status = reply.xpath(
'interface-information/physical-interface/admin-status')
if not admin_status or not conditional(
state, admin_status[0].text.strip()):
failed_conditions.append('state ' + 'eq(%s)' % state)
if tx_rate:
output_bps = reply.xpath(
'interface-information/physical-interface/traffic-statistics/output-bps'
)
if not output_bps or not conditional(
tx_rate, output_bps[0].text.strip(), cast=int):
failed_conditions.append('tx_rate ' + tx_rate)
if rx_rate:
input_bps = reply.xpath(
'interface-information/physical-interface/traffic-statistics/input-bps'
)
if not input_bps or not conditional(
rx_rate, input_bps[0].text.strip(), cast=int):
failed_conditions.append('rx_rate ' + rx_rate)
if want_neighbors:
if neighbors is None:
element = Element('get-lldp-interface-neighbors')
intf_name = SubElement(element, 'interface-device')
intf_name.text = item.get('name')
reply = exec_rpc(module,
tostring(element),
ignore_warning=False)
have_host = [
item.text for item in reply.xpath(
'lldp-neighbors-information/lldp-neighbor-information/lldp-remote-system-name'
)
]
have_port = [
item.text for item in reply.xpath(
'lldp-neighbors-information/lldp-neighbor-information/lldp-remote-port-id'
)
]
for neighbor in want_neighbors:
host = neighbor.get('host')
port = neighbor.get('port')
if host and host not in have_host:
failed_conditions.append('host ' + host)
if port and port not in have_port:
failed_conditions.append('port ' + port)
if failed_conditions:
msg = 'One or more conditional statements have not been satisfied'
module.fail_json(msg=msg, failed_conditions=failed_conditions)
module.exit_json(**result)
def main():
""" main entry point for module execution
"""
argument_spec = dict(
name=dict(),
state=dict(
default="present",
choices=["present", "absent", "enabled", "disabled"],
),
active=dict(default=True, type="bool"),
)
argument_spec.update(junos_argument_spec)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
warnings = list()
result = {"changed": False}
if warnings:
result["warnings"] = warnings
top = "protocols/lldp/interface"
param_to_xpath_map = collections.OrderedDict()
param_to_xpath_map.update([
("name", {
"xpath": "name",
"is_key": True
}),
("disable", {
"xpath": "disable",
"tag_only": True
}),
])
item = module.params.copy()
state = item.get("state")
item["disable"] = True if state in ("disabled", "absent") else False
if state in ("enabled", "disabled"):
item["state"] = "present"
want = map_params_to_obj(module, param_to_xpath_map, param=item)
ele = map_obj_to_ele(module, want, top, param=item)
with locked_config(module):
diff = load_config(module, tostring(ele), 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 main():
""" main entry point for module execution
"""
argument_spec = dict(
hostname=dict(),
domain_name=dict(),
domain_search=dict(type="list"),
name_servers=dict(type="list"),
state=dict(choices=["present", "absent"], default="present"),
active=dict(default=True, type="bool"),
)
argument_spec.update(junos_argument_spec)
params = ["hostname", "domain_name", "domain_search", "name_servers"]
required_if = [
("state", "present", params, True),
("state", "absent", params, True),
("state", "active", params, True),
("state", "suspend", params, True),
]
module = AnsibleModule(
argument_spec=argument_spec,
required_if=required_if,
supports_check_mode=True,
)
warnings = list()
result = {"changed": False}
if warnings:
result["warnings"] = warnings
top = "system"
param_to_xpath_map = collections.OrderedDict()
param_to_xpath_map.update([
("hostname", {
"xpath": "host-name",
"leaf_only": True
}),
("domain_name", {
"xpath": "domain-name",
"leaf_only": True
}),
(
"domain_search",
{
"xpath": "domain-search",
"leaf_only": True,
"value_req": True,
},
),
("name_servers", {
"xpath": "name-server/name",
"is_key": True
}),
])
validate_param_values(module, param_to_xpath_map)
want = map_params_to_obj(module, param_to_xpath_map)
ele = map_obj_to_ele(module, want, top)
with locked_config(module):
diff = load_config(module, tostring(ele), 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 main():
""" main entry point for module execution
"""
element_spec = dict(address=dict(aliases=['prefix']),
next_hop=dict(),
preference=dict(type='int',
aliases=['admin_distance']),
qualified_next_hop=dict(type='str'),
qualified_preference=dict(type='int'),
state=dict(default='present',
choices=['present', 'absent']),
active=dict(default=True, type='bool'))
aggregate_spec = deepcopy(element_spec)
aggregate_spec['address'] = dict(required=True)
# 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),
purge=dict(default=False, type='bool'))
argument_spec.update(element_spec)
argument_spec.update(junos_argument_spec)
required_one_of = [['aggregate', 'address']]
mutually_exclusive = [['aggregate', 'address']]
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=required_one_of,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
warnings = list()
result = {'changed': False}
if warnings:
result['warnings'] = warnings
top = 'routing-options/static/route'
param_to_xpath_map = collections.OrderedDict()
param_to_xpath_map.update([('address', {
'xpath': 'name',
'is_key': True
}), ('next_hop', 'next-hop'), ('preference', 'preference/metric-value'),
('qualified_next_hop', {
'xpath': 'name',
'top': 'qualified-next-hop'
}),
('qualified_preference', {
'xpath': 'preference',
'top': 'qualified-next-hop'
})])
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]
item = param.copy()
if item['state'] == 'present':
if not item['address'] and item['next_hop']:
module.fail_json(
msg=
"parameters are required together: ['address', 'next_hop']"
)
want = map_params_to_obj(module, param_to_xpath_map, param=item)
requests.append(map_obj_to_ele(module, want, top, param=item))
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 main():
""" main entry point for module execution
"""
element_spec = dict(
address=dict(aliases=["prefix"]),
next_hop=dict(),
preference=dict(type="int", aliases=["admin_distance"]),
qualified_next_hop=dict(type="str"),
qualified_preference=dict(type="int"),
state=dict(default="present", choices=["present", "absent"]),
active=dict(default=True, type="bool"),
)
aggregate_spec = deepcopy(element_spec)
aggregate_spec["address"] = dict(required=True)
# 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),
purge=dict(default=False, type="bool"),
)
argument_spec.update(element_spec)
argument_spec.update(junos_argument_spec)
required_one_of = [["aggregate", "address"]]
mutually_exclusive = [["aggregate", "address"]]
module = AnsibleModule(
argument_spec=argument_spec,
required_one_of=required_one_of,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True,
)
warnings = list()
result = {"changed": False}
if warnings:
result["warnings"] = warnings
top = "routing-options/static/route"
param_to_xpath_map = collections.OrderedDict()
param_to_xpath_map.update([
("address", {
"xpath": "name",
"is_key": True
}),
("next_hop", "next-hop"),
("preference", "preference/metric-value"),
(
"qualified_next_hop",
{
"xpath": "name",
"top": "qualified-next-hop"
},
),
(
"qualified_preference",
{
"xpath": "preference",
"top": "qualified-next-hop"
},
),
])
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]
item = param.copy()
if item["state"] == "present":
if not item["address"] and item["next_hop"]:
module.fail_json(
msg=
"parameters are required together: ['address', 'next_hop']"
)
want = map_params_to_obj(module, param_to_xpath_map, param=item)
requests.append(map_obj_to_ele(module, want, top, param=item))
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)
