puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/util/package.rb

@@ -0,0 +1,31 @@
+module Puppet::Util::Package
+  def versioncmp(version_a, version_b)
+    vre = /[-.]|\d+|[^-.\d]+/
+    ax = version_a.scan(vre)
+    bx = version_b.scan(vre)
+
+    while (ax.length>0 && bx.length>0)
+      a = ax.shift
+      b = bx.shift
+
+      if( a == b )                 then next
+      elsif (a == '-' && b == '-') then next
+      elsif (a == '-')             then return -1
+      elsif (b == '-')             then return 1
+      elsif (a == '.' && b == '.') then next
+      elsif (a == '.' )            then return -1
+      elsif (b == '.' )            then return 1
+      elsif (a =~ /^\d+$/ && b =~ /^\d+$/) then
+        if( a =~ /^0/ or b =~ /^0/ ) then
+          return a.to_s.upcase <=> b.to_s.upcase
+        end
+        return a.to_i <=> b.to_i
+      else
+        return a.upcase <=> b.upcase
+      end
+    end
+    version_a <=> version_b;
+  end
+
+  module_function :versioncmp
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/pidlock.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+require 'puppet/util/lockfile'
+
+class Puppet::Util::Pidlock
+
+  def initialize(lockfile)
+    @lockfile = Puppet::Util::Lockfile.new(lockfile)
+  end
+
+  def locked?
+    clear_if_stale
+    @lockfile.locked?
+  end
+
+  def mine?
+    Process.pid == lock_pid
+  end
+
+  def lock
+    return mine? if locked?
+
+    @lockfile.lock(Process.pid)
+  end
+
+  def unlock
+    if mine?
+      return @lockfile.unlock
+    else
+      false
+    end
+  end
+
+  def lock_pid
+    pid = @lockfile.lock_data
+    begin
+      Integer(pid)
+    rescue ArgumentError, TypeError
+      nil
+    end
+  end
+
+  def file_path
+    @lockfile.file_path
+  end
+
+  def clear_if_stale
+    return @lockfile.unlock if lock_pid.nil?
+
+    errors = [Errno::ESRCH]
+    # Win32::Process now throws SystemCallError. Since this could be
+    # defined anywhere, only add when on Windows.
+    errors << SystemCallError if Puppet::Util::Platform.windows?
+
+    begin
+      Process.kill(0, lock_pid)
+    rescue *errors
+      @lockfile.unlock
+    end
+  end
+  private :clear_if_stale
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/platform.rb

@@ -0,0 +1,22 @@
+module Puppet
+  module Util
+    module Platform
+      def windows?
+        # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
+        # library uses that to test what platform it's on. In some places we
+        # would use Puppet.features.microsoft_windows?, but this method can be
+        # used to determine the behavior of the underlying system without
+        # requiring features to be initialized and without side effect.
+        !!File::ALT_SEPARATOR
+      end
+      module_function :windows?
+
+      def default_paths
+        return [] if windows?
+
+        %w{/usr/sbin /sbin}
+      end
+      module_function :default_paths
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/plugins.rb

@@ -0,0 +1,82 @@
+#
+# This system manages an extensible set of metadata about plugins which it
+#   collects by searching for files named "plugin_init.rb" in a series of
+#   directories.  Initially, these are simply the $LOAD_PATH.
+#
+# The contents of each file found is executed in the context of a Puppet::Plugins
+#    object (and thus scoped).  An example file might contain:
+#
+# -------------------------------------------------------
+#      @name = "Greet the CA"
+#
+#      @description = %q{
+#        This plugin causes a friendly greeting to print out on a master
+#        that is operating as the CA, after it has been set up but before
+#        it does anything.
+#      }
+#
+#      def after_application_setup(options)
+#        if options[:application_object].is_a?(Puppet::Application::Master) && Puppet::SSL::CertificateAuthority.ca?
+#          puts "Hey, this is the CA!"
+#        end
+#      end
+# -------------------------------------------------------
+#
+# Note that the instance variables are local to this Puppet::Plugin (and so may be used
+#   for maintaining state, etc.) but the plugin system does not provide any thread safety
+#   assurances, so they may not be adequate for some complex use cases.
+
+
+module Puppet
+  class Plugins
+    Paths  = [] # Where we might find plugin initialization code
+    Loaded = [] # Code we have found (one-to-one with paths once searched)
+    #
+    # Return all the Puppet::Plugins we know about, searching any new paths
+    #
+    def self.known
+      Paths[Loaded.length...Paths.length].each { |path|
+        file = File.join(path,'plugin_init.rb')
+        Loaded << (Puppet::FileSystem.exist?(file) && new(file))
+      }
+      Loaded.compact
+    end
+    #
+    # Add more places to look for plugins without adding duplicates or changing the
+    #   order of ones we've already found.
+    #
+    def self.look_in(*paths)
+      Paths.replace Paths | paths.flatten.collect { |path| File.expand_path(path) }
+    end
+    #
+    # Initially just look in $LOAD_PATH
+    #
+    look_in $LOAD_PATH
+    #
+    # Calling methods (hooks) on the class calls the method of the same name on
+    #   all plugins that use that hook, passing in the same arguments to each
+    #   and returning an array containing the results returned by each plugin as
+    #   an array of [plugin_name,result] pairs.
+    #
+    def self.method_missing(hook,*args,&block)
+      known.
+        select  { |p| p.respond_to? hook }.
+        collect { |p| [p.name,p.send(hook,*args,&block)] }
+    end
+    #
+    #
+    #
+    attr_reader :path,:name
+    def initialize(path)
+      @name = @path = path
+      class << self
+        private
+        def define_hooks
+          eval File.read(path),nil,path,1
+        end
+      end
+      define_hooks
+    end
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/util/posix.rb

@@ -0,0 +1,137 @@
+# Utility methods for interacting with POSIX objects; mostly user and group
+module Puppet::Util::POSIX
+
+  # This is a list of environment variables that we will set when we want to override the POSIX locale
+  LOCALE_ENV_VARS = ['LANG', 'LC_ALL', 'LC_MESSAGES', 'LANGUAGE',
+                           'LC_COLLATE', 'LC_CTYPE', 'LC_MONETARY', 'LC_NUMERIC', 'LC_TIME']
+
+  # This is a list of user-related environment variables that we will unset when we want to provide a pristine
+  # environment for "exec" runs
+  USER_ENV_VARS = ['HOME', 'USER', 'LOGNAME']
+
+
+
+  # Retrieve a field from a POSIX Etc object.  The id can be either an integer
+  # or a name.  This only works for users and groups.  It's also broken on
+  # some platforms, unfortunately, which is why we fall back to the other
+  # method search_posix_field in the gid and uid methods if a sanity check
+  # fails
+  def get_posix_field(space, field, id)
+    raise Puppet::DevError, "Did not get id from caller" unless id
+
+    if id.is_a?(Integer)
+      if id > Puppet[:maximum_uid].to_i
+        Puppet.err "Tried to get #{field} field for silly id #{id}"
+        return nil
+      end
+      method = methodbyid(space)
+    else
+      method = methodbyname(space)
+    end
+
+    begin
+      return Etc.send(method, id).send(field)
+    rescue NoMethodError, ArgumentError
+      # ignore it; we couldn't find the object
+      return nil
+    end
+  end
+
+  # A degenerate method of retrieving name/id mappings.  The job of this method is
+  # to retrieve all objects of a certain type, search for a specific entry
+  # and then return a given field from that entry.
+  def search_posix_field(type, field, id)
+    idmethod = idfield(type)
+    integer = false
+    if id.is_a?(Integer)
+      integer = true
+      if id > Puppet[:maximum_uid].to_i
+        Puppet.err "Tried to get #{field} field for silly id #{id}"
+        return nil
+      end
+    end
+
+    Etc.send(type) do |object|
+      if integer and object.send(idmethod) == id
+        return object.send(field)
+      elsif object.name == id
+        return object.send(field)
+      end
+    end
+
+    # Apparently the group/passwd methods need to get reset; if we skip
+    # this call, then new users aren't found.
+    case type
+    when :passwd; Etc.send(:endpwent)
+    when :group; Etc.send(:endgrent)
+    end
+    nil
+  end
+
+  # Determine what the field name is for users and groups.
+  def idfield(space)
+    case space.intern
+    when :gr, :group; return :gid
+    when :pw, :user, :passwd; return :uid
+    else
+      raise ArgumentError.new("Can only handle users and groups")
+    end
+  end
+
+  # Determine what the method is to get users and groups by id
+  def methodbyid(space)
+    case space.intern
+    when :gr, :group; return :getgrgid
+    when :pw, :user, :passwd; return :getpwuid
+    else
+      raise ArgumentError.new("Can only handle users and groups")
+    end
+  end
+
+  # Determine what the method is to get users and groups by name
+  def methodbyname(space)
+    case space.intern
+    when :gr, :group; return :getgrnam
+    when :pw, :user, :passwd; return :getpwnam
+    else
+      raise ArgumentError.new("Can only handle users and groups")
+    end
+  end
+
+  # Get the GID
+  def gid(group)
+      get_posix_value(:group, :gid, group)
+  end
+
+  # Get the UID
+  def uid(user)
+      get_posix_value(:passwd, :uid, user)
+  end
+
+  private
+
+  # Get the specified id_field of a given field (user or group), 
+  # whether an ID name is provided
+  def get_posix_value(location, id_field, field)
+    begin
+      field = Integer(field)
+    rescue ArgumentError
+      # pass
+    end
+    if field.is_a?(Integer)
+      return nil unless name = get_posix_field(location, :name, field)
+      id = get_posix_field(location, id_field, name)
+      check_value = id
+    else
+      return nil unless id = get_posix_field(location, id_field, field)
+      name = get_posix_field(location, :name, id)
+      check_value = name
+    end
+    if check_value != field
+      return search_posix_field(location, id_field, field)
+    else
+      return id
+    end
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/util/profiler.rb

@@ -0,0 +1,53 @@
+require 'benchmark'
+
+# A simple profiling callback system.
+#
+# @api public
+module Puppet::Util::Profiler
+  require 'puppet/util/profiler/wall_clock'
+  require 'puppet/util/profiler/object_counts'
+  require 'puppet/util/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 hierachy.
+  #
+  # @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 = nil, &block)
+    @profiler.profile(message, metric_id, &block)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/profiler/aggregate.rb

@@ -0,0 +1,85 @@
+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} ms (#{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
+