Coverage for lib/ansible/modules/network/nxos/nxos_static_route.py : 73%

#!/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': 'network'} 

DOCUMENTATION = ''' 

--- 

module: nxos_static_route 

extends_documentation_fragment: nxos 

version_added: "2.2" 

short_description: Manages static route configuration 

description: 

- Manages static route configuration 

author: Gabriele Gerbino (@GGabriele) 

notes: 

- Tested against NXOSv 7.3.(0)D1(1) on VIRL 

- If no vrf is supplied, vrf is set to default. 

- If C(state=absent), the route will be removed, regardless of the 

non-required parameters. 

options: 

prefix: 

description: 

- Destination prefix of static route. 

required: true 

aliases: 

- address 

next_hop: 

description: 

- Next hop address or interface of static route. 

If interface, it must be the fully-qualified interface name. 

required: true 

vrf: 

description: 

- VRF for static route. 

required: false 

default: default 

tag: 

description: 

- Route tag value (numeric). 

required: false 

default: null 

route_name: 

description: 

- Name of the route. Used with the name parameter on the CLI. 

required: false 

default: null 

pref: 

description: 

- Preference or administrative difference of route (range 1-255). 

required: false 

default: null 

aliases: 

- admin_distance 

aggregate: 

description: List of static route definitions 

version_added: 2.5 

state: 

description: 

- Manage the state of the resource. 

required: true 

choices: ['present','absent'] 

''' 

EXAMPLES = ''' 

- nxos_static_route: 

prefix: "192.168.20.64/24" 

next_hop: "3.3.3.3" 

route_name: testing 

pref: 100 

''' 

RETURN = ''' 

commands: 

description: commands sent to the device 

returned: always 

type: list 

sample: ["ip route 192.168.20.0/24 3.3.3.3 name testing 100"] 

''' 

import re 

from copy import deepcopy 

from ansible.module_utils.network.nxos.nxos import get_config, load_config 

from ansible.module_utils.network.nxos.nxos import nxos_argument_spec 

from ansible.module_utils.basic import AnsibleModule 

from ansible.module_utils.network.common.config import CustomNetworkConfig 

from ansible.module_utils.network.common.utils import remove_default_spec 

def reconcile_candidate(module, candidate, prefix, w): 

netcfg = CustomNetworkConfig(indent=2, contents=get_config(module)) 

state = w['state'] 

set_command = set_route_command(prefix, w) 

remove_command = remove_route_command(prefix, w) 

parents = [] 

commands = [] 

if w['vrf'] == 'default': 

config = netcfg.get_section(set_command) 

117 ↛ 118line 117 didn't jump to line 118, because the condition on line 117 was never true if config and state == 'absent': 

commands = [remove_command] 

119 ↛ 120line 119 didn't jump to line 120, because the condition on line 119 was never true elif not config and state == 'present': 

commands = [set_command] 

else: 

parents = ['vrf context {0}'.format(w['vrf'])] 

config = netcfg.get_section(parents) 

124 ↛ 126line 124 didn't jump to line 126, because the condition on line 124 was never false if not isinstance(config, list): 

config = config.split('\n') 

config = [line.strip() for line in config] 

if set_command in config and state == 'absent': 

commands = [remove_command] 

elif set_command not in config and state == 'present': 

commands = [set_command] 

if commands: 

candidate.add(commands, parents=parents) 

def fix_prefix_to_regex(prefix): 

prefix = prefix.replace('.', r'\.').replace('/', r'\/') 

return prefix 

def get_existing(module, prefix, warnings): 

key_map = ['tag', 'pref', 'route_name', 'next_hop'] 

netcfg = CustomNetworkConfig(indent=2, contents=get_config(module)) 

parents = 'vrf context {0}'.format(module.params['vrf']) 

prefix_to_regex = fix_prefix_to_regex(prefix) 

route_regex = r'.*ip\sroute\s{0}\s(?P<next_hop>\S+)(\sname\s(?P<route_name>\S+))?(\stag\s(?P<tag>\d+))?(\s(?P<pref>\d+))?.*'.format(prefix_to_regex) 

if module.params['vrf'] == 'default': 

config = str(netcfg) 

else: 

config = netcfg.get_section(parents) 

if config: 

try: 

match_route = re.match(route_regex, config, re.DOTALL) 

group_route = match_route.groupdict() 

for key in key_map: 

if key not in group_route: 

group_route[key] = '' 

group_route['prefix'] = prefix 

group_route['vrf'] = module.params['vrf'] 

except (AttributeError, TypeError): 

group_route = {} 

else: 

group_route = {} 

msg = ("VRF {0} didn't exist.".format(module.params['vrf'])) 

if msg not in warnings: 

warnings.append(msg) 

return group_route 

def remove_route_command(prefix, w): 

return 'no ip route {0} {1}'.format(prefix, w['next_hop']) 

def set_route_command(prefix, w): 

route_cmd = 'ip route {0} {1}'.format(prefix, w['next_hop']) 

if w['route_name']: 

route_cmd += ' name {0}'.format(w['route_name']) 

if w['tag']: 

route_cmd += ' tag {0}'.format(w['tag']) 

if w['pref']: 

route_cmd += ' {0}'.format(w['pref']) 

return route_cmd 

def get_dotted_mask(mask): 

bits = 0 

for i in range(32 - mask, 32): 

bits |= (1 << i) 

mask = ("%d.%d.%d.%d" % ((bits & 0xff000000) >> 24, (bits & 0xff0000) >> 16, (bits & 0xff00) >> 8, (bits & 0xff))) 

return mask 

def get_network_start(address, netmask): 

address = address.split('.') 

netmask = netmask.split('.') 

return [str(int(address[x]) & int(netmask[x])) for x in range(0, 4)] 

def network_from_string(address, mask, module): 

octects = address.split('.') 

209 ↛ 210line 209 didn't jump to line 210, because the condition on line 209 was never true if len(octects) > 4: 

module.fail_json(msg='Incorrect address format.', address=address) 

for octect in octects: 

try: 

214 ↛ 215line 214 didn't jump to line 215, because the condition on line 214 was never true if int(octect) < 0 or int(octect) > 255: 

module.fail_json(msg='Address may contain invalid values.', 

address=address) 

except ValueError: 

module.fail_json(msg='Address may contain non-integer values.', 

address=address) 

try: 

222 ↛ 223line 222 didn't jump to line 223, because the condition on line 222 was never true if int(mask) < 0 or int(mask) > 32: 

module.fail_json(msg='Incorrect mask value.', mask=mask) 

except ValueError: 

module.fail_json(msg='Mask may contain non-integer values.', mask=mask) 

netmask = get_dotted_mask(int(mask)) 

return '.'.join(get_network_start(address, netmask)) 

def normalize_prefix(module, prefix): 

splitted_prefix = prefix.split('/') 

address = splitted_prefix[0] 

235 ↛ 236line 235 didn't jump to line 236, because the condition on line 235 was never true if len(splitted_prefix) > 2: 

module.fail_json(msg='Incorrect address format.', address=address) 

237 ↛ 243line 237 didn't jump to line 243, because the condition on line 237 was never false elif len(splitted_prefix) == 2: 

mask = splitted_prefix[1] 

network = network_from_string(address, mask, module) 

normalized_prefix = str(network) + '/' + str(mask) 

else: 

normalized_prefix = prefix + '/' + str(32) 

return normalized_prefix 

def map_params_to_obj(module): 

obj = [] 

aggregate = module.params.get('aggregate') 

if aggregate: 

for item in aggregate: 

for key in item: 

if item.get(key) is None: 

item[key] = module.params[key] 

d = item.copy() 

obj.append(d) 

else: 

obj.append({ 

'prefix': module.params['prefix'], 

'next_hop': module.params['next_hop'], 

'vrf': module.params['vrf'], 

'tag': module.params['tag'], 

'route_name': module.params['route_name'], 

'pref': module.params['pref'], 

'state': module.params['state'] 

}) 

return obj 

def main(): 

element_spec = dict( 

prefix=dict(type='str', aliases=['address']), 

next_hop=dict(type='str'), 

vrf=dict(type='str', default='default'), 

tag=dict(type='str'), 

route_name=dict(type='str'), 

pref=dict(type='str', aliases=['admin_distance']), 

state=dict(choices=['absent', 'present'], default='present'), 

) 

aggregate_spec = deepcopy(element_spec) 

aggregate_spec['prefix'] = dict(required=True) 

aggregate_spec['next_hop'] = dict(required=True) 

# remove default in aggregate spec, to handle common arguments 

remove_default_spec(aggregate_spec) 

argument_spec = dict( 

aggregate=dict(type='list', elements='dict', options=aggregate_spec) 

) 

argument_spec.update(element_spec) 

argument_spec.update(nxos_argument_spec) 

module = AnsibleModule( 

argument_spec=argument_spec, 

supports_check_mode=True, 

) 

warnings = list() 

result = {'changed': False, 'commands': []} 

305 ↛ 306line 305 didn't jump to line 306, because the condition on line 305 was never true if warnings: 

result['warnings'] = warnings 

want = map_params_to_obj(module) 

for w in want: 

prefix = normalize_prefix(module, w['prefix']) 

candidate = CustomNetworkConfig(indent=3) 

reconcile_candidate(module, candidate, prefix, w) 

if candidate: 

candidate = candidate.items_text() 

load_config(module, candidate) 

result['commands'].extend(candidate) 

result['changed'] = True 

else: 

result['commands'] = [] 

module.exit_json(**result) 

324 ↛ exitline 324 didn't exit the module, because the condition on line 324 was never falseif __name__ == '__main__': 

main()