def main():
argument_spec = dict(anycast_gateway_mac=dict(required=True, type="str"))
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
warnings = list()
result = {"changed": False, "commands": [], "warnings": warnings}
args = PARAM_TO_COMMAND_KEYMAP.keys()
existing = get_existing(module, args)
proposed = dict((k, v) for k, v in module.params.items()
if v is not None and k in args)
candidate = CustomNetworkConfig(indent=3)
get_commands(module, existing, proposed, candidate)
if candidate:
candidate = candidate.items_text()
result["commands"] = candidate
if not module.check_mode:
load_config(module, candidate)
result["changed"] = True
module.exit_json(**result)
def get_existing(module, args, warnings):
existing = {}
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
asn_regex = re.compile(r'.*router\sbgp\s(?P<existing_asn>\d+(\.\d+)?).*',
re.S)
match_asn = asn_regex.match(str(netcfg))
if match_asn:
existing_asn = match_asn.group('existing_asn')
parents = ["router bgp {0}".format(existing_asn)]
if module.params['vrf'] != 'default':
parents.append('vrf {0}'.format(module.params['vrf']))
parents.append('neighbor {0}'.format(module.params['neighbor']))
parents.append('address-family {0} {1}'.format(module.params['afi'],
module.params['safi']))
config = netcfg.get_section(parents)
if config:
for arg in args:
if arg not in ['asn', 'vrf', 'neighbor', 'afi', 'safi']:
existing[arg] = get_value(arg, config, module)
existing['asn'] = existing_asn
existing['neighbor'] = module.params['neighbor']
existing['vrf'] = module.params['vrf']
existing['afi'] = module.params['afi']
existing['safi'] = module.params['safi']
else:
warnings.append(
"The BGP process didn't exist but the task just created it.")
return existing
def get_existing(module, args, warnings):
existing = {}
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module, flags=['bgp all']))
asn_re = re.compile(r'.*router\sbgp\s(?P<existing_asn>\d+(\.\d+)?).*', re.S)
asn_match = asn_re.match(str(netcfg))
if asn_match:
existing_asn = asn_match.group('existing_asn')
bgp_parent = 'router bgp {0}'.format(existing_asn)
if module.params['vrf'] != 'default':
parents = [bgp_parent, 'vrf {0}'.format(module.params['vrf'])]
else:
parents = [bgp_parent]
config = netcfg.get_section(parents)
if config:
for arg in args:
if arg != 'asn' and (module.params['vrf'] == 'default' or
arg not in GLOBAL_PARAMS):
existing[arg] = get_value(arg, config)
existing['asn'] = existing_asn
if module.params['vrf'] == 'default':
existing['vrf'] = 'default'
if not existing and module.params['vrf'] != 'default' and module.params['state'] == 'present':
msg = ("VRF {0} doesn't exist.".format(module.params['vrf']))
warnings.append(msg)
return existing
def get_existing(module, args):
existing = {}
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
interface_exist = check_interface(module, netcfg)
if interface_exist:
parents = ["interface {0}".format(interface_exist)]
temp_config = netcfg.get_section(parents)
if ("member vni {0} associate-vrf".format(module.params["vni"])
in temp_config):
parents.append("member vni {0} associate-vrf".format(
module.params["vni"]))
config = netcfg.get_section(parents)
elif "member vni {0}".format(module.params["vni"]) in temp_config:
parents.append("member vni {0}".format(module.params["vni"]))
config = netcfg.get_section(parents)
else:
config = {}
if config:
for arg in args:
if arg not in ["interface", "vni"]:
existing[arg] = get_value(arg, config, module)
existing["interface"] = interface_exist
existing["vni"] = module.params["vni"]
return existing, interface_exist
def get_existing(module, args, warnings):
existing = {}
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
asn_regex = re.compile(r".*router\sbgp\s(?P<existing_asn>\d+(\.\d+)?).*",
re.S)
match_asn = asn_regex.match(str(netcfg))
if match_asn:
existing_asn = match_asn.group("existing_asn")
parents = ["router bgp {0}".format(existing_asn)]
if module.params["vrf"] != "default":
parents.append("vrf {0}".format(module.params["vrf"]))
parents.append("neighbor {0}".format(module.params["neighbor"]))
parents.append("address-family {0} {1}".format(module.params["afi"],
module.params["safi"]))
config = netcfg.get_section(parents)
if config:
for arg in args:
if arg not in ["asn", "vrf", "neighbor", "afi", "safi"]:
existing[arg] = get_value(arg, config, module)
existing["asn"] = existing_asn
existing["neighbor"] = module.params["neighbor"]
existing["vrf"] = module.params["vrf"]
existing["afi"] = module.params["afi"]
existing["safi"] = module.params["safi"]
else:
warnings.append(
"The BGP process didn't exist but the task just created it.")
return existing
def main():
argument_spec = dict(
bfd=dict(required=False, type="str", choices=["enable", "disable"]),
ssm_range=dict(required=False, type="list", default=[],
elements="str"),
)
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
warnings = list()
result = {"changed": False, "commands": [], "warnings": warnings}
params = module.params
args = [k for k in PARAM_TO_COMMAND_KEYMAP.keys() if params[k] is not None]
# SSM syntax check
if "ssm_range" in args:
for item in params["ssm_range"]:
if re.search("none|default", item):
break
if len(item.split(".")) != 4:
module.fail_json(
msg="Valid ssm_range values are multicast addresses "
"or the keyword 'none' or the keyword 'default'.", )
existing = get_existing(module, args)
proposed_args = dict((k, v) for k, v in params.items() if k in args)
proposed = {}
for key, value in proposed_args.items():
if key == "ssm_range":
if value and value[0] == "default":
if existing.get(key):
proposed[key] = "default"
else:
v = sorted(set([str(i) for i in value]))
ex = sorted(set([str(i) for i in existing.get(key, [])]))
if v != ex:
proposed[key] = " ".join(str(s) for s in v)
elif key == "bfd":
if value != existing.get("bfd", "disable"):
proposed[key] = value
elif value != existing.get(key):
proposed[key] = value
candidate = CustomNetworkConfig(indent=3)
get_commands(module, existing, proposed, candidate)
if candidate:
candidate = candidate.items_text()
result["commands"] = candidate
result["changed"] = True
load_config(module, candidate)
module.exit_json(**result)
def main():
argument_spec = dict(
bfd=dict(required=False, type='str', choices=['enable', 'disable']),
ssm_range=dict(required=False, type='list', default=[]),
)
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
warnings = list()
result = {'changed': False, 'commands': [], 'warnings': warnings}
params = module.params
args = [k for k in PARAM_TO_COMMAND_KEYMAP.keys() if params[k] is not None]
# SSM syntax check
if 'ssm_range' in args:
for item in params['ssm_range']:
if re.search('none|default', item):
break
if len(item.split('.')) != 4:
module.fail_json(msg="Valid ssm_range values are multicast addresses "
"or the keyword 'none' or the keyword 'default'.")
existing = get_existing(module, args)
proposed_args = dict((k, v) for k, v in params.items() if k in args)
proposed = {}
for key, value in proposed_args.items():
if key == 'ssm_range':
if value and value[0] == 'default':
if existing.get(key):
proposed[key] = 'default'
else:
v = sorted(set([str(i) for i in value]))
ex = sorted(set([str(i) for i in existing.get(key, [])]))
if v != ex:
proposed[key] = ' '.join(str(s) for s in v)
elif key == 'bfd':
if value != existing.get('bfd', 'disable'):
proposed[key] = value
elif value != existing.get(key):
proposed[key] = value
candidate = CustomNetworkConfig(indent=3)
get_commands(module, existing, proposed, candidate)
if candidate:
candidate = candidate.items_text()
result['commands'] = candidate
result['changed'] = True
load_config(module, candidate)
module.exit_json(**result)
def main():
argument_spec = dict(
vni=dict(required=True, type="str"),
route_distinguisher=dict(required=False, type="str"),
route_target_both=dict(required=False, type="list"),
route_target_import=dict(required=False, type="list"),
route_target_export=dict(required=False, type="list"),
state=dict(
choices=["present", "absent"], default="present", required=False
),
)
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(
argument_spec=argument_spec, supports_check_mode=True
)
warnings = list()
results = dict(changed=False, warnings=warnings)
state = module.params["state"]
args = PARAM_TO_COMMAND_KEYMAP.keys()
existing = get_existing(module, args)
proposed_args = dict(
(k, v) for k, v in module.params.items() if v is not None and k in args
)
commands = []
parents = []
proposed = {}
for key, value in proposed_args.items():
if key != "vni":
if value == "true":
value = True
elif value == "false":
value = False
if existing.get(key) != value:
proposed[key] = value
if state == "present":
commands, parents = state_present(module, existing, proposed)
elif state == "absent" and existing:
commands, parents = state_absent(module, existing, proposed)
if commands:
candidate = CustomNetworkConfig(indent=3)
candidate.add(commands, parents=parents)
candidate = candidate.items_text()
if not module.check_mode:
load_config(module, candidate)
results["changed"] = True
results["commands"] = candidate
else:
results["commands"] = []
module.exit_json(**results)
def parse_mode(module, config, group, member):
mode = None
netcfg = CustomNetworkConfig(indent=1, contents=config)
parents = ["interface {0}".format(member)]
body = netcfg.get_section(parents)
match_int = re.findall("interface {0}\\n".format(member), body, re.M)
if match_int:
match = re.search("channel-group {0} mode (\\S+)".format(group), body,
re.M)
if match:
mode = match.group(1)
return mode
def has_lldp(module):
config = get_config(module)
netcfg = CustomNetworkConfig(indent=1, contents=config)
parents = [PROTOCOL]
body = netcfg.get_section(parents)
for line in body.split('\n'):
l = line.strip()
match = re.search(r'disable', l, re.M)
if match:
return False
return True
def get_existing(module, args):
existing = {}
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
if module.params['interface'].startswith('loopback') or module.params['interface'].startswith('port-channel'):
parents = ['interface {0}'.format(module.params['interface'])]
else:
parents = ['interface {0}'.format(module.params['interface'].capitalize())]
config = netcfg.get_section(parents)
if 'ospf' in config:
for arg in args:
if arg not in ['interface']:
existing[arg] = get_value(arg, config, module)
existing['interface'] = module.params['interface']
return existing
def main():
element_spec = dict(
prefix=dict(type='str', aliases=['address']),
next_hop=dict(type='str'),
vrf=dict(type='str', default='default'),
tag=dict(type='str'),
route_name=dict(type='str'),
pref=dict(type='str', aliases=['admin_distance']),
state=dict(choices=['absent', 'present'], default='present'),
track=dict(type='int'),
)
aggregate_spec = deepcopy(element_spec)
aggregate_spec['prefix'] = dict(required=True)
aggregate_spec['next_hop'] = 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(nxos_argument_spec)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
warnings = list()
result = {'changed': False, 'commands': []}
if warnings:
result['warnings'] = warnings
want = map_params_to_obj(module)
for w in want:
prefix = normalize_prefix(module, w['prefix'])
candidate = CustomNetworkConfig(indent=3)
reconcile_candidate(module, candidate, prefix, w)
if not module.check_mode and candidate:
candidate = candidate.items_text()
load_config(module, candidate)
result['commands'].extend(candidate)
result['changed'] = True
module.exit_json(**result)
def get_existing(module, args, warnings):
existing = {}
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
asn_regex = re.compile(
r".*router\sbgp\s(?P<existing_asn>\d+(\.\d+)?).*", re.DOTALL
)
match_asn = asn_regex.match(str(netcfg))
if match_asn:
existing_asn = match_asn.group("existing_asn")
parents = ["router bgp {0}".format(existing_asn)]
if module.params["vrf"] != "default":
parents.append("vrf {0}".format(module.params["vrf"]))
parents.append(
"address-family {0} {1}".format(
module.params["afi"], module.params["safi"]
)
)
config = netcfg.get_section(parents)
if config:
for arg in args:
if arg not in ["asn", "afi", "safi", "vrf"]:
gv = get_value(arg, config, module)
if gv:
existing[arg] = gv
else:
if (
arg != "client_to_client"
and arg in PARAM_TO_DEFAULT_KEYMAP.keys()
):
existing[arg] = PARAM_TO_DEFAULT_KEYMAP.get(arg)
else:
existing[arg] = gv
existing["asn"] = existing_asn
existing["afi"] = module.params["afi"]
existing["safi"] = module.params["safi"]
existing["vrf"] = module.params["vrf"]
else:
warnings.append(
"The BGP process {0} didn't exist but the task just created it.".format(
module.params["asn"]
)
)
return existing
def main():
element_spec = dict(
prefix=dict(type="str", aliases=["address"]),
next_hop=dict(type="str"),
vrf=dict(type="str", default="default"),
tag=dict(type="str"),
route_name=dict(type="str"),
pref=dict(type="str", aliases=["admin_distance"]),
state=dict(choices=["absent", "present"], default="present"),
track=dict(type="int"),
)
aggregate_spec = deepcopy(element_spec)
aggregate_spec["prefix"] = dict(required=True)
aggregate_spec["next_hop"] = 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(nxos_argument_spec)
module = AnsibleModule(
argument_spec=argument_spec, supports_check_mode=True
)
warnings = list()
result = {"changed": False, "commands": []}
if warnings:
result["warnings"] = warnings
want = map_params_to_obj(module)
for w in want:
prefix = normalize_prefix(module, w["prefix"])
candidate = CustomNetworkConfig(indent=3)
reconcile_candidate(module, candidate, prefix, w)
if not module.check_mode and candidate:
candidate = candidate.items_text()
load_config(module, candidate)
result["commands"].extend(candidate)
result["changed"] = True
module.exit_json(**result)
def get_existing(module):
existing = []
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
if module.params["mode"] == "maintenance":
parents = ["configure maintenance profile maintenance-mode"]
else:
parents = ["configure maintenance profile normal-mode"]
config = netcfg.get_section(parents)
if config:
existing = config.splitlines()
existing = [cmd.strip() for cmd in existing]
existing.pop(0)
return existing
def reconcile_candidate(module, candidate, prefix, want):
state, vrf = want['state'], want['vrf']
if vrf == 'default':
parents = []
flags = " | include '^ip route'"
else:
parents = ['vrf context {0}'.format(vrf)]
flags = " | section '{0}' | include '^ ip route'".format(parents[0])
# Find existing routes in this vrf/default
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module, flags=[flags]))
routes = str(netcfg).split('\n')
# strip whitespace from route strings
routes = [i.strip() for i in routes]
prefix_and_nh = 'ip route {0} {1}'.format(prefix, want['next_hop'])
existing = [i for i in routes if i.startswith(prefix_and_nh)]
proposed = set_route_command(prefix, want, module)
commands = []
if state == 'absent' and existing:
commands = ['no ' + existing[0]]
elif state == 'present' and proposed not in routes:
if existing:
commands = ['no ' + existing[0]]
commands.append(proposed)
if commands:
candidate.add(commands, parents=parents)
def get_existing(module, args):
existing = {}
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
if module.params["interface"].startswith("loopback") or module.params[
"interface"].startswith("port-channel"):
parents = ["interface {0}".format(module.params["interface"])]
else:
parents = [
"interface {0}".format(module.params["interface"].capitalize())
]
config = netcfg.get_section(parents)
if "ospf" in config:
for arg in args:
if arg not in ["interface"]:
existing[arg] = get_value(arg, config, module)
existing["interface"] = module.params["interface"]
return existing
def main():
argument_spec = dict(
ospf=dict(required=True, type="str"),
state=dict(
choices=["present", "absent"], default="present", required=False
),
)
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(
argument_spec=argument_spec, supports_check_mode=True
)
warnings = list()
result = dict(changed=False, warnings=warnings)
state = module.params["state"]
ospf = str(module.params["ospf"])
existing = get_existing(module)
proposed = dict(ospf=ospf)
if not existing:
existing_list = []
else:
existing_list = existing["ospf"]
candidate = CustomNetworkConfig(indent=3)
if state == "present" and ospf not in existing_list:
state_present(module, proposed, candidate)
if state == "absent" and ospf in existing_list:
state_absent(module, proposed, candidate)
if candidate:
candidate = candidate.items_text()
load_config(module, candidate)
result["changed"] = True
result["commands"] = candidate
else:
result["commands"] = []
module.exit_json(**result)
def get_existing(module, args, warnings):
existing = {}
netcfg = CustomNetworkConfig(
indent=2, contents=get_config(module, flags=["bgp all"])
)
asn_re = re.compile(
r".*router\sbgp\s(?P<existing_asn>\d+(\.\d+)?).*", re.S
)
asn_match = asn_re.match(str(netcfg))
if asn_match:
existing_asn = asn_match.group("existing_asn")
bgp_parent = "router bgp {0}".format(existing_asn)
if module.params["vrf"] != "default":
parents = [bgp_parent, "vrf {0}".format(module.params["vrf"])]
else:
parents = [bgp_parent]
config = netcfg.get_section(parents)
if config:
for arg in args:
if arg != "asn" and (
module.params["vrf"] == "default"
or arg not in GLOBAL_PARAMS
):
existing[arg] = get_value(arg, config)
existing["asn"] = existing_asn
if module.params["vrf"] == "default":
existing["vrf"] = "default"
if (
not existing
and module.params["vrf"] != "default"
and module.params["state"] == "present"
):
msg = "VRF {0} doesn't exist.".format(module.params["vrf"])
warnings.append(msg)
return existing
def get_existing(module, args, warnings):
existing = {}
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
asn_regex = re.compile(r'.*router\sbgp\s(?P<existing_asn>\d+(\.\d+)?).*',
re.DOTALL)
match_asn = asn_regex.match(str(netcfg))
if match_asn:
existing_asn = match_asn.group('existing_asn')
parents = ["router bgp {0}".format(existing_asn)]
if module.params['vrf'] != 'default':
parents.append('vrf {0}'.format(module.params['vrf']))
parents.append('address-family {0} {1}'.format(module.params['afi'],
module.params['safi']))
config = netcfg.get_section(parents)
if config:
for arg in args:
if arg not in ['asn', 'afi', 'safi', 'vrf']:
gv = get_value(arg, config, module)
if gv:
existing[arg] = gv
else:
if arg != 'client_to_client' and arg in PARAM_TO_DEFAULT_KEYMAP.keys(
):
existing[arg] = PARAM_TO_DEFAULT_KEYMAP.get(arg)
else:
existing[arg] = gv
existing['asn'] = existing_asn
existing['afi'] = module.params['afi']
existing['safi'] = module.params['safi']
existing['vrf'] = module.params['vrf']
else:
warnings.append(
"The BGP process {0} didn't exist but the task just created it.".
format(module.params['asn']))
return existing
def get_existing(module, args):
existing = {}
netcfg = CustomNetworkConfig(indent=2,
contents=get_config(module, flags=["all"]))
interface_string = "interface {0}".format(
module.params["interface"].lower())
parents = [interface_string]
config = netcfg.get_section(parents)
if config:
for arg in args:
existing[arg] = get_value(arg, config, module)
existing["interface"] = module.params["interface"].lower()
else:
if interface_string in str(netcfg):
existing["interface"] = module.params["interface"].lower()
for arg in args:
existing[arg] = ""
return existing
def get_existing(module, args):
existing = {}
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
parents = ['evpn', 'vni {0} l2'.format(module.params['vni'])]
config = netcfg.get_section(parents)
if config:
for arg in args:
if arg != 'vni':
if arg == 'route_distinguisher':
existing[arg] = get_value(arg, config, module)
else:
existing[arg] = get_route_target_value(arg, config, module)
existing_fix = dict((k, v) for k, v in existing.items() if v)
if not existing_fix:
existing = existing_fix
existing['vni'] = module.params['vni']
return existing
def map_config_to_obj(module):
objs = list()
output = None
command = ["show vlan brief | json"]
output = run_commands(module, command, check_rc="retry_json")[0]
if output:
netcfg = CustomNetworkConfig(indent=2,
contents=get_config(module,
flags=["all"]))
if isinstance(output, dict):
vlans = None
try:
vlans = output["TABLE_vlanbriefxbrief"]["ROW_vlanbriefxbrief"]
except KeyError:
return objs
if vlans:
if isinstance(vlans, list):
for vlan in vlans:
obj = parse_vlan_options(module, netcfg, output, vlan)
objs.append(obj)
elif isinstance(vlans, dict):
obj = parse_vlan_options(module, netcfg, output, vlans)
objs.append(obj)
else:
vlans = list()
splitted_line = re.split(r"\n(\d+)|\n{2}", output.strip())
for line in splitted_line:
if not line:
continue
if len(line) > 0:
line = line.strip()
if line[0].isdigit():
match = re.search(r"^(\d+)$", line, re.M)
if match:
v = match.group(1)
pos1 = splitted_line.index(v)
pos2 = pos1 + 1
# fmt: off
vlaninfo = "".join(splitted_line[pos1:pos2 + 1])
# fmt: on
vlans.append(vlaninfo)
if vlans:
objs = parse_vlan_non_structured(module, netcfg, vlans)
else:
return objs
return objs
def map_config_to_obj(want, module):
objs = list()
netcfg = CustomNetworkConfig(indent=2, contents=get_config(module))
for w in want:
parents = ["interface {0}".format(w["name"])]
config = netcfg.get_section(parents)
obj = dict(name=None, ipv4=None, ipv6=[])
if config:
match_name = re.findall(r"interface (\S+)", config, re.M)
if match_name:
obj["name"] = normalize_interface(match_name[0])
match_ipv4 = re.findall(r"ip address (\S+)", config, re.M)
if match_ipv4:
obj["ipv4"] = match_ipv4[0]
match_ipv6 = re.findall(r"ipv6 address (\S+)", config, re.M)
if match_ipv6:
obj["ipv6"] = match_ipv6
objs.append(obj)
return objs
def main():
argument_spec = dict(
rp_address=dict(required=True, type="str"),
group_list=dict(required=False, type="str"),
prefix_list=dict(required=False, type="str"),
route_map=dict(required=False, type="str"),
bidir=dict(required=False, type="bool"),
state=dict(choices=["present", "absent"],
default="present",
required=False),
)
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[
["group_list", "route_map"],
["group_list", "prefix_list"],
["route_map", "prefix_list"],
],
supports_check_mode=True,
)
warnings = list()
result = {"changed": False, "commands": [], "warnings": warnings}
state = module.params["state"]
args = ["rp_address", "group_list", "prefix_list", "route_map", "bidir"]
proposed_args = dict((k, v) for k, v in module.params.items()
if v is not None and k in args)
if module.params["group_list"]:
existing = get_existing(module, args, True)
proposed = get_proposed(proposed_args, existing)
else:
existing = get_existing(module, args, False)
proposed = get_proposed(proposed_args, existing)
candidate = CustomNetworkConfig(indent=3)
if state == "present" and (proposed or not existing):
state_present(module, existing, proposed, candidate)
elif state == "absent" and existing:
state_absent(module, existing, candidate)
if candidate:
candidate = candidate.items_text()
result["commands"] = candidate
result["changed"] = True
msgs = load_config(module, candidate, True)
if msgs:
for item in msgs:
if item:
if isinstance(item, dict):
err_str = item["clierror"]
else:
err_str = item
if "No policy was configured" in err_str:
if state == "absent":
addr = module.params["rp_address"]
new_cmd = "no ip pim rp-address {0}".format(addr)
load_config(module, new_cmd)
module.exit_json(**result)
def main():
argument_spec = dict(
interface=dict(required=True, type="str"),
vni=dict(required=True, type="str"),
assoc_vrf=dict(required=False, type="bool"),
multicast_group=dict(required=False, type="str"),
peer_list=dict(required=False, type="list", elements="str"),
suppress_arp=dict(required=False, type="bool"),
suppress_arp_disable=dict(required=False, type="bool"),
ingress_replication=dict(required=False,
type="str",
choices=["bgp", "static", "default"]),
state=dict(choices=["present", "absent"],
default="present",
required=False),
)
argument_spec.update(nxos_argument_spec)
mutually_exclusive = [
("suppress_arp", "suppress_arp_disable"),
("assoc_vrf", "multicast_group"),
("assoc_vrf", "suppress_arp"),
("assoc_vrf", "suppress_arp_disable"),
("assoc_vrf", "ingress_replication"),
]
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True,
)
warnings = list()
result = {"changed": False, "commands": [], "warnings": warnings}
if module.params["peer_list"]:
if (module.params["peer_list"][0] != "default"
and module.params["ingress_replication"] != "static"):
module.fail_json(msg="ingress_replication=static is required "
"when using peer_list param")
else:
peer_list = module.params["peer_list"]
if peer_list[0] == "default":
module.params["peer_list"] = "default"
else:
stripped_peer_list = list(map(str.strip, peer_list))
module.params["peer_list"] = stripped_peer_list
state = module.params["state"]
args = PARAM_TO_COMMAND_KEYMAP.keys()
existing, interface_exist = get_existing(module, args)
if state == "present":
if not interface_exist:
module.fail_json(
msg=
"The proposed NVE interface does not exist. Use nxos_interface to create it first."
)
elif interface_exist != module.params["interface"]:
module.fail_json(
msg="Only 1 NVE interface is allowed on the switch.")
elif state == "absent":
if interface_exist != module.params["interface"]:
module.exit_json(**result)
elif existing and existing["vni"] != module.params["vni"]:
module.fail_json(
msg="ERROR: VNI delete failed: Could not find vni node for {0}"
.format(module.params["vni"]),
existing_vni=existing["vni"],
)
proposed_args = dict((k, v) for k, v in module.params.items()
if v is not None and k in args)
proposed = {}
for key, value in proposed_args.items():
if key in ["multicast_group", "peer_list", "ingress_replication"]:
if str(value).lower() == "default":
value = PARAM_TO_DEFAULT_KEYMAP.get(key, "default")
if key != "interface" and existing.get(key) != value:
proposed[key] = value
candidate = CustomNetworkConfig(indent=3)
if state == "present":
state_present(module, existing, proposed, candidate)
elif existing and state == "absent":
state_absent(module, existing, proposed, candidate)
if candidate:
candidate = candidate.items_text()
result["changed"] = True
result["commands"] = candidate
if not module.check_mode:
load_config(module, candidate)
module.exit_json(**result)
def main():
argument_spec = dict(
asn=dict(required=True, type="str"),
vrf=dict(required=False, type="str", default="default"),
neighbor=dict(required=True, type="str"),
afi=dict(
required=True,
type="str",
choices=["ipv4", "ipv6", "vpnv4", "vpnv6", "l2vpn"],
),
safi=dict(
required=True, type="str", choices=["unicast", "multicast", "evpn"]
),
additional_paths_receive=dict(
required=False,
type="str",
choices=["enable", "disable", "inherit"],
),
additional_paths_send=dict(
required=False,
type="str",
choices=["enable", "disable", "inherit"],
),
advertise_map_exist=dict(required=False, type="list", elements="str"),
advertise_map_non_exist=dict(
required=False, type="list", elements="str"
),
allowas_in=dict(required=False, type="bool"),
allowas_in_max=dict(required=False, type="str"),
as_override=dict(required=False, type="bool"),
default_originate=dict(required=False, type="bool"),
default_originate_route_map=dict(required=False, type="str"),
disable_peer_as_check=dict(required=False, type="bool"),
filter_list_in=dict(required=False, type="str"),
filter_list_out=dict(required=False, type="str"),
max_prefix_limit=dict(required=False, type="str"),
max_prefix_interval=dict(required=False, type="str"),
max_prefix_threshold=dict(required=False, type="str"),
max_prefix_warning=dict(required=False, type="bool"),
next_hop_self=dict(required=False, type="bool"),
next_hop_third_party=dict(required=False, type="bool"),
prefix_list_in=dict(required=False, type="str"),
prefix_list_out=dict(required=False, type="str"),
route_map_in=dict(required=False, type="str"),
route_map_out=dict(required=False, type="str"),
route_reflector_client=dict(required=False, type="bool"),
send_community=dict(
required=False,
choices=["none", "both", "extended", "standard", "default"],
),
soft_reconfiguration_in=dict(
required=False, type="str", choices=["enable", "always", "inherit"]
),
soo=dict(required=False, type="str"),
suppress_inactive=dict(required=False, type="bool"),
unsuppress_map=dict(required=False, type="str"),
weight=dict(required=False, type="str"),
state=dict(
choices=["present", "absent"], default="present", required=False
),
rewrite_evpn_rt_asn=dict(required=False, type="bool"),
)
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[
["advertise_map_exist", "advertise_map_non_exist"],
["max_prefix_interval", "max_prefix_warning"],
["default_originate", "default_originate_route_map"],
["allowas_in", "allowas_in_max"],
],
supports_check_mode=True,
)
warnings = list()
result = dict(changed=False, warnings=warnings)
state = module.params["state"]
for key in [
"max_prefix_interval",
"max_prefix_warning",
"max_prefix_threshold",
]:
if module.params[key] and not module.params["max_prefix_limit"]:
module.fail_json(
msg="max_prefix_limit is required when using %s" % key
)
if module.params["vrf"] == "default" and module.params["soo"]:
module.fail_json(msg="SOO is only allowed in non-default VRF")
args = PARAM_TO_COMMAND_KEYMAP.keys()
existing = get_existing(module, args, warnings)
if existing.get("asn") and state == "present":
if existing.get("asn") != module.params["asn"]:
module.fail_json(
msg="Another BGP ASN already exists.",
proposed_asn=module.params["asn"],
existing_asn=existing.get("asn"),
)
for param in ["advertise_map_exist", "advertise_map_non_exist"]:
if module.params[param] == ["default"]:
module.params[param] = "default"
proposed_args = dict(
(k, v) for k, v in module.params.items() if v is not None and k in args
)
proposed = {}
for key, value in proposed_args.items():
if key not in ["asn", "vrf", "neighbor"]:
if not isinstance(value, list):
if str(value).lower() == "true":
value = True
elif str(value).lower() == "false":
value = False
elif str(value).lower() == "default":
if key in BOOL_PARAMS:
value = False
else:
value = "default"
elif key == "send_community" and str(value).lower() == "none":
value = "default"
if existing.get(key) != value:
proposed[key] = value
candidate = CustomNetworkConfig(indent=3)
if state == "present":
state_present(module, existing, proposed, candidate)
elif state == "absent" and existing:
state_absent(module, existing, candidate)
if candidate:
candidate = candidate.items_text()
if not module.check_mode:
responses = load_config(module, candidate)
if responses:
for resp in responses:
if resp:
if resp.endswith("is valid only for EBGP peers"):
module.fail_json(msg=resp)
result["changed"] = True
result["commands"] = candidate
else:
result["commands"] = []
module.exit_json(**result)
def main():
argument_spec = dict(
interface=dict(required=True, type="str"),
ospf=dict(required=True, type="str"),
area=dict(required=True, type="str"),
bfd=dict(
choices=["enable", "disable", "default"],
required=False,
type="str",
),
cost=dict(required=False, type="str"),
hello_interval=dict(required=False, type="str"),
dead_interval=dict(required=False, type="str"),
passive_interface=dict(required=False, type="bool"),
network=dict(required=False,
type="str",
choices=["broadcast", "point-to-point"]),
message_digest=dict(required=False, type="bool"),
message_digest_key_id=dict(required=False, type="str"),
message_digest_algorithm_type=dict(required=False,
type="str",
choices=["md5", "default"]),
message_digest_encryption_type=dict(
required=False,
type="str",
choices=["cisco_type_7", "3des", "default"],
),
message_digest_password=dict(required=False, type="str", no_log=True),
state=dict(choices=["present", "absent"],
default="present",
required=False),
)
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(
argument_spec=argument_spec,
required_together=[[
"message_digest_key_id",
"message_digest_algorithm_type",
"message_digest_encryption_type",
"message_digest_password",
]],
supports_check_mode=True,
)
# Normalize interface input data.
#
# * For port-channel and loopback interfaces expection is all lower case names.
# * All other interfaces the expectation is an uppercase leading character
# followed by lower case characters.
#
if re.match(r"(port-channel|loopback)", module.params["interface"], re.I):
module.params["interface"] = module.params["interface"].lower()
else:
module.params["interface"] = module.params["interface"].capitalize()
warnings = list()
result = {"changed": False, "commands": [], "warnings": warnings}
for param in [
"message_digest_encryption_type",
"message_digest_algorithm_type",
"message_digest_password",
]:
if (module.params[param] == "default"
and module.params["message_digest_key_id"] != "default"):
module.exit_json(
msg=
"Use message_digest_key_id=default to remove an existing authentication configuration"
)
state = module.params["state"]
args = PARAM_TO_COMMAND_KEYMAP.keys()
existing = get_existing(module, args)
proposed_args = dict((k, v) for k, v in module.params.items()
if v is not None and k in args)
proposed = {}
for key, value in proposed_args.items():
if key != "interface":
if str(value).lower() == "true":
value = True
elif str(value).lower() == "false":
value = False
elif str(value).lower() == "default":
value = "default"
elif key == "bfd":
value = str(value).lower()
if existing.get(key) or (not existing.get(key) and value):
proposed[key] = value
elif ("passive_interface" in key and existing.get(key) is None
and value is False):
proposed[key] = value
proposed["area"] = normalize_area(proposed["area"], module)
if "hello_interval" in proposed and proposed["hello_interval"] == "10":
proposed["hello_interval"] = "default"
candidate = CustomNetworkConfig(indent=3)
if state == "present":
state_present(module, existing, proposed, candidate)
elif (state == "absent" and existing.get("ospf") == proposed["ospf"]
and existing.get("area") == proposed["area"]):
state_absent(module, existing, proposed, candidate)
if candidate:
candidate = candidate.items_text()
if not module.check_mode:
load_config(module, candidate)
result["changed"] = True
result["commands"] = candidate
module.exit_json(**result)
def main():
argument_spec = dict(
asn=dict(required=True, type="str"),
vrf=dict(required=False, type="str", default="default"),
safi=dict(required=True,
type="str",
choices=["unicast", "multicast", "evpn"]),
afi=dict(
required=True,
type="str",
choices=["ipv4", "ipv6", "vpnv4", "vpnv6", "l2vpn"],
),
additional_paths_install=dict(required=False, type="bool"),
additional_paths_receive=dict(required=False, type="bool"),
additional_paths_selection=dict(required=False, type="str"),
additional_paths_send=dict(required=False, type="bool"),
advertise_l2vpn_evpn=dict(required=False, type="bool"),
client_to_client=dict(required=False, type="bool"),
dampen_igp_metric=dict(required=False, type="str"),
dampening_state=dict(required=False, type="bool"),
dampening_half_time=dict(required=False, type="str"),
dampening_max_suppress_time=dict(required=False, type="str"),
dampening_reuse_time=dict(required=False, type="str"),
dampening_routemap=dict(required=False, type="str"),
dampening_suppress_time=dict(required=False, type="str"),
default_information_originate=dict(required=False, type="bool"),
default_metric=dict(required=False, type="str"),
distance_ebgp=dict(required=False, type="str"),
distance_ibgp=dict(required=False, type="str"),
distance_local=dict(required=False, type="str"),
inject_map=dict(required=False, type="list", elements="list"),
maximum_paths=dict(required=False, type="str"),
maximum_paths_ibgp=dict(required=False, type="str"),
networks=dict(required=False, type="list", elements="list"),
next_hop_route_map=dict(required=False, type="str"),
redistribute=dict(required=False, type="list", elements="list"),
suppress_inactive=dict(required=False, type="bool"),
table_map=dict(required=False, type="str"),
table_map_filter=dict(required=False, type="bool"),
state=dict(choices=["present", "absent"],
default="present",
required=False),
retain_route_target=dict(required=False, type="str"),
)
argument_spec.update(nxos_argument_spec)
mutually_exclusive = [
("dampening_state", "dampening_routemap"),
("dampening_state", "dampening_half_time"),
("dampening_state", "dampening_suppress_time"),
("dampening_state", "dampening_reuse_time"),
("dampening_state", "dampening_max_suppress_time"),
("dampening_routemap", "dampening_half_time"),
("dampening_routemap", "dampening_suppress_time"),
("dampening_routemap", "dampening_reuse_time"),
("dampening_routemap", "dampening_max_suppress_time"),
]
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=mutually_exclusive,
required_together=[
DAMPENING_PARAMS,
["distance_ibgp", "distance_ebgp", "distance_local"],
],
supports_check_mode=True,
)
warnings = list()
result = dict(changed=False, warnings=warnings)
state = module.params["state"]
if module.params["advertise_l2vpn_evpn"]:
if module.params["vrf"] == "default":
module.fail_json(
msg="It is not possible to advertise L2VPN "
"EVPN in the default VRF. Please specify "
"another one.",
vrf=module.params["vrf"],
)
if module.params["table_map_filter"] and not module.params["table_map"]:
module.fail_json(msg="table_map param is needed when using"
" table_map_filter filter.")
args = PARAM_TO_COMMAND_KEYMAP.keys()
existing = get_existing(module, args, warnings)
if existing.get("asn") and state == "present":
if existing.get("asn") != module.params["asn"]:
module.fail_json(
msg="Another BGP ASN already exists.",
proposed_asn=module.params["asn"],
existing_asn=existing.get("asn"),
)
proposed_args = dict((k, v) for k, v in module.params.items()
if v is not None and k in args)
for arg in ["networks", "inject_map", "redistribute"]:
if proposed_args.get(arg):
if proposed_args[arg][0] == "default":
proposed_args[arg] = "default"
proposed = {}
for key, value in proposed_args.items():
if key not in ["asn", "vrf"]:
if str(value).lower() == "default":
value = PARAM_TO_DEFAULT_KEYMAP.get(key, "default")
if existing.get(key) != value:
proposed[key] = value
candidate = CustomNetworkConfig(indent=3)
if state == "present":
state_present(module, existing, proposed, candidate)
elif state == "absent" and existing:
state_absent(module, candidate)
if candidate:
candidate = candidate.items_text()
if not module.check_mode:
load_config(module, candidate)
result["changed"] = True
result["commands"] = candidate
else:
result["commands"] = []
module.exit_json(**result)
def main():
argument_spec = dict(
asn=dict(required=True, type="str"),
vrf=dict(required=False, type="str", default="default"),
bestpath_always_compare_med=dict(required=False, type="bool"),
bestpath_aspath_multipath_relax=dict(required=False, type="bool"),
bestpath_compare_neighborid=dict(required=False, type="bool"),
bestpath_compare_routerid=dict(required=False, type="bool"),
bestpath_cost_community_ignore=dict(required=False, type="bool"),
bestpath_med_confed=dict(required=False, type="bool"),
bestpath_med_missing_as_worst=dict(required=False, type="bool"),
bestpath_med_non_deterministic=dict(required=False, type="bool"),
cluster_id=dict(required=False, type="str"),
confederation_id=dict(required=False, type="str"),
confederation_peers=dict(required=False, type="list"),
disable_policy_batching=dict(required=False, type="bool"),
disable_policy_batching_ipv4_prefix_list=dict(
required=False, type="str"
),
disable_policy_batching_ipv6_prefix_list=dict(
required=False, type="str"
),
enforce_first_as=dict(required=False, type="bool"),
event_history_cli=dict(
required=False,
choices=[
"true",
"false",
"default",
"size_small",
"size_medium",
"size_large",
"size_disable",
],
),
event_history_detail=dict(
required=False,
choices=[
"true",
"false",
"default",
"size_small",
"size_medium",
"size_large",
"size_disable",
],
),
event_history_events=dict(
required=False,
choices=[
"true",
"false",
"default",
"size_small",
"size_medium",
"size_large",
"size_disable",
],
),
event_history_periodic=dict(
required=False,
choices=[
"true",
"false",
"default",
"size_small",
"size_medium",
"size_large",
"size_disable",
],
),
fast_external_fallover=dict(required=False, type="bool"),
flush_routes=dict(required=False, type="bool"),
graceful_restart=dict(required=False, type="bool"),
graceful_restart_helper=dict(required=False, type="bool"),
graceful_restart_timers_restart=dict(required=False, type="str"),
graceful_restart_timers_stalepath_time=dict(
required=False, type="str"
),
isolate=dict(required=False, type="bool"),
local_as=dict(required=False, type="str"),
log_neighbor_changes=dict(required=False, type="bool"),
maxas_limit=dict(required=False, type="str"),
neighbor_down_fib_accelerate=dict(required=False, type="bool"),
reconnect_interval=dict(required=False, type="str"),
router_id=dict(required=False, type="str"),
shutdown=dict(required=False, type="bool"),
suppress_fib_pending=dict(required=False, type="bool"),
timer_bestpath_limit=dict(required=False, type="str"),
timer_bgp_hold=dict(required=False, type="str"),
timer_bgp_keepalive=dict(required=False, type="str"),
state=dict(
choices=["present", "absent"], default="present", required=False
),
)
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(
argument_spec=argument_spec,
required_together=[["timer_bgp_hold", "timer_bgp_keepalive"]],
supports_check_mode=True,
)
warnings = list()
result = dict(changed=False, warnings=warnings)
state = module.params["state"]
if module.params["vrf"] != "default":
for param in GLOBAL_PARAMS:
if module.params[param]:
module.fail_json(
msg='Global params can be modified only under "default" VRF.',
vrf=module.params["vrf"],
global_param=param,
)
args = PARAM_TO_COMMAND_KEYMAP.keys()
existing = get_existing(module, args, warnings)
if existing.get("asn") and state == "present":
if existing.get("asn") != module.params["asn"]:
module.fail_json(
msg="Another BGP ASN already exists.",
proposed_asn=module.params["asn"],
existing_asn=existing.get("asn"),
)
proposed_args = dict(
(k, v) for k, v in module.params.items() if v is not None and k in args
)
proposed = {}
for key, value in proposed_args.items():
if key not in ["asn", "vrf"]:
if str(value).lower() == "default":
value = PARAM_TO_DEFAULT_KEYMAP.get(key, "default")
if key == "confederation_peers":
if value[0] == "default":
if existing.get(key):
proposed[key] = "default"
else:
v = set([int(i) for i in value])
ex = set([int(i) for i in existing.get(key)])
if v != ex:
proposed[key] = " ".join(str(s) for s in v)
else:
if existing.get(key) != value:
proposed[key] = value
candidate = CustomNetworkConfig(indent=3)
if state == "present":
state_present(module, existing, proposed, candidate)
elif existing.get("asn") == module.params["asn"]:
state_absent(module, existing, candidate)
if candidate:
candidate = candidate.items_text()
if not module.check_mode:
load_config(module, candidate)
result["changed"] = True
result["commands"] = candidate
else:
result["commands"] = []
module.exit_json(**result)
