puppet 4.10.0 → 5.0.0

data/lib/puppet/ssl/validator/default_validator.rb

@@ -69,12 +69,12 @@ class Puppet::SSL::Validator::DefaultValidator #< class Puppet::SSL::Validator
   # @api private
   #
   def call(preverify_ok, store_context)
+    current_cert = store_context.current_cert
+    @peer_certs << Puppet::SSL::Certificate.from_instance(current_cert)
+
     # We must make a copy since the scope of the store_context will be lost
     # across invocations of this method.
     if preverify_ok
-      current_cert = store_context.current_cert
-      @peer_certs << Puppet::SSL::Certificate.from_instance(current_cert)
-
       # If we've copied all of the certs in the chain out of the SSL library
       if @peer_certs.length == store_context.chain.length
         # (#20027) The peer cert must be issued by a specific authority
@@ -100,7 +100,6 @@ class Puppet::SSL::Validator::DefaultValidator #< class Puppet::SSL::Validator
           @verify_errors << error_string
         end
       else
-        current_cert = store_context.current_cert
         @verify_errors << "#{error_string} for #{current_cert.subject}"
       end
     end

data/lib/puppet/syntax_checkers/base64.rb

@@ -15,9 +15,9 @@ class Puppet::SyntaxCheckers::Base64 < Puppet::Plugins::SyntaxCheckers::SyntaxCh
   # @api public
   #
   def check(text, syntax, acceptor, source_pos)
-    raise ArgumentError.new("Base64 syntax checker: the text to check must be a String.") unless text.is_a?(String)
-    raise ArgumentError.new("Base64 syntax checker: the syntax identifier must be a String, e.g. json, data+json") unless syntax.is_a?(String)
-    raise ArgumentError.new("Base64 syntax checker: invalid Acceptor, got: '#{acceptor.class.name}'.") unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
+    raise ArgumentError.new(_("Base64 syntax checker: the text to check must be a String.")) unless text.is_a?(String)
+    raise ArgumentError.new(_("Base64 syntax checker: the syntax identifier must be a String, e.g. json, data+json")) unless syntax.is_a?(String)
+    raise ArgumentError.new(_("Base64 syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name }) unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
     cleaned_text = text.gsub(/[\r?\n[:blank:]]/, '')
     begin
       # Do a strict decode64 on text with all whitespace stripped since the non strict version
@@ -25,17 +25,17 @@ class Puppet::SyntaxCheckers::Base64 < Puppet::Plugins::SyntaxCheckers::SyntaxCh
       Base64.strict_decode64(cleaned_text)
     rescue => e
       if (cleaned_text.bytes.to_a.size * 8) % 6 != 0
-        msg2 = "padding is not correct"
+        msg2 = _("padding is not correct")
       else
-        msg2 = "contains letters outside strict base 64 range (or whitespace)"
+        msg2 = _("contains letters outside strict base 64 range (or whitespace)")
       end
-      msg = "Base64 syntax checker: Cannot parse invalid Base64 string - #{msg2}"
+      msg = _("Base64 syntax checker: Cannot parse invalid Base64 string - %{msg2}") % { msg2: msg2 }
 
       # TODO: improve the pops API to allow simpler diagnostic creation while still maintaining capabilities
       # and the issue code. (In this case especially, where there is only a single error message being issued).
       #
       issue = Puppet::Pops::Issues::issue(:ILLEGAL_BASE64) { msg }
-      acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, source_pos.locator.file, source_pos, {}))
+      acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, source_pos.file, source_pos, {}))
     end
   end
 end

data/lib/puppet/syntax_checkers/json.rb

@@ -14,22 +14,22 @@ class Puppet::SyntaxCheckers::Json < Puppet::Plugins::SyntaxCheckers::SyntaxChec
   # @api public
   #
   def check(text, syntax, acceptor, source_pos)
-    raise ArgumentError.new("Json syntax checker: the text to check must be a String.") unless text.is_a?(String)
-    raise ArgumentError.new("Json syntax checker: the syntax identifier must be a String, e.g. json, data+json") unless syntax.is_a?(String)
-    raise ArgumentError.new("Json syntax checker: invalid Acceptor, got: '#{acceptor.class.name}'.") unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
+    raise ArgumentError.new(_("Json syntax checker: the text to check must be a String.")) unless text.is_a?(String)
+    raise ArgumentError.new(_("Json syntax checker: the syntax identifier must be a String, e.g. json, data+json")) unless syntax.is_a?(String)
+    raise ArgumentError.new(_("Json syntax checker: invalid Acceptor, got: '%{klass}'.") % { klass: acceptor.class.name }) unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
     #raise ArgumentError.new("Json syntax checker: location_info must be a Hash") unless location_info.is_a?(Hash)
 
     begin
       JSON.parse(text)
     rescue => e
       # Cap the message to 100 chars and replace newlines
-      msg = "JSON syntax checker: Cannot parse invalid JSON string. \"#{e.message().slice(0,100).gsub(/\r?\n/, "\\n")}\""
+      msg = _("JSON syntax checker: Cannot parse invalid JSON string. \"%{message}\"") % { message: e.message().slice(0,100).gsub(/\r?\n/, "\\n") }
 
       # TODO: improve the pops API to allow simpler diagnostic creation while still maintaining capabilities
       # and the issue code. (In this case especially, where there is only a single error message being issued).
       #
       issue = Puppet::Pops::Issues::issue(:ILLEGAL_JSON) { msg }
-      acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, source_pos.locator.file, source_pos, {}))
+      acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, source_pos.file, source_pos, {}))
     end
   end
 end

data/lib/puppet/test/test_helper.rb

@@ -1,5 +1,3 @@
-require 'puppet/indirector/data_binding/hiera'
-
 require 'tmpdir'
 require 'fileutils'
 
@@ -146,8 +144,6 @@ module Puppet::Test
       Puppet::Util::Profiler.clear
 
       Puppet.clear_deprecation_warnings
-
-      Puppet::DataBinding::Hiera.instance_variable_set("@hiera", nil)
     end
 
     # Call this method once per test, after execution of each individual test.

data/lib/puppet/transaction/additional_resource_generator.rb

@@ -22,7 +22,7 @@ class Puppet::Transaction::AdditionalResourceGenerator
       generated = resource.generate
     rescue => detail
       @resources_failed_to_generate = true
-      resource.log_exception(detail, "Failed to generate additional resources using 'generate': #{detail}")
+      resource.log_exception(detail, _("Failed to generate additional resources using 'generate': %{detail}") % { detail: detail })
     end
     return unless generated
     generated = [generated] unless generated.is_a?(Array)
@@ -51,13 +51,14 @@ class Puppet::Transaction::AdditionalResourceGenerator
 
   def eval_generate(resource)
     return false unless resource.respond_to?(:eval_generate)
-    raise Puppet::DevError,"Depthfirst resources are not supported by eval_generate" if resource.depthfirst?
+    raise Puppet::DevError, _("Depthfirst resources are not supported by eval_generate") if resource.depthfirst?
     begin
       generated = replace_duplicates_with_catalog_resources(resource.eval_generate)
       return false if generated.empty?
     rescue => detail
       @resources_failed_to_generate = true
-      resource.log_exception(detail, "Failed to generate additional resources using 'eval_generate': #{detail}")
+      #TRANSLATORS eval_generate is a method name and should be left untranslated
+      resource.log_exception(detail, _("Failed to generate additional resources using 'eval_generate': %{detail}") % { detail: detail })
       return false
     end
     add_resources(generated, resource)

data/lib/puppet/transaction/event.rb

@@ -12,7 +12,6 @@ class Puppet::Transaction::Event
   include Puppet::Network::FormatSupport
 
   ATTRIBUTES = [:name, :resource, :property, :previous_value, :desired_value, :historical_value, :status, :message, :file, :line, :source_description, :audited, :invalidate_refreshes, :redacted, :corrective_change]
-  YAML_ATTRIBUTES = %w{@audited @property @previous_value @desired_value @historical_value @message @name @status @time @redacted @corrective_change}.map(&:to_sym)
   attr_accessor *ATTRIBUTES
   attr_accessor :time
   attr_reader :default_log_level
@@ -34,7 +33,16 @@ class Puppet::Transaction::Event
     @time = Time.now
   end
 
+  def eql?(event)
+    self.class == event.class && ATTRIBUTES.all? { |attr| send(attr).eql?(event.send(attr)) }
+  end
+  alias == eql?
+
   def initialize_from_hash(data)
+    data = Puppet::Pops::Serialization::FromDataConverter.convert(data, {
+      :allow_unresolved => true,
+      :loader => Puppet::Pops::Loaders.static_loader
+    })
     @audited = data['audited']
     @property = data['property']
     @previous_value = data['previous_value']
@@ -50,19 +58,26 @@ class Puppet::Transaction::Event
   end
 
   def to_data_hash
-    {
+    hash = {
       'audited' => @audited,
       'property' => @property,
       'previous_value' => @previous_value,
       'desired_value' => @desired_value,
       'historical_value' => @historical_value,
       'message' => @message,
-      'name' => @name,
+      'name' => @name.nil? ? nil : @name.to_s,
       'status' => @status,
       'time' => @time.iso8601(9),
       'redacted' => @redacted,
       'corrective_change' => @corrective_change,
     }
+    Puppet::Pops::Serialization::ToDataConverter.convert(hash, {
+      :rich_data => true,
+      :symbol_as_string => true,
+      :local_reference => false,
+      :type_by_reference => true,
+      :message_prefix => 'Event'
+    })
   end
 
   def property=(prop)
@@ -82,7 +97,7 @@ class Puppet::Transaction::Event
   end
 
   def status=(value)
-    raise ArgumentError, "Event status can only be #{EVENT_STATUSES.join(', ')}" unless EVENT_STATUSES.include?(value)
+    raise ArgumentError, _("Event status can only be %{statuses}") % { statuses: EVENT_STATUSES.join(', ') } unless EVENT_STATUSES.include?(value)
     @status = value
   end
 
@@ -94,10 +109,6 @@ class Puppet::Transaction::Event
     %Q(#<#{self.class.name} @name="#{@name.inspect}" @message="#{@message.inspect}">)
   end
 
-  def to_yaml_properties
-    YAML_ATTRIBUTES & super
-  end
-
   # Calculate and set the corrective_change parameter, based on the old_system_value of the property.
   # @param [Object] old_system_value system_value from last transaction
   # @return [bool] true if this is a corrective_change

data/lib/puppet/transaction/event_manager.rb

@@ -84,13 +84,13 @@ class Puppet::Transaction::EventManager
   def dequeue_all_events_for_resource(target)
     callbacks = @event_queues[target]
     if callbacks && !callbacks.empty?
-      target.info "Unscheduling all events on #{target}"
+      target.info _("Unscheduling all events on %{target}") % { target: target }
       @event_queues[target] = {}
     end
   end
 
   def dequeue_events_for_resource(target, callback)
-    target.info "Unscheduling #{callback} on #{target}"
+    target.info _("Unscheduling %{callback} on %{target}") % { callback: callback, target: target }
     @event_queues[target][callback] = [] if @event_queues[target]
   end
 
@@ -105,7 +105,7 @@ class Puppet::Transaction::EventManager
     if refreshing_c_whit
       source.debug "The container #{target} will propagate my #{callback} event"
     else
-      source.info "Scheduling #{callback} of #{target}"
+      source.info _("Scheduling %{callback} of %{target}") % { callback: callback, target: target }
     end
 
     @event_queues[target] ||= {}
@@ -147,11 +147,11 @@ class Puppet::Transaction::EventManager
     resource.send(callback)
 
     if not resource.is_a?(Puppet::Type.type(:whit))
-      resource.notice "Triggered '#{callback}' from #{events.length} events"
+      resource.notice n_("Triggered '%{callback}' from %{count} event", "Triggered '%{callback}' from %{count} events", events.length) % { count: events.length, callback: callback }
     end
     return true
   rescue => detail
-    resource.err "Failed to call #{callback}: #{detail}"
+    resource.err _("Failed to call %{callback}: %{detail}") % { callback: callback, detail: detail }
 
     transaction.resource_status(resource).failed_to_restart = true
     resource.log_exception(detail)
@@ -159,7 +159,7 @@ class Puppet::Transaction::EventManager
   end
 
   def process_noop_events(resource, callback, events)
-    resource.notice "Would have triggered '#{callback}' from #{events.length} events"
+    resource.notice n_("Would have triggered '%{callback}' from %{count} event", "Would have triggered '%{callback}' from %{count} events", events.length) % { count: events.length, callback: callback }
 
     # And then add an event for it.
     queue_events(resource, [resource.event(:status => "noop", :name => :noop_restart)])

data/lib/puppet/transaction/persistence.rb

@@ -47,22 +47,22 @@ class Puppet::Transaction::Persistence
       return
     end
     unless File.file?(filename)
-      Puppet.warning("Transaction store file #{filename} is not a file, ignoring")
+      Puppet.warning(_("Transaction store file %{filename} is not a file, ignoring") % { filename: filename })
       return
     end
 
     result = nil
-    Puppet::Util.benchmark(:debug, "Loaded transaction store file") do
+    Puppet::Util.benchmark(:debug, _("Loaded transaction store file")) do
       begin
         result = Puppet::Util::Yaml.load_file(filename, false, true)
       rescue Puppet::Util::Yaml::YamlLoadError => detail
-        Puppet.log_exception(detail, "Transaction store file #{filename} is corrupt (#{detail}); replacing", { :level => :warning })
+        Puppet.log_exception(detail, _("Transaction store file %{filename} is corrupt (%{detail}); replacing") % { filename: filename, detail: detail }, { :level => :warning })
 
         begin
           File.rename(filename, filename + ".bad")
         rescue => detail
-          Puppet.log_exception(detail, "Unable to rename corrupt transaction store file: #{detail}")
-          raise Puppet::Error, "Could not rename corrupt transaction store file #{filename}; remove manually", detail.backtrace
+          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 = {}
@@ -70,7 +70,7 @@ class Puppet::Transaction::Persistence
     end
 
     unless result.is_a?(Hash)
-      Puppet.err "Transaction store file #{filename} is valid YAML but not returning a hash. Check the file for corruption, or remove it before continuing."
+      Puppet.err _("Transaction store file %{filename} is valid YAML but not returning a hash. Check the file for corruption, or remove it before continuing.") % { filename: filename }
       return
     end
 

data/lib/puppet/transaction/report.rb

@@ -35,6 +35,7 @@ require 'puppet/indirector'
 #
 # @api public
 class Puppet::Transaction::Report
+  include Puppet::Util::PsychSupport
   extend Puppet::Indirector
 
   indirects :report, :terminus_class => :processor
@@ -51,6 +52,9 @@ class Puppet::Transaction::Report
   # The id of the code input to the compiler.
   attr_accessor :code_id
 
+  # The id of the job responsible for this run.
+  attr_accessor :job_id
+
   # A master generated catalog uuid, useful for connecting a single catalog to multiple reports.
   attr_accessor :catalog_uuid
 
@@ -95,12 +99,6 @@ class Puppet::Transaction::Report
   #
   attr_reader :time
 
-  # The 'kind' of report is the name of operation that triggered the report to be produced.
-  # Typically "apply".
-  # @return [String] the kind of operation that triggered the generation of the report.
-  #
-  attr_reader :kind
-
   # The status of the client run is an enumeration: 'failed', 'changed' or 'unchanged'
   # @return [String] the status of the run - one of the values 'failed', 'changed', or 'unchanged'
   #
@@ -172,7 +170,9 @@ class Puppet::Transaction::Report
 
   # @api private
   def compute_status(resource_metrics, change_metric)
-    if resources_failed_to_generate || (resource_metrics["failed"] || 0) > 0
+    if resources_failed_to_generate ||
+       (resource_metrics["failed"] || 0) > 0 ||
+       (resource_metrics["failed_to_restart"] || 0) > 0
       'failed'
     elsif change_metric > 0
       'changed'
@@ -206,19 +206,19 @@ class Puppet::Transaction::Report
   end
 
   # @api private
-  def initialize(kind, configuration_version=nil, environment=nil, transaction_uuid=nil)
+  def initialize(configuration_version=nil, environment=nil, transaction_uuid=nil, job_id=nil)
     @metrics = {}
     @logs = []
     @resource_statuses = {}
     @external_times ||= {}
     @host = Puppet[:node_name_value]
     @time = Time.now
-    @kind = kind
-    @report_format = 6
+    @report_format = 7
     @puppet_version = Puppet.version
     @configuration_version = configuration_version
     @transaction_uuid = transaction_uuid
     @code_id = nil
+    @job_id = job_id
     @catalog_uuid = nil
     @cached_catalog_status = nil
     @master_used = nil
@@ -251,6 +251,10 @@ class Puppet::Transaction::Report
       @catalog_uuid = catalog_uuid
     end
 
+    if job_id = data['job_id']
+      @job_id = job_id
+    end
+
     if code_id = data['code_id']
       @code_id = code_id
     end
@@ -262,50 +266,54 @@ class Puppet::Transaction::Report
     if @time.is_a? String
       @time = Time.parse(@time)
     end
-    @kind = data['kind']
 
     @metrics = {}
     data['metrics'].each do |name, hash|
-      @metrics[name] = Puppet::Util::Metric.from_data_hash(hash)
+      # Older versions contain tags that causes Psych to create instances directly
+      @metrics[name] = hash.is_a?(Puppet::Util::Metric) ? hash : Puppet::Util::Metric.from_data_hash(hash)
     end
 
     @logs = data['logs'].map do |record|
-      Puppet::Util::Log.from_data_hash(record)
+      # Older versions contain tags that causes Psych to create instances directly
+      record.is_a?(Puppet::Util::Log) ? record : Puppet::Util::Log.from_data_hash(record)
     end
 
     @resource_statuses = {}
-    data['resource_statuses'].map do |record|
-      if record[1] == {}
-        status = nil
+    data['resource_statuses'].map do |key, rs|
+      @resource_statuses[key] = if rs == Puppet::Resource::EMPTY_HASH
+        nil
       else
-        status = Puppet::Resource::Status.from_data_hash(record[1])
+        # 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[record[0]] = status
     end
   end
 
   def to_data_hash
-    {
+    hash = {
       'host' => @host,
       'time' => @time.iso8601(9),
       'configuration_version' => @configuration_version,
       'transaction_uuid' => @transaction_uuid,
-      'catalog_uuid' => @catalog_uuid,
-      'code_id' => @code_id,
-      'cached_catalog_status' => @cached_catalog_status,
       'report_format' => @report_format,
       'puppet_version' => @puppet_version,
-      'kind' => @kind,
       'status' => @status,
       'noop' => @noop,
       'noop_pending' => @noop_pending,
       'environment' => @environment,
-      'master_used' => @master_used,
-      'logs' => @logs,
-      'metrics' => @metrics,
-      'resource_statuses' => @resource_statuses,
+      '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] }],
       'corrective_change' => @corrective_change,
     }
+
+    # The following is include only when set
+    hash['master_used'] = @master_used unless @master_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?
+    hash['cached_catalog_status'] = @cached_catalog_status unless @cached_catalog_status.nil?
+    hash
   end
 
   # @return [String] the host name
@@ -383,20 +391,6 @@ class Puppet::Transaction::Report
     status
   end
 
-  # @api private
-  #
-  def to_yaml_properties
-    super - [:@external_times, :@resources_failed_to_generate]
-  end
-
-  def self.supported_formats
-    [:pson, :yaml]
-  end
-
-  def self.default_format
-    :pson
-  end
-
   private
 
   # Mark the report as corrective, if there are any resource_status marked corrective.

data/lib/puppet/transaction/resource_harness.rb

@@ -47,12 +47,12 @@ class Puppet::Transaction::ResourceHarness
 
   def schedule(resource)
     unless resource.catalog
-      resource.warning "Cannot schedule without a schedule-containing catalog"
+      resource.warning _("Cannot schedule without a schedule-containing catalog")
       return nil
     end
 
     return nil unless name = resource[:schedule]
-    resource.catalog.resource(:schedule, name) || resource.fail("Could not find schedule #{name}")
+    resource.catalog.resource(:schedule, name) || resource.fail(_("Could not find schedule %{name}") % { name: name })
   end
 
   # Used mostly for scheduling and auditing at this point.
@@ -144,17 +144,17 @@ class Puppet::Transaction::ResourceHarness
 
       event = create_change_event(param, current_value, historical_value)
       event.status = "failure"
-      event.message = param.format("change from %s to %s failed: #{detail}",
+      event.message = param.format(_("change from %s to %s failed: "),
                                    param.is_to_s(current_value),
-                                   param.should_to_s(param.should))
+                                   param.should_to_s(param.should)) + detail.to_s
       event
     rescue Exception => detail
       # Execution will halt on Exceptions, they get raised to the application
       event = create_change_event(param, current_value, historical_value)
       event.status = "failure"
-      event.message = param.format("change from %s to %s failed: #{detail}",
+      event.message = param.format(_("change from %s to %s failed: "),
                                    param.is_to_s(current_value),
-                                   param.should_to_s(param.should))
+                                   param.should_to_s(param.should)) + detail.to_s
       raise
     ensure
       if event
@@ -209,7 +209,7 @@ 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])
-      event.message = property.format("audit change: previously recorded value %s has been changed to %s",
+      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))
     end
@@ -219,23 +219,25 @@ class Puppet::Transaction::ResourceHarness
 
   def audit_message(param, do_audit, historical_value, current_value)
     if do_audit && historical_value && !are_audited_values_equal(historical_value, current_value)
-      param.format(" (previously recorded value was %s)", param.is_to_s(historical_value))
+      param.format(_(" (previously recorded value was %s)"), param.is_to_s(historical_value))
     else
       ""
     end
   end
 
   def noop(event, param, current_value, audit_message)
-    event.message = param.format("current_value %s, should be %s (noop)#{audit_message}",
+    event.message = param.format(_("current_value %s, should be %s (noop)"),
                                  param.is_to_s(current_value),
-                                 param.should_to_s(param.should))
+                                 param.should_to_s(param.should)) + audit_message.to_s
     event.status = "noop"
   end
 
   def sync(event, param, current_value, audit_message)
     param.sync
     if param.sensitive
-      event.message = param.format("changed %s to %s#{audit_message}", param.is_to_s(current_value), param.should_to_s(param.should))
+      event.message = param.format(_("changed %s to %s"),
+                                   param.is_to_s(current_value),
+                                   param.should_to_s(param.should)) + audit_message.to_s
     else
       event.message = "#{param.change_to_s(current_value, param.should)}#{audit_message}"
     end
@@ -256,7 +258,7 @@ class Puppet::Transaction::ResourceHarness
         end
       else
         property = resource.property(param_name)
-        property.notice(property.format("audit change: newly-recorded value %s", context.current_values[param_name]))
+        property.notice(property.format(_("audit change: newly-recorded value %s"), context.current_values[param_name]))
       end
     end
   end