ansible/network/vyos/vyos_config.py

#!/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: vyos_config
version_added: "2.2"
author: "Peter Sprygada (@privateip)"
short_description: Manage VyOS configuration on remote device
description:
  - This module provides configuration file management of VyOS
    devices.  It provides arguments for managing both the
    configuration file and state of the active configuration.   All
    configuration statements are based on `set` and `delete` commands
    in the device configuration.
extends_documentation_fragment: vyos
options:
  lines:
    description:
      - The ordered set of configuration lines to be managed and
        compared with the existing configuration on the remote
        device.
    required: false
    default: null
  src:
    description:
      - Path to the configuration file to load.
    required: no
    default: null
  rollback:
    description:
      - Rollback the device configuration to the
        revision specified.  If the specified rollback revision does
        not exist, then the module will produce an error and fail.
      - NOTE THIS WILL CAUSE THE DEVICE TO REBOOT AUTOMATICALLY.
    required: false
    default: null
  update_config:
    description:
      - Should  the configuration on the remote device be updated with the
        calculated changes. When set to true, the configuration will be updated
        and when set to false, the configuration will not be updated.
    required: false
    default: true
    choices: ['yes', 'no']
  backup_config:
    description:
      - Create a local backup copy of the current running configuration
        prior to making any changes.   The configuration file will be
        stored in the backups folder in the root of the playbook or role.
    required: false
    default: false
    choices: ['yes', 'no']
"""

RETURN = """
connected:
  description: Boolean that specifies if the module connected to the device
  returned: always
  type: bool
  sample: true
updates:
  description: The list of configuration commands sent to the device
  returned: always
  type: list
  sample: ['...', '...']
"""

EXAMPLES = """
# Note: examples below use the following provider dict to handle
#       transport and authentication to the node.
vars:
  cli:
    host: "{{ inventory_hostname }}"
    username: vyos
    password: vyos
    transport: cli

- name: configure the remote device
  vyos_config:
    lines:
      - set system host-name {{ inventory_hostname }}
      - set service lldp
      - delete service dhcp-server
    provider: "{{ cli }}"

- name: rollback config to revision 3
  vyos_config:
    rollback: 3
    provider: "{{ cli }}"
"""
from ansible.module_utils.network import Command, get_exception
from ansible.module_utils.netcfg import NetworkConfig, dumps
from ansible.module_utils.vyos import NetworkModule, NetworkError
from ansible.module_utils.vyos import vyos_argument_spec
from ansible.module_utils.vyos import load_config, load_candidate


def invoke(name, *args, **kwargs):
    func = globals().get(name)
    if func:
        return func(*args, **kwargs)


def config_to_commands(config):
    set_format = config.startswith('set') or config.startswith('delete')
    candidate = NetworkConfig(indent=4, contents=config, device_os='junos')
    if not set_format:
        candidate = [c.line for c in candidate.items]
        commands = list()
        for item in candidate:
            for index, entry in enumerate(commands):
                if item.startswith(entry):
                    del commands[index]
                    break
            commands.append(item)
    else:
        commands = str(candidate).split('\n')
    return commands


def do_lines(module, result):
    commands = module.params['lines']
    result.update(load_config(module, commands))


def do_src(module, result):
    contents = module.params['src']
    commands = config_to_commands(contents)
    result.update(load_config(module, commands))


def do_rollback(module, result):
    rollback = 'rollback %s' % module.params['rollback']
    prompt = re.compile('\[confirm\]')
    cmd = Command(rollback, prompt=prompt, response='y', is_reboot=True, delay=1)

    try:
        module.cli(['configure', cmd])
    except NetworkError:
        exc = get_exception()
        cmds = [str(c) for c in exc.kwargs.get('commands', list())]
        module.fail_json(msg=str(exc), commands=cmds)


def main():

    argument_spec = dict(
        lines=dict(type='list'),

        src=dict(type='path'),

        rollback=dict(type='int'),

        update_config=dict(type='bool', default=False),
        backup_config=dict(type='bool', default=False)
    )
    argument_spec.update(vyos_argument_spec)

    mutually_exclusive = [('lines', 'rollback'), ('lines', 'src'),
                          ('src', 'rollback')]

    module = NetworkModule(argument_spec=argument_spec,
                           connect_on_load=False,
                           mutually_exclusive=mutually_exclusive,
                           supports_check_mode=True)

    module.check_mode = not module.params['update_config']

    result = dict(changed=False, warnings=list())

    if module.params['backup_config']:
        result['__backup__'] = module.cli('show configuration')[0]

    if module.params['lines']:
        do_lines(module, result)

    elif module.params['src']:
        do_src(module, result)

    elif module.params['rollback'] and not module.check_mode:
        do_rollback(module, result)

    if 'filtered' in result:
        result['warnings'].append('Some configuration commands where '
                                  'filtered, please see the filtered key')

    result['connected'] = module.connected

    module.exit_json(**result)


if __name__ == '__main__':
    main()