def update_interface_vrf_details_from_vrf(self, aruba_ansible_module, vrf_name, interface_name, update_type="insert"):
        port = Port()
        vrf = VRF()
        if not port.check_port_exists(aruba_ansible_module, interface_name):
            aruba_ansible_module.module.fail_json(msg="Interface {} is not configured".format(interface_name))

        result = port.get_port_field_values(aruba_ansible_module,
                                            interface_name,
                                            ['vrf'])
        if 'vrf' in result.keys():
            if result['vrf'] != "" and result['vrf'] != vrf_name:
                aruba_ansible_module.module.fail_json(
                    msg=("Interface {} is attached to VRF {}. Delete interface and recreate with VRF {}".format(
                        interface_name, result['vrf'], vrf_name)))

        if not vrf.check_vrf_exists(aruba_ansible_module, vrf_name):
            if vrf_name != "default":
                aruba_ansible_module.module.fail_json(msg="VRF {} does not exist".format(vrf_name))
            aruba_ansible_module = vrf.create_vrf(aruba_ansible_module, vrf_name)

        port_field = {
            "vrf": vrf_name
        }

        aruba_ansible_module = port.update_port_fields(aruba_ansible_module, interface_name, port_field)
        try:
            aruba_ansible_module = port.delete_port_fields(aruba_ansible_module, interface_name, ['ip4_address'])
            aruba_ansible_module = port.delete_port_fields(aruba_ansible_module, interface_name, ['ip6_address'])
        except:
            pass

        return aruba_ansible_module
Esempio n. 2
0
    def update_interface_ip_helper_address(self, aruba_ansible_module,
                                           vrf_name, interface_name,
                                           ip_helper_address):

        vrf = VRF()
        if vrf_name is not None:
            vrf_name = 'default'

        if not vrf.check_vrf_exists(aruba_ansible_module, vrf_name):

            if vrf_name == 'default':
                aruba_ansible_module = vrf.create_vrf(aruba_ansible_module,
                                                      vrf_name)
            else:
                aruba_ansible_module.module.fail_json(
                    msg="VRF {vrf} is not "
                    "configured"
                    "".format(vrf=vrf_name))  # NOQA

        if 'DHCP_Relay' not in aruba_ansible_module.running_config.keys():

            aruba_ansible_module.running_config['DHCP_Relay'] = {}

        encoded_interface_name = interface_name.replace("/", "%2F")

        index = '{vrf}/{int}'.format(vrf=vrf_name, int=encoded_interface_name)

        if index not in aruba_ansible_module.running_config["DHCP_Relay"].keys(
        ):  # NOQA
            aruba_ansible_module.running_config["DHCP_Relay"][index] = {}

        if "ipv4_ucast_server" not in aruba_ansible_module.running_config[
                "DHCP_Relay"][index].keys():  # NOQA
            aruba_ansible_module.running_config["DHCP_Relay"][index][
                "ipv4_ucast_server"] = []  # NOQA

        aruba_ansible_module.running_config["DHCP_Relay"][index][
            "port"] = encoded_interface_name  # NOQA

        aruba_ansible_module.running_config["DHCP_Relay"][index][
            "vrf"] = vrf_name  # NOQA

        for item in ip_helper_address:
            aruba_ansible_module.running_config["DHCP_Relay"][index][
                "ipv4_ucast_server"].append(item)  # NOQA
            aruba_ansible_module.running_config["DHCP_Relay"][index][
                "ipv4_ucast_server"].sort()  # NOQA

        return aruba_ansible_module
def main():
    module_args = dict(name=dict(type='str', required=True),
                       state=dict(default='create',
                                  choices=['create', 'delete']))

    aruba_ansible_module = ArubaAnsibleModule(module_args)

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

    vrf = VRF()

    if state == 'create':
        aruba_ansible_module = vrf.create_vrf(aruba_ansible_module, vrf_name)

    if state == 'delete':
        aruba_ansible_module = vrf.delete_vrf(aruba_ansible_module, vrf_name)

    aruba_ansible_module.update_switch_config()
Esempio n. 4
0
    def update_interface_vrf_details_from_l3(self,
                                             aruba_ansible_module,
                                             vrf_name,
                                             interface_name,
                                             update_type="insert"):
        port = Port()
        vrf = VRF()
        if not port.check_port_exists(aruba_ansible_module, interface_name):
            aruba_ansible_module.module.fail_json(
                msg="Interface {int} is not "
                "configured"
                "".format(int=interface_name))  # NOQA

        result = port.get_port_field_values(aruba_ansible_module,
                                            interface_name, ['vrf'])
        if 'vrf' in result.keys():
            if result['vrf'] != "" and result['vrf'] != vrf_name:
                aruba_ansible_module.module.fail_json(
                    msg=("Interface {int} is attached to VRF {vrf}. "
                         "Delete interface"
                         " and recreate with VRF "
                         "{vrf_name}".format(int=interface_name,
                                             vrf=result['vrf'],
                                             vrf_name=vrf_name)))

        if not vrf.check_vrf_exists(aruba_ansible_module, vrf_name):
            if vrf_name != "default":
                aruba_ansible_module.module.fail_json(
                    msg="VRF {vrf} does not "
                    "exist"
                    "".format(vrf=vrf_name))  # NOQA
            aruba_ansible_module = vrf.create_vrf(aruba_ansible_module,
                                                  vrf_name)

        port_field = {"vrf": vrf_name}

        aruba_ansible_module = port.update_port_fields(aruba_ansible_module,
                                                       interface_name,
                                                       port_field)

        return aruba_ansible_module
    def update_interface_ip_helper_address(self, aruba_ansible_module, vrf_name, interface_name, ip_helper_address):

        vrf = VRF()
        if vrf_name is not None:
            vrf_name = 'default'

        if not vrf.check_vrf_exists(aruba_ansible_module, vrf_name):

            if vrf_name == 'default':
                aruba_ansible_module = vrf.create_vrf(aruba_ansible_module, vrf_name)
            else:
                aruba_ansible_module.module.fail_json(msg="VRF {} is not comfigured".format(vrf_name))

        if not aruba_ansible_module.running_config.has_key('DHCP_Relay'):

            aruba_ansible_module.running_config['DHCP_Relay'] = {}

        encoded_interface_name = interface_name.replace("/", "%2F")

        index = '{}/{}'.format(vrf_name, encoded_interface_name)

        if not aruba_ansible_module.running_config["DHCP_Relay"].has_key(index):
            aruba_ansible_module.running_config["DHCP_Relay"][index] = {}

        if not aruba_ansible_module.running_config["DHCP_Relay"][index].has_key("ipv4_ucast_server"):
            aruba_ansible_module.running_config["DHCP_Relay"][index]["ipv4_ucast_server"] = []

        aruba_ansible_module.running_config["DHCP_Relay"][index]["port"] = encoded_interface_name

        aruba_ansible_module.running_config["DHCP_Relay"][index]["vrf"] = vrf_name

        for item in ip_helper_address:
            aruba_ansible_module.running_config["DHCP_Relay"][index]["ipv4_ucast_server"].append(item)
            aruba_ansible_module.running_config["DHCP_Relay"][index]["ipv4_ucast_server"].sort()

        return aruba_ansible_module
def main():
    module_args = dict(vrf_name=dict(type='str',
                                     required=False,
                                     default='default'),
                       destination_address_prefix=dict(type='str',
                                                       required=True),
                       type=dict(type='str',
                                 default='forward',
                                 choices=['forward', 'blackhole', 'reject']),
                       distance=dict(type='int', default=1),
                       next_hop_interface=dict(type='str', default=None),
                       next_hop_ip_address=dict(type='str', default=None),
                       state=dict(default='create',
                                  choices=['create', 'delete']))

    aruba_ansible_module = ArubaAnsibleModule(module_args)

    vrf_name = aruba_ansible_module.module.params['vrf_name']
    prefix = aruba_ansible_module.module.params['destination_address_prefix']
    route_type = aruba_ansible_module.module.params['type']
    distance = aruba_ansible_module.module.params['distance']
    next_hop_interface = aruba_ansible_module.module.params[
        'next_hop_interface']  # NOQA
    next_hop_ip_address = aruba_ansible_module.module.params[
        'next_hop_ip_address']  # NOQA
    state = aruba_ansible_module.module.params['state']

    vrf = VRF()

    if vrf_name is None:
        vrf_name = 'default'

    if not vrf.check_vrf_exists(aruba_ansible_module, vrf_name):

        if vrf_name == 'default' and state == 'create':
            aruba_ansible_module = vrf.create_vrf(aruba_ansible_module,
                                                  vrf_name)
        else:
            aruba_ansible_module.module.fail_json(msg="VRF {vrf} is not "
                                                  "configured"
                                                  "".format(vrf=vrf_name))

    encoded_prefix = prefix.replace("/", "%2F")
    index = vrf_name + '/' + encoded_prefix

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

        address_family = 'ipv6' if ':' in prefix else 'ipv4'

        if not aruba_ansible_module.running_config['System']['vrfs'][
                vrf_name].has_key('Static_Route'):  # NOQA
            aruba_ansible_module.running_config['System']['vrfs'][vrf_name][
                'Static_Route'] = {}  # NOQA

        if not aruba_ansible_module.running_config['System']['vrfs'][vrf_name][
                'Static_Route'].has_key(index):  # NOQA
            aruba_ansible_module.running_config['System']['vrfs'][vrf_name][
                'Static_Route'][index] = {}  # NOQA

        if address_family is not None:
            aruba_ansible_module.running_config['System']['vrfs'][vrf_name][
                'Static_Route'][index][
                    "address_family"] = address_family  # NOQA

        if prefix is not None:
            aruba_ansible_module.running_config['System']['vrfs'][vrf_name][
                'Static_Route'][index]["prefix"] = prefix  # NOQA

        if route_type is not None:
            aruba_ansible_module.running_config['System']['vrfs'][vrf_name][
                'Static_Route'][index]["type"] = route_type  # NOQA

            if route_type == 'forward':
                if not aruba_ansible_module.running_config['System']['vrfs'][
                        vrf_name]['Static_Route'][index].has_key(
                            'static_nexthops'):  # NOQA
                    aruba_ansible_module.running_config['System']['vrfs'][
                        vrf_name]['Static_Route'][index]['static_nexthops'] = {
                            "0": {
                                "bfd_enable": False,
                                "distance": distance
                            }
                        }  # NOQA

                if next_hop_interface is not None:
                    encoded_interface = next_hop_interface.replace('/', '%2F')
                    aruba_ansible_module.running_config['System']['vrfs'][
                        vrf_name]['Static_Route'][index]['static_nexthops'][
                            "0"]["port"] = encoded_interface  # NOQA

                if next_hop_ip_address is not None:
                    aruba_ansible_module.running_config['System']['vrfs'][
                        vrf_name]['Static_Route'][index]['static_nexthops'][
                            "0"]["ip_address"] = next_hop_ip_address  # NOQA

    if state == 'delete':

        if not aruba_ansible_module.running_config['System']['vrfs'][
                vrf_name].has_key('Static_Route'):  # NOQA
            aruba_ansible_module.warnings.append(
                "Static route for destination {dest} and does not exist in VRF{vrf}"
                .format(dest=prefix, vrf=vrf_name))  # NOQA

        elif not aruba_ansible_module.running_config['System']['vrfs'][
                vrf_name]['Static_Route'].has_key(index):  # NOQA
            aruba_ansible_module.warnings.append(
                "Static route for destination {dest} and does not exist in VRF{vrf}"
                .format(dest=prefix, vrf=vrf_name))  # NOQA

        else:
            aruba_ansible_module.running_config['System']['vrfs'][vrf_name][
                'Static_Route'].pop(index)  # NOQA

    aruba_ansible_module.update_switch_config()
Esempio n. 7
0
def main():
    module_args = dict(mgmt_nameservers=dict(type='dict', required=False),
                       dns_domain_list=dict(type='dict', required=False),
                       dns_domain_name=dict(type='str', required=False),
                       dns_name_servers=dict(type='dict', required=False),
                       vrf=dict(type='str', required=False),
                       dns_host_v4_address_mapping=dict(type='dict',
                                                        required=False),
                       state=dict(type='str',
                                  default='create',
                                  choices=['create', 'delete', 'update']))

    aruba_ansible_module = ArubaAnsibleModule(module_args)

    mgmt_nameservers = aruba_ansible_module.module.params['mgmt_nameservers']
    dns_domain_name = aruba_ansible_module.module.params['dns_domain_name']
    dns_domain_list = aruba_ansible_module.module.params['dns_domain_list']
    vrf_name = aruba_ansible_module.module.params['vrf']
    dns_name_servers = aruba_ansible_module.module.params['dns_name_servers']
    dns_host_v4_address_mapping = aruba_ansible_module.module.params[
        'dns_host_v4_address_mapping']  # NOQA
    state = aruba_ansible_module.module.params['state']

    vrf = VRF()

    if state == 'create' or state == 'update':
        if mgmt_nameservers is not None:
            mgmt_if_mode = aruba_ansible_module.running_config['System'][
                'mgmt_intf']['mode']  # NOQA

            if mgmt_if_mode != 'static':

                aruba_ansible_module.module.fail_json(
                    msg=
                    "The management interface must have static IP to configure management interface name servers"
                )  # NOQA

            for k, v in mgmt_nameservers.items():
                if k.lower() == 'primary':
                    aruba_ansible_module.running_config['System']['mgmt_intf'][
                        'dns_server_1'] = v  # NOQA
                elif k.lower() == 'secondary':
                    aruba_ansible_module.running_config['System']['mgmt_intf'][
                        'dns_server_2'] = v  # NOQA

        if vrf_name is None:
            vrf_name = 'default'

        if dns_domain_name is not None:
            aruba_ansible_module = vrf.update_vrf_dns_domain_name(
                aruba_ansible_module,
                vrf_name,
                dns_domain_name,
                update_type="insert")  # NOQA

        if dns_domain_list is not None:
            aruba_ansible_module = vrf.update_vrf_dns_domain_list(
                aruba_ansible_module,
                vrf_name,
                dns_domain_list,
                update_type="insert")  # NOQA

        if dns_name_servers is not None:
            aruba_ansible_module = vrf.update_vrf_dns_name_servers(
                aruba_ansible_module,
                vrf_name,
                dns_name_servers,
                update_type="insert")  # NOQA

        if dns_host_v4_address_mapping is not None:
            aruba_ansible_module = vrf.update_vrf_dns_host_v4_address_mapping(
                aruba_ansible_module,
                vrf_name,
                dns_host_v4_address_mapping,
                update_type="insert")  # NOQA

    if state == 'delete':

        if vrf_name is None:
            vrf_name = 'default'

        if mgmt_nameservers is not None:

            for k, v in mgmt_nameservers.items():
                if k.lower() == 'primary':
                    aruba_ansible_module.running_config['System'][
                        'mgmt_intf'].pop('dns_server_1')  # NOQA
                elif k.lower() == 'secondary':
                    aruba_ansible_module.running_config['System'][
                        'mgmt_intf'].pop('dns_server_2')  # NOQA

        if dns_domain_name is not None:
            aruba_ansible_module = vrf.update_vrf_dns_domain_name(
                aruba_ansible_module,
                vrf_name,
                dns_domain_name,
                update_type="delete")  # NOQA

        if dns_domain_list is not None:
            aruba_ansible_module = vrf.update_vrf_dns_domain_list(
                aruba_ansible_module,
                vrf_name,
                dns_domain_list,
                update_type="delete")  # NOQA

        if dns_name_servers is not None:
            aruba_ansible_module = vrf.update_vrf_dns_name_servers(
                aruba_ansible_module,
                vrf_name,
                dns_name_servers,
                update_type="delete")  # NOQA

        if dns_host_v4_address_mapping is not None:
            aruba_ansible_module = vrf.update_vrf_dns_host_v4_address_mapping(
                aruba_ansible_module,
                vrf_name,
                dns_host_v4_address_mapping,
                update_type="delete")  # NOQA

    aruba_ansible_module.update_switch_config()