1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
|
# pylint: disable=invalid-name,protected-access,import-error,line-too-long,attribute-defined-outside-init
# 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 <http://www.gnu.org/licenses/>.
"""This file is a stdout callback plugin for the OpenShift Quick
Installer. The purpose of this callback plugin is to reduce the amount
of produced output for customers and enable simpler progress checking.
What's different:
* Playbook progress is expressed as: Play <current_play>/<total_plays> (Play Name)
Ex: Play 3/30 (Initialize Megafrobber)
* The Tasks and Handlers in each play (and included roles) are printed
as a series of .'s following the play progress line.
* Many of these methods include copy and paste code from the upstream
default.py callback. We do that to give us control over the stdout
output while allowing Ansible to handle the file logging
normally. The biggest changes here are that we are manually setting
`log_only` to True in the Display.display method and we redefine the
Display.banner method locally so we can set log_only on that call as
well.
"""
from __future__ import (absolute_import, print_function)
import sys
from ansible import constants as C
from ansible.plugins.callback import CallbackBase
from ansible.utils.color import colorize, hostcolor
class CallbackModule(CallbackBase):
"""
Ansible callback plugin
"""
CALLBACK_VERSION = 2.2
CALLBACK_TYPE = 'stdout'
CALLBACK_NAME = 'openshift_quick_installer'
CALLBACK_NEEDS_WHITELIST = False
plays_count = 0
plays_total_ran = 0
def banner(self, msg, color=None):
'''Prints a header-looking line with stars taking up to 80 columns
of width (3 columns, minimum)
Overrides the upstream banner method so that display is called
with log_only=True
'''
msg = msg.strip()
star_len = (79 - len(msg))
if star_len < 0:
star_len = 3
stars = "*" * star_len
self._display.display("\n%s %s" % (msg, stars), color=color, log_only=True)
def v2_playbook_on_start(self, playbook):
"""This is basically the start of it all"""
self.plays_count = len(playbook.get_plays())
self.plays_total_ran = 0
if self._display.verbosity > 1:
from os.path import basename
self.banner("PLAYBOOK: %s" % basename(playbook._file_name))
def v2_playbook_on_play_start(self, play):
"""Each play calls this once before running any tasks
We could print the number of tasks here as well by using
`play.get_tasks()` but that is not accurate when a play includes a
role. Only the tasks directly assigned to a play are exposed in the
`play` object.
"""
self.plays_total_ran += 1
print("")
print("Play %s/%s (%s)" % (self.plays_total_ran, self.plays_count, play.get_name()))
name = play.get_name().strip()
if not name:
msg = "PLAY"
else:
msg = "PLAY [%s]" % name
self._play = play
self.banner(msg)
# pylint: disable=unused-argument,no-self-use
def v2_playbook_on_task_start(self, task, is_conditional):
"""This prints out the task header. For example:
TASK [openshift_facts : Ensure PyYaml is installed] ***...
Rather than print out all that for every task, we print a dot
character to indicate a task has been started.
"""
sys.stdout.write('.')
args = ''
# args can be specified as no_log in several places: in the task or in
# the argument spec. We can check whether the task is no_log but the
# argument spec can't be because that is only run on the target
# machine and we haven't run it thereyet at this time.
#
# So we give people a config option to affect display of the args so
# that they can secure this if they feel that their stdout is insecure
# (shoulder surfing, logging stdout straight to a file, etc).
if not task.no_log and C.DISPLAY_ARGS_TO_STDOUT:
args = ', '.join(('%s=%s' % a for a in task.args.items()))
args = ' %s' % args
self.banner("TASK [%s%s]" % (task.get_name().strip(), args))
if self._display.verbosity >= 2:
path = task.get_path()
if path:
self._display.display("task path: %s" % path, color=C.COLOR_DEBUG, log_only=True)
# pylint: disable=unused-argument,no-self-use
def v2_playbook_on_handler_task_start(self, task):
"""Print out task header for handlers
Rather than print out a header for every handler, we print a dot
character to indicate a handler task has been started.
"""
sys.stdout.write('.')
self.banner("RUNNING HANDLER [%s]" % task.get_name().strip())
# pylint: disable=unused-argument,no-self-use
def v2_playbook_on_cleanup_task_start(self, task):
"""Print out a task header for cleanup tasks
Rather than print out a header for every handler, we print a dot
character to indicate a handler task has been started.
"""
sys.stdout.write('.')
self.banner("CLEANUP TASK [%s]" % task.get_name().strip())
def v2_playbook_on_include(self, included_file):
"""Print out paths to statically included files"""
msg = 'included: %s for %s' % (included_file._filename, ", ".join([h.name for h in included_file._hosts]))
self._display.display(msg, color=C.COLOR_SKIP, log_only=True)
def v2_runner_on_ok(self, result):
"""This prints out task results in a fancy format
The only thing we change here is adding `log_only=True` to the
.display() call
"""
delegated_vars = result._result.get('_ansible_delegated_vars', None)
self._clean_results(result._result, result._task.action)
if result._task.action in ('include', 'include_role'):
return
elif result._result.get('changed', False):
if delegated_vars:
msg = "changed: [%s -> %s]" % (result._host.get_name(), delegated_vars['ansible_host'])
else:
msg = "changed: [%s]" % result._host.get_name()
color = C.COLOR_CHANGED
else:
if delegated_vars:
msg = "ok: [%s -> %s]" % (result._host.get_name(), delegated_vars['ansible_host'])
else:
msg = "ok: [%s]" % result._host.get_name()
color = C.COLOR_OK
if result._task.loop and 'results' in result._result:
self._process_items(result)
else:
if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and '_ansible_verbose_override' not in result._result:
msg += " => %s" % (self._dump_results(result._result),)
self._display.display(msg, color=color, log_only=True)
self._handle_warnings(result._result)
def v2_runner_item_on_ok(self, result):
"""Print out task results for items you're iterating over"""
delegated_vars = result._result.get('_ansible_delegated_vars', None)
if result._task.action in ('include', 'include_role'):
return
elif result._result.get('changed', False):
msg = 'changed'
color = C.COLOR_CHANGED
else:
msg = 'ok'
color = C.COLOR_OK
if delegated_vars:
msg += ": [%s -> %s]" % (result._host.get_name(), delegated_vars['ansible_host'])
else:
msg += ": [%s]" % result._host.get_name()
msg += " => (item=%s)" % (self._get_item(result._result),)
if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and '_ansible_verbose_override' not in result._result:
msg += " => %s" % self._dump_results(result._result)
self._display.display(msg, color=color, log_only=True)
def v2_runner_item_on_skipped(self, result):
"""Print out task results when an item is skipped"""
if C.DISPLAY_SKIPPED_HOSTS:
msg = "skipping: [%s] => (item=%s) " % (result._host.get_name(), self._get_item(result._result))
if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and '_ansible_verbose_override' not in result._result:
msg += " => %s" % self._dump_results(result._result)
self._display.display(msg, color=C.COLOR_SKIP, log_only=True)
def v2_runner_on_skipped(self, result):
"""Print out task results when a task (or something else?) is skipped"""
if C.DISPLAY_SKIPPED_HOSTS:
if result._task.loop and 'results' in result._result:
self._process_items(result)
else:
msg = "skipping: [%s]" % result._host.get_name()
if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and '_ansible_verbose_override' not in result._result:
msg += " => %s" % self._dump_results(result._result)
self._display.display(msg, color=C.COLOR_SKIP, log_only=True)
def v2_playbook_on_notify(self, res, handler):
"""What happens when a task result is 'changed' and the task has a
'notify' list attached.
"""
self._display.display("skipping: no hosts matched", color=C.COLOR_SKIP, log_only=True)
def v2_playbook_on_stats(self, stats):
"""Print the final playbook run stats"""
self._display.display("", screen_only=True)
self.banner("PLAY RECAP")
hosts = sorted(stats.processed.keys())
for h in hosts:
t = stats.summarize(h)
self._display.display(
u"%s : %s %s %s %s" % (
hostcolor(h, t),
colorize(u'ok', t['ok'], C.COLOR_OK),
colorize(u'changed', t['changed'], C.COLOR_CHANGED),
colorize(u'unreachable', t['unreachable'], C.COLOR_UNREACHABLE),
colorize(u'failed', t['failures'], C.COLOR_ERROR)),
screen_only=True
)
self._display.display(
u"%s : %s %s %s %s" % (
hostcolor(h, t, False),
colorize(u'ok', t['ok'], None),
colorize(u'changed', t['changed'], None),
colorize(u'unreachable', t['unreachable'], None),
colorize(u'failed', t['failures'], None)),
log_only=True
)
self._display.display("", screen_only=True)
self._display.display("", screen_only=True)
# Some plays are conditional and won't run (such as load
# balancers) if they aren't required. Sometimes plays are
# conditionally included later in the run. Let the user know
# about this to avoid potential confusion.
if self.plays_total_ran != self.plays_count:
print("Installation Complete: Note: Play count is only an estimate, some plays may have been skipped or dynamically added")
self._display.display("", screen_only=True)
|
