puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/transaction/additional_resource_generator.rb

@@ -0,0 +1,126 @@
+# 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
+  def initialize(catalog, relationship_graph, prioritizer)
+    @catalog = catalog
+    @relationship_graph = relationship_graph
+    @prioritizer = prioritizer
+  end
+
+  def generate_additional_resources(resource)
+    return unless resource.respond_to?(:generate)
+    begin
+      generated = resource.generate
+    rescue => detail
+      resource.log_exception(detail, "Failed to generate additional resources using 'generate': #{detail}")
+    end
+    return unless generated
+    generated = [generated] unless generated.is_a?(Array)
+    generated.collect do |res|
+      @catalog.resource(res.ref) || res
+    end.each do |res|
+      priority = @prioritizer.generate_priority_contained_in(resource, res)
+      add_resource(res, resource, priority)
+
+      add_conditional_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
+      resource.log_exception(detail, "Failed to generate additional resources using 'eval_generate': #{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)
+    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)
+    if @catalog.resource(res.ref).nil?
+      res.tag(*parent_resource.tags)
+      @catalog.add_resource(res)
+      @relationship_graph.add_vertex(res, priority)
+      @catalog.add_edge(@catalog.container_of(parent_resource), res)
+      res.finish
+    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/vendor/gems/puppet-3.7.3/lib/puppet/transaction/event.rb

@@ -0,0 +1,107 @@
+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]
+  YAML_ATTRIBUTES = %w{@audited @property @previous_value @desired_value @historical_value @message @name @status @time}.map(&:to_sym)
+  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 self.from_pson(data)
+    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
+    self.from_data_hash(data)
+  end
+
+  def initialize(options = {})
+    @audited = false
+
+    set_options(options)
+    @time = Time.now
+  end
+
+  def initialize_from_hash(data)
+    @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
+  end
+
+  def to_data_hash
+    {
+      'audited' => @audited,
+      'property' => @property,
+      'previous_value' => @previous_value,
+      'desired_value' => @desired_value,
+      'historical_value' => @historical_value,
+      'message' => @message,
+      'name' => @name,
+      'status' => @status,
+      'time' => @time.iso8601(9),
+    }
+  end
+
+  def property=(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 #{EVENT_STATUSES.join(', ')}" unless EVENT_STATUSES.include?(value)
+    @status = value
+  end
+
+  def to_s
+    message
+  end
+
+  def to_yaml_properties
+    YAML_ATTRIBUTES & super
+  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/vendor/gems/puppet-3.7.3/lib/puppet/transaction/event_manager.rb

@@ -0,0 +1,122 @@
+require 'puppet/transaction'
+
+class Puppet::Transaction::EventManager
+  attr_reader :transaction, :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
+
+  # Queue events for other resources to respond to.  All of these events have
+  # to be from the same resource.
+  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_events_for_resource(target, callback)
+    target.info "Unscheduling #{callback} on #{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}"
+    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
+
+  def process_callback(resource, callback, events)
+    process_noop_events(resource, callback, events) and return false unless events.detect { |e| e.status != "noop" }
+    resource.send(callback)
+
+    if not resource.is_a?(Puppet::Type.type(:whit))
+      resource.notice "Triggered '#{callback}' from #{events.length} events"
+    end
+    return true
+  rescue => detail
+    resource.err "Failed to call #{callback}: #{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 "Would have triggered '#{callback}' from #{events.length} events"
+
+    # And then add an event for it.
+    queue_events(resource, [resource.event(:status => "noop", :name => :noop_restart)])
+    true # so the 'and if' works
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/transaction/report.rb

@@ -0,0 +1,383 @@
+require 'puppet'
+require '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_.
+#
+# * **Logs** - are the output that each change produces.
+# * **Metrics** - are all of the numerical data involved in the transaction.
+#
+# Use {Puppet::Reports} class to create a new custom report type. This class is indirectly used
+# as a source of data to report in such a registered report.
+#
+# ##Metrics
+# There are three types of metrics in each report, and each type of metric has one or more values.
+#
+# * Time: Keeps track of how long things took.
+#   * Total: Total time for the configuration run
+#   * File:
+#   * Exec:
+#   * User:
+#   * Group:
+#   * Config Retrieval: How long the configuration took to retrieve
+#   * Service:
+#   * Package:
+# * Resources: Keeps track of the following stats:
+#   * Total: The total number of resources being managed
+#   * Skipped: How many resources were skipped, because of either tagging or scheduling restrictions
+#   * Scheduled: How many resources met any scheduling restrictions
+#   * Out of Sync: How many resources were out of sync
+#   * Applied: How many resources were attempted to be fixed
+#   * Failed: How many resources were not successfully fixed
+#   * Restarted: How many resources were restarted because their dependencies changed
+#   * Failed Restarts: How many resources could not be restarted
+# * Changes: The total number of changes in the transaction.
+#
+# @api public
+class Puppet::Transaction::Report
+  extend Puppet::Indirector
+
+  indirects :report, :terminus_class => :processor
+
+  # The version of the configuration
+  # @todo Uncertain what this is?
+  # @return [???] the configuration version
+  attr_accessor :configuration_version
+
+  # An agent generated transaction uuid, useful for connecting catalog and report
+  # @return [String] uuid
+  attr_accessor :transaction_uuid
+
+  # The host name for which the report is generated
+  # @return [String] the host name
+  attr_accessor :host
+
+  # The name of the environment the host is in
+  # @return [String] the environment name
+  attr_accessor :environment
+
+  # A hash with a map from resource to status
+  # @return [Hash{String => Puppet::Resource::Status}] Resource name to status.
+  attr_reader :resource_statuses
+
+  # A list of log messages.
+  # @return [Array<Puppet::Util::Log>] logged messages
+  attr_reader :logs
+
+  # A hash of metric name to metric value.
+  # @return [Hash<{String => Object}>] A map of metric name to value.
+  # @todo Uncertain if all values are numbers - now marked as Object.
+  #
+  attr_reader :metrics
+
+  # The time when the report data was generated.
+  # @return [Time] A time object indicating when the report data was generated
+  #
+  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'
+  #
+  attr_reader :status
+
+  # @return [String] The Puppet version in String form.
+  # @see Puppet::version()
+  #
+  attr_reader :puppet_version
+
+  # @return [Integer] report format version number.  This value is constant for
+  #    a given version of Puppet; it is incremented when a new release of Puppet
+  #    changes the API for the various objects that make up a report.
+  #
+  attr_reader :report_format
+
+  def self.from_data_hash(data)
+    obj = self.allocate
+    obj.initialize_from_hash(data)
+    obj
+  end
+
+  def self.from_pson(data)
+    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
+    self.from_data_hash(data)
+  end
+
+  def as_logging_destination(&block)
+    Puppet::Util::Log.with_destination(self, &block)
+  end
+
+  # @api private
+  def <<(msg)
+    @logs << msg
+    self
+  end
+
+  # @api private
+  def add_times(name, value)
+    @external_times[name] = value
+  end
+
+  # @api private
+  def add_metric(name, hash)
+    metric = Puppet::Util::Metric.new(name)
+
+    hash.each do |name, value|
+      metric.newvalue(name, value)
+    end
+
+    @metrics[metric.name] = metric
+    metric
+  end
+
+  # @api private
+  def add_resource_status(status)
+    @resource_statuses[status.resource] = status
+  end
+
+  # @api private
+  def compute_status(resource_metrics, change_metric)
+    if (resource_metrics["failed"] || 0) > 0
+      'failed'
+    elsif change_metric > 0
+      'changed'
+    else
+      'unchanged'
+    end
+  end
+
+  # @api private
+  def prune_internal_data
+    resource_statuses.delete_if {|name,res| res.resource_type == 'Whit'}
+  end
+
+  # @api private
+  def finalize_report
+    prune_internal_data
+
+    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(:events, calculate_event_metrics)
+    @status = compute_status(resource_metrics, change_metric)
+  end
+
+  # @api private
+  def initialize(kind, configuration_version=nil, environment=nil, transaction_uuid=nil)
+    @metrics = {}
+    @logs = []
+    @resource_statuses = {}
+    @external_times ||= {}
+    @host = Puppet[:node_name_value]
+    @time = Time.now
+    @kind = kind
+    @report_format = 4
+    @puppet_version = Puppet.version
+    @configuration_version = configuration_version
+    @transaction_uuid = transaction_uuid
+    @environment = environment
+    @status = 'failed' # assume failed until the report is finalized
+  end
+
+  # @api private
+  def initialize_from_hash(data)
+    @puppet_version = data['puppet_version']
+    @report_format = data['report_format']
+    @configuration_version = data['configuration_version']
+    @transaction_uuid = data['transaction_uuid']
+    @environment = data['environment']
+    @status = data['status']
+    @host = data['host']
+    @time = data['time']
+    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)
+    end
+
+    @logs = data['logs'].map do |record|
+      Puppet::Util::Log.from_data_hash(record)
+    end
+
+    @resource_statuses = {}
+    data['resource_statuses'].map do |record|
+      if record[1] == {}
+        status = nil
+      else
+        status = Puppet::Resource::Status.from_data_hash(record[1])
+      end
+      @resource_statuses[record[0]] = status
+    end
+  end
+
+  def to_data_hash
+    {
+      'host' => @host,
+      'time' => @time.iso8601(9),
+      'configuration_version' => @configuration_version,
+      'transaction_uuid' => @transaction_uuid,
+      'report_format' => @report_format,
+      'puppet_version' => @puppet_version,
+      'kind' => @kind,
+      'status' => @status,
+      'environment' => @environment,
+
+      'logs' => @logs,
+      'metrics' => @metrics,
+      'resource_statuses' => @resource_statuses,
+    }
+  end
+
+  # @return [String] the host name
+  # @api public
+  #
+  def name
+    host
+  end
+
+  # Provide a human readable textual summary of this report.
+  # @note This is intended for debugging purposes
+  # @return [String] A string with a textual summary of this report.
+  # @api public
+  #
+  def summary
+    report = raw_summary
+
+    ret = ""
+    report.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key|
+      ret += "#{Puppet::Util::Metric.labelize(key)}:\n"
+
+      report[key].keys.sort { |a,b|
+        # sort by label
+        if a == :total
+          1
+        elsif b == :total
+          -1
+        else
+          report[key][a].to_s <=> report[key][b].to_s
+        end
+      }.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
+    end
+    ret
+  end
+
+  # Provides a raw hash summary of this report.
+  # @return [Hash<{String => Object}>] A hash with metrics key to value map
+  # @api public
+  #
+  def raw_summary
+    report = { "version" => { "config" => configuration_version, "puppet" => Puppet.version  } }
+
+    @metrics.each do |name, metric|
+      key = metric.name.to_s
+      report[key] = {}
+      metric.values.each do |name, label, value|
+        report[key][name.to_s] = value
+      end
+      report[key]["total"] = 0 unless key == "time" or report[key].include?("total")
+    end
+    (report["time"] ||= {})["last_run"] = Time.now.tv_sec
+    report
+  end
+
+  # Computes a single number that represents the report's status.
+  # The computation is based on the contents of this report's metrics.
+  # The resulting number is a bitmask where
+  # individual bits represent the presence of different metrics.
+  #
+  # * 0x2 set if there are changes
+  # * 0x4 set if there are resource failures or resources that failed to restart
+  # @return [Integer] A bitmask where 0x2 is set if there are changes, and 0x4 is set of there are failures.
+  # @api public
+  #
+  def exit_status
+    status = 0
+    status |= 2 if @metrics["changes"]["total"] > 0
+    status |= 4 if @metrics["resources"]["failed"] > 0
+    status |= 4 if @metrics["resources"]["failed_to_restart"] > 0
+    status
+  end
+
+  # @api private
+  #
+  def to_yaml_properties
+    super - [:@external_times]
+  end
+
+  def self.supported_formats
+    [:pson, :yaml]
+  end
+
+  def self.default_format
+    Puppet[:report_serialization_format].intern
+  end
+
+  private
+
+  def calculate_change_metric
+    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|
+      metrics["total"] += status.events.length
+      status.events.each do |event|
+        metrics[event.status] += 1
+      end
+    end
+
+    metrics
+  end
+
+  def calculate_resource_metrics
+    metrics = {}
+    metrics["total"] = resource_statuses.length
+
+    # force every resource key in the report to be present
+    # even if no resources is in this given state
+    Puppet::Resource::Status::STATES.each do |state|
+      metrics[state.to_s] = 0
+    end
+
+    resource_statuses.each do |name, status|
+      Puppet::Resource::Status::STATES.each do |state|
+        metrics[state.to_s] += 1 if status.send(state)
+      end
+    end
+
+    metrics
+  end
+
+  def calculate_time_metrics
+    metrics = Hash.new(0)
+    resource_statuses.each do |name, status|
+      type = Puppet::Resource.new(name).type
+      metrics[type.to_s.downcase] += status.evaluation_time if status.evaluation_time
+    end
+
+    @external_times.each do |name, value|
+      metrics[name.to_s.downcase] = value
+    end
+
+    metrics["total"] = metrics.values.inject(0) { |a,b| a+b }
+
+    metrics
+  end
+end