| #!/usr/bin/env python |
| |
| import os |
| import sys |
| import pdb |
| import json |
| import uuid |
| |
| from tempfile import NamedTemporaryFile |
| from ansible.inventory import Inventory |
| from ansible.vars import VariableManager |
| from ansible.parsing.dataloader import DataLoader |
| from ansible.executor import playbook_executor |
| from ansible.utils.display import Display |
| from ansible.plugins.callback import CallbackBase |
| from xos.logger import observer_logger as logger |
| |
| class ResultCallback(CallbackBase): |
| |
| CALLBACK_VERSION = 2.0 |
| CALLBACK_NAME = 'resultcallback' |
| CALLBACK_TYPE = 'programmatic' |
| |
| def __init__(self): |
| super(ResultCallback, self).__init__() |
| self.results = [] |
| self.uuid = str(uuid.uuid1()) |
| self.playbook_status = 'OK' |
| |
| def v2_playbook_on_start(self, playbook): |
| self.playbook = playbook._file_name |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "playbook start", |
| 'ansible_status': "OK", |
| 'ansible_playbook': self.playbook |
| } |
| logger.info("PLAYBOOK START [%s]" % self.playbook, extra=log_extra) |
| |
| def v2_playbook_on_stats(self, stats): |
| host_stats = {} |
| for host in stats.processed.keys(): |
| host_stats[host] = stats.summarize(host) |
| |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "playbook stats", |
| 'ansible_status': self.playbook_status, |
| 'ansible_playbook': self.playbook, |
| 'ansible_result': json.dumps(host_stats) |
| } |
| |
| if self.playbook_status == 'OK': |
| logger.info("PLAYBOOK END [%s]" % self.playbook, extra=log_extra) |
| else: |
| logger.error("PLAYBOOK END [%s]" % self.playbook, extra=log_extra) |
| |
| def v2_playbook_on_play_start(self, play): |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "play start", |
| 'ansible_status': self.playbook_status, |
| 'ansible_playbook': self.playbook |
| } |
| logger.debug("PLAY START [%s]" % play.name, extra=log_extra) |
| |
| def v2_runner_on_ok(self, result, **kwargs): |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "task", |
| 'ansible_status': "OK", |
| 'ansible_result': json.dumps(result._result), |
| 'ansible_task': result._task, |
| 'ansible_playbook': self.playbook, |
| 'ansible_host': result._host.get_name() |
| } |
| logger.debug("OK [%s]" % str(result._task), extra=log_extra) |
| self.results.append(result) |
| |
| def v2_runner_on_failed(self, result, **kwargs): |
| self.playbook_status = "FAILED" |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "task", |
| 'ansible_status': "FAILED", |
| 'ansible_result': json.dumps(result._result), |
| 'ansible_task': result._task, |
| 'ansible_playbook': self.playbook, |
| 'ansible_host': result._host.get_name() |
| } |
| logger.error("FAILED [%s]" % str(result._task), extra=log_extra) |
| self.results.append(result) |
| |
| def v2_runner_on_async_failed(self, result, **kwargs): |
| self.playbook_status = "FAILED" |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "task", |
| 'ansible_status': "ASYNC FAILED", |
| 'ansible_result': json.dumps(result._result), |
| 'ansible_task': result._task, |
| 'ansible_playbook': self.playbook, |
| 'ansible_host': result._host.get_name() |
| } |
| logger.error("ASYNC FAILED [%s]" % str(result._task), extra=log_extra) |
| |
| def v2_runner_on_skipped(self, result, **kwargs): |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "task", |
| 'ansible_status': "SKIPPED", |
| 'ansible_result': json.dumps(result._result), |
| 'ansible_task': result._task, |
| 'ansible_playbook': self.playbook, |
| 'ansible_host': result._host.get_name() |
| } |
| logger.debug("SKIPPED [%s]" % str(result._task), extra=log_extra) |
| self.results.append(result) |
| |
| def v2_runner_on_unreachable(self, result, **kwargs): |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "task", |
| 'ansible_status': "UNREACHABLE", |
| 'ansible_result': json.dumps(result._result), |
| 'ansible_task': result._task, |
| 'ansible_playbook': self.playbook, |
| 'ansible_host': result._host.get_name() |
| } |
| logger.error("UNREACHABLE [%s]" % str(result._task), extra=log_extra) |
| self.results.append(result) |
| |
| def v2_runner_retry(self, result, **kwargs): |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "task", |
| 'ansible_status': "RETRY", |
| 'ansible_result': json.dumps(result._result), |
| 'ansible_task': result._task, |
| 'ansible_playbook': self.playbook, |
| 'ansible_host': result._host.get_name() |
| } |
| logger.warning("RETRYING [%s] - attempt %d" % (str(result._task), result._result['attempts']), extra=log_extra) |
| self.results.append(result) |
| |
| def v2_playbook_on_handler_task_start(self, task, **kwargs): |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "task", |
| 'ansible_status': "HANDLER", |
| 'ansible_task': task.get_name().strip(), |
| 'ansible_playbook': self.playbook, |
| 'ansible_host': result._host.get_name() |
| } |
| logger.debug("HANDLER [%s]" % task.get_name().strip(), extra=log_extra) |
| |
| def v2_playbook_on_import_for_host(self, result, imported_file): |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "import", |
| 'ansible_status': "IMPORT", |
| 'ansible_result': json.dumps(result._result), |
| 'ansible_playbook': self.playbook, |
| 'ansible_host': result._host.get_name() |
| } |
| logger.debug("IMPORT [%s]" % imported_file, extra=log_extra) |
| self.results.append(result) |
| |
| def v2_playbook_on_not_import_for_host(self, result, missing_file): |
| log_extra = { |
| 'xos_type': "ansible", |
| 'ansible_uuid': self.uuid, |
| 'ansible_type': "import", |
| 'ansible_status': "MISSING IMPORT", |
| 'ansible_result': json.dumps(result._result), |
| 'ansible_playbook': self.playbook, |
| 'ansible_host': result._host.get_name() |
| } |
| logger.debug("MISSING IMPORT [%s]" % missing_file, extra=log_extra) |
| self.results.append(result) |
| |
| class Options(object): |
| """ |
| Options class to replace Ansible OptParser |
| """ |
| def __init__(self, verbosity=None, inventory=None, listhosts=None, subset=None, module_paths=None, extra_vars=None, |
| forks=None, ask_vault_pass=None, vault_password_files=None, new_vault_password_file=None, |
| output_file=None, tags=None, skip_tags=None, one_line=None, tree=None, ask_sudo_pass=None, ask_su_pass=None, |
| sudo=None, sudo_user=None, become=None, become_method=None, become_user=None, become_ask_pass=None, |
| ask_pass=None, private_key_file=None, remote_user=None, connection=None, timeout=None, ssh_common_args=None, |
| sftp_extra_args=None, scp_extra_args=None, ssh_extra_args=None, poll_interval=None, seconds=None, check=None, |
| syntax=None, diff=None, force_handlers=None, flush_cache=None, listtasks=None, listtags=None, module_path=None): |
| self.verbosity = verbosity |
| self.inventory = inventory |
| self.listhosts = listhosts |
| self.subset = subset |
| self.module_paths = module_paths |
| self.extra_vars = extra_vars |
| self.forks = forks |
| self.ask_vault_pass = ask_vault_pass |
| self.vault_password_files = vault_password_files |
| self.new_vault_password_file = new_vault_password_file |
| self.output_file = output_file |
| self.tags = tags |
| self.skip_tags = skip_tags |
| self.one_line = one_line |
| self.tree = tree |
| self.ask_sudo_pass = ask_sudo_pass |
| self.ask_su_pass = ask_su_pass |
| self.sudo = sudo |
| self.sudo_user = sudo_user |
| self.become = become |
| self.become_method = become_method |
| self.become_user = become_user |
| self.become_ask_pass = become_ask_pass |
| self.ask_pass = ask_pass |
| self.private_key_file = private_key_file |
| self.remote_user = remote_user |
| self.connection = connection |
| self.timeout = timeout |
| self.ssh_common_args = ssh_common_args |
| self.sftp_extra_args = sftp_extra_args |
| self.scp_extra_args = scp_extra_args |
| self.ssh_extra_args = ssh_extra_args |
| self.poll_interval = poll_interval |
| self.seconds = seconds |
| self.check = check |
| self.syntax = syntax |
| self.diff = diff |
| self.force_handlers = force_handlers |
| self.flush_cache = flush_cache |
| self.listtasks = listtasks |
| self.listtags = listtags |
| self.module_path = module_path |
| |
| |
| class Runner(object): |
| |
| def __init__(self, playbook, run_data, private_key_file=None, verbosity=0, host_file=None): |
| |
| self.playbook = playbook |
| self.run_data = run_data |
| |
| self.options = Options() |
| self.options.output_file = playbook + '.result' |
| self.options.private_key_file = private_key_file |
| self.options.verbosity = verbosity |
| self.options.connection = 'ssh' # Need a connection type "smart" or "ssh" |
| #self.options.become = True |
| self.options.become_method = 'sudo' |
| self.options.become_user = 'root' |
| |
| # Set global verbosity |
| self.display = Display() |
| self.display.verbosity = self.options.verbosity |
| # Executor appears to have it's own |
| # verbosity object/setting as well |
| playbook_executor.verbosity = self.options.verbosity |
| |
| # Become Pass Needed if not logging in as user root |
| #passwords = {'become_pass': become_pass} |
| |
| # Gets data from YAML/JSON files |
| self.loader = DataLoader() |
| try: |
| self.loader.set_vault_password(os.environ['VAULT_PASS']) |
| except KeyError: |
| pass |
| |
| # All the variables from all the various places |
| self.variable_manager = VariableManager() |
| self.variable_manager.extra_vars = {} # self.run_data |
| |
| # Set inventory, using most of above objects |
| if (host_file): |
| self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list = host_file) |
| else: |
| self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager) |
| |
| self.variable_manager.set_inventory(self.inventory) |
| |
| # Setup playbook executor, but don't run until run() called |
| self.pbex = playbook_executor.PlaybookExecutor( |
| playbooks=[playbook], |
| inventory=self.inventory, |
| variable_manager=self.variable_manager, |
| loader=self.loader, |
| options=self.options, |
| passwords={}) |
| |
| def run(self): |
| os.environ['REQUESTS_CA_BUNDLE'] = '/usr/local/share/ca-certificates/local_certs.crt' |
| callback = ResultCallback() |
| self.pbex._tqm._stdout_callback = callback |
| |
| self.pbex.run() |
| stats = self.pbex._tqm._stats |
| |
| # Test if success for record_logs |
| run_success = True |
| hosts = sorted(stats.processed.keys()) |
| for h in hosts: |
| t = stats.summarize(h) |
| if t['unreachable'] > 0 or t['failures'] > 0: |
| run_success = False |
| |
| #os.remove(self.hosts.name) |
| |
| return stats,callback.results |
| |