mirror of
https://github.com/ansible-collections/community.general.git
synced 2025-05-21 16:39:08 -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")
271 lines
7.7 KiB
Python
271 lines
7.7 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: junos_facts
|
|
version_added: "2.1"
|
|
author: "Nathaniel Case (@qalthos)"
|
|
short_description: Collect facts from remote devices running Juniper Junos
|
|
description:
|
|
- Collects fact information from a remote device running the Junos
|
|
operating system. By default, the module will collect basic fact
|
|
information from the device to be included with the hostvars.
|
|
Additional fact information can be collected based on the
|
|
configured set of arguments.
|
|
extends_documentation_fragment: junos
|
|
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"
|
|
version_added: "2.3"
|
|
"""
|
|
|
|
EXAMPLES = """
|
|
- name: collect default set of facts
|
|
junos_facts:
|
|
|
|
- name: collect default set of facts and configuration
|
|
junos_facts:
|
|
gather_subset: config
|
|
"""
|
|
|
|
RETURN = """
|
|
ansible_facts:
|
|
description: Returns the facts collect from the device
|
|
returned: always
|
|
type: dict
|
|
"""
|
|
|
|
import re
|
|
from xml.etree.ElementTree import Element, SubElement, tostring
|
|
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible.module_utils.six import iteritems
|
|
from ansible.module_utils.junos import junos_argument_spec, check_args
|
|
from ansible.module_utils.junos import command, get_configuration
|
|
from ansible.module_utils.netconf import send_request
|
|
|
|
|
|
USE_PERSISTENT_CONNECTION = True
|
|
|
|
class FactsBase(object):
|
|
|
|
def __init__(self, module):
|
|
self.module = module
|
|
self.facts = dict()
|
|
|
|
def populate(self):
|
|
raise NotImplementedError
|
|
|
|
def cli(self, command):
|
|
reply = command(self.module, command)
|
|
output = reply.find('.//output')
|
|
if not output:
|
|
self.module.fail_json(msg='failed to retrieve facts for command %s' % command)
|
|
return str(output.text).strip()
|
|
|
|
def rpc(self, rpc):
|
|
return send_request(self.module, Element(rpc))
|
|
|
|
def get_text(self, ele, tag):
|
|
try:
|
|
return str(ele.find(tag).text).strip()
|
|
except AttributeError:
|
|
pass
|
|
|
|
|
|
class Default(FactsBase):
|
|
|
|
def populate(self):
|
|
reply = self.rpc('get-software-information')
|
|
data = reply.find('.//software-information')
|
|
|
|
self.facts.update({
|
|
'hostname': self.get_text(data, 'host-name'),
|
|
'version': self.get_text(data, 'junos-version'),
|
|
'model': self.get_text(data, 'product-model')
|
|
})
|
|
|
|
reply = self.rpc('get-chassis-inventory')
|
|
data = reply.find('.//chassis-inventory/chassis')
|
|
|
|
self.facts['serialnum'] = self.get_text(data, 'serial-number')
|
|
|
|
|
|
class Config(FactsBase):
|
|
|
|
def populate(self):
|
|
config_format = self.module.params['config_format']
|
|
reply = get_configuration(self.module, format=config_format)
|
|
|
|
if config_format =='xml':
|
|
config = tostring(reply.find('configuration')).strip()
|
|
|
|
elif config_format == 'text':
|
|
config = self.get_text(reply, 'configuration-text')
|
|
|
|
elif config_format == 'json':
|
|
config = str(reply.text).strip()
|
|
|
|
elif config_format == 'set':
|
|
config = self.get_text(reply, 'configuration-set')
|
|
|
|
self.facts['config'] = config
|
|
|
|
|
|
|
|
class Hardware(FactsBase):
|
|
|
|
def populate(self):
|
|
|
|
reply = self.rpc('get-system-memory-information')
|
|
data = reply.find('.//system-memory-information/system-memory-summary-information')
|
|
|
|
self.facts.update({
|
|
'memfree_mb': int(self.get_text(data, 'system-memory-free')),
|
|
'memtotal_mb': int(self.get_text(data, 'system-memory-total'))
|
|
})
|
|
|
|
reply = self.rpc('get-system-storage')
|
|
data = reply.find('.//system-storage-information')
|
|
|
|
filesystems = list()
|
|
for obj in data:
|
|
filesystems.append(self.get_text(obj, 'filesystem-name'))
|
|
self.facts['filesystems'] = filesystems
|
|
|
|
|
|
class Interfaces(FactsBase):
|
|
|
|
def populate(self):
|
|
ele = Element('get-interface-information')
|
|
SubElement(ele, 'detail')
|
|
reply = send_request(self.module, ele)
|
|
|
|
interfaces = {}
|
|
|
|
for item in reply[0]:
|
|
name = self.get_text(item, 'name')
|
|
obj = {
|
|
'oper-status': self.get_text(item, 'oper-status'),
|
|
'admin-status': self.get_text(item, 'admin-status'),
|
|
'speed': self.get_text(item, 'speed'),
|
|
'macaddress': self.get_text(item, 'hardware-physical-address'),
|
|
'mtu': self.get_text(item, 'mtu'),
|
|
'type': self.get_text(item, 'if-type'),
|
|
}
|
|
|
|
interfaces[name] = obj
|
|
|
|
self.facts['interfaces'] = interfaces
|
|
|
|
|
|
FACT_SUBSETS = dict(
|
|
default=Default,
|
|
hardware=Hardware,
|
|
config=Config,
|
|
interfaces=Interfaces,
|
|
)
|
|
|
|
VALID_SUBSETS = frozenset(FACT_SUBSETS.keys())
|
|
|
|
|
|
def main():
|
|
""" Main entry point for AnsibleModule
|
|
"""
|
|
argument_spec = dict(
|
|
gather_subset=dict(default=['!config'], type='list'),
|
|
config_format=dict(default='text', choices=['xml', 'text', 'set', 'json']),
|
|
)
|
|
|
|
argument_spec.update(junos_argument_spec)
|
|
|
|
module = AnsibleModule(argument_spec=argument_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='Subset must be one of [%s], got %s' %
|
|
(', '.join(VALID_SUBSETS), 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](module))
|
|
|
|
for inst in instances:
|
|
inst.populate()
|
|
facts.update(inst.facts)
|
|
|
|
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()
|