openvox 7.37.1

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

@@ -0,0 +1,48 @@
+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/lib/puppet/util/profiler/object_counts.rb

@@ -0,0 +1,17 @@
+require_relative '../../../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/lib/puppet/util/profiler/wall_clock.rb

@@ -0,0 +1,35 @@
+require_relative '../../../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/lib/puppet/util/profiler.rb

@@ -0,0 +1,53 @@
+require 'benchmark'
+
+# A simple profiling callback system.
+#
+# @api public
+module Puppet::Util::Profiler
+  require_relative 'profiler/wall_clock'
+  require_relative 'profiler/object_counts'
+  require_relative 'profiler/around_profiler'
+
+  @profiler = Puppet::Util::Profiler::AroundProfiler.new
+
+  # Reset the profiling system to the original state
+  #
+  # @api private
+  def self.clear
+    @profiler.clear
+  end
+
+  # Retrieve the current list of profilers
+  #
+  # @api private
+  def self.current
+    @profiler.current
+  end
+
+  # @param profiler [#profile] A profiler for the current thread
+  # @api private
+  def self.add_profiler(profiler)
+    @profiler.add_profiler(profiler)
+  end
+
+  # @param profiler [#profile] A profiler to remove from the current thread
+  # @api private
+  def self.remove_profiler(profiler)
+    @profiler.remove_profiler(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 public
+  def self.profile(message, metric_id, &block)
+    @profiler.profile(message, metric_id, &block)
+  end
+end

data/lib/puppet/util/provider_features.rb

@@ -0,0 +1,179 @@
+# Provides feature definitions.
+require_relative '../../puppet/util/docs'
+require_relative '../../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_by(&: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_by(&: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/lib/puppet/util/psych_support.rb

@@ -0,0 +1,30 @@
+# 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

data/lib/puppet/util/rdoc/code_objects.rb

@@ -0,0 +1,295 @@
+require 'rdoc/code_objects'
+
+module RDoc
+
+  # This modules contains various class that are used to hold information
+  # about the various Puppet language structures we found while parsing.
+  #
+  # Those will be mapped to their html counterparts which are defined in
+  # PuppetGenerator.
+
+  # PuppetTopLevel is a top level (usually a .pp/.rb file)
+  module PuppetTopLevel
+    attr_accessor :module_name, :global
+  end
+
+  # Add top level comments to a class or module
+  # @api private
+  module AddClassModuleComment
+    def add_comment(comment, location = nil)
+        super
+    end
+  end
+
+  # PuppetModule holds a Puppet Module
+  # This is mapped to an HTMLPuppetModule
+  # it leverage the RDoc (ruby) module infrastructure
+  class PuppetModule < NormalModule
+    include AddClassModuleComment
+
+    attr_accessor :facts, :plugins
+
+    def initialize(name,superclass=nil)
+      @facts = []
+      @plugins = []
+      @nodes = {}
+      super(name,superclass)
+    end
+
+    def add_plugin(plugin)
+      name = plugin.name
+      type = plugin.type
+      meth = AnyMethod.new("*args", name)
+      meth.params = "(*args)"
+      meth.visibility = :public
+      meth.document_self = true
+      meth.singleton = false
+      meth.comment = plugin.comment
+      if type == 'function'
+        @function_container ||= add_module(NormalModule, "__functions__")
+        @function_container.add_method(meth)
+      elsif type == 'type'
+        @type_container ||= add_module(NormalModule, "__types__")
+        @type_container.add_method(meth)
+      end
+    end
+
+    def add_fact(fact)
+      @fact_container ||= add_module(NormalModule, "__facts__")
+      confine_str = fact.confine.empty? ? '' : fact.confine.to_s
+      const = Constant.new(fact.name, confine_str, fact.comment)
+      @fact_container.add_constant(const)
+    end
+
+    # Adds a module called __nodes__ and adds nodes to it as classes
+    #
+    def add_node(name,superclass)
+      cls = @nodes[name]
+      if cls
+        return cls
+      end
+      @node_container ||= add_module(NormalModule, "__nodes__")
+      cls = @node_container.add_class(PuppetNode, name, superclass)
+      @nodes[name] = cls if !@done_documenting
+      cls
+    end
+
+    def each_fact
+      @facts.each {|c| yield c}
+    end
+
+    def each_plugin
+      @plugins.each {|c| yield c}
+    end
+
+    def each_node
+      @nodes.each {|c| yield c}
+    end
+
+    def nodes
+      @nodes.values
+    end
+  end
+
+  # PuppetClass holds a puppet class
+  # It is mapped to a HTMLPuppetClass for display
+  # It leverages RDoc (ruby) Class
+  class PuppetClass < ClassModule
+    include AddClassModuleComment
+
+    attr_accessor :resource_list, :requires, :childs, :realizes
+
+    def initialize(name, superclass)
+      super(name,superclass)
+      @resource_list = []
+      @requires = []
+      @realizes = []
+      @childs = []
+    end
+
+    def aref_prefix
+      'puppet_class'
+    end
+
+    def add_resource(resource)
+      add_to(@resource_list, resource)
+    end
+
+    def is_module?
+      false
+    end
+
+    def superclass=(superclass)
+      @superclass = superclass
+    end
+
+    # we're (ab)using the RDoc require system here.
+    # we're adding a required Puppet class, overriding
+    # the RDoc add_require method which sees ruby required files.
+    def add_require(required)
+      add_to(@requires, required)
+    end
+
+    def add_realize(realized)
+      add_to(@realizes, realized)
+    end
+
+    def add_child(child)
+      @childs << child
+    end
+
+    # Look up the given symbol. RDoc only looks for class1::class2.method
+    # or class1::class2#method. Since our definitions are mapped to RDoc methods
+    # but are written class1::class2::define we need to perform the lookup by
+    # ourselves.
+    def find_symbol(symbol, method=nil)
+      result = super(symbol)
+      if not result and symbol =~ /::/
+        modules = symbol.split(/::/)
+        unless modules.empty?
+          module_name = modules.shift
+          result = find_module_named(module_name)
+          if result
+            last_name = ""
+            previous = nil
+            modules.each do |mod|
+              previous = result
+              last_name = mod
+              result = result.find_module_named(mod)
+              break unless result
+            end
+            unless result
+              result = previous
+              method = last_name
+            end
+          end
+        end
+        if result && method
+          if !result.respond_to?(:find_local_symbol)
+            p result.name
+            p method
+            fail
+          end
+          result = result.find_local_symbol(method)
+        end
+      end
+      result
+    end
+
+  end
+
+  # PuppetNode holds a puppet node
+  # It is mapped to a HTMLPuppetNode for display
+  # A node is just a variation of a class
+  class PuppetNode < PuppetClass
+    include AddClassModuleComment
+
+    def initialize(name, superclass)
+      super(name,superclass)
+    end
+
+    def is_module?
+      false
+    end
+  end
+
+  # Plugin holds a native puppet plugin (function,type...)
+  # It is mapped to a HTMLPuppetPlugin for display
+  class Plugin < Context
+    attr_accessor :name, :type
+
+    def initialize(name, type)
+      super()
+      @name = name
+      @type = type
+      @comment = ""
+    end
+
+    def <=>(other)
+      @name <=> other.name
+    end
+
+    def full_name
+      @name
+    end
+
+    def http_url(prefix)
+      path = full_name.split("::")
+      File.join(prefix, *path) + ".html"
+    end
+
+    def is_fact?
+      false
+    end
+
+    def to_s
+      res = self.class.name + ": #{@name} (#{@type})\n"
+      res << @comment.to_s
+      res
+    end
+  end
+
+  # Fact holds a custom fact
+  # It is mapped to a HTMLPuppetPlugin for display
+  class Fact < Context
+    attr_accessor :name, :confine
+
+    def initialize(name, confine)
+      super()
+      @name = name
+      @confine = confine
+      @comment = ""
+    end
+
+    def <=>(other)
+      @name <=> other.name
+    end
+
+    def is_fact?
+      true
+    end
+
+    def full_name
+      @name
+    end
+
+    def to_s
+      res = self.class.name + ": #{@name}\n"
+      res << @comment.to_s
+      res
+    end
+  end
+
+  # PuppetResource holds a puppet resource
+  # It is mapped to a HTMLPuppetResource for display
+  # A resource is defined by its "normal" form Type[title]
+  class PuppetResource < CodeObject
+    attr_accessor :type, :title, :params
+
+    def initialize(type, title, comment, params)
+      super()
+      @type = type
+      @title = title
+      @comment = comment
+      @params = params
+    end
+
+    def <=>(other)
+      full_name <=> other.full_name
+    end
+
+    def full_name
+      @type + "[#{@title}]"
+    end
+
+    def name
+      full_name
+    end
+
+    def to_s
+      res = @type + "[#{@title}]\n"
+      res << @comment.to_s
+      res
+    end
+  end
+end