iosxe_static_route

#!/usr/bin/env python

# Copyright 2016 Jonas Stenling <jonas@stenling.se>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

DOCUMENTATION = '''
---

module: iosxe_static_route
short_description: Manages configuration of static routes
description:
    - Manages static routes in IOS-XE Netconf enabled devices
author: Jonas Stenling 
requirements:
    - IOS XE with Netconf enabled
    - pyskate
notes:
    - The module tries to be idempotent, but it is up to the user to verify
      that the resulting configuration is correct.

options:
    ipv4_network:
        description:
            - IPv4 network address of static route
        required: true
        default: null
        choices: []
        aliases: []
    ipv4_netmask:
        description:
            - IPv4 netmask of static route
        required: true
        default: null
        choices: []
        aliases: []
    ipv4_nexthop:
        description:
            - IPv4 next hop of static route
        required: true
        default: null
        choices: []
        aliases: []
    vrf:
        description:
            - VRF where route shall be installed
        required: false
        default: null
        choices: []
        aliases: []
    name:
        name:
            - Description of static route
        required: false
        default: null
        choices: []
        aliases: []
    ignore_name:
        name:
            - Do not perform matching of route name when adding or
              removing a route.
        required: false
        default: null
        choices: ['true', 'false']
        aliases: []
    state:
        description:
            - Specify desired state of the resource
        required: false
        default: present
        choices: ['present','absent']
        aliases: []
    host:
        description:
            - IP Address or hostname (resolvable by Ansible control host)
              of the target NX-API enabled switch
        required: true
        default: null
        choices: []
        aliases: []
    username:
        description:
            - Username used to login to the router
        required: true
        default: null
        choices: []
        aliases: []
    password:
        description:
            - Password used to login to the router
        required: true
        default: null
        choices: []
        aliases: []
'''

EXAMPLES = '''

# Configure static route
- iosxe_static_route:
    ipv4_network: 10.1.0.0
    ipv4_netmask: 255.255.255.0
    ipv4_nexthop: 192.168.1.1
    vrf: test3
    name: Internal server network
    host: {{ inventory_hostname }}
    username: {{ username }}
    password: {{ password }}
'''
try:
    import socket
    import pyskate.utils
    from pyskate.iosxe_netconf import IOSXEDevice, ConfigDeployError
except ImportError as e:
    print '*' * 30
    print e
    print '*' * 30

def change_state(current_state, state):
    '''Returns new expected state if a change is needed, otherwise
    returns False'''
    if current_state == 'absent':
        if state == 'present':
            return 'present'
        elif state == 'absent':
            return False
    elif current_state == 'present':
        if state == 'present':
            return False
        elif state == 'absent':
            return 'absent'

def compare_proposed_to_running_wo_name(proposed_config, running_config, vrf):
    '''Compare running_config to proposed_config and ignore name field.
    Used when ignore_name == True'''

    if vrf is not None:
        proposed_config_wo_name = ' '.join(proposed_config[0].split()[0:7])

        commands = [proposed_config_wo_name]

        for line in running_config:
            running_config_wo_name = ' '.join(line.split()[0:7])
            if running_config_wo_name in commands:
                commands.remove(running_config_wo_name)
        return commands
    else:
        proposed_config_wo_name = ' '.join(proposed_config[0].split()[0:5])

        commands = [proposed_config_wo_name]

        for line in running_config:
            running_config_wo_name = ' '.join(line.split()[0:5])
            if running_config_wo_name in commands:
                commands.remove(running_config_wo_name)
        return commands


def main():

    module = AnsibleModule(
        argument_spec=dict(
            ipv4_network=dict(required=True, type='str'),
            ipv4_netmask=dict(required=True, type='str'),
            ipv4_nexthop=dict(required=True, type='str'),
            vrf=dict(required=False, type='str', default=None),
            name=dict(required=False, type='str', default=None),
            ignore_name=dict(required=False, type='bool'),
            state=dict(choices=['present', 'absent'], default='present'),
            host=dict(required=True),
            username=dict(type='str'),
            password=dict(type='str'),
        ),
        supports_check_mode=True
    )

    username = module.params['username']
    password = module.params['password']
    host = socket.gethostbyname(module.params['host'])
    state = module.params['state']
    ipv4_network = module.params['ipv4_network']
    ipv4_netmask = module.params['ipv4_netmask']
    ipv4_nexthop = module.params['ipv4_nexthop']
    ignore_name = module.params['ignore_name']
    vrf = module.params['vrf']
    name = module.params['name']

    device = IOSXEDevice(host, username, password)

    try:
        device.connect()
    except:
        module.fail_json(msg="Failed to connect to {0}".format(host))

    changed = False

#
# This part should be refactored to have all args in a list and
# a function to apply the correct config, such as:
#
# args = [vrf, ipv4_network, ipv4_netmask, ipv4_nexthop, name]
#
# map = { 'vrf': [0, 'vrf'], 'ipv4_network': [1, None] }
#
# Where first item in list is positional parameter and the second if any
# additional configuration shall be applied.
#
# cmd = ''
# for i in args:
#     cmd = cmd + apply_map(i)
#
# and the apply_map function will check if the args is not None and in that case
# add the config to cmd.



    if name is not None:
        if len(name.split()) > 1: # name contains spaces, need to wrap in quotes
            if vrf is not None:
                proposed_config = ['ip route vrf {0} {1} {2} {3} name "{4}"'.format(
                        vrf,
                        ipv4_network,
                        ipv4_netmask,
                        ipv4_nexthop,
                        name)]
            else:
                proposed_config = ['ip route {0} {1} {2} name "{3}"'.format(
                        ipv4_network,
                        ipv4_netmask,
                        ipv4_nexthop,
                        name)]
        else:
            if vrf is not None:
                proposed_config = ['ip route vrf {0} {1} {2} {3} name {4}'.format(
                        vrf,
                        ipv4_network,
                        ipv4_netmask,
                        ipv4_nexthop,
                        name)]
            else:    
                proposed_config = ['ip route {0} {1} {2} name {3}'.format(
                        ipv4_network,
                        ipv4_netmask,
                        ipv4_nexthop,
                        name)]
    else:    
        if vrf is not None:
            proposed_config = ['ip route vrf {0} {1} {2} {3}'.format(
                    vrf,
                    ipv4_network,
                    ipv4_netmask,
                    ipv4_nexthop)]
        else:    
            proposed_config = ['ip route {0} {1} {2}'.format(
                    ipv4_network,
                    ipv4_netmask,
                    ipv4_nexthop)]

    running_config = [x.strip() for x in device.get_config()]
    running_config = [x for x in running_config if x.startswith('ip route')]


    if ignore_name:
        final_config = compare_proposed_to_running_wo_name(proposed_config,
                running_config, vrf)
    else:    
        final_config = pyskate.utils.compare_proposed_to_running(proposed_config, running_config)

    if len(final_config) == 0: # route already exists in router
        current_state = 'present'
    else:
        current_state = 'absent'

    # check if state is supposed to change 
    new_state = change_state(current_state, state)

    if new_state:
        if 'absent' in new_state:
            if ignore_name:
                if vrf is not None: 
                    final_config = ['no ' + ' '.join(proposed_config[0].split()[0:7])]
                else:
                    final_config = ['no ' + ' '.join(proposed_config[0].split()[0:5])]
            else:
               final_config = ['no ' + proposed_config[0]]
            changed = True
        elif 'present' in new_state:
            changed = True

        if module.check_mode:
            module.exit_json(changed=True, commands='\n'.join(final_config))
        try:    
            device.edit_config('\n'.join(final_config))
            changed = True
        except ConfigDeployError:
            changed = False
            module.fail_json(msg="Failed to configure {0}".format(host))
    else:
        # if state is not changed, set correct final_config
        final_config = []

    results = {}
    results['proposed'] = proposed_config
    results['final'] = final_config
    results['changed'] = changed

    device.disconnect()

    module.exit_json(**results)

from ansible.module_utils.basic import *
main()