diff --git a/.gitignore b/.gitignore index aa861ed..f1012bf 100644 --- a/.gitignore +++ b/.gitignore @@ -54,3 +54,5 @@ docs/_build/ .idea .DS_Store + +env diff --git a/AUTHORS b/AUTHORS index f7323fc..775f066 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,2 +1,6 @@ David Barroso +<<<<<<< HEAD +Elisa Jasinska +======= Elisa Jasinska +>>>>>>> master diff --git a/Manifest.in b/Manifest.in index 540b720..16c0d1a 100644 --- a/Manifest.in +++ b/Manifest.in @@ -1 +1,2 @@ -include requirements.txt \ No newline at end of file +include requirements.txt +include utils/*.yml diff --git a/ansible/napalm_get_facts b/ansible/napalm_get_facts new file mode 100644 index 0000000..3f5933b --- /dev/null +++ b/ansible/napalm_get_facts @@ -0,0 +1,66 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# Copyright 2014 Spotify AB. All rights reserved. +# +# The contents of this file are 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. + + +""" +""" + +import ast +import logging + +logger = logging.getLogger('eos_install_config') + +DOCUMENTATION = ''' +''' + +EXAMPLES = ''' +''' + + +def main(): + module = AnsibleModule( + argument_spec=dict( + hostname=dict(required=True), + username=dict(required=True), + password=dict(required=True), + dev_os=dict(required=True), + ), + supports_check_mode=True + ) + + hostname = module.params['hostname'] + username = module.params['username'] + dev_os = module.params['dev_os'] + password = module.params['password'] + + + network_driver = get_network_driver(dev_os) + + device = network_driver(hostname, username, password) + device.open() + + facts = device.get_facts() + facts['interface_details'] = device.get_interfaces() + + device.close() + + module.exit_json(ansible_facts=facts) + +from ansible.module_utils.basic import * +from napalm import get_network_driver + +main() diff --git a/napalm/fortios.py b/napalm/fortios.py index 11efd2c..f0945e4 100644 --- a/napalm/fortios.py +++ b/napalm/fortios.py @@ -18,6 +18,22 @@ from pyFG.exceptions import FailedCommit, CommandExecutionException from base import NetworkDriver from exceptions import ReplaceConfigException, MergeConfigException +from utils.string_parsers import colon_separated_string_to_dict, convert_uptime_string_seconds + + +def execute_get(device, cmd, separator=':', auto=False): + output = device.execute_command(cmd) + + if auto: + if ':' in output[0]: + separator=':' + elif '\t' in output[0]: + separator='\t' + else: + raise Exception('Unknown separator for block:\n{}'.format(output)) + + return colon_separated_string_to_dict('\n'.join(output), separator) + class FortiOSDriver(NetworkDriver): @@ -96,4 +112,101 @@ class FortiOSDriver(NetworkDriver): self.device.candidate_config['vpn certificate local']['Fortinet_CA_SSLProxy'].del_param('certificate') self.device.candidate_config['vpn certificate local']['Fortinet_SSLProxy'].del_param('private-key') self.device.candidate_config['vpn certificate local']['Fortinet_SSLProxy'].del_param('certificate') - self.device.commit() \ No newline at end of file + self.device.commit() + + def get_facts(self): + system_status = execute_get(self.device, 'get system status') + performance_status = execute_get(self.device, 'get system performance status') + + interfaces = execute_get(self.device, 'get system interface | grep ==') + interface_list = [x.split()[2] for x in interfaces.keys()] + + domain = execute_get(self.device, 'get system dns | grep domain')['domain'] + + return { + 'vendor': 'Fortigate', + 'os_version': system_status['Version'].split(',')[0].split()[1], + 'uptime': convert_uptime_string_seconds(performance_status['Uptime']), + 'serial_number': system_status['Serial-Number'], + 'model': system_status['Version'].split(',')[0].split()[0], + 'hostname': system_status['Hostname'], + 'fqdn': '{}.{}'.format(system_status['Hostname'], domain), + 'interface_list': interface_list + } + + @staticmethod + def _get_tab_separated_interfaces(output): + interface_statistics = { + 'is_up': ('up' in output['State'] and 'up' or 'down'), + 'speed': output['Speed'], + 'mac_adddress': output['Current_HWaddr'] + } + return interface_statistics + + @staticmethod + def _get_unsupported_interfaces(): + return { + 'is_up': None, + 'is_enabled': None, + 'description': None, + 'last_flapped': None, + 'mode': None, + 'speed': None, + 'mac_address': None + } + + def get_interfaces(self): + interface_statistics = dict() + self.device.load_config('system interface') + for iface in self.get_facts()['interface_list']: + try: + hw_output = execute_get(self.device, 'diagnose hardware deviceinfo nic {}'.format(iface), auto=True) + ifs = self._get_tab_separated_interfaces(hw_output) + + ifs['is_enabled'] = self.device.running_config['system interface'][iface].get_param('status') != 'down' + ifs['description'] = self.device.running_config['system interface'][iface].get_param('description') + ifs['last_flapped'] = None + #ifs['mode'] = 'routed' + ifs['last_flapped'] = None + interface_statistics[iface] = ifs + except CommandExecutionException: + interface_statistics[iface] = self._get_unsupported_interfaces() + + return interface_statistics + + # def get_bgp_neighbors(self): + # bgp_sum = self.device.execute_command('get router info bgp sum') + # re_neigh = re.compile("^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+") + # neighbors = {n.split()[0]: n.split()[1:] for n in bgp_sum if re.match(re_neigh, n)} + # + # peers = dict() + # + # self.device.load_config('router bgp') + # + # for neighbor, parameters in neighbors.iteritems(): + # neigh_conf = self.device.running_config['router bgp']['neighbor']['{}'.format(neighbor)] + # peers[neighbor] = dict() + # peers[neighbor]['remote_as'] = int(neigh_conf.get_param('remote-as')) + # peers[neighbor]['is_enabled'] = neigh_conf.get_param('shutdown') != 'enable' or False + # peers[neighbor]['is_up'] = 'never' != parameters[7] or False + # peers[neighbor]['uptime'] = convert_uptime_string_seconds(parameters[7]) + # peers[neighbor]['accepted_prefixes'] = int(self.device.execute_command('get router info bgp neighbor {} | grep "accepted prefixes"'.format(neighbor))[0].split()[0]) + # peers[neighbor]['sent_prefixes'] = int(self.device.execute_command('get router info bgp neighbor {} | grep "announced prefixes"'.format(neighbor))[0].split()[0]) + # + # received = self.device.execute_command('get router info bgp neighbors {} received-routes | grep prefixes'.format(neighbor))[0].split() + # if len(received) > 0: + # peers[neighbor]['received_prefixes'] = int(received[-1]) + # else: + # # Soft-reconfig is not enabled + # peers[neighbor]['received_prefixes'] = 0 + # + # return { + # 'default': { + # 'local_as': int(bgp_sum[0].split()[7]), + # 'router_id': bgp_sum[0].split()[3], + # 'peers': peers + # } + # } + + def get_lldp_neighbors(self): + return {} diff --git a/utils/__init__.py b/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/utils/junos_views.py b/utils/junos_views.py new file mode 100755 index 0000000..a8f014d --- /dev/null +++ b/utils/junos_views.py @@ -0,0 +1,7 @@ +""" +Load tables/views +""" +from jnpr.junos.factory import loadyaml +from os.path import splitext +_YAML_ = splitext(__file__)[0] + '.yml' +globals().update(loadyaml(_YAML_)) diff --git a/utils/junos_views.yml b/utils/junos_views.yml new file mode 100644 index 0000000..e3f3be5 --- /dev/null +++ b/utils/junos_views.yml @@ -0,0 +1,69 @@ +--- + +#### +#### Interface table +#### + +junos_iface_table: + rpc: get-interface-information + args: + extensive: True + args_key: interface_name + item: physical-interface + view: junos_iface_view + +junos_iface_view: + fields: + is_up: { oper-status: True=up } + is_enabled: { admin-status: True=up } + description: description + last_flapped: { interface-flapped/@seconds: int } + #mode: logical-interface/address-family/address-family-name + speed: speed + mac_address: current-physical-address + +#### +#### BGP tables +#### + +junos_route_instance_table: + rpc: get-instance-information + item: instance-core + key: instance-name + view: junos_route_instance_view + +junos_route_instance_view: + fields: + name: instance-name + +junos_bgp_table: + rpc: get-bgp-summary-information + item: bgp-peer + key: peer-address + view: junos_bgp_view + +junos_bgp_view: + fields: + remote_as: { peer-as: int } + description: description + is_up: { peer-state: True=Established } + is_enabled: { peer-state: False=True } + uptime: { elapsed-time/@seconds: int } + received_prefixes: { bgp-rib/received-prefix-count: int } + accepted_prefixes: { bgp-rib/accepted-prefix-count: int } + sent_prefixes: { bgp-rib/aadvertised-prefix-count: int } + +#### +#### LLDP table +#### + +junos_lldp_table: + rpc: get-lldp-neighbors-information + item: lldp-neighbor-information + key: lldp-local-port-id | lldp-local-interface + view: junos_lldp_view + +junos_lldp_view: + fields: + hostname: lldp-remote-system-name + port: lldp-remote-port-description | lldp-remote-port-id diff --git a/utils/string_parsers.py b/utils/string_parsers.py new file mode 100644 index 0000000..161d939 --- /dev/null +++ b/utils/string_parsers.py @@ -0,0 +1,99 @@ +import re + +def sorted_nicely( l ): + """ Sort the given iterable in the way that humans expect.""" + convert = lambda text: int(text) if text.isdigit() else text + alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ] + return sorted(l, key = alphanum_key) + +def colon_separated_string_to_dict(string, separator=':'): + ''' + Converts a string in the format: + + Name: Et3 + Switchport: Enabled + Administrative Mode: trunk + Operational Mode: trunk + MAC Address Learning: enabled + Access Mode VLAN: 3 (VLAN0003) + Trunking Native Mode VLAN: 1 (default) + Administrative Native VLAN tagging: disabled + Administrative private VLAN mapping: ALL + Trunking VLANs Enabled: 2-3,5-7,20-21,23,100-200 + Trunk Groups: + + into a dictionary + + ''' + dictionary = dict() + + for line in string.splitlines(): + line_data = line.split(separator) + + if len(line_data) > 1: + dictionary[line_data[0].strip()] = ''.join(line_data[1:]).strip() + elif len(line_data) == 1: + dictionary[line_data[0].strip()] = None + else: + raise Exception('Something went wrong parsing the colo separated string {}'.format(line)) + + return dictionary + +def hyphen_range(string): + ''' + Expands a string of numbers separated by commas and hyphens into a list of integers. + For example: 2-3,5-7,20-21,23,100-200 + ''' + list_numbers = list() + temporary_list = string.split(',') + + for element in temporary_list: + sub_element = element.split('-') + + if len(sub_element) == 1: + list_numbers.append(int(sub_element[0])) + elif len(sub_element) == 2: + for x in range(int(sub_element[0]), int(sub_element[1])+1): + list_numbers.append(x) + else: + raise Exception('Something went wrong expanding the range'.format(string)) + + return list_numbers + +def convert_uptime_string_seconds(uptime): + ''' + Convert uptime strings to seconds. The string can be formatted various ways, eg. + 1 hour, 56 minutes + ''' + regex_1 = re.compile(r"((?P\d+) week(s)?,\s+)?((?P\d+) day(s)?,\s+)?((?P\d+) hour(s)?,\s+)?((?P\d+) minute(s)?)") + regex_2 = re.compile(r"((?P\d+)):((?P\d+)):((?P\d+))") + + regex_list = [regex_1, regex_2] + + uptime_dict = dict() + for regex in regex_list: + uptime_dict = regex.search(uptime) + if uptime_dict is not None: + uptime_dict = uptime_dict.groupdict() + break + uptime_dict = dict() + + uptime_seconds = 0 + + for unit, value in uptime_dict.iteritems(): + if value != None: + if unit == 'weeks': + uptime_seconds += int(value) * 604800 + elif unit == 'days': + uptime_seconds += int(value) * 86400 + elif unit == 'hours': + uptime_seconds += int(value) * 3600 + elif unit == 'minutes': + uptime_seconds += int(value) * 60 + elif unit == 'seconds': + uptime_seconds += int(value) + else: + raise Exception('Unrecognized unit "{}" in uptime:{}'.format(unit, uptime)) + + return uptime_seconds +