# Copyright: (c) 2016, Allen Sanabria # 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 from os import path, walk import re import ansible.constants as C from ansible.errors import AnsibleError from ansible.module_utils.six import string_types from ansible.module_utils.common.text.converters import to_native, to_text from ansible.plugins.action import ActionBase from ansible.utils.vars import combine_vars from pathlib import Path class ActionModule(ActionBase): TRANSFERS_FILES = False _requires_connection = False def run(self, tmp=None, task_vars=None): """ Load yml files recursively from a directory. """ del tmp # tmp no longer has any effect if task_vars is None: task_vars = dict() self.show_content = True self.included_files = [] # Validate arguments dirs = 0 module_args = self._task.args.copy() if not "dir" in module_args: raise AnsibleError('\'dir\' option is mendatory in load_haproxy_config') if not "default_domain" in module_args: raise AnsibleError('\'default_domain\' option is mendatory in load_haproxy_config') if not "default_dns_provider" in module_args: raise AnsibleError('\'default_dns_provider\' option is mendatory in load_haproxy_config') if not "default_dns_target" in module_args: raise AnsibleError('\'default_dns_target\' option is mendatory in load_haproxy_config') self.source_dir = module_args.get('dir') self.default_domain = module_args.get('default_domain') self.default_dns_provider = module_args.get('default_dns_provider') self.default_dns_target = module_args.get('default_dns_target') self.dir = module_args.get('dir') self.depth = module_args.get('depth', 0) results = { "domain_maping": [], "dns_hostnames": dict(), # { provider: [ { hostname:"", domain:"", state: "", target: "" } ] } "protected_domain": [], "backend_config": [] } failed = False self._set_root_dir() if not path.exists(self.source_dir): failed = True err_msg = ('{0} directory does not exist'.format(to_native(self.source_dir))) elif not path.isdir(self.source_dir): failed = True err_msg = ('{0} is not a directory'.format(to_native(self.source_dir))) else: for root_dir, filenames in self._traverse_dir_depth(): failed, err_msg, updated_results = (self._load_files_in_dir(root_dir, filenames)) if failed: break results['domain_maping'] = results['domain_maping'] + updated_results['domain_maping'] results['protected_domain'] = results['protected_domain'] + updated_results['protected_domain'] results['backend_config'] = results['backend_config'] + updated_results['backend_config'] print(updated_results) for key, value in updated_results['dns_hostnames'].items(): results['dns_hostnames'][key] = results['dns_hostnames'].get(key, []) + value result = super(ActionModule, self).run(task_vars=task_vars) if failed: result['failed'] = failed result['message'] = err_msg scope = dict() scope['haproxy_config'] = results results = scope result['ansible_included_var_files'] = self.included_files result['ansible_facts'] = results result['_ansible_no_log'] = not self.show_content return result def _set_root_dir(self): if self._task._role: if self.source_dir.split('/')[0] == 'vars': path_to_use = ( path.join(self._task._role._role_path, self.source_dir) ) if path.exists(path_to_use): self.source_dir = path_to_use else: path_to_use = ( path.join( self._task._role._role_path, 'vars', self.source_dir ) ) self.source_dir = path_to_use else: if hasattr(self._task._ds, '_data_source'): current_dir = ( "/".join(self._task._ds._data_source.split('/')[:-1]) ) self.source_dir = path.join(current_dir, self.source_dir) def _log_walk(self, error): self._display.vvv('Issue with walking through "%s": %s' % (to_native(error.filename), to_native(error))) def _traverse_dir_depth(self): """ Recursively iterate over a directory and sort the files in alphabetical order. Do not iterate pass the set depth. The default depth is unlimited. """ current_depth = 0 sorted_walk = list(walk(self.source_dir, onerror=self._log_walk, followlinks=True)) sorted_walk.sort(key=lambda x: x[0]) for current_root, current_dir, current_files in sorted_walk: current_depth += 1 if current_depth <= self.depth or self.depth == 0: current_files.sort() yield (current_root, current_files) else: break def _load_files(self, filename): """ Loads a file and converts the output into a valid Python dict. Args: filename (str): The source file. Returns: Tuple (bool, str, dict) """ results = dict() failed = False err_msg = '' b_data, show_content = self._loader._get_file_contents(filename) data = to_text(b_data, errors='surrogate_or_strict') self.show_content = show_content data = self._loader.load(data, file_name=filename, show_content=show_content) if not data: data = dict() if not isinstance(data, dict): failed = True err_msg = ('{0} must be stored as a dictionary/hash'.format(to_native(filename))) else: self.included_files.append(filename) results.update(data) return failed, err_msg, results def _load_files_in_dir(self, root_dir, var_files): """ Load the found yml files and update/overwrite the dictionary. Args: root_dir (str): The base directory of the list of files that is being passed. var_files: (list): List of files to iterate over and load into a dictionary. Returns: Tuple (bool, str, dict) """ results = { "domain_maping": [], "dns_hostnames": dict(), # { provider: [ { hostname:"", domain:"", state: "", target: "" } ] } "protected_domain": [], "backend_config": [] } failed = False err_msg = '' for filename in var_files: stop_iter = False # Never include main.yml from a role, as that is the default included by the role if self._task._role: if path.join(self._task._role._role_path, filename) == path.join(root_dir, 'vars', 'main.yml'): stop_iter = True continue filepath = path.join(root_dir, filename) if not stop_iter and not failed: if path.exists(filepath): failed, err_msg, loaded_data = self._load_files(filepath) if not failed: main_hostname = Path(filepath).stem dns = loaded_data.get("dns", dict()) domain = dns.get("domain", self.default_domain) dns_provider = dns.get("provider", self.default_dns_provider) dns_target = dns.get("target", self.default_dns_provider) protected = loaded_data.get("protected", False) additionnal_hostname = loaded_data.get('additionnal_hostname', []) state = loaded_data.get("state", "present") if "backend" not in loaded_data: failed = True err_msg = ('Could not find "backend" in {0}'.format(to_native(filename))) continue backend = loaded_data.get("backend") if state == "present": results['domain_maping'].append('{0}.{1} {2}'.format(main_hostname, domain, backend.get("name"))) results['backend_config'].append(backend) if protected: results['protected_domain'].append('{0}.{1}'.format(main_hostname, domain)) if not dns.get("skip", False): if not dns_provider in results['dns_hostnames']: results['dns_hostnames'].update({ dns_provider: []}) results['dns_hostnames'][dns_provider].append({ "hostname": main_hostname, "domain": domain, "target": dns_target, "state": state, }) for host in additionnal_hostname: this_dns = host.get("dns", dns) this_domain = this_dns.get("domain", domain) this_dns_provider = this_dns.get("provider", dns_provider) this_dns_target = this_dns.get("target", dns_target) this_protected = host.get('protected', protected) this_state = host.get('state', state) if this_state == "present": full_domain = '{0}.{1}'.format(host.get("hostname"), this_domain) if host.get("hostname") else this_domain results['domain_maping'].append('{0} {2}'.format(full_domain, this_domain, backend.get("name"))) if this_protected: results['protected_domain'].append(full_domain) if not this_dns.get("skip", dns.get("skip", False)): if not this_dns_provider in results['dns_hostnames']: results['dns_hostnames'].update({ this_dns_provider: []}) results['dns_hostnames'][this_dns_provider].append({ "hostname": host.get("hostname"), "domain": this_domain, "target": this_dns_target, "state": this_state }) return failed, err_msg, results