puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

data/lib/puppet/transaction/event.rb

@@ -1,7 +1,9 @@
-require 'puppet/transaction'
-require 'puppet/util/tagging'
-require 'puppet/util/logging'
-require 'puppet/network/format_support'
+# frozen_string_literal: true
+
+require_relative '../../puppet/transaction'
+require_relative '../../puppet/util/tagging'
+require_relative '../../puppet/util/logging'
+require_relative '../../puppet/network/format_support'
 
 # A simple struct for storing what happens on the system.
 class Puppet::Transaction::Event
@@ -14,10 +16,10 @@ class Puppet::Transaction::Event
   attr_accessor :time
   attr_reader :default_log_level
 
-  EVENT_STATUSES = %w{noop success failure audit}
+  EVENT_STATUSES = %w[noop success failure audit]
 
   def self.from_data_hash(data)
-    obj = self.allocate
+    obj = allocate
     obj.initialize_from_hash(data)
     obj
   end
@@ -67,9 +69,9 @@ class Puppet::Transaction::Event
 
   def initialize_from_hash(data)
     data = Puppet::Pops::Serialization::FromDataConverter.convert(data, {
-      :allow_unresolved => true,
-      :loader => Puppet::Pops::Loaders.static_loader
-    })
+                                                                    :allow_unresolved => true,
+                                                                    :loader => Puppet::Pops::Loaders.static_loader
+                                                                  })
     @audited = data['audited']
     @property = data['property']
     @previous_value = data['previous_value']
@@ -109,7 +111,8 @@ class Puppet::Transaction::Event
   end
 
   def resource=(res)
-    if res.respond_to?(:[]) and level = res[:loglevel]
+    level = res[:loglevel] if res.respond_to?(:[])
+    if level
       @default_log_level = level
     end
     @resource = res.to_s
@@ -121,6 +124,7 @@ class Puppet::Transaction::Event
 
   def status=(value)
     raise ArgumentError, _("Event status can only be %{statuses}") % { statuses: EVENT_STATUSES.join(', ') } unless EVENT_STATUSES.include?(value)
+
     @status = value
   end
 

data/lib/puppet/transaction/event_manager.rb

@@ -1,11 +1,12 @@
-require 'puppet/transaction'
+# frozen_string_literal: true
+
+require_relative '../../puppet/transaction'
 
 # This class stores, routes, and responds to events generated while evaluating
 # a transaction.
 #
 # @api private
 class Puppet::Transaction::EventManager
-
   # @!attribute [r] transaction
   #   @return [Puppet::Transaction] The transaction associated with this event manager.
   attr_reader :transaction
@@ -49,15 +50,14 @@ class Puppet::Transaction::EventManager
   # @param events [Array<Puppet::Transaction::Event>] All events generated by this resource
   # @return [void]
   def queue_events(resource, events)
-    #@events += events
+    # @events += events
 
     # Do some basic normalization so we're not doing so many
     # graph queries for large sets of events.
-    events.inject({}) do |collection, event|
+    events.each_with_object({}) do |event, collection|
       collection[event.name] ||= []
       collection[event.name] << event
-      collection
-    end.collect do |name, list|
+    end.collect do |_name, list|
       # It doesn't matter which event we use - they all have the same source
       # and name here.
       event = list[0]
@@ -68,17 +68,18 @@ class Puppet::Transaction::EventManager
       received = (event.name != :restarted)
       relationship_graph.matching_edges(event, resource).each do |edge|
         received ||= true unless edge.target.is_a?(Puppet::Type.type(:whit))
-        next unless method = edge.callback
+        method = edge.callback
+        next unless method
         next unless edge.target.respond_to?(method)
 
         queue_events_for_resource(resource, edge.target, method, list)
       end
       @events << event if received
 
-      queue_events_for_resource(resource, resource, :refresh, [event]) if resource.self_refresh? and ! resource.deleting?
+      queue_events_for_resource(resource, resource, :refresh, [event]) if resource.self_refresh? and !resource.deleting?
     end
 
-    dequeue_events_for_resource(resource, :refresh) if events.detect { |e| e.invalidate_refreshes }
+    dequeue_events_for_resource(resource, :refresh) if events.detect(&:invalidate_refreshes)
   end
 
   def dequeue_all_events_for_resource(target)
@@ -114,7 +115,9 @@ class Puppet::Transaction::EventManager
   end
 
   def queued_events(resource)
-    return unless callbacks = @event_queues[resource]
+    callbacks = @event_queues[resource]
+    return unless callbacks
+
     callbacks.each do |callback, events|
       yield callback, events unless events.empty?
     end
@@ -139,31 +142,27 @@ class Puppet::Transaction::EventManager
   #   associated with this callback and resource.
   # @return [true, false] Whether the callback was successfully run.
   def process_callback(resource, callback, events)
-    if !process_callback?(resource, events)
+    unless process_callback?(resource, events)
       process_noop_events(resource, callback, events)
       return false
     end
 
     resource.send(callback)
 
-    if not resource.is_a?(Puppet::Type.type(:whit))
+    unless resource.is_a?(Puppet::Type.type(:whit))
       message = n_("Triggered '%{callback}' from %{count} event", "Triggered '%{callback}' from %{count} events", events.length) % { count: events.length, callback: callback }
       resource.notice message
       add_callback_status_event(resource, callback, message, "success")
     end
 
-    return true
+    true
   rescue => detail
     resource_error_message = _("Failed to call %{callback}: %{detail}") % { callback: callback, detail: detail }
-    resource.err resource_error_message
-    if not resource.is_a?(Puppet::Type.type(:whit))
-      add_callback_status_event(resource, callback, resource_error_message, "failure")
-    end
-
+    resource.err(resource_error_message)
     transaction.resource_status(resource).failed_to_restart = true
     transaction.resource_status(resource).fail_with_event(resource_error_message)
     resource.log_exception(detail)
-    return false
+    false
   end
 
   def add_callback_status_event(resource, callback, message, status)

data/lib/puppet/transaction/persistence.rb

@@ -1,14 +1,35 @@
+# frozen_string_literal: true
+
 require 'yaml'
-require 'puppet/util/yaml'
+require_relative '../../puppet/util/yaml'
 
 # A persistence store implementation for storing information between
 # transaction runs for the purposes of information inference (such
 # as calculating corrective_change).
 # @api private
 class Puppet::Transaction::Persistence
+  def self.allowed_classes
+    @allowed_classes ||= [
+      Symbol,
+      Time,
+      Regexp,
+      # URI is excluded, because it serializes all instance variables including the
+      # URI parser. Better to serialize the URL encoded representation.
+      SemanticPuppet::Version,
+      # SemanticPuppet::VersionRange has many nested classes and is unlikely to be
+      # used directly, so ignore it
+      Puppet::Pops::Time::Timestamp,
+      Puppet::Pops::Time::TimeData,
+      Puppet::Pops::Time::Timespan,
+      Puppet::Pops::Types::PBinaryType::Binary
+      # Puppet::Pops::Types::PSensitiveType::Sensitive values are excluded from
+      # the persistence store, ignore it.
+    ].freeze
+  end
+
   def initialize
     @old_data = {}
-    @new_data = {"resources" => {}}
+    @new_data = { "resources" => {} }
   end
 
   # Obtain the full raw data from the persistence store.
@@ -43,7 +64,7 @@ class Puppet::Transaction::Persistence
   def copy_skipped(resource_name)
     @old_data["resources"] ||= {}
     old_value = @old_data["resources"][resource_name]
-    if !old_value.nil?
+    unless old_value.nil?
       @new_data["resources"][resource_name] = old_value
     end
   end
@@ -54,6 +75,7 @@ class Puppet::Transaction::Persistence
     unless Puppet::FileSystem.exist?(filename)
       return
     end
+
     unless File.file?(filename)
       Puppet.warning(_("Transaction store file %{filename} is not a file, ignoring") % { filename: filename })
       return
@@ -61,20 +83,18 @@ class Puppet::Transaction::Persistence
 
     result = nil
     Puppet::Util.benchmark(:debug, _("Loaded transaction store file in %{seconds} seconds")) do
+      result = Puppet::Util::Yaml.safe_load_file(filename, self.class.allowed_classes)
+    rescue Puppet::Util::Yaml::YamlLoadError => detail
+      Puppet.log_exception(detail, _("Transaction store file %{filename} is corrupt (%{detail}); replacing") % { filename: filename, detail: detail })
+
       begin
-        result = Puppet::Util::Yaml.safe_load_file(filename, [Symbol])
-      rescue Puppet::Util::Yaml::YamlLoadError => detail
-        Puppet.log_exception(detail, _("Transaction store file %{filename} is corrupt (%{detail}); replacing") % { filename: filename, detail: detail })
-
-        begin
-          File.rename(filename, filename + ".bad")
-        rescue => detail
-          Puppet.log_exception(detail, _("Unable to rename corrupt transaction store file: %{detail}") % { detail: detail })
-          raise Puppet::Error, _("Could not rename corrupt transaction store file %{filename}; remove manually") % { filename: filename }, detail.backtrace
-        end
-
-        result = {}
+        File.rename(filename, filename + ".bad")
+      rescue => detail
+        Puppet.log_exception(detail, _("Unable to rename corrupt transaction store file: %{detail}") % { detail: detail })
+        raise Puppet::Error, _("Could not rename corrupt transaction store file %{filename}; remove manually") % { filename: filename }, detail.backtrace
       end
+
+      result = {}
     end
 
     unless result.is_a?(Hash)

data/lib/puppet/transaction/report.rb

@@ -1,5 +1,7 @@
-require 'puppet'
-require 'puppet/indirector'
+# frozen_string_literal: true
+
+require_relative '../../puppet'
+require_relative '../../puppet/indirector'
 
 # This class is used to report what happens on a client.
 # There are two types of data in a report; _Logs_ and _Metrics_.
@@ -38,6 +40,7 @@ class Puppet::Transaction::Report
   include Puppet::Util::PsychSupport
   extend Puppet::Indirector
 
+  STATES_FOR_EXCLUSION_FROM_REPORT = [:failed, :failed_to_restart, :out_of_sync, :skipped].freeze
   indirects :report, :terminus_class => :processor
 
   # The version of the configuration
@@ -63,9 +66,9 @@ class Puppet::Transaction::Report
   # or 'on_failure'
   attr_accessor :cached_catalog_status
 
-  # Contains the name and port of the master that was successfully contacted
+  # Contains the name and port of the server that was successfully contacted
   # @return [String] a string of the format 'servername:port'
-  attr_accessor :master_used
+  attr_accessor :server_used
 
   # The host name for which the report is generated
   # @return [String] the host name
@@ -75,6 +78,10 @@ class Puppet::Transaction::Report
   # @return [String] the environment name
   attr_accessor :environment
 
+  # The name of the environment the agent initially started in
+  # @return [String] the environment name
+  attr_accessor :initial_environment
+
   # Whether there are changes that we decided not to apply because of noop
   # @return [Boolean]
   #
@@ -122,7 +129,7 @@ class Puppet::Transaction::Report
 
   # @!attribute [r] corrective_change
   #   @return [Boolean] true if the report contains any events and resources that had
-  #      corrective changes.
+  #      corrective changes, including noop corrective changes.
   attr_reader :corrective_change
 
   # @return [Boolean] true if one or more resources attempted to generate
@@ -134,10 +141,10 @@ class Puppet::Transaction::Report
   #
   attr_accessor :transaction_completed
 
-  TOTAL = "total".freeze
+  TOTAL = "total"
 
   def self.from_data_hash(data)
-    obj = self.allocate
+    obj = allocate
     obj.initialize_from_hash(data)
     obj
   end
@@ -199,7 +206,7 @@ class Puppet::Transaction::Report
 
   # @api private
   def prune_internal_data
-    resource_statuses.delete_if {|name,res| res.resource_type == 'Whit'}
+    resource_statuses.delete_if { |_name, res| res.resource_type == 'Whit' }
   end
 
   # @api private
@@ -210,21 +217,21 @@ class Puppet::Transaction::Report
     resource_metrics = add_metric(:resources, calculate_resource_metrics)
     add_metric(:time, calculate_time_metrics)
     change_metric = calculate_change_metric
-    add_metric(:changes, {TOTAL => change_metric})
+    add_metric(:changes, { TOTAL => change_metric })
     add_metric(:events, calculate_event_metrics)
     @status = compute_status(resource_metrics, change_metric)
-    @noop_pending = @resource_statuses.any? { |name,res| has_noop_events?(res) }
+    @noop_pending = @resource_statuses.any? { |_name, res| has_noop_events?(res) }
   end
 
   # @api private
-  def initialize(configuration_version=nil, environment=nil, transaction_uuid=nil, job_id=nil)
+  def initialize(configuration_version = nil, environment = nil, transaction_uuid = nil, job_id = nil, start_time = Time.now)
     @metrics = {}
     @logs = []
     @resource_statuses = {}
     @external_times ||= {}
     @host = Puppet[:node_name_value]
-    @time = Time.now
-    @report_format = 10
+    @time = start_time
+    @report_format = 12
     @puppet_version = Puppet.version
     @configuration_version = configuration_version
     @transaction_uuid = transaction_uuid
@@ -232,7 +239,7 @@ class Puppet::Transaction::Report
     @job_id = job_id
     @catalog_uuid = nil
     @cached_catalog_status = nil
-    @master_used = nil
+    @server_used = nil
     @environment = environment
     @status = 'failed' # assume failed until the report is finalized
     @noop = Puppet[:noop]
@@ -256,24 +263,26 @@ class Puppet::Transaction::Report
     @time = data['time']
     @corrective_change = data['corrective_change']
 
-    if master_used = data['master_used']
-      @master_used = master_used
+    if data['server_used']
+      @server_used = data['server_used']
+    elsif data['master_used']
+      @server_used = data['master_used']
     end
 
-    if catalog_uuid = data['catalog_uuid']
-      @catalog_uuid = catalog_uuid
+    if data['catalog_uuid']
+      @catalog_uuid = data['catalog_uuid']
     end
 
-    if job_id = data['job_id']
-      @job_id = job_id
+    if data['job_id']
+      @job_id = data['job_id']
     end
 
-    if code_id = data['code_id']
-      @code_id = code_id
+    if data['code_id']
+      @code_id = data['code_id']
     end
 
-    if cached_catalog_status = data['cached_catalog_status']
-      @cached_catalog_status = cached_catalog_status
+    if data['cached_catalog_status']
+      @cached_catalog_status = data['cached_catalog_status']
     end
 
     if @time.is_a? String
@@ -293,15 +302,35 @@ class Puppet::Transaction::Report
 
     @resource_statuses = {}
     data['resource_statuses'].map do |key, rs|
-      @resource_statuses[key] = if rs == Puppet::Resource::EMPTY_HASH
-        nil
-      else
-        # Older versions contain tags that causes Psych to create instances directly
-        rs.is_a?(Puppet::Resource::Status) ? rs : Puppet::Resource::Status.from_data_hash(rs)
-      end
+      @resource_statuses[key] =
+        if rs == Puppet::Resource::EMPTY_HASH
+          nil
+        elsif rs.is_a?(Puppet::Resource::Status)
+          # Older versions contain tags that causes Psych to create instances
+          # directly
+          rs
+        else
+          Puppet::Resource::Status.from_data_hash(rs)
+        end
     end
   end
 
+  def resource_unchanged?(rs)
+    STATES_FOR_EXCLUSION_FROM_REPORT.each do |state|
+      return false if rs.send(state)
+    end
+    true
+  end
+
+  def calculate_resource_statuses
+    resource_statuses = if Puppet[:exclude_unchanged_resources]
+                          @resource_statuses.reject { |_key, rs| resource_unchanged?(rs) }
+                        else
+                          @resource_statuses
+                        end
+    resource_statuses.transform_values { |rs| rs.nil? ? nil : rs.to_data_hash }
+  end
+
   def to_data_hash
     hash = {
       'host' => @host,
@@ -315,14 +344,14 @@ class Puppet::Transaction::Report
       'noop' => @noop,
       'noop_pending' => @noop_pending,
       'environment' => @environment,
-      'logs' => @logs.map { |log| log.to_data_hash },
-      'metrics' => Hash[@metrics.map { |key, metric| [key, metric.to_data_hash] }],
-      'resource_statuses' => Hash[@resource_statuses.map { |key, rs| [key, rs.nil? ? nil : rs.to_data_hash] }],
+      'logs' => @logs.map(&:to_data_hash),
+      'metrics' => @metrics.transform_values(&:to_data_hash),
+      'resource_statuses' => calculate_resource_statuses,
       'corrective_change' => @corrective_change,
     }
 
     # The following is include only when set
-    hash['master_used'] = @master_used unless @master_used.nil?
+    hash['server_used'] = @server_used unless @server_used.nil?
     hash['catalog_uuid'] = @catalog_uuid unless @catalog_uuid.nil?
     hash['code_id'] = @code_id unless @code_id.nil?
     hash['job_id'] = @job_id unless @job_id.nil?
@@ -345,11 +374,11 @@ class Puppet::Transaction::Report
   def summary
     report = raw_summary
 
-    ret = ""
-    report.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key|
+    ret = ''.dup
+    report.keys.sort_by(&:to_s).each do |key|
       ret += "#{Puppet::Util::Metric.labelize(key)}:\n"
 
-      report[key].keys.sort { |a,b|
+      report[key].keys.sort { |a, b|
         # sort by label
         if a == TOTAL
           1
@@ -361,6 +390,7 @@ class Puppet::Transaction::Report
       }.each do |label|
         value = report[key][label]
         next if value == 0
+
         value = "%0.2f" % value if value.is_a?(Float)
         ret += "   %15s %s\n" % [Puppet::Util::Metric.labelize(label) + ":", value]
       end
@@ -373,12 +403,22 @@ class Puppet::Transaction::Report
   # @api public
   #
   def raw_summary
-    report = { "version" => { "config" => configuration_version, "puppet" => Puppet.version  } }
+    report = {
+      "version" => {
+        "config" => configuration_version,
+        "puppet" => Puppet.version
+      },
+      "application" => {
+        "run_mode" => Puppet.run_mode.name.to_s,
+        "initial_environment" => initial_environment,
+        "converged_environment" => environment
+      }
+    }
 
-    @metrics.each do |name, metric|
+    @metrics.each do |_name, metric|
       key = metric.name.to_s
       report[key] = {}
-      metric.values.each do |metric_name, label, value|
+      metric.values.each do |metric_name, _label, value|
         report[key][metric_name.to_s] = value
       end
       report[key][TOTAL] = 0 unless key == "time" or report[key].include?(TOTAL)
@@ -400,8 +440,8 @@ class Puppet::Transaction::Report
   def exit_status
     status = 0
     if @metrics["changes"] && @metrics["changes"][TOTAL] &&
-        @metrics["resources"] && @metrics["resources"]["failed"] &&
-        @metrics["resources"]["failed_to_restart"]
+       @metrics["resources"] && @metrics["resources"]["failed"] &&
+       @metrics["resources"]["failed_to_restart"]
       status |= 2 if @metrics["changes"][TOTAL] > 0
       status |= 4 if @metrics["resources"]["failed"] > 0
       status |= 4 if @metrics["resources"]["failed_to_restart"] > 0
@@ -415,19 +455,19 @@ class Puppet::Transaction::Report
 
   # Mark the report as corrective, if there are any resource_status marked corrective.
   def calculate_report_corrective_change
-    @corrective_change = resource_statuses.any? do |name, status|
+    @corrective_change = resource_statuses.any? do |_name, status|
       status.corrective_change
     end
   end
 
   def calculate_change_metric
-    resource_statuses.map { |name, status| status.change_count || 0 }.inject(0) { |a,b| a+b }
+    resource_statuses.map { |_name, status| status.change_count || 0 }.inject(0) { |a, b| a + b }
   end
 
   def calculate_event_metrics
     metrics = Hash.new(0)
-    %w{total failure success}.each { |m| metrics[m] = 0 }
-    resource_statuses.each do |name, status|
+    %w[total failure success].each { |m| metrics[m] = 0 }
+    resource_statuses.each do |_name, status|
       metrics[TOTAL] += status.events.length
       status.events.each do |event|
         metrics[event.status] += 1
@@ -447,7 +487,7 @@ class Puppet::Transaction::Report
       metrics[state.to_s] = 0
     end
 
-    resource_statuses.each do |name, status|
+    resource_statuses.each do |_name, status|
       Puppet::Resource::Status::STATES.each do |state|
         metrics[state.to_s] += 1 if status.send(state)
       end
@@ -458,7 +498,7 @@ class Puppet::Transaction::Report
 
   def calculate_time_metrics
     metrics = Hash.new(0)
-    resource_statuses.each do |name, status|
+    resource_statuses.each do |_name, status|
       metrics[status.resource_type.downcase] += status.evaluation_time if status.evaluation_time
     end
 

data/lib/puppet/transaction/resource_harness.rb

@@ -1,4 +1,6 @@
-require 'puppet/resource/status'
+# frozen_string_literal: true
+
+require_relative '../../puppet/resource/status'
 
 class Puppet::Transaction::ResourceHarness
   NO_ACTION = Object.new
@@ -20,7 +22,7 @@ class Puppet::Transaction::ResourceHarness
       context = ResourceApplicationContext.from_resource(resource, status)
       perform_changes(resource, context)
 
-      if status.changed? && ! resource.noop?
+      if status.changed? && !resource.noop?
         cache(resource, :synced, Time.now)
         resource.flush if resource.respond_to?(:flush)
       end
@@ -35,7 +37,9 @@ class Puppet::Transaction::ResourceHarness
 
   def scheduled?(resource)
     return true if Puppet[:ignoreschedules]
-    return true unless schedule = schedule(resource)
+
+    schedule = schedule(resource)
+    return true unless schedule
 
     # We use 'checked' here instead of 'synced' because otherwise we'll
     # end up checking most resources most times, because they will generally
@@ -51,7 +55,9 @@ class Puppet::Transaction::ResourceHarness
       return nil
     end
 
-    return nil unless name = resource[:schedule]
+    name = resource[:schedule]
+    return nil unless name
+
     resource.catalog.resource(:schedule, name) || resource.fail(_("Could not find schedule %{name}") % { name: name })
   end
 
@@ -99,7 +105,7 @@ class Puppet::Transaction::ResourceHarness
   # We persist the last known values for the properties of a resource after resource
   # application.
   # @param [Puppet::Type] resource resource whose values we are to persist.
-  # @param [ResourceApplicationContent] context the application context to operate on.
+  # @param [ResourceApplicationContext] context the application context to operate on.
   def persist_system_values(resource, context)
     param_to_event = {}
     context.status.events.each do |ev|
@@ -161,6 +167,7 @@ class Puppet::Transaction::ResourceHarness
         name = param.name.to_s
         event.message ||= _("could not create change error message for %{name}") % { name: name }
         event.calculate_corrective_change(@persistence.get_system_value(context.resource.ref, name))
+        event.message << ' (corrective)' if event.corrective_change
         context.record(event)
         event.send_log
         context.synced_params << param.name
@@ -210,10 +217,10 @@ class Puppet::Transaction::ResourceHarness
 
     # The event we've been provided might have been redacted so we need to use the state stored within
     # the resource application context to see if an event was actually generated.
-    if !are_audited_values_equal(context.historical_values[property.name], context.current_values[property.name])
+    unless are_audited_values_equal(context.historical_values[property.name], context.current_values[property.name])
       event.message = property.format(_("audit change: previously recorded value %s has been changed to %s"),
-                 property.is_to_s(event.historical_value),
-                 property.is_to_s(event.previous_value))
+                                      property.is_to_s(event.historical_value),
+                                      property.is_to_s(event.previous_value))
     end
 
     event
@@ -303,10 +310,10 @@ class Puppet::Transaction::ResourceHarness
       ResourceApplicationContext.new(resource,
                                      resource.retrieve_resource.to_hash,
                                      Puppet::Util::Storage.cache(resource).dup,
-                                     (resource[:audit] || []).map { |p| p.to_sym },
+                                     (resource[:audit] || []).map(&:to_sym),
                                      [],
                                      status,
-                                     resource.parameters.select { |n,p| p.is_a?(Puppet::Property) && !p.sensitive })
+                                     resource.parameters.select { |_n, p| p.is_a?(Puppet::Property) && !p.sensitive })
     end
 
     def resource_present?