From 44265b37813189f2012c8676aee988083a81ff82 Mon Sep 17 00:00:00 2001 From: GGabriele Date: Wed, 14 Sep 2016 16:48:38 +0200 Subject: [PATCH] Adding nxos_install_os --- network/nxos/nxos_install_os.py | 389 ++++++++++++++++++++++++++++++++ 1 file changed, 389 insertions(+) create mode 100644 network/nxos/nxos_install_os.py diff --git a/network/nxos/nxos_install_os.py b/network/nxos/nxos_install_os.py new file mode 100644 index 00000000000..16935771597 --- /dev/null +++ b/network/nxos/nxos_install_os.py @@ -0,0 +1,389 @@ +#!/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 . +# + +DOCUMENTATION = ''' +--- +module: nxos_install_os +short_description: Set boot options like boot image and kickstart image. +description: + - Install an operating system by setting the boot options like boot + image and kickstart image. +notes: + - The module will fail due to timeout issues, but the install will go on + anyway. Ansible's block and rescue can be leveraged to handle this kind + of failure and check actual module results. See EXAMPLE for more about + this. + - Do not include full file paths, just the name of the file(s) stored on + the top level flash directory. + - You must know if your platform supports taking a kickstart image as a + parameter. If supplied but not supported, errors may occur. + - This module attempts to install the software immediately, + wich may trigger a reboot. + - In check mode, the module tells you if the current boot images are set + to the desired images. +author: + - Jason Edelman (@jedelman8) + - Gabriele Gerbibo (@GGabriele) +version_added: 2.2 +options: + system_image_file: + description: + - Name of the system (or combined) image file on flash. + required: true + kickstart_image_file: + description: + - Name of the kickstart image file on flash. + required: false + default: null +''' + +EXAMPLES = ''' +- block: + - name: Install OS + nxos_install_os: + system_image_file: nxos.7.0.3.I2.2d.bin + host: "{{ inventory_hostname }}" + username: "{{ un }}" + password: "{{ pwd }}" + transport: nxapi + rescue: + - name: Wait for device to come back up + wait_for: + port: 22 + state: started + timeout: 300 + delay: 60 + host: "{{ inventory_hostname }}" + - name: Check installed OS + nxos_command: + commands: + - show version + username: "{{ un }}" + password: "{{ pwd }}" + host: "{{ inventory_hostname }}" + transport: nxapi + register: output + - assert: + that: + - output['stdout'][0]['kickstart_ver_str'] == '7.0(3)I4(1)' +''' + + +# COMMON CODE FOR MIGRATION +import re + +from ansible.module_utils.basic import get_exception +from ansible.module_utils.netcfg import NetworkConfig, ConfigLine +from ansible.module_utils.shell import ShellError + +try: + from ansible.module_utils.nxos import get_module +except ImportError: + from ansible.module_utils.nxos import NetworkModule + + +def to_list(val): + if isinstance(val, (list, tuple)): + return list(val) + elif val is not None: + return [val] + else: + return list() + + +class CustomNetworkConfig(NetworkConfig): + + def expand_section(self, configobj, S=None): + if S is None: + S = list() + S.append(configobj) + for child in configobj.children: + if child in S: + continue + self.expand_section(child, S) + return S + + def get_object(self, path): + for item in self.items: + if item.text == path[-1]: + parents = [p.text for p in item.parents] + if parents == path[:-1]: + return item + + def to_block(self, section): + return '\n'.join([item.raw for item in section]) + + def get_section(self, path): + try: + section = self.get_section_objects(path) + return self.to_block(section) + except ValueError: + return list() + + def get_section_objects(self, path): + if not isinstance(path, list): + path = [path] + obj = self.get_object(path) + if not obj: + raise ValueError('path does not exist in config') + return self.expand_section(obj) + + + def add(self, lines, parents=None): + """Adds one or lines of configuration + """ + + ancestors = list() + offset = 0 + obj = None + + ## global config command + if not parents: + for line in to_list(lines): + item = ConfigLine(line) + item.raw = line + if item not in self.items: + self.items.append(item) + + else: + for index, p in enumerate(parents): + try: + i = index + 1 + obj = self.get_section_objects(parents[:i])[0] + ancestors.append(obj) + + except ValueError: + # add parent to config + offset = index * self.indent + obj = ConfigLine(p) + obj.raw = p.rjust(len(p) + offset) + if ancestors: + obj.parents = list(ancestors) + ancestors[-1].children.append(obj) + self.items.append(obj) + ancestors.append(obj) + + # add child objects + for line in to_list(lines): + # check if child already exists + for child in ancestors[-1].children: + if child.text == line: + break + else: + offset = len(parents) * self.indent + item = ConfigLine(line) + item.raw = line.rjust(len(line) + offset) + item.parents = ancestors + ancestors[-1].children.append(item) + self.items.append(item) + + +def get_network_module(**kwargs): + try: + return get_module(**kwargs) + except NameError: + return NetworkModule(**kwargs) + +def get_config(module, include_defaults=False): + config = module.params['config'] + if not config: + try: + config = module.get_config() + except AttributeError: + defaults = module.params['include_defaults'] + config = module.config.get_config(include_defaults=defaults) + return CustomNetworkConfig(indent=2, contents=config) + +def load_config(module, candidate): + config = get_config(module) + + commands = candidate.difference(config) + commands = [str(c).strip() for c in commands] + + save_config = module.params['save'] + + result = dict(changed=False) + + if commands: + if not module.check_mode: + try: + module.configure(commands) + except AttributeError: + module.config(commands) + + if save_config: + try: + module.config.save_config() + except AttributeError: + module.execute(['copy running-config startup-config']) + + result['changed'] = True + result['updates'] = commands + + return result +# END OF COMMON CODE + + +def execute_show(cmds, module, command_type=None): + command_type_map = { + 'cli_show': 'json', + 'cli_show_ascii': 'text' + } + + try: + if command_type: + response = module.execute(cmds, command_type=command_type) + else: + response = module.execute(cmds) + except ShellError: + clie = get_exception() + module.fail_json(msg='Error sending {0}'.format(cmds), + error=str(clie)) + except AttributeError: + try: + if command_type: + command_type = command_type_map.get(command_type) + module.cli.add_commands(cmds, output=command_type) + response = module.cli.run_commands() + else: + module.cli.add_commands(cmds, output=command_type) + response = module.cli.run_commands() + except ShellError: + clie = get_exception() + module.fail_json(msg='Error sending {0}'.format(cmds), + error=str(clie)) + return response + + +def execute_show_command(command, module, command_type='cli_show_ascii'): + cmds = [command] + if module.params['transport'] == 'cli': + body = execute_show(cmds, module) + elif module.params['transport'] == 'nxapi': + body = execute_show(cmds, module, command_type=command_type) + + return body + + +def execute_config_command(commands, module): + try: + module.configure(commands) + except ShellError: + clie = get_exception() + module.fail_json(msg='Error sending CLI commands', + error=str(clie), commands=commands) + except AttributeError: + try: + commands.insert(0, 'configure') + module.cli.add_commands(commands, output='config') + module.cli.run_commands() + except ShellError: + clie = get_exception() + module.fail_json(msg='Error sending CLI commands', + error=str(clie), commands=commands) + + +def get_boot_options(module): + """Get current boot variables + like system image and kickstart image. + Returns: + A dictionary, e.g. { 'kick': router_kick.img, 'sys': 'router_sys.img'} + """ + command = 'show boot' + body = execute_show_command(command, module)[0] + boot_options_raw_text = body.split('Boot Variables on next reload')[1] + + if 'kickstart' in boot_options_raw_text: + kick_regex = r'kickstart variable = bootflash:/(\S+)' + sys_regex = r'system variable = bootflash:/(\S+)' + + kick = re.search(kick_regex, boot_options_raw_text).group(1) + sys = re.search(sys_regex, boot_options_raw_text).group(1) + retdict = dict(kick=kick, sys=sys) + else: + nxos_regex = r'NXOS variable = bootflash:/(\S+)' + nxos = re.search(nxos_regex, boot_options_raw_text).group(1) + retdict = dict(sys=nxos) + + command = 'show install all status' + retdict['status'] = execute_show_command(command, module)[0] + + return retdict + + +def already_set(current_boot_options, system_image_file, kickstart_image_file): + return current_boot_options.get('sys') == system_image_file \ + and current_boot_options.get('kick') == kickstart_image_file + + +def set_boot_options(module, image_name, kickstart=None): + """Set boot variables + like system image and kickstart image. + Args: + The main system image file name. + Keyword Args: many implementors may choose + to supply a kickstart parameter to specicify a kickstart image. + """ + commands = ['terminal dont-ask'] + if kickstart is None: + commands.append('install all nxos %s' % image_name) + else: + commands.append( + 'install all system %s kickstart %s' % (image_name, kickstart)) + execute_config_command(commands, module) + + +def main(): + argument_spec = dict( + system_image_file=dict(required=True), + kickstart_image_file=dict(required=False), + ) + module = get_network_module(argument_spec=argument_spec, + supports_check_mode=True) + + system_image_file = module.params['system_image_file'] + kickstart_image_file = module.params['kickstart_image_file'] + + if kickstart_image_file == 'null': + kickstart_image_file = None + + current_boot_options = get_boot_options(module) + changed = False + if not already_set(current_boot_options, + system_image_file, + kickstart_image_file): + changed = True + + if not module.check_mode and changed == True: + set_boot_options(module, + system_image_file, + kickstart=kickstart_image_file) + + if not already_set(install_state, + system_image_file, + kickstart_image_file): + module.fail_json(msg='Install not successful', + install_state=install_state) + else: + install_state = current_boot_options + + module.exit_json(changed=changed, install_state=install_state) + + +if __name__ == '__main__': + main() \ No newline at end of file