chef 14.15.6-universal-mingw32 → 15.0.293-universal-mingw32

data/lib/chef/data_bag_item.rb

@@ -1,209 +1,209 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Nuo Yan (<nuo@chef.io>)
-# Author:: Christopher Brown (<cb@chef.io>)
-# Copyright:: Copyright 2009-2018, 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 "forwardable"
-
-require "chef/config"
-require "chef/mixin/params_validate"
-require "chef/mixin/from_file"
-require "chef/data_bag"
-require "chef/mash"
-require "chef/server_api"
-require "chef/json_compat"
-
-class Chef
-  class DataBagItem
-
-    extend Forwardable
-
-    include Chef::Mixin::FromFile
-    include Chef::Mixin::ParamsValidate
-
-    VALID_ID = /^[\.\-[:alnum:]_]+$/
-
-    def self.validate_id!(id_str)
-      if id_str.nil? || ( id_str !~ VALID_ID )
-        raise Exceptions::InvalidDataBagItemID, "Data Bag items must have an id matching #{VALID_ID.inspect}, you gave: #{id_str.inspect}"
-      end
-    end
-
-    # Define all Hash's instance methods as delegating to @raw_data
-    def_delegators(:@raw_data, *(Hash.instance_methods - Object.instance_methods))
-
-    attr_reader :raw_data
-
-    # Create a new Chef::DataBagItem
-    def initialize(chef_server_rest: nil)
-      @data_bag = nil
-      @raw_data = Mash.new
-      @chef_server_rest = chef_server_rest
-    end
-
-    def chef_server_rest
-      @chef_server_rest ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url])
-    end
-
-    def self.chef_server_rest
-      Chef::ServerAPI.new(Chef::Config[:chef_server_url])
-    end
-
-    def validate_id!(id_str)
-      self.class.validate_id!(id_str)
-    end
-
-    def raw_data=(new_data)
-      new_data = Mash.new(new_data)
-      unless new_data.respond_to?(:[]) && new_data.respond_to?(:keys)
-        raise Exceptions::ValidationFailed, "Data Bag Items must contain a Hash or Mash!"
-      end
-      validate_id!(new_data["id"])
-      @raw_data = new_data
-    end
-
-    def data_bag(arg = nil)
-      set_or_return(
-        :data_bag,
-        arg,
-        regex: /^[\-[:alnum:]_]+$/
-      )
-    end
-
-    def name
-      object_name
-    end
-
-    def object_name
-      raise Exceptions::ValidationFailed, "You must have an 'id' or :id key in the raw data" unless raw_data.key?("id")
-      raise Exceptions::ValidationFailed, "You must have declared what bag this item belongs to!" unless data_bag
-
-      id = raw_data["id"]
-      "data_bag_item_#{data_bag}_#{id}"
-    end
-
-    def self.object_name(data_bag_name, id)
-      "data_bag_item_#{data_bag_name}_#{id}"
-    end
-
-    def to_h
-      result = raw_data.dup
-      result["chef_type"] = "data_bag_item"
-      result["data_bag"] = data_bag.to_s
-      result
-    end
-
-    alias_method :to_hash, :to_h
-
-    # Serialize this object as a hash
-    def to_json(*a)
-      result = {
-        "name"       => object_name,
-        "json_class" => self.class.name,
-        "chef_type"  => "data_bag_item",
-        "data_bag"   => data_bag,
-        "raw_data"   => raw_data,
-      }
-      Chef::JSONCompat.to_json(result, *a)
-    end
-
-    def self.from_hash(h)
-      h.delete("chef_type")
-      h.delete("json_class")
-
-      item = new
-      item.data_bag(h.delete("data_bag")) if h.key?("data_bag")
-      if h.key?("raw_data")
-        item.raw_data = h["raw_data"]
-      else
-        item.raw_data = h
-      end
-      item
-    end
-
-    # Load a Data Bag Item by name via either the RESTful API or local data_bag_path if run in solo mode
-    def self.load(data_bag, name)
-      if Chef::Config[:solo_legacy_mode]
-        bag = Chef::DataBag.load(data_bag)
-        raise Exceptions::InvalidDataBagItemID, "Item #{name} not found in data bag #{data_bag}. Other items found: #{bag.keys.join(", ")}" unless bag.include?(name)
-        item = bag[name]
-      else
-        item = Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("data/#{data_bag}/#{name}")
-      end
-
-      if item.kind_of?(DataBagItem)
-        item
-      else
-        item = from_hash(item)
-        item.data_bag(data_bag)
-        item
-      end
-    end
-
-    def destroy(data_bag = self.data_bag(), databag_item = name)
-      chef_server_rest.delete("data/#{data_bag}/#{databag_item}")
-    end
-
-    # Save this Data Bag Item via RESTful API
-    def save(item_id = @raw_data["id"])
-      r = chef_server_rest
-      begin
-        if Chef::Config[:why_run]
-          Chef::Log.warn("In why-run mode, so NOT performing data bag item save.")
-        else
-          r.put("data/#{data_bag}/#{item_id}", self)
-        end
-      rescue Net::HTTPClientException => e
-        raise e unless e.response.code == "404"
-        r.post("data/#{data_bag}", self)
-      end
-      self
-    end
-
-    # Create this Data Bag Item via RESTful API
-    def create
-      chef_server_rest.post("data/#{data_bag}", self)
-      self
-    end
-
-    def ==(other)
-      other.respond_to?(:to_h) &&
-        other.respond_to?(:data_bag) &&
-        (other.to_h == to_h) &&
-        (other.data_bag.to_s == data_bag.to_s)
-    end
-
-    # As a string
-    def to_s
-      "data_bag_item[#{id}]"
-    end
-
-    def inspect
-      "data_bag_item[#{data_bag.inspect}, #{raw_data['id'].inspect}, #{raw_data.inspect}]"
-    end
-
-    def pretty_print(pretty_printer)
-      pretty_printer.pp({ "data_bag_item('#{data_bag}', '#{id}')" => to_hash })
-    end
-
-    def id
-      @raw_data["id"]
-    end
-
-  end
-end
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Nuo Yan (<nuo@chef.io>)
+# Author:: Christopher Brown (<cb@chef.io>)
+# Copyright:: Copyright 2009-2018, 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 "forwardable"
+
+require_relative "config"
+require_relative "mixin/params_validate"
+require_relative "mixin/from_file"
+require_relative "data_bag"
+require_relative "mash"
+require_relative "server_api"
+require_relative "json_compat"
+
+class Chef
+  class DataBagItem
+
+    extend Forwardable
+
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+
+    VALID_ID = /^[\.\-[:alnum:]_]+$/.freeze
+
+    def self.validate_id!(id_str)
+      if id_str.nil? || ( id_str !~ VALID_ID )
+        raise Exceptions::InvalidDataBagItemID, "Data Bag items must have an id matching #{VALID_ID.inspect}, you gave: #{id_str.inspect}"
+      end
+    end
+
+    # Define all Hash's instance methods as delegating to @raw_data
+    def_delegators(:@raw_data, *(Hash.instance_methods - Object.instance_methods))
+
+    attr_reader :raw_data
+
+    # Create a new Chef::DataBagItem
+    def initialize(chef_server_rest: nil)
+      @data_bag = nil
+      @raw_data = Mash.new
+      @chef_server_rest = chef_server_rest
+    end
+
+    def chef_server_rest
+      @chef_server_rest ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url])
+    end
+
+    def self.chef_server_rest
+      Chef::ServerAPI.new(Chef::Config[:chef_server_url])
+    end
+
+    def validate_id!(id_str)
+      self.class.validate_id!(id_str)
+    end
+
+    def raw_data=(new_data)
+      new_data = Mash.new(new_data)
+      unless new_data.respond_to?(:[]) && new_data.respond_to?(:keys)
+        raise Exceptions::ValidationFailed, "Data Bag Items must contain a Hash or Mash!"
+      end
+      validate_id!(new_data["id"])
+      @raw_data = new_data
+    end
+
+    def data_bag(arg = nil)
+      set_or_return(
+        :data_bag,
+        arg,
+        regex: /^[\-[:alnum:]_]+$/
+      )
+    end
+
+    def name
+      object_name
+    end
+
+    def object_name
+      raise Exceptions::ValidationFailed, "You must have an 'id' or :id key in the raw data" unless raw_data.key?("id")
+      raise Exceptions::ValidationFailed, "You must have declared what bag this item belongs to!" unless data_bag
+
+      id = raw_data["id"]
+      "data_bag_item_#{data_bag}_#{id}"
+    end
+
+    def self.object_name(data_bag_name, id)
+      "data_bag_item_#{data_bag_name}_#{id}"
+    end
+
+    def to_h
+      result = raw_data.dup
+      result["chef_type"] = "data_bag_item"
+      result["data_bag"] = data_bag.to_s
+      result
+    end
+
+    alias_method :to_hash, :to_h
+
+    # Serialize this object as a hash
+    def to_json(*a)
+      result = {
+        "name" => object_name,
+        "json_class" => self.class.name,
+        "chef_type" => "data_bag_item",
+        "data_bag" => data_bag,
+        "raw_data" => raw_data,
+      }
+      Chef::JSONCompat.to_json(result, *a)
+    end
+
+    def self.from_hash(h)
+      h.delete("chef_type")
+      h.delete("json_class")
+
+      item = new
+      item.data_bag(h.delete("data_bag")) if h.key?("data_bag")
+      if h.key?("raw_data")
+        item.raw_data = h["raw_data"]
+      else
+        item.raw_data = h
+      end
+      item
+    end
+
+    # Load a Data Bag Item by name via either the RESTful API or local data_bag_path if run in solo mode
+    def self.load(data_bag, name)
+      if Chef::Config[:solo_legacy_mode]
+        bag = Chef::DataBag.load(data_bag)
+        raise Exceptions::InvalidDataBagItemID, "Item #{name} not found in data bag #{data_bag}. Other items found: #{bag.keys.join(", ")}" unless bag.include?(name)
+        item = bag[name]
+      else
+        item = Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("data/#{data_bag}/#{name}")
+      end
+
+      if item.kind_of?(DataBagItem)
+        item
+      else
+        item = from_hash(item)
+        item.data_bag(data_bag)
+        item
+      end
+    end
+
+    def destroy(data_bag = self.data_bag(), databag_item = name)
+      chef_server_rest.delete("data/#{data_bag}/#{databag_item}")
+    end
+
+    # Save this Data Bag Item via RESTful API
+    def save(item_id = @raw_data["id"])
+      r = chef_server_rest
+      begin
+        if Chef::Config[:why_run]
+          Chef::Log.warn("In why-run mode, so NOT performing data bag item save.")
+        else
+          r.put("data/#{data_bag}/#{item_id}", self)
+        end
+      rescue Net::HTTPClientException => e
+        raise e unless e.response.code == "404"
+        r.post("data/#{data_bag}", self)
+      end
+      self
+    end
+
+    # Create this Data Bag Item via RESTful API
+    def create
+      chef_server_rest.post("data/#{data_bag}", self)
+      self
+    end
+
+    def ==(other)
+      other.respond_to?(:to_h) &&
+        other.respond_to?(:data_bag) &&
+        (other.to_h == to_h) &&
+        (other.data_bag.to_s == data_bag.to_s)
+    end
+
+    # As a string
+    def to_s
+      "data_bag_item[#{id}]"
+    end
+
+    def inspect
+      "data_bag_item[#{data_bag.inspect}, #{raw_data['id'].inspect}, #{raw_data.inspect}]"
+    end
+
+    def pretty_print(pretty_printer)
+      pretty_printer.pp({ "data_bag_item('#{data_bag}', '#{id}')" => to_hash })
+    end
+
+    def id
+      @raw_data["id"]
+    end
+
+  end
+end

data/lib/chef/data_collector.rb

@@ -1,565 +1,324 @@
-#
-# Author:: Adam Leff (<adamleff@chef.io>)
-# Author:: Ryan Cragun (<ryan@chef.io>)
-#
-# Copyright:: Copyright 2012-2018, 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/server_api"
-require "chef/http/simple_json"
-require "chef/event_dispatch/base"
-require "chef/data_collector/messages"
-require "chef/data_collector/resource_report"
-require "ostruct"
-require "set"
-
-class Chef
-
-  # == Chef::DataCollector
-  # Provides methods for determinine whether a reporter should be registered.
-  class DataCollector
-
-    # Whether or not to enable data collection:
-    # * always disabled for why run mode
-    # * disabled when the user sets `Chef::Config[:data_collector][:mode]` to a
-    #   value that excludes the mode (client or solo) that we are running as
-    # * disabled in solo mode if the user did not configure the auth token
-    # * disabled if `Chef::Config[:data_collector][:server_url]` is set to a
-    #   falsey value
-    def self.register_reporter?
-      if why_run?
-        Chef::Log.trace("data collector is disabled for why run mode")
-        return false
-      end
-      unless reporter_enabled_for_current_mode?
-        Chef::Log.trace("data collector is configured to only run in " \
-                        "#{Chef::Config[:data_collector][:mode].inspect} modes, disabling it")
-        return false
-      end
-      unless data_collector_url_configured? || data_collector_output_locations_configured?
-        Chef::Log.trace("Neither data collector URL or output locations have been configured, disabling data collector")
-        return false
-      end
-      if solo? && !token_auth_configured?
-        Chef::Log.trace("Data collector token must be configured to use Chef Automate data collector with Chef Solo")
-      end
-      if !solo? && token_auth_configured?
-        Chef::Log.warn("Data collector token authentication is not recommended for client-server mode" \
-                       "Please upgrade Chef Server to 12.11.0 and remove the token from your config file " \
-                       "to use key based authentication instead")
-      end
-      true
-    end
-
-    def self.data_collector_url_configured?
-      !!Chef::Config[:data_collector][:server_url]
-    end
-
-    def self.data_collector_output_locations_configured?
-      !!Chef::Config[:data_collector][:output_locations]
-    end
-
-    def self.why_run?
-      !!Chef::Config[:why_run]
-    end
-
-    def self.token_auth_configured?
-      !!Chef::Config[:data_collector][:token]
-    end
-
-    def self.solo?
-      !!Chef::Config[:solo] || !!Chef::Config[:local_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, :deprecations
-
-      def initialize
-        validate_data_collector_server_url!
-        validate_data_collector_output_locations! if data_collector_output_locations
-        @all_resource_reports    = []
-        @current_resource_loaded = nil
-        @error_descriptions      = {}
-        @expanded_run_list       = {}
-        @deprecations            = Set.new
-        @enabled                 = true
-
-        @http = setup_http_client(data_collector_server_url)
-        if data_collector_output_locations
-          @http_output_locations = setup_http_output_locations if data_collector_output_locations[:urls]
-        end
-      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)
-
-        message = Chef::DataCollector::Messages.run_start_message(current_run_status)
-        disable_reporter_on_error do
-          send_to_data_collector(message)
-        end
-        send_to_output_locations(message) if data_collector_output_locations
-      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)
-        initialize_resource_report_if_needed(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)
-        initialize_resource_report_if_needed(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)
-
-        initialize_resource_report_if_needed(new_resource, action)
-        current_resource_report.skipped(conditional)
-      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)
-        initialize_resource_report_if_needed(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)
-        initialize_resource_report_if_needed(new_resource, action)
-        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)
-          clear_current_resource_report
-        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
-
-      # see EventDispatch::Base#deprecation
-      # Append a received deprecation to the list of deprecations
-      def deprecation(message, location = caller(2..2)[0])
-        add_deprecation(message.message, message.url, location)
-      end
-
-      private
-
-      # Selects the type of HTTP client to use based on whether we are using
-      # token-based or signed header authentication. Token authentication is
-      # intended to be used primarily for Chef Solo in which case no signing
-      # key will be available (in which case `Chef::ServerAPI.new()` would
-      # raise an exception.
-      def setup_http_client(url)
-        if data_collector_token.nil?
-          Chef::ServerAPI.new(url, validate_utf8: false)
-        else
-          Chef::HTTP::SimpleJSON.new(url, validate_utf8: false)
-        end
-      end
-
-      def setup_http_output_locations
-        Chef::Config[:data_collector][:output_locations][:urls].each_with_object({}) do |location_url, http_output_locations|
-          http_output_locations[location_url] = setup_http_client(location_url)
-        end
-      end
-
-      #
-      # 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,
-             Errno::EHOSTDOWN => e
-        # Do not disable data collector reporter if additional output_locations have been specified
-        disable_data_collector_reporter unless data_collector_output_locations
-        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
-          # Make the message non-scary for folks who don't have automate:
-          msg << " (This is normal if you do not have Chef Automate)"
-          Chef::Log.info(msg)
-        end
-      end
-
-      def send_to_data_collector(message)
-        return unless data_collector_accessible?
-        http.post(nil, message, headers) if data_collector_server_url
-      end
-
-      def send_to_output_locations(message)
-        data_collector_output_locations.each do |type, location_list|
-          location_list.each do |l|
-            handle_output_location(type, l, message)
-          end
-        end
-      end
-
-      def handle_output_location(type, loc, message)
-        type == :urls ? send_to_http_location(loc, message) : send_to_file_location(loc, message)
-      end
-
-      def send_to_file_location(file_name, message)
-        open(file_name, "a") { |f| f.puts message }
-      end
-
-      def send_to_http_location(http_url, message)
-        @http_output_locations[http_url].post(nil, message, headers) if @http_output_locations[http_url]
-      rescue
-        Chef::Log.trace("Data collector failed to send to URL location #{http_url}. Please check your configured data_collector.output_locations")
-      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
-
-        message = 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,
-                   deprecations: deprecations.to_a
-                  )
-        disable_reporter_on_error do
-          send_to_data_collector(message)
-        end
-        send_to_output_locations(message) if data_collector_output_locations
-      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_output_locations
-        Chef::Config[:data_collector][:output_locations]
-      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_h
-        )
-      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_error_description(discription_hash)
-        @error_descriptions = discription_hash
-      end
-
-      def add_deprecation(message, url, location)
-        @deprecations << { message: message, url: url, location: location }
-      end
-
-      def initialize_resource_report_if_needed(new_resource, action, current_resource = nil)
-        return unless current_resource_report.nil?
-        @current_resource_report = create_resource_report(new_resource, action, current_resource)
-      end
-
-      def create_resource_report(new_resource, action, current_resource = nil)
-        Chef::DataCollector::ResourceReport.new(
-          new_resource,
-          action,
-          current_resource
-        )
-      end
-
-      def clear_current_resource_report
-        @current_resource_report = nil
-      end
-
-      def detect_unprocessed_resources
-        # create a Hash (for performance reasons, rather than an Array) containing all
-        # resource+action combinations from the Resource Collection
-        #
-        # We use the object ID instead of the resource itself in the Hash key because
-        # we currently allow users to create a property called "hash" which creates
-        # a #hash instance method on the resource. Ruby expects that to be a Fixnum,
-        # so bad things happen when adding an object to an Array or a Hash if it's not.
-        collection_resources = {}
-        run_context.resource_collection.all_resources.each do |resource|
-          Array(resource.action).each do |action|
-            collection_resources[[resource.__id__, action]] = resource
-          end
-        end
-
-        # Delete from the Hash any resource+action combination we have
-        # already processed.
-        all_resource_reports.each do |report|
-          collection_resources.delete([report.resource.__id__, report.action])
-        end
-
-        # The items remaining in the Hash are unprocessed resource+actions,
-        # so we'll create new resource reports for them which default to
-        # a state of "unprocessed".
-        collection_resources.each do |key, resource|
-          # The Hash key is an array of the Resource's object ID and the action.
-          # We need to pluck out the action.
-          add_resource_report(create_resource_report(resource, key[1]))
-        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
-
-      def validate_and_return_uri(uri)
-        URI(uri)
-      rescue URI::InvalidURIError
-        nil
-      end
-
-      def validate_and_create_file(file)
-        send_to_file_location(file, "")
-        true
-      # Rescue exceptions raised by the file path being non-existent or not writeable and re-raise them to the user
-      # with clearer explanatory text.
-      rescue Errno::ENOENT
-        raise Chef::Exceptions::ConfigurationError,
-              "Chef::Config[:data_collector][:output_locations][:files] contains the location #{file}, which is a non existent file path."
-      rescue Errno::EACCES
-        raise Chef::Exceptions::ConfigurationError,
-              "Chef::Config[:data_collector][:output_locations][:files] contains the location #{file}, which cannnot be written to by Chef."
-      end
-
-      def validate_data_collector_server_url!
-        unless !data_collector_server_url && data_collector_output_locations
-          uri = validate_and_return_uri(data_collector_server_url)
-          unless uri
-            raise Chef::Exceptions::ConfigurationError, "Chef::Config[:data_collector][:server_url] (#{data_collector_server_url}) is not a valid URI."
-          end
-
-          if uri.host.nil?
-            raise Chef::Exceptions::ConfigurationError,
-              "Chef::Config[:data_collector][:server_url] (#{data_collector_server_url}) is a URI with no host. Please supply a valid URL."
-          end
-        end
-      end
-
-      def handle_type(type, loc)
-        type == :urls ? validate_and_return_uri(loc) : validate_and_create_file(loc)
-      end
-
-      def validate_data_collector_output_locations!
-        if data_collector_output_locations.empty?
-          raise Chef::Exceptions::ConfigurationError,
-                "Chef::Config[:data_collector][:output_locations] is empty. Please supply an hash of valid URLs and / or local file paths."
-        end
-
-        data_collector_output_locations.each do |type, locations|
-          locations.each do |l|
-            unless handle_type(type, l)
-              raise Chef::Exceptions::ConfigurationError,
-                      "Chef::Config[:data_collector][:output_locations] contains the location #{l} which is not valid."
-            end
-          end
-        end
-      end
-    end
-  end
-end
+#
+# Author:: Adam Leff (<adamleff@chef.io>)
+# Author:: Ryan Cragun (<ryan@chef.io>)
+#
+# Copyright:: Copyright 2012-2019, 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_relative "server_api"
+require_relative "http/simple_json"
+require_relative "event_dispatch/base"
+require "set"
+require_relative "data_collector/run_end_message"
+require_relative "data_collector/run_start_message"
+require_relative "data_collector/config_validation"
+require_relative "data_collector/error_handlers"
+require_relative "dist"
+
+class Chef
+  class DataCollector
+    # The DataCollector is mode-agnostic reporting tool which can be used with
+    # server-based and solo-based clients.  It can report to a file, to an
+    # authenticated Chef Automate reporting endpoint, or to a user-supplied
+    # webhook.  It sends two messages:  one at the start of the run and one
+    # at the end of the run.  Most early failures in the actual Chef::Client itself
+    # are reported, but parsing of the client.rb must have succeeded and some code
+    # in Chef::Application could throw so early as to prevent reporting.  If
+    # exceptions are thrown both run-start and run-end messages are still sent in
+    # pairs.
+    #
+    class Reporter < EventDispatch::Base
+      include Chef::DataCollector::ErrorHandlers
+
+      # @return [Chef::RunList::RunListExpansion] the expanded run list
+      attr_reader :expanded_run_list
+
+      # @return [Chef::RunStatus] the run status
+      attr_reader :run_status
+
+      # @return [Chef::Node] the chef node
+      attr_reader :node
+
+      # @return [Set<Hash>] the acculumated list of deprecation warnings
+      attr_reader :deprecations
+
+      # @return [Chef::ActionCollection] the action collection object
+      attr_reader :action_collection
+
+      # @return [Chef::EventDispatch::Dispatcher] the event dispatcher
+      attr_reader :events
+
+      # @param events [Chef::EventDispatch::Dispatcher] the event dispatcher
+      def initialize(events)
+        @events = events
+        @expanded_run_list       = {}
+        @deprecations            = Set.new
+      end
+
+      # Hook to grab the run_status.  We also make the decision to run or not run here (our
+      # config has been parsed so we should know if we need to run, we unregister if we do
+      # not want to run).
+      #
+      # (see EventDispatch::Base#run_start)
+      #
+      def run_start(chef_version, run_status)
+        events.unregister(self) unless should_be_enabled?
+        @run_status = run_status
+      end
+
+      # Hook to grab the node object after it has been successfully loaded
+      #
+      # (see EventDispatch::Base#node_load_success)
+      #
+      def node_load_success(node)
+        @node = node
+      end
+
+      # The expanded run list is stored for later use by the run_completed
+      # event and message.
+      #
+      # (see EventDispatch::Base#run_list_expanded)
+      #
+      def run_list_expanded(run_list_expansion)
+        @expanded_run_list = run_list_expansion
+      end
+
+      # Hook event to register with the action_collection if we are still enabled.
+      #
+      # This is also how we wire up to the action_collection since it passes itself as the argument.
+      #
+      # (see EventDispatch::Base#action_collection_registration)
+      #
+      def action_collection_registration(action_collection)
+        @action_collection = action_collection
+        action_collection.register(self)
+      end
+
+      # - Creates and writes our NodeUUID back to the node object
+      # - Sanity checks the data collector
+      # - Sends the run start message
+      # - If the run_start message fails, this may disable the rest of data collection or fail hard
+      #
+      # (see EventDispatch::Base#run_started)
+      #
+      def run_started(run_status)
+        Chef::DataCollector::ConfigValidation.validate_server_url!
+        Chef::DataCollector::ConfigValidation.validate_output_locations!
+
+        send_run_start
+      end
+
+      # Hook event to accumulating deprecation messages
+      #
+      # (see EventDispatch::Base#deprecation)
+      #
+      def deprecation(message, location = caller(2..2)[0])
+        @deprecations << { message: message.message, url: message.url, location: message.location }
+      end
+
+      # Hook to send the run completion message with a status of success
+      #
+      # (see EventDispatch::Base#run_completed)
+      #
+      def run_completed(node)
+        send_run_completion("success")
+      end
+
+      # Hook to send the run completion message with a status of failed
+      #
+      # (see EventDispatch::Base#run_failed)
+      #
+      def run_failed(exception)
+        send_run_completion("failure")
+      end
+
+      private
+
+      # Construct a http client for either the main data collector or for the http output_locations.
+      #
+      # Note that based on the token setting either the main data collector and all the http output_locations
+      # are going to all require chef-server authentication or not.  There is no facility to mix-and-match on
+      # a per-url basis.
+      #
+      # @param url [String] the string url to connect to
+      # @returns [Chef::HTTP] the appropriate Chef::HTTP subclass instance to use
+      #
+      def setup_http_client(url)
+        if Chef::Config[:data_collector][:token].nil?
+          Chef::ServerAPI.new(url, validate_utf8: false)
+        else
+          Chef::HTTP::SimpleJSON.new(url, validate_utf8: false)
+        end
+      end
+
+      # Handle POST'ing data to the data collector.  Note that this is a totally separate concern
+      # from the array of URI's in the extra configured output_locations.
+      #
+      # On failure this will unregister the data collector (if there are no other configured output_locations)
+      # and optionally will either silently continue or fail hard depending on configuration.
+      #
+      # @param message [Hash] message to send
+      #
+      def send_to_data_collector(message)
+        return unless Chef::Config[:data_collector][:server_url]
+        @http ||= setup_http_client(Chef::Config[:data_collector][:server_url])
+        @http.post(nil, message, headers)
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
+        Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError, Net::ProtocolError, OpenSSL::SSL::SSLError,
+        Errno::EHOSTDOWN => e
+        # Do not disable data collector reporter if additional output_locations have been specified
+        events.unregister(self) unless Chef::Config[:data_collector][:output_locations]
+
+        code = e&.response&.code&.to_s || "Exception Code Empty"
+
+        msg = "Error while reporting run start to Data Collector. URL: #{Chef::Config[:data_collector][:server_url]} Exception: #{code} -- #{e.message} "
+
+        if Chef::Config[:data_collector][:raise_on_failure]
+          Chef::Log.error(msg)
+          raise
+        else
+          # Make the message non-scary for folks who don't have automate:
+          msg << " (This is normal if you do not have Chef Automate)"
+          Chef::Log.info(msg)
+        end
+      end
+
+      # Process sending the configured message to all the extra output locations.
+      #
+      # @param message [Hash] message to send
+      #
+      def send_to_output_locations(message)
+        return unless Chef::Config[:data_collector][:output_locations]
+
+        Chef::Config[:data_collector][:output_locations].each do |type, locations|
+          locations.each do |location|
+            send_to_file_location(location, message) if type == :files
+            send_to_http_location(location, message) if type == :urls
+          end
+        end
+      end
+
+      # Sends a single message to a file, rendered as JSON.
+      #
+      # @param file_name [String] the file to write to
+      # @param message [Hash] the message to render as JSON
+      #
+      def send_to_file_location(file_name, message)
+        File.open(file_name, "a") do |fh|
+          fh.puts Chef::JSONCompat.to_json(message, validate_utf8: false)
+        end
+      end
+
+      # Sends a single message to a http uri, rendered as JSON.  Maintains a cache of Chef::HTTP
+      # objects to use on subsequent requests.
+      #
+      # @param http_url [String] the configured http uri string endpoint to send to
+      # @param message [Hash] the message to render as JSON
+      #
+      def send_to_http_location(http_url, message)
+        @http_output_locations_clients[http_url] ||= setup_http_client(http_url)
+        @http_output_locations_clients[http_url].post(nil, message, headers)
+      rescue
+        # FIXME: we do all kinds of complexity to deal with errors in send_to_data_collector and we just don't care here, which feels like
+        # like poor behavior on several different levels, at least its a warn now... (I don't quite understand why it was written this way)
+        Chef::Log.warn("Data collector failed to send to URL location #{http_url}. Please check your configured data_collector.output_locations")
+      end
+
+      # @return [Boolean] if we've sent a run_start message yet
+      def sent_run_start?
+        !!@sent_run_start
+      end
+
+      # Send the run start message to the configured server or output locations
+      #
+      def send_run_start
+        message = Chef::DataCollector::RunStartMessage.construct_message(self)
+        send_to_data_collector(message)
+        send_to_output_locations(message)
+        @sent_run_start = true
+      end
+
+      # Send the run completion message to the configured server or output locations
+      #
+      # @param status [String] Either "success" or "failed"
+      #
+      def send_run_completion(status)
+        # this is necessary to send a run_start message when we fail before the run_started chef event.
+        # we adhere to a contract that run_start + run_completion events happen in pairs.
+        send_run_start unless sent_run_start?
+
+        message = Chef::DataCollector::RunEndMessage.construct_message(self, status)
+        send_to_data_collector(message)
+        send_to_output_locations(message)
+      end
+
+      # @return [Hash] HTTP headers for the data collector endpoint
+      def headers
+        headers = { "Content-Type" => "application/json" }
+
+        unless Chef::Config[:data_collector][:token].nil?
+          headers["x-data-collector-token"] = Chef::Config[:data_collector][:token]
+          headers["x-data-collector-auth"]  = "version=1.0"
+        end
+
+        headers
+      end
+
+      # Main logic controlling the data collector being enabled or disabled:
+      #
+      # * disabled in why-run mode
+      # * disabled when `Chef::Config[:data_collector][:mode]` excludes the solo-vs-client mode
+      # * disabled if there is no server_url or no output_locations to log to
+      # * enabled if there is a configured output_location even without a token
+      # * disabled in solo mode if the user did not configure the auth token
+      #
+      # @return [Boolean] true if the data collector should be enabled
+      #
+      def should_be_enabled?
+        running_mode = ( Chef::Config[:solo_legacy_mode] || Chef::Config[:local_mode] ) ? :solo : :client
+        want_mode = Chef::Config[:data_collector][:mode]
+
+        case
+        when Chef::Config[:why_run]
+          Chef::Log.trace("data collector is disabled for why run mode")
+          return false
+        when (want_mode != :both) && running_mode != want_mode
+          Chef::Log.trace("data collector is configured to only run in #{Chef::Config[:data_collector][:mode]} modes, disabling it")
+          return false
+        when !(Chef::Config[:data_collector][:server_url] || Chef::Config[:data_collector][:output_locations])
+          Chef::Log.trace("Neither data collector URL or output locations have been configured, disabling data collector")
+          return false
+        when running_mode == :client && Chef::Config[:data_collector][:token]
+          Chef::Log.warn("Data collector token authentication is not recommended for client-server mode. " \
+                         "Please upgrade #{Chef::Dist::SERVER_PRODUCT} to 12.11 or later and remove the token from your config file " \
+                         "to use key based authentication instead")
+          return true
+        when Chef::Config[:data_collector][:output_locations] && Chef::Config[:data_collector][:output_locations][:files] && !Chef::Config[:data_collector][:output_locations][:files].empty?
+          # we can run fine to a file without a token, even in solo mode.
+          return true
+        when running_mode == :solo && !Chef::Config[:data_collector][:token]
+          # we are in solo mode and are not logging to a file, so must have a token
+          Chef::Log.trace("Data collector token must be configured to use Chef Automate data collector with #{Chef::Dist::PRODUCT} Solo")
+          return false
+        else
+          return true
+        end
+      end
+
+    end
+  end
+end