ansible/network/openswitch/ops_facts.py

415 lines
12 KiB
Python
Raw Normal View History

#!/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/>.
#
DOCUMENTATION = """
---
module: ops_facts
version_added: "2.1"
author: "Peter Sprygada (@privateip)"
short_description: Collect device specific facts from OpenSwitch
description:
- Collects facts from devices running the OpenSwitch operating
system. Fact collection is supported over both Cli and Rest
transports. 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.
- The facts collected from pre Ansible 2.2 are still available and
are collected for backwards compatibility; however, these facts
should be considered deprecated and will be removed in a future
release.
extends_documentation_fragment: openswitch
options:
config:
description:
- When enabled, this argument will collect the current
running configuration from the remote device. If the
2016-08-05 15:40:52 +02:00
C(transport=rest) then the collected configuration will
be the full system configuration.
required: false
2016-08-05 15:40:52 +02:00
choices:
- true
- false
default: false
endpoints:
description:
- Accepts a list of endpoints to retrieve from the remote
device using the REST API. The endpoints should be valid
2016-08-05 15:40:52 +02:00
endpoints available on the device. This argument is only
valid when the C(transport=rest).
required: false
default: null
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, legacy, 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.2"
"""
EXAMPLES = """
# Note: examples below use the following provider dict to handle
# transport and authentication to the node.
vars:
cli:
host: "{{ inventory_hostname }}"
username: netop
password: netop
transport: cli
rest:
host: "{{ inventory_hostname }}"
username: netop
password: netop
transport: rest
- ops_facts:
gather_subset: all
provider: "{{ rest }}"
# Collect only the config and default facts
- ops_facts:
gather_subset: config
provider: "{{ cli }}"
# Do not collect config facts
- ops_facts:
gather_subset:
- "!config"
provider: "{{ cli }}"
- name: collect device facts
ops_facts:
provider: "{{ cli }}"
- name: include the config
ops_facts:
config: yes
provider: "{{ rest }}"
- name: include a set of rest endpoints
ops_facts:
endpoints:
- /system/interfaces/1
- /system/interfaces/2
provider: "{{ rest }}"
"""
RETURN = """
ansible_net_gather_subset:
description: The list of fact subsets collected from the device
returned: always
type: list
# default
ansible_net_model:
description: The model name returned from the device
returned: when transport is cli
type: str
ansible_net_serialnum:
description: The serial number of the remote device
returned: when transport is cli
type: str
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: when transport is cli
type: string
# config
ansible_net_config:
description: The current active config from the device
returned: when config is enabled
type: str
# legacy (pre Ansible 2.2)
config:
description: The current system configuration
returned: when enabled
type: string
sample: '....'
hostname:
description: returns the configured hostname
returned: always
type: string
sample: ops01
version:
description: The current version of OpenSwitch
returned: always
type: string
sample: '0.3.0'
endpoints:
description: The JSON response from the URL endpoint
returned: when endpoints argument is defined and transport is rest
type: list
sample: [{....}, {....}]
"""
import re
from ansible.module_utils.basic import get_exception
from ansible.module_utils.netcli import CommandRunner, AddCommandError
from ansible.module_utils.openswitch import NetworkModule
2016-08-05 15:40:52 +02:00
def add_command(runner, command):
try:
runner.add_command(command)
except AddCommandError:
# AddCommandError is raised for any issue adding a command to
# the runner. Silently ignore the exception in this case
pass
2016-08-05 15:40:52 +02:00
class FactsBase(object):
2016-08-05 15:40:52 +02:00
def __init__(self, module, runner):
self.module = module
self.transport = module.params['transport']
self.runner = runner
self.facts = dict()
if self.transport == 'cli':
self.commands()
def populate(self):
getattr(self, self.transport)()
def cli(self):
pass
def rest(self):
pass
class Default(FactsBase):
def commands(self):
add_command(self.runner, 'show system')
add_command(self.runner, 'show hostname')
def rest(self):
self.facts.update(self.get_system())
def cli(self):
data = self.runner.get_command('show system')
self.facts['version'] = self.parse_version(data)
self.facts['serialnum'] = self.parse_serialnum(data)
self.facts['model'] = self.parse_model(data)
self.facts['image'] = self.parse_image(data)
self.facts['hostname'] = self.runner.get_command('show hostname')
def parse_version(self, data):
match = re.search(r'OpenSwitch Version\s+: (\S+)', data)
if match:
return match.group(1)
def parse_model(self, data):
match = re.search(r'Platform\s+:\s(\S+)', data, re.M)
if match:
return match.group(1)
def parse_image(self, data):
match = re.search(r'\(Build: (\S+)\)', data, re.M)
if match:
return match.group(1)
def parse_serialnum(self, data):
match = re.search(r'Serial Number\s+: (\S+)', data)
if match:
return match.group(1)
def get_system(self):
response = self.module.connection.get('/system')
return dict(
hostname=response.json['configuration']['hostname'],
version=response.json['status']['switch_version']
)
class Config(FactsBase):
def commands(self):
add_command(self.runner, 'show running-config')
def cli(self):
self.facts['config'] = self.runner.get_command('show running-config')
class Legacy(FactsBase):
# facts from ops_facts 2.1
def commands(self):
add_command(self.runner, 'show system')
add_command(self.runner, 'show hostname')
if self.module.params['config']:
add_command(self.runner, 'show running-config')
def rest(self):
self.facts['_endpoints'] = self.get_endpoints()
self.facts.update(self.get_system())
if self.module.params['config']:
self.facts['_config'] = self.get_config()
def cli(self):
self.facts['_hostname'] = self.runner.get_command('show hostname')
data = self.runner.get_command('show system')
self.facts['_version'] = self.parse_version(data)
if self.module.params['config']:
self.facts['_config'] = self.runner.get_command('show running-config')
def parse_version(self, data):
match = re.search(r'OpenSwitch Version\s+: (\S+)', data)
if match:
return match.group(1)
def get_endpoints(self):
responses = list()
urls = self.module.params['endpoints'] or list()
for ep in urls:
response = self.module.connection.get(ep)
if response.headers['status'] != 200:
self.module.fail_json(msg=response.headers['msg'])
responses.append(response.json)
return responses
def get_system(self):
response = self.module.connection.get('/system')
return dict(
_hostname=response.json['configuration']['hostname'],
_version=response.json['status']['switch_version']
)
def get_config(self):
response = self.module.connection.get('/system/full-configuration')
return response.json
def check_args(module, warnings):
if module.params['transport'] != 'rest' and module.params['endpoints']:
warnings.append('Endpoints can only be collected when transport is '
'set to "rest". Endpoints will not be collected')
FACT_SUBSETS = dict(
default=Default,
config=Config,
legacy=Legacy
)
VALID_SUBSETS = frozenset(FACT_SUBSETS.keys())
def main():
spec = dict(
gather_subset=dict(default=['!config'], type='list'),
# the next two arguments are legacy from pre 2.2 ops_facts
# these will be deprecated and ultimately removed
config=dict(default=False, type='bool'),
endpoints=dict(type='list'),
transport=dict(default='cli', choices=['cli', 'rest'])
)
module = NetworkModule(argument_spec=spec, supports_check_mode=True)
gather_subset = module.params['gather_subset']
warnings = list()
check_args(module, warnings)
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')
runable_subsets.add('legacy')
facts = dict()
facts['gather_subset'] = list(runable_subsets)
runner = CommandRunner(module)
instances = list()
for key in runable_subsets:
instances.append(FACT_SUBSETS[key](module, runner))
if module.params['transport'] == 'cli':
runner.run()
try:
for inst in instances:
inst.populate()
facts.update(inst.facts)
except Exception:
raise
module.exit_json(out=module.from_json(runner.items))
ansible_facts = dict()
for key, value in facts.iteritems():
# this is to maintain capability with ops_facts 2.1
if key.startswith('_'):
ansible_facts[key[1:]] = value
else:
key = 'ansible_net_%s' % key
ansible_facts[key] = value
module.exit_json(ansible_facts=ansible_facts, warnings=warnings)
if __name__ == '__main__':
main()