eole-galaxy/cadoles/eole/plugins/modules/creoleset.py

#!/usr/bin/python

# Copyright: (c) 2018, Terry Jones <terry.jones@example.org>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

DOCUMENTATION = r'''
---
module: CreoleSet

short_description: This module aims to set variables on EOLE modules

version_added: "1.0.0"

description: This module aims to set variables on EOLE modules orderly and atomicly.

options:
    variables:
        description: Name of the variable to change.
        required: true
        type: list
    state:
        description: state of variables
        required: false
        type: str
author:
    - Cadoles
'''

EXAMPLES = r'''
variables:
    - name: activer_ajout_hosts
      value: 'oui'
    - name: adresse_ip_hosts
      value:
        - 192.168.1.1
    - name: nom_long_hosts
      value:
        - "seth.domain.org cloud.domain.org"
state: exact
'''

RETURN = r'''
# These are examples of possible return values, and in general should use other names for return values.
diff:
    description: variable modifications status.
    type: list
    returned: always
    sample: ['activer_ajout_hosts: non => oui'] 
'''

from ansible.module_utils.basic import AnsibleModule
from creole.loader import creole_loader, config_save_values


def run_module():
    # define available arguments/parameters a user can pass to the module
    module_args = dict(
        variables=dict(type='list', required=True),
        state=dict(type='str', required=False, default='exact'),
    )

    # seed the result dict in the object
    # we primarily care about changed and state
    # changed is if this module effectively modified the target
    # state will include any data that you want your module to pass back
    # for consumption, for example, in a subsequent task
    result = dict(
        changed=False,
        diff=[],
        debug=[],
    )

    # the AnsibleModule object will be our abstraction working with Ansible
    # this includes instantiation, a couple of common attr would be the
    # args/params passed to the execution, as well as if the module
    # supports check mode
    module = AnsibleModule(
        argument_spec=module_args,
        supports_check_mode=True
    )

    # if the user is working with this module in only check mode we do not
    # want to make any changes to the environment, just return the current
    # state with no modifications
    c = creole_loader(rw=True, reload_config=True)
    d = c.cfgimpl_get_description()
    diff = []
    c.cfgimpl_get_settings().remove('disabled')

    variables = {c.find_first(byname=variable['name']): variable['value']
               for variable in module.params['variables']}

    slaves = [v for v in variables if v.impl_is_master_slaves('slave')]

    masters = {v: [] for v in variables if v.impl_is_master_slaves('master')}

    for slave in slaves:
        master = slave.impl_get_master_slaves().getmaster(slave)
        masters[master].append(slave)

    ordered_variables = [(v, []) for v in variables if not v.impl_is_master_slaves()]

    ordered_variables.extend(masters.items())

    for variable, sub_variables in ordered_variables:
        value = variables[variable]
        if not isinstance(value, list):
            values = [value]
        else:
            values = value
        var_path = d.impl_get_path_by_opt(variable)
        old_value = c.getattr(var_path)
        if not variable.impl_is_multi():
            method = 'exact'
        else:
            method = module.params['state']

        if method == 'exact':
            if old_value != values:
                diff.append('{}: {} => {}'.format(var_path, old_value, value))
            c.setattr(var_path, value)
            for sub_variable in sub_variables:
                sub_value = variables[sub_variable]
                sub_var_path = d.impl_get_path_by_opt(sub_variable)
                sub_old_value = c.getattr(sub_var_path)
                if sub_old_value != sub_value:
                    diff.append('{}: {} => {}'.format(sub_var_path, sub_old_value, sub_value))
                c.setattr(sub_var_path, sub_value)

        if method == 'present':
            is_present = False
            group_dict = {}
            for sub_variable in sub_variables:
                group_dict[d.impl_get_path_by_opt(sub_variable)] = variables[sub_variable]
            for v_index, value in enumerate(values):
                for index, item in enumerate(c.getattr(var_path)):
                    if value == item and  all([c.getattr(sv)[index] == group_dict[sv] for sv in group_dict]):
                        is_present = True
                        break
                if not is_present:
                    old_value.append(value)
                    diff.append('{}: {} => {}'.format(var_path, old_value[:-1], old_value))
                    for sub_variable, sub_value in group_dict.items():
                        if not isinstance(sub_value, list):
                            sub_value = [sub_value]
                        c.getattr(sub_variable)[-1] = sub_value[v_index]
                        diff.append('{}: {} => {}'.format(sub_variable, c.getattr(sub_variable)[:-1], c.getattr(sub_variable)))

    result['diff'] = diff
    c.cfgimpl_get_settings().append('disabled')
    #c.make_dict()

    if not module.check_mode and diff:
        config_save_values(c, 'creole')
        result['changed'] = True

    module.exit_json(**result)


def main():
    run_module()


if __name__ == '__main__':
    main()