openvox 7.37.1

data/lib/puppet/transaction/event.rb

@@ -0,0 +1,168 @@
+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
+  include Puppet::Util::Tagging
+  include Puppet::Util::Logging
+  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]
+  attr_accessor(*ATTRIBUTES)
+  attr_accessor :time
+  attr_reader :default_log_level
+
+  EVENT_STATUSES = %w{noop success failure audit}
+
+  def self.from_data_hash(data)
+    obj = self.allocate
+    obj.initialize_from_hash(data)
+    obj
+  end
+
+  def initialize(audited: false,
+                 corrective_change: false,
+                 desired_value: nil,
+                 file: nil,
+                 historical_value: nil,
+                 invalidate_refreshes: nil,
+                 line: nil,
+                 message: nil,
+                 name: nil,
+                 previous_value: nil,
+                 property: nil,
+                 redacted: false,
+                 resource: nil,
+                 source_description: nil,
+                 status: nil,
+                 tags: nil)
+
+    @audited = audited
+    @corrective_change = corrective_change
+    @desired_value = desired_value
+    @file = file
+    @historical_value = historical_value
+    @invalidate_refreshes = invalidate_refreshes
+    @line = line
+    @message = message
+    @name = name
+    @previous_value = previous_value
+    @redacted = redacted
+    @source_description = source_description
+    @tags = tags
+
+    self.property = property if property
+    self.resource = resource if resource
+    self.status = status if status
+
+    @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']
+    @desired_value = data['desired_value']
+    @historical_value = data['historical_value']
+    @message = data['message']
+    @name = data['name'].intern if data['name']
+    @status = data['status']
+    @time = data['time']
+    @time = Time.parse(@time) if @time.is_a? String
+    @redacted = data.fetch('redacted', false)
+    @corrective_change = data['corrective_change']
+  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.nil? ? nil : @name.to_s,
+      'status' => @status,
+      'time' => @time.iso8601(9),
+      'redacted' => @redacted,
+      'corrective_change' => @corrective_change,
+    }
+    # Use the stringifying converter since rich data is not possible downstream.
+    # (This will destroy some data type information, but this is expected).
+    Puppet::Pops::Serialization::ToStringifiedConverter.convert(hash, :message_prefix => 'Event')
+  end
+
+  def property=(prop)
+    @property_instance = prop
+    @property = prop.to_s
+  end
+
+  def resource=(res)
+    level = res[:loglevel] if res.respond_to?(:[])
+    if level
+      @default_log_level = level
+    end
+    @resource = res.to_s
+  end
+
+  def send_log
+    super(log_level, message)
+  end
+
+  def status=(value)
+    raise ArgumentError, _("Event status can only be %{statuses}") % { statuses: EVENT_STATUSES.join(', ') } unless EVENT_STATUSES.include?(value)
+    @status = value
+  end
+
+  def to_s
+    message
+  end
+
+  def inspect
+    %Q(#<#{self.class.name} @name="#{@name.inspect}" @message="#{@message.inspect}">)
+  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
+  def calculate_corrective_change(old_system_value)
+    # Only idempotent properties, and cases where we have an old system_value
+    # are corrective_changes.
+    if @property_instance.idempotent? &&
+       !@property_instance.sensitive &&
+       !old_system_value.nil?
+
+      # If the values aren't insync, we have confirmed a corrective_change
+      insync = @property_instance.insync_values?(old_system_value, previous_value)
+
+      # Preserve the nil state, but flip true/false
+      @corrective_change = insync.nil? ? nil : !insync
+    else
+      @corrective_change = false
+    end
+  end
+
+  private
+
+  # If it's a failure, use 'err', else use either the resource's log level (if available)
+  # or 'notice'.
+  def log_level
+    status == "failure" ? :err : (@default_log_level || :notice)
+  end
+
+  # Used by the Logging module
+  def log_source
+    source_description || property || resource
+  end
+end

data/lib/puppet/transaction/event_manager.rb

@@ -0,0 +1,179 @@
+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
+
+  # @!attribute [r] events
+  #   @todo Determine if this instance variable is used for anything aside from testing.
+  #   @return [Array<Puppet::Transaction::Events>] A list of events that can be
+  #     handled by the target resource. Events that cannot be handled by the
+  #     target resource will be discarded.
+  attr_reader :events
+
+  def initialize(transaction)
+    @transaction = transaction
+    @event_queues = {}
+    @events = []
+  end
+
+  def relationship_graph
+    transaction.relationship_graph
+  end
+
+  # Respond to any queued events for this resource.
+  def process_events(resource)
+    restarted = false
+    queued_events(resource) do |callback, events|
+      r = process_callback(resource, callback, events)
+      restarted ||= r
+    end
+
+    if restarted
+      queue_events(resource, [resource.event(:name => :restarted, :status => "success")])
+
+      transaction.resource_status(resource).restarted = true
+    end
+  end
+
+  # Queues events for other resources to respond to.  All of these events have
+  # to be from the same resource.
+  #
+  # @param resource [Puppet::Type] The resource generating the given events
+  # @param events [Array<Puppet::Transaction::Event>] All events generated by this resource
+  # @return [void]
+  def queue_events(resource, 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|
+      collection[event.name] ||= []
+      collection[event.name] << event
+      collection
+    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]
+
+      # Collect the targets of any subscriptions to those events.  We pass
+      # the parent resource in so it will override the source in the events,
+      # since eval_generated children can't have direct relationships.
+      received = (event.name != :restarted)
+      relationship_graph.matching_edges(event, resource).each do |edge|
+        received ||= true unless edge.target.is_a?(Puppet::Type.type(:whit))
+        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?
+    end
+
+    dequeue_events_for_resource(resource, :refresh) if events.detect { |e| e.invalidate_refreshes }
+  end
+
+  def dequeue_all_events_for_resource(target)
+    callbacks = @event_queues[target]
+    if callbacks && !callbacks.empty?
+      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}") % { callback: callback, target: target }
+    @event_queues[target][callback] = [] if @event_queues[target]
+  end
+
+  def queue_events_for_resource(source, target, callback, events)
+    whit = Puppet::Type.type(:whit)
+
+    # The message that a resource is refreshing the completed-whit for its own class
+    # is extremely counter-intuitive. Basically everything else is easy to understand,
+    # if you suppress the whit-lookingness of the whit resources
+    refreshing_c_whit = target.is_a?(whit) && target.name =~ /^completed_/
+
+    if refreshing_c_whit
+      source.debug "The container #{target} will propagate my #{callback} event"
+    else
+      source.info _("Scheduling %{callback} of %{target}") % { callback: callback, target: target }
+    end
+
+    @event_queues[target] ||= {}
+    @event_queues[target][callback] ||= []
+    @event_queues[target][callback].concat(events)
+  end
+
+  def queued_events(resource)
+    callbacks = @event_queues[resource]
+    return unless callbacks
+    callbacks.each do |callback, events|
+      yield callback, events unless events.empty?
+    end
+  end
+
+  private
+
+  # Should the callback for this resource be invoked?
+  # @param resource [Puppet::Type] The resource to be refreshed
+  # @param events [Array<Puppet::Transaction::Event>] A list of events
+  #   associated with this callback and resource.
+  # @return [true, false] Whether the callback should be run.
+  def process_callback?(resource, events)
+    !(events.all? { |e| e.status == "noop" } || resource.noop?)
+  end
+
+  # Processes callbacks for a given resource.
+  #
+  # @param resource [Puppet::Type] The resource receiving the callback.
+  # @param callback [Symbol] The name of the callback method that will be invoked.
+  # @param events [Array<Puppet::Transaction::Event>] A list of events
+  #   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)
+      process_noop_events(resource, callback, events)
+      return false
+    end
+
+    resource.send(callback)
+
+    if not 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
+  rescue => detail
+    resource_error_message = _("Failed to call %{callback}: %{detail}") % { callback: callback, detail: detail }
+    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
+  end
+
+  def add_callback_status_event(resource, callback, message, status)
+    options = { message: message, status: status, name: callback.to_s }
+    event = resource.event options
+    transaction.resource_status(resource) << event if event
+  end
+
+  def process_noop_events(resource, callback, 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)])
+  end
+end

data/lib/puppet/transaction/persistence.rb

@@ -0,0 +1,119 @@
+require '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" => {}}
+  end
+
+  # Obtain the full raw data from the persistence store.
+  # @return [Hash] hash of data stored in persistence store
+  def data
+    @old_data
+  end
+
+  # Retrieve the system value using the resource and parameter name
+  # @param [String] resource_name name of resource
+  # @param [String] param_name name of the parameter
+  # @return [Object,nil] the system_value
+  def get_system_value(resource_name, param_name)
+    if !@old_data["resources"].nil? &&
+       !@old_data["resources"][resource_name].nil? &&
+       !@old_data["resources"][resource_name]["parameters"].nil? &&
+       !@old_data["resources"][resource_name]["parameters"][param_name].nil?
+      @old_data["resources"][resource_name]["parameters"][param_name]["system_value"]
+    else
+      nil
+    end
+  end
+
+  def set_system_value(resource_name, param_name, value)
+    @new_data["resources"] ||= {}
+    @new_data["resources"][resource_name] ||= {}
+    @new_data["resources"][resource_name]["parameters"] ||= {}
+    @new_data["resources"][resource_name]["parameters"][param_name] ||= {}
+    @new_data["resources"][resource_name]["parameters"][param_name]["system_value"] = value
+  end
+
+  def copy_skipped(resource_name)
+    @old_data["resources"] ||= {}
+    old_value = @old_data["resources"][resource_name]
+    if !old_value.nil?
+      @new_data["resources"][resource_name] = old_value
+    end
+  end
+
+  # Load data from the persistence store on disk.
+  def load
+    filename = Puppet[:transactionstorefile]
+    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
+    end
+
+    result = nil
+    Puppet::Util.benchmark(:debug, _("Loaded transaction store file in %{seconds} seconds")) do
+      begin
+        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
+          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
+    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.") % { filename: filename }
+      return
+    end
+
+    @old_data = result
+  end
+
+  # Save data from internal class to persistence store on disk.
+  def save
+    Puppet::Util::Yaml.dump(@new_data, Puppet[:transactionstorefile])
+  end
+
+  # Use the catalog and run_mode to determine if persistence should be enabled or not
+  # @param [Puppet::Resource::Catalog] catalog catalog being processed
+  # @return [boolean] true if persistence is enabled
+  def enabled?(catalog)
+    catalog.host_config? && Puppet.run_mode.name == :agent
+  end
+end