def main():
argument_spec = aci_argument_spec
argument_spec.update(
mcp=dict(type='str', required=False,
aliases=['mcp_interface',
'name']), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
admin_state=dict(type='str', choices=['disabled', 'enabled']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
mcp = module.params['mcp']
description = module.params['description']
admin_state = module.params['admin_state']
state = module.params['state']
aci = ACIModule(module)
# TODO: This logic could be cleaner.
if mcp is not None:
path = 'api/mo/uni/infra/mcpIfP--%(mcp)s.json' % module.params
elif state == 'query':
# Query all objects
path = 'api/node/class/mcpIfPol.json'
else:
module.fail_json(
msg="Parameter 'mcp' is required for state 'absent' or 'present'")
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='mcpIfPol',
class_config=dict(name=mcp,
descr=description,
adminSt=admin_state))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='mcpIfPol')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(interface=dict(
type='str', required=True, aliases=['contract_name', 'name']))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
interface = aci_utils.parse_interface(module.params['interface'])
aci = ACIModule(module)
# query_str = '/api/class/infraRsHPathAtt.json?query-target-filter=eq(infraRsHPathAtt.tDn,"{}")&target-subtree-class=relnTo'.format(interface)
# try:
# query_res = json.loads(aci.query(query_str))
# if len(query_res) == 0:
# module.fail_json(msg="Interface not found", **results)
# int_override_dn = query_res[0]['infraRsHPathAtt']['attributes']['dn']
# except Exception as e:
# module.fail_json(msg="Error occured retrieving path info: %s"%e, **results)
#
#
#
# set_fact('int_override_dn', int_override_dn)
set_fact('interface_epgs', get_epgs(interface, aci, module))
results['changed'] = False
module.exit_json(**results)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
rtp=dict(type='str', required=False,
aliases=['name', 'rtp_name'
]), # Not required for querying all objects
tenant=dict(type='str', required=False,
aliases=['tenant_name'
]), # Not required for quering all objects
description=dict(type='str', aliases=['descr']),
tag=dict(type='int'),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['rtp', 'tenant']],
['state', 'present', ['rtp', 'tenant']],
],
)
rtp = module.params['rtp']
description = module.params['description']
tag = module.params['tag']
state = module.params['state']
aci = ACIModule(module)
aci.construct_url(root_class='tenant', subclass_1='rtp')
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(
aci_class='l3extRouteTagPol',
class_config=dict(
name=rtp,
descr=description,
tag=tag,
),
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='l3extRouteTagPol')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
tenant=dict(type='str',
required=False,
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']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
tenant = module.params['tenant']
description = module.params['description']
state = module.params['state']
aci = ACIModule(module)
if tenant is not None:
# Work with a specific object
path = 'api/mo/uni/tn-%(tenant)s.json' % module.params
elif state == 'query':
# Query all objects
path = 'api/class/fvTenant.json'
else:
module.fail_json(
msg="Parameter 'tenant' is required for state 'absent' or 'present'"
)
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='fvTenant',
class_config=dict(name=tenant, descr=description))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fvTenant')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
description=dict(type='str', aliases=['descr']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
policy_control_direction=dict(choices=['ingress', 'egress'],
type='str'),
policy_control_preference=dict(choices=['enforced', 'unenforced'],
type='str'),
state=dict(choices=['absent', 'present', 'query'],
type='str',
default='present'),
tenant=dict(type='str', required=False,
aliases=['tenant_name'
]), # Not required for querying all objects
vrf=dict(type='str',
required=False,
aliases=['context', 'name', 'vrf_name'
]), # Not required for querying all objects
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'absent', ['tenant', 'vrf']],
['state', 'present', ['tenant', 'vrf']]])
description = module.params['description']
policy_control_direction = module.params['policy_control_direction']
policy_control_preference = module.params['policy_control_preference']
state = module.params['state']
vrf = module.params['vrf']
aci = ACIModule(module)
aci.construct_url(root_class="tenant", subclass_1="vrf")
aci.get_existing()
if state == 'present':
# Filter out module params with null values
aci.payload(aci_class='fvCtx',
class_config=dict(descr=description,
pcEnfDir=policy_control_direction,
pcEnfPref=policy_control_preference,
name=vrf))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fvCtx')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
dst_group=dict(type='str', required=False,
aliases=['name'
]), # Not required for querying all objects
tenant=dict(type='str', required=False,
aliases=['tenant_name'
]), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'absent', ['dst_group', 'tenant']],
['state', 'present', ['dst_group', 'tenant']]],
)
dst_group = module.params['dst_group']
description = module.params['description']
state = module.params['state']
# Add tenant_span_dst_grp to module.params for URL building
module.params['tenant_span_dst_grp'] = dst_group
aci = ACIModule(module)
aci.construct_url(root_class='tenant', subclass_1='tenant_span_dst_grp')
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(
aci_class='spanDestGrp',
class_config=dict(name=dst_group, descr=description),
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='spanDestGrp')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
# Remove tenant_span_dst_grp that was used to build URL from module.params
module.params.pop('tenant_span_dst_grp')
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
lldp_policy=dict(type='str', require=False, aliases=['name']),
description=dict(type='str', aliases=['descr']),
receive_state=dict(type='str', choices=['disabled', 'enabled']),
transmit_state=dict(type='str', choices=['disabled', 'enabled']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['lldp_policy']],
['state', 'present', ['lldp_policy']],
],
)
lldp_policy = module.params['lldp_policy']
description = module.params['description']
receive_state = module.params['receive_state']
transmit_state = module.params['transmit_state']
state = module.params['state']
aci = ACIModule(module)
aci.construct_url(root_class='lldp_policy')
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(
aci_class='lldpIfPol',
class_config=dict(
name=lldp_policy,
descr=description,
adminRxSt=receive_state,
adminTxSt=transmit_state,
),
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='lldpIfPol')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
rtp=dict(type='str', required=False, aliases=['name', 'rtp_name']), # Not required for querying all objects
tenant=dict(type='str', required=False, aliases=['tenant_name']), # Not required for quering all objects
description=dict(type='str', aliases=['descr']),
tag=dict(type='int'),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
method=dict(type='str', choices=['delete', 'get', 'post'], aliases=['action'], removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
rtp = module.params['rtp']
tenant = module.params['tenant']
description = module.params['description']
tag = module.params['tag']
state = module.params['state']
aci = ACIModule(module)
if rtp is not None:
# Work with a specific object
if tenant is not None:
path = 'api/mo/uni/tn-%(tenant)s/rttag-%(rtp)s.json' % module.params
else:
path = 'api/class/l3extRouteTagPol.json?query-target-filter=eq(l3extRouteTagPol.name,"%(rtp)s")' % module.params
elif state == 'query':
# Query all objects
if tenant is not None:
path = 'api/mo/uni/tn-%(tenant)s.json?rsp-subtree=children&rsp-subtree-class=l3extRouteTagPol&rsp-subtree-include=no-scoped' % module.params
else:
path = 'api/node/class/l3extRouteTagPol.json'
else:
module.fail_json(msg="Parameter 'rtp' is required for state 'absent' or 'present'")
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='l3extRouteTagPol', class_config=dict(name=rtp, descr=description, tag=tag))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='l3extRouteTagPol')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
port_channel=dict(type='str', required=False, aliases=['name']), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
min_links=dict(type='int'),
max_links=dict(type='int'),
mode=dict(type='str', choices=['off', 'mac-pin', 'active', 'passive', 'mac-pin-nicload']),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
method=dict(type='str', choices=['delete', 'get', 'post'], aliases=['action'], removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
port_channel = module.params['port_channel']
description = module.params['description']
# TODO: Validate min_links is in the acceptable range
min_links = module.params['min_link']
# TODO: Validate max_links is in the acceptable range
min_links = str(min_links)
max_links = module.params['max_link']
max_links = str(max_links)
mode = module.params['mode']
state = module.params['state']
aci = ACIModule(module)
# TODO: This logic could be cleaner.
if port_channel is not None:
path = 'api/mo/uni/infra/lacplagp-%(port_channel)s.json' % module.params
elif state == 'query':
# Query all objects
path = 'api/node/class/lacplagPol.json'
else:
module.fail_json(msg="Parameter 'port_channel' is required for state 'absent' or 'present'")
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='lacpLagPol', class_config=dict(name=port_channel, descr=description, minLinks=min_links, maxLinks=max_links, mode=mode))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='lacpLagPol')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
bd=dict(type='str', aliases=['bd_name', 'bridge_domain']),
l3out=dict(type='str'),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
tenant=dict(type='str', aliases=['tenant_name']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6') # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_together=[['gateway', 'mask']],
required_if=[
['state', 'present', ['bd', 'l3out', 'tenant']],
['state', 'absent', ['bd', 'l3out', 'tenant']],
],
)
l3out = module.params['l3out']
state = module.params['state']
# Add bd_l3out key to module.params for building the URL
module.params['bd_l3out'] = l3out
aci = ACIModule(module)
aci.construct_url(root_class='tenant',
subclass_1='bd',
subclass_2='bd_l3out')
aci.get_existing()
if state == 'present':
# Filter out module params with null values
aci.payload(
aci_class='fvRsBDToOut',
class_config=dict(tnL3extOutName=l3out),
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fvRsBDToOut')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
# Remove bd_l3out key used for URL building from module.params
module.params.pop('bd_l3out')
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
contract=dict(type='str', aliases=['contract_name']),
filter_name=dict(type='str'),
log=dict(tyep='str', choices=['log', 'none'], aliases=['directive']),
subject=dict(type='str', aliases=['subject_name']),
tenant=dict(type='str', aliases=['tenant_name']),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
method=dict(type='str', choices=['delete', 'get', 'post'], aliases=['action'], removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'absent', ['contract', 'filter_name', 'subject', 'tenant']],
['state', 'present', ['contract', 'filter_name', 'subject', 'tenant']]]
)
# contract = module.params['contract']
filter_name = module.params['filter_name']
log = module.params['log']
# subject = module.params['subject']
# tenant = module.params['tenant']
state = module.params['state']
# Convert log to empty string if none, as that is what API expects. An empty string is not a good option to present the user.
if log == 'none':
log = ''
# TODO: cleanup this logic and provide better filter_strings for all options
if filter_name is not None:
# Work with specific binding
path = 'api/mo/uni/tn-%(tenant)s/brc-%(contract)s/subj-%(subject)s/rssubjFiltAtt-%(filter_name)s.json' % module.params
else:
path = 'api/class/vzRsSubjFiltAtt.json'
aci = ACIModule(module)
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='vzRsSubjFiltAtt', class_config=dict(tnVzFilterName=filter_name, directives=log))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='vzRsSubjFiltAtt')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
description=dict(type='str', aliases=['descr']),
method=dict(type='str', choices=['delete', 'get', 'post'], aliases=['action'], removed_in_version='2.6'), # Deprecated starting from v2.6
policy_control_direction=dict(choices=['ingress', 'egress'], type='str'),
policy_control_preference=dict(choices=['enforced', 'unenforced'], type='str'),
state=dict(choices=['absent', 'present', 'query'], type='str', default='present'),
tenant=dict(type='str', required=False, aliases=['tenant_name']), # Not required for querying all objects
vrf=dict(type='str', required=False, aliases=['context', 'name', 'vrf_name']), # Not required for querying all objects
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
description = module.params['description']
policy_control_direction = module.params['policy_control_direction']
policy_control_preference = module.params['policy_control_preference']
state = module.params['state']
tenant = module.params['tenant']
vrf = module.params['vrf']
aci = ACIModule(module)
if vrf is not None:
if tenant is not None:
path = 'api/mo/uni/tn-%(tenant)s/ctx-%(vrf)s.json' % module.params
elif state == 'query':
path = 'api/mo/uni/tn-%(tenant)s.json?rsp-subtree=children&rsp-subtree-class=fvCtx&rsp-subtree-include=no-scoped' % module.params
else:
module.fail_json(msg="Parameter 'tenant' is required for state 'absent' or 'present'")
elif state == 'query':
path = 'api/class/fvCtx.json'
else:
module.fail_json(msg="Parameter 'vrf' is required for state 'absent' or 'present'")
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module params with null values
aci.payload(aci_class='fvCtx', class_config=dict(descr=description, pcEnfDir=policy_control_direction, pcEnfPref=policy_control_preference, name=vrf))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fvCtx')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
l2_policy=dict(type='str', required=False, aliases=['name']), # Not required for querying all policies
description=dict(type='str', aliases=['descr']),
vlan_scope=dict(type='str', choices=['global', 'portlocal']), # No default provided on purpose
qinq=dict(type='str', choices=['core_port', 'disabled', 'edge_port']),
vepa=dict(type='str', choices=['disabled', 'enabled']),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
method=dict(type='str', choices=['delete', 'get', 'post'], aliases=['action'], removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
l2_policy = module.params['l2_policy']
vlan_scope = module.params['vlan_scope']
qinq = module.params['qinq']
if qinq is not None:
qinq = QINQ_MAPPING[qinq]
vepa = module.param['vepa']
description = module.params['description']
state = module.params['state']
aci = ACIModule(module)
if l2_policy is not None:
# Work with a specific object
path = 'api/mo/uni/infra/l2IfP-%(l2_policy)s.json' % module.params
elif state == 'query':
# Query all objects
path = 'api/class/l2IfPol.json'
else:
module.fail_json(msg="Parameter 'l2_policy' is required for state 'absent' or 'present'")
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='l2IfPol', class_config=dict(name=l2_policy, descr=description, vlanScope=vlan_scope, qinq=qinq, vepa=vepa))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='l2IfPol')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
port_security=dict(
type='str', required=False,
aliases=['name']), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
max_end_points=dict(type='int'),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'absent', ['port_security']],
['state', 'present', ['port_security']]],
)
port_security = module.params['port_security']
description = module.params['description']
max_end_points = module.params['max_end_points']
if max_end_points is not None and max_end_points not in range(12001):
module.fail_json(
msg='The "max_end_points" must be between 0 and 12000')
state = module.params['state']
aci = ACIModule(module)
aci.construct_url(root_class='port_security')
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(
aci_class='l2PortSecurityPol',
class_config=dict(name=port_security,
descr=description,
maximum=max_end_points),
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='l2PortSecurityPol')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
aep=dict(type='str',
aliases=['name',
'aep_name']), # not required for querying all AEPs
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', ['aep']],
['state', 'present', ['aep']],
],
)
aep = module.params['aep']
description = module.params['description']
state = module.params['state']
aci = ACIModule(module)
aci.construct_url(root_class=dict(
aci_class='infraAttEntityP',
aci_rn='infra/attentp-{}'.format(aep),
filter_target='eq(infraAttEntityP.name, "{}")'.format(aep),
module_object=aep,
), )
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(
aci_class='infraAttEntityP',
class_config=dict(
name=aep,
descr=description,
),
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='infraAttEntityP')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
tenant_name=dict(type='str', aliases=['name']),
description=dict(type='str', aliases=['descr']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
tenant_name = module.params['tenant_name']
description = str(module.params['description'])
state = module.params['state']
aci = ACIModule(module)
if tenant_name is not None:
# Work with a specific tenant
path = 'api/mo/uni/tn-%(tenant_name)s.json' % module.params
elif state == 'query':
# Query all tenants
path = 'api/node/class/fvTenant.json'
else:
module.fail_json(
"Parameter 'tenant_name' is required for state 'absent' or 'present'"
)
if state == 'query':
aci.request(path)
elif module.check_mode:
# TODO: Implement proper check-mode (presence check)
aci.result(changed=True, response='OK (Check mode)', status=200)
else:
payload = {
'fvTenant': {
'attributes': {
'name': tenant_name,
'descr': description
}
}
}
aci.request_diff(path, payload=json.dumps(payload))
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
contract=dict(type='str', required=False, aliases=['contract_name', 'name']), # Not required for querying all objects
tenant=dict(type='str', required=False, aliases=['tenant_name']), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
scope=dict(type='str', choices=['application-profile', 'context', 'global', 'tenant']),
priority=dict(type='str', choices=['level1', 'level2', 'level3', 'unspecified']), # No default provided on purpose
dscp=dict(type='str',
choices=['AF11', 'AF12', 'AF13', 'AF21', 'AF22', 'AF23', 'AF31', 'AF32', 'AF33', 'AF41', 'AF42', 'AF43',
'CS0', 'CS1', 'CS2', 'CS3', 'CS4', 'CS5', 'CS6', 'CS7', 'EF', 'VA', 'unspecified'],
aliases=['target']), # No default provided on purpose
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
method=dict(type='str', choices=['delete', 'get', 'post'], aliases=['action'], removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'absent', ['tenant', 'contract']],
['state', 'present', ['tenant', 'contract']]]
)
contract = module.params['contract']
description = module.params['description']
scope = module.params['scope']
priority = module.params['priority']
dscp = module.params['dscp']
state = module.params['state']
aci = ACIModule(module)
aci.construct_url(root_class='tenant', subclass_1='contract')
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(
aci_class='vzBrCP',
class_config=dict(name=contract, descr=description, scope=scope, prio=priority, targetDscp=dscp)
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='vzBrCP')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
aep=dict(type='str',
aliases=['name',
'aep_name']), # not required for querying all AEPs
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,
)
aep = module.params['aep']
description = module.params['description']
state = module.params['state']
aci = ACIModule(module)
if aep is not None:
path = 'api/mo/uni/infra/attentp-%(aep)s.json' % module.params
elif state == 'query':
path = 'api/class/infraAttEntityP.json'
else:
module.fail_json(
msg="Parameter 'aep' is required for state 'absent' or 'present'")
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='infraAttEntityP',
class_config=dict(name=aep, descr=description))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='infraAttEntityP')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
l2_policy=dict(type='str', required=False, aliases=['name']), # Not required for querying all policies
description=dict(type='str', aliases=['descr']),
vlan_scope=dict(type='str', choices=['global', 'portlocal']), # No default provided on purpose
qinq=dict(type='str', choices=['core', 'disabled', 'edge']),
vepa=dict(type='str', choices=['disabled', 'enabled']),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
method=dict(type='str', choices=['delete', 'get', 'post'], aliases=['action'], removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'absent', ['l2_policy']],
['state', 'present', ['l2_policy']]]
)
l2_policy = module.params['l2_policy']
vlan_scope = module.params['vlan_scope']
qinq = module.params['qinq']
if qinq is not None:
qinq = QINQ_MAPPING[qinq]
vepa = module.params['vepa']
description = module.params['description']
state = module.params['state']
aci = ACIModule(module)
aci.construct_url(root_class='l2_policy')
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(
aci_class='l2IfPol',
class_config=dict(name=l2_policy, descr=description, vlanScope=vlan_scope, qinq=qinq, vepa=vepa)
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='l2IfPol')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
bd=dict(type='str', aliases=['bd_name', 'bridge_domain']),
l3out=dict(type='str'),
state=dict(type='str', choices=['absent', 'present', 'query']),
tenant=dict(type='str', aliases=['tenant_name']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6') # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_together=[['gateway', 'mask']],
required_if=[['state', 'present', ['bd', 'l3out', 'tenant']],
['state', 'absent', ['bd', 'l3out', 'tenant']]])
l3out = module.params['l3out']
state = module.params['state']
aci = ACIModule(module)
if state != 'query':
path = 'api/mo/uni/tn-%(tenant)s/BD-%(bd)s/rsBDToOut-%(l3out)s.json' % module.params
else:
path = 'api/class/fvRsBDToOut.json'
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module params with null values
aci.payload(aci_class='fvRsBDToOut',
class_config=dict(tnL3extOutName=l3out))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fvRsBDToOut')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
fc_policy=dict(type='str', required=False, 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']),
method=dict(type='str', choices=['delete', 'get', 'post'], aliases=['action'], removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'absent', ['fc_policy']],
['state', 'present', ['fc_policy']]]
)
fc_policy = module.params['fc_policy']
port_mode = module.params['port_mode']
description = module.params['description']
state = module.params['state']
aci = ACIModule(module)
aci.construct_url(root_class='fc_policy')
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(
aci_class='fcIfPol',
class_config=dict(name=fc_policy, descr=description, portMode=port_mode)
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fcIfPol')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
compare_export_policy=dict(type='str'),
compare_snapshot=dict(type='str'),
description=dict(type='str', aliases=['descr']),
export_policy=dict(type='str'),
fail_on_decrypt=dict(type='bool'),
import_mode=dict(type='str', choices=['atomic', 'best-effort']),
import_policy=dict(type='str'),
import_type=dict(type='str', choices=['merge', 'replace']),
snapshot=dict(type='str', required=True),
state=dict(type='str',
default='rollback',
choices=['preview', 'rollback']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
required_if=[
[
'state', 'preview',
['compare_export_policy', 'compare_snapshot']
],
['state', 'rollback', ['import_policy']],
],
)
description = module.params['description']
export_policy = module.params['export_policy']
fail_on_decrypt = module.params['fail_on_decrypt']
if fail_on_decrypt is True:
fail_on_decrypt = 'yes'
elif fail_on_decrypt is False:
fail_on_decrypt = 'no'
import_mode = module.params['import_mode']
import_policy = module.params['import_policy']
import_type = module.params['import_type']
snapshot = module.params['snapshot']
state = module.params['state']
aci = ACIModule(module)
if state == 'rollback':
if snapshot.startswith('run-'):
snapshot = snapshot.replace('run-', '', 1)
if not snapshot.endswith('.tar.gz'):
snapshot += '.tar.gz'
filename = 'ce2_{0}-{1}'.format(export_policy, snapshot)
aci.construct_url(root_class=dict(
aci_class='configImportP',
aci_rn='fabric/configimp-{}'.format(import_policy),
filter_target='(configImportP.name, "{}")'.format(import_policy),
module_object=import_policy,
), )
aci.get_existing()
# Filter out module parameters with null values
aci.payload(
aci_class='configImportP',
class_config=dict(
adminSt='triggered',
descr=description,
failOnDecryptErrors=fail_on_decrypt,
fileName=filename,
importMode=import_mode,
importType=import_type,
name=import_policy,
snapshot='yes',
),
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='configImportP')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'preview':
aci.result[
'url'] = '%(protocol)s://%(hostname)s/mqapi2/snapshots.diff.xml' % module.params
aci.result['filter_string'] = (
'?s1dn=uni/backupst/snapshots-[uni/fabric/configexp-%(export_policy)s]/snapshot-%(snapshot)s&'
's2dn=uni/backupst/snapshots-[uni/fabric/configexp-%(compare_export_policy)s]/snapshot-%(compare_snapshot)s'
) % module.params
# Generate rollback comparison
get_preview(aci)
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
bd=dict(type='str', aliases=['bd_name']),
description=dict(type='str', aliases=['descr']),
enable_vip=dict(type='str', choices=['no', 'yes']),
gateway=dict(type='str', aliases=['gateway_ip']),
mask=dict(type='int', aliases=['subnet_mask']),
subnet_name=dict(type='str', aliases=['name']),
nd_prefix_policy=dict(type='str'),
preferred=dict(type='str', choices=['no', 'yes']),
route_profile=dict(type='str'),
route_profile_l3_out=dict(type='str'),
scope=dict(
type='list',
choices=[['private'], ['public'], ['shared'],
['private', 'shared'], ['shared', 'private'],
['public', 'shared'], ['shared', 'public']],
),
subnet_control=dict(
type='str',
choices=['nd_ra', 'no_gw', 'querier_ip', 'unspecified']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
tenant=dict(type='str', aliases=['tenant_name']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_together=[['gateway', 'mask']],
required_if=[
['state', 'present', ['bd', 'gateway', 'mask', 'tenant']],
['state', 'absent', ['bd', 'gateway', 'mask', 'tenant']],
],
)
description = module.params['description']
enable_vip = module.params['enable_vip']
tenant = module.params['tenant']
bd = module.params['bd']
gateway = module.params['gateway']
mask = module.params['mask']
if mask is not None and mask not in range(0, 129):
# TODO: split checkes between IPv4 and IPv6 Addresses
module.fail_json(
msg=
'Valid Subnet Masks are 0 to 32 for IPv4 Addresses and 0 to 128 for IPv6 addresses'
)
if gateway is not None:
gateway = '{}/{}'.format(gateway, str(mask))
subnet_name = module.params['subnet_name']
nd_prefix_policy = module.params['nd_prefix_policy']
preferred = module.params['preferred']
route_profile = module.params['route_profile']
route_profile_l3_out = module.params['route_profile_l3_out']
scope = module.params['scope']
if scope:
if len(scope) == 1:
scope = scope[0]
elif 'public' in scope:
scope = 'public,shared'
else:
scope = 'private,shared'
state = module.params['state']
subnet_control = module.params['subnet_control']
if subnet_control:
subnet_control = SUBNET_CONTROL_MAPPING[subnet_control]
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='fvTenant',
aci_rn='tn-{}'.format(tenant),
filter_target='eq(fvTenant.name, \"{}\")'.format(tenant),
module_object=tenant,
),
subclass_1=dict(
aci_class='fvBD',
aci_rn='BD-{}'.format(bd),
filter_target='eq(fvBD.name, \"{}\")'.format(bd),
module_object=bd,
),
subclass_2=dict(
aci_class='fvSubnet',
aci_rn='subnet-[{}]'.format(gateway),
filter_target='eq(fvSubnet.ip, \"{}\")'.format(gateway),
module_object=gateway,
),
child_classes=['fvRsBDSubnetToProfile', 'fvRsNdPfxPol'],
)
aci.get_existing()
if state == 'present':
# Filter out module params with null values
aci.payload(
aci_class='fvSubnet',
class_config=dict(
ctrl=subnet_control,
descr=description,
ip=gateway,
name=subnet_name,
preferred=preferred,
scope=scope,
virtual=enable_vip,
),
child_configs=[
{
'fvRsBDSubnetToProfile': {
'attributes': {
'tnL3extOutName': route_profile_l3_out,
'tnRtctrlProfileName': route_profile
}
}
},
{
'fvRsNdPfxPol': {
'attributes': {
'tnNdPfxPolName': nd_prefix_policy
}
}
},
],
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fvSubnet')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
description=dict(type='str', aliases=['descr']),
export_policy=dict(type='str', aliases=['name']),
format=dict(type='str', choices=['json', 'xml']),
include_secure=dict(type='str', choices=['no', 'yes']),
max_count=dict(type='int'),
snapshot=dict(type='str'),
state=dict(type='str', choices=['absent', 'present', 'query'], default='present'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
required_if=[
['state', 'absent', ['export_policy', 'snapshot']],
['state', 'present', ['export_policy']],
],
)
description = module.params['description']
export_policy = module.params['export_policy']
file_format = module.params['format']
include_secure = module.params['include_secure']
max_count = module.params['max_count']
if max_count is not None:
if max_count in range(1, 11):
max_count = str(max_count)
else:
module.fail_json(msg='The "max_count" must be a number between 1 and 10')
snapshot = module.params['snapshot']
if snapshot is not None and not snapshot.startswith('run-'):
snapshot = 'run-' + snapshot
state = module.params['state']
aci = ACIModule(module)
if state == 'present':
aci.construct_url(
root_class=dict(
aci_class='configExportP',
aci_rn='fabric/configexp-{}'.format(export_policy),
filter_target='eq(configExportP.name, "{}")'.format(export_policy),
module_object=export_policy,
),
)
aci.get_existing()
# Filter out module params with null values
aci.payload(
aci_class='configExportP',
class_config=dict(
adminSt='triggered',
descr=description,
format=file_format,
includeSecureFields=include_secure,
maxSnapshotCount=max_count,
name=export_policy,
snapshot='yes',
),
)
aci.get_diff('configExportP')
# Create a new Snapshot
aci.post_config()
else:
# Prefix the proper url to export_policy
if export_policy is not None:
export_policy = 'uni/fabric/configexp-{}'.format(export_policy)
aci.construct_url(
root_class=dict(
aci_class='configSnapshotCont',
aci_rn='backupst/snapshots-[{}]'.format(export_policy),
filter_target='(configSnapshotCont.name, "{}")'.format(export_policy),
module_object=export_policy,
),
subclass_1=dict(
aci_class='configSnapshot',
aci_rn='snapshot-{}'.format(snapshot),
filter_target='(configSnapshot.name, "{}")'.format(snapshot),
module_object=snapshot,
),
)
aci.get_existing()
if state == 'absent':
# Build POST request to used to remove Snapshot
aci.payload(
aci_class='configSnapshot',
class_config=dict(
name=snapshot,
retire="yes",
),
)
if aci.result['existing']:
aci.get_diff('configSnapshot')
# Mark Snapshot for Deletion
aci.post_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
path=dict(type='str', required=True, aliases=['uri']),
method=dict(type='str',
default='get',
choices=['delete', 'get', 'post'],
aliases=['action']),
src=dict(type='path', aliases=['config_file']),
content=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[['content', 'src']],
)
path = module.params['path']
content = module.params['content']
src = module.params['src']
method = module.params['method']
timeout = module.params['timeout']
# Report missing file
file_exists = False
if src:
if os.path.isfile(src):
file_exists = True
else:
module.fail_json(msg="Cannot find/access src '%s'" % src)
# Find request type
if path.find('.xml') != -1:
rest_type = 'xml'
if not HAS_LXML_ETREE:
module.fail_json(
msg=
'The lxml python library is missing, or lacks etree support.')
if not HAS_XMLJSON_COBRA:
module.fail_json(
msg=
'The xmljson python library is missing, or lacks cobra support.'
)
elif path.find('.json') != -1:
rest_type = 'json'
else:
module.fail_json(
msg='Failed to find REST API content type (neither .xml nor .json).'
)
aci = ACIModule(module)
# We include the payload as it may be templated
payload = content
if file_exists:
with open(src, 'r') as config_object:
# TODO: Would be nice to template this, requires action-plugin
payload = config_object.read()
# Perform actual request using auth cookie (Same as aci_request,but also supports XML)
url = '%(protocol)s://%(hostname)s/' % aci.params + path.lstrip('/')
if method != 'get':
url = update_qsl(url, {'rsp-subtree': 'modified'})
aci.result['url'] = url
resp, info = fetch_url(module,
url,
data=payload,
method=method.upper(),
timeout=timeout,
headers=aci.headers)
aci.result['response'] = info['msg']
aci.result['status'] = info['status']
# Report failure
if info['status'] != 200:
try:
aci_response(aci.result, info['body'], rest_type)
module.fail_json(
msg='Request failed: %(error_code)s %(error_text)s' %
aci.result,
**aci.result)
except KeyError:
module.fail_json(msg='Request failed for %(url)s. %(msg)s' % info,
**aci.result)
aci_response(aci.result, resp.read(), rest_type)
# Report success
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
action_rule=dict(type='str',
required=False,
aliases=['action_rule_name', 'name'
]), # Not required for querying all objects
tenant=dict(type='str', required=False,
aliases=['tenant_name'
]), # Not required for querying all objects
description=dict(type='str', aliases=['descr']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['action_rule', 'tenant']],
['state', 'present', ['action_rule', 'tenant']],
],
)
action_rule = module.params['action_rule']
description = module.params['description']
state = module.params['state']
tenant = module.params['tenant']
aci = ACIModule(module)
aci.construct_url(
root_class=dict(
aci_class='fvTenant',
aci_rn='tn-{}'.format(tenant),
filter_target='(fvTenant.name, "{}")'.format(tenant),
module_object=tenant,
),
subclass_1=dict(
aci_class='rtctrlAttrP',
aci_rn='attr-{}'.format(action_rule),
filter_target='(rtctrlAttrP.name, "{}")'.format(action_rule),
module_object=action_rule,
),
)
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(
aci_class='rtctrlAttrP',
class_config=dict(
name=action_rule,
descr=description,
),
)
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='rtctrlAttrP')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
bd=dict(type='str', aliases=['bd_name']),
description=dict(type='str', aliases=['descr']),
enable_vip=dict(type='str', choices=['no', 'yes']),
gateway=dict(type='str', aliases=['gateway_ip']),
mask=dict(type='int', aliases=['subnet_mask']),
subnet_name=dict(type='str', aliases=['name']),
nd_prefix_policy=dict(type='str'),
preferred=dict(type='str', choices=['no', 'yes']),
route_profile=dict(type='str'),
route_profile_l3_out=dict(type='str'),
scope=dict(type='str', choices=['private', 'public', 'shared']),
subnet_control=dict(
type='str',
choices=['nd_ra', 'no_gw', 'querier_ip', 'unspecified']),
state=dict(type='str', choices=['absent', 'present', 'query']),
tenant=dict(type='str', aliases=['tenant_name']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6') # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_together=[['gateway', 'mask']],
required_if=[['state', 'present', ['bd', 'gateway', 'mask', 'tenant']],
['state', 'absent', ['bd', 'gateway', 'mask', 'tenant']]])
bd = module.params['bd']
description = module.params['description']
enable_vip = module.params['enable_vip']
gateway = module.params['gateway']
mask = module.params['mask']
if mask is not None and mask not in range(0, 129):
# TODO: split checkes between IPv4 and IPv6 Addresses
module.fail_json(
msg=
'Valid Subnet Masks are 0 to 32 for IPv4 Addresses and 0 to 128 for IPv6 addresses'
)
if gateway is not None and mask is not None:
gateway_addr = '{}/{}'.format(gateway, str(mask))
subnet_name = module.params['subnet_name']
nd_prefix_policy = module.params['nd_prefix_policy']
preferred = module.params['preferred']
route_profile = module.params['route_profile']
route_profile_l3_out = module.params['route_profile_l3_out']
scope = module.params['scope']
state = module.params['state']
subnet_control = module.params['subnet_control']
if subnet_control:
subnet_control = SUBNET_CONTROL_MAPPING[subnet_control]
tenant = module.params['tenant']
aci = ACIModule(module)
if gateway is not None:
if tenant is not None and bd is not None:
path = 'api/mo/uni/tn-%(tenant)s/BD-%(bd)s/subnet-[%(gateway)s/%(mask)s].json' % module.params
filter_string = '?rsp-subtree=full&rsp-subtree-class=fvRsBDSubnetToProfile,fvRsNdPfxPol&rsp-prop-include=config-only'
elif tenant is not None:
path = 'api/mo/uni/tn-%(tenant)s.json' % module.params
filter_string = (
'?rsp-subtree=full&rsp-subtree-class=fvSubnet,fvRsBDSubnetToProfile,fvRsNdPfxPol'
'&rsp-subtree-filter=eq(fvSubnet.ip, \"%(gateway)s/%(mask)s\")'
) % module.params
elif bd is not None:
path = 'api/class/fvBD.json'
filter_string = (
'?query-target-filter=eq(fvBD.name, \"%(bd)s\")&rsp-subtree=full&rsp-subtree-class=fvSubnet,fvRsBDSubnetToProfile,fvRsNdPfxPol'
'&rsp-subtree-filter=eq(fvSubnet.ip, \"%(gateway)s/%(mask)s\")'
) % module.params
else:
path = 'api/class/fvSubnet.json'
filter_string = '?query-target-filter=eq(fvSubnet.ip, \"%(gateway)s/%(mask)s\")&rsp-subtree=children' % module.params
elif subnet_name is not None:
if tenant is not None and bd is not None:
path = 'api/mo/uni/tn-%(tenant)s/BD-%(bd)s.json' % module.params
filter_string = (
'?rsp-subtree=full&rsp-subtree-class=fvSubnet,fvRsBDSubnetToProfile,fvRsNdPfxPol'
'&rsp-subtree-filter=eq(fvSubnet.name, \"%(name)s\")'
) % module.params
elif tenant is not None:
path = 'api/mo/uni/tn-%(tenant)s.json' % module.params
filter_string = (
'?rsp-subtree=full&rsp-subtree-class=fvSubnet,fvRsBDSubnetToProfile,fvRsNdPfxPol'
'&rsp-subtree-filter=eq(fvSubnet.name, \"%(name)s\")'
) % module.params
elif bd is not None:
path = 'api/class/fvBD.json'
filter_string = (
'?query-target-filter=eq(fvBD.name, \"%(bd)s\")&rsp-subtree=full&rsp-subtree-class=fvSubnet,fvRsBDSubnetToProfile,fvRsNdPfxPol'
'&rsp-subtree-filter=eq(fvSubnet.name, \"%(name)s\")'
) % module.params
else:
path = 'api/class/fvSubnet.json'
filter_string = '?query-target-filter=eq(fvSubnet.name, \"%(name)s\")&rsp-subtree=children' % module.params
elif tenant is not None:
if bd is not None:
path = 'api/mo/uni/tn-%(tenant)s/BD-%(bd)s.json' % module.params
filter_string = '?rsp-subtree=full&rsp-subtree-class=fvSubnet,fvRsBDSubnetToProfile,fvRsNdPfxPol'
else:
path = 'api/mo/uni/tn-%(tenant)s.json' % module.params
filter_string = '?rsp-subtree=full&rsp-subtree-class=fvSubnet,fvRsBDSubnetToProfile,fvRsNdPfxPol'
elif bd is not None:
path = 'api/class/fvBD.json'
filter_string = (
'?query-target-filter=eq(fvBD.name, \"%(bd)s\")&rsp-subtree=full'
'&rsp-subtree-class=fvSubnet,fvRsBDSubnetToProfile,fvRsNdPfxPol'
) % module.params
else:
path = 'api/class/fvSubnet.json'
filter_string = '?rsp-subtree=full&rsp-subtree-class=fvSubnet,fvRsBDSubnetToProfile,fvRsNdPfxPol'
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing(filter_string=filter_string)
if state == 'present':
# Filter out module params with null values
aci.payload(aci_class='fvSubnet',
class_config=dict(ctrl=subnet_control,
descr=description,
ip=gateway_addr,
name=subnet_name,
preferred=preferred,
scope=scope,
virtual=enable_vip),
child_configs=[{
'fvRsBDSubnetToProfile': {
'attributes': {
'tnL3extOutName': route_profile_l3_out,
'tnRtctrlProfileName': route_profile
}
}
}, {
'fvRsNdPfxPol': {
'attributes': {
'tnNdPfxPolName': nd_prefix_policy
}
}
}])
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fvSubnet')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
allow_useg=dict(type='str', choices=['encap', 'useg']),
app_profile=dict(type='str', aliases=['app_profile_name']),
deploy_immediacy=dict(type='str', choices=['immediate', 'on-demand']),
domain_profile=dict(type='str', aliases=['domain_name']),
domain_type=dict(type='str',
choices=['phys', 'vmm'],
aliases=['domain']),
encap=dict(type='int'),
encap_mode=dict(type='str', choices=['auto', 'vlan', 'vxlan']),
epg=dict(type='str', aliases=['name', 'epg_name']),
netflow=dict(type='str', choices=['disabled', 'enabled']),
primary_encap=dict(type='int'),
resolution_immediacy=dict(
type='str', choices=['immdediate', 'lazy', 'pre-provision']),
tenant=dict(type='str', aliases=['tenant_name']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[[
'state', 'absent',
['app_profile', 'domain_profile', 'domain_type', 'epg', 'tenant']
],
[
'state', 'present',
[
'app_profile', 'domain_profile', 'domain_type',
'epg', 'tenant'
]
]])
allow_useg = module.params['allow_useg']
# app_profile = module.params['app_profile']
deploy_immediacy = module.params['deploy_immediacy']
# domain_profile = module.params['domain_profile']
domain_type = module.params['domain_type']
if domain_type == 'vmm':
module.params["domain_type"] = 'vmmp-VMware/dom'
encap = module.params['encap']
if encap is not None:
if encap in range(1, 4097):
encap = 'vlan-{}'.format(encap)
else:
module.fail_json(msg='Valid VLAN assigments are from 1 to 4096')
encap_mode = module.params['encap_mode']
# epg = module.params['epg']
# tenant = module.params['tenant']
netflow = module.params['netflow']
primary_encap = module.params['primary_encap']
if primary_encap is not None:
if primary_encap in range(1, 4097):
primary_encap = 'vlan-{}'.format(primary_encap)
else:
module.fail_json(msg='Valid VLAN assigments are from 1 to 4096')
resolution_immediacy = module.params['resolution_immediacy']
state = module.params['state']
aci = ACIModule(module)
# TODO: Add logic to handle multiple input variations when query
if state != 'query':
# Work with a specific EPG
path = ('api/mo/uni/tn-%(tenant)s/ap-%(app_profile)s/epg-%(epg)s/'
'rsdomAtt-[uni/%(domain_type)s-%(domain_profile)s].json'
) % module.params
else:
# Query all EPGs
path = 'api/class/fvRsDomAtt.json'
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='fvRsDomAtt',
class_config=dict(classPref=allow_useg,
encap=encap,
encapMode=encap_mode,
instrImedcy=deploy_immediacy,
netflowPref=netflow,
primaryEncap=primary_encap,
resImedcy=resolution_immediacy))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fvRsDomAtt')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
contract=dict(type='str', aliases=['contract_name']),
subject=dict(type='str',
aliases=['contract_subject', 'name', 'subject_name']),
tenant=dict(type='str', aliases=['tenant_name']),
priority=dict(type='str',
choices=['unspecified', 'level1', 'level2', 'level3']),
reverse_filter=dict(type='str', choices=['yes', 'no']),
dscp=dict(type='str', aliases=['target']),
description=dict(type='str', aliases=['descr']),
consumer_match=dict(
type='str', choices=['all', 'at_least_one', 'at_most_one',
'none']),
provider_match=dict(
type='str', choices=['all', 'at_least_one', 'at_most_one',
'none']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
directive=dict(
type='str',
removed_in_version='2.4'), # Deprecated starting from v2.4
filter=dict(type='str',
aliases=['filter_name'],
removed_in_version='2.4') # Deprecated starting from v2.4
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'absent', ['contract', 'subject', 'tenant']],
['state', 'present', ['contract', 'subject', 'tenant']]])
subject = module.params['subject']
priority = module.params['priority']
reverse_filter = module.params['reverse_filter']
dscp = module.params['dscp']
description = module.params['description']
filter_name = module.params['filter']
directive = module.params['directive']
consumer_match = module.params['consumer_match']
provider_match = module.params['provider_match']
state = module.params['state']
if directive is not None or filter_name is not None:
module.fail_json(
msg=
'Managing Contract Subjects to Filter bindings has been moved to M(aci_subject_bind_filter)'
)
aci = ACIModule(module)
aci.construct_url(root_class='tenant',
subclass_1='contract',
subclass_2='subject')
aci.get_existing()
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='vzSubj',
class_config=dict(name=subject,
prio=priority,
revFltPorts=reverse_filter,
targetDscp=dscp,
consMatchT=consumer_match,
provMatchT=provider_match,
descr=description))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='vzSubj')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)
def main():
argument_spec = aci_argument_spec
argument_spec.update(
tenant=dict(type='str',
aliases=['tenant_name'
]), # tenant not required for querying all APs
app_profile=dict(type='str',
aliases=['ap', 'app_profile_name', 'name']),
description=dict(type='str', aliases=['descr'], required=False),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
method=dict(type='str',
choices=['delete', 'get', 'post'],
aliases=['action'],
removed_in_version='2.6'), # Deprecated starting from v2.6
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'absent', ['tenant', 'app_profile']],
['state', 'present', ['tenant', 'app_profile']]])
tenant = module.params['tenant']
app_profile = module.params['app_profile']
description = module.params['description']
state = module.params['state']
aci = ACIModule(module)
if tenant is not None and app_profile is not None:
path = 'api/mo/uni/tn-%(tenant)s/ap-%(app_profile)s.json' % module.params
filter_string = ''
elif tenant is None and app_profile is None:
path = 'api/class/fvAp.json'
filter_string = ''
elif tenant is not None:
path = 'api/mo/uni/tn-%(tenant)s.json' % module.params
filter_string = '?rsp-subtree=children&rsp-subtree-class=fvAp&rsp-subtree-include=no-scoped'
else:
path = 'api/class/fvAp.json'
filter_string = '?query-target-filter=eq(fvAp.name, \"%(app_profile)s\")' % module.params
aci.result['url'] = '%(protocol)s://%(hostname)s/' % aci.params + path
aci.get_existing(filter_string=filter_string)
if state == 'present':
# Filter out module parameters with null values
aci.payload(aci_class='fvAp',
class_config=dict(name=app_profile, descr=description))
# Generate config diff which will be used as POST request body
aci.get_diff(aci_class='fvAp')
# Submit changes if module not in check_mode and the proposed is different than existing
aci.post_config()
elif state == 'absent':
aci.delete_config()
module.exit_json(**aci.result)