fortios_system_config_backup.py

#!/usr/bin/python
from __future__ import (absolute_import, division, print_function)
# Copyright 2019 Fortinet, Inc.
#
# This program 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.
#
# This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.

__metaclass__ = type

ANSIBLE_METADATA = {'status': ['preview'],
                    'supported_by': 'community',
                    'metadata_version': '1.1'}

DOCUMENTATION = '''
DOCUMENTATION HERE
'''

EXAMPLES = '''
EXAMPLE HERE
'''

RETURN = '''
RETURN HERE
'''

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.connection import Connection
from ansible.module_utils.network.fortios.fortios import FortiOSHandler
from ansible.module_utils.network.fortimanager.common import FAIL_SOCKET_MSG
import os
import base64

def login(data, fos):
    host = data['host']
    username = data['username']
    password = data['password']
    ssl_verify = data['ssl_verify']

    fos.debug('on')
    if 'https' in data and not data['https']:
        fos.https('off')
    else:
        fos.https('on')

    fos.login(host, username, password, verify=ssl_verify)


def filter_config_backup_data(json):
    option_list = ['scope', 'destination']
    dictionary = {}

    for attribute in option_list:
        if attribute in json and json[attribute] is not None:
            dictionary[attribute] = json[attribute]

    return dictionary

def underscore_to_hyphen(data):
    if isinstance(data, list):
        for elem in data:
            elem = underscore_to_hyphen(elem)
    elif isinstance(data, dict):
        new_data = {}
        for k, v in data.items():
            new_data[k.replace('_', '-')] = underscore_to_hyphen(v)
        data = new_data

    return data

def config_backup(data, fos, check_mode=False):
    vdom = data['vdom']
    config_backup_data = data['config_backup']

    filtered_data = {}
    filtered_data = underscore_to_hyphen(filter_config_backup_data(config_backup_data))

    #use monitor api - /monitor prefix is required for the config backup
    return fos.monitor('system',
                   'config/backup',
                    vdom=vdom,
                    parameters=filtered_data,
)


def fortios_system(data, fos):

    if data['config_backup']:
        resp = config_backup(data, fos)
	
	#use binary (resp.content) instead of resp.text - as binary can be still written to a file if there is a non-ascii code returned or in the fortigate configuration
        config = resp.content
        filename = data['config_backup']['filename']
	
	#context handler to write binary to file
        with open(filename, 'wb') as file:
            file.write(config)
	
	#return a true result - as received response will be a config file
        return False, False, {
            'status': 200,
            'backup': config
        }



def main():
    fields = {
        "host": {"required": False, "type": "str"},
        "username": {"required": False, "type": "str"},
        "password": {"required": False, "type": "str", "default": "", "no_log": True},
        "vdom": {"required": False, "type": "str", "default": "root"},
        "https": {"required": False, "type": "bool", "default": True},
        "ssl_verify": {"required": False, "type": "bool", "default": True},
        "config_backup": {
            "required": False, "type": "dict", "default": None,
            "options": {
				"scope": {"required": True, "type": "str",
					"choices": ["global", "vdom"]},
				"destination": {"required": False, "type": "str"},
                "filename": {"required": False, "type":"str"},
				"usb_filename": {"required": False, "type": "str"},
				"password": {"required": False, "type": "str"},
				"vdom": {"required": False, "type": "str"},
            }
        }
    }

    module = AnsibleModule(argument_spec=fields,
                           supports_check_mode=False)

    # legacy_mode refers to using fortiosapi instead of HTTPAPI
    legacy_mode = 'host' in module.params and module.params['host'] is not None and \
                  'username' in module.params and module.params['username'] is not None and \
                  'password' in module.params and module.params['password'] is not None

    if not legacy_mode:
        if module._socket_path:
            connection = Connection(module._socket_path)
            fos = FortiOSHandler(connection)

            is_error, has_changed, result = fortios_system(module.params, fos)
        else:
            module.fail_json(**FAIL_SOCKET_MSG)
    else:
        try:
            from fortiosapi import FortiOSAPI
        except ImportError:
            module.fail_json(msg="fortiosapi module is required")

        fos = FortiOSAPI()

        login(module.params, fos)
        is_error, has_changed, result = fortios_system(module.params, fos)
        fos.logout()

    if not is_error:
        module.exit_json(changed=has_changed, meta=result)
    else:
        module.fail_json(msg="Error in repo", meta=result)


if __name__ == '__main__':
    main()