mirror of
https://github.com/ansible-collections/community.general.git
synced 2025-04-25 11:51:26 -07:00
92a425a532
* Make it easier to find network modules Feedback has been it's difficult (via Google or directly) to find modules as some people search for the company name vs product name, therefore specify both. * "IOS XR" (not "IOS-XR")
431 lines
13 KiB
Python
431 lines
13 KiB
Python
#!/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.0',
|
|
'status': ['preview'],
|
|
'supported_by': 'core'}
|
|
|
|
|
|
DOCUMENTATION = """
|
|
---
|
|
module: iosxr_facts
|
|
version_added: "2.2"
|
|
author: "Ricardo Carrillo Cruz (@rcarrillocruz)"
|
|
short_description: Collect facts from remote devices running IOS XR
|
|
description:
|
|
- Collects a base set of device facts from a remote device that
|
|
is running IOS XR. This module prepends all of the
|
|
base network fact keys with C(ansible_net_<fact>). The facts
|
|
module will always collect a base set of facts from the device
|
|
and can enable or disable collection of additional facts.
|
|
extends_documentation_fragment: iosxr
|
|
options:
|
|
gather_subset:
|
|
description:
|
|
- When supplied, this argument will restrict the facts collected
|
|
to a given subset. Possible values for this argument include
|
|
all, hardware, config, and interfaces. Can specify a list of
|
|
values to include a larger subset. Values can also be used
|
|
with an initial C(M(!)) to specify that a specific subset should
|
|
not be collected.
|
|
required: false
|
|
default: '!config'
|
|
"""
|
|
|
|
EXAMPLES = """
|
|
# Collect all facts from the device
|
|
- iosxr_facts:
|
|
gather_subset: all
|
|
|
|
# Collect only the config and default facts
|
|
- iosxr_facts:
|
|
gather_subset:
|
|
- config
|
|
|
|
# Do not collect hardware facts
|
|
- iosxr_facts:
|
|
gather_subset:
|
|
- "!hardware"
|
|
"""
|
|
|
|
RETURN = """
|
|
ansible_net_gather_subset:
|
|
description: The list of fact subsets collected from the device
|
|
returned: always
|
|
type: list
|
|
|
|
# default
|
|
ansible_net_version:
|
|
description: The operating system version running on the remote device
|
|
returned: always
|
|
type: str
|
|
ansible_net_hostname:
|
|
description: The configured hostname of the device
|
|
returned: always
|
|
type: string
|
|
ansible_net_image:
|
|
description: The image file the device is running
|
|
returned: always
|
|
type: string
|
|
|
|
# hardware
|
|
ansible_net_filesystems:
|
|
description: All file system names available on the device
|
|
returned: when hardware is configured
|
|
type: list
|
|
ansible_net_memfree_mb:
|
|
description: The available free memory on the remote device in Mb
|
|
returned: when hardware is configured
|
|
type: int
|
|
ansible_net_memtotal_mb:
|
|
description: The total memory on the remote device in Mb
|
|
returned: when hardware is configured
|
|
type: int
|
|
|
|
# config
|
|
ansible_net_config:
|
|
description: The current active config from the device
|
|
returned: when config is configured
|
|
type: str
|
|
|
|
# interfaces
|
|
ansible_net_all_ipv4_addresses:
|
|
description: All IPv4 addresses configured on the device
|
|
returned: when interfaces is configured
|
|
type: list
|
|
ansible_net_all_ipv6_addresses:
|
|
description: All IPv6 addresses configured on the device
|
|
returned: when interfaces is configured
|
|
type: list
|
|
ansible_net_interfaces:
|
|
description: A hash of all interfaces running on the system
|
|
returned: when interfaces is configured
|
|
type: dict
|
|
ansible_net_neighbors:
|
|
description: The list of LLDP neighbors from the remote device
|
|
returned: when interfaces is configured
|
|
type: dict
|
|
"""
|
|
import re
|
|
|
|
from ansible.module_utils.iosxr import run_commands
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible.module_utils.six import iteritems
|
|
from ansible.module_utils.six.moves import zip
|
|
from ansible.module_utils.iosxr import iosxr_argument_spec, check_args
|
|
|
|
|
|
class FactsBase(object):
|
|
|
|
def __init__(self):
|
|
self.facts = dict()
|
|
self.commands()
|
|
|
|
def commands(self):
|
|
raise NotImplementedError
|
|
|
|
|
|
class Default(FactsBase):
|
|
|
|
def commands(self):
|
|
return(['show version brief'])
|
|
|
|
def populate(self, results):
|
|
self.facts['version'] = self.parse_version(results['show version brief'])
|
|
self.facts['image'] = self.parse_image(results['show version brief'])
|
|
self.facts['hostname'] = self.parse_hostname(results['show version brief'])
|
|
|
|
def parse_version(self, data):
|
|
match = re.search(r'Version (\S+)$', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_hostname(self, data):
|
|
match = re.search(r'^(.+) uptime', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_image(self, data):
|
|
match = re.search(r'image file is "(.+)"', data)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
|
|
class Hardware(FactsBase):
|
|
|
|
def commands(self):
|
|
return(['dir /all', 'show memory summary'])
|
|
|
|
def populate(self, results):
|
|
self.facts['filesystems'] = self.parse_filesystems(
|
|
results['dir /all'])
|
|
|
|
match = re.search(r'Physical Memory (\d+)M total \((\d+)',
|
|
results['show memory summary'])
|
|
if match:
|
|
self.facts['memtotal_mb'] = int(match[0])
|
|
self.facts['memfree_mb'] = int(match[1])
|
|
|
|
def parse_filesystems(self, data):
|
|
return re.findall(r'^Directory of (\S+)', data, re.M)
|
|
|
|
|
|
class Config(FactsBase):
|
|
|
|
def commands(self):
|
|
return(['show running-config'])
|
|
|
|
def populate(self, results):
|
|
self.facts['config'] = results['show running-config']
|
|
|
|
|
|
class Interfaces(FactsBase):
|
|
|
|
def commands(self):
|
|
return(['show interfaces', 'show ipv6 interface',
|
|
'show lldp', 'show lldp neighbors detail'])
|
|
|
|
def populate(self, results):
|
|
self.facts['all_ipv4_addresses'] = list()
|
|
self.facts['all_ipv6_addresses'] = list()
|
|
|
|
interfaces = self.parse_interfaces(results['show interfaces'])
|
|
self.facts['interfaces'] = self.populate_interfaces(interfaces)
|
|
|
|
data = results['show ipv6 interface']
|
|
if len(data) > 0:
|
|
data = self.parse_interfaces(data)
|
|
self.populate_ipv6_interfaces(data)
|
|
|
|
if 'LLDP is not enabled' not in results['show lldp']:
|
|
neighbors = results['show lldp neighbors detail']
|
|
self.facts['neighbors'] = self.parse_neighbors(neighbors)
|
|
|
|
def populate_interfaces(self, interfaces):
|
|
facts = dict()
|
|
for key, value in iteritems(interfaces):
|
|
intf = dict()
|
|
intf['description'] = self.parse_description(value)
|
|
intf['macaddress'] = self.parse_macaddress(value)
|
|
|
|
ipv4 = self.parse_ipv4(value)
|
|
intf['ipv4'] = self.parse_ipv4(value)
|
|
if ipv4:
|
|
self.add_ip_address(ipv4['address'], 'ipv4')
|
|
|
|
intf['mtu'] = self.parse_mtu(value)
|
|
intf['bandwidth'] = self.parse_bandwidth(value)
|
|
intf['duplex'] = self.parse_duplex(value)
|
|
intf['lineprotocol'] = self.parse_lineprotocol(value)
|
|
intf['operstatus'] = self.parse_operstatus(value)
|
|
intf['type'] = self.parse_type(value)
|
|
|
|
facts[key] = intf
|
|
return facts
|
|
|
|
def populate_ipv6_interfaces(self, data):
|
|
for key, value in iteritems(data):
|
|
self.facts['interfaces'][key]['ipv6'] = list()
|
|
addresses = re.findall(r'\s+(.+), subnet', value, re.M)
|
|
subnets = re.findall(r', subnet is (.+)$', value, re.M)
|
|
for addr, subnet in zip(addresses, subnets):
|
|
ipv6 = dict(address=addr.strip(), subnet=subnet.strip())
|
|
self.add_ip_address(addr.strip(), 'ipv6')
|
|
self.facts['interfaces'][key]['ipv6'].append(ipv6)
|
|
|
|
def add_ip_address(self, address, family):
|
|
if family == 'ipv4':
|
|
self.facts['all_ipv4_addresses'].append(address)
|
|
else:
|
|
self.facts['all_ipv6_addresses'].append(address)
|
|
|
|
def parse_neighbors(self, neighbors):
|
|
facts = dict()
|
|
nbors = neighbors.split('------------------------------------------------')
|
|
for entry in nbors[1:]:
|
|
if entry == '':
|
|
continue
|
|
intf = self.parse_lldp_intf(entry)
|
|
if intf not in facts:
|
|
facts[intf] = list()
|
|
fact = dict()
|
|
fact['host'] = self.parse_lldp_host(entry)
|
|
fact['port'] = self.parse_lldp_port(entry)
|
|
facts[intf].append(fact)
|
|
return facts
|
|
|
|
def parse_interfaces(self, data):
|
|
parsed = dict()
|
|
key = ''
|
|
for line in data.split('\n'):
|
|
if len(line) == 0:
|
|
continue
|
|
elif line[0] == ' ':
|
|
parsed[key] += '\n%s' % line
|
|
else:
|
|
match = re.match(r'^(\S+)', line)
|
|
if match:
|
|
key = match.group(1)
|
|
parsed[key] = line
|
|
return parsed
|
|
|
|
def parse_description(self, data):
|
|
match = re.search(r'Description: (.+)$', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_macaddress(self, data):
|
|
match = re.search(r'address is (\S+)', data)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_ipv4(self, data):
|
|
match = re.search(r'Internet address is (\S+)/(\d+)', data)
|
|
if match:
|
|
addr = match.group(1)
|
|
masklen = int(match.group(2))
|
|
return dict(address=addr, masklen=masklen)
|
|
|
|
def parse_mtu(self, data):
|
|
match = re.search(r'MTU (\d+)', data)
|
|
if match:
|
|
return int(match.group(1))
|
|
|
|
def parse_bandwidth(self, data):
|
|
match = re.search(r'BW (\d+)', data)
|
|
if match:
|
|
return int(match.group(1))
|
|
|
|
def parse_duplex(self, data):
|
|
match = re.search(r'(\w+) Duplex', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_type(self, data):
|
|
match = re.search(r'Hardware is (.+),', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_lineprotocol(self, data):
|
|
match = re.search(r'line protocol is (.+)\s+?$', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_operstatus(self, data):
|
|
match = re.search(r'^(?:.+) is (.+),', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_lldp_intf(self, data):
|
|
match = re.search(r'^Local Interface: (.+)$', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_lldp_host(self, data):
|
|
match = re.search(r'System Name: (.+)$', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
def parse_lldp_port(self, data):
|
|
match = re.search(r'Port id: (.+)$', data, re.M)
|
|
if match:
|
|
return match.group(1)
|
|
|
|
|
|
FACT_SUBSETS = dict(
|
|
default=Default,
|
|
hardware=Hardware,
|
|
interfaces=Interfaces,
|
|
config=Config,
|
|
)
|
|
|
|
VALID_SUBSETS = frozenset(FACT_SUBSETS.keys())
|
|
|
|
|
|
def main():
|
|
spec = dict(
|
|
gather_subset=dict(default=['!config'], type='list')
|
|
)
|
|
|
|
spec.update(iosxr_argument_spec)
|
|
|
|
module = AnsibleModule(argument_spec=spec,
|
|
supports_check_mode=True)
|
|
|
|
warnings = list()
|
|
check_args(module, warnings)
|
|
|
|
gather_subset = module.params['gather_subset']
|
|
|
|
runable_subsets = set()
|
|
exclude_subsets = set()
|
|
|
|
for subset in gather_subset:
|
|
if subset == 'all':
|
|
runable_subsets.update(VALID_SUBSETS)
|
|
continue
|
|
|
|
if subset.startswith('!'):
|
|
subset = subset[1:]
|
|
if subset == 'all':
|
|
exclude_subsets.update(VALID_SUBSETS)
|
|
continue
|
|
exclude = True
|
|
else:
|
|
exclude = False
|
|
|
|
if subset not in VALID_SUBSETS:
|
|
module.fail_json(msg='Bad subset')
|
|
|
|
if exclude:
|
|
exclude_subsets.add(subset)
|
|
else:
|
|
runable_subsets.add(subset)
|
|
|
|
if not runable_subsets:
|
|
runable_subsets.update(VALID_SUBSETS)
|
|
|
|
runable_subsets.difference_update(exclude_subsets)
|
|
runable_subsets.add('default')
|
|
|
|
facts = dict()
|
|
facts['gather_subset'] = list(runable_subsets)
|
|
|
|
instances = list()
|
|
for key in runable_subsets:
|
|
instances.append(FACT_SUBSETS[key]())
|
|
|
|
try:
|
|
for inst in instances:
|
|
commands = inst.commands()
|
|
responses = run_commands(module, commands)
|
|
results = dict(zip(commands, responses))
|
|
inst.populate(results)
|
|
facts.update(inst.facts)
|
|
except Exception:
|
|
module.exit_json(out=module.from_json(results))
|
|
|
|
ansible_facts = dict()
|
|
for key, value in iteritems(facts):
|
|
key = 'ansible_net_%s' % key
|
|
ansible_facts[key] = value
|
|
|
|
module.exit_json(ansible_facts=ansible_facts, warnings=warnings)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|