diff options
Diffstat (limited to 'ansible_collections/community/general/plugins/callback/diy.py')
| -rw-r--r-- | ansible_collections/community/general/plugins/callback/diy.py | 1417 |
1 files changed, 1417 insertions, 0 deletions
diff --git a/ansible_collections/community/general/plugins/callback/diy.py b/ansible_collections/community/general/plugins/callback/diy.py new file mode 100644 index 000000000..75b3f4e24 --- /dev/null +++ b/ansible_collections/community/general/plugins/callback/diy.py @@ -0,0 +1,1417 @@ +# -*- coding: utf-8 -*- + +# Copyright (c) 2019, Trevor Highfill <trevor.highfill@outlook.com> +# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt) +# SPDX-License-Identifier: GPL-3.0-or-later + +from __future__ import (absolute_import, division, print_function) +__metaclass__ = type + +DOCUMENTATION = r''' + name: diy + type: stdout + short_description: Customize the output + version_added: 0.2.0 + description: + - Callback plugin that allows you to supply your own custom callback templates to be output. + author: Trevor Highfill (@theque5t) + extends_documentation_fragment: + - default_callback + notes: + - Uses the C(default) callback plugin output when a custom callback message(C(msg)) is not provided. + - Makes the callback event data available via the C(ansible_callback_diy) dictionary, which can be used in the templating context for the options. + The dictionary is only available in the templating context for the options. It is not a variable that is available via the other + various execution contexts, such as playbook, play, task etc. + - Options being set by their respective variable input can only be set using the variable if the variable was set in a context that is available to the + respective callback. + Use the C(ansible_callback_diy) dictionary to see what is available to a callback. Additionally, C(ansible_callback_diy.top_level_var_names) will output + the top level variable names available to the callback. + - Each option value is rendered as a template before being evaluated. This allows for the dynamic usage of an option. For example, + C("{{ 'yellow' if ansible_callback_diy.result.is_changed else 'bright green' }}") + - "**Condition** for all C(msg) options: + if value C(is None or omit), + then the option is not being used. + **Effect**: use of the C(default) callback plugin for output" + - "**Condition** for all C(msg) options: + if value C(is not None and not omit and length is not greater than 0), + then the option is being used without output. + **Effect**: suppress output" + - "**Condition** for all C(msg) options: + if value C(is not None and not omit and length is greater than 0), + then the option is being used with output. + **Effect**: render value as template and output" + - "Valid color values: C(black), C(bright gray), C(blue), C(white), C(green), C(bright blue), C(cyan), C(bright green), C(red), C(bright cyan), + C(purple), C(bright red), C(yellow), C(bright purple), C(dark gray), C(bright yellow), C(magenta), C(bright magenta), C(normal)" + seealso: + - name: default – default Ansible screen output + description: The official documentation on the B(default) callback plugin. + link: https://docs.ansible.com/ansible/latest/plugins/callback/default.html + requirements: + - set as stdout_callback in configuration + options: + on_any_msg: + description: Output to be used for callback on_any. + ini: + - section: callback_diy + key: on_any_msg + env: + - name: ANSIBLE_CALLBACK_DIY_ON_ANY_MSG + vars: + - name: ansible_callback_diy_on_any_msg + type: str + + on_any_msg_color: + description: + - Output color to be used for I(on_any_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: on_any_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_ON_ANY_MSG_COLOR + vars: + - name: ansible_callback_diy_on_any_msg_color + type: str + + runner_on_failed_msg: + description: Output to be used for callback runner_on_failed. + ini: + - section: callback_diy + key: runner_on_failed_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_FAILED_MSG + vars: + - name: ansible_callback_diy_runner_on_failed_msg + type: str + + runner_on_failed_msg_color: + description: + - Output color to be used for I(runner_on_failed_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_on_failed_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_FAILED_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_on_failed_msg_color + type: str + + runner_on_ok_msg: + description: Output to be used for callback runner_on_ok. + ini: + - section: callback_diy + key: runner_on_ok_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_OK_MSG + vars: + - name: ansible_callback_diy_runner_on_ok_msg + type: str + + runner_on_ok_msg_color: + description: + - Output color to be used for I(runner_on_ok_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_on_ok_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_OK_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_on_ok_msg_color + type: str + + runner_on_skipped_msg: + description: Output to be used for callback runner_on_skipped. + ini: + - section: callback_diy + key: runner_on_skipped_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_SKIPPED_MSG + vars: + - name: ansible_callback_diy_runner_on_skipped_msg + type: str + + runner_on_skipped_msg_color: + description: + - Output color to be used for I(runner_on_skipped_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_on_skipped_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_SKIPPED_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_on_skipped_msg_color + type: str + + runner_on_unreachable_msg: + description: Output to be used for callback runner_on_unreachable. + ini: + - section: callback_diy + key: runner_on_unreachable_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_UNREACHABLE_MSG + vars: + - name: ansible_callback_diy_runner_on_unreachable_msg + type: str + + runner_on_unreachable_msg_color: + description: + - Output color to be used for I(runner_on_unreachable_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_on_unreachable_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_UNREACHABLE_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_on_unreachable_msg_color + type: str + + playbook_on_start_msg: + description: Output to be used for callback playbook_on_start. + ini: + - section: callback_diy + key: playbook_on_start_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_START_MSG + vars: + - name: ansible_callback_diy_playbook_on_start_msg + type: str + + playbook_on_start_msg_color: + description: + - Output color to be used for I(playbook_on_start_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_start_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_START_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_start_msg_color + type: str + + playbook_on_notify_msg: + description: Output to be used for callback playbook_on_notify. + ini: + - section: callback_diy + key: playbook_on_notify_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_NOTIFY_MSG + vars: + - name: ansible_callback_diy_playbook_on_notify_msg + type: str + + playbook_on_notify_msg_color: + description: + - Output color to be used for I(playbook_on_notify_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_notify_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_NOTIFY_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_notify_msg_color + type: str + + playbook_on_no_hosts_matched_msg: + description: Output to be used for callback playbook_on_no_hosts_matched. + ini: + - section: callback_diy + key: playbook_on_no_hosts_matched_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_NO_HOSTS_MATCHED_MSG + vars: + - name: ansible_callback_diy_playbook_on_no_hosts_matched_msg + type: str + + playbook_on_no_hosts_matched_msg_color: + description: + - Output color to be used for I(playbook_on_no_hosts_matched_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_no_hosts_matched_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_NO_HOSTS_MATCHED_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_no_hosts_matched_msg_color + type: str + + playbook_on_no_hosts_remaining_msg: + description: Output to be used for callback playbook_on_no_hosts_remaining. + ini: + - section: callback_diy + key: playbook_on_no_hosts_remaining_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_NO_HOSTS_REMAINING_MSG + vars: + - name: ansible_callback_diy_playbook_on_no_hosts_remaining_msg + type: str + + playbook_on_no_hosts_remaining_msg_color: + description: + - Output color to be used for I(playbook_on_no_hosts_remaining_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_no_hosts_remaining_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_NO_HOSTS_REMAINING_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_no_hosts_remaining_msg_color + type: str + + playbook_on_task_start_msg: + description: Output to be used for callback playbook_on_task_start. + ini: + - section: callback_diy + key: playbook_on_task_start_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_TASK_START_MSG + vars: + - name: ansible_callback_diy_playbook_on_task_start_msg + type: str + + playbook_on_task_start_msg_color: + description: + - Output color to be used for I(playbook_on_task_start_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_task_start_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_TASK_START_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_task_start_msg_color + type: str + + playbook_on_handler_task_start_msg: + description: Output to be used for callback playbook_on_handler_task_start. + ini: + - section: callback_diy + key: playbook_on_handler_task_start_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_HANDLER_TASK_START_MSG + vars: + - name: ansible_callback_diy_playbook_on_handler_task_start_msg + type: str + + playbook_on_handler_task_start_msg_color: + description: + - Output color to be used for I(playbook_on_handler_task_start_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_handler_task_start_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_HANDLER_TASK_START_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_handler_task_start_msg_color + type: str + + playbook_on_vars_prompt_msg: + description: Output to be used for callback playbook_on_vars_prompt. + ini: + - section: callback_diy + key: playbook_on_vars_prompt_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_VARS_PROMPT_MSG + vars: + - name: ansible_callback_diy_playbook_on_vars_prompt_msg + type: str + + playbook_on_vars_prompt_msg_color: + description: + - Output color to be used for I(playbook_on_vars_prompt_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_vars_prompt_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_VARS_PROMPT_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_vars_prompt_msg_color + type: str + + playbook_on_play_start_msg: + description: Output to be used for callback playbook_on_play_start. + ini: + - section: callback_diy + key: playbook_on_play_start_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_PLAY_START_MSG + vars: + - name: ansible_callback_diy_playbook_on_play_start_msg + type: str + + playbook_on_play_start_msg_color: + description: + - Output color to be used for I(playbook_on_play_start_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_play_start_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_PLAY_START_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_play_start_msg_color + type: str + + playbook_on_stats_msg: + description: Output to be used for callback playbook_on_stats. + ini: + - section: callback_diy + key: playbook_on_stats_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_STATS_MSG + vars: + - name: ansible_callback_diy_playbook_on_stats_msg + type: str + + playbook_on_stats_msg_color: + description: + - Output color to be used for I(playbook_on_stats_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_stats_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_STATS_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_stats_msg_color + type: str + + on_file_diff_msg: + description: Output to be used for callback on_file_diff. + ini: + - section: callback_diy + key: on_file_diff_msg + env: + - name: ANSIBLE_CALLBACK_DIY_ON_FILE_DIFF_MSG + vars: + - name: ansible_callback_diy_on_file_diff_msg + type: str + + on_file_diff_msg_color: + description: + - Output color to be used for I(on_file_diff_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: on_file_diff_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_ON_FILE_DIFF_MSG_COLOR + vars: + - name: ansible_callback_diy_on_file_diff_msg_color + type: str + + playbook_on_include_msg: + description: Output to be used for callback playbook_on_include. + ini: + - section: callback_diy + key: playbook_on_include_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_INCLUDE_MSG + vars: + - name: ansible_callback_diy_playbook_on_include_msg + type: str + + playbook_on_include_msg_color: + description: + - Output color to be used for I(playbook_on_include_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_include_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_INCLUDE_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_include_msg_color + type: str + + runner_item_on_ok_msg: + description: Output to be used for callback runner_item_on_ok. + ini: + - section: callback_diy + key: runner_item_on_ok_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ITEM_ON_OK_MSG + vars: + - name: ansible_callback_diy_runner_item_on_ok_msg + type: str + + runner_item_on_ok_msg_color: + description: + - Output color to be used for I(runner_item_on_ok_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_item_on_ok_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ITEM_ON_OK_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_item_on_ok_msg_color + type: str + + runner_item_on_failed_msg: + description: Output to be used for callback runner_item_on_failed. + ini: + - section: callback_diy + key: runner_item_on_failed_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ITEM_ON_FAILED_MSG + vars: + - name: ansible_callback_diy_runner_item_on_failed_msg + type: str + + runner_item_on_failed_msg_color: + description: + - Output color to be used for I(runner_item_on_failed_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_item_on_failed_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ITEM_ON_FAILED_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_item_on_failed_msg_color + type: str + + runner_item_on_skipped_msg: + description: Output to be used for callback runner_item_on_skipped. + ini: + - section: callback_diy + key: runner_item_on_skipped_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ITEM_ON_SKIPPED_MSG + vars: + - name: ansible_callback_diy_runner_item_on_skipped_msg + type: str + + runner_item_on_skipped_msg_color: + description: + - Output color to be used for I(runner_item_on_skipped_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_item_on_skipped_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ITEM_ON_SKIPPED_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_item_on_skipped_msg_color + type: str + + runner_retry_msg: + description: Output to be used for callback runner_retry. + ini: + - section: callback_diy + key: runner_retry_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_RETRY_MSG + vars: + - name: ansible_callback_diy_runner_retry_msg + type: str + + runner_retry_msg_color: + description: + - Output color to be used for I(runner_retry_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_retry_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_RETRY_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_retry_msg_color + type: str + + runner_on_start_msg: + description: Output to be used for callback runner_on_start. + ini: + - section: callback_diy + key: runner_on_start_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_START_MSG + vars: + - name: ansible_callback_diy_runner_on_start_msg + type: str + + runner_on_start_msg_color: + description: + - Output color to be used for I(runner_on_start_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_on_start_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_START_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_on_start_msg_color + type: str + + runner_on_no_hosts_msg: + description: Output to be used for callback runner_on_no_hosts. + ini: + - section: callback_diy + key: runner_on_no_hosts_msg + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_NO_HOSTS_MSG + vars: + - name: ansible_callback_diy_runner_on_no_hosts_msg + type: str + + runner_on_no_hosts_msg_color: + description: + - Output color to be used for I(runner_on_no_hosts_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: runner_on_no_hosts_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_RUNNER_ON_NO_HOSTS_MSG_COLOR + vars: + - name: ansible_callback_diy_runner_on_no_hosts_msg_color + type: str + + playbook_on_setup_msg: + description: Output to be used for callback playbook_on_setup. + ini: + - section: callback_diy + key: playbook_on_setup_msg + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_SETUP_MSG + vars: + - name: ansible_callback_diy_playbook_on_setup_msg + type: str + + playbook_on_setup_msg_color: + description: + - Output color to be used for I(playbook_on_setup_msg). + - Template should render a L(valid color value,#notes). + ini: + - section: callback_diy + key: playbook_on_setup_msg_color + env: + - name: ANSIBLE_CALLBACK_DIY_PLAYBOOK_ON_SETUP_MSG_COLOR + vars: + - name: ansible_callback_diy_playbook_on_setup_msg_color + type: str +''' + +EXAMPLES = r''' +ansible.cfg: > + # Enable plugin + [defaults] + stdout_callback=community.general.diy + + [callback_diy] + # Output when playbook starts + playbook_on_start_msg="DIY output(via ansible.cfg): playbook example: {{ ansible_callback_diy.playbook.file_name }}" + playbook_on_start_msg_color=yellow + + # Comment out to allow default plugin output + # playbook_on_play_start_msg="PLAY: starting play {{ ansible_callback_diy.play.name }}" + + # Accept on_skipped_msg or ansible_callback_diy_runner_on_skipped_msg as input vars + # If neither are supplied, omit the option + runner_on_skipped_msg="{{ on_skipped_msg | default(ansible_callback_diy_runner_on_skipped_msg) | default(omit) }}" + + # Newline after every callback + # on_any_msg='{{ " " | join("\n") }}' + +playbook.yml: > + --- + - name: "Default plugin output: play example" + hosts: localhost + gather_facts: false + tasks: + - name: Default plugin output + ansible.builtin.debug: + msg: default plugin output + + - name: Override from play vars + hosts: localhost + gather_facts: false + vars: + ansible_connection: local + green: "\e[0m\e[38;5;82m" + yellow: "\e[0m\e[38;5;11m" + bright_purple: "\e[0m\e[38;5;105m" + cyan: "\e[0m\e[38;5;51m" + green_bg_black_fg: "\e[0m\e[48;5;40m\e[38;5;232m" + yellow_bg_black_fg: "\e[0m\e[48;5;226m\e[38;5;232m" + purple_bg_white_fg: "\e[0m\e[48;5;57m\e[38;5;255m" + cyan_bg_black_fg: "\e[0m\e[48;5;87m\e[38;5;232m" + magenta: "\e[38;5;198m" + white: "\e[0m\e[38;5;255m" + ansible_callback_diy_playbook_on_play_start_msg: "\n{{green}}DIY output(via play vars): play example: {{magenta}}{{ansible_callback_diy.play.name}}\n\n" + ansible_callback_diy_playbook_on_task_start_msg: "DIY output(via play vars): task example: {{ ansible_callback_diy.task.name }}" + ansible_callback_diy_playbook_on_task_start_msg_color: cyan + ansible_callback_diy_playbook_on_stats_msg: |+2 + CUSTOM STATS + ============================== + {% for key in ansible_callback_diy.stats | sort %} + {% if ansible_callback_diy.stats[key] %} + {% if key == 'ok' %} + {% set color_one = lookup('vars','green_bg_black_fg') %} + {% set prefix = ' ' %} + {% set suffix = ' ' %} + {% set color_two = lookup('vars','green') %} + {% elif key == 'changed' %} + {% set color_one = lookup('vars','yellow_bg_black_fg') %} + {% set prefix = ' ' %} + {% set suffix = ' ' %} + {% set color_two = lookup('vars','yellow') %} + {% elif key == 'processed' %} + {% set color_one = lookup('vars','purple_bg_white_fg') %} + {% set prefix = ' ' %} + {% set suffix = ' ' %} + {% set color_two = lookup('vars','bright_purple') %} + {% elif key == 'skipped' %} + {% set color_one = lookup('vars','cyan_bg_black_fg') %} + {% set prefix = ' ' %} + {% set suffix = ' ' %} + {% set color_two = lookup('vars','cyan') %} + {% else %} + {% set color_one = "" %} + {% set prefix = "" %} + {% set suffix = "" %} + {% set color_two = "" %} + {% endif %} + {{ color_one }}{{ "%s%s%s" | format(prefix,key,suffix) }}{{ color_two }}: {{ ansible_callback_diy.stats[key] | to_nice_yaml }} + {% endif %} + {% endfor %} + + tasks: + - name: Custom banner with default plugin result output + ansible.builtin.debug: + msg: "default plugin output: result example" + + - name: Override from task vars + ansible.builtin.debug: + msg: "example {{ two }}" + changed_when: true + vars: + white_fg_red_bg: "\e[0m\e[48;5;1m" + two: "{{ white_fg_red_bg }} 2 " + ansible_callback_diy_playbook_on_task_start_msg: "\nDIY output(via task vars): task example: {{ ansible_callback_diy.task.name }}" + ansible_callback_diy_playbook_on_task_start_msg_color: bright magenta + ansible_callback_diy_runner_on_ok_msg: "DIY output(via task vars): result example: \n{{ ansible_callback_diy.result.output.msg }}\n" + ansible_callback_diy_runner_on_ok_msg_color: "{{ 'yellow' if ansible_callback_diy.result.is_changed else 'bright green' }}" + + - name: Suppress output + ansible.builtin.debug: + msg: i should not be displayed + vars: + ansible_callback_diy_playbook_on_task_start_msg: "" + ansible_callback_diy_runner_on_ok_msg: "" + + - name: Using alias vars (see ansible.cfg) + ansible.builtin.debug: + msg: + when: false + vars: + ansible_callback_diy_playbook_on_task_start_msg: "" + on_skipped_msg: "DIY output(via task vars): skipped example:\n\e[0m\e[38;5;4m\u25b6\u25b6 {{ ansible_callback_diy.result.task.name }}\n" + on_skipped_msg_color: white + + - name: Just stdout + ansible.builtin.command: echo some stdout + vars: + ansible_callback_diy_playbook_on_task_start_msg: "\n" + ansible_callback_diy_runner_on_ok_msg: "{{ ansible_callback_diy.result.output.stdout }}\n" + + - name: Multiline output + ansible.builtin.debug: + msg: "{{ multiline }}" + vars: + ansible_callback_diy_playbook_on_task_start_msg: "\nDIY output(via task vars): task example: {{ ansible_callback_diy.task.name }}" + multiline: "line\nline\nline" + ansible_callback_diy_runner_on_ok_msg: |+2 + some + {{ ansible_callback_diy.result.output.msg }} + output + + ansible_callback_diy_playbook_on_task_start_msg_color: bright blue + + - name: Indentation + ansible.builtin.debug: + msg: "{{ item.msg }}" + with_items: + - { indent: 1, msg: one., color: red } + - { indent: 2, msg: two.., color: yellow } + - { indent: 3, msg: three..., color: bright yellow } + vars: + ansible_callback_diy_runner_item_on_ok_msg: "{{ ansible_callback_diy.result.output.msg | indent(item.indent, True) }}" + ansible_callback_diy_runner_item_on_ok_msg_color: "{{ item.color }}" + ansible_callback_diy_runner_on_ok_msg: "GO!!!" + ansible_callback_diy_runner_on_ok_msg_color: bright green + + - name: Using lookup and template as file + ansible.builtin.shell: "echo {% raw %}'output from {{ file_name }}'{% endraw %} > {{ file_name }}" + vars: + ansible_callback_diy_playbook_on_task_start_msg: "\nDIY output(via task vars): task example: {{ ansible_callback_diy.task.name }}" + file_name: diy_file_template_example + ansible_callback_diy_runner_on_ok_msg: "{{ lookup('template', file_name) }}" + + - name: 'Look at top level vars available to the "runner_on_ok" callback' + ansible.builtin.debug: + msg: '' + vars: + ansible_callback_diy_playbook_on_task_start_msg: "\nDIY output(via task vars): task example: {{ ansible_callback_diy.task.name }}" + ansible_callback_diy_runner_on_ok_msg: |+2 + {% for var in (ansible_callback_diy.top_level_var_names|reject('match','vars|ansible_callback_diy.*')) | sort %} + {{ green }}{{ var }}: + {{ white }}{{ lookup('vars', var) }} + + {% endfor %} + ansible_callback_diy_runner_on_ok_msg_color: white + + - name: 'Look at event data available to the "runner_on_ok" callback' + ansible.builtin.debug: + msg: '' + vars: + ansible_callback_diy_playbook_on_task_start_msg: "\nDIY output(via task vars): task example: {{ ansible_callback_diy.task.name }}" + ansible_callback_diy_runner_on_ok_msg: |+2 + {% for key in ansible_callback_diy | sort %} + {{ green }}{{ key }}: + {{ white }}{{ ansible_callback_diy[key] }} + + {% endfor %} +''' + +import sys +from contextlib import contextmanager +from ansible.template import Templar +from ansible.vars.manager import VariableManager +from ansible.plugins.callback.default import CallbackModule as Default +from ansible.module_utils.common.text.converters import to_text + + +class DummyStdout(object): + def flush(self): + pass + + def write(self, b): + pass + + def writelines(self, l): + pass + + +class CallbackModule(Default): + """ + Callback plugin that allows you to supply your own custom callback templates to be output. + """ + CALLBACK_VERSION = 2.0 + CALLBACK_TYPE = 'stdout' + CALLBACK_NAME = 'community.general.diy' + + DIY_NS = 'ansible_callback_diy' + + @contextmanager + def _suppress_stdout(self, enabled): + saved_stdout = sys.stdout + if enabled: + sys.stdout = DummyStdout() + yield + sys.stdout = saved_stdout + + def _get_output_specification(self, loader, variables): + _ret = {} + _calling_method = sys._getframe(1).f_code.co_name + _callback_type = (_calling_method[3:] if _calling_method[:3] == "v2_" else _calling_method) + _callback_options = ['msg', 'msg_color'] + + for option in _callback_options: + _option_name = '%s_%s' % (_callback_type, option) + _option_template = variables.get( + self.DIY_NS + "_" + _option_name, + self.get_option(_option_name) + ) + _ret.update({option: self._template( + loader=loader, + template=_option_template, + variables=variables + )}) + + _ret.update({'vars': variables}) + + return _ret + + def _using_diy(self, spec): + return (spec['msg'] is not None) and (spec['msg'] != spec['vars']['omit']) + + def _parent_has_callback(self): + return hasattr(super(CallbackModule, self), sys._getframe(1).f_code.co_name) + + def _template(self, loader, template, variables): + _templar = Templar(loader=loader, variables=variables) + return _templar.template( + template, + preserve_trailing_newlines=True, + convert_data=False, + escape_backslashes=True + ) + + def _output(self, spec, stderr=False): + _msg = to_text(spec['msg']) + if len(_msg) > 0: + self._display.display(msg=_msg, color=spec['msg_color'], stderr=stderr) + + def _get_vars(self, playbook, play=None, host=None, task=None, included_file=None, + handler=None, result=None, stats=None, remove_attr_ref_loop=True): + def _get_value(obj, attr=None, method=None): + if attr: + return getattr(obj, attr, getattr(obj, "_" + attr, None)) + + if method: + _method = getattr(obj, method) + return _method() + + def _remove_attr_ref_loop(obj, attributes): + _loop_var = getattr(obj, 'loop_control', None) + _loop_var = (_loop_var or 'item') + + for attr in attributes: + if str(_loop_var) in str(_get_value(obj=obj, attr=attr)): + attributes.remove(attr) + + return attributes + + class CallbackDIYDict(dict): + def __deepcopy__(self, memo): + return self + + _ret = {} + + _variable_manager = VariableManager(loader=playbook.get_loader()) + + _all = _variable_manager.get_vars() + if play: + _all = play.get_variable_manager().get_vars( + play=play, + host=(host if host else getattr(result, '_host', None)), + task=(handler if handler else task) + ) + _ret.update(_all) + + _ret.update(_ret.get(self.DIY_NS, {self.DIY_NS: CallbackDIYDict()})) + + _ret[self.DIY_NS].update({'playbook': {}}) + _playbook_attributes = ['entries', 'file_name', 'basedir'] + + for attr in _playbook_attributes: + _ret[self.DIY_NS]['playbook'].update({attr: _get_value(obj=playbook, attr=attr)}) + + if play: + _ret[self.DIY_NS].update({'play': {}}) + _play_attributes = ['any_errors_fatal', 'become', 'become_flags', 'become_method', + 'become_user', 'check_mode', 'collections', 'connection', + 'debugger', 'diff', 'environment', 'fact_path', 'finalized', + 'force_handlers', 'gather_facts', 'gather_subset', + 'gather_timeout', 'handlers', 'hosts', 'ignore_errors', + 'ignore_unreachable', 'included_conditional', 'included_path', + 'max_fail_percentage', 'module_defaults', 'name', 'no_log', + 'only_tags', 'order', 'port', 'post_tasks', 'pre_tasks', + 'remote_user', 'removed_hosts', 'roles', 'run_once', 'serial', + 'skip_tags', 'squashed', 'strategy', 'tags', 'tasks', 'uuid', + 'validated', 'vars_files', 'vars_prompt'] + + for attr in _play_attributes: + _ret[self.DIY_NS]['play'].update({attr: _get_value(obj=play, attr=attr)}) + + if host: + _ret[self.DIY_NS].update({'host': {}}) + _host_attributes = ['name', 'uuid', 'address', 'implicit'] + + for attr in _host_attributes: + _ret[self.DIY_NS]['host'].update({attr: _get_value(obj=host, attr=attr)}) + + if task: + _ret[self.DIY_NS].update({'task': {}}) + _task_attributes = ['action', 'any_errors_fatal', 'args', 'async', 'async_val', + 'become', 'become_flags', 'become_method', 'become_user', + 'changed_when', 'check_mode', 'collections', 'connection', + 'debugger', 'delay', 'delegate_facts', 'delegate_to', 'diff', + 'environment', 'failed_when', 'finalized', 'ignore_errors', + 'ignore_unreachable', 'loop', 'loop_control', 'loop_with', + 'module_defaults', 'name', 'no_log', 'notify', 'parent', 'poll', + 'port', 'register', 'remote_user', 'retries', 'role', 'run_once', + 'squashed', 'tags', 'untagged', 'until', 'uuid', 'validated', + 'when'] + + # remove arguments that reference a loop var because they cause templating issues in + # callbacks that do not have the loop context(e.g. playbook_on_task_start) + if task.loop and remove_attr_ref_loop: + _task_attributes = _remove_attr_ref_loop(obj=task, attributes=_task_attributes) + + for attr in _task_attributes: + _ret[self.DIY_NS]['task'].update({attr: _get_value(obj=task, attr=attr)}) + + if included_file: + _ret[self.DIY_NS].update({'included_file': {}}) + _included_file_attributes = ['args', 'filename', 'hosts', 'is_role', 'task'] + + for attr in _included_file_attributes: + _ret[self.DIY_NS]['included_file'].update({attr: _get_value( + obj=included_file, + attr=attr + )}) + + if handler: + _ret[self.DIY_NS].update({'handler': {}}) + _handler_attributes = ['action', 'any_errors_fatal', 'args', 'async', 'async_val', + 'become', 'become_flags', 'become_method', 'become_user', + 'changed_when', 'check_mode', 'collections', 'connection', + 'debugger', 'delay', 'delegate_facts', 'delegate_to', 'diff', + 'environment', 'failed_when', 'finalized', 'ignore_errors', + 'ignore_unreachable', 'listen', 'loop', 'loop_control', + 'loop_with', 'module_defaults', 'name', 'no_log', + 'notified_hosts', 'notify', 'parent', 'poll', 'port', + 'register', 'remote_user', 'retries', 'role', 'run_once', + 'squashed', 'tags', 'untagged', 'until', 'uuid', 'validated', + 'when'] + + if handler.loop and remove_attr_ref_loop: + _handler_attributes = _remove_attr_ref_loop(obj=handler, + attributes=_handler_attributes) + + for attr in _handler_attributes: + _ret[self.DIY_NS]['handler'].update({attr: _get_value(obj=handler, attr=attr)}) + + _ret[self.DIY_NS]['handler'].update({'is_host_notified': handler.is_host_notified(host)}) + + if result: + _ret[self.DIY_NS].update({'result': {}}) + _result_attributes = ['host', 'task', 'task_name'] + + for attr in _result_attributes: + _ret[self.DIY_NS]['result'].update({attr: _get_value(obj=result, attr=attr)}) + + _result_methods = ['is_changed', 'is_failed', 'is_skipped', 'is_unreachable'] + + for method in _result_methods: + _ret[self.DIY_NS]['result'].update({method: _get_value(obj=result, method=method)}) + + _ret[self.DIY_NS]['result'].update({'output': getattr(result, '_result', None)}) + + _ret.update(result._result) + + if stats: + _ret[self.DIY_NS].update({'stats': {}}) + _stats_attributes = ['changed', 'custom', 'dark', 'failures', 'ignored', + 'ok', 'processed', 'rescued', 'skipped'] + + for attr in _stats_attributes: + _ret[self.DIY_NS]['stats'].update({attr: _get_value(obj=stats, attr=attr)}) + + _ret[self.DIY_NS].update({'top_level_var_names': list(_ret.keys())}) + + return _ret + + def v2_on_any(self, *args, **kwargs): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._diy_spec['vars'] + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_on_any(*args, **kwargs) + + def v2_runner_on_failed(self, result, ignore_errors=False): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task, + result=result + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec, stderr=(not ignore_errors)) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_runner_on_failed(result, ignore_errors) + + def v2_runner_on_ok(self, result): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task, + result=result + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_runner_on_ok(result) + + def v2_runner_on_skipped(self, result): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task, + result=result + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_runner_on_skipped(result) + + def v2_runner_on_unreachable(self, result): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task, + result=result + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_runner_on_unreachable(result) + + # not implemented as the call to this is not implemented yet + def v2_runner_on_async_poll(self, result): + pass + + # not implemented as the call to this is not implemented yet + def v2_runner_on_async_ok(self, result): + pass + + # not implemented as the call to this is not implemented yet + def v2_runner_on_async_failed(self, result): + pass + + def v2_runner_item_on_ok(self, result): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task, + result=result, + remove_attr_ref_loop=False + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_runner_item_on_ok(result) + + def v2_runner_item_on_failed(self, result): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task, + result=result, + remove_attr_ref_loop=False + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_runner_item_on_failed(result) + + def v2_runner_item_on_skipped(self, result): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task, + result=result, + remove_attr_ref_loop=False + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_runner_item_on_skipped(result) + + def v2_runner_retry(self, result): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task, + result=result + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_runner_retry(result) + + def v2_runner_on_start(self, host, task): + self._diy_host = host + self._diy_task = task + + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + host=self._diy_host, + task=self._diy_task + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_runner_on_start(host, task) + + def v2_playbook_on_start(self, playbook): + self._diy_playbook = playbook + self._diy_loader = self._diy_playbook.get_loader() + + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_start(playbook) + + def v2_playbook_on_notify(self, handler, host): + self._diy_handler = handler + self._diy_host = host + + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + host=self._diy_host, + handler=self._diy_handler + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_notify(handler, host) + + def v2_playbook_on_no_hosts_matched(self): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._diy_spec['vars'] + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_no_hosts_matched() + + def v2_playbook_on_no_hosts_remaining(self): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._diy_spec['vars'] + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_no_hosts_remaining() + + def v2_playbook_on_task_start(self, task, is_conditional): + self._diy_task = task + + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_task_start(task, is_conditional) + + # not implemented as the call to this is not implemented yet + def v2_playbook_on_cleanup_task_start(self, task): + pass + + def v2_playbook_on_handler_task_start(self, task): + self._diy_task = task + + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_handler_task_start(task) + + def v2_playbook_on_vars_prompt(self, varname, private=True, prompt=None, encrypt=None, + confirm=False, salt_size=None, salt=None, default=None, + unsafe=None): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._diy_spec['vars'] + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_vars_prompt( + varname, private, prompt, encrypt, + confirm, salt_size, salt, default, + unsafe + ) + + # not implemented as the call to this is not implemented yet + def v2_playbook_on_import_for_host(self, result, imported_file): + pass + + # not implemented as the call to this is not implemented yet + def v2_playbook_on_not_import_for_host(self, result, missing_file): + pass + + def v2_playbook_on_play_start(self, play): + self._diy_play = play + + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_play_start(play) + + def v2_playbook_on_stats(self, stats): + self._diy_stats = stats + + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + stats=self._diy_stats + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_stats(stats) + + def v2_playbook_on_include(self, included_file): + self._diy_included_file = included_file + + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_included_file._task, + included_file=self._diy_included_file + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_playbook_on_include(included_file) + + def v2_on_file_diff(self, result): + self._diy_spec = self._get_output_specification( + loader=self._diy_loader, + variables=self._get_vars( + playbook=self._diy_playbook, + play=self._diy_play, + task=self._diy_task, + result=result + ) + ) + + if self._using_diy(spec=self._diy_spec): + self._output(spec=self._diy_spec) + + if self._parent_has_callback(): + with self._suppress_stdout(enabled=self._using_diy(spec=self._diy_spec)): + super(CallbackModule, self).v2_on_file_diff(result) |