EVOLUTION-MANAGER

Edit File: ce_ospf_vrf.py

#!/usr/bin/python
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#

ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'community'}

DOCUMENTATION = '''
---
module: ce_ospf_vrf
version_added: "2.4"
short_description: Manages configuration of an OSPF VPN instance on HUAWEI CloudEngine switches.
description:
    - Manages configuration of an OSPF VPN instance on HUAWEI CloudEngine switches.
author: Yang yang (@QijunPan)
notes:
    - This module requires the netconf system service be enabled on the remote device being managed.
    - Recommended connection is C(netconf).
    - This module also works with C(local) connections for legacy playbooks.
options:
    ospf:
        description:
            - The ID of the ospf process.
              Valid values are an integer, 1 - 4294967295, the default value is 1.
        required: true
    route_id:
        description:
            - Specifies the ospf private route id,.
              Valid values are a string, formatted as an IP address
              (i.e. "10.1.1.1") the length is 0 - 20.
    vrf:
        description:
            - Specifies the vpn instance which use ospf,length is 1 - 31.
              Valid values are a string.
        default: _public_
    description:
        description:
            - Specifies the description information of ospf process.
    bandwidth:
        description:
            - Specifies the reference bandwidth used to assign ospf cost.
              Valid values are an integer, in Mbps, 1 - 2147483648, the default value is 100.
    lsaalflag:
        description:
            - Specifies the mode of timer to calculate interval of arrive LSA.
              If set the parameter but not specifies value, the default will be used.
              If true use general timer.
              If false use intelligent timer.
        type: bool
        default: 'no'
    lsaainterval:
        description:
            - Specifies the interval of arrive LSA when use the general timer.
              Valid value is an integer, in millisecond, from 0 to 10000.
    lsaamaxinterval:
        description:
            - Specifies the max interval of arrive LSA when use the intelligent timer.
              Valid value is an integer, in millisecond, from 0 to 10000, the default value is 1000.
    lsaastartinterval:
        description:
            - Specifies the start interval of arrive LSA when use the intelligent timer.
              Valid value is an integer, in millisecond, from 0 to 10000, the default value is 500.
    lsaaholdinterval:
        description:
            - Specifies the hold interval of arrive LSA when use the intelligent timer.
              Valid value is an integer, in millisecond, from 0 to 10000, the default value is 500.
    lsaointervalflag:
        description:
            - Specifies whether cancel the interval of LSA originate or not.
              If set the parameter but noe specifies value, the default will be used.
              true:cancel the interval of LSA originate, the interval is 0.
              false:do not cancel the interval of LSA originate.
        type: bool
        default: 'no'
    lsaointerval:
        description:
            - Specifies the interval of originate LSA .
              Valid value is an integer, in second, from 0 to 10, the default value is 5.
    lsaomaxinterval:
        description:
            - Specifies the max interval of originate LSA .
              Valid value is an integer, in millisecond, from 1 to 10000, the default value is 5000.
    lsaostartinterval:
        description:
            - Specifies the start interval of originate LSA .
              Valid value is an integer, in millisecond, from 0 to 1000, the default value is 500.
    lsaoholdinterval:
        description:
            - Specifies the hold interval of originate LSA .
              Valid value is an integer, in millisecond, from 0 to 5000, the default value is 1000.
    spfintervaltype:
        description:
            - Specifies the mode of timer which used to calculate SPF.
              If set the parameter but noe specifies value, the default will be used.
              If is intelligent-timer, then use intelligent timer.
              If is timer, then use second level timer.
              If is millisecond, then use millisecond level timer.
        choices: ['intelligent-timer','timer','millisecond']
        default: intelligent-timer
    spfinterval:
        description:
            - Specifies the interval to calculate SPF when use second level  timer.
              Valid value is an integer, in second, from 1 to 10.
    spfintervalmi:
        description:
            - Specifies the interval to calculate SPF when use millisecond level  timer.
              Valid value is an integer, in millisecond, from 1 to 10000.
    spfmaxinterval:
        description:
            - Specifies the max interval to calculate SPF when use intelligent timer.
              Valid value is an integer, in millisecond, from 1 to 20000, the default value is 5000.
    spfstartinterval:
        description:
            - Specifies the start interval to calculate SPF when use intelligent timer.
              Valid value is an integer, in millisecond, from 1 to 1000, the default value is 50.
    spfholdinterval:
        description:
            - Specifies the hold interval to calculate SPF when use intelligent timer.
              Valid value is an integer, in millisecond, from 1 to 5000, the default value is 200.
    state:
        description:
            - Specify desired state of the resource.
        choices: ['present', 'absent']
        default: present
'''

EXAMPLES = '''
- name: ospf vrf module test
  hosts: cloudengine
  connection: local
  gather_facts: no
  vars:
    cli:
      host: "{{ inventory_hostname }}"
      port: "{{ ansible_ssh_port }}"
      username: "{{ username }}"
      password: "{{ password }}"
      transport: cli

tasks:

- name: Configure ospf route id
    ce_ospf_vrf:
      ospf: 2
      route_id: 2.2.2.2
      lsaointervalflag: False
      lsaointerval: 2
      provider: "{{ cli }}"
'''

RETURN = '''
proposed:
    description: k/v pairs of parameters passed into module
    returned: verbose mode
    type: dict
    sample: {
        "bandwidth": "100",
        "description": null,
        "lsaaholdinterval": "500",
        "lsaainterval": null,
        "lsaamaxinterval": "1000",
        "lsaastartinterval": "500",
        "lsaalflag": "False",
        "lsaoholdinterval": "1000",
        "lsaointerval": "2",
        "lsaointervalflag": "False",
        "lsaomaxinterval": "5000",
        "lsaostartinterval": "500",
        "process_id": "2",
        "route_id": "2.2.2.2",
        "spfholdinterval": "1000",
        "spfinterval": null,
        "spfintervalmi": null,
        "spfintervaltype": "intelligent-timer",
        "spfmaxinterval": "10000",
        "spfstartinterval": "500",
        "vrf": "_public_"
    }
existing:
    description: k/v pairs of existing configuration
    returned: verbose mode
    type: dict
    sample: {
                "bandwidthReference": "100",
                "description": null,
                "lsaArrivalFlag": "false",
                "lsaArrivalHoldInterval": "500",
                "lsaArrivalInterval": null,
                "lsaArrivalMaxInterval": "1000",
                "lsaArrivalStartInterval": "500",
                "lsaOriginateHoldInterval": "1000",
                "lsaOriginateInterval": "2",
                "lsaOriginateIntervalFlag": "false",
                "lsaOriginateMaxInterval": "5000",
                "lsaOriginateStartInterval": "500",
                "processId": "2",
                "routerId": "2.2.2.2",
                "spfScheduleHoldInterval": "1000",
                "spfScheduleInterval": null,
                "spfScheduleIntervalMillisecond": null,
                "spfScheduleIntervalType": "intelligent-timer",
                "spfScheduleMaxInterval": "10000",
                "spfScheduleStartInterval": "500",
                "vrfName": "_public_"
            }
end_state:
    description: k/v pairs of configuration after module execution
    returned: verbose mode
    type: dict
    sample: {
                "bandwidthReference": "100",
                "description": null,
                "lsaArrivalFlag": "false",
                "lsaArrivalHoldInterval": "500",
                "lsaArrivalInterval": null,
                "lsaArrivalMaxInterval": "1000",
                "lsaArrivalStartInterval": "500",
                "lsaOriginateHoldInterval": "1000",
                "lsaOriginateInterval": "2",
                "lsaOriginateIntervalFlag": "false",
                "lsaOriginateMaxInterval": "5000",
                "lsaOriginateStartInterval": "500",
                "processId": "2",
                "routerId": "2.2.2.2",
                "spfScheduleHoldInterval": "1000",
                "spfScheduleInterval": null,
                "spfScheduleIntervalMillisecond": null,
                "spfScheduleIntervalType": "intelligent-timer",
                "spfScheduleMaxInterval": "10000",
                "spfScheduleStartInterval": "500",
                "vrfName": "_public_"
            }
updates:
    description: commands sent to the device
    returned: always
    type: list
    sample: ["ospf 2"]
changed:
    description: check to see if a change was made on the device
    returned: always
    type: bool
    sample: False
'''

from xml.etree import ElementTree
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.network.cloudengine.ce import get_nc_config, set_nc_config, ce_argument_spec

CE_NC_GET_OSPF_VRF = """
    <filter type="subtree">
      <ospfv2 xmlns="http://www.huawei.com/netconf/vrp" content-version="1.0" format-version="1.0">
        <ospfv2comm>
          <ospfSites>
            <ospfSite>
              <processId></processId>
              <routerId></routerId>
              <vrfName></vrfName>
              <description></description>
              <bandwidthReference></bandwidthReference>
              <lsaArrivalFlag></lsaArrivalFlag>
              <lsaArrivalInterval></lsaArrivalInterval>
              <lsaArrivalMaxInterval></lsaArrivalMaxInterval>
              <lsaArrivalStartInterval></lsaArrivalStartInterval>
              <lsaArrivalHoldInterval></lsaArrivalHoldInterval>
              <lsaOriginateIntervalFlag></lsaOriginateIntervalFlag>
              <lsaOriginateInterval></lsaOriginateInterval>
              <lsaOriginateMaxInterval></lsaOriginateMaxInterval>
              <lsaOriginateStartInterval></lsaOriginateStartInterval>
              <lsaOriginateHoldInterval></lsaOriginateHoldInterval>
              <spfScheduleIntervalType></spfScheduleIntervalType>
              <spfScheduleInterval></spfScheduleInterval>
              <spfScheduleIntervalMillisecond></spfScheduleIntervalMillisecond>
              <spfScheduleMaxInterval></spfScheduleMaxInterval>
              <spfScheduleStartInterval></spfScheduleStartInterval>
              <spfScheduleHoldInterval></spfScheduleHoldInterval>
            </ospfSite>
          </ospfSites>
        </ospfv2comm>
      </ospfv2>
    </filter>
"""

CE_NC_CREATE_OSPF_VRF = """
      <ospfv2 xmlns="http://www.huawei.com/netconf/vrp" content-version="1.0" format-version="1.0">
        <ospfv2comm>
          <ospfSites>
            <ospfSite operation="merge">
              <processId>%s</processId>
%s
              <vrfName>%s</vrfName>
              <description>%s</description>
              <bandwidthReference>%s</bandwidthReference>
              <lsaArrivalFlag>%s</lsaArrivalFlag>
              <lsaArrivalInterval>%s</lsaArrivalInterval>
              <lsaArrivalMaxInterval>%s</lsaArrivalMaxInterval>
              <lsaArrivalStartInterval>%s</lsaArrivalStartInterval>
              <lsaArrivalHoldInterval>%s</lsaArrivalHoldInterval>
              <lsaOriginateIntervalFlag>%s</lsaOriginateIntervalFlag>
              <lsaOriginateInterval>%s</lsaOriginateInterval>
              <lsaOriginateMaxInterval>%s</lsaOriginateMaxInterval>
              <lsaOriginateStartInterval>%s</lsaOriginateStartInterval>
              <lsaOriginateHoldInterval>%s</lsaOriginateHoldInterval>
              <spfScheduleIntervalType>%s</spfScheduleIntervalType>
              <spfScheduleInterval>%s</spfScheduleInterval>
              <spfScheduleIntervalMillisecond>%s</spfScheduleIntervalMillisecond>
              <spfScheduleMaxInterval>%s</spfScheduleMaxInterval>
              <spfScheduleStartInterval>%s</spfScheduleStartInterval>
              <spfScheduleHoldInterval>%s</spfScheduleHoldInterval>
            </ospfSite>
          </ospfSites>
        </ospfv2comm>
      </ospfv2>
"""
CE_NC_CREATE_ROUTE_ID = """
              <routerId>%s</routerId>
"""

CE_NC_DELETE_OSPF = """
      <ospfv2 xmlns="http://www.huawei.com/netconf/vrp" content-version="1.0" format-version="1.0">
        <ospfv2comm>
          <ospfSites>
            <ospfSite operation="delete">
              <processId>%s</processId>
              <routerId>%s</routerId>
              <vrfName>%s</vrfName>
            </ospfSite>
          </ospfSites>
        </ospfv2comm>
      </ospfv2>
"""

def build_config_xml(xmlstr):
    """build_config_xml"""

return '<config> ' + xmlstr + ' </config>'

class OspfVrf(object):
    """
    Manages configuration of an ospf instance.
    """

def __init__(self, argument_spec):
        self.spec = argument_spec
        self.module = None
        self.init_module()

# module input info
        self.ospf = self.module.params['ospf']
        self.route_id = self.module.params['route_id']
        self.vrf = self.module.params['vrf']
        self.description = self.module.params['description']
        self.bandwidth = self.module.params['bandwidth']
        self.lsaalflag = self.module.params['lsaalflag']
        self.lsaainterval = self.module.params['lsaainterval']
        self.lsaamaxinterval = self.module.params['lsaamaxinterval']
        self.lsaastartinterval = self.module.params['lsaastartinterval']
        self.lsaaholdinterval = self.module.params['lsaaholdinterval']
        self.lsaointervalflag = self.module.params['lsaointervalflag']
        self.lsaointerval = self.module.params['lsaointerval']
        self.lsaomaxinterval = self.module.params['lsaomaxinterval']
        self.lsaostartinterval = self.module.params['lsaostartinterval']
        self.lsaoholdinterval = self.module.params['lsaoholdinterval']
        self.spfintervaltype = self.module.params['spfintervaltype']
        self.spfinterval = self.module.params['spfinterval']
        self.spfintervalmi = self.module.params['spfintervalmi']
        self.spfmaxinterval = self.module.params['spfmaxinterval']
        self.spfstartinterval = self.module.params['spfstartinterval']
        self.spfholdinterval = self.module.params['spfholdinterval']
        self.state = self.module.params['state']

# ospf info
        self.ospf_info = dict()

# state
        self.changed = False
        self.updates_cmd = list()
        self.results = dict()
        self.proposed = dict()
        self.existing = dict()
        self.end_state = dict()
        self.lsa_arrival_changed = False
        self.lsa_originate_changed = False
        self.spf_changed = False
        self.route_id_changed = False
        self.bandwidth_changed = False
        self.description_changed = False
        self.vrf_changed = False

def init_module(self):
        """" init module """

self.module = AnsibleModule(
            argument_spec=self.spec, supports_check_mode=True)

def check_response(self, xml_str, xml_name):
        """Check if response message is already succeed."""

if "<ok/>" not in xml_str:
            self.module.fail_json(msg='Error: %s failed.' % xml_name)

def is_valid_ospf_process_id(self):
        """check whether the input ospf process id is valid"""

if not self.ospf.isdigit():
            return False
        if int(self.ospf) > 4294967295 or int(self.ospf) < 1:
            return False
        return True

def is_valid_ospf_route_id(self):
        """check is ipv4 addr is valid"""

if self.route_id.find('.') != -1:
            addr_list = self.route_id.split('.')
            if len(addr_list) != 4:
                return False
            for each_num in addr_list:
                if not each_num.isdigit():
                    return False
                if int(each_num) > 255:
                    return False
            return True
        return False

def is_valid_vrf_name(self):
        """check whether the input ospf vrf name is valid"""

if len(self.vrf) > 31 or len(self.vrf) < 1:
            return False
        if self.vrf.find('?') != -1:
            return False
        if self.vrf.find(' ') != -1:
            return False
        return True

def is_valid_description(self):
        """check whether the input ospf description is valid"""

if len(self.description) > 80 or len(self.description) < 1:
            return False
        if self.description.find('?') != -1:
            return False
        return True

def is_valid_bandwidth(self):
        """check whether the input ospf bandwidth reference is valid"""

if not self.bandwidth.isdigit():
            return False
        if int(self.bandwidth) > 2147483648 or int(self.bandwidth) < 1:
            return False
        return True

def is_valid_lsa_arrival_interval(self):
        """check whether the input ospf lsa arrival interval is valid"""

if self.lsaainterval is None:
            return False
        if not self.lsaainterval.isdigit():
            return False
        if int(self.lsaainterval) > 10000 or int(self.lsaainterval) < 0:
            return False
        return True

def isvalidlsamaxarrivalinterval(self):
        """check whether the input ospf lsa max arrival interval is valid"""

if not self.lsaamaxinterval.isdigit():
            return False
        if int(self.lsaamaxinterval) > 10000 or int(self.lsaamaxinterval) < 1:
            return False
        return True

def isvalidlsastartarrivalinterval(self):
        """check whether the input ospf lsa start arrival interval is valid"""

if not self.lsaastartinterval.isdigit():
            return False
        if int(self.lsaastartinterval) > 1000 or int(self.lsaastartinterval) < 0:
            return False
        return True

def isvalidlsaholdarrivalinterval(self):
        """check whether the input ospf lsa hold arrival interval is valid"""

if not self.lsaaholdinterval.isdigit():
            return False
        if int(self.lsaaholdinterval) > 5000 or int(self.lsaaholdinterval) < 0:
            return False
        return True

def is_valid_lsa_originate_interval(self):
        """check whether the input ospf lsa originate interval is valid"""

if not self.lsaointerval.isdigit():
            return False
        if int(self.lsaointerval) > 10 or int(self.lsaointerval) < 0:
            return False
        return True

def isvalidlsaoriginatemaxinterval(self):
        """check whether the input ospf lsa originate max interval is valid"""

if not self.lsaomaxinterval.isdigit():
            return False
        if int(self.lsaomaxinterval) > 10000 or int(self.lsaomaxinterval) < 1:
            return False
        return True

def isvalidlsaostartinterval(self):
        """check whether the input ospf lsa originate start interval is valid"""

if not self.lsaostartinterval.isdigit():
            return False
        if int(self.lsaostartinterval) > 1000 or int(self.lsaostartinterval) < 0:
            return False
        return True

def isvalidlsaoholdinterval(self):
        """check whether the input ospf lsa originate hold interval is valid"""

if not self.lsaoholdinterval.isdigit():
            return False
        if int(self.lsaoholdinterval) > 5000 or int(self.lsaoholdinterval) < 1:
            return False
        return True

def is_valid_spf_interval(self):
        """check whether the input ospf spf interval is valid"""

if not self.spfinterval.isdigit():
            return False
        if int(self.spfinterval) > 10 or int(self.spfinterval) < 1:
            return False
        return True

def is_valid_spf_milli_interval(self):
        """check whether the input ospf spf millisecond level interval is valid"""

if not self.spfintervalmi.isdigit():
            return False
        if int(self.spfintervalmi) > 10000 or int(self.spfintervalmi) < 1:
            return False
        return True

def is_valid_spf_max_interval(self):
        """check whether the input ospf spf intelligent timer max interval is valid"""

if not self.spfmaxinterval.isdigit():
            return False
        if int(self.spfmaxinterval) > 20000 or int(self.spfmaxinterval) < 1:
            return False
        return True

def is_valid_spf_start_interval(self):
        """check whether the input ospf spf intelligent timer start interval is valid"""

if not self.spfstartinterval.isdigit():
            return False
        if int(self.spfstartinterval) > 1000 or int(self.spfstartinterval) < 1:
            return False
        return True

def is_valid_spf_hold_interval(self):
        """check whether the input ospf spf intelligent timer hold interval is valid"""

if not self.spfholdinterval.isdigit():
            return False
        if int(self.spfholdinterval) > 5000 or int(self.spfholdinterval) < 1:
            return False
        return True

def is_route_id_exist(self):
        """is route id exist"""

if not self.ospf_info:
            return False

for ospf_site in self.ospf_info["ospfsite"]:
            if ospf_site["processId"] != self.ospf:
                continue
            if ospf_site["routerId"] == self.route_id:
                return True
            else:
                continue
        return False

def get_exist_ospf_id(self):
        """get exist ospf process id"""