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
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
|
#
# Author:: Adam Leff (<adamleff@chef.io>)
# Author:: Ryan Cragun (<ryan@chef.io>)
#
# Copyright:: Copyright 2012-2016, Chef Software Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
require "uri"
require "chef/event_dispatch/base"
require "chef/data_collector/messages"
require "chef/data_collector/resource_report"
require "ostruct"
class Chef
# == Chef::DataCollector
# Provides methods for determinine whether a reporter should be registered.
class DataCollector
def self.register_reporter?
Chef::Config[:data_collector][:server_url] &&
!Chef::Config[:why_run] &&
self.reporter_enabled_for_current_mode?
end
def self.reporter_enabled_for_current_mode?
if Chef::Config[:solo] || Chef::Config[:local_mode]
acceptable_modes = [:solo, :both]
else
acceptable_modes = [:client, :both]
end
acceptable_modes.include?(Chef::Config[:data_collector][:mode])
end
# == Chef::DataCollector::Reporter
# Provides an event handler that can be registered to report on Chef
# run data. Unlike the existing Chef::ResourceReporter event handler,
# the DataCollector handler is not tied to a Chef Server / Chef Reporting
# and exports its data through a webhook-like mechanism to a configured
# endpoint.
class Reporter < EventDispatch::Base
attr_reader :all_resource_reports, :status, :exception, :error_descriptions,
:expanded_run_list, :run_context, :run_status, :http,
:current_resource_report, :enabled
def initialize
@all_resource_reports = []
@current_resource_loaded = nil
@error_descriptions = {}
@expanded_run_list = {}
@http = Chef::HTTP.new(data_collector_server_url)
@enabled = true
end
# see EventDispatch::Base#run_started
# Upon receipt, we will send our run start message to the
# configured DataCollector endpoint. Depending on whether
# the user has configured raise_on_failure, if we cannot
# send the message, we will either disable the DataCollector
# Reporter for the duration of this run, or we'll raise an
# exception.
def run_started(current_run_status)
update_run_status(current_run_status)
disable_reporter_on_error do
send_to_data_collector(
Chef::DataCollector::Messages.run_start_message(current_run_status).to_json
)
end
end
# see EventDispatch::Base#run_completed
# Upon receipt, we will send our run completion message to the
# configured DataCollector endpoint.
def run_completed(node)
send_run_completion(status: "success")
end
# see EventDispatch::Base#run_failed
def run_failed(exception)
send_run_completion(status: "failure")
end
# see EventDispatch::Base#converge_start
# Upon receipt, we stash the run_context for use at the
# end of the run in order to determine what resource+action
# combinations have not yet fired so we can report on
# unprocessed resources.
def converge_start(run_context)
@run_context = run_context
end
# see EventDispatch::Base#converge_complete
# At the end of the converge, we add any unprocessed resources
# to our report list.
def converge_complete
detect_unprocessed_resources
end
# see EventDispatch::Base#converge_failed
# At the end of the converge, we add any unprocessed resources
# to our report list
def converge_failed(exception)
detect_unprocessed_resources
end
# see EventDispatch::Base#resource_current_state_loaded
# Create a new ResourceReport instance that we'll use to track
# the state of this resource during the run. Nested resources are
# ignored as they are assumed to be an inline resource of a custom
# resource, and we only care about tracking top-level resources.
def resource_current_state_loaded(new_resource, action, current_resource)
return if nested_resource?(new_resource)
update_current_resource_report(create_resource_report(new_resource, action, current_resource))
end
# see EventDispatch::Base#resource_up_to_date
# Mark our ResourceReport status accordingly
def resource_up_to_date(new_resource, action)
current_resource_report.up_to_date unless nested_resource?(new_resource)
end
# see EventDispatch::Base#resource_skipped
# If this is a top-level resource, we create a ResourceReport
# instance (because a skipped resource does not trigger the
# resource_current_state_loaded event), and flag it as skipped.
def resource_skipped(new_resource, action, conditional)
return if nested_resource?(new_resource)
resource_report = create_resource_report(new_resource, action)
resource_report.skipped(conditional)
update_current_resource_report(resource_report)
end
# see EventDispatch::Base#resource_updated
# Flag the current ResourceReport instance as updated (as long as it's
# a top-level resource).
def resource_updated(new_resource, action)
current_resource_report.updated unless nested_resource?(new_resource)
end
# see EventDispatch::Base#resource_failed
# Flag the current ResourceReport as failed and supply the exception as
# long as it's a top-level resource, and update the run error text
# with the proper Formatter.
def resource_failed(new_resource, action, exception)
current_resource_report.failed(exception) unless nested_resource?(new_resource)
update_error_description(
Formatters::ErrorMapper.resource_failed(
new_resource,
action,
exception
).for_json
)
end
# see EventDispatch::Base#resource_completed
# Mark the ResourceReport instance as finished (for timing details).
# This marks the end of this resource during this run.
def resource_completed(new_resource)
if current_resource_report && !nested_resource?(new_resource)
current_resource_report.finish
add_resource_report(current_resource_report)
update_current_resource_report(nil)
end
end
# see EventDispatch::Base#run_list_expanded
# The expanded run list is stored for later use by the run_completed
# event and message.
def run_list_expanded(run_list_expansion)
@expanded_run_list = run_list_expansion
end
# see EventDispatch::Base#run_list_expand_failed
# The run error text is updated with the output of the appropriate
# formatter.
def run_list_expand_failed(node, exception)
update_error_description(
Formatters::ErrorMapper.run_list_expand_failed(
node,
exception
).for_json
)
end
# see EventDispatch::Base#cookbook_resolution_failed
# The run error text is updated with the output of the appropriate
# formatter.
def cookbook_resolution_failed(expanded_run_list, exception)
update_error_description(
Formatters::ErrorMapper.cookbook_resolution_failed(
expanded_run_list,
exception
).for_json
)
end
# see EventDispatch::Base#cookbook_sync_failed
# The run error text is updated with the output of the appropriate
# formatter.
def cookbook_sync_failed(cookbooks, exception)
update_error_description(
Formatters::ErrorMapper.cookbook_sync_failed(
cookbooks,
exception
).for_json
)
end
private
#
# Yields to the passed-in block (which is expected to be some interaction
# with the DataCollector endpoint). If some communication failure occurs,
# either disable any future communications to the DataCollector endpoint, or
# raise an exception (if the user has set
# Chef::Config.data_collector.raise_on_failure to true.)
#
# @param block [Proc] A ruby block to run. Ignored if a command is given.
#
def disable_reporter_on_error
yield
rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse,
Net::HTTPHeaderSyntaxError, Net::ProtocolError, OpenSSL::SSL::SSLError => e
disable_data_collector_reporter
code = if e.respond_to?(:response) && e.response.code
e.response.code.to_s
else
"Exception Code Empty"
end
msg = "Error while reporting run start to Data Collector. " \
"URL: #{data_collector_server_url} " \
"Exception: #{code} -- #{e.message} "
if Chef::Config[:data_collector][:raise_on_failure]
Chef::Log.error(msg)
raise
else
Chef::Log.warn(msg)
end
end
def send_to_data_collector(message)
return unless data_collector_accessible?
Chef::Log.debug("data_collector_reporter: POSTing the following message to #{data_collector_server_url}: #{message}")
http.post(nil, message, headers)
end
#
# Send any messages to the DataCollector endpoint that are necessary to
# indicate the run has completed. Currently, two messages are sent:
#
# - An "action" message with the node object indicating it's been updated
# - An "run_converge" (i.e. RunEnd) message with details about the run,
# what resources were modified/up-to-date/skipped, etc.
#
# @param opts [Hash] Additional details about the run, such as its success/failure.
#
def send_run_completion(opts)
# If run_status is nil we probably failed before the client triggered
# the run_started callback. In this case we'll skip updating because
# we have nothing to report.
return unless run_status
send_to_data_collector(Chef::DataCollector::Messages.node_update_message(run_status).to_json)
send_to_data_collector(
Chef::DataCollector::Messages.run_end_message(
run_status: run_status,
expanded_run_list: expanded_run_list,
resources: all_resource_reports,
status: opts[:status],
error_descriptions: error_descriptions
).to_json
)
end
def headers
headers = { "Content-Type" => "application/json" }
unless data_collector_token.nil?
headers["x-data-collector-token"] = data_collector_token
headers["x-data-collector-auth"] = "version=1.0"
end
headers
end
def data_collector_server_url
Chef::Config[:data_collector][:server_url]
end
def data_collector_token
Chef::Config[:data_collector][:token]
end
def add_resource_report(resource_report)
@all_resource_reports << OpenStruct.new(
resource: resource_report.new_resource,
action: resource_report.action,
report_data: resource_report.to_hash
)
end
def disable_data_collector_reporter
@enabled = false
end
def data_collector_accessible?
@enabled
end
def update_run_status(run_status)
@run_status = run_status
end
def update_current_resource_report(resource_report)
@current_resource_report = resource_report
end
def update_error_description(discription_hash)
@error_descriptions = discription_hash
end
def create_resource_report(new_resource, action, current_resource = nil)
Chef::DataCollector::ResourceReport.new(
new_resource,
action,
current_resource
)
end
def detect_unprocessed_resources
# create a Set containing all resource+action combinations from
# the Resource Collection
collection_resources = Set.new
run_context.resource_collection.all_resources.each do |resource|
Array(resource.action).each do |action|
collection_resources.add([resource, action])
end
end
# Delete from the Set any resource+action combination we have
# already processed.
all_resource_reports.each do |report|
collection_resources.delete([report.resource, report.action])
end
# The items remaining in the Set are unprocessed resource+actions,
# so we'll create new resource reports for them which default to
# a state of "unprocessed".
collection_resources.each do |resource, action|
add_resource_report(create_resource_report(resource, action))
end
end
# If we are getting messages about a resource while we are in the middle of
# another resource's update, we assume that the nested resource is just the
# implementation of a provider, and we want to hide it from the reporting
# output.
def nested_resource?(new_resource)
@current_resource_report && @current_resource_report.new_resource != new_resource
end
end
end
end
|