puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

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'
   #
@@ -132,10 +130,6 @@ class Puppet::Transaction::Report
   #
   attr_accessor :resources_failed_to_generate
 
-  # @return [Boolean] true if the transaction completed it's evaluate
-  #
-  attr_accessor :transaction_completed
-
   def self.from_data_hash(data)
     obj = self.allocate
     obj.initialize_from_hash(data)
@@ -177,8 +171,8 @@ class Puppet::Transaction::Report
   # @api private
   def compute_status(resource_metrics, change_metric)
     if resources_failed_to_generate ||
-       !transaction_completed ||
-       (resource_metrics["failed"] || 0) > 0
+       (resource_metrics["failed"] || 0) > 0 ||
+       (resource_metrics["failed_to_restart"] || 0) > 0
       'failed'
     elsif change_metric > 0
       'changed'
@@ -212,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
@@ -233,7 +227,6 @@ class Puppet::Transaction::Report
     @noop = Puppet[:noop]
     @noop_pending = false
     @corrective_change = false
-    @transaction_completed = false
   end
 
   # @api private
@@ -258,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
@@ -269,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
@@ -390,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