def main():
argument_spec = aci_argument_spec()
argument_spec.update(
lldp_policy=dict(type='str', aliases=['name']), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
receive_state=dict(type='bool'),
transmit_state=dict(type='bool'),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
name_alias=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['lldp_policy']],
['state', 'present', ['lldp_policy']],
],
)
aci = ACIModule(module)
lldp_policy = module.params.get('lldp_policy')
description = module.params.get('description')
receive_state = aci.boolean(module.params.get('receive_state'), 'enabled', 'disabled')
transmit_state = aci.boolean(module.params.get('transmit_state'), 'enabled', 'disabled')
state = module.params.get('state')
name_alias = module.params.get('name_alias')
aci.construct_url(
root_class=dict(
aci_class='lldpIfPol',
aci_rn='infra/lldpIfP-{0}'.format(lldp_policy),
module_object=lldp_policy,
target_filter={'name': lldp_policy},
),
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='lldpIfPol',
class_config=dict(
name=lldp_policy,
descr=description,
adminRxSt=receive_state,
adminTxSt=transmit_state,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class='lldpIfPol')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
group=dict(type='str',
aliases=['group']), # Not required for querying all objects
firmwarepol=dict(type='str'), # Not required for querying all objects
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
name_alias=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['group']],
['state', 'present', ['group', 'firmwarepol']],
],
)
state = module.params.get('state')
group = module.params.get('group')
firmwarepol = module.params.get('firmwarepol')
name_alias = module.params.get('name_alias')
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='firmwareFwGrp',
aci_rn='fabric/fwgrp-{0}'.format(group),
target_filter={'name': group},
module_object=group,
),
child_classes=['firmwareRsFwgrpp'],
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='firmwareFwGrp',
class_config=dict(
name=group,
nameAlias=name_alias,
),
child_configs=[
dict(firmwareRsFwgrpp=dict(attributes=dict(
tnFirmwareFwPName=firmwarepol, ), ), ),
],
)
aci.get_diff(aci_class='firmwareFwGrp')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
name=dict(type='str'), # Not required for querying all objects
version=dict(type='str'),
ignoreCompat=dict(type='bool'),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
name_alias=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['name']],
['state', 'present', ['name', 'version']],
],
)
state = module.params.get('state')
name = module.params.get('name')
version = module.params.get('version')
name_alias = module.params.get('name_alias')
if module.params.get('ignoreCompat'):
ignore = 'yes'
else:
ignore = 'no'
aci = ACIModule(module)
aci.construct_url(root_class=dict(
aci_class='firmwareFwP',
aci_rn='fabric/fwpol-{0}'.format(name),
target_filter={'name': name},
module_object=name,
), )
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='firmwareFwP',
class_config=dict(
name=name,
version=version,
ignoreCompat=ignore,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class='firmwareFwP')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
mcp=dict(type='str',
aliases=['mcp_interface',
'name']), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
admin_state=dict(type='bool'),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
name_alias=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['mcp']],
['state', 'present', ['mcp']],
],
)
aci = ACIModule(module)
mcp = module.params.get('mcp')
description = module.params.get('description')
admin_state = aci.boolean(module.params.get('admin_state'), 'enabled',
'disabled')
state = module.params.get('state')
name_alias = module.params.get('name_alias')
aci.construct_url(root_class=dict(
aci_class='mcpIfPol',
aci_rn='infra/mcpIfP-{0}'.format(mcp),
module_object=mcp,
target_filter={'name': mcp},
), )
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='mcpIfPol',
class_config=dict(
name=mcp,
descr=description,
adminSt=admin_state,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class='mcpIfPol')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(aci_owner_spec())
argument_spec.update(
group=dict(type="str"), # Not required for querying all objects
policy=dict(type="str"), # Not required for querying all objects
state=dict(type="str",
default="present",
choices=["absent", "present", "query"]),
name_alias=dict(type="str"),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["group"]],
["state", "present", ["group"]],
],
)
state = module.params.get("state")
group = module.params.get("group")
policy = module.params.get("policy")
name_alias = module.params.get("name_alias")
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class="maintMaintGrp",
aci_rn="fabric/maintgrp-{0}".format(group),
target_filter={"name": group},
module_object=group,
),
child_classes=["maintRsMgrpp"],
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="maintMaintGrp",
class_config=dict(
name=group,
nameAlias=name_alias,
),
child_configs=[
dict(maintRsMgrpp=dict(attributes=dict(
tnMaintMaintPName=policy, ), ), ),
],
)
aci.get_diff(aci_class="maintMaintGrp")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
dns_profile=dict(type='str', aliases=['profile_name'], required=True),
domain=dict(type='str', aliases=['name', 'domain_name']),
default=dict(type='bool'),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['domain']],
['state', 'present', ['domain']],
],
)
aci = ACIModule(module)
dns_profile = module.params.get('dns_profile')
domain = module.params.get('domain')
default = aci.boolean(module.params.get('default'))
state = module.params.get('state')
aci.construct_url(
root_class=dict(
aci_class='dnsProfile',
aci_rn='fabric/dnsp-{0}'.format(dns_profile),
module_object=dns_profile,
target_filter={'name': dns_profile},
),
subclass_1=dict(
aci_class='dnsDomain',
aci_rn='dom-{0}'.format(domain),
module_object=domain,
target_filter={'name': domain}
),
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='dnsDomain',
class_config=dict(
name=domain,
isDefault=default
),
)
aci.get_diff(aci_class='dnsDomain')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
fc_policy=dict(type='str',
aliases=['name'
]), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
port_mode=dict(type='str',
choices=['f', 'np']), # No default provided on purpose
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
name_alias=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['fc_policy']],
['state', 'present', ['fc_policy']],
],
)
fc_policy = module.params.get('fc_policy')
port_mode = module.params.get('port_mode')
description = module.params.get('description')
state = module.params.get('state')
name_alias = module.params.get('name_alias')
aci = ACIModule(module)
aci.construct_url(root_class=dict(
aci_class='fcIfPol',
aci_rn='infra/fcIfPol-{0}'.format(fc_policy),
module_object=fc_policy,
target_filter={'name': fc_policy},
), )
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='fcIfPol',
class_config=dict(
name=fc_policy,
descr=description,
portMode=port_mode,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class='fcIfPol')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(
community=dict(type="str"),
policy=dict(type="str", aliases=["snmp_policy", "snmp_policy_name"]),
description=dict(type="str"),
state=dict(type="str",
default="present",
choices=["absent", "present", "query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["policy", "community"]],
["state", "present", ["policy", "community"]],
],
)
aci = ACIModule(module)
community = module.params.get("community")
policy = module.params.get("policy")
description = module.params.get("description")
state = module.params.get("state")
aci.construct_url(
root_class=dict(
aci_class="snmpPol",
aci_rn="fabric/snmppol-{0}".format(policy),
module_object=policy,
target_filter={"name": policy},
),
subclass_1=dict(
aci_class="snmpCommunityP",
aci_rn="community-{0}".format(community),
module_object=community,
target_filter={"name": community},
),
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="snmpCommunityP",
class_config=dict(name=community, descr=description),
)
aci.get_diff(aci_class="snmpCommunityP")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
breakout_port_group=dict(
type='str',
aliases=['name']), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
breakout_map=dict(type='str'),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['breakout_port_group']],
['state', 'present', ['breakout_port_group']],
],
)
breakout_port_group = module.params.get('breakout_port_group')
description = module.params.get('description')
breakout_map = module.params.get('breakout_map')
state = module.params.get('state')
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='infraBrkoutPortGrp',
aci_rn='infra/funcprof/brkoutportgrp-{0}'.format(
breakout_port_group),
module_object=breakout_port_group,
target_filter={'name': breakout_port_group},
),
child_classes=[],
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='infraBrkoutPortGrp',
class_config=dict(
name=breakout_port_group,
descr=description,
brkoutMap=breakout_map,
),
)
aci.get_diff(aci_class='infraBrkoutPortGrp')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(aci_owner_spec())
argument_spec.update(
cdp_policy=dict(type="str", required=False, aliases=["cdp_interface", "name"]), # Not required for querying all objects
description=dict(type="str", aliases=["descr"]),
admin_state=dict(type="bool"),
state=dict(type="str", default="present", choices=["absent", "present", "query"]),
name_alias=dict(type="str"),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["cdp_policy"]],
["state", "present", ["cdp_policy"]],
],
)
aci = ACIModule(module)
cdp_policy = module.params.get("cdp_policy")
description = module.params.get("description")
admin_state = aci.boolean(module.params.get("admin_state"), "enabled", "disabled")
state = module.params.get("state")
name_alias = module.params.get("name_alias")
aci.construct_url(
root_class=dict(
aci_class="cdpIfPol",
aci_rn="infra/cdpIfP-{0}".format(cdp_policy),
module_object=cdp_policy,
target_filter={"name": cdp_policy},
),
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="cdpIfPol",
class_config=dict(
name=cdp_policy,
descr=description,
adminSt=admin_state,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class="cdpIfPol")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
group=dict(type='str'), # Not required for querying all objects
node=dict(type='str'),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
name_alias=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['node', 'group']],
['state', 'present', ['node', 'group']],
],
)
state = module.params.get('state')
group = module.params.get('group')
node = module.params.get('node')
name_alias = module.params.get('name_alias')
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='maintMaintGrp',
aci_rn='fabric/maintgrp-{0}'.format(group),
target_filter={'name': group},
module_object=group,
),
subclass_1=dict(
aci_class='fabricNodeBlk',
aci_rn='nodeblk-blk{0}-{0}'.format(node),
target_filter={'name': 'blk{0}-{0}'.format(node)},
module_object=node,
),
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='fabricNodeBlk',
class_config=dict(
from_=node,
to_=node,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class='fabricNodeBlk')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update({
'asn': dict(type='str'),
'description': dict(type='str', aliases=['descr']),
'name': dict(type='str', aliases=['autonomous_system_profile', 'autonomous_system_profile_name']),
'name_alias': dict(type='str'),
'state': dict(type='str', default='present', choices=['absent', 'present', 'query']),
})
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
annotation = module.params['annotation']
asn = module.params['asn']
description = module.params['description']
name = module.params['name']
name_alias = module.params['name_alias']
state = module.params['state']
child_configs = []
aci = ACIModule(module)
aci.construct_url(
root_class={
'aci_class': 'cloudBgpAsP',
'aci_rn': 'clouddomp/as'.format(),
'target_filter': {'name': name},
'module_object': None
},
child_classes=[]
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='cloudBgpAsP',
class_config={
'annotation': annotation,
'asn': asn,
'descr': description,
'name': name,
'nameAlias': name_alias,
},
child_configs=child_configs
)
aci.get_diff(aci_class='cloudBgpAsP')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(aci_owner_spec())
argument_spec.update(
name=dict(type="str", aliases=["snmp_policy", "snmp_policy_name"]),
admin_state=dict(type="str", choices=["enabled", "disabled"]),
contact=dict(type="str"),
description=dict(type="str"),
location=dict(type="str"),
state=dict(type="str", default="present", choices=["absent", "present", "query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["name"]],
["state", "present", ["name"]],
],
)
aci = ACIModule(module)
name = module.params.get("name")
admin_state = module.params.get("admin_state")
contact = module.params.get("contact")
description = module.params.get("description")
location = module.params.get("location")
state = module.params.get("state")
aci.construct_url(
root_class=dict(
aci_class="snmpPol",
aci_rn="fabric/snmppol-{0}".format(name),
module_object=name,
target_filter={"name": name},
),
child_classes=["snmpCommunityP", "snmpClientGrpP"],
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="snmpPol",
class_config=dict(name=name, adminSt=admin_state, contact=contact, descr=description, loc=location),
)
aci.get_diff(aci_class="snmpPol")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
leaf_profile=dict(type='str', aliases=['leaf_profile_name']), # Not required for querying all objects
interface_selector=dict(type='str', aliases=['interface_profile_name', 'interface_selector_name', 'name']), # Not required for querying all objects
state=dict(type='str', default='present', choices=['absent', 'present', 'query'])
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['leaf_profile', 'interface_selector']],
['state', 'present', ['leaf_profile', 'interface_selector']]
],
)
leaf_profile = module.params.get('leaf_profile')
# WARNING: interface_selector accepts non existing interface_profile names and they appear on APIC gui with a state of "missing-target"
interface_selector = module.params.get('interface_selector')
state = module.params.get('state')
# Defining the interface profile tDn for clarity
interface_selector_tDn = 'uni/infra/accportprof-{0}'.format(interface_selector)
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='infraNodeP',
aci_rn='infra/nprof-{0}'.format(leaf_profile),
module_object=leaf_profile,
target_filter={'name': leaf_profile},
),
subclass_1=dict(
aci_class='infraRsAccPortP',
aci_rn='rsaccPortP-[{0}]'.format(interface_selector_tDn),
module_object=interface_selector,
target_filter={'name': interface_selector},
)
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='infraRsAccPortP',
class_config=dict(tDn=interface_selector_tDn),
)
aci.get_diff(aci_class='infraRsAccPortP')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
tenant=dict(type='str', required=True),
cloud_context_profile=dict(type='str', required=True),
state=dict(type='str',
default='query',
choices=['absent', 'present', 'query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
tenant = module.params.get('tenant')
cloud_context_profile = module.params.get('cloud_context_profile')
state = module.params.get('state')
child_configs = []
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='fvTenant',
aci_rn='tn-{0}'.format(tenant),
target_filter='eq(fvTenant.name, "{0}")'.format(tenant),
module_object=tenant),
subclass_1=dict(aci_class='cloudCtxProfile',
aci_rn='ctxprofile-{0}'.format(cloud_context_profile),
target_filter='eq(cloudCtxProfile.name, "{0}")'.format(
cloud_context_profile),
module_object=cloud_context_profile),
subclass_2=dict(aci_class='cloudRouterP',
aci_rn="routerp-default",
target_filter='eq(cloudRouterP.name, "default")',
module_object="default"),
child_classes=[
'cloudRsToVpnGwPol', 'cloudRsToHostRouterPol', 'cloudIntNetworkP'
])
aci.get_existing()
if state == 'present':
child_configs.append(
dict(cloudIntNetworkP=dict(attributes=dict(name="default"))))
aci.payload(aci_class='cloudRouterP',
class_config=dict(name="default"),
child_configs=child_configs)
aci.get_diff(aci_class='cloudRouterP')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
dn=dict(type="str"),
tag_key=dict(type="str", no_log=False),
tag_value=dict(type="str", default=""),
tag_type=dict(type="str", choices=["annotation", "instance", "tag"], required=True),
state=dict(type="str", default="present", choices=["absent", "present", "query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["dn", "tag_key"]],
["state", "present", ["dn", "tag_key"]],
],
)
aci = ACIModule(module)
dn = module.params.get('dn')
tag_key = module.params.get("tag_key")
tag_value = module.params.get("tag_value")
tag_type = module.params.get("tag_type")
state = module.params.get("state")
if module.params.get('dn') is not None:
dn = dn.lstrip("uni/")
aci_type = dict(
annotation=dict(dn="{0}/annotationKey-{1}".format(dn, tag_key), name="tagAnnotation", config=dict(value=tag_value)),
instance=dict(dn="{0}/tag-{1}".format(dn, tag_key), name="tagInst", config=dict()),
tag=dict(dn="{0}/tagKey-{1}".format(dn, tag_key), name="tagTag", config=dict(value=tag_value)),
)
aci.construct_url(
root_class=dict(
aci_class=aci_type[tag_type]["name"],
aci_rn=aci_type[tag_type]["dn"],
module_object=tag_key,
target_filter={"name": tag_key},
)
)
aci.get_existing()
if state == "present":
aci.payload(aci_class=aci_type[tag_type]["name"], class_config=aci_type[tag_type]["config"])
aci.get_diff(aci_class=aci_type[tag_type]["name"])
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
leaf_profile=dict(type='str',
aliases=['name', 'leaf_profile_name'
]), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
name_alias=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['leaf_profile']],
['state', 'present', ['leaf_profile']],
],
)
leaf_profile = module.params.get('leaf_profile')
description = module.params.get('description')
state = module.params.get('state')
name_alias = module.params.get('name_alias')
aci = ACIModule(module)
aci.construct_url(root_class=dict(
aci_class='infraNodeP',
aci_rn='infra/nprof-{0}'.format(leaf_profile),
module_object=leaf_profile,
target_filter={'name': leaf_profile},
), )
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='infraNodeP',
class_config=dict(
name=leaf_profile,
descr=description,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class='infraNodeP')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(
leaf_profile=dict(type="str", aliases=["leaf_profile_name"]), # Not required for querying all objects
interface_selector=dict(type="str", aliases=["interface_profile_name", "interface_selector_name", "name"]), # Not required for querying all objects
state=dict(type="str", default="present", choices=["absent", "present", "query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[["state", "absent", ["leaf_profile", "interface_selector"]], ["state", "present", ["leaf_profile", "interface_selector"]]],
)
leaf_profile = module.params.get("leaf_profile")
# WARNING: interface_selector accepts non existing interface_profile names and they appear on APIC gui with a state of "missing-target"
interface_selector = module.params.get("interface_selector")
state = module.params.get("state")
# Defining the interface profile tDn for clarity
interface_selector_tDn = "uni/infra/accportprof-{0}".format(interface_selector)
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class="infraNodeP",
aci_rn="infra/nprof-{0}".format(leaf_profile),
module_object=leaf_profile,
target_filter={"name": leaf_profile},
),
subclass_1=dict(
aci_class="infraRsAccPortP",
aci_rn="rsaccPortP-[{0}]".format(interface_selector_tDn),
module_object=interface_selector,
target_filter={"name": interface_selector},
),
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="infraRsAccPortP",
class_config=dict(tDn=interface_selector_tDn),
)
aci.get_diff(aci_class="infraRsAccPortP")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(aci_owner_spec())
argument_spec.update(
tenant=dict(type="str", aliases=["name", "tenant_name"]), # Not required for querying all objects
description=dict(type="str", aliases=["descr"]),
state=dict(type="str", default="present", choices=["absent", "present", "query"]),
name_alias=dict(type="str"),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["tenant"]],
["state", "present", ["tenant"]],
],
)
description = module.params.get("description")
state = module.params.get("state")
tenant = module.params.get("tenant")
name_alias = module.params.get("name_alias")
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class="fvTenant",
aci_rn="tn-{0}".format(tenant),
module_object=tenant,
target_filter={"name": tenant},
),
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="fvTenant",
class_config=dict(
name=tenant,
descr=description,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class="fvTenant")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(community=dict(type='str'),
policy=dict(
type='str',
aliases=['snmp_policy', 'snmp_policy_name']),
description=dict(type='str'),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['policy', 'community']],
['state', 'present', ['policy', 'community']],
])
aci = ACIModule(module)
community = module.params.get('community')
policy = module.params.get('policy')
description = module.params.get('description')
state = module.params.get('state')
aci.construct_url(root_class=dict(
aci_class='snmpPol',
aci_rn='fabric/snmppol-{0}'.format(policy),
module_object=policy,
target_filter={'name': policy},
),
subclass_1=dict(
aci_class='snmpCommunityP',
aci_rn='community-{0}'.format(community),
module_object=community,
target_filter={'name': community},
))
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='snmpCommunityP',
class_config=dict(name=community, descr=description),
)
aci.get_diff(aci_class='snmpCommunityP')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(aci_owner_spec())
argument_spec.update(
name=dict(type="str", aliases=["leaf_switch_profile", "leaf_profile"]),
description=dict(type="str", aliases=["descr"]),
state=dict(type="str",
default="present",
choices=["absent", "present", "query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["name"]],
["state", "present", ["name"]],
],
)
aci = ACIModule(module)
name = module.params.get("name")
description = module.params.get("description")
state = module.params.get("state")
child_classes = ["fabricLeafS"]
aci.construct_url(
root_class=dict(
aci_class="fabricLeafP",
aci_rn="fabric/leprof-{0}".format(name),
module_object=name,
target_filter={"name": name},
),
child_classes=child_classes,
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="fabricLeafP",
class_config=dict(name=name, descr=description),
)
aci.get_diff(aci_class="fabricLeafP")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
asn=dict(type='int'),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'present', ['asn']],
],
)
asn = module.params.get('asn')
state = module.params.get('state')
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='bgpInstPol',
aci_rn='fabric/bgpInstP-default',
module_object='default',
target_filter={'name': 'default'},
),
subclass_1=dict(
aci_class='bgpAsP',
aci_rn='as',
module_object='name',
target_filter={'name': ''},
),
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='bgpAsP',
class_config=dict(asn=asn, ),
)
aci.get_diff(aci_class='bgpAsP')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(name=dict(
type='str', aliases=['spine_switch_profile', 'spine_profile']),
description=dict(type='str', aliases=['descr']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['name']],
['state', 'present', ['name']],
])
aci = ACIModule(module)
name = module.params.get('name')
description = module.params.get('description')
state = module.params.get('state')
child_classes = ['fabricSpineS']
aci.construct_url(
root_class=dict(
aci_class='fabricSpineP',
aci_rn='fabric/spprof-{0}'.format(name),
module_object=name,
target_filter={'name': name},
),
child_classes=child_classes,
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='fabricSpineP',
class_config=dict(name=name, descr=description),
)
aci.get_diff(aci_class='fabricSpineP')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(
tenant=dict(type="str", aliases=["tenant_name"]),
vrf=dict(type="str", aliases=["context", "vrf_name"]),
contract=dict(type="str", aliases=["contract_name"]),
type=dict(type="str", required=True, choices=["provider", "consumer", "interface"], aliases=["contract_type"]),
state=dict(type="str", default="present", choices=["absent", "present", "query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[["state", "absent", ["contract", "vrf", "tenant"]], ["state", "present", ["contract", "vrf", "tenant"]]],
)
tenant = module.params.get("tenant")
vrf = module.params.get("vrf")
contract = module.params.get("contract")
type = module.params.get("type")
state = module.params.get("state")
aci_class = ACI_CLASS_MAPPING[type]["class"]
aci_rn = ACI_CLASS_MAPPING[type]["rn"]
aci_target_attribute = ACI_CLASS_MAPPING[type]["target_attribute"]
aci = ACIModule(module)
aci.construct_url(
root_class=dict(aci_class="fvTenant", aci_rn="tn-{0}".format(tenant), module_object=tenant, target_filter={"name": tenant}),
subclass_1=dict(aci_class="fvCtx", aci_rn="ctx-{0}".format(vrf), module_object=vrf, target_filter={"name": vrf}),
subclass_2=dict(aci_class="vzAny", aci_rn="any", module_object="any", target_filter={"name": "any"}),
subclass_3=dict(aci_class=aci_class, aci_rn="{0}{1}".format(aci_rn, contract), module_object=contract, target_filter={aci_target_attribute: contract}),
)
aci.get_existing()
if state == "present":
aci.payload(aci_class=aci_class, class_config={aci_target_attribute: contract})
aci.get_diff(aci_class=aci_class)
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(aci_owner_spec())
argument_spec.update(
pool=dict(type="str",
aliases=["name", "pool_name"
]), # Not required for querying all objects
description=dict(type="str", aliases=["descr"]),
pool_allocation_mode=dict(type="str",
aliases=["allocation_mode", "mode"],
choices=["dynamic", "static"]),
state=dict(type="str",
default="present",
choices=["absent", "present", "query"]),
name_alias=dict(type="str"),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["pool"]],
["state", "present", ["pool"]],
],
)
description = module.params.get("description")
pool = module.params.get("pool")
pool_allocation_mode = module.params.get("pool_allocation_mode")
state = module.params.get("state")
name_alias = module.params.get("name_alias")
pool_name = pool
# ACI Pool URL requires the allocation mode for vlan and vsan pools (ex: uni/infra/vlanns-[poolname]-static)
if pool is not None:
if pool_allocation_mode is not None:
pool_name = "[{0}]-{1}".format(pool, pool_allocation_mode)
else:
module.fail_json(
msg=
"ACI requires the 'pool_allocation_mode' when 'pool' is provided"
)
aci = ACIModule(module)
aci.construct_url(root_class=dict(
aci_class="fvnsVlanInstP",
aci_rn="infra/vlanns-{0}".format(pool_name),
module_object=pool,
target_filter={"name": pool},
), )
aci.get_existing()
if state == "present":
aci.payload(
aci_class="fvnsVlanInstP",
class_config=dict(
allocMode=pool_allocation_mode,
descr=description,
name=pool,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class="fvnsVlanInstP")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(
pod_id=dict(type="int", aliases=["pod", "pod_number"]),
node_id=dict(type="int", aliases=["leaf", "spine", "node"]),
fex_id=dict(type="int"),
interface=dict(type="str"),
state=dict(type="str",
default="present",
choices=["absent", "present", "query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["pod_id", "node_id", "interface"]],
["state", "present", ["pod_id", "node_id", "interface"]],
],
)
aci = ACIModule(module)
pod_id = module.params.get("pod_id")
node_id = module.params.get("node_id")
interface = module.params.get("interface")
fex_id = module.params.get("fex_id")
state = module.params.get("state")
if fex_id:
rn = "rsoosPath-[topology/pod-{0}/paths-{1}/extpaths-{2}/pathep-[eth{3}]]".format(
pod_id, node_id, fex_id, interface)
else:
rn = "rsoosPath-[topology/pod-{0}/paths-{1}/pathep-[eth{2}]]".format(
pod_id, node_id, interface)
aci.construct_url(
root_class=dict(
aci_class="fabricInst",
aci_rn="fabric",
module_object="fabric",
target_filter={"name": "fabric"},
),
subclass_1=dict(
aci_class="fabricOOServicePol",
aci_rn="outofsvc",
module_object="outofsvc",
target_filter={"name": "default"},
),
subclass_2=dict(
aci_class="fabricRsOosPath",
aci_rn=rn,
),
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="fabricRsOosPath",
class_config=dict(lc="blacklist", ),
)
aci.get_diff(aci_class="fabricRsOosPath")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(aci_owner_spec())
argument_spec.update(
interface_profile=dict(type="str",
aliases=[
"leaf_interface_profile_name",
"leaf_interface_profile",
"interface_profile_name"
]),
access_port_selector=dict(type="str",
aliases=[
"name", "access_port_selector_name"
]), # Not required for querying all objects
description=dict(type="str"),
port_blk=dict(
type="str",
aliases=["leaf_port_blk_name", "leaf_port_blk", "port_blk_name"]),
leaf_port_blk_description=dict(type="str"),
from_port=dict(type="str",
aliases=["from", "fromPort", "from_port_range"]),
to_port=dict(type="str", aliases=["to", "toPort", "to_port_range"]),
from_card=dict(type="str", aliases=["from_card_range"]),
to_card=dict(type="str", aliases=["to_card_range"]),
policy_group=dict(type="str", aliases=["policy_group_name"]),
interface_type=dict(type="str",
default="switch_port",
choices=[
"breakout", "fex", "port_channel",
"switch_port", "vpc", "fex_port_channel",
"fex_vpc"
]),
type=dict(type="str", default="leaf", choices=["fex", "leaf"]),
state=dict(type="str",
default="present",
choices=["absent", "present", "query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "absent", ["interface_profile", "access_port_selector"]],
[
"state", "present",
["interface_profile", "access_port_selector"]
],
],
)
interface_profile = module.params.get("interface_profile")
access_port_selector = module.params.get("access_port_selector")
description = module.params.get("description")
port_blk = module.params.get("port_blk")
leaf_port_blk_description = module.params.get("leaf_port_blk_description")
from_port = module.params.get("from_port")
to_port = module.params.get("to_port")
from_card = module.params.get("from_card")
to_card = module.params.get("to_card")
policy_group = module.params.get("policy_group")
interface_type = module.params.get("interface_type")
state = module.params.get("state")
type_profile = module.params.get("type")
# Build child_configs dynamically
child_configs = [
dict(infraPortBlk=dict(attributes=dict(
descr=leaf_port_blk_description,
name=port_blk,
fromPort=from_port,
toPort=to_port,
fromCard=from_card,
toCard=to_card,
), ), )
]
# Add infraRsAccBaseGrp only when policy_group was defined
if policy_group is not None:
child_configs.append(
dict(infraRsAccBaseGrp=dict(attributes=dict(
tDn=INTERFACE_TYPE_MAPPING[interface_type].format(
policy_group), ), ), ))
aci = ACIModule(module)
aci_class = "infraAccPortP"
aci_rn = "accportprof"
if type_profile == "fex":
aci_class = "infraFexP"
aci_rn = "fexprof"
aci.construct_url(
root_class=dict(
aci_class=aci_class,
aci_rn="infra/" + aci_rn + "-{0}".format(interface_profile),
module_object=interface_profile,
target_filter={"name": interface_profile},
),
subclass_1=dict(
aci_class="infraHPortS",
# NOTE: normal rn: hports-{name}-typ-{type}, hence here hardcoded to range for purposes of module
aci_rn="hports-{0}-typ-range".format(access_port_selector),
module_object=access_port_selector,
target_filter={"name": access_port_selector},
),
child_classes=["infraPortBlk", "infraRsAccBaseGrp"],
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="infraHPortS",
class_config=dict(
descr=description,
name=access_port_selector,
# type='range',
),
child_configs=child_configs,
)
aci.get_diff(aci_class="infraHPortS")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
contract_type=dict(type='str',
required=True,
choices=['consumer', 'provider']),
l3out=dict(type='str', aliases=['l3out_name']),
contract=dict(type='str'),
priority=dict(type='str',
choices=['level1', 'level2', 'level3', 'unspecified']),
provider_match=dict(
type='str', choices=['all', 'at_least_one', 'at_most_one',
'none']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
tenant=dict(type='str'),
extepg=dict(type='str', aliases=['extepg_name', 'external_epg']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['extepg', 'contract', 'l3out', 'tenant']],
['state', 'present', ['extepg', 'contract', 'l3out', 'tenant']],
],
)
l3out = module.params.get('l3out')
contract = module.params.get('contract')
contract_type = module.params.get('contract_type')
extepg = module.params.get('extepg')
priority = module.params.get('priority')
provider_match = module.params.get('provider_match')
if provider_match is not None:
provider_match = PROVIDER_MATCH_MAPPING.get(provider_match)
state = module.params.get('state')
tenant = module.params.get('tenant')
aci_class = ACI_CLASS_MAPPING.get(contract_type)["class"]
aci_rn = ACI_CLASS_MAPPING.get(contract_type)["rn"]
if contract_type == "consumer" and provider_match is not None:
module.fail_json(
msg=
"the 'provider_match' is only configurable for Provided Contracts")
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='fvTenant',
aci_rn='tn-{0}'.format(tenant),
module_object=tenant,
target_filter={'name': tenant},
),
subclass_1=dict(
aci_class='l3extOut',
aci_rn='out-{0}'.format(l3out),
module_object=l3out,
target_filter={'name': l3out},
),
subclass_2=dict(
aci_class='l3extInstP',
aci_rn='instP-{0}'.format(extepg),
module_object=extepg,
target_filter={'name': extepg},
),
subclass_3=dict(
aci_class=aci_class,
aci_rn='{0}{1}'.format(aci_rn, contract),
module_object=contract,
target_filter={'tnVzBrCPName': contract},
),
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class=aci_class,
class_config=dict(
matchT=provider_match,
prio=priority,
tnVzBrCPName=contract,
),
)
aci.get_diff(aci_class=aci_class)
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(
tenant=dict(type="str", required=True, aliases=["tenant_name"]),
l3out=dict(type="str", required=True, aliases=["l3out_name"]),
extepg=dict(type="str", required=True, aliases=["extepg_name",
"name"]),
network=dict(type="str", aliases=["address", "ip"]),
description=dict(type="str", aliases=["descr"]),
subnet_name=dict(type="str", aliases=["name"]),
scope=dict(type="list",
elements="str",
default=["import-security"],
choices=[
"export-rtctrl", "import-security", "shared-rtctrl",
"shared-security"
]),
state=dict(type="str",
default="present",
choices=["absent", "present", "query"]),
name_alias=dict(type="str"),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "present", ["network"]],
["state", "absent", ["network"]],
],
)
aci = ACIModule(module)
tenant = module.params.get("tenant")
l3out = module.params.get("l3out")
extepg = module.params.get("extepg")
network = module.params.get("network")
description = module.params.get("description")
subnet_name = module.params.get("subnet_name")
scope = ",".join(sorted(module.params.get("scope")))
state = module.params.get("state")
name_alias = module.params.get("name_alias")
aci.construct_url(
root_class=dict(
aci_class="fvTenant",
aci_rn="tn-{0}".format(tenant),
module_object=tenant,
target_filter={"name": tenant},
),
subclass_1=dict(
aci_class="l3extOut",
aci_rn="out-{0}".format(l3out),
module_object=l3out,
target_filter={"name": l3out},
),
subclass_2=dict(
aci_class="l3extInstP",
aci_rn="instP-{0}".format(extepg),
module_object=extepg,
target_filter={"name": extepg},
),
subclass_3=dict(
aci_class="l3extSubnet",
aci_rn="extsubnet-[{0}]".format(network),
module_object=network,
target_filter={"name": network},
),
)
aci.get_existing()
if state == "present":
aci.payload(
aci_class="l3extSubnet",
class_config=dict(
ip=network,
descr=description,
name=subnet_name,
scope=scope,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class="l3extSubnet")
aci.post_config()
elif state == "absent":
aci.delete_config()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
tenant=dict(type='str', aliases=['tenant_name']), # Not required for querying all objects
l3out=dict(type='str', aliases=['l3out_name']), # Not required for querying all objects
logical_node=dict(type='str'), # Not required for querying all objects
logical_interface=dict(type='str'),
path_dn=dict(type='str'),
side=dict(type='str'),
description=dict(type='str', aliases=['descr']),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
name_alias=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'present', ['side', 'path_dn', 'logical_interface', 'logical_node', 'l3out', 'tenant']],
['state', 'absent', ['side', 'path_dn', 'logical_interface', 'logical_node', 'l3out', 'tenant']],
],
)
aci = ACIModule(module)
tenant = module.params.get('tenant')
l3out = module.params.get('l3out')
logical_node = module.params.get('logical_node')
logical_interface = module.params.get('logical_interface')
path_dn = module.params.get('path_dn')
side = module.params.get('side')
description = module.params.get('description')
state = module.params.get('state')
name_alias = module.params.get('name_alias')
aci.construct_url(
root_class=dict(
aci_class='fvTenant',
aci_rn='tn-{0}'.format(tenant),
module_object=tenant,
target_filter={'name': tenant},
),
subclass_1=dict(
aci_class='l3extOut',
aci_rn='out-{0}'.format(l3out),
module_object=l3out,
target_filter={'name': l3out},
),
subclass_2=dict(
aci_class='l3extLNodeP',
aci_rn='lnodep-{0}'.format(logical_node),
module_object=logical_node,
target_filter={'name': logical_node},
),
subclass_3=dict(
aci_class='l3extLIfP',
aci_rn='/lifp-{0}'.format(logical_interface),
module_object=logical_interface,
target_filter={'name': logical_interface},
),
subclass_4=dict(
aci_class='l3extRsPathL3OutAtt',
aci_rn='/rspathL3OutAtt-[{0}]'.format(path_dn),
module_object=path_dn,
target_filter={'name': path_dn},
),
subclass_5=dict(
aci_class='l3extMember',
aci_rn='/mem-{0}'.format(side),
module_object=side,
target_filter={'name': side},
),
)
aci.get_existing()
if state == 'present':
aci.payload(
aci_class='l3extMember',
class_config=dict(
name=side,
descr=description,
nameAlias=name_alias,
),
)
aci.get_diff(aci_class='l3extMember')
aci.post_config()
elif state == 'absent':
aci.delete_config()
aci.exit_json()
