def main(): argument_spec = mso_argument_spec() argument_spec.update( tenant=dict(type='str', aliases=['name'], required=True), site=dict(type='str', aliases=['name']), cloud_account=dict(type='str'), security_domains=dict(type='list', elements='str', default=[]), aws_trusted=dict(type='bool'), azure_access_type=dict(type='str', default='shared', choices=['managed', 'unmanaged', 'shared']), azure_active_directory_id=dict(type='str'), aws_access_key=dict(type='str'), aws_account_org=dict(type='bool', default='false'), azure_active_directory_name=dict(type='str'), azure_subscription_id=dict(type='str'), azure_application_id=dict(type='str'), azure_credential_name=dict(type='str'), secret_key=dict(type='str'), state=dict(type='str', default='present', choices=['absent', 'present', 'query']), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ['state', 'absent', ['tenant', 'site']], ['state', 'present', ['tenant', 'site']], ], ) state = module.params.get('state') security_domains = module.params.get('security_domains') cloud_account = module.params.get('cloud_account') azure_access_type = module.params.get('azure_access_type') azure_credential_name = module.params.get('azure_credential_name') azure_application_id = module.params.get('azure_application_id') azure_active_directory_id = module.params.get('azure_active_directory_id') azure_active_directory_name = module.params.get('azure_active_directory_name') azure_subscription_id = module.params.get('azure_subscription_id') secret_key = module.params.get('secret_key') aws_account_org = module.params.get('aws_account_org') aws_access_key = module.params.get('aws_access_key') aws_trusted = module.params.get('aws_trusted') mso = MSOModule(module) # Get tenant_id and site_id tenant_id = mso.lookup_tenant(module.params.get('tenant')) site_id = mso.lookup_site(module.params.get('site')) tenants = [(t.get('id')) for t in mso.query_objs('tenants')] tenant_idx = tenants.index((tenant_id)) # set tenent and port paths tenant_path = 'tenants/{0}'.format(tenant_id) ops = [] ports_path = '/siteAssociations/-' port_path = '/siteAssociations/{0}'.format(site_id) payload = dict( siteId=site_id, securityDomains=security_domains, cloudAccount=cloud_account, ) if cloud_account: if 'azure' in cloud_account: azure_account = dict( accessType=azure_access_type, securityDomains=security_domains, vendor='azure', ) payload['azureAccount'] = [azure_account] cloudSubscription = dict( cloudSubscriptionId=azure_subscription_id, cloudApplicationId=azure_application_id, ) payload['azureAccount'][0]['cloudSubscription'] = cloudSubscription if azure_access_type == 'shared': payload['azureAccount'] = [] if azure_access_type == 'managed': if not azure_subscription_id: mso.fail_json(msg="azure_susbscription_id is required when in managed mode.") if not azure_application_id: mso.fail_json(msg="azure_application_id is required when in managed mode.") payload['azureAccount'][0]['cloudApplication'] = [] payload['azureAccount'][0]['cloudActiveDirectory'] = [] if azure_access_type == 'unmanaged': if not azure_subscription_id: mso.fail_json(msg="azure_subscription_id is required when in unmanaged mode.") if not azure_application_id: mso.fail_json(msg="azure_application_id is required when in unmanaged mode.") if not secret_key: mso.fail_json(msg="secret_key is required when in unmanaged mode.") if not azure_active_directory_id: mso.fail_json(msg="azure_active_directory_id is required when in unmanaged mode.") if not azure_active_directory_name: mso.fail_json(msg="azure_active_directory_name is required when in unmanaged mode.") if not azure_credential_name: mso.fail_json(msg="azure_credential_name is required when in unmanaged mode.") azure_account.update( accessType='credentials', ) cloudApplication = dict( cloudApplicationId=azure_application_id, cloudCredentialName=azure_credential_name, secretKey=secret_key, cloudActiveDirectoryId=azure_active_directory_id ) cloudActiveDirectory = dict( cloudActiveDirectoryId=azure_active_directory_id, cloudActiveDirectoryName=azure_active_directory_name ) payload['azureAccount'][0]['cloudApplication'] = [cloudApplication] payload['azureAccount'][0]['cloudActiveDirectory'] = [cloudActiveDirectory] else: aws_account = dict( accountId=cloud_account, isTrusted=aws_trusted, accessKeyId=aws_access_key, secretKey=secret_key, isAccountInOrg=aws_account_org, ) if not aws_trusted: if not aws_access_key: mso.fail_json(msg="aws_access_key is a required field in untrusted mode.") if not secret_key: mso.fail_json(msg="secret_key is a required field in untrusted mode.") payload['awsAccount'] = [aws_account] sites = [(s.get('siteId')) for s in mso.query_objs('tenants')[tenant_idx]['siteAssociations']] if site_id in sites: site_idx = sites.index((site_id)) mso.existing = mso.query_objs('tenants')[tenant_idx]['siteAssociations'][site_idx] if state == 'query': if len(sites) == 0: mso.fail_json(msg="No site associated with tenant Id {0}".format(tenant_id)) elif site_id not in sites and site_id is not None: mso.fail_json(msg="Site Id {0} not associated with tenant Id {1}".format(site_id, tenant_id)) elif site_id is None: mso.existing = mso.query_objs('tenants')[tenant_idx]['siteAssociations'] mso.exit_json() mso.previous = mso.existing if state == 'absent': if mso.existing: mso.sent = mso.existing = {} ops.append(dict(op='remove', path=port_path)) if 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=ports_path, value=mso.sent)) mso.existing = mso.proposed if not module.check_mode and mso.proposed != mso.previous: mso.request(tenant_path, method='PATCH', data=ops) mso.exit_json()
def main(): argument_spec = mso_argument_spec() argument_spec.update( tenant=dict(type='str', required=True), schema=dict(type='str', required=True), template=dict(type='str', aliases=['name']), display_name=dict(type='str'), state=dict(type='str', default='present', choices=['absent', 'present', 'query']), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ['state', 'absent', ['template']], ['state', 'present', ['template']], ], ) tenant = module.params['tenant'] schema = module.params['schema'] template = module.params['template'] display_name = module.params['display_name'] state = module.params['state'] mso = MSOModule(module) # Get schema schema_obj = mso.get_obj('schemas', displayName=schema) mso.existing = {} if schema_obj: # Schema exists schema_path = 'schemas/{id}'.format(**schema_obj) # Get template templates = [t['name'] for t in schema_obj['templates']] if template: if template in templates: template_idx = templates.index(template) mso.existing = schema_obj['templates'][template_idx] else: mso.existing = schema_obj['templates'] else: schema_path = 'schemas' if state == 'query': if not mso.existing: if template: mso.fail_json(msg="Template '{0}' not found".format(template)) else: mso.existing = [] mso.exit_json() template_path = '/templates/{0}'.format(template) ops = [] mso.previous = mso.existing if state == 'absent': mso.proposed = mso.sent = {} if not schema_obj: # There was no schema to begin with pass elif len(templates) == 1: # There is only one tenant, remove schema mso.existing = {} if not module.check_mode: mso.request(schema_path, method='DELETE') elif mso.existing: # Remove existing template mso.existing = {} ops.append(dict(op='remove', path=template_path)) else: # There was no template to begin with pass elif state == 'present': tenant_id = mso.lookup_tenant(tenant) if display_name is None: display_name = mso.existing.get('displayName', template) if not schema_obj: # Schema does not exist, so we have to create it payload = dict( displayName=schema, templates=[ dict( name=template, displayName=display_name, tenantId=tenant_id, ) ], sites=[], ) mso.existing = payload['templates'][0] if not module.check_mode: mso.request(schema_path, method='POST', data=payload) elif mso.existing: # Template exists, so we have to update it payload = dict( name=template, displayName=display_name, tenantId=tenant_id, ) mso.sanitize(payload, collate=True) ops.append( dict(op='replace', path=template_path + '/displayName', value=display_name)) ops.append( dict(op='replace', path=template_path + '/tenantId', value=tenant_id)) mso.existing = mso.proposed else: # Template does not exist, so we have to add it payload = dict( name=template, displayName=display_name, tenantId=tenant_id, ) mso.sanitize(payload, collate=True) ops.append(dict(op='add', path='/templates/-', value=payload)) 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( dhcp_relay_policy=dict(type="str", required=True, aliases=['name']), ip=dict(type="str"), tenant=dict(type="str"), schema=dict(type="str"), template=dict(type="str"), application_profile=dict(type="str", aliases=['anp']), endpoint_group=dict(type="str", aliases=['epg']), external_endpoint_group=dict(type="str", aliases=['ext_epg', 'external_epg']), state=dict(type="str", default="present", choices=["absent", "present", "query"]), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ["state", "present", ["ip", "tenant", "schema", "template"]], ["state", "absent", ["tenant", "schema", "template"]], ], ) dhcp_relay_policy = module.params.get("dhcp_relay_policy") ip = module.params.get("ip") tenant = module.params.get("tenant") schema = module.params.get("schema") template = module.params.get("template") if template is not None: template = template.replace(' ', '') application_profile = module.params.get("application_profile") endpoint_group = module.params.get("endpoint_group") external_endpoint_group = module.params.get("external_endpoint_group") state = module.params.get("state") mso = MSOModule(module) path = "policies/dhcp/relay" tenant_id = mso.lookup_tenant(tenant) # Get schema_id schema_id = mso.lookup_schema(schema) provider = dict( addr=ip, externalEpgRef='', epgRef='', l3Ref='', tenantId=tenant_id, ) provider_index = None previous_provider = {} if application_profile is not None and endpoint_group is not None: provider[ 'epgRef'] = '/schemas/{schemaId}/templates/{templateName}/anps/{app}/epgs/{epg}'.format( schemaId=schema_id, templateName=template, app=application_profile, epg=endpoint_group, ) elif external_endpoint_group is not None: provider[ 'externalEpgRef'] = '/schemas/{schemaId}/templates/{templateName}/externalEpgs/{ext_epg}'.format( schemaId=schema_id, templateName=template, ext_epg=external_endpoint_group) # Query for existing object(s) dhcp_relay_obj = mso.get_obj(path, name=dhcp_relay_policy, key="DhcpRelayPolicies") if 'id' not in dhcp_relay_obj: mso.fail_json( msg="DHCP Relay Policy '{0}' is not a valid DHCP Relay Policy name." .format(dhcp_relay_policy)) policy_id = dhcp_relay_obj.get("id") providers = [] if "provider" in dhcp_relay_obj: providers = dhcp_relay_obj.get('provider') for index, prov in enumerate(providers): if ((provider.get('epgRef') != '' and prov.get('epgRef') == provider.get('epgRef')) or (provider.get('externalEpgRef') != '' and prov.get('externalEpgRef') == provider.get('externalEpgRef'))): previous_provider = prov provider_index = index # If we found an existing object, continue with it path = '{0}/{1}'.format(path, policy_id) if state == "query": mso.existing = providers if endpoint_group is not None or external_endpoint_group is not None: mso.existing = previous_provider mso.exit_json() if endpoint_group is None and external_endpoint_group is None: mso.fail_json( msg= "Missing either endpoint_group or external_endpoint_group required attribute." ) mso.previous = previous_provider if state == "absent": provider = {} if previous_provider: if provider_index is not None: providers.pop(provider_index) elif state == "present": if provider_index is not None: providers[provider_index] = provider else: providers.append(provider) if module.check_mode: mso.existing = provider else: mso.existing = dhcp_relay_obj dhcp_relay_obj["provider"] = providers mso.sanitize(dhcp_relay_obj, collate=True) new_dhcp_relay_obj = mso.request(path, method="PUT", data=mso.sent) mso.existing = {} for index, prov in enumerate(new_dhcp_relay_obj.get('provider')): if ((provider.get('epgRef') != '' and prov.get('epgRef') == provider.get('epgRef')) or (provider.get('externalEpgRef') != '' and prov.get('externalEpgRef') == provider.get('externalEpgRef'))): mso.existing = prov mso.exit_json()
def main(): argument_spec = mso_argument_spec() argument_spec.update( dhcp_option_policy=dict(type="str", aliases=['name']), description=dict(type="str"), tenant=dict(type="str"), state=dict(type="str", default="present", choices=["absent", "present", "query"]), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ['state', 'absent', ['dhcp_option_policy']], ['state', 'present', ['dhcp_option_policy', 'tenant']], ], ) dhcp_option_policy = module.params.get("dhcp_option_policy") description = module.params.get("description") tenant = module.params.get("tenant") state = module.params.get("state") mso = MSOModule(module) path = "policies/dhcp/option" # Query for existing object(s) if dhcp_option_policy: mso.existing = mso.get_obj(path, name=dhcp_option_policy, key="DhcpRelayPolicies") if mso.existing: policy_id = mso.existing.get("id") # If we found an existing object, continue with it path = '{0}/{1}'.format(path, policy_id) else: mso.existing = mso.query_objs(path, key="DhcpRelayPolicies") mso.previous = mso.existing if state == "absent": if mso.existing: if module.check_mode: mso.existing = {} else: mso.existing = mso.request(path, method="DELETE", data=mso.sent) elif state == "present": tenant_id = mso.lookup_tenant(tenant) payload = dict( name=dhcp_option_policy, desc=description, policyType="dhcp", policySubtype="option", tenantId=tenant_id, ) mso.sanitize(payload, collate=True) if mso.existing: if mso.check_changed(): if module.check_mode: mso.existing = mso.proposed else: mso.existing = mso.request(path, method="PUT", data=mso.sent) else: if module.check_mode: mso.existing = mso.proposed else: mso.existing = mso.request(path, method="POST", data=mso.sent) mso.exit_json()
def main(): argument_spec = mso_argument_spec() argument_spec.update( source_schema=dict(type='str'), destination_schema=dict(type='str'), destination_tenant=dict(type='str'), source_template_name=dict(type='str'), destination_template_name=dict(type='str'), destination_template_display_name=dict(type='str'), state=dict(type='str', default='clone', choices=['clone']), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ['state', 'clone', ['destination_schema', 'destination_tenant']], ], ) source_schema = module.params.get('source_schema') destination_schema = module.params.get('destination_schema') destination_tenant = module.params.get('destination_tenant') source_template_name = module.params.get('source_template_name') destination_template_name = module.params.get('destination_template_name') destination_template_display_name = module.params.get( 'destination_template_display_name') state = module.params.get('state') mso = MSOModule(module) destination_schema_id = None # Get source schema id and destination schema id schema_summary = mso.query_objs('schemas/list-identity', key='schemas') for schema in schema_summary: if schema.get('displayName') == source_schema: source_schema_id = schema.get('id') if schema.get('displayName') == destination_schema: destination_schema_id = schema.get('id') destination_schema = None break if destination_schema_id is None: mso.fail_json(msg="Schema with the name '{0}' does not exist.".format( destination_schema)) # Get destination tenant id destination_tenant_id = mso.lookup_tenant(destination_tenant) path = 'schemas/cloneTemplates' if state == 'clone': if destination_template_display_name is None: destination_template_display_name = destination_template_name payload = dict( destTenantId=destination_tenant_id, destSchemaId=destination_schema_id, destSchemaName=destination_schema, templatesToBeCloned=[ dict( schemaId=source_schema_id, templateName=source_template_name, destTemplateName=destination_template_name, destTempDisplayName=destination_template_display_name, ) ], ) mso.sanitize(payload, collate=True) mso.previous = {} if not mso.existing: if module.check_mode: mso.existing = {} else: mso.existing = mso.request(path, method='POST', data=mso.sent) mso.exit_json()