Beispiel #1
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        group=dict(type='str',
                   aliases=['group']),  # Not required for querying all objects
        firmwarepol=dict(type='str'),  # Not required for querying all objects
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['group']],
            ['state', 'present', ['group', 'firmwarepol']],
        ],
    )

    state = module.params.get('state')
    group = module.params.get('group')
    firmwarepol = module.params.get('firmwarepol')
    name_alias = module.params.get('name_alias')

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='firmwareFwGrp',
            aci_rn='fabric/fwgrp-{0}'.format(group),
            target_filter={'name': group},
            module_object=group,
        ),
        child_classes=['firmwareRsFwgrpp'],
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='firmwareFwGrp',
            class_config=dict(
                name=group,
                nameAlias=name_alias,
            ),
            child_configs=[
                dict(firmwareRsFwgrpp=dict(attributes=dict(
                    tnFirmwareFwPName=firmwarepol, ), ), ),
            ],
        )

        aci.get_diff(aci_class='firmwareFwGrp')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        mcp=dict(type='str',
                 aliases=['mcp_interface',
                          'name']),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        admin_state=dict(type='bool'),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['mcp']],
            ['state', 'present', ['mcp']],
        ],
    )

    aci = ACIModule(module)

    mcp = module.params.get('mcp')
    description = module.params.get('description')
    admin_state = aci.boolean(module.params.get('admin_state'), 'enabled',
                              'disabled')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    aci.construct_url(root_class=dict(
        aci_class='mcpIfPol',
        aci_rn='infra/mcpIfP-{0}'.format(mcp),
        module_object=mcp,
        target_filter={'name': mcp},
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='mcpIfPol',
            class_config=dict(
                name=mcp,
                descr=description,
                adminSt=admin_state,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='mcpIfPol')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #3
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        fc_policy=dict(type='str',
                       aliases=['name'
                                ]),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        port_mode=dict(type='str',
                       choices=['f', 'np']),  # No default provided on purpose
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['fc_policy']],
            ['state', 'present', ['fc_policy']],
        ],
    )

    fc_policy = module.params.get('fc_policy')
    port_mode = module.params.get('port_mode')
    description = module.params.get('description')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class='fcIfPol',
        aci_rn='infra/fcIfPol-{0}'.format(fc_policy),
        module_object=fc_policy,
        target_filter={'name': fc_policy},
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='fcIfPol',
            class_config=dict(
                name=fc_policy,
                descr=description,
                portMode=port_mode,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='fcIfPol')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #4
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        leaf_profile=dict(type='str',
                          aliases=['name', 'leaf_profile_name'
                                   ]),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['leaf_profile']],
            ['state', 'present', ['leaf_profile']],
        ],
    )

    leaf_profile = module.params.get('leaf_profile')
    description = module.params.get('description')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class='infraNodeP',
        aci_rn='infra/nprof-{0}'.format(leaf_profile),
        module_object=leaf_profile,
        target_filter={'name': leaf_profile},
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='infraNodeP',
            class_config=dict(
                name=leaf_profile,
                descr=description,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='infraNodeP')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #5
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        description=dict(type='str', aliases=['descr']),
        node_id=dict(type='int'),  # Not required for querying all objects
        pod_id=dict(type='int'),
        role=dict(type='str',
                  choices=['leaf', 'spine', 'unspecified'],
                  aliases=['role_name']),
        serial=dict(type='str',
                    aliases=['serial_number'
                             ]),  # Not required for querying all objects
        switch=dict(type='str', aliases=['name', 'switch_name']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['node_id', 'serial']],
            ['state', 'present', ['node_id', 'serial']],
        ],
    )

    pod_id = module.params.get('pod_id')
    serial = module.params.get('serial')
    node_id = module.params.get('node_id')
    switch = module.params.get('switch')
    description = module.params.get('description')
    role = module.params.get('role')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class='fabricNodeIdentP',
        aci_rn='controller/nodeidentpol/nodep-{0}'.format(serial),
        module_object=serial,
        target_filter={'serial': serial},
    ))

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='fabricNodeIdentP',
            class_config=dict(
                descr=description,
                name=switch,
                nodeId=node_id,
                podId=pod_id,
                # NOTE: Originally we were sending 'rn', but now we need 'dn' for idempotency
                # FIXME: Did this change with ACI version ?
                dn='uni/controller/nodeidentpol/nodep-{0}'.format(serial),
                # rn='nodep-{0}'.format(serial),
                role=role,
                serial=serial,
                nameAlias=name_alias,
            ))

        aci.get_diff(aci_class='fabricNodeIdentP')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json(**aci.result)
Beispiel #6
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        leaf_interface_profile=dict(
            type='str', aliases=['leaf_interface_profile_name'
                                 ]),  # Not required for querying all objects
        access_port_selector=dict(type='str',
                                  aliases=[
                                      'name', 'access_port_selector_name'
                                  ]),  # Not required for querying all objects
        leaf_port_blk=dict(type='str', aliases=[
            'leaf_port_blk_name'
        ]),  # Not required for querying all objects
        leaf_port_blk_description=dict(type='str'),
        from_port=dict(
            type='str', aliases=['from', 'fromPort', 'from_port_range']
        ),  # Not required for querying all objects and deleting sub port blocks
        to_port=dict(
            type='str', aliases=['to', 'toPort', 'to_port_range']
        ),  # Not required for querying all objects and deleting sub port blocks
        from_sub_port=dict(
            type='str', aliases=['fromSubPort', 'from_sub_port_range']
        ),  # Not required for querying all objects and deleting sub port blocks
        to_sub_port=dict(
            type='str', aliases=['toSubPort', 'to_sub_port_range']
        ),  # Not required for querying all objects and deleting sub port blocks
        from_card=dict(type='str', aliases=['from_card_range']),
        to_card=dict(type='str', aliases=['to_card_range']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            [
                'state', 'absent',
                [
                    'access_port_selector', 'leaf_port_blk',
                    'leaf_interface_profile'
                ]
            ],
            [
                'state', 'present',
                [
                    'access_port_selector', 'leaf_port_blk', 'from_port',
                    'to_port', 'from_sub_port', 'to_sub_port',
                    'leaf_interface_profile'
                ]
            ],
        ],
    )

    leaf_interface_profile = module.params.get('leaf_interface_profile')
    access_port_selector = module.params.get('access_port_selector')
    leaf_port_blk = module.params.get('leaf_port_blk')
    leaf_port_blk_description = module.params.get('leaf_port_blk_description')
    from_port = module.params.get('from_port')
    to_port = module.params.get('to_port')
    from_sub_port = module.params.get('from_sub_port')
    to_sub_port = module.params.get('to_sub_port')
    from_card = module.params.get('from_card')
    to_card = module.params.get('to_card')
    state = module.params.get('state')

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='infraAccPortP',
            aci_rn='infra/accportprof-{0}'.format(leaf_interface_profile),
            module_object=leaf_interface_profile,
            target_filter={'name': leaf_interface_profile},
        ),
        subclass_1=dict(
            aci_class='infraHPortS',
            # NOTE: normal rn: hports-{name}-typ-{type}, hence here hardcoded to range for purposes of module
            aci_rn='hports-{0}-typ-range'.format(access_port_selector),
            module_object=access_port_selector,
            target_filter={'name': access_port_selector},
        ),
        subclass_2=dict(
            aci_class='infraSubPortBlk',
            aci_rn='subportblk-{0}'.format(leaf_port_blk),
            module_object=leaf_port_blk,
            target_filter={'name': leaf_port_blk},
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='infraSubPortBlk',
            class_config=dict(
                descr=leaf_port_blk_description,
                name=leaf_port_blk,
                fromPort=from_port,
                toPort=to_port,
                fromSubPort=from_sub_port,
                toSubPort=to_sub_port,
                fromCard=from_card,
                toCard=to_card,
                #  type='range',
            ),
        )

        aci.get_diff(aci_class='infraSubPortBlk')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        name=dict(type='str',
                  aliases=['name']),  # Not required for querying all objects
        version=dict(type='str', aliases=['version']),
        ignoreCompat=dict(type='bool'),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['name']],
            ['state', 'present', ['name', 'version']],
        ],
    )

    state = module.params.get('state')
    name = module.params.get('name')
    version = module.params.get('version')
    name_alias = module.params.get('name_alias')

    if module.params.get('ignoreCompat'):
        ignore = 'yes'
    else:
        ignore = 'no'

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class='firmwareFwP',
        aci_rn='fabric/fwpol-{0}'.format(name),
        target_filter={'name': name},
        module_object=name,
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='firmwareFwP',
            class_config=dict(
                name=name,
                version=version,
                ignoreCompat=ignore,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='firmwareFwP')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #8
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        pool_type=dict(type='str',
                       required=True,
                       aliases=['type'],
                       choices=['vlan', 'vxlan', 'vsan']),
        allocation_mode=dict(type='str',
                             aliases=['mode'],
                             choices=['dynamic', 'inherit', 'static']),
        description=dict(type='str', aliases=['descr']),
        pool=dict(type='str',
                  aliases=['pool_name'
                           ]),  # Not required for querying all objects
        pool_allocation_mode=dict(type='str',
                                  aliases=['pool_mode'],
                                  choices=['dynamic', 'static']),
        range_end=dict(type='int',
                       aliases=['end'
                                ]),  # Not required for querying all objects
        range_name=dict(type='str',
                        aliases=["name", "range"
                                 ]),  # Not required for querying all objects
        range_start=dict(type='int',
                         aliases=["start"
                                  ]),  # Not required for querying all objects
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            [
                'state', 'absent',
                ['pool', 'range_end', 'range_name', 'range_start']
            ],
            [
                'state', 'present',
                ['pool', 'range_end', 'range_name', 'range_start']
            ],
        ],
    )

    allocation_mode = module.params.get('allocation_mode')
    description = module.params.get('description')
    pool = module.params.get('pool')
    pool_allocation_mode = module.params.get('pool_allocation_mode')
    pool_type = module.params.get('pool_type')
    range_end = module.params.get('range_end')
    range_name = module.params.get('range_name')
    range_start = module.params.get('range_start')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    if range_end is not None:
        encap_end = '{0}-{1}'.format(pool_type, range_end)
    else:
        encap_end = None

    if range_start is not None:
        encap_start = '{0}-{1}'.format(pool_type, range_start)
    else:
        encap_start = None

    ACI_RANGE_MAPPING = dict(
        vlan=dict(
            aci_class='fvnsEncapBlk',
            aci_mo='from-[{0}]-to-[{1}]'.format(encap_start, encap_end),
        ),
        vxlan=dict(
            aci_class='fvnsEncapBlk',
            aci_mo='from-[{0}]-to-[{1}]'.format(encap_start, encap_end),
        ),
        vsan=dict(
            aci_class='fvnsVsanEncapBlk',
            aci_mo='vsanfrom-[{0}]-to-[{1}]'.format(encap_start, encap_end),
        ),
    )

    # Collect proper class and mo information based on pool_type
    aci_range_class = ACI_RANGE_MAPPING[pool_type]["aci_class"]
    aci_range_mo = ACI_RANGE_MAPPING[pool_type]["aci_mo"]
    aci_pool_class = ACI_POOL_MAPPING[pool_type]["aci_class"]
    aci_pool_mo = ACI_POOL_MAPPING[pool_type]["aci_mo"]
    pool_name = pool

    # Validate range_end and range_start are valid for its respective encap type
    for encap_id in range_end, range_start:
        if encap_id is not None:
            if pool_type == 'vlan':
                if not 1 <= encap_id <= 4094:
                    module.fail_json(
                        msg=
                        'vlan pools must have "range_start" and "range_end" values between 1 and 4094'
                    )
            elif pool_type == 'vxlan':
                if not 5000 <= encap_id <= 16777215:
                    module.fail_json(
                        msg=
                        'vxlan pools must have "range_start" and "range_end" values between 5000 and 16777215'
                    )
            elif pool_type == 'vsan':
                if not 1 <= encap_id <= 4093:
                    module.fail_json(
                        msg=
                        'vsan pools must have "range_start" and "range_end" values between 1 and 4093'
                    )

    if range_end is not None and range_start is not None:
        # Validate range_start is less than range_end
        if range_start > range_end:
            module.fail_json(
                msg=
                'The "range_start" must be less than or equal to the "range_end"'
            )

    elif range_end is None and range_start is None:
        if range_name is None:
            # Reset range managed object to None for aci util to properly handle query
            aci_range_mo = None

    # Vxlan does not support setting the allocation mode
    if pool_type == 'vxlan' and allocation_mode is not None:
        module.fail_json(
            msg=
            'vxlan pools do not support setting the "allocation_mode"; please omit this parameter for vxlan pools'
        )

    # ACI Pool URL requires the allocation mode for vlan and vsan pools (ex: uni/infra/vlanns-[poolname]-static)
    if pool_type != 'vxlan' and pool is not None:
        if pool_allocation_mode is not None:
            pool_name = '[{0}]-{1}'.format(pool, pool_allocation_mode)
        else:
            module.fail_json(
                msg=
                'ACI requires the "pool_allocation_mode" for "pool_type" of "vlan" and "vsan" when the "pool" is provided'
            )

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class=aci_pool_class,
            aci_rn='{0}{1}'.format(aci_pool_mo, pool_name),
            module_object=pool,
            target_filter={'name': pool},
        ),
        subclass_1=dict(
            aci_class=aci_range_class,
            aci_rn='{0}'.format(aci_range_mo),
            module_object=aci_range_mo,
            target_filter={
                'from': encap_start,
                'to': encap_end,
                'name': range_name
            },
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class=aci_range_class,
            class_config={
                "allocMode": allocation_mode,
                "descr": description,
                "from": encap_start,
                "name": range_name,
                "to": encap_end,
                "nameAlias": name_alias,
            },
        )

        aci.get_diff(aci_class=aci_range_class)

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #9
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        tenant=dict(type='str',
                    aliases=['tenant_name'
                             ]),  # Not required for querying all objects
        dst_group=dict(type='str'),  # Not required for querying all objects
        src_group=dict(type='str'),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['dst_group', 'src_group', 'tenant']],
            ['state', 'present', ['dst_group', 'src_group', 'tenant']],
        ],
    )

    description = module.params.get('description')
    dst_group = module.params.get('dst_group')
    src_group = module.params.get('src_group')
    state = module.params.get('state')
    tenant = module.params.get('tenant')
    name_alias = module.params.get('name_alias')

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='fvTenant',
            aci_rn='tn-{0}'.format(tenant),
            module_object=tenant,
            target_filter={'name': tenant},
        ),
        subclass_1=dict(
            aci_class='spanSrcGrp',
            aci_rn='srcgrp-{0}'.format(src_group),
            module_object=src_group,
            target_filter={'name': src_group},
        ),
        subclass_2=dict(
            aci_class='spanSpanLbl',
            aci_rn='spanlbl-{0}'.format(dst_group),
            module_object=dst_group,
            target_filter={'name': dst_group},
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='spanSpanLbl',
            class_config=dict(
                descr=description,
                name=dst_group,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='spanSpanLbl')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #10
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        name=dict(type='str',
                  aliases=['name', 'scheduler_name'
                           ]),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        windowname=dict(type='str', aliases=['windowname']),
        recurring=dict(type='bool'),
        concurCap=dict(
            type='int'),  # Number of devices it will run against concurrently
        maxTime=dict(
            type='str'
        ),  # The amount of minutes a process will be able to run (unlimited or dd:hh:mm:ss)
        date=dict(type='str', aliases=[
            'date'
        ]),  # The date the process will run YYYY-MM-DDTHH:MM:SS
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        hour=dict(type='int'),
        minute=dict(type='int'),
        day=dict(type='str',
                 default='every-day',
                 choices=[
                     'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
                     'Saturday', 'Sunday', 'every-day', 'even-day', 'odd-day'
                 ]),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['name']],
            ['state', 'present', ['name']],
        ],
    )

    state = module.params.get('state')
    name = module.params.get('name')
    windowname = module.params.get('windowname')
    recurring = module.params.get('recurring')
    date = module.params.get('date')
    hour = module.params.get('hour')
    minute = module.params.get('minute')
    maxTime = module.params.get('maxTime')
    concurCap = module.params.get('concurCap')
    day = module.params.get('day')
    description = module.params.get('description')
    name_alias = module.params.get('name_alias')

    if recurring:
        child_configs = [
            dict(trigRecurrWindowP=dict(attributes=dict(
                name=windowname,
                hour=hour,
                minute=minute,
                procCa=maxTime,
                concurCap=concurCap,
                day=day,
            )))
        ]
    elif recurring is False:
        child_configs = [
            dict(trigAbsWindowP=dict(attributes=dict(
                name=windowname,
                procCap=maxTime,
                concurCap=concurCap,
                date=date,
            )))
        ]
    else:
        child_configs = []

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class='trigSchedP',
        aci_rn='fabric/schedp-{0}'.format(name),
        target_filter={'name': name},
        module_object=name,
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='trigSchedP',
            class_config=dict(
                name=name,
                descr=description,
                nameAlias=name_alias,
            ),
            child_configs=child_configs,
        )

        aci.get_diff(aci_class='trigSchedP')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        name=dict(type='str',
                  aliases=['credential_name', 'credential_profile']),
        credential_password=dict(type='str', no_log=True),
        credential_username=dict(type='str'),
        description=dict(type='str', aliases=['descr']),
        domain=dict(type='str', aliases=['domain_name', 'domain_profile']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        vm_provider=dict(type='str', choices=VM_PROVIDER_MAPPING.keys()),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['domain']],
            ['state', 'present', ['domain']],
        ],
    )

    name = module.params.get('name')
    credential_password = module.params.get('credential_password')
    credential_username = module.params.get('credential_username')
    description = module.params.get('description')
    domain = module.params.get('domain')
    state = module.params.get('state')
    vm_provider = module.params.get('vm_provider')
    name_alias = module.params.get('name_alias')

    credential_class = 'vmmUsrAccP'
    usracc_mo = 'uni/vmmp-{0}/dom-{1}/usracc-{2}'.format(
        VM_PROVIDER_MAPPING.get(vm_provider), domain, name)
    usracc_rn = 'vmmp-{0}/dom-{1}/usracc-{2}'.format(
        VM_PROVIDER_MAPPING.get(vm_provider), domain, name)

    # Ensure that querying all objects works when only domain is provided
    if name is None:
        usracc_mo = None

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class=credential_class,
        aci_rn=usracc_rn,
        module_object=usracc_mo,
        target_filter={
            'name': domain,
            'usracc': name
        },
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class=credential_class,
            class_config=dict(
                descr=description,
                name=name,
                pwd=credential_password,
                usr=credential_username,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class=credential_class)

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #12
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        tenant=dict(type='str',
                    aliases=['tenant_name'
                             ]),  # Not required for querying all objects
        l3out=dict(type='str',
                   aliases=['l3out_name',
                            'name']),  # Not required for querying all objects
        domain=dict(type='str',
                    aliases=['ext_routed_domain_name', 'routed_domain']),
        vrf=dict(type='str', aliases=['vrf_name']),
        description=dict(type='str', aliases=['descr']),
        route_control=dict(type='list',
                           choices=['export', 'import'],
                           aliases=['route_control_enforcement']),
        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']),
        l3protocol=dict(type='list',
                        choices=['bgp', 'eigrp', 'ospf', 'pim', 'static']),
        asn=dict(type='int', aliases=['as_number']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['l3out', 'tenant']],
            ['state', 'present', ['l3out', 'tenant', 'domain', 'vrf']],
        ],
    )

    aci = ACIModule(module)

    l3out = module.params.get('l3out')
    domain = module.params.get('domain')
    dscp = module.params.get('dscp')
    description = module.params.get('description')
    enforceRtctrl = module.params.get('route_control')
    vrf = module.params.get('vrf')
    l3protocol = module.params.get('l3protocol')
    asn = module.params.get('asn')
    state = module.params.get('state')
    tenant = module.params.get('tenant')
    name_alias = module.params.get('name_alias')

    if l3protocol:
        if 'eigrp' in l3protocol and asn is None:
            module.fail_json(
                msg="Parameter 'asn' is required when l3protocol is 'eigrp'")
        if 'eigrp' not in l3protocol and asn is not None:
            module.warn(
                "Parameter 'asn' is only applicable when l3protocol is 'eigrp'. The ASN will be ignored"
            )

    enforce_ctrl = ''
    if enforceRtctrl is not None:
        if len(enforceRtctrl) == 1 and enforceRtctrl[0] == 'import':
            aci.fail_json(
                "The route_control parameter is invalid: allowed options are export or import,export only"
            )
        elif len(enforceRtctrl) == 1 and enforceRtctrl[0] == 'export':
            enforce_ctrl = 'export'
        else:
            enforce_ctrl = 'export,import'
    child_classes = [
        'l3extRsL3DomAtt', 'l3extRsEctx', 'bgpExtP', 'ospfExtP', 'eigrpExtP',
        'pimExtP'
    ]

    aci.construct_url(
        root_class=dict(
            aci_class='fvTenant',
            aci_rn='tn-{0}'.format(tenant),
            module_object=tenant,
            target_filter={'name': tenant},
        ),
        subclass_1=dict(
            aci_class='l3extOut',
            aci_rn='out-{0}'.format(l3out),
            module_object=l3out,
            target_filter={'name': l3out},
        ),
        child_classes=child_classes,
    )

    aci.get_existing()

    child_configs = [
        dict(l3extRsL3DomAtt=dict(attributes=dict(
            tDn='uni/l3dom-{0}'.format(domain)))),
        dict(l3extRsEctx=dict(attributes=dict(tnFvCtxName=vrf))),
    ]
    if l3protocol is not None:
        for protocol in l3protocol:
            if protocol == 'bgp':
                child_configs.append(
                    dict(bgpExtP=dict(
                        attributes=dict(descr='', nameAlias=''))))
            elif protocol == 'eigrp':
                child_configs.append(
                    dict(eigrpExtP=dict(
                        attributes=dict(descr='', nameAlias='', asn=asn))))
            elif protocol == 'ospf':
                child_configs.append(
                    dict(ospfExtP=dict(
                        attributes=dict(descr='', nameAlias=''))))
            elif protocol == 'pim':
                child_configs.append(
                    dict(pimExtP=dict(
                        attributes=dict(descr='', nameAlias=''))))

    if state == 'present':
        aci.payload(
            aci_class='l3extOut',
            class_config=dict(
                name=l3out,
                descr=description,
                dn='uni/tn-{0}/out-{1}'.format(tenant, l3out),
                enforceRtctrl=enforce_ctrl,
                targetDscp=dscp,
                nameAlias=name_alias,
            ),
            child_configs=child_configs,
        )

        aci.get_diff(aci_class='l3extOut')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        source=dict(type='str',
                    aliases=['name', 'source_name'
                             ]),  # Not required for querying all objects
        polling_interval=dict(type='int'),
        url=dict(type='str'),
        url_username=dict(type='str'),
        url_password=dict(type='str', no_log=True),
        url_protocol=dict(type='str',
                          default='scp',
                          choices=['http', 'local', 'scp', 'usbkey'],
                          aliases=['url_proto']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['source']],
            ['state', 'present', ['url_protocol', 'source', 'url']],
        ],
    )

    polling_interval = module.params.get('polling_interval')
    url_protocol = module.params.get('url_protocol')
    state = module.params.get('state')
    source = module.params.get('source')
    url = module.params.get('url')
    url_password = module.params.get('url_password')
    url_username = module.params.get('url_username')
    name_alias = module.params.get('name_alias')

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class='firmwareOSource',
        aci_rn='fabric/fwrepop',
        module_object=source,
        target_filter={'name': source},
    ), )
    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='firmwareOSource',
            class_config=dict(
                name=source,
                url=url,
                password=url_password,
                pollingInterval=polling_interval,
                proto=url_protocol,
                user=url_username,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='firmwareOSource')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #14
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        pool=dict(type='str',
                  aliases=['name', 'pool_name'
                           ]),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        pool_allocation_mode=dict(type='str',
                                  aliases=['allocation_mode', 'mode'],
                                  choices=['dynamic', 'static']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['pool']],
            ['state', 'present', ['pool']],
        ],
    )

    description = module.params.get('description')
    pool = module.params.get('pool')
    pool_allocation_mode = module.params.get('pool_allocation_mode')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    pool_name = pool

    # ACI Pool URL requires the allocation mode for vlan and vsan pools (ex: uni/infra/vlanns-[poolname]-static)
    if pool is not None:
        if pool_allocation_mode is not None:
            pool_name = '[{0}]-{1}'.format(pool, pool_allocation_mode)
        else:
            module.fail_json(
                msg=
                "ACI requires the 'pool_allocation_mode' when 'pool' is provided"
            )

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class='fvnsVlanInstP',
        aci_rn='infra/vlanns-{0}'.format(pool_name),
        module_object=pool,
        target_filter={'name': pool},
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='fvnsVlanInstP',
            class_config=dict(
                allocMode=pool_allocation_mode,
                descr=description,
                name=pool,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='fvnsVlanInstP')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #15
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        contract_type=dict(type='str',
                           required=True,
                           choices=['consumer', 'provider']),
        ap=dict(type='str',
                aliases=['app_profile', 'app_profile_name'
                         ]),  # Not required for querying all objects
        epg=dict(type='str',
                 aliases=['epg_name'
                          ]),  # Not required for querying all objects
        contract=dict(type='str',
                      aliases=['contract_name'
                               ]),  # Not required for querying all objects
        priority=dict(type='str',
                      choices=['level1', 'level2', 'level3', 'unspecified']),
        provider_match=dict(
            type='str', choices=['all', 'at_least_one', 'at_most_one',
                                 'none']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        tenant=dict(type='str',
                    aliases=['tenant_name'
                             ]),  # Not required for querying all objects
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['ap', 'contract', 'epg', 'tenant']],
            ['state', 'present', ['ap', 'contract', 'epg', 'tenant']],
        ],
    )

    ap = module.params.get('ap')
    contract = module.params.get('contract')
    contract_type = module.params.get('contract_type')
    epg = module.params.get('epg')
    priority = module.params.get('priority')
    provider_match = module.params.get('provider_match')
    if provider_match is not None:
        provider_match = PROVIDER_MATCH_MAPPING[provider_match]
    state = module.params.get('state')
    tenant = module.params.get('tenant')

    aci_class = ACI_CLASS_MAPPING[contract_type]["class"]
    aci_rn = ACI_CLASS_MAPPING[contract_type]["rn"]

    if contract_type == "consumer" and provider_match is not None:
        module.fail_json(
            msg=
            "the 'provider_match' is only configurable for Provided Contracts")

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='fvTenant',
            aci_rn='tn-{0}'.format(tenant),
            module_object=tenant,
            target_filter={'name': tenant},
        ),
        subclass_1=dict(
            aci_class='fvAp',
            aci_rn='ap-{0}'.format(ap),
            module_object=ap,
            target_filter={'name': ap},
        ),
        subclass_2=dict(
            aci_class='fvAEPg',
            aci_rn='epg-{0}'.format(epg),
            module_object=epg,
            target_filter={'name': epg},
        ),
        subclass_3=dict(
            aci_class=aci_class,
            aci_rn='{0}{1}'.format(aci_rn, contract),
            module_object=contract,
            target_filter={'tnVzBrCPName': contract},
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class=aci_class,
            class_config=dict(
                matchT=provider_match,
                prio=priority,
                tnVzBrCPName=contract,
            ),
        )

        aci.get_diff(aci_class=aci_class)

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #16
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        pool_type=dict(type='str',
                       required=True,
                       aliases=['type'],
                       choices=['vlan', 'vsan', 'vxlan']),
        description=dict(type='str', aliases=['descr']),
        pool=dict(type='str',
                  aliases=['name', 'pool_name'
                           ]),  # Not required for querying all objects
        pool_allocation_mode=dict(type='str',
                                  aliases=['allocation_mode', 'mode'],
                                  choices=['dynamic', 'static']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['pool']],
            ['state', 'present', ['pool']],
        ],
    )

    description = module.params.get('description')
    pool = module.params.get('pool')
    pool_type = module.params.get('pool_type')
    pool_allocation_mode = module.params.get('pool_allocation_mode')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    aci_class = ACI_POOL_MAPPING[pool_type]['aci_class']
    aci_mo = ACI_POOL_MAPPING[pool_type]['aci_mo']
    pool_name = pool

    # ACI Pool URL requires the pool_allocation mode for vlan and vsan pools (ex: uni/infra/vlanns-[poolname]-static)
    if pool_type != 'vxlan' and pool is not None:
        if pool_allocation_mode is not None:
            pool_name = '[{0}]-{1}'.format(pool, pool_allocation_mode)
        else:
            module.fail_json(
                msg=
                "ACI requires parameter 'pool_allocation_mode' for 'pool_type' of 'vlan' and 'vsan' when parameter 'pool' is provided"
            )

    # Vxlan pools do not support pool allocation modes
    if pool_type == 'vxlan' and pool_allocation_mode is not None:
        module.fail_json(
            msg=
            "vxlan pools do not support setting the 'pool_allocation_mode'; please remove this parameter from the task"
        )

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class=aci_class,
        aci_rn='{0}{1}'.format(aci_mo, pool_name),
        module_object=pool,
        target_filter={'name': pool},
    ), )

    aci.get_existing()

    if state == 'present':
        # Filter out module parameters with null values
        aci.payload(aci_class=aci_class,
                    class_config=dict(
                        allocMode=pool_allocation_mode,
                        descr=description,
                        name=pool,
                        nameAlias=name_alias,
                    ))

        # Generate config diff which will be used as POST request body
        aci.get_diff(aci_class=aci_class)

        # Submit changes if module not in check_mode and the proposed is different than existing
        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        lldp_policy=dict(type='str',
                         aliases=['name'
                                  ]),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        receive_state=dict(type='bool'),
        transmit_state=dict(type='bool'),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['lldp_policy']],
            ['state', 'present', ['lldp_policy']],
        ],
    )

    aci = ACIModule(module)

    lldp_policy = module.params.get('lldp_policy')
    description = module.params.get('description')
    receive_state = aci.boolean(module.params.get('receive_state'), 'enabled',
                                'disabled')
    transmit_state = aci.boolean(module.params.get('transmit_state'),
                                 'enabled', 'disabled')
    state = module.params.get('state')

    aci.construct_url(root_class=dict(
        aci_class='lldpIfPol',
        aci_rn='infra/lldpIfP-{0}'.format(lldp_policy),
        module_object=lldp_policy,
        target_filter={'name': lldp_policy},
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='lldpIfPol',
            class_config=dict(
                name=lldp_policy,
                descr=description,
                adminRxSt=receive_state,
                adminTxSt=transmit_state,
            ),
        )

        aci.get_diff(aci_class='lldpIfPol')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        # NOTE: Since this module needs to include both infra:AccBndlGrp (for PC and VPC) and infra:AccPortGrp (for leaf access port policy group):
        # NOTE: I'll allow the user to make the choice here (link(PC), node(VPC), leaf(leaf-access port policy group))
        lag_type=dict(type='str',
                      required=True,
                      aliases=['lag_type_name'],
                      choices=['leaf', 'link', 'node']),
        policy_group=dict(type='str',
                          aliases=['name', 'policy_group_name'
                                   ]),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        link_level_policy=dict(type='str', aliases=['link_level_policy_name']),
        cdp_policy=dict(type='str', aliases=['cdp_policy_name']),
        mcp_policy=dict(type='str', aliases=['mcp_policy_name']),
        lldp_policy=dict(type='str', aliases=['lldp_policy_name']),
        stp_interface_policy=dict(type='str',
                                  aliases=['stp_interface_policy_name']),
        egress_data_plane_policing_policy=dict(
            type='str', aliases=['egress_data_plane_policing_policy_name']),
        ingress_data_plane_policing_policy=dict(
            type='str', aliases=['ingress_data_plane_policing_policy_name']),
        priority_flow_control_policy=dict(
            type='str', aliases=['priority_flow_control_policy_name']),
        fibre_channel_interface_policy=dict(
            type='str', aliases=['fibre_channel_interface_policy_name']),
        slow_drain_policy=dict(type='str', aliases=['slow_drain_policy_name']),
        port_channel_policy=dict(type='str',
                                 aliases=['port_channel_policy_name']),
        monitoring_policy=dict(type='str', aliases=['monitoring_policy_name']),
        storm_control_interface_policy=dict(
            type='str', aliases=['storm_control_interface_policy_name']),
        l2_interface_policy=dict(type='str',
                                 aliases=['l2_interface_policy_name']),
        port_security_policy=dict(type='str',
                                  aliases=['port_security_policy_name']),
        aep=dict(type='str', aliases=['aep_name']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['policy_group']],
            ['state', 'present', ['policy_group']],
        ],
    )

    policy_group = module.params.get('policy_group')
    description = module.params.get('description')
    lag_type = module.params.get('lag_type')
    link_level_policy = module.params.get('link_level_policy')
    cdp_policy = module.params.get('cdp_policy')
    mcp_policy = module.params.get('mcp_policy')
    lldp_policy = module.params.get('lldp_policy')
    stp_interface_policy = module.params.get('stp_interface_policy')
    egress_data_plane_policing_policy = module.params.get(
        'egress_data_plane_policing_policy')
    ingress_data_plane_policing_policy = module.params.get(
        'ingress_data_plane_policing_policy')
    priority_flow_control_policy = module.params.get(
        'priority_flow_control_policy')
    fibre_channel_interface_policy = module.params.get(
        'fibre_channel_interface_policy')
    slow_drain_policy = module.params.get('slow_drain_policy')
    port_channel_policy = module.params.get('port_channel_policy')
    monitoring_policy = module.params.get('monitoring_policy')
    storm_control_interface_policy = module.params.get(
        'storm_control_interface_policy')
    l2_interface_policy = module.params.get('l2_interface_policy')
    port_security_policy = module.params.get('port_security_policy')
    aep = module.params.get('aep')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    if lag_type == 'leaf':
        aci_class_name = 'infraAccPortGrp'
        dn_name = 'accportgrp'
        class_config_dict = dict(
            name=policy_group,
            descr=description,
            nameAlias=name_alias,
        )
        # Reset for target_filter
        lag_type = None
    elif lag_type in ('link', 'node'):
        aci_class_name = 'infraAccBndlGrp'
        dn_name = 'accbundle'
        class_config_dict = dict(
            name=policy_group,
            descr=description,
            lagT=lag_type,
            nameAlias=name_alias,
        )

    child_configs = [
        dict(infraRsCdpIfPol=dict(attributes=dict(
            tnCdpIfPolName=cdp_policy, ), ), ),
        dict(infraRsFcIfPol=dict(attributes=dict(
            tnFcIfPolName=fibre_channel_interface_policy, ), ), ),
        dict(infraRsHIfPol=dict(attributes=dict(
            tnFabricHIfPolName=link_level_policy, ), ), ),
        dict(infraRsL2IfPol=dict(attributes=dict(
            tnL2IfPolName=l2_interface_policy, ), ), ),
        dict(infraRsL2PortSecurityPol=dict(attributes=dict(
            tnL2PortSecurityPolName=port_security_policy, ), ), ),
        dict(infraRsLacpPol=dict(attributes=dict(
            tnLacpLagPolName=port_channel_policy, ), ), ),
        dict(infraRsLldpIfPol=dict(attributes=dict(
            tnLldpIfPolName=lldp_policy, ), ), ),
        dict(infraRsMcpIfPol=dict(attributes=dict(
            tnMcpIfPolName=mcp_policy, ), ), ),
        dict(infraRsMonIfInfraPol=dict(attributes=dict(
            tnMonInfraPolName=monitoring_policy, ), ), ),
        dict(infraRsQosEgressDppIfPol=dict(attributes=dict(
            tnQosDppPolName=egress_data_plane_policing_policy, ), ), ),
        dict(infraRsQosIngressDppIfPol=dict(attributes=dict(
            tnQosDppPolName=ingress_data_plane_policing_policy, ), ), ),
        dict(infraRsQosPfcIfPol=dict(attributes=dict(
            tnQosPfcIfPolName=priority_flow_control_policy, ), ), ),
        dict(infraRsQosSdIfPol=dict(attributes=dict(
            tnQosSdIfPolName=slow_drain_policy, ), ), ),
        dict(infraRsStormctrlIfPol=dict(attributes=dict(
            tnStormctrlIfPolName=storm_control_interface_policy, ), ), ),
        dict(infraRsStpIfPol=dict(attributes=dict(
            tnStpIfPolName=stp_interface_policy, ), ), ),
    ]

    # Add infraRsattEntP binding only when aep was defined
    if aep is not None:
        child_configs.append(
            dict(infraRsAttEntP=dict(attributes=dict(
                tDn='uni/infra/attentp-{0}'.format(aep), ), ), ))

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class=aci_class_name,
            aci_rn='infra/funcprof/{0}-{1}'.format(dn_name, policy_group),
            module_object=policy_group,
            target_filter={
                'name': policy_group,
                'lagT': lag_type
            },
        ),
        child_classes=[
            'infraRsAttEntP',
            'infraRsCdpIfPol',
            'infraRsFcIfPol',
            'infraRsHIfPol',
            'infraRsL2IfPol',
            'infraRsL2PortSecurityPol',
            'infraRsLacpPol',
            'infraRsLldpIfPol',
            'infraRsMcpIfPol',
            'infraRsMonIfInfraPol',
            'infraRsQosEgressDppIfPol',
            'infraRsQosIngressDppIfPol',
            'infraRsQosPfcIfPol',
            'infraRsQosSdIfPol',
            'infraRsStormctrlIfPol',
            'infraRsStpIfPol',
        ],
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class=aci_class_name,
            class_config=class_config_dict,
            child_configs=child_configs,
        )

        aci.get_diff(aci_class=aci_class_name)

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #19
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        tenant=dict(type='str',
                    aliases=['tenant_name'
                             ]),  # Not required for querying all objects
        ap=dict(type='str',
                aliases=['app_profile', 'app_profile_name'
                         ]),  # Not required for querying all objects
        epg=dict(type='str',
                 aliases=['epg_name'
                          ]),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        encap_id=dict(type='int', aliases=['vlan', 'vlan_id']),
        primary_encap_id=dict(type='int',
                              aliases=['primary_vlan', 'primary_vlan_id']),
        deploy_immediacy=dict(type='str', choices=['immediate', 'lazy']),
        interface_mode=dict(type='str',
                            choices=[
                                '802.1p', 'access', 'native', 'regular',
                                'tagged', 'trunk', 'untagged'
                            ],
                            aliases=['interface_mode_name', 'mode']),
        interface_type=dict(
            type='str',
            default='switch_port',
            choices=['fex', 'port_channel', 'switch_port', 'vpc']),
        pod_id=dict(type='int',
                    aliases=['pod', 'pod_number'
                             ]),  # Not required for querying all objects
        leafs=dict(type='list',
                   aliases=['leaves', 'nodes', 'paths', 'switches'
                            ]),  # Not required for querying all objects
        interface=dict(type='str'),  # Not required for querying all objects
        extpaths=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=[
            ['interface_type', 'fex', ['extpaths']],
            [
                'state', 'absent',
                ['ap', 'epg', 'interface', 'leafs', 'pod_id', 'tenant']
            ],
            [
                'state', 'present',
                [
                    'ap', 'encap_id', 'epg', 'interface', 'leafs', 'pod_id',
                    'tenant'
                ]
            ],
        ],
    )

    tenant = module.params.get('tenant')
    ap = module.params.get('ap')
    epg = module.params.get('epg')
    description = module.params.get('description')
    encap_id = module.params.get('encap_id')
    primary_encap_id = module.params.get('primary_encap_id')
    deploy_immediacy = module.params.get('deploy_immediacy')
    interface_mode = module.params.get('interface_mode')
    interface_type = module.params.get('interface_type')
    pod_id = module.params.get('pod_id')
    leafs = module.params.get('leafs')
    if leafs is not None:
        # Process leafs, and support dash-delimited leafs
        leafs = []
        for leaf in module.params.get('leafs'):
            # Users are likely to use integers for leaf IDs, which would raise an exception when using the join method
            leafs.extend(str(leaf).split('-'))
        if len(leafs) == 1:
            if interface_type == 'vpc':
                module.fail_json(
                    msg='A interface_type of "vpc" requires 2 leafs')
            leafs = leafs[0]
        elif len(leafs) == 2:
            if interface_type != 'vpc':
                module.fail_json(
                    msg=
                    'The interface_types "switch_port", "port_channel", and "fex" \
                    do not support using multiple leafs for a single binding')
            leafs = "-".join(leafs)
        else:
            module.fail_json(
                msg='The "leafs" parameter must not have more than 2 entries')
    interface = module.params.get('interface')
    extpaths = module.params.get('extpaths')
    state = module.params.get('state')

    if encap_id is not None:
        if encap_id not in range(1, 4097):
            module.fail_json(msg='Valid VLAN assigments are from 1 to 4096')
        encap_id = 'vlan-{0}'.format(encap_id)

    if primary_encap_id is not None:
        if primary_encap_id not in range(1, 4097):
            module.fail_json(msg='Valid VLAN assigments are from 1 to 4096')
        primary_encap_id = 'vlan-{0}'.format(primary_encap_id)

    static_path = INTERFACE_TYPE_MAPPING[interface_type].format(
        pod_id=pod_id, leafs=leafs, extpaths=extpaths, interface=interface)

    path_target_filter = {}
    if pod_id is not None and leafs is not None and interface is not None and (
            interface_type != 'fex' or extpaths is not None):
        path_target_filter = {'tDn': static_path}

    if interface_mode is not None:
        interface_mode = INTERFACE_MODE_MAPPING[interface_mode]

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='fvTenant',
            aci_rn='tn-{0}'.format(tenant),
            module_object=tenant,
            target_filter={'name': tenant},
        ),
        subclass_1=dict(
            aci_class='fvAp',
            aci_rn='ap-{0}'.format(ap),
            module_object=ap,
            target_filter={'name': ap},
        ),
        subclass_2=dict(
            aci_class='fvAEPg',
            aci_rn='epg-{0}'.format(epg),
            module_object=epg,
            target_filter={'name': epg},
        ),
        subclass_3=dict(
            aci_class='fvRsPathAtt',
            aci_rn='rspathAtt-[{0}]'.format(static_path),
            module_object=static_path,
            target_filter=path_target_filter,
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='fvRsPathAtt',
            class_config=dict(
                descr=description,
                encap=encap_id,
                primaryEncap=primary_encap_id,
                instrImedcy=deploy_immediacy,
                mode=interface_mode,
                tDn=static_path,
            ),
        )

        aci.get_diff(aci_class='fvRsPathAtt')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #20
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        port_security=dict(
            type='str',
            aliases=['name']),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        max_end_points=dict(type='int'),
        port_security_timeout=dict(type='int'),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['port_security']],
            ['state', 'present', ['port_security']],
        ],
    )

    port_security = module.params.get('port_security')
    description = module.params.get('description')
    max_end_points = module.params.get('max_end_points')
    port_security_timeout = module.params.get('port_security_timeout')
    name_alias = module.params.get('name_alias')
    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')
    if port_security_timeout is not None and port_security_timeout not in range(
            60, 3601):
        module.fail_json(
            msg='The "port_security_timeout" must be between 60 and 3600')
    state = module.params.get('state')

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class='l2PortSecurityPol',
        aci_rn='infra/portsecurityP-{0}'.format(port_security),
        module_object=port_security,
        target_filter={'name': port_security},
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='l2PortSecurityPol',
            class_config=dict(
                name=port_security,
                descr=description,
                maximum=max_end_points,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='l2PortSecurityPol')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #21
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        aaa_password=dict(type='str', no_log=True),
        aaa_password_lifetime=dict(type='int'),
        aaa_password_update_required=dict(type='bool'),
        aaa_user=dict(type='str',
                      aliases=['name'
                               ]),  # Not required for querying all objects
        clear_password_history=dict(type='bool'),
        description=dict(type='str', aliases=['descr']),
        email=dict(type='str'),
        enabled=dict(type='bool'),
        expiration=dict(type='str'),
        expires=dict(type='bool'),
        first_name=dict(type='str'),
        last_name=dict(type='str'),
        phone=dict(type='str'),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['aaa_user']],
            ['state', 'present', ['aaa_user']],
            ['expires', True, ['expiration']],
        ],
    )

    aci = ACIModule(module)

    if not HAS_DATEUTIL:
        module.fail_json(msg='dateutil required for this module')

    aaa_password = module.params.get('aaa_password')
    aaa_password_lifetime = module.params.get('aaa_password_lifetime')
    aaa_password_update_required = aci.boolean(
        module.params.get('aaa_password_update_required'))
    aaa_user = module.params.get('aaa_user')
    clear_password_history = aci.boolean(
        module.params.get('clear_password_history'), 'yes', 'no')
    description = module.params.get('description')
    email = module.params.get('email')
    enabled = aci.boolean(module.params.get('enabled'), 'active', 'inactive')
    expires = aci.boolean(module.params.get('expires'))
    first_name = module.params.get('first_name')
    last_name = module.params.get('last_name')
    phone = module.params.get('phone')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    expiration = module.params.get('expiration')
    if expiration is not None and expiration != 'never':
        try:
            expiration = aci.iso8601_format(
                dateutil.parser.parse(expiration).replace(tzinfo=tzutc()))
        except Exception as e:
            module.fail_json(msg="Failed to parse date format '%s', %s" %
                             (module.params.get('expiration'), e))

    aci.construct_url(root_class=dict(
        aci_class='aaaUser',
        aci_rn='userext/user-{0}'.format(aaa_user),
        module_object=aaa_user,
        target_filter={'name': aaa_user},
    ), )
    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='aaaUser',
            class_config=dict(
                accountStatus=enabled,
                clearPwdHistory=clear_password_history,
                descr=description,
                email=email,
                expiration=expiration,
                expires=expires,
                firstName=first_name,
                lastName=last_name,
                name=aaa_user,
                phone=phone,
                pwd=aaa_password,
                pwdLifeTime=aaa_password_lifetime,
                pwdUpdateRequired=aaa_password_update_required,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='aaaUser')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        port_channel=dict(type='str',
                          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=['active', 'mac-pin', 'mac-pin-nicload', 'off',
                     'passive']),
        fast_select=dict(type='bool'),
        graceful_convergence=dict(type='bool'),
        load_defer=dict(type='bool'),
        suspend_individual=dict(type='bool'),
        symmetric_hash=dict(type='bool'),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['port_channel']],
            ['state', 'present', ['port_channel']],
        ],
    )

    port_channel = module.params.get('port_channel')
    description = module.params.get('description')
    min_links = module.params.get('min_links')
    if min_links is not None and min_links not in range(1, 17):
        module.fail_json(
            msg='The "min_links" must be a value between 1 and 16')
    max_links = module.params.get('max_links')
    if max_links is not None and max_links not in range(1, 17):
        module.fail_json(
            msg='The "max_links" must be a value between 1 and 16')
    mode = module.params.get('mode')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    # Build ctrl value for request
    ctrl = []
    if module.params.get('fast_select') is True:
        ctrl.append('fast-sel-hot-stdby')
    if module.params.get('graceful_convergence') is True:
        ctrl.append('graceful-conv')
    if module.params.get('load_defer') is True:
        ctrl.append('load-defer')
    if module.params.get('suspend_individual') is True:
        ctrl.append('susp-individual')
    if module.params.get('symmetric_hash') is True:
        ctrl.append('symmetric-hash')
    if not ctrl:
        ctrl = None
    else:
        ctrl = ",".join(ctrl)

    aci = ACIModule(module)
    aci.construct_url(root_class=dict(
        aci_class='lacpLagPol',
        aci_rn='infra/lacplagp-{0}'.format(port_channel),
        module_object=port_channel,
        target_filter={'name': port_channel},
    ), )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='lacpLagPol',
            class_config=dict(
                name=port_channel,
                ctrl=ctrl,
                descr=description,
                minLinks=min_links,
                maxLinks=max_links,
                mode=mode,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='lacpLagPol')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #23
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update({
        'description':
        dict(type='str'),
        'leaf_profile':
        dict(type='str', aliases=['leaf_profile_name'
                                  ]),  # Not required for querying all objects
        'leaf':
        dict(type='str',
             aliases=[
                 'name', 'leaf_name', 'leaf_profile_leaf_name',
                 'leaf_selector_name'
             ]),  # Not required for querying all objects
        'leaf_node_blk':
        dict(type='str', aliases=['leaf_node_blk_name', 'node_blk_name']),
        'leaf_node_blk_description':
        dict(type='str'),
        # NOTE: Keyword 'from' is a reserved word in python, so we need it as a string
        'from':
        dict(type='int',
             aliases=['node_blk_range_from', 'from_range', 'range_from']),
        'to':
        dict(type='int', aliases=['node_blk_range_to', 'to_range',
                                  'range_to']),
        'policy_group':
        dict(type='str', aliases=['policy_group_name']),
        'state':
        dict(type='str',
             default='present',
             choices=['absent', 'present', 'query']),
        'name_alias':
        dict(type='str'),
    })

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[['state', 'absent', ['leaf_profile', 'leaf']],
                     [
                         'state', 'present',
                         [
                             'leaf_profile', 'leaf', 'leaf_node_blk', 'from',
                             'to'
                         ]
                     ]])

    description = module.params.get('description')
    leaf_profile = module.params.get('leaf_profile')
    leaf = module.params.get('leaf')
    leaf_node_blk = module.params.get('leaf_node_blk')
    leaf_node_blk_description = module.params.get('leaf_node_blk_description')
    from_ = module.params.get('from')
    to_ = module.params.get('to')
    policy_group = module.params.get('policy_group')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    # Build child_configs dynamically
    child_configs = [
        dict(infraNodeBlk=dict(attributes=dict(
            descr=leaf_node_blk_description,
            name=leaf_node_blk,
            from_=from_,
            to_=to_,
        ), ), ),
    ]

    # Add infraRsAccNodePGrp only when policy_group was defined
    if policy_group is not None:
        child_configs.append(
            dict(infraRsAccNodePGrp=dict(attributes=dict(
                tDn='uni/infra/funcprof/accnodepgrp-{0}'.format(
                    policy_group), ), ), ))

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='infraNodeP',
            aci_rn='infra/nprof-{0}'.format(leaf_profile),
            module_object=leaf_profile,
            target_filter={'name': leaf_profile},
        ),
        subclass_1=dict(
            aci_class='infraLeafS',
            # NOTE: normal rn: leaves-{name}-typ-{type}, hence here hardcoded to range for purposes of module
            aci_rn='leaves-{0}-typ-range'.format(leaf),
            module_object=leaf,
            target_filter={'name': leaf},
        ),
        # NOTE: infraNodeBlk is not made into a subclass because there is a 1-1 mapping between node block and leaf selector name
        child_classes=['infraNodeBlk', 'infraRsAccNodePGrp'],
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='infraLeafS',
            class_config=dict(
                descr=description,
                name=leaf,
                nameAlias=name_alias,
            ),
            child_configs=child_configs,
        )

        aci.get_diff(aci_class='infraLeafS')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #24
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        contract=dict(type='str',
                      aliases=['contract_name'
                               ]),  # Not required for querying all objects
        filter=dict(type='str',
                    aliases=['filter_name'
                             ]),  # Not required for querying all objects
        subject=dict(type='str',
                     aliases=['contract_subject', 'subject_name'
                              ]),  # Not required for querying all objects
        tenant=dict(type='str',
                    aliases=['tenant_name'
                             ]),  # Not required for querying all objects
        log=dict(type='str', choices=['log', 'none'], aliases=['directive']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['contract', 'filter', 'subject', 'tenant']],
            ['state', 'present', ['contract', 'filter', 'subject', 'tenant']],
        ],
    )

    contract = module.params.get('contract')
    filter_name = module.params.get('filter')
    log = module.params.get('log')
    subject = module.params.get('subject')
    tenant = module.params.get('tenant')
    state = module.params.get('state')

    # Add subject_filter key to modul.params for building the URL
    module.params['subject_filter'] = filter_name

    # 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 = ''

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='fvTenant',
            aci_rn='tn-{0}'.format(tenant),
            module_object=tenant,
            target_filter={'name': tenant},
        ),
        subclass_1=dict(
            aci_class='vzBrCP',
            aci_rn='brc-{0}'.format(contract),
            module_object=contract,
            target_filter={'name': contract},
        ),
        subclass_2=dict(
            aci_class='vzSubj',
            aci_rn='subj-{0}'.format(subject),
            module_object=subject,
            target_filter={'name': subject},
        ),
        subclass_3=dict(
            aci_class='vzRsSubjFiltAtt',
            aci_rn='rssubjFiltAtt-{0}'.format(filter_name),
            module_object=filter_name,
            target_filter={'tnVzFilterName': filter_name},
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='vzRsSubjFiltAtt',
            class_config=dict(
                tnVzFilterName=filter_name,
                directives=log,
            ),
        )

        aci.get_diff(aci_class='vzRsSubjFiltAtt')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    # Remove subject_filter used to build URL from module.params
    module.params.pop('subject_filter')

    aci.exit_json()
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        group=dict(type='str', aliases=['group']),  # Not required for querying all objects
        node=dict(type='str', aliases=['node']),
        state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['node', 'group']],
            ['state', 'present', ['node', 'group']],
        ],
    )

    state = module.params.get('state')
    group = module.params.get('group')
    node = module.params.get('node')
    name_alias = module.params.get('name_alias')

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='firmwareFwGrp',
            aci_rn='fabric/fwgrp-{0}'.format(group),
            target_filter={'name': group},
            module_object=group,
        ),
        subclass_1=dict(
            aci_class='fabricNodeBlk',
            aci_rn='nodeblk-blk{0}-{0}'.format(node),
            target_filter={'name': node},
            module_object=node,
        ),

    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='fabricNodeBlk',
            class_config=dict(
                from_=node,
                to_=node,
                nameAlias=name_alias,
            ),


        )

        aci.get_diff(aci_class='fabricNodeBlk')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #26
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        domain_type=dict(type='str', required=True, choices=['fc', 'l2dom', 'l3dom', 'phys', 'vmm'], aliases=['type']),
        domain=dict(type='str', aliases=['domain_name', 'domain_profile', 'name']),  # Not required for querying all objects
        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']),
        encap_mode=dict(type='str', choices=['unknown', 'vlan', 'vxlan']),
        multicast_address=dict(type='str'),
        state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
        vm_provider=dict(type='str', choices=['cloudfoundry', 'kubernetes', 'microsoft', 'openshift', 'openstack', 'redhat', 'vmware']),
        vswitch=dict(type='str', choices=['avs', 'default', 'dvs', 'unknown']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['domain_type', 'vmm', ['vm_provider']],
            ['state', 'absent', ['domain', 'domain_type']],
            ['state', 'present', ['domain', 'domain_type']],
        ],
    )

    dscp = module.params.get('dscp')
    domain = module.params.get('domain')
    domain_type = module.params.get('domain_type')
    encap_mode = module.params.get('encap_mode')
    multicast_address = module.params.get('multicast_address')
    vm_provider = module.params.get('vm_provider')
    vswitch = module.params.get('vswitch')
    if vswitch is not None:
        vswitch = VSWITCH_MAPPING.get(vswitch)
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    if domain_type != 'vmm':
        if vm_provider is not None:
            module.fail_json(msg="Domain type '{0}' cannot have parameter 'vm_provider'".format(domain_type))
        if encap_mode is not None:
            module.fail_json(msg="Domain type '{0}' cannot have parameter 'encap_mode'".format(domain_type))
        if multicast_address is not None:
            module.fail_json(msg="Domain type '{0}' cannot have parameter 'multicast_address'".format(domain_type))
        if vswitch is not None:
            module.fail_json(msg="Domain type '{0}' cannot have parameter 'vswitch'".format(domain_type))

    if dscp is not None and domain_type not in ['l2dom', 'l3dom']:
        module.fail_json(msg="DSCP values can only be assigned to 'l2ext and 'l3ext' domains")

    # Compile the full domain for URL building
    if domain_type == 'fc':
        domain_class = 'fcDomP'
        domain_mo = 'uni/fc-{0}'.format(domain)
        domain_rn = 'fc-{0}'.format(domain)
    elif domain_type == 'l2dom':
        domain_class = 'l2extDomP'
        domain_mo = 'uni/l2dom-{0}'.format(domain)
        domain_rn = 'l2dom-{0}'.format(domain)
    elif domain_type == 'l3dom':
        domain_class = 'l3extDomP'
        domain_mo = 'uni/l3dom-{0}'.format(domain)
        domain_rn = 'l3dom-{0}'.format(domain)
    elif domain_type == 'phys':
        domain_class = 'physDomP'
        domain_mo = 'uni/phys-{0}'.format(domain)
        domain_rn = 'phys-{0}'.format(domain)
    elif domain_type == 'vmm':
        domain_class = 'vmmDomP'
        domain_mo = 'uni/vmmp-{0}/dom-{1}'.format(VM_PROVIDER_MAPPING.get(vm_provider), domain)
        domain_rn = 'vmmp-{0}/dom-{1}'.format(VM_PROVIDER_MAPPING.get(vm_provider), domain)

    # Ensure that querying all objects works when only domain_type is provided
    if domain is None:
        domain_mo = None

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class=domain_class,
            aci_rn=domain_rn,
            module_object=domain_mo,
            target_filter={'name': domain},
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class=domain_class,
            class_config=dict(
                encapMode=encap_mode,
                mcastAddr=multicast_address,
                mode=vswitch,
                name=domain,
                targetDscp=dscp,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class=domain_class)

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        l2_policy=dict(type='str', 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='bool'),
        state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['l2_policy']],
            ['state', 'present', ['l2_policy']],
        ],
    )

    aci = ACIModule(module)

    l2_policy = module.params.get('l2_policy')
    vlan_scope = module.params.get('vlan_scope')
    qinq = module.params.get('qinq')
    if qinq is not None:
        qinq = QINQ_MAPPING.get(qinq)
    vepa = aci.boolean(module.params.get('vepa'), 'enabled', 'disabled')
    description = module.params.get('description')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    aci.construct_url(
        root_class=dict(
            aci_class='l2IfPol',
            aci_rn='infra/l2IfP-{0}'.format(l2_policy),
            module_object=l2_policy,
            target_filter={'name': l2_policy},
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='l2IfPol',
            class_config=dict(
                name=l2_policy,
                descr=description,
                vlanScope=vlan_scope,
                qinq=qinq, vepa=vepa,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='l2IfPol')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #28
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        leaf_interface_profile=dict(
            type='str', aliases=['leaf_interface_profile_name'
                                 ]),  # Not required for querying all objects
        access_port_selector=dict(type='str',
                                  aliases=[
                                      'name', 'access_port_selector_name'
                                  ]),  # Not required for querying all objects
        description=dict(type='str'),
        leaf_port_blk=dict(type='str', aliases=['leaf_port_blk_name']),
        leaf_port_blk_description=dict(type='str'),
        from_port=dict(type='str',
                       aliases=['from', 'fromPort', 'from_port_range']),
        to_port=dict(type='str', aliases=['to', 'toPort', 'to_port_range']),
        from_card=dict(type='str', aliases=['from_card_range']),
        to_card=dict(type='str', aliases=['to_card_range']),
        policy_group=dict(type='str', aliases=['policy_group_name']),
        interface_type=dict(
            type='str',
            default='switch_port',
            choices=['breakout', 'fex', 'port_channel', 'switch_port', 'vpc']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            [
                'state', 'absent',
                ['leaf_interface_profile', 'access_port_selector']
            ],
            [
                'state', 'present',
                ['leaf_interface_profile', 'access_port_selector']
            ],
        ],
    )

    leaf_interface_profile = module.params.get('leaf_interface_profile')
    access_port_selector = module.params.get('access_port_selector')
    description = module.params.get('description')
    leaf_port_blk = module.params.get('leaf_port_blk')
    leaf_port_blk_description = module.params.get('leaf_port_blk_description')
    from_port = module.params.get('from_port')
    to_port = module.params.get('to_port')
    from_card = module.params.get('from_card')
    to_card = module.params.get('to_card')
    policy_group = module.params.get('policy_group')
    interface_type = module.params.get('interface_type')
    state = module.params.get('state')

    # Build child_configs dynamically
    child_configs = [
        dict(infraPortBlk=dict(attributes=dict(
            descr=leaf_port_blk_description,
            name=leaf_port_blk,
            fromPort=from_port,
            toPort=to_port,
            fromCard=from_card,
            toCard=to_card,
        ), ), )
    ]

    # Add infraRsAccBaseGrp only when policy_group was defined
    if policy_group is not None:
        child_configs.append(
            dict(infraRsAccBaseGrp=dict(attributes=dict(
                tDn=INTERFACE_TYPE_MAPPING[interface_type].format(
                    policy_group), ), ), ))

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='infraAccPortP',
            aci_rn='infra/accportprof-{0}'.format(leaf_interface_profile),
            module_object=leaf_interface_profile,
            target_filter={'name': leaf_interface_profile},
        ),
        subclass_1=dict(
            aci_class='infraHPortS',
            # NOTE: normal rn: hports-{name}-typ-{type}, hence here hardcoded to range for purposes of module
            aci_rn='hports-{0}-typ-range'.format(access_port_selector),
            module_object=access_port_selector,
            target_filter={'name': access_port_selector},
        ),
        child_classes=['infraPortBlk', 'infraRsAccBaseGrp'],
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='infraHPortS',
            class_config=dict(
                descr=description,
                name=access_port_selector,
                #  type='range',
            ),
            child_configs=child_configs,
        )

        aci.get_diff(aci_class='infraHPortS')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #29
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        pool=dict(type='str',
                  aliases=['pool_name'
                           ]),  # Not required for querying all objects
        block_name=dict(type='str',
                        aliases=['name'
                                 ]),  # Not required for querying all objects
        block_end=dict(type='int',
                       aliases=['end'
                                ]),  # Not required for querying all objects
        block_start=dict(type='int',
                         aliases=["start"
                                  ]),  # Not required for querying all objects
        allocation_mode=dict(type='str',
                             aliases=['mode'],
                             choices=['dynamic', 'inherit', 'static']),
        description=dict(type='str', aliases=['descr']),
        pool_allocation_mode=dict(type='str',
                                  aliases=['pool_mode'],
                                  choices=['dynamic', 'static']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            [
                'state', 'absent',
                ['pool', 'block_end', 'block_name', 'block_start']
            ],
            [
                'state', 'present',
                ['pool', 'block_end', 'block_name', 'block_start']
            ],
        ],
    )

    allocation_mode = module.params.get('allocation_mode')
    description = module.params.get('description')
    pool = module.params.get('pool')
    pool_allocation_mode = module.params.get('pool_allocation_mode')
    block_end = module.params.get('block_end')
    block_name = module.params.get('block_name')
    block_start = module.params.get('block_start')
    state = module.params.get('state')
    name_alias = module.params.get('name_alias')

    if block_end is not None:
        encap_end = 'vlan-{0}'.format(block_end)
    else:
        encap_end = None

    if block_start is not None:
        encap_start = 'vlan-{0}'.format(block_start)
    else:
        encap_start = None

    # Collect proper mo information
    aci_block_mo = 'from-[{0}]-to-[{1}]'.format(encap_start, encap_end)
    pool_name = pool

    # Validate block_end and block_start are valid for its respective encap type
    for encap_id in block_end, block_start:
        if encap_id is not None:
            if not 1 <= encap_id <= 4094:
                module.fail_json(
                    msg=
                    "vlan pools must have 'block_start' and 'block_end' values between 1 and 4094"
                )

    if block_end is not None and block_start is not None:
        # Validate block_start is less than block_end
        if block_start > block_end:
            module.fail_json(
                msg=
                "The 'block_start' must be less than or equal to the 'block_end'"
            )

    elif block_end is None and block_start is None:
        if block_name is None:
            # Reset range managed object to None for aci util to properly handle query
            aci_block_mo = None

    # ACI Pool URL requires the allocation mode (ex: uni/infra/vlanns-[poolname]-static)
    if pool is not None:
        if pool_allocation_mode is not None:
            pool_name = '[{0}]-{1}'.format(pool, pool_allocation_mode)
        else:
            module.fail_json(
                msg=
                "ACI requires the 'pool_allocation_mode' when 'pool' is provided"
            )

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='fvnsVlanInstP',
            aci_rn='infra/vlanns-{0}'.format(pool_name),
            module_object=pool,
            target_filter={'name': pool},
        ),
        subclass_1=dict(
            aci_class='fvnsEncapBlk',
            aci_rn=aci_block_mo,
            module_object=aci_block_mo,
            target_filter={
                'from': encap_start,
                'to': encap_end,
                'name': block_name
            },
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='fvnsEncapBlk',
            class_config={
                "allocMode": allocation_mode,
                "descr": description,
                "from": encap_start,
                "name": block_name,
                "to": encap_end,
                "nameAlias": name_alias,
            },
        )

        aci.get_diff(aci_class='fvnsEncapBlk')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()
Beispiel #30
0
def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        tenant=dict(type='str',
                    aliases=['tenant_name'
                             ]),  # Not required for querying all objects
        vrf=dict(type='str',
                 aliases=['context', 'name', 'vrf_name'
                          ]),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        policy_control_direction=dict(type='str',
                                      choices=['egress', 'ingress']),
        policy_control_preference=dict(type='str',
                                       choices=['enforced', 'unenforced']),
        state=dict(type='str',
                   default='present',
                   choices=['absent', 'present', 'query']),
        name_alias=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['tenant', 'vrf']],
            ['state', 'present', ['tenant', 'vrf']],
        ],
    )

    description = module.params.get('description')
    policy_control_direction = module.params.get('policy_control_direction')
    policy_control_preference = module.params.get('policy_control_preference')
    state = module.params.get('state')
    tenant = module.params.get('tenant')
    vrf = module.params.get('vrf')
    name_alias = module.params.get('name_alias')

    aci = ACIModule(module)
    aci.construct_url(
        root_class=dict(
            aci_class='fvTenant',
            aci_rn='tn-{0}'.format(tenant),
            module_object=tenant,
            target_filter={'name': tenant},
        ),
        subclass_1=dict(
            aci_class='fvCtx',
            aci_rn='ctx-{0}'.format(vrf),
            module_object=vrf,
            target_filter={'name': vrf},
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='fvCtx',
            class_config=dict(
                descr=description,
                pcEnfDir=policy_control_direction,
                pcEnfPref=policy_control_preference,
                name=vrf,
                nameAlias=name_alias,
            ),
        )

        aci.get_diff(aci_class='fvCtx')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()