Beispiel #1
0
def main():
    module_args = dict(vrf_name=dict(type='str', default='default'),
                       interface_list=dict(type='list', required=True),
                       state=dict(default='create',
                                  choices=['create', 'delete', 'update']))

    aruba_ansible_module = ArubaAnsibleModule(module_args)

    vrf_name = aruba_ansible_module.module.params['vrf_name']
    vrf_interface_list = aruba_ansible_module.module.params['interface_list']
    state = aruba_ansible_module.module.params['state']

    l3_interface = L3_Interface()

    if state == 'create' or state == 'update':
        update_type = 'insert'
    else:
        update_type = 'delete'

    for interface_name in vrf_interface_list:
        error = ("Interface {} is configured as L2 or L3 interface in VRF\n"
                 "Delete interface from configuration then recreate with "
                 "desired VRF".format(interface_name))
        if not l3_interface.check_if_l3_interface_possible(
                aruba_ansible_module, interface_name):  # NOQA
            aruba_ansible_module.module.fail_json(msg=error)

        aruba_ansible_module = l3_interface.update_interface_vrf_details_from_vrf(
            aruba_ansible_module, vrf_name, interface_name,
            update_type)  # NOQA

    aruba_ansible_module.update_switch_config()
def main():
    module_args = dict(interface=dict(type='str', required=True),
                       admin_state=dict(default='up', choices=['up', 'down']),
                       description=dict(type='str', default=None),
                       ipv4=dict(type='list', default=None),
                       ipv6=dict(type='list', default=None),
                       interface_qos_rate=dict(type='dict', default=None),
                       interface_qos_schedule_profile=dict(type='dict',
                                                           default=None),
                       vrf=dict(type='str', default=None),
                       ip_helper_address=dict(type='list', default=None),
                       state=dict(default='create',
                                  choices=['create', 'delete', 'update']))

    aruba_ansible_module = ArubaAnsibleModule(module_args)

    interface_name = aruba_ansible_module.module.params['interface']
    admin_state = aruba_ansible_module.module.params['admin_state']
    description = aruba_ansible_module.module.params['description']
    ipv4 = aruba_ansible_module.module.params['ipv4']
    ipv6 = aruba_ansible_module.module.params['ipv6']
    interface_qos_rate = aruba_ansible_module.module.params[
        'interface_qos_rate']  # NOQA
    interface_qos_schedule_profile = aruba_ansible_module.module.params[
        'interface_qos_schedule_profile']
    vrf = aruba_ansible_module.module.params['vrf']
    ip_helper_address = aruba_ansible_module.module.params['ip_helper_address']

    state = aruba_ansible_module.module.params['state']

    l3_interface = L3_Interface()
    interface = Interface()
    if state == 'create':
        aruba_ansible_module = l3_interface.create_l3_interface(
            aruba_ansible_module, interface_name)  # NOQA
        if vrf is None:
            vrf = "default"

        if vrf is not None:
            aruba_ansible_module = l3_interface.update_interface_vrf_details_from_l3(
                aruba_ansible_module, vrf, interface_name)  # NOQA

    if state == 'delete':
        aruba_ansible_module = l3_interface.delete_l3_interface(
            aruba_ansible_module, interface_name)

    if (state == 'update') or (state == 'create'):

        if admin_state is not None:
            aruba_ansible_module = interface.update_interface_admin_state(
                aruba_ansible_module, interface_name, admin_state)

        if description is not None:
            aruba_ansible_module = interface.update_interface_description(
                aruba_ansible_module, interface_name, description)

        if vrf is not None and vrf != "default":
            aruba_ansible_module = l3_interface.update_interface_vrf_details_from_l3(
                aruba_ansible_module, vrf, interface_name)  # NOQA

        if interface_qos_rate is not None:
            aruba_ansible_module = l3_interface.update_interface_qos_rate(
                aruba_ansible_module, interface_name, interface_qos_rate)

        if interface_qos_schedule_profile is not None:
            aruba_ansible_module = l3_interface.update_interface_qos_profile(
                aruba_ansible_module, interface_name,
                interface_qos_schedule_profile)  # NOQA

        if ipv4 is not None:
            aruba_ansible_module = l3_interface.update_interface_ipv4_address(
                aruba_ansible_module, interface_name, ipv4)  # NOQA

        if ipv6 is not None:
            aruba_ansible_module = l3_interface.update_interface_ipv6_address(
                aruba_ansible_module, interface_name, ipv6)  # NOQA

        if ip_helper_address is not None:
            if vrf is not None:
                vrf = 'default'
            aruba_ansible_module = l3_interface.update_interface_ip_helper_address(
                aruba_ansible_module, vrf, interface_name,
                ip_helper_address)  # NOQA

    aruba_ansible_module.update_switch_config()
def main():
    module_args = dict(
        vlan_id=dict(type='str', required=True),
        admin_state=dict(type='str', required=False, choices=['up', 'down']),
        state=dict(default='create', choices=['create', 'delete', 'update']),
        ipv4=dict(type='list', default=None),
        description=dict(type='str', default=None),
        ipv6=dict(type='list', default=None),
        vrf=dict(type='str', default=None),
        ip_helper_address=dict(type='list', default=None),
        active_gateway_ip=dict(type='str', default=None),
        active_gateway_mac_v4=dict(type='str', default=None),
    )

    aruba_ansible_module = ArubaAnsibleModule(module_args)

    vlan_id = aruba_ansible_module.module.params['vlan_id']
    admin_state = aruba_ansible_module.module.params['admin_state']
    ipv4 = aruba_ansible_module.module.params['ipv4']
    ipv6 = aruba_ansible_module.module.params['ipv6']
    vrf = aruba_ansible_module.module.params['vrf']
    description = aruba_ansible_module.module.params['description']
    ip_helper_address = aruba_ansible_module.module.params['ip_helper_address']
    active_gateway_ip = aruba_ansible_module.module.params['active_gateway_ip']
    active_gateway_mac_v4 = aruba_ansible_module.module.params[
        'active_gateway_mac_v4']  # NOQA
    state = aruba_ansible_module.module.params['state']

    vlan = VLAN()
    port = Port()
    interface = Interface()
    vlan_interface_id = "vlan" + vlan_id
    if not vlan.check_vlan_exist(aruba_ansible_module, vlan_id):
        aruba_ansible_module.module.fail_json(msg="VLAN {} does not exist. "
                                              "VLAN needs to be created "
                                              "before adding or deleting "
                                              "interfaces".format(vlan_id))

    if state == 'create':
        aruba_ansible_module = port.create_port(aruba_ansible_module,
                                                vlan_interface_id)
        aruba_ansible_module = interface.create_interface(
            aruba_ansible_module, vlan_interface_id)

        if admin_state is None:
            admin_state = 'up'

        user_config = {
            "admin": admin_state,
        }

        interface_fields = {
            "name": vlan_interface_id,
            "type": "vlan",
            "user_config": user_config
        }
        aruba_ansible_module = interface.update_interface_fields(
            aruba_ansible_module, vlan_interface_id, interface_fields)  # NOQA

        if vrf is not None:
            vrf_name = vrf
        else:
            vrf_name = "default"

        port_fields = {
            "interfaces": [vlan_interface_id],
            "vlan_tag": vlan_id,
            "vrf": vrf_name,
            "admin": admin_state
        }
        aruba_ansible_module = port.update_port_fields(aruba_ansible_module,
                                                       vlan_interface_id,
                                                       port_fields)

    if (state == 'create') or (state == 'update'):

        if not port.check_port_exists(aruba_ansible_module, vlan_interface_id):
            aruba_ansible_module.module.fail_json(msg="VLAN interface does not"
                                                  " exist")

        if admin_state is not None:
            port_fields = {"admin": admin_state}
            user_config = {"admin": admin_state}
            interface_fields = {"user_config": user_config}

        aruba_ansible_module = port.update_port_fields(aruba_ansible_module,
                                                       vlan_interface_id,
                                                       port_fields)
        aruba_ansible_module = interface.update_interface_fields(
            aruba_ansible_module, vlan_interface_id, interface_fields)  # NOQA

        if description is not None:
            port_fields = {"description": description}

            aruba_ansible_module = port.update_port_fields(
                aruba_ansible_module, vlan_interface_id, port_fields)  # NOQA

        if ipv4 is not None:
            l3_interface = L3_Interface()
            aruba_ansible_module = l3_interface.update_interface_ipv4_address(
                aruba_ansible_module, vlan_interface_id, ipv4)  # NOQA

        if ipv6 is not None:
            l3_interface = L3_Interface()
            aruba_ansible_module = l3_interface.update_interface_ipv6_address(
                aruba_ansible_module, vlan_interface_id, ipv6)  # NOQA

        if ip_helper_address is not None:
            l3_interface = L3_Interface()
            if vrf is None:
                vrf = "default"
            aruba_ansible_module = l3_interface.update_interface_ip_helper_address(
                aruba_ansible_module, vrf, vlan_interface_id,
                ip_helper_address)  # NOQA

        if vrf is not None:
            l3_interface = L3_Interface()
            aruba_ansible_module = l3_interface.update_interface_vrf_details_from_l3(
                aruba_ansible_module,
                vrf,
                vlan_interface_id,
                update_type="insert")  # NOQA

        if (active_gateway_ip is not None) and (active_gateway_mac_v4 is None):
            aruba_ansible_module.module.fail_json(
                msg=
                " Both active_gateway_ip and active_gateway_mac_v4 are required for configure active gateway."
            )  # NOQA
        elif (active_gateway_ip is None) and (active_gateway_mac_v4
                                              is not None):  # NOQA
            aruba_ansible_module.module.fail_json(
                msg=
                " Both active_gateway_ip and active_gateway_mac_v4 are required for configure active gateway."
            )  # NOQA
        elif (active_gateway_ip is not None) and (active_gateway_mac_v4
                                                  is not None):  # NOQA
            port_fields = {
                "vsx_virtual_ip4": active_gateway_ip,
                "vsx_virtual_gw_mac_v4": active_gateway_mac_v4
            }
            aruba_ansible_module = port.update_port_fields(
                aruba_ansible_module, vlan_interface_id, port_fields)  # NOQA

    if state == 'delete':
        aruba_ansible_module = port.delete_port(aruba_ansible_module,
                                                vlan_interface_id)
        aruba_ansible_module = interface.delete_interface(
            aruba_ansible_module, vlan_interface_id)

    aruba_ansible_module.update_switch_config()
Beispiel #4
0
def main():
    module_args = dict(
        vlan_id=dict(type='str', required=True),
        admin_state=dict(type='str', required=False, choices=['up', 'down']),
        state=dict(default='create', choices=['create', 'delete', 'update']),
        ipv4=dict(type='list', default=None),
        description=dict(type='str', default=None),
        ipv6=dict(type='list', default=None),
        vrf=dict(type='str', default=None),
        ip_helper_address=dict(type='list', default=None),
        active_gateway_ip=dict(type='str', default=None),
        active_gateway_mac_v4=dict(type='str', default=None),
    )

    # Version management
    try:
        from ansible.module_utils.aoscx_pyaoscx import Session
        from pyaoscx.session import Session as Pyaoscx_Session
        from pyaoscx.device import Device

        USE_PYAOSCX_SDK = True

    except ImportError:

        USE_PYAOSCX_SDK = False

    if USE_PYAOSCX_SDK:
        from ansible.module_utils.basic import AnsibleModule

        # ArubaModule
        ansible_module = AnsibleModule(argument_spec=module_args,
                                       supports_check_mode=True)

        vlan_id = ansible_module.params['vlan_id']
        admin_state = ansible_module.params['admin_state']
        ipv4 = ansible_module.params['ipv4']
        ipv6 = ansible_module.params['ipv6']
        vrf = ansible_module.params['vrf']
        description = ansible_module.params['description']
        ip_helper_address = ansible_module.params['ip_helper_address']  # NOQA
        active_gateway_ip = ansible_module.params['active_gateway_ip']
        active_gateway_mac_v4 = ansible_module.params['active_gateway_mac_v4']
        state = ansible_module.params['state']

        # Set IP variable as empty arrays
        if ipv4 == ['']:
            ipv4 = []
        if ipv6 == ['']:
            ipv6 = []

        # Session
        session = Session(ansible_module)

        # Set variables
        vlan_interface_id = "vlan" + vlan_id
        if admin_state is None:
            admin_state = 'up'
        if vrf is not None:
            vrf_name = vrf
        else:
            vrf_name = "default"

        # Set result var
        result = dict(changed=False)

        if ansible_module.check_mode:
            ansible_module.exit_json(**result)

        # Get session serialized information
        session_info = session.get_session()
        # Create pyaoscx.session object
        s = Pyaoscx_Session.from_session(session_info['s'],
                                         session_info['url'])

        # Create a Device Object
        device = Device(s)

        if state == 'delete':
            # Create Interface Object
            vlan_interface = device.interface(vlan_interface_id)
            # Delete it
            vlan_interface.delete()
            # Changed
            result['changed'] = True

        if state == 'create' or state == 'update':
            # Create Interface with incoming attributes
            vlan_interface = device.interface(vlan_interface_id)
            # Verify if interface was create
            if vlan_interface.was_modified():
                # Changed
                result['changed'] = True

            # Configure SVI
            # Verify if object was changed
            modified_op = vlan_interface.configure_svi(vlan=int(vlan_id),
                                                       ipv4=ipv4,
                                                       ipv6=ipv6,
                                                       vrf=vrf,
                                                       description=description,
                                                       user_config=admin_state)

            if active_gateway_ip is not None and active_gateway_mac_v4 is not None:
                modified_op2 = vlan_interface.set_active_gateaway(
                    active_gateway_ip, active_gateway_mac_v4)
                modified_op = modified_op2 or modified_op

            if ip_helper_address is not None:
                # Create DHCP_Relay object
                dhcp_relay = device.dhcp_relay(vrf=vrf, port=vlan_interface_id)
                # Add helper addresses
                modified_dhcp_relay = dhcp_relay.add_ipv4_addresses(
                    ip_helper_address)
                modified_op = modified_op or modified_dhcp_relay

            if modified_op:
                # Changed
                result['changed'] = True

        # Exit
        ansible_module.exit_json(**result)

    # Use Older version
    else:
        aruba_ansible_module = ArubaAnsibleModule(module_args)

        vlan_id = aruba_ansible_module.module.params['vlan_id']
        admin_state = aruba_ansible_module.module.params['admin_state']
        ipv4 = aruba_ansible_module.module.params['ipv4']
        ipv6 = aruba_ansible_module.module.params['ipv6']
        vrf = aruba_ansible_module.module.params['vrf']
        description = aruba_ansible_module.module.params['description']
        ip_helper_address = aruba_ansible_module.module.params[
            'ip_helper_address']
        active_gateway_ip = aruba_ansible_module.module.params[
            'active_gateway_ip']
        active_gateway_mac_v4 = aruba_ansible_module.module.params[
            'active_gateway_mac_v4']  # NOQA
        state = aruba_ansible_module.module.params['state']

        vlan = VLAN()
        port = Port()
        interface = Interface()
        vlan_interface_id = "vlan" + vlan_id
        if not vlan.check_vlan_exist(aruba_ansible_module, vlan_id):
            aruba_ansible_module.module.fail_json(
                msg="VLAN {id} does not exist. "
                "VLAN needs to be created "
                "before adding or deleting "
                "interfaces"
                "".format(id=vlan_id))

        if state == 'create':
            aruba_ansible_module = port.create_port(aruba_ansible_module,
                                                    vlan_interface_id)
            aruba_ansible_module = interface.create_interface(
                aruba_ansible_module, vlan_interface_id, type='vlan')

            if admin_state is None:
                admin_state = 'up'

            user_config = {
                "admin": admin_state,
            }

            interface_fields = {
                "name": vlan_interface_id,
                "type": "vlan",
                "user_config": user_config
            }
            aruba_ansible_module = interface.update_interface_fields(
                aruba_ansible_module, vlan_interface_id,
                interface_fields)  # NOQA

            if vrf is not None:
                vrf_name = vrf
            else:
                vrf_name = "default"

            port_fields = {
                "interfaces": [vlan_interface_id],
                "vlan_tag": vlan_id,
                "vrf": vrf_name,
                "admin": admin_state
            }
            aruba_ansible_module = port.update_port_fields(
                aruba_ansible_module, vlan_interface_id, port_fields)

        if (state == 'create') or (state == 'update'):

            if not port.check_port_exists(aruba_ansible_module,
                                          vlan_interface_id):
                aruba_ansible_module.module.fail_json(
                    msg="VLAN interface does not"
                    " exist")

            if admin_state is not None:
                port_fields = {"admin": admin_state}
                user_config = {"admin": admin_state}
                interface_fields = {"user_config": user_config}

            aruba_ansible_module = port.update_port_fields(
                aruba_ansible_module, vlan_interface_id, port_fields)
            aruba_ansible_module = interface.update_interface_fields(
                aruba_ansible_module, vlan_interface_id,
                interface_fields)  # NOQA

            if description is not None:
                port_fields = {"description": description}

                aruba_ansible_module = port.update_port_fields(
                    aruba_ansible_module, vlan_interface_id,
                    port_fields)  # NOQA

            if ipv4 is not None:
                l3_interface = L3_Interface()
                aruba_ansible_module = l3_interface.update_interface_ipv4_address(
                    aruba_ansible_module, vlan_interface_id, ipv4)  # NOQA

            if ipv6 is not None:
                l3_interface = L3_Interface()
                aruba_ansible_module = l3_interface.update_interface_ipv6_address(
                    aruba_ansible_module, vlan_interface_id, ipv6)  # NOQA

            if ip_helper_address is not None:
                l3_interface = L3_Interface()
                if vrf is None:
                    vrf = "default"
                aruba_ansible_module = l3_interface.update_interface_ip_helper_address(
                    aruba_ansible_module, vrf, vlan_interface_id,
                    ip_helper_address)  # NOQA

            if vrf is not None:
                l3_interface = L3_Interface()
                aruba_ansible_module = l3_interface.update_interface_vrf_details_from_l3(
                    aruba_ansible_module,
                    vrf,
                    vlan_interface_id,
                    update_type="insert")  # NOQA

            if (active_gateway_ip
                    is not None) and (active_gateway_mac_v4 is None):
                aruba_ansible_module.module.fail_json(
                    msg=
                    " Both active_gateway_ip and active_gateway_mac_v4 are required for configure active gateway."
                )  # NOQA
            elif (active_gateway_ip is None) and (active_gateway_mac_v4
                                                  is not None):  # NOQA
                aruba_ansible_module.module.fail_json(
                    msg=
                    " Both active_gateway_ip and active_gateway_mac_v4 are required for configure active gateway."
                )  # NOQA
            elif (active_gateway_ip is not None) and (active_gateway_mac_v4
                                                      is not None):  # NOQA
                port_fields = {
                    "vsx_virtual_ip4": active_gateway_ip,
                    "vsx_virtual_gw_mac_v4": active_gateway_mac_v4
                }
                aruba_ansible_module = port.update_port_fields(
                    aruba_ansible_module, vlan_interface_id,
                    port_fields)  # NOQA

        if state == 'delete':
            aruba_ansible_module = port.delete_port(aruba_ansible_module,
                                                    vlan_interface_id)
            aruba_ansible_module = interface.delete_interface(
                aruba_ansible_module, vlan_interface_id, type='vlan')

        aruba_ansible_module.update_switch_config()
def main():
    module_args = dict(interface=dict(type='str', required=True),
                       description=dict(type='str', default=None),
                       ipv4=dict(type='list', default=None),
                       ipv6=dict(type='list', default=None),
                       interface_qos_schedule_profile=dict(type='dict',
                                                           default=None),
                       interface_qos_rate=dict(type='dict', default=None),
                       vrf=dict(type='str', default=None),
                       ip_helper_address=dict(type='list', default=None),
                       state=dict(default='create',
                                  choices=['create', 'delete', 'update']))

    if USE_PYAOSCX_SDK:
        ansible_module = AnsibleModule(argument_spec=module_args,
                                       supports_check_mode=True)

        interface_name = ansible_module.params['interface']
        description = ansible_module.params['description']
        ipv4 = ansible_module.params['ipv4']
        ipv6 = ansible_module.params['ipv6']
        vrf = ansible_module.params['vrf']
        ip_helper_addresses = ansible_module.params['ip_helper_address']
        state = ansible_module.params['state']

        # Set IP variable as empty arrays
        if ipv4 == ['']:
            ipv4 = []
        if ipv6 == ['']:
            ipv6 = []

        # Set Variables
        if vrf is None:
            vrf = 'default'

        # Set result var
        result = dict(changed=False)

        if ansible_module.check_mode:
            ansible_module.exit_json(**result)

        session = get_pyaoscx_session(ansible_module)
        device = Device(session)
        if state == 'delete':
            # Create Interface Object
            interface = device.interface(interface_name)
            # Delete it
            interface.delete()

            # Changed
            result['changed'] = True
        else:
            # Create Interface Object
            interface = device.interface(interface_name)
            # Verify if interface was create
            if interface.was_modified():
                # Changed
                result['changed'] = True
            # Configure L4
            # Verify if object was changed
            modified_op = interface.configure_l3(ipv4=ipv4,
                                                 ipv6=ipv6,
                                                 vrf=vrf,
                                                 description=description)

            if ip_helper_addresses is not None:
                # Create DHCP_Relay object
                dhcp_relay = device.dhcp_relay(vrf=vrf, port=interface_name)
                # Add helper addresses
                dhcp_relay.add_ipv4_addresses(ip_helper_addresses)

            if modified_op:
                # Changed
                result['changed'] = True

        # Exit
        ansible_module.exit_json(**result)

    # Use Older version
    else:

        aruba_ansible_module = ArubaAnsibleModule(module_args)

        interface_name = aruba_ansible_module.module.params['interface']
        admin_state = aruba_ansible_module.module.params['admin_state']
        description = aruba_ansible_module.module.params['description']
        ipv4 = aruba_ansible_module.module.params['ipv4']
        ipv6 = aruba_ansible_module.module.params['ipv6']
        interface_qos_rate = aruba_ansible_module.module.params[
            'interface_qos_rate']  # NOQA
        interface_qos_schedule_profile = aruba_ansible_module.module.params[
            'interface_qos_schedule_profile']
        vrf = aruba_ansible_module.module.params['vrf']
        ip_helper_address = aruba_ansible_module.module.params[
            'ip_helper_address']

        state = aruba_ansible_module.module.params['state']

        l3_interface = L3_Interface()
        interface = Interface()
        if state == 'create':
            aruba_ansible_module = l3_interface.create_l3_interface(
                aruba_ansible_module, interface_name)  # NOQA
            if vrf is None:
                vrf = "default"

            if vrf is not None:
                aruba_ansible_module = l3_interface.update_interface_vrf_details_from_l3(
                    aruba_ansible_module, vrf, interface_name)  # NOQA

        if state == 'delete':
            aruba_ansible_module = l3_interface.delete_l3_interface(
                aruba_ansible_module, interface_name)

        if (state == 'update') or (state == 'create'):

            if admin_state is not None:
                aruba_ansible_module = interface.update_interface_admin_state(
                    aruba_ansible_module, interface_name, admin_state)

            if description is not None:
                aruba_ansible_module = interface.update_interface_description(
                    aruba_ansible_module, interface_name, description)

            if vrf is not None and vrf != "default":
                aruba_ansible_module = l3_interface.update_interface_vrf_details_from_l3(
                    aruba_ansible_module, vrf, interface_name)  # NOQA

            if interface_qos_rate is not None:
                aruba_ansible_module = l3_interface.update_interface_qos_rate(
                    aruba_ansible_module, interface_name, interface_qos_rate)

            if interface_qos_schedule_profile is not None:
                aruba_ansible_module = l3_interface.update_interface_qos_profile(
                    aruba_ansible_module, interface_name,
                    interface_qos_schedule_profile)  # NOQA

            if ipv4 is not None:
                aruba_ansible_module = l3_interface.update_interface_ipv4_address(
                    aruba_ansible_module, interface_name, ipv4)  # NOQA

            if ipv6 is not None:
                aruba_ansible_module = l3_interface.update_interface_ipv6_address(
                    aruba_ansible_module, interface_name, ipv6)  # NOQA

            if ip_helper_address is not None:
                if vrf is not None:
                    vrf = 'default'
                aruba_ansible_module = l3_interface.update_interface_ip_helper_address(
                    aruba_ansible_module, vrf, interface_name,
                    ip_helper_address)  # NOQA

        aruba_ansible_module.update_switch_config()