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(
id=dict(type='int', aliases=['controller', 'node']),
state=dict(type='str', default='query', choices=['query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
id = module.params.get('id')
state = module.params.get('state')
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='topSystem',
target_filter={'id': id}
)
)
aci.get_existing()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
region=dict(type='str', aliases=["name"]),
cloud=dict(type='str', choices=['aws', 'azure'], required=True),
state=dict(type='str', default='query', choices=['query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
region = module.params.get('region')
cloud = module.params.get('cloud')
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='cloudProvP',
aci_rn='clouddomp/provp-{0}'.format(cloud),
target_filter='eq(cloudProvP.vendor, "{0}")'.format(cloud),
module_object=cloud),
subclass_1=dict(
aci_class='cloudRegion',
aci_rn='region-{0}'.format(region),
target_filter='eq(cloudRegion.name, "{0}")'.format(region),
module_object=region),
child_classes=[])
aci.get_existing()
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(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(aci_annotation_spec())
argument_spec.update(
region=dict(type="str", aliases=["name"]),
cloud=dict(type="str", choices=["aws", "azure"], required=True),
state=dict(type="str", default="query", choices=["query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
region = module.params.get("region")
cloud = module.params.get("cloud")
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class="cloudProvP",
aci_rn="clouddomp/provp-{0}".format(cloud),
target_filter='eq(cloudProvP.vendor, "{0}")'.format(cloud),
module_object=cloud),
subclass_1=dict(
aci_class="cloudRegion",
aci_rn="region-{0}".format(region),
target_filter='eq(cloudRegion.name, "{0}")'.format(region),
module_object=region),
child_classes=[],
)
aci.get_existing()
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(
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(
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(
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(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({
'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(
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(
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(
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(
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(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(
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(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(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(
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(state=dict(type='str',
default='query',
choices=['query']), )
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
aci = ACIModule(module)
aci.construct_url(root_class=dict(aci_class='cloudProvP'))
aci.get_existing()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(aci_annotation_spec())
argument_spec.update(state=dict(type="str",
default="query",
choices=["query"]), )
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
aci = ACIModule(module)
aci.construct_url(root_class=dict(aci_class="cloudProvP"))
aci.get_existing()
aci.exit_json()
def main():
argument_spec = aci_argument_spec()
argument_spec.update(
id=dict(type="int", aliases=["controller", "node"]),
state=dict(type="str", default="query", choices=["query"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
id = module.params.get("id")
aci = ACIModule(module)
aci.construct_url(
root_class=dict(aci_class="topSystem", target_filter={"id": id}))
aci.get_existing()
aci.exit_json()
