bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/util/profiler/aggregate.rb

@@ -1,85 +0,0 @@
-require 'puppet/util/profiler'
-require 'puppet/util/profiler/wall_clock'
-
-class Puppet::Util::Profiler::Aggregate < Puppet::Util::Profiler::WallClock
-  def initialize(logger, identifier)
-    super(logger, identifier)
-    @metrics_hash = Metric.new
-  end
-
-  def shutdown()
-    super
-    @logger.call("AGGREGATE PROFILING RESULTS:")
-    @logger.call("----------------------------")
-    print_metrics(@metrics_hash, "")
-    @logger.call("----------------------------")
-  end
-
-  def do_start(description, metric_id)
-    super(description, metric_id)
-  end
-
-  def do_finish(context, description, metric_id)
-    result = super(context, description, metric_id)
-    update_metric(@metrics_hash, metric_id, result[:time])
-    result
-  end
-
-  def update_metric(metrics_hash, metric_id, time)
-    first, *rest = *metric_id
-    if first
-      m = metrics_hash[first]
-      m.increment
-      m.add_time(time)
-      if rest.count > 0
-        update_metric(m, rest, time)
-      end
-    end
-  end
-
-  def values
-    @metrics_hash
-  end
-
-  def print_metrics(metrics_hash, prefix)
-    metrics_hash.sort_by {|k,v| v.time }.reverse_each do |k,v|
-      @logger.call("#{prefix}#{k}: #{v.time} s (#{v.count} calls)")
-      print_metrics(metrics_hash[k], "#{prefix}#{k} -> ")
-    end
-  end
-
-  class Metric < Hash
-    def initialize
-      super
-      @count = 0
-      @time = 0
-    end
-    attr_reader :count, :time
-
-    def [](key)
-      if !has_key?(key)
-        self[key] = Metric.new
-      end
-      super(key)
-    end
-
-    def increment
-      @count += 1
-    end
-
-    def add_time(time)
-      @time += time
-    end
-  end
-
-  class Timer
-    def initialize
-      @start = Time.now
-    end
-
-    def stop
-      Time.now - @start
-    end
-  end
-end
-

data/vendored/puppet/lib/puppet/util/profiler/around_profiler.rb

@@ -1,67 +0,0 @@
-# A Profiler that can be used to wrap around blocks of code. It is configured
-# with other profilers and controls them to start before the block is executed
-# and finish after the block is executed.
-#
-# @api private
-class Puppet::Util::Profiler::AroundProfiler
-
-  def initialize
-    @profilers = []
-  end
-
-  # Reset the profiling system to the original state
-  #
-  # @api private
-  def clear
-    @profilers = []
-  end
-
-  # Retrieve the current list of profilers
-  #
-  # @api private
-  def current
-    @profilers
-  end
-
-  # @param profiler [#profile] A profiler for the current thread
-  # @api private
-  def add_profiler(profiler)
-    @profilers << profiler
-    profiler
-  end
-
-  # @param profiler [#profile] A profiler to remove from the current thread
-  # @api private
-  def remove_profiler(profiler)
-    @profilers.delete(profiler)
-  end
-
-  # Profile a block of code and log the time it took to execute.
-  #
-  # This outputs logs entries to the Puppet masters logging destination
-  # providing the time it took, a message describing the profiled code
-  # and a leaf location marking where the profile method was called
-  # in the profiled hierarchy.
-  #
-  # @param message [String] A description of the profiled event
-  # @param metric_id [Array] A list of strings making up the ID of a metric to profile
-  # @param block [Block] The segment of code to profile
-  # @api private
-  def profile(message, metric_id)
-    retval = nil
-    contexts = {}
-    @profilers.each do |profiler|
-      contexts[profiler] = profiler.start(message, metric_id)
-    end
-
-    begin
-      retval = yield
-    ensure
-      @profilers.each do |profiler|
-        profiler.finish(contexts[profiler], message, metric_id)
-      end
-    end
-
-    retval
-  end
-end

data/vendored/puppet/lib/puppet/util/profiler/logging.rb

@@ -1,48 +0,0 @@
-class Puppet::Util::Profiler::Logging
-  def initialize(logger, identifier)
-    @logger = logger
-    @identifier = identifier
-    @sequence = Sequence.new
-  end
-
-  def start(description, metric_id)
-    @sequence.next
-    @sequence.down
-    do_start(description, metric_id)
-  end
-
-  def finish(context, description, metric_id)
-    profile_explanation = do_finish(context, description, metric_id)[:msg]
-    @sequence.up
-    @logger.call("PROFILE [#{@identifier}] #{@sequence} #{description}: #{profile_explanation}")
-  end
-
-  def shutdown()
-    # nothing to do
-  end
-
-  class Sequence
-    INITIAL = 0
-    SEPARATOR = '.'
-
-    def initialize
-      @elements = [INITIAL]
-    end
-
-    def next
-      @elements[-1] += 1
-    end
-
-    def down
-      @elements << INITIAL
-    end
-
-    def up
-      @elements.pop
-    end
-
-    def to_s
-      @elements.join(SEPARATOR)
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/profiler/object_counts.rb

@@ -1,17 +0,0 @@
-require 'puppet/util/profiler/logging'
-
-class Puppet::Util::Profiler::ObjectCounts < Puppet::Util::Profiler::Logging
-  def start
-    ObjectSpace.count_objects
-  end
-
-  def finish(before)
-    after = ObjectSpace.count_objects
-
-    diff = before.collect do |type, count|
-      [type, after[type] - count]
-    end
-
-    diff.sort.collect { |pair| pair.join(': ') }.join(', ')
-  end
-end

data/vendored/puppet/lib/puppet/util/profiler/wall_clock.rb

@@ -1,35 +0,0 @@
-require 'puppet/util/profiler/logging'
-
-# A profiler implementation that measures the number of seconds a segment of
-# code takes to execute and provides a callback with a string representation of
-# the profiling information.
-#
-# @api private
-class Puppet::Util::Profiler::WallClock < Puppet::Util::Profiler::Logging
-  def do_start(description, metric_id)
-    Timer.new
-  end
-
-  def do_finish(context, description, metric_id)
-    {:time => context.stop,
-     :msg => _("took %{context} seconds") % { context: context }}
-  end
-
-  class Timer
-    FOUR_DECIMAL_DIGITS = '%0.4f'
-
-    def initialize
-      @start = Time.now
-    end
-
-    def stop
-      @time = Time.now - @start
-      @time
-    end
-
-    def to_s
-      format(FOUR_DECIMAL_DIGITS, @time)
-    end
-  end
-end
-

data/vendored/puppet/lib/puppet/util/provider_features.rb

@@ -1,181 +0,0 @@
-# Provides feature definitions.
-require 'puppet/util/docs'
-require 'puppet/util'
-# This module models provider features and handles checking whether the features
-# are present.
-# @todo Unclear what is api and what is private in this module.
-#
-module Puppet::Util::ProviderFeatures
-  include Puppet::Util::Docs
-  # This class models provider features and handles checking whether the features
-  # are present.
-  # @todo Unclear what is api and what is private in this class
-  class ProviderFeature
-    include Puppet::Util
-    include Puppet::Util::Docs
-    attr_accessor :name, :docs, :methods
-
-    # Are all of the requirements met?
-    # Requirements are checked by checking if feature predicate methods have been generated - see {#methods_available?}.
-    # @param obj [Object, Class] the object or class to check if requirements are met
-    # @return [Boolean] whether all requirements for this feature are met or not.
-    def available?(obj)
-      if self.methods
-        return !!methods_available?(obj)
-      else
-        # In this case, the provider has to declare support for this
-        # feature, and that's been checked before we ever get to the
-        # method checks.
-        return false
-      end
-    end
-
-    def initialize(name, docs, methods: nil)
-      self.name = name.intern
-      self.docs = docs
-      @methods = methods
-    end
-
-    private
-
-    # Checks whether all feature predicate methods are available.
-    # @param obj [Object, Class] the object or class to check if feature predicates are available or not.
-    # @return [Boolean] Returns whether all of the required methods are available or not in the given object.
-    def methods_available?(obj)
-      methods.each do |m|
-        if obj.is_a?(Class)
-          return false unless obj.public_method_defined?(m)
-        else
-          return false unless obj.respond_to?(m)
-        end
-      end
-      true
-    end
-  end
-
-  # Defines one feature.
-  # At a minimum, a feature requires a name
-  # and docs, and at this point they should also specify a list of methods
-  # required to determine if the feature is present.
-  # @todo How methods that determine if the feature is present are specified.
-  def feature(name, docs, hash = {})
-    @features ||= {}
-    raise Puppet::DevError, _("Feature %{name} is already defined") % { name: name } if @features.include?(name)
-    begin
-      obj = ProviderFeature.new(name, docs, hash)
-      @features[obj.name] = obj
-    rescue ArgumentError => detail
-      error = ArgumentError.new(
-        _("Could not create feature %{name}: %{detail}") % { name: name, detail: detail }
-      )
-      error.set_backtrace(detail.backtrace)
-      raise error
-    end
-  end
-
-  # @return [String] Returns a string with documentation covering all features.
-  def featuredocs
-    str = ""
-    @features ||= {}
-    return nil if @features.empty?
-    names = @features.keys.sort { |a,b| a.to_s <=> b.to_s }
-    names.each do |name|
-      doc = @features[name].docs.gsub(/\n\s+/, " ")
-      str << "- *#{name}*: #{doc}\n"
-    end
-
-    if providers.length > 0
-      headers = ["Provider", names].flatten
-      data = {}
-      providers.each do |provname|
-        data[provname] = []
-        prov = provider(provname)
-        names.each do |name|
-          if prov.feature?(name)
-            data[provname] << "*X*"
-          else
-            data[provname] << ""
-          end
-        end
-      end
-      str << doctable(headers, data)
-    end
-    str
-  end
-
-  # @return [Array<String>] Returns a list of features.
-  def features
-    @features ||= {}
-    @features.keys
-  end
-
-  # Generates a module that sets up the boolean predicate methods to test for given features.
-  #
-  def feature_module
-    unless defined?(@feature_module)
-      @features ||= {}
-      @feature_module = ::Module.new
-      const_set("FeatureModule", @feature_module)
-      features = @features
-      # Create a feature? method that can be passed a feature name and
-      # determine if the feature is present.
-      @feature_module.send(:define_method, :feature?) do |name|
-        method = name.to_s + "?"
-        return !!(respond_to?(method) and send(method))
-      end
-
-      # Create a method that will list all functional features.
-      @feature_module.send(:define_method, :features) do
-        return false unless defined?(features)
-        features.keys.find_all { |n| feature?(n) }.sort { |a,b|
-          a.to_s <=> b.to_s
-        }
-      end
-
-      # Create a method that will determine if a provided list of
-      # features are satisfied by the curred provider.
-      @feature_module.send(:define_method, :satisfies?) do |*needed|
-        ret = true
-        needed.flatten.each do |feature|
-          unless feature?(feature)
-            ret = false
-            break
-          end
-        end
-        ret
-      end
-
-      # Create a boolean method for each feature so you can test them
-      # individually as you might need.
-      @features.each do |name, feature|
-        method = name.to_s + "?"
-        @feature_module.send(:define_method, method) do
-          (is_a?(Class) ?  declared_feature?(name) : self.class.declared_feature?(name)) or feature.available?(self)
-        end
-      end
-
-      # Allow the provider to declare that it has a given feature.
-      @feature_module.send(:define_method, :has_features) do |*names|
-        @declared_features ||= []
-        names.each do |name|
-          @declared_features << name.intern
-        end
-      end
-      # Aaah, grammatical correctness
-      @feature_module.send(:alias_method, :has_feature, :has_features)
-    end
-    @feature_module
-  end
-
-  # @return [ProviderFeature] Returns a provider feature instance by name.
-  # @param name [String] the name of the feature to return
-  # @note Should only be used for testing.
-  # @api private
-  #
-  def provider_feature(name)
-    return nil unless defined?(@features)
-
-    @features[name]
-  end
-end
-

data/vendored/puppet/lib/puppet/util/psych_support.rb

@@ -1,30 +0,0 @@
-# This module should be included when a class can be serialized to yaml and
-# needs to handle the deserialization from Psych with more control. Psych normally
-# pokes values directly into an instance using `instance_variable_set` which completely
-# bypasses encapsulation.
-#
-# The class that includes this module must implement an instance method `initialize_from_hash`
-# that is given a hash with attribute to value mappings.
-#
-module Puppet::Util::PsychSupport
-  # This method is called from the Psych Yaml deserializer when it encounters a tag
-  # in the form !ruby/object:<class name>.
-  #
-  def init_with(psych_coder)
-    # The PsychCoder has a hashmap of instance variable name (sans the @ symbol) to values
-    # to set, and can thus directly be fed to initialize_from_hash.
-    #
-    initialize_from_hash(psych_coder.map)
-  end
-
-  # This method is called from the Psych Yaml serializer
-  # The serializer will call this method to create a hash that will be serialized to YAML.
-  # Instead of using the object itself during the mapping process we use what is
-  # returned by calling `to_data_hash` on the object itself since some of the
-  # objects we manage have asymmetrical serialization and deserialization.
-  #
-  def encode_with(psych_encoder)
-    tag = Psych.dump_tags[self.class] || "!ruby/object:#{self.class.name}"
-    psych_encoder.represent_map(tag, to_data_hash)
-  end
-end