def main():
argument_spec = mso_argument_spec()
argument_spec.update(
schema=dict(type='str', required=True),
site=dict(type='str', required=True),
template=dict(type='str', required=True),
anp=dict(type='str', required=True),
epg=dict(type='str', required=True),
type=dict(type='str', default='port', choices=['port', 'vpc', 'dpc']),
pod=dict(type='str'
), # This parameter is not required for querying all objects
leaf=dict(type='str'
), # This parameter is not required for querying all objects
fex=dict(type='str'
), # This parameter is not required for querying all objects
path=dict(type='str'
), # This parameter is not required for querying all objects
vlan=dict(type='int'
), # This parameter is not required for querying all objects
primary_micro_segment_vlan=dict(
type='int'
), # This parameter is not required for querying all objects
deployment_immediacy=dict(type='str',
default='lazy',
choices=['immediate', 'lazy']),
mode=dict(type='str',
default='untagged',
choices=['native', 'regular', 'untagged']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['type', 'pod', 'leaf', 'path', 'vlan']],
['state', 'present', ['type', 'pod', 'leaf', 'path', 'vlan']],
],
)
schema = module.params.get('schema')
site = module.params.get('site')
template = module.params.get('template').replace(' ', '')
anp = module.params.get('anp')
epg = module.params.get('epg')
path_type = module.params.get('type')
pod = module.params.get('pod')
leaf = module.params.get('leaf')
fex = module.params.get('fex')
path = module.params.get('path')
vlan = module.params.get('vlan')
primary_micro_segment_vlan = module.params.get(
'primary_micro_segment_vlan')
deployment_immediacy = module.params.get('deployment_immediacy')
mode = module.params.get('mode')
state = module.params.get('state')
if path_type == 'port' and fex is not None:
# Select port path for fex if fex param is used
portpath = 'topology/{0}/paths-{1}/extpaths-{2}/pathep-[{3}]'.format(
pod, leaf, fex, path)
elif path_type == 'vpc':
portpath = 'topology/{0}/protpaths-{1}/pathep-[{2}]'.format(
pod, leaf, path)
else:
portpath = 'topology/{0}/paths-{1}/pathep-[{2}]'.format(
pod, leaf, path)
mso = MSOModule(module)
# Get schema_id
schema_obj = mso.get_obj('schemas', displayName=schema)
if not schema_obj:
mso.fail_json(
msg="Provided schema '{0}' does not exist".format(schema))
schema_path = 'schemas/{id}'.format(**schema_obj)
schema_id = schema_obj.get('id')
# Get template
templates = [t.get('name') for t in schema_obj.get('templates')]
if template not in templates:
mso.fail_json(
msg="Provided template '{0}' does not exist. Existing templates: {1}"
.format(template, ', '.join(templates)))
template_idx = templates.index(template)
# Get site
site_id = mso.lookup_site(site)
# Get site_idx
if 'sites' not in schema_obj:
mso.fail_json(
msg=
"No site associated with template '{0}'. Associate the site with the template using mso_schema_site."
.format(template))
sites = [(s.get('siteId'), s.get('templateName'))
for s in schema_obj.get('sites')]
sites_list = [
s.get('siteId') + '/' + s.get('templateName')
for s in schema_obj.get('sites')
]
if (site_id, template) not in sites:
mso.fail_json(
msg="Provided site/siteId/template '{0}/{1}/{2}' does not exist. "
"Existing siteIds/templates: {3}".format(site, site_id, template,
', '.join(sites_list)))
# Schema-access uses indexes
site_idx = sites.index((site_id, template))
# Path-based access uses site_id-template
site_template = '{0}-{1}'.format(site_id, template)
payload = dict()
ops = []
op_path = ''
# Get ANP
anp_ref = mso.anp_ref(schema_id=schema_id, template=template, anp=anp)
anps = [a.get('anpRef') for a in schema_obj['sites'][site_idx]['anps']]
anps_in_temp = [
a.get('name') for a in schema_obj['templates'][template_idx]['anps']
]
if anp not in anps_in_temp:
mso.fail_json(
msg="Provided anp '{0}' does not exist. Existing anps: {1}".format(
anp, ', '.join(anps)))
else:
# Update anp index at template level
template_anp_idx = anps_in_temp.index(anp)
# If anp not at site level but exists at template level
if anp_ref not in anps:
op_path = '/sites/{0}/anps/-'.format(site_template)
payload.update(anpRef=dict(
schemaId=schema_id,
templateName=template,
anpName=anp,
), )
else:
# Update anp index at site level
anp_idx = anps.index(anp_ref)
# Get EPG
epg_ref = mso.epg_ref(schema_id=schema_id,
template=template,
anp=anp,
epg=epg)
# If anp exists at site level
if 'anpRef' not in payload:
epgs = [
e.get('epgRef')
for e in schema_obj['sites'][site_idx]['anps'][anp_idx]['epgs']
]
# If anp already at site level AND if epg not at site level (or) anp not at site level
if ('anpRef' not in payload
and epg_ref not in epgs) or 'anpRef' in payload:
epgs_in_temp = [
e.get('name') for e in schema_obj['templates'][template_idx]
['anps'][template_anp_idx]['epgs']
]
# If EPG not at template level - Fail
if epg not in epgs_in_temp:
mso.fail_json(
msg=
"Provided EPG '{0}' does not exist. Existing EPGs: {1} epgref {2}"
.format(epg, ', '.join(epgs_in_temp), epg_ref))
# EPG at template level but not at site level. Create payload at site level for EPG
else:
new_epg = dict(epgRef=dict(
schemaId=schema_id,
templateName=template,
anpName=anp,
epgName=epg,
))
# If anp not in payload then, anp already exists at site level. New payload will only have new EPG payload
if 'anpRef' not in payload:
op_path = '/sites/{0}/anps/{1}/epgs/-'.format(
site_template, anp)
payload = new_epg
else:
# If anp in payload, anp exists at site level. Update payload with EPG payload
payload['epgs'] = [new_epg]
# Update index of EPG at site level
else:
epg_idx = epgs.index(epg_ref)
# Get Leaf
# If anp at site level and epg is at site level
if 'anpRef' not in payload and 'epgRef' not in payload:
portpaths = [
p.get('path') for p in schema_obj.get('sites')[site_idx]['anps']
[anp_idx]['epgs'][epg_idx]['staticPorts']
]
if portpath in portpaths:
portpath_idx = portpaths.index(portpath)
port_path = '/sites/{0}/anps/{1}/epgs/{2}/staticPorts/{3}'.format(
site_template, anp, epg, portpath_idx)
mso.existing = schema_obj.get('sites')[site_idx]['anps'][anp_idx][
'epgs'][epg_idx]['staticPorts'][portpath_idx]
if state == 'query':
if leaf is None or vlan is None:
mso.existing = schema_obj.get('sites')[site_idx]['anps'][anp_idx][
'epgs'][epg_idx]['staticPorts']
elif not mso.existing:
mso.fail_json(msg="Static port '{portpath}' not found".format(
portpath=portpath))
mso.exit_json()
ports_path = '/sites/{0}/anps/{1}/epgs/{2}/staticPorts'.format(
site_template, anp, epg)
ops = []
new_leaf = dict(
deploymentImmediacy=deployment_immediacy,
mode=mode,
path=portpath,
portEncapVlan=vlan,
type=path_type,
microSegVlan=primary_micro_segment_vlan,
)
# If payload is empty, anp and EPG already exist at site level
if not payload:
op_path = ports_path + '/-'
payload = new_leaf
# If payload exists
else:
# If anp already exists at site level
if 'anpRef' not in payload:
payload['staticPorts'] = [new_leaf]
else:
payload['epgs'][0]['staticPorts'] = [new_leaf]
mso.previous = mso.existing
if state == 'absent':
if mso.existing:
mso.sent = mso.existing = {}
ops.append(dict(op='remove', path=port_path))
elif state == 'present':
mso.sanitize(payload, collate=True)
if mso.existing:
ops.append(dict(op='replace', path=port_path, value=mso.sent))
else:
ops.append(dict(op='add', path=op_path, value=mso.sent))
mso.existing = new_leaf
if not module.check_mode:
mso.request(schema_path, method='PATCH', data=ops)
mso.exit_json()
def main():
argument_spec = mso_argument_spec()
argument_spec.update(
schema=dict(type='str', required=True),
site=dict(type='str', required=True),
template=dict(type='str', required=True),
anp=dict(type='str', required=True),
epg=dict(type='str', required=True),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
)
argument_spec.update(mso_epg_subnet_spec())
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['subnet']],
['state', 'present', ['subnet']],
],
)
schema = module.params.get('schema')
site = module.params.get('site')
template = module.params.get('template').replace(' ', '')
anp = module.params.get('anp')
epg = module.params.get('epg')
subnet = module.params.get('subnet')
description = module.params.get('description')
scope = module.params.get('scope')
shared = module.params.get('shared')
no_default_gateway = module.params.get('no_default_gateway')
state = module.params.get('state')
mso = MSOModule(module)
# Get schema objects
schema_id, schema_path, schema_obj = mso.query_schema(schema)
# Get site
site_id = mso.lookup_site(site)
# Get site_idx
if 'sites' not in schema_obj:
mso.fail_json(msg="No site associated with template '{0}'. Associate the site with the template using mso_schema_site.".format(template))
sites = [(s.get('siteId'), s.get('templateName')) for s in schema_obj.get('sites')]
if (site_id, template) not in sites:
mso.fail_json(msg="Provided site/template '{0}-{1}' does not exist. Existing sites/templates: {2}".format(site, template, ', '.join(sites)))
# Schema-access uses indexes
site_idx = sites.index((site_id, template))
# Path-based access uses site_id-template
site_template = '{0}-{1}'.format(site_id, template)
# Get ANP
anp_ref = mso.anp_ref(schema_id=schema_id, template=template, anp=anp)
anps = [a.get('anpRef') for a in schema_obj.get('sites')[site_idx]['anps']]
if anp_ref not in anps:
mso.fail_json(msg="Provided anp '{0}' does not exist. Existing anps: {1}".format(anp, ', '.join(anps)))
anp_idx = anps.index(anp_ref)
# Get EPG
epg_ref = mso.epg_ref(schema_id=schema_id, template=template, anp=anp, epg=epg)
epgs = [e.get('epgRef') for e in schema_obj.get('sites')[site_idx]['anps'][anp_idx]['epgs']]
if epg_ref not in epgs:
mso.fail_json(msg="Provided epg '{0}' does not exist. Existing epgs: {1}".format(epg, ', '.join(epgs)))
epg_idx = epgs.index(epg_ref)
# Get Subnet
subnets = [s.get('ip') for s in schema_obj.get('sites')[site_idx]['anps'][anp_idx]['epgs'][epg_idx]['subnets']]
if subnet in subnets:
subnet_idx = subnets.index(subnet)
# FIXME: Changes based on index are DANGEROUS
subnet_path = '/sites/{0}/anps/{1}/epgs/{2}/subnets/{3}'.format(site_template, anp, epg, subnet_idx)
mso.existing = schema_obj.get('sites')[site_idx]['anps'][anp_idx]['epgs'][epg_idx]['subnets'][subnet_idx]
if state == 'query':
if subnet is None:
mso.existing = schema_obj.get('sites')[site_idx]['anps'][anp_idx]['epgs'][epg_idx]['subnets']
elif not mso.existing:
mso.fail_json(msg="Subnet '{subnet}' not found".format(subnet=subnet))
mso.exit_json()
subnets_path = '/sites/{0}/anps/{1}/epgs/{2}/subnets'.format(site_template, anp, epg)
ops = []
mso.previous = mso.existing
if state == 'absent':
if mso.existing:
mso.sent = mso.existing = {}
ops.append(dict(op='remove', path=subnet_path))
elif state == 'present':
if not mso.existing:
if description is None:
description = subnet
if scope is None:
scope = 'private'
if shared is None:
shared = False
if no_default_gateway is None:
no_default_gateway = False
payload = dict(
ip=subnet,
description=description,
scope=scope,
shared=shared,
noDefaultGateway=no_default_gateway,
)
mso.sanitize(payload, collate=True)
if mso.existing:
ops.append(dict(op='replace', path=subnet_path, value=mso.sent))
else:
ops.append(dict(op='add', path=subnets_path + '/-', value=mso.sent))
mso.existing = mso.proposed
if not module.check_mode:
mso.request(schema_path, method='PATCH', data=ops)
mso.exit_json()
def main():
argument_spec = mso_argument_spec()
argument_spec.update(
schema=dict(type='str', required=True),
site=dict(type='str', required=True),
template=dict(type='str', required=True),
anp=dict(type='str', required=True),
epg=dict(type='str', required=True),
domain_association_type=dict(type='str', choices=['vmmDomain', 'l3ExtDomain', 'l2ExtDomain', 'physicalDomain', 'fibreChannelDomain']),
domain_profile=dict(type='str'),
deployment_immediacy=dict(type='str', choices=['immediate', 'lazy']),
resolution_immediacy=dict(type='str', choices=['immediate', 'lazy', 'pre-provision']),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
micro_seg_vlan_type=dict(type='str'),
micro_seg_vlan=dict(type='int'),
port_encap_vlan_type=dict(type='str'),
port_encap_vlan=dict(type='int'),
vlan_encap_mode=dict(type='str', choices=['static', 'dynamic']),
allow_micro_segmentation=dict(type='bool'),
switch_type=dict(type='str'),
switching_mode=dict(type='str'),
enhanced_lagpolicy_name=dict(type='str'),
enhanced_lagpolicy_dn=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['domain_association_type', 'domain_profile', 'deployment_immediacy', 'resolution_immediacy']],
['state', 'present', ['domain_association_type', 'domain_profile', 'deployment_immediacy', 'resolution_immediacy']],
],
)
schema = module.params.get('schema')
site = module.params.get('site')
template = module.params.get('template')
anp = module.params.get('anp')
epg = module.params.get('epg')
domain_association_type = module.params.get('domain_association_type')
domain_profile = module.params.get('domain_profile')
deployment_immediacy = module.params.get('deployment_immediacy')
resolution_immediacy = module.params.get('resolution_immediacy')
state = module.params.get('state')
micro_seg_vlan_type = module.params.get('micro_seg_vlan_type')
micro_seg_vlan = module.params.get('micro_seg_vlan')
port_encap_vlan_type = module.params.get('port_encap_vlan_type')
port_encap_vlan = module.params.get('port_encap_vlan')
vlan_encap_mode = module.params.get('vlan_encap_mode')
allow_micro_segmentation = module.params.get('allow_micro_segmentation')
switch_type = module.params.get('switch_type')
switching_mode = module.params.get('switching_mode')
enhanced_lagpolicy_name = module.params.get('enhanced_lagpolicy_name')
enhanced_lagpolicy_dn = module.params.get('enhanced_lagpolicy_dn')
mso = MSOModule(module)
# Get schema_id
schema_obj = mso.get_obj('schemas', displayName=schema)
if not schema_obj:
mso.fail_json(msg="Provided schema '{0}' does not exist".format(schema))
schema_path = 'schemas/{id}'.format(**schema_obj)
schema_id = schema_obj.get('id')
# Get template
templates = [t.get('name') for t in schema_obj.get('templates')]
if template not in templates:
mso.fail_json(msg="Provided template '{0}' does not exist. Existing templates: {1}".format(template, ', '.join(templates)))
template_idx = templates.index(template)
# Get site
site_id = mso.lookup_site(site)
# Get site_idx
sites = [(s.get('siteId'), s.get('templateName')) for s in schema_obj.get('sites')]
sites_list = [s.get('siteId') + '/' + s.get('templateName') for s in schema_obj.get('sites')]
if (site_id, template) not in sites:
mso.fail_json(msg="Provided site/siteId/template '{0}/{1}/{2}' does not exist. "
"Existing siteIds/templates: {3}".format(site, site_id, template, ', '.join(sites_list)))
# Schema-access uses indexes
site_idx = sites.index((site_id, template))
# Path-based access uses site_id-template
site_template = '{0}-{1}'.format(site_id, template)
payload = dict()
ops = []
op_path = ''
# Get ANP
anp_ref = mso.anp_ref(schema_id=schema_id, template=template, anp=anp)
anps = [a.get('anpRef') for a in schema_obj['sites'][site_idx]['anps']]
anps_path = '/sites/{0}/anps'.format(site_template)
anps_in_temp = [a.get('name') for a in schema_obj['templates'][template_idx]['anps']]
if anp not in anps_in_temp:
mso.fail_json(msg="Provided anp '{0}' does not exist. Existing anps: {1}".format(anp, ', '.join(anps)))
else:
# Update anp index at template level
template_anp_idx = anps_in_temp.index(anp)
# If anp not at site level but exists at template level
if anp_ref not in anps:
op_path = '/sites/{0}/anps/-'.format(site_template)
payload.update(
anpRef=dict(
schemaId=schema_id,
templateName=template,
anpName=anp,
),
)
else:
# Update anp index at site level
anp_idx = anps.index(anp_ref)
# Get EPG
epg_ref = mso.epg_ref(schema_id=schema_id, template=template, anp=anp, epg=epg)
# If anp exists at site level
if 'anpRef' not in payload:
epgs = [e.get('epgRef') for e in schema_obj['sites'][site_idx]['anps'][anp_idx]['epgs']]
epgs_path = '/sites/{0}/anps/{1}/epgs'.format(site_template, anp)
# If anp already at site level AND if epg not at site level (or) anp not at site level?
if ('anpRef' not in payload and epg_ref not in epgs) or 'anpRef' in payload:
epgs_in_temp = [e.get('name') for e in schema_obj['templates'][template_idx]['anps'][template_anp_idx]['epgs']]
# If EPG not at template level - Fail
if epg not in epgs_in_temp:
mso.fail_json(msg="Provided EPG '{0}' does not exist. Existing EPGs: {1} epgref {2}".format(epg, ', '.join(epgs_in_temp), epg_ref))
# EPG at template level but not at site level. Create payload at site level for EPG
else:
new_epg = dict(
epgRef=dict(
schemaId=schema_id,
templateName=template,
anpName=anp,
epgName=epg,
)
)
# If anp not in payload then, anp already exists at site level. New payload will only have new EPG payload
if 'anpRef' not in payload:
op_path = '/sites/{0}/anps/{1}/epgs/-'.format(site_template, anp)
payload = new_epg
else:
# If anp in payload, anp exists at site level. Update payload with EPG payload
payload['epgs'] = [new_epg]
# Update index of EPG at site level
else:
epg_idx = epgs.index(epg_ref)
if domain_association_type == 'vmmDomain':
domain_dn = 'uni/vmmp-VMware/dom-{0}'.format(domain_profile)
elif domain_association_type == 'l3ExtDomain':
domain_dn = 'uni/l3dom-{0}'.format(domain_profile)
elif domain_association_type == 'l2ExtDomain':
domain_dn = 'uni/l2dom-{0}'.format(domain_profile)
elif domain_association_type == 'physicalDomain':
domain_dn = 'uni/phys-{0}'.format(domain_profile)
elif domain_association_type == 'fibreChannelDomain':
domain_dn = 'uni/fc-{0}'.format(domain_profile)
else:
domain_dn = ''
# Get Domains
# If anp at site level and epg is at site level
if 'anpRef' not in payload and 'epgRef' not in payload:
domains = [dom.get('dn') for dom in schema_obj['sites'][site_idx]['anps'][anp_idx]['epgs'][epg_idx]['domainAssociations']]
if domain_dn in domains:
domain_idx = domains.index(domain_dn)
domain_path = '/sites/{0}/anps/{1}/epgs/{2}/domainAssociations/{3}'.format(site_template, anp, epg, domain_idx)
mso.existing = schema_obj['sites'][site_idx]['anps'][anp_idx]['epgs'][epg_idx]['domainAssociations'][domain_idx]
if state == 'query':
if domain_association_type is None or domain_profile is None:
mso.existing = schema_obj.get('sites')[site_idx]['anps'][anp_idx]['epgs'][epg_idx]['domainAssociations']
elif not mso.existing:
mso.fail_json(msg="Domain association '{domain_association_type}/{domain_profile}' not found".format(
domain_association_type=domain_association_type,
domain_profile=domain_profile))
mso.exit_json()
domains_path = '/sites/{0}/anps/{1}/epgs/{2}/domainAssociations'.format(site_template, anp, epg)
ops = []
new_domain = dict(
dn=domain_dn,
domainType=domain_association_type,
deploymentImmediacy=deployment_immediacy,
resolutionImmediacy=resolution_immediacy,
)
if domain_association_type == 'vmmDomain':
vmmDomainProperties = {}
if micro_seg_vlan_type and micro_seg_vlan:
microSegVlan = dict(vlanType=micro_seg_vlan_type, vlan=micro_seg_vlan)
vmmDomainProperties['microSegVlan'] = microSegVlan
elif not micro_seg_vlan_type and micro_seg_vlan:
mso.fail_json(msg="micro_seg_vlan_type is required when micro_seg_vlan is provided.")
elif micro_seg_vlan_type and not micro_seg_vlan:
mso.fail_json(msg="micro_seg_vlan is required when micro_seg_vlan_type is provided.")
if port_encap_vlan_type and port_encap_vlan:
portEncapVlan = dict(vlanType=port_encap_vlan_type, vlan=port_encap_vlan)
vmmDomainProperties['portEncapVlan'] = portEncapVlan
elif not port_encap_vlan_type and port_encap_vlan:
mso.fail_json(msg="port_encap_vlan_type is required when port_encap_vlan is provided.")
elif port_encap_vlan_type and not port_encap_vlan:
mso.fail_json(msg="port_encap_vlan is required when port_encap_vlan_type is provided.")
if vlan_encap_mode:
vmmDomainProperties['vlanEncapMode'] = vlan_encap_mode
if allow_micro_segmentation:
vmmDomainProperties['allowMicroSegmentation'] = allow_micro_segmentation
if switch_type:
vmmDomainProperties['switchType'] = switch_type
if switching_mode:
vmmDomainProperties['switchingMode'] = switching_mode
if enhanced_lagpolicy_name and enhanced_lagpolicy_dn:
enhancedLagPol = dict(name=enhanced_lagpolicy_name, dn=enhanced_lagpolicy_dn)
epgLagPol = dict(enhancedLagPol=enhancedLagPol)
vmmDomainProperties['epgLagPol'] = epgLagPol
elif not enhanced_lagpolicy_name and enhanced_lagpolicy_dn:
mso.fail_json(msg="enhanced_lagpolicy_name is required when enhanced_lagpolicy_dn is provided.")
elif enhanced_lagpolicy_name and not enhanced_lagpolicy_dn:
mso.fail_json(msg="enhanced_lagpolicy_dn is required when enhanced_lagpolicy_name is provided.")
if vmmDomainProperties:
new_domain['vmmDomainProperties'] = vmmDomainProperties
# If payload is empty, anp and EPG already exist at site level
if not payload:
op_path = domains_path + '/-'
payload = new_domain
# If payload exists
else:
# If anp already exists at site level...(AND payload != epg as well?)
if 'anpRef' not in payload:
payload['domainAssociations'] = [new_domain]
else:
payload['epgs'][0]['domainAssociations'] = [new_domain]
mso.previous = mso.existing
if state == 'absent':
if mso.existing:
mso.sent = mso.existing = {}
ops.append(dict(op='remove', path=domain_path))
elif state == 'present':
mso.sanitize(payload, collate=True)
if mso.existing:
ops.append(dict(op='replace', path=domain_path, value=mso.sent))
else:
ops.append(dict(op='add', path=op_path, value=mso.sent))
mso.existing = new_domain
if not module.check_mode:
mso.request(schema_path, method='PATCH', data=ops)
mso.exit_json()
def main():
argument_spec = mso_argument_spec()
argument_spec.update(
schema=dict(type='str', required=True),
site=dict(type='str', required=True),
template=dict(type='str', required=True),
anp=dict(type='str', required=True),
epg=dict(type='str', required=True),
type=dict(type='str', default='port', choices=['port']),
pod=dict(type='str'
), # This parameter is not required for querying all objects
leaf=dict(type='str'
), # This parameter is not required for querying all objects
fex=dict(type='str'
), # This parameter is not required for querying all objects
path=dict(type='str'
), # This parameter is not required for querying all objects
vlan=dict(type='int'
), # This parameter is not required for querying all objects
deployment_immediacy=dict(type='str', choices=['immediate', 'lazy']),
mode=dict(type='str', choices=['native', 'regular', 'untagged']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['type', 'pod', 'leaf', 'path', 'vlan']],
['state', 'present', ['type', 'pod', 'leaf', 'path', 'vlan']],
],
)
schema = module.params['schema']
site = module.params['site']
template = module.params['template']
anp = module.params['anp']
epg = module.params['epg']
path_type = module.params['type']
pod = module.params['pod']
leaf = module.params['leaf']
fex = module.params['fex']
path = module.params['path']
vlan = module.params['vlan']
deployment_immediacy = module.params['deployment_immediacy']
mode = module.params['mode']
state = module.params['state']
if path_type == 'port' and fex is not None:
# Select port path for fex if fex param is used
portpath = 'topology/{0}/paths-{1}/extpaths-{2}/pathep-[{3}]'.format(
pod, leaf, fex, path)
else:
portpath = 'topology/{0}/paths-{1}/pathep-[{2}]'.format(
pod, leaf, path)
mso = MSOModule(module)
# Get schema_id
schema_obj = mso.get_obj('schemas', displayName=schema)
if not schema_obj:
mso.fail_json(
msg="Provided schema '{0}' does not exist".format(schema))
schema_path = 'schemas/{id}'.format(**schema_obj)
schema_id = schema_obj['id']
# Get site
site_id = mso.lookup_site(site)
# Get site_idx
sites = [(s['siteId'], s['templateName']) for s in schema_obj['sites']]
if (site_id, template) not in sites:
mso.fail_json(
msg=
"Provided site/template '{0}-{1}' does not exist. Existing sites/templates: {2}"
.format(site, template, ', '.join(sites)))
# Schema-access uses indexes
site_idx = sites.index((site_id, template))
# Path-based access uses site_id-template
site_template = '{0}-{1}'.format(site_id, template)
# Get ANP
anp_ref = mso.anp_ref(schema_id=schema_id, template=template, anp=anp)
anps = [a['anpRef'] for a in schema_obj['sites'][site_idx]['anps']]
if anp_ref not in anps:
mso.fail_json(
msg="Provided anp '{0}' does not exist. Existing anps: {1}".format(
anp, ', '.join(anps)))
anp_idx = anps.index(anp_ref)
# Get EPG
epg_ref = mso.epg_ref(schema_id=schema_id,
template=template,
anp=anp,
epg=epg)
epgs = [
e['epgRef']
for e in schema_obj['sites'][site_idx]['anps'][anp_idx]['epgs']
]
if epg_ref not in epgs:
mso.fail_json(
msg="Provided epg '{0}' does not exist. Existing epgs: {1}".format(
epg, ', '.join(epgs)))
epg_idx = epgs.index(epg_ref)
# Get Leaf
portpaths = [
p['path'] for p in schema_obj['sites'][site_idx]['anps'][anp_idx]
['epgs'][epg_idx]['staticPorts']
]
if portpath in portpaths:
portpath_idx = portpaths.index(portpath)
# FIXME: Changes based on index are DANGEROUS
port_path = '/sites/{0}/anps/{1}/epgs/{2}/staticPorts/{3}'.format(
site_template, anp, epg, portpath_idx)
mso.existing = schema_obj['sites'][site_idx]['anps'][anp_idx]['epgs'][
epg_idx]['staticPorts'][portpath_idx]
if state == 'query':
if leaf is None or vlan is None:
mso.existing = schema_obj['sites'][site_idx]['anps'][anp_idx][
'epgs'][epg_idx]['staticPorts']
elif not mso.existing:
mso.fail_json(msg="Static port '{portpath}' not found".format(
portpath=portpath))
mso.exit_json()
ports_path = '/sites/{0}/anps/{1}/epgs/{2}/staticPorts'.format(
site_template, anp, epg)
ops = []
mso.previous = mso.existing
if state == 'absent':
if mso.existing:
mso.sent = mso.existing = {}
ops.append(dict(op='remove', path=port_path))
elif state == 'present':
if not mso.existing:
if deployment_immediacy is None:
deployment_immediacy = 'lazy'
if mode is None:
mode = 'untagged'
payload = dict(
deploymentImmediacy=deployment_immediacy,
mode=mode,
path=portpath,
portEncapVlan=vlan,
type=path_type,
)
mso.sanitize(payload, collate=True)
if mso.existing:
ops.append(dict(op='replace', path=port_path, value=mso.sent))
else:
ops.append(dict(op='add', path=ports_path + '/-', value=mso.sent))
mso.existing = mso.proposed
if not module.check_mode:
mso.request(schema_path, method='PATCH', data=ops)
mso.exit_json()
def main():
argument_spec = mso_argument_spec()
argument_spec.update(
schema=dict(type='str', required=True),
site=dict(type='str', required=True),
template=dict(type='str', required=True),
anp=dict(type='str', required=True),
epg=dict(type='str', aliases=[
'name'
]), # This parameter is 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', ['epg']],
['state', 'present', ['epg']],
],
)
schema = module.params.get('schema')
site = module.params.get('site')
template = module.params.get('template').replace(' ', '')
anp = module.params.get('anp')
epg = module.params.get('epg')
state = module.params.get('state')
mso = MSOModule(module)
# Get schema objects
schema_id, schema_path, schema_obj = mso.query_schema(schema)
# Get site
site_id = mso.lookup_site(site)
if 'sites' not in schema_obj:
mso.fail_json(
msg=
"No site associated with template '{0}'. Associate the site with the template using mso_schema_site."
.format(template))
sites = [(s.get('siteId'), s.get('templateName'))
for s in schema_obj.get('sites')]
if (site_id, template) not in sites:
mso.fail_json(
msg=
"Provided site/template '{0}-{1}' does not exist. Existing sites/templates: {2}"
.format(site, template, ', '.join(sites)))
# Schema-access uses indexes
site_idx = sites.index((site_id, template))
# Path-based access uses site_id-template
site_template = '{0}-{1}'.format(site_id, template)
# Get ANP
anp_ref = mso.anp_ref(schema_id=schema_id, template=template, anp=anp)
anps = [a.get('anpRef') for a in schema_obj.get('sites')[site_idx]['anps']]
if anp_ref not in anps:
mso.fail_json(
msg="Provided anp '{0}' does not exist. Existing anps: {1}".format(
anp, ', '.join(anps)))
anp_idx = anps.index(anp_ref)
# Get EPG
epg_ref = mso.epg_ref(schema_id=schema_id,
template=template,
anp=anp,
epg=epg)
epgs = [
e.get('epgRef')
for e in schema_obj.get('sites')[site_idx]['anps'][anp_idx]['epgs']
]
if epg is not None and epg_ref in epgs:
epg_idx = epgs.index(epg_ref)
epg_path = '/sites/{0}/anps/{1}/epgs/{2}'.format(
site_template, anp, epg)
mso.existing = schema_obj.get(
'sites')[site_idx]['anps'][anp_idx]['epgs'][epg_idx]
if state == 'query':
if epg is None:
mso.existing = schema_obj.get(
'sites')[site_idx]['anps'][anp_idx]['epgs']
elif not mso.existing:
mso.fail_json(msg="EPG '{epg}' not found".format(epg=epg))
mso.exit_json()
epgs_path = '/sites/{0}/anps/{1}/epgs'.format(site_template, anp)
ops = []
mso.previous = mso.existing
if state == 'absent':
if mso.existing:
mso.sent = mso.existing = {}
ops.append(dict(op='remove', path=epg_path))
elif state == 'present':
payload = dict(epgRef=dict(
schemaId=schema_id,
templateName=template,
anpName=anp,
epgName=epg,
), )
mso.sanitize(payload, collate=True)
if not mso.existing:
ops.append(dict(op='add', path=epgs_path + '/-', value=mso.sent))
mso.existing = mso.proposed
if not module.check_mode:
mso.request(schema_path, method='PATCH', data=ops)
mso.exit_json()
def main():
argument_spec = mso_argument_spec()
argument_spec.update(
schema=dict(type='str', required=True),
site=dict(type='str', required=True),
template=dict(type='str', required=True),
anp=dict(type='str', required=True),
epg=dict(type='str', required=True),
selector=dict(type='str'),
expressions=dict(type='list',
elements='dict',
options=mso_expression_spec()),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['selector']],
['state', 'present', ['selector']],
],
)
schema = module.params.get('schema')
site = module.params.get('site')
template = module.params.get('template').replace(' ', '')
anp = module.params.get('anp')
epg = module.params.get('epg')
selector = module.params.get('selector')
expressions = module.params.get('expressions')
state = module.params.get('state')
mso = MSOModule(module)
# Get schema objects
schema_id, schema_path, schema_obj = mso.query_schema(schema)
# Get template
templates = [t.get('name') for t in schema_obj.get('templates')]
if template not in templates:
mso.fail_json(
msg="Provided template '{0}' does not exist. Existing templates: {1}"
.format(template, ', '.join(templates)))
template_idx = templates.index(template)
# Get site
site_id = mso.lookup_site(site)
# Get cloud type
site_type = mso.get_obj('sites', name=site).get("cloudProviders")[0]
# Get site_idx
if 'sites' not in schema_obj:
mso.fail_json(
msg=
"No site associated with template '{0}'. Associate the site with the template using mso_schema_site."
.format(template))
sites = [(s.get('siteId'), s.get('templateName'))
for s in schema_obj.get('sites')]
if (site_id, template) not in sites:
mso.fail_json(
msg="Provided site-template association '{0}-{1}' does not exist.".
format(site, template))
# Schema-access uses indexes
site_idx = sites.index((site_id, template))
# Path-based access uses site_id-template
site_template = '{0}-{1}'.format(site_id, template)
payload = dict()
ops = []
op_path = ''
# Get ANP
anp_ref = mso.anp_ref(schema_id=schema_id, template=template, anp=anp)
anps = [a.get('anpRef') for a in schema_obj['sites'][site_idx]['anps']]
anps_in_temp = [
a.get('name') for a in schema_obj['templates'][template_idx]['anps']
]
if anp not in anps_in_temp:
mso.fail_json(
msg="Provided anp '{0}' does not exist. Existing anps: {1}".format(
anp, ', '.join(anps_in_temp)))
else:
# Get anp index at template level
template_anp_idx = anps_in_temp.index(anp)
# If anp not at site level but exists at template level
if anp_ref not in anps:
op_path = '/sites/{0}/anps/-'.format(site_template)
payload.update(anpRef=dict(
schemaId=schema_id,
templateName=template,
anpName=anp,
), )
else:
# Get anp index at site level
anp_idx = anps.index(anp_ref)
# Get EPG
epg_ref = mso.epg_ref(schema_id=schema_id,
template=template,
anp=anp,
epg=epg)
# If anp exists at site level
if 'anpRef' not in payload:
epgs = [
e.get('epgRef')
for e in schema_obj['sites'][site_idx]['anps'][anp_idx]['epgs']
]
# If anp already at site level AND if epg not at site level (or) anp not at site level?
if ('anpRef' not in payload
and epg_ref not in epgs) or 'anpRef' in payload:
epgs_in_temp = [
e.get('name') for e in schema_obj['templates'][template_idx]
['anps'][template_anp_idx]['epgs']
]
# If EPG not at template level - Fail
if epg not in epgs_in_temp:
mso.fail_json(
msg="Provided EPG '{0}' does not exist. Existing EPGs: {1}".
format(epg, ', '.join(epgs_in_temp)))
# EPG at template level but not at site level. Create payload at site level for EPG
else:
new_epg = dict(epgRef=dict(
schemaId=schema_id,
templateName=template,
anpName=anp,
epgName=epg,
))
# If anp not in payload then, anp already exists at site level. New payload will only have new EPG payload
if 'anpRef' not in payload:
op_path = '/sites/{0}/anps/{1}/epgs/-'.format(
site_template, anp)
payload = new_epg
else:
# If anp in payload, anp exists at site level. Update payload with EPG payload
payload['epgs'] = [new_epg]
# Get index of EPG at site level
else:
epg_idx = epgs.index(epg_ref)
# Get selectors
# If anp at site level and epg is at site level
if 'anpRef' not in payload and 'epgRef' not in payload:
if selector and " " in selector:
mso.fail_json(
msg="There should not be any space in selector name.")
selectors = [
s.get('name') for s in schema_obj.get('sites')[site_idx]['anps']
[anp_idx]['epgs'][epg_idx]['selectors']
]
if selector in selectors:
selector_idx = selectors.index(selector)
selector_path = '/sites/{0}/anps/{1}/epgs/{2}/selectors/{3}'.format(
site_template, anp, epg, selector_idx)
mso.existing = schema_obj['sites'][site_idx]['anps'][anp_idx][
'epgs'][epg_idx]['selectors'][selector_idx]
if state == 'query':
if 'anpRef' in payload:
mso.fail_json(
msg="Anp '{anp}' does not exist in site level.".format(
anp=anp))
if 'epgRef' in payload:
mso.fail_json(
msg="Epg '{epg}' does not exist in site level.".format(
epg=epg))
if selector is None:
mso.existing = schema_obj['sites'][site_idx]['anps'][anp_idx][
'epgs'][epg_idx]['selectors']
elif not mso.existing:
mso.fail_json(msg="Selector '{selector}' not found".format(
selector=selector))
mso.exit_json()
mso.previous = mso.existing
if state == 'absent':
if mso.existing:
mso.sent = mso.existing = {}
ops.append(dict(op='remove', path=selector_path))
elif state == 'present':
# Get expressions
all_expressions = []
if expressions:
for expression in expressions:
type = expression.get('type')
operator = expression.get('operator')
value = expression.get('value')
if " " in type:
mso.fail_json(
msg=
"There should not be any space in 'type' attribute of expression '{0}'"
.format(type))
if operator in ["has_key", "does_not_have_key"] and value:
mso.fail_json(
msg=
"Attribute 'value' is not supported for operator '{0}' in expression '{1}'"
.format(operator, type))
if operator in ["not_in", "in", "equals", "not_equals"
] and not value:
mso.fail_json(
msg=
"Attribute 'value' needed for operator '{0}' in expression '{1}'"
.format(operator, type))
if type in ["region", "zone", "ip_address"]:
if type == "zone" and site_type != "aws":
mso.fail_json(
msg="Type 'zone' is only supported for aws")
if operator in ["has_key", "does_not_have_key"]:
mso.fail_json(
msg=
"Operator '{0}' is not supported when expression type is '{1}'"
.format(operator, type))
type = EXPRESSION_KEYS.get(type)
else:
type = 'Custom:' + type
all_expressions.append(
dict(
key=type,
operator=EXPRESSION_OPERATORS.get(operator),
value=value,
))
new_selector = dict(
name=selector,
expressions=all_expressions,
)
selectors_path = '/sites/{0}/anps/{1}/epgs/{2}/selectors/-'.format(
site_template, anp, epg)
# if payload is empty, anp and epg already exist at site level
if not payload:
op_path = selectors_path
payload = new_selector
# if payload exist
else:
# if anp already exists at site level
if 'anpRef' not in payload:
payload['selectors'] = [new_selector]
else:
payload['epgs'][0]['selectors'] = [new_selector]
mso.sanitize(payload, collate=True)
if mso.existing:
ops.append(dict(op='replace', path=selector_path, value=mso.sent))
else:
ops.append(dict(op='add', path=op_path, value=mso.sent))
mso.existing = new_selector
if not module.check_mode and mso.existing != mso.previous:
mso.request(schema_path, method='PATCH', data=ops)
mso.exit_json()
def main():
argument_spec = mso_argument_spec()
argument_spec.update(
schema=dict(type='str', required=True),
site=dict(type='str', required=True),
template=dict(type='str', required=True),
anp=dict(type='str', required=True),
epg=dict(type='str', required=True),
domain_association_type=dict(type='str',
choices=[
'vmmDomain', 'l3ExtDomain',
'l2ExtDomain', 'physicalDomain',
'fibreChannel'
]),
domain_profile=dict(type='str'),
deployment_immediacy=dict(type='str', choices=['immediate', 'lazy']),
resolution_immediacy=dict(
type='str', choices=['immediate', 'lazy', 'pre-provision']),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'query']),
micro_seg_vlan_type=dict(type='str'),
micro_seg_vlan=dict(type='int'),
port_encap_vlan_type=dict(type='str'),
port_encap_vlan=dict(type='int'),
vlan_encap_mode=dict(type='str', choices=['static', 'dynamic']),
allow_micro_segmentation=dict(type='bool'),
switch_type=dict(type='str'),
switching_mode=dict(type='str'),
enhanced_lagpolicy_name=dict(type='str'),
enhanced_lagpolicy_dn=dict(type='str'),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
[
'state', 'absent',
[
'domain_association_type', 'domain_profile',
'deployment_immediacy', 'resolution_immediacy'
]
],
[
'state', 'present',
[
'domain_association_type', 'domain_profile',
'deployment_immediacy', 'resolution_immediacy'
]
],
],
)
schema = module.params['schema']
site = module.params['site']
template = module.params['template']
anp = module.params['anp']
epg = module.params['epg']
domain_association_type = module.params['domain_association_type']
domain_profile = module.params['domain_profile']
deployment_immediacy = module.params['deployment_immediacy']
resolution_immediacy = module.params['resolution_immediacy']
state = module.params['state']
micro_seg_vlan_type = module.params['micro_seg_vlan_type']
micro_seg_vlan = module.params['micro_seg_vlan']
port_encap_vlan_type = module.params['port_encap_vlan_type']
port_encap_vlan = module.params['port_encap_vlan']
vlan_encap_mode = module.params['vlan_encap_mode']
allow_micro_segmentation = module.params['allow_micro_segmentation']
switch_type = module.params['switch_type']
switching_mode = module.params['switching_mode']
enhanced_lagpolicy_name = module.params['enhanced_lagpolicy_name']
enhanced_lagpolicy_dn = module.params['enhanced_lagpolicy_dn']
mso = MSOModule(module)
# Get schema_id
schema_obj = mso.get_obj('schemas', displayName=schema)
if not schema_obj:
mso.fail_json(
msg="Provided schema '{0}' does not exist".format(schema))
schema_path = 'schemas/{id}'.format(**schema_obj)
schema_id = schema_obj['id']
# Get site
site_id = mso.lookup_site(site)
# Get site_idx
sites = [(s['siteId'], s['templateName']) for s in schema_obj['sites']]
if (site_id, template) not in sites:
mso.fail_json(
msg=
"Provided site/template '{0}-{1}' does not exist. Existing sites/templates: {2}"
.format(site, template, ', '.join(sites)))
# Schema-access uses indexes
site_idx = sites.index((site_id, template))
# Path-based access uses site_id-template
site_template = '{0}-{1}'.format(site_id, template)
# Get ANP
anp_ref = mso.anp_ref(schema_id=schema_id, template=template, anp=anp)
anps = [a['anpRef'] for a in schema_obj['sites'][site_idx]['anps']]
if anp_ref not in anps:
mso.fail_json(
msg="Provided anp '{0}' does not exist. Existing anps: {1}".format(
anp, ', '.join(anps)))
anp_idx = anps.index(anp_ref)
# Get EPG
epg_ref = mso.epg_ref(schema_id=schema_id,
template=template,
anp=anp,
epg=epg)
print(epg_ref)
epgs = [
e['epgRef']
for e in schema_obj['sites'][site_idx]['anps'][anp_idx]['epgs']
]
if epg_ref not in epgs:
mso.fail_json(
msg=
"Provided epg '{0}' does not exist. Existing epgs: {1} epgref {2}".
format(epg, str(schema_obj['sites'][site_idx]), epg_ref))
epg_idx = epgs.index(epg_ref)
if domain_association_type == 'vmmDomain':
domain_dn = 'uni/vmmp-VMware/dom-{0}'.format(domain_profile)
elif domain_association_type == 'l3ExtDomain':
domain_dn = 'uni/l3dom-{0}'.format(domain_profile)
elif domain_association_type == 'l2ExtDomain':
domain_dn = 'uni/l2dom-{0}'.format(domain_profile)
elif domain_association_type == 'physicalDomain':
domain_dn = 'uni/phys-{0}'.format(domain_profile)
elif domain_association_type == 'fibreChannel':
domain_dn = 'uni/fc-{0}'.format(domain_profile)
else:
domain_dn = ''
# Get Domains
domains = [
dom['dn'] for dom in schema_obj['sites'][site_idx]['anps'][anp_idx]
['epgs'][epg_idx]['domainAssociations']
]
if domain_dn in domains:
domain_idx = domains.index(domain_dn)
domain_path = '/sites/{0}/anps/{1}/epgs/{2}/domainAssociations/{3}'.format(
site_template, anp, epg, domain_idx)
mso.existing = schema_obj['sites'][site_idx]['anps'][anp_idx]['epgs'][
epg_idx]['domainAssociations'][domain_idx]
if state == 'query':
if domain_association_type is None or domain_profile is None:
mso.existing = schema_obj['sites'][site_idx]['anps'][anp_idx][
'epgs'][epg_idx]['domainAssociations']
elif not mso.existing:
mso.fail_json(
msg=
"Domain association '{domain_association_type}/{domain_profile}' not found"
.format(domain_association_type=domain_association_type,
domain_profile=domain_profile))
mso.exit_json()
domains_path = '/sites/{0}/anps/{1}/epgs/{2}/domainAssociations'.format(
site_template, anp, epg)
ops = []
if domain_association_type == 'vmmDomain':
vmmDomainProperties = {}
if micro_seg_vlan_type and micro_seg_vlan:
microSegVlan = dict(vlanType=micro_seg_vlan_type,
vlan=micro_seg_vlan)
vmmDomainProperties['microSegVlan'] = microSegVlan
elif not micro_seg_vlan_type and micro_seg_vlan:
mso.fail_json(
msg=
"micro_seg_vlan_type is required when micro_seg_vlan is provided."
)
elif micro_seg_vlan_type and not micro_seg_vlan:
mso.fail_json(
msg=
"micro_seg_vlan is required when micro_seg_vlan_type is provided."
)
if micro_seg_vlan_type and micro_seg_vlan:
portEncapVlan = dict(vlanType=port_encap_vlan_type,
vlan=port_encap_vlan)
vmmDomainProperties['portEncapVlan'] = portEncapVlan
elif not port_encap_vlan_type and port_encap_vlan:
mso.fail_json(
msg=
"port_encap_vlan_type is required when port_encap_vlan is provided."
)
elif port_encap_vlan_type and not port_encap_vlan:
mso.fail_json(
msg=
"port_encap_vlan is required when port_encap_vlan_type is provided."
)
if vlan_encap_mode:
vmmDomainProperties['vlanEncapMode'] = vlan_encap_mode
if allow_micro_segmentation:
vmmDomainProperties[
'allowMicroSegmentation'] = allow_micro_segmentation
if switch_type:
vmmDomainProperties['switchType'] = switch_type
if switching_mode:
vmmDomainProperties['switchingMode'] = switching_mode
if enhanced_lagpolicy_name and enhanced_lagpolicy_dn:
enhancedLagPol = dict(name=enhanced_lagpolicy_name,
dn=enhanced_lagpolicy_dn)
epgLagPol = dict(enhancedLagPol=enhancedLagPol)
vmmDomainProperties['epgLagPol'] = epgLagPol
elif not enhanced_lagpolicy_name and enhanced_lagpolicy_dn:
mso.fail_json(
msg=
"enhanced_lagpolicy_name is required when enhanced_lagpolicy_dn is provided."
)
elif enhanced_lagpolicy_name and not enhanced_lagpolicy_dn:
mso.fail_json(
msg=
"enhanced_lagpolicy_dn is required when enhanced_lagpolicy_name is provided."
)
payload = dict(
dn=domain_dn,
domainType=domain_association_type,
deploymentImmediacy=deployment_immediacy,
resolutionImmediacy=resolution_immediacy,
)
if vmmDomainProperties:
payload['vmmDomainProperties'] = vmmDomainProperties
else:
payload = dict(
dn=domain_dn,
domainType=domain_association_type,
deploymentImmediacy=deployment_immediacy,
resolutionImmediacy=resolution_immediacy,
)
mso.previous = mso.existing
if state == 'absent':
if mso.existing:
mso.sent = mso.existing = {}
ops.append(dict(op='remove', path=domains_path))
elif state == 'present':
mso.sanitize(payload, collate=True)
if mso.existing:
ops.append(dict(op='replace', path=domain_path, value=mso.sent))
else:
ops.append(dict(op='add', path=domains_path + '/-',
value=mso.sent))
mso.existing = mso.proposed
if not module.check_mode:
mso.request(schema_path, method='PATCH', data=ops)
mso.exit_json()
def main():
argument_spec = mso_argument_spec()
argument_spec.update(
schema=dict(type='str', required=True),
site=dict(type='str', required=True),
template=dict(type='str', required=True),
anp=dict(type='str', required=True),
epg=dict(type='str', required=True),
pod=dict(type='str'
), # This parameter is not required for querying all objects
leaf=dict(type='str', aliases=['name']),
vlan=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', 'absent', ['pod', 'leaf', 'vlan']],
['state', 'present', ['pod', 'leaf', 'vlan']],
],
)
schema = module.params.get('schema')
site = module.params.get('site')
template = module.params.get('template')
anp = module.params.get('anp')
epg = module.params.get('epg')
pod = module.params.get('pod')
leaf = module.params.get('leaf')
vlan = module.params.get('vlan')
state = module.params.get('state')
leafpath = 'topology/{0}/node-{1}'.format(pod, leaf)
mso = MSOModule(module)
# Get schema_id
schema_obj = mso.get_obj('schemas', displayName=schema)
if not schema_obj:
mso.fail_json(
msg="Provided schema '{0}' does not exist".format(schema))
schema_path = 'schemas/{id}'.format(**schema_obj)
schema_id = schema_obj.get('id')
# Get site
site_id = mso.lookup_site(site)
# Get site_idx
sites = [(s.get('siteId'), s.get('templateName'))
for s in schema_obj.get('sites')]
if (site_id, template) not in sites:
mso.fail_json(
msg=
"Provided site/template '{0}-{1}' does not exist. Existing sites/templates: {2}"
.format(site, template, ', '.join(sites)))
# Schema-access uses indexes
site_idx = sites.index((site_id, template))
# Path-based access uses site_id-template
site_template = '{0}-{1}'.format(site_id, template)
# Get ANP
anp_ref = mso.anp_ref(schema_id=schema_id, template=template, anp=anp)
anps = [a.get('anpRef') for a in schema_obj.get('sites')[site_idx]['anps']]
if anp_ref not in anps:
mso.fail_json(
msg="Provided anp '{0}' does not exist. Existing anps: {1}".format(
anp, ', '.join(anps)))
anp_idx = anps.index(anp_ref)
# Get EPG
epg_ref = mso.epg_ref(schema_id=schema_id,
template=template,
anp=anp,
epg=epg)
epgs = [
e.get('epgRef')
for e in schema_obj.get('sites')[site_idx]['anps'][anp_idx]['epgs']
]
if epg_ref not in epgs:
mso.fail_json(
msg="Provided epg '{0}' does not exist. Existing epgs: {1}".format(
epg, ', '.join(epgs)))
epg_idx = epgs.index(epg_ref)
# Get Leaf
leafs = [(l.get('path'), l.get('portEncapVlan')) for l in schema_obj.get(
'sites')[site_idx]['anps'][anp_idx]['epgs'][epg_idx]['staticLeafs']]
if (leafpath, vlan) in leafs:
leaf_idx = leafs.index((leafpath, vlan))
# FIXME: Changes based on index are DANGEROUS
leaf_path = '/sites/{0}/anps/{1}/epgs/{2}/staticLeafs/{3}'.format(
site_template, anp, epg, leaf_idx)
mso.existing = schema_obj.get('sites')[site_idx]['anps'][anp_idx][
'epgs'][epg_idx]['staticLeafs'][leaf_idx]
if state == 'query':
if leaf is None or vlan is None:
mso.existing = schema_obj.get('sites')[site_idx]['anps'][anp_idx][
'epgs'][epg_idx]['staticLeafs']
elif not mso.existing:
mso.fail_json(msg="Static leaf '{leaf}/{vlan}' not found".format(
leaf=leaf, vlan=vlan))
mso.exit_json()
leafs_path = '/sites/{0}/anps/{1}/epgs/{2}/staticLeafs'.format(
site_template, anp, epg)
ops = []
mso.previous = mso.existing
if state == 'absent':
if mso.existing:
mso.sent = mso.existing = {}
ops.append(dict(op='remove', path=leaf_path))
elif state == 'present':
payload = dict(
path=leafpath,
portEncapVlan=vlan,
)
mso.sanitize(payload, collate=True)
if mso.existing:
ops.append(dict(op='replace', path=leaf_path, value=mso.sent))
else:
ops.append(dict(op='add', path=leafs_path + '/-', value=mso.sent))
mso.existing = mso.proposed
if not module.check_mode:
mso.request(schema_path, method='PATCH', data=ops)
mso.exit_json()
