bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/transaction/additional_resource_generator.rb

@@ -1,220 +0,0 @@
-# Adds additional resources to the catalog and relationship graph that are
-# generated by existing resources. There are two ways that a resource can
-# generate additional resources, either through the #generate method or the
-# #eval_generate method.
-#
-# @api private
-class Puppet::Transaction::AdditionalResourceGenerator
-  attr_writer :relationship_graph
-  # [boolean] true if any resource has attempted and failed to generate resources
-  attr_reader :resources_failed_to_generate
-
-  def initialize(catalog, relationship_graph, prioritizer)
-    @catalog = catalog
-    @relationship_graph = relationship_graph
-    @prioritizer = prioritizer
-    @resources_failed_to_generate = false
-  end
-
-  def generate_additional_resources(resource)
-    return unless resource.respond_to?(:generate)
-    begin
-      generated = resource.generate
-    rescue => detail
-      @resources_failed_to_generate = true
-      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)
-    generated.collect! do |res|
-      @catalog.resource(res.ref) || res
-    end
-    unless resource.depthfirst?
-      # This is reversed because PUP-1963 changed how generated
-      # resources were added to the catalog. It exists for backwards
-      # compatibility only, and can probably be removed in Puppet 5
-      #
-      # Previously, resources were given sequential priorities in the
-      # relationship graph. Post-1963, resources are added to the
-      # catalog one by one adjacent to the parent resource. This
-      # causes an implicit reversal of their application order from
-      # the old code. The reverse makes it all work like it did.
-      generated.reverse!
-    end
-    generated.each do |res|
-      add_resource(res, resource)
-
-      add_generated_directed_dependency(resource, res)
-      generate_additional_resources(res)
-    end
-  end
-
-  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?
-    begin
-      generated = replace_duplicates_with_catalog_resources(resource.eval_generate)
-      return false if generated.empty?
-    rescue => detail
-      @resources_failed_to_generate = true
-      #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)
-
-    made = Hash[generated.map(&:name).zip(generated)]
-    contain_generated_resources_in(resource, made)
-    connect_resources_to_ancestors(resource, made)
-
-    true
-  end
-
-  private
-
-  def replace_duplicates_with_catalog_resources(generated)
-    generated.collect do |generated_resource|
-      @catalog.resource(generated_resource.ref) || generated_resource
-    end
-  end
-
-  def contain_generated_resources_in(resource, made)
-    sentinel = Puppet::Type.type(:whit).new(:name => "completed_#{resource.title}", :catalog => resource.catalog)
-    # Tag the completed whit with all of the tags of the generating resource
-    # except the type name to allow event propogation to succeed beyond the whit
-    # "boundary" when filtering resources with tags. We include auto-generated
-    # tags such as the type name to support implicit filtering as well as
-    # explicit. Note that resource#tags returns a duplicate of the resource's
-    # tags.
-    sentinel.merge_tags_from(resource)
-    priority = @prioritizer.generate_priority_contained_in(resource, sentinel)
-    @relationship_graph.add_vertex(sentinel, priority)
-
-    redirect_edges_to_sentinel(resource, sentinel, made)
-
-    made.values.each do |res|
-      # This resource isn't 'completed' until each child has run
-      add_conditional_directed_dependency(res, sentinel, Puppet::Graph::RelationshipGraph::Default_label)
-    end
-
-    # This edge allows the resource's events to propagate, though it isn't
-    # strictly necessary for ordering purposes
-    add_conditional_directed_dependency(resource, sentinel, Puppet::Graph::RelationshipGraph::Default_label)
-  end
-
-  def redirect_edges_to_sentinel(resource, sentinel, made)
-    @relationship_graph.adjacent(resource, :direction => :out, :type => :edges).each do |e|
-      next if made[e.target.name]
-
-      @relationship_graph.add_relationship(sentinel, e.target, e.label)
-      @relationship_graph.remove_edge! e
-    end
-  end
-
-  def connect_resources_to_ancestors(resource, made)
-    made.values.each do |res|
-      # Depend on the nearest ancestor we generated, falling back to the
-      # resource if we have none
-      parent_name = res.ancestors.find { |a| made[a] and made[a] != res }
-      parent = made[parent_name] || resource
-
-      add_conditional_directed_dependency(parent, res)
-    end
-  end
-
-  def add_resources(generated, resource)
-    generated.each do |res|
-      priority = @prioritizer.generate_priority_contained_in(resource, res)
-      add_resource(res, resource, priority)
-    end
-  end
-
-  def add_resource(res, parent_resource, priority=nil)
-    if @catalog.resource(res.ref).nil?
-      res.merge_tags_from(parent_resource)
-      if parent_resource.depthfirst?
-        @catalog.add_resource_before(parent_resource, res)
-      else
-        @catalog.add_resource_after(parent_resource, res)
-      end
-      @catalog.add_edge(@catalog.container_of(parent_resource), res)
-      if @relationship_graph && priority
-        # If we have a relationship_graph we should add the resource
-        # to it (this is an eval_generate). If we don't, then the
-        # relationship_graph has not yet been created and we can skip
-        # adding it.
-        @relationship_graph.add_vertex(res, priority)
-      end
-      res.finish
-    end
-  end
-
-  # add correct edge for depth- or breadth- first traversal of
-  # generated resource. Skip generating the edge if there is already
-  # some sort of edge between the two resources.
-  def add_generated_directed_dependency(parent, child, label=nil)
-    if parent.depthfirst?
-      source = child
-      target = parent
-    else
-      source = parent
-      target = child
-    end
-
-    # For each potential relationship metaparam, check if parent or
-    # child references the other. If there are none, we should add our
-    # edge.
-    edge_exists = Puppet::Type.relationship_params.any? { |param|
-      param_sym = param.name.to_sym
-
-      if parent[param_sym]
-        parent_contains = parent[param_sym].any? { |res|
-          res.ref == child.ref
-        }
-      else
-        parent_contains = false
-      end
-
-      if child[param_sym]
-        child_contains = child[param_sym].any? { |res|
-          res.ref == parent.ref
-        }
-      else
-        child_contains = false
-      end
-
-      parent_contains || child_contains
-    }
-
-    if not edge_exists
-      # We *cannot* use target.to_resource here!
-      #
-      # For reasons that are beyond my (and, perhaps, human)
-      # comprehension, to_resource will call retrieve. This is
-      # problematic if a generated resource needs the system to be
-      # changed by a previous resource (think a file on a path
-      # controlled by a mount resource).
-      #
-      # Instead of using to_resource, we just construct a resource as
-      # if the arguments to the Type instance had been passed to a
-      # Resource instead.
-      resource = ::Puppet::Resource.new(target.class, target.title,
-                                        :parameters => target.original_parameters)
-
-      source[:before] ||= []
-      source[:before] << resource
-    end
-  end
-
-  # Copy an important relationships from the parent to the newly-generated
-  # child resource.
-  def add_conditional_directed_dependency(parent, child, label=nil)
-    @relationship_graph.add_vertex(child)
-    edge = parent.depthfirst? ? [child, parent] : [parent, child]
-    if @relationship_graph.edge?(*edge.reverse)
-      parent.debug "Skipping automatic relationship to #{child}"
-    else
-      @relationship_graph.add_relationship(edge[0],edge[1],label)
-    end
-  end
-end

data/vendored/puppet/lib/puppet/transaction/event.rb

@@ -1,144 +0,0 @@
-require 'puppet/transaction'
-require 'puppet/util/tagging'
-require 'puppet/util/logging'
-require 'puppet/util/methodhelper'
-require 'puppet/network/format_support'
-
-# A simple struct for storing what happens on the system.
-class Puppet::Transaction::Event
-  include Puppet::Util::MethodHelper
-  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(options = {})
-    @audited = false
-    @redacted = false
-    @corrective_change = false
-
-    set_options(options)
-    @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,
-    }
-    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)
-    @property_instance = prop
-    @property = prop.to_s
-  end
-
-  def resource=(res)
-    if res.respond_to?(:[]) and level = res[:loglevel]
-      @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/vendored/puppet/lib/puppet/transaction/event_manager.rb

@@ -1,167 +0,0 @@
-require '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))
-        next unless method = edge.callback
-        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)
-    return unless callbacks = @event_queues[resource]
-    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))
-      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}") % { callback: callback, detail: detail }
-
-    transaction.resource_status(resource).failed_to_restart = true
-    resource.log_exception(detail)
-    return false
-  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