openvox 9.0.0.pre.rc1-universal-darwin

data/lib/puppet/util/reference.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util/instance_loader'
+require 'fileutils'
+
+# Manage Reference Documentation.
+class Puppet::Util::Reference
+  include Puppet::Util
+  include Puppet::Util::Docs
+
+  extend Puppet::Util::InstanceLoader
+
+  instance_load(:reference, 'puppet/reference')
+
+  def self.modes
+    %w[text]
+  end
+
+  def self.newreference(name, options = {}, &block)
+    ref = new(name, **options, &block)
+    instance_hash(:reference)[name.intern] = ref
+
+    ref
+  end
+
+  def self.page(*sections)
+    depth = 4
+    # Use the minimum depth
+    sections.each do |name|
+      section = reference(name) or raise _("Could not find section %{name}") % { name: name }
+      depth = section.depth if section.depth < depth
+    end
+  end
+
+  def self.references(environment)
+    instance_loader(:reference).loadall(environment)
+    loaded_instances(:reference).sort_by(&:to_s)
+  end
+
+  attr_accessor :page, :depth, :header, :title, :dynamic
+  attr_writer :doc
+
+  def doc
+    if defined?(@doc)
+      "#{@name} - #{@doc}"
+    else
+      @title
+    end
+  end
+
+  def dynamic?
+    dynamic
+  end
+
+  def initialize(name, title: nil, depth: nil, dynamic: nil, doc: nil, &block)
+    @name = name
+    @title = title
+    @depth = depth
+    @dynamic = dynamic
+    @doc = doc
+
+    meta_def(:generate, &block)
+
+    # Now handle the defaults
+    @title ||= _("%{name} Reference") % { name: @name.to_s.capitalize }
+    @page ||= @title.gsub(/\s+/, '')
+    @depth ||= 2
+    @header ||= ""
+  end
+
+  # Indent every line in the chunk except those which begin with '..'.
+  def indent(text, tab)
+    text.gsub(/(^|\A)/, tab).gsub(/^ +\.\./, "..")
+  end
+
+  def option(name, value)
+    ":#{name.to_s.capitalize}: #{value}\n"
+  end
+
+  def text
+    puts output
+  end
+
+  def to_markdown(withcontents = true)
+    # First the header
+    text = markdown_header(@title, 1)
+
+    text << @header
+
+    text << generate
+
+    text
+  end
+end

data/lib/puppet/util/resource_template.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util'
+require_relative '../../puppet/util/logging'
+require 'erb'
+
+# A template wrapper that evaluates a template in the
+# context of a resource, allowing the resource attributes
+# to be looked up from within the template.
+#  This provides functionality essentially equivalent to
+# the language's template() function.  You pass your file
+# path and the resource you want to use into the initialization
+# method, then call result on the instance, and you get back
+# a chunk of text.
+#  The resource's parameters are available as instance variables
+# (as opposed to the language, where we use a method_missing trick).
+#  For example, say you have a resource that generates a file.  You would
+# need to implement the following style of `generate` method:
+#
+#   def generate
+#       template = Puppet::Util::ResourceTemplate.new("/path/to/template", self)
+#
+#       return Puppet::Type.type(:file).new :path => "/my/file",
+#           :content => template.evaluate
+#   end
+#
+# This generated file gets added to the catalog (which is what `generate` does),
+# and its content is the result of the template.  You need to use instance
+# variables in your template, so if your template just needs to have the name
+# of the generating resource, it would just have:
+#
+#   <%= @name %>
+#
+# Since the ResourceTemplate class sets as instance variables all of the resource's
+# parameters.
+#
+# Note that this example uses the generating resource as its source of
+# parameters, which is generally most useful, since it allows you to configure
+# the generated resource via the generating resource.
+class Puppet::Util::ResourceTemplate
+  include Puppet::Util::Logging
+
+  def evaluate
+    set_resource_variables
+    Puppet::Util.create_erb(Puppet::FileSystem.read(@file, :encoding => 'utf-8')).result(binding)
+  end
+
+  def initialize(file, resource)
+    raise ArgumentError, _("Template %{file} does not exist") % { file: file } unless Puppet::FileSystem.exist?(file)
+
+    @file = file
+    @resource = resource
+  end
+
+  private
+
+  def set_resource_variables
+    @resource.to_hash.each do |param, value|
+      var = "@#{param}"
+      instance_variable_set(var, value)
+    end
+  end
+end

data/lib/puppet/util/retry_action.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Puppet::Util::RetryAction
+  class RetryException < Exception; end # rubocop:disable Lint/InheritException
+  class RetryException::NoBlockGiven < RetryException; end
+  class RetryException::NoRetriesGiven < RetryException; end
+  class RetryException::RetriesExceeded < RetryException; end
+
+  # Execute the supplied block retrying with exponential backoff.
+  #
+  # @param [Hash] options the retry options
+  # @option options [Integer] :retries Maximum number of times to retry.
+  # @option options [Array<Exception>] :retry_exceptions ([StandardError]) Optional array of exceptions that are allowed to be retried.
+  # @yield The block to be executed.
+  def self.retry_action(options = {})
+    # Retry actions for a specified amount of time. This method will allow the final
+    # retry to complete even if that extends beyond the timeout period.
+    unless block_given?
+      raise RetryException::NoBlockGiven
+    end
+
+    retries = options[:retries]
+    if retries.nil?
+      raise RetryException::NoRetriesGiven
+    end
+
+    retry_exceptions = options[:retry_exceptions] || [StandardError]
+    failures = 0
+    begin
+      yield
+    rescue *retry_exceptions => e
+      if failures >= retries
+        raise RetryException::RetriesExceeded, _("%{retries} exceeded") % { retries: retries }, e.backtrace
+      end
+
+      Puppet.info(_("Caught exception %{klass}:%{error} retrying") % { klass: e.class, error: e })
+
+      failures += 1
+
+      # Increase the amount of time that we sleep after every
+      # failed retry attempt.
+      sleep(((2**failures) - 1) * 0.1)
+
+      retry
+    end
+  end
+end

data/lib/puppet/util/rpm_compare.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'English'
+module Puppet::Util::RpmCompare
+  ARCH_LIST = %w[
+    noarch i386 i686 ppc ppc64 armv3l armv4b armv4l armv4tl armv5tel
+    armv5tejl armv6l armv7l m68kmint s390 s390x ia64 x86_64 sh3 sh4
+  ].freeze
+
+  ARCH_REGEX = Regexp.new(ARCH_LIST.map { |arch| "\\.#{arch}" }.join('|'))
+
+  # This is an attempt at implementing RPM's
+  # lib/rpmvercmp.c rpmvercmp(a, b) in Ruby.
+  #
+  # Some of the things in here look REALLY
+  # UGLY and/or arbitrary. Our goal is to
+  # match how RPM compares versions, quirks
+  # and all.
+  #
+  # I've kept a lot of C-like string processing
+  # in an effort to keep this as identical to RPM
+  # as possible.
+  #
+  # returns 1 if str1 is newer than str2,
+  #         0 if they are identical
+  #        -1 if str1 is older than str2
+  def rpmvercmp(str1, str2)
+    return 0 if str1 == str2
+
+    front_strip_re = /^[^A-Za-z0-9~]+/
+
+    while str1.length > 0 or str2.length > 0
+      # trim anything that's in front_strip_re and != '~' off the beginning of each string
+      str1 = str1.gsub(front_strip_re, '')
+      str2 = str2.gsub(front_strip_re, '')
+
+      # "handle the tilde separator, it sorts before everything else"
+      if str1 =~ /^~/ && str2 =~ /^~/
+        # if they both have ~, strip it
+        str1 = str1[1..]
+        str2 = str2[1..]
+        next
+      elsif str1 =~ /^~/
+        return -1
+      elsif str2 =~ /^~/
+        return 1
+      end
+
+      break if str1.length == 0 or str2.length == 0
+
+      # "grab first completely alpha or completely numeric segment"
+      isnum = false
+      # if the first char of str1 is a digit, grab the chunk of continuous digits from each string
+      if str1 =~ /^[0-9]+/
+        if str1 =~ /^[0-9]+/
+          segment1 = $LAST_MATCH_INFO.to_s
+          str1 = $LAST_MATCH_INFO.post_match
+        else
+          segment1 = ''
+        end
+        if str2 =~ /^[0-9]+/
+          segment2 = $LAST_MATCH_INFO.to_s
+          str2 = $LAST_MATCH_INFO.post_match
+        else
+          segment2 = ''
+        end
+        isnum = true
+      # else grab the chunk of continuous alphas from each string (which may be '')
+      else
+        if str1 =~ /^[A-Za-z]+/
+          segment1 = $LAST_MATCH_INFO.to_s
+          str1 = $LAST_MATCH_INFO.post_match
+        else
+          segment1 = ''
+        end
+        if str2 =~ /^[A-Za-z]+/
+          segment2 = $LAST_MATCH_INFO.to_s
+          str2 = $LAST_MATCH_INFO.post_match
+        else
+          segment2 = ''
+        end
+      end
+
+      # if the segments we just grabbed from the strings are different types (i.e. one numeric one alpha),
+      # where alpha also includes ''; "numeric segments are always newer than alpha segments"
+      if segment2.length == 0
+        return 1 if isnum
+
+        return -1
+      end
+
+      if isnum
+        # "throw away any leading zeros - it's a number, right?"
+        segment1 = segment1.gsub(/^0+/, '')
+        segment2 = segment2.gsub(/^0+/, '')
+        # "whichever number has more digits wins"
+        return 1 if segment1.length > segment2.length
+        return -1 if segment1.length < segment2.length
+      end
+
+      # "strcmp will return which one is greater - even if the two segments are alpha
+      # or if they are numeric. don't return if they are equal because there might
+      # be more segments to compare"
+      rc = segment1 <=> segment2
+      return rc if rc != 0
+    end # end while loop
+
+    # if we haven't returned anything yet, "whichever version still has characters left over wins"
+    return 1 if str1.length > str2.length
+    return -1 if str1.length < str2.length
+
+    0
+  end
+
+  # parse a rpm "version" specification
+  # this re-implements rpm's
+  # rpmUtils.miscutils.stringToVersion() in ruby
+  def rpm_parse_evr(full_version)
+    epoch_index = full_version.index(':')
+    if epoch_index
+      epoch = full_version[0, epoch_index]
+      full_version = full_version[epoch_index + 1, full_version.length]
+    else
+      epoch = nil
+    end
+    begin
+      epoch = String(Integer(epoch))
+    rescue
+      # If there are non-digits in the epoch field, default to nil
+      epoch = nil
+    end
+    release_index = full_version.index('-')
+    if release_index
+      version = full_version[0, release_index]
+      release = full_version[release_index + 1, full_version.length]
+      arch = release.scan(ARCH_REGEX)[0]
+      if arch
+        architecture = arch.delete('.')
+        release.gsub!(ARCH_REGEX, '')
+      end
+    else
+      version = full_version
+      release = nil
+    end
+    { :epoch => epoch, :version => version, :release => release, :arch => architecture }
+  end
+
+  # this method is a native implementation of the
+  # compare_values function in rpm's python bindings,
+  # found in python/header-py.c, as used by rpm.
+  def compare_values(s1, s2)
+    return 0 if s1.nil? && s2.nil?
+    return 1 if !s1.nil? && s2.nil?
+    return -1 if s1.nil? && !s2.nil?
+
+    rpmvercmp(s1, s2)
+  end
+
+  # how rpm compares two package versions:
+  # rpmUtils.miscutils.compareEVR(), which massages data types and then calls
+  # rpm.labelCompare(), found in rpm.git/python/header-py.c, which
+  # sets epoch to 0 if null, then compares epoch, then ver, then rel
+  # using compare_values() and returns the first non-0 result, else 0.
+  # This function combines the logic of compareEVR() and labelCompare().
+  #
+  # "version_should" can be v, v-r, or e:v-r.
+  # "version_is" will always be at least v-r, can be e:v-r
+  #
+  # return 1: a is newer than b
+  #        0: a and b are the same version
+  #       -1: b is newer than a
+  def rpm_compare_evr(should, is)
+    # pass on to rpm labelCompare
+    should_hash = rpm_parse_evr(should)
+    is_hash = rpm_parse_evr(is)
+
+    unless should_hash[:epoch].nil?
+      rc = compare_values(should_hash[:epoch], is_hash[:epoch])
+      return rc unless rc == 0
+    end
+
+    rc = compare_values(should_hash[:version], is_hash[:version])
+    return rc unless rc == 0
+
+    # here is our special case, PUP-1244.
+    # if should_hash[:release] is nil (not specified by the user),
+    # and comparisons up to here are equal, return equal. We need to
+    # evaluate to whatever level of detail the user specified, so we
+    # don't end up upgrading or *downgrading* when not intended.
+    #
+    # This should NOT be triggered if we're trying to ensure latest.
+    return 0 if should_hash[:release].nil?
+
+    compare_values(should_hash[:release], is_hash[:release])
+  end
+end

data/lib/puppet/util/rubygems.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util'
+
+module Puppet::Util::RubyGems
+  # Base/factory class for rubygems source. These classes introspec into
+  # rubygems to in order to list where the rubygems system will look for files
+  # to load.
+  class Source
+    class << self
+      # @api private
+      def has_rubygems?
+        # Gems are not actually available when Bundler is loaded, even
+        # though the Gem constant is defined. This is because Bundler
+        # loads in rubygems, but then removes the custom require that
+        # rubygems installs. So when Bundler is around we have to act
+        # as though rubygems is not, e.g. we shouldn't be able to load
+        # a gem that Bundler doesn't want us to see.
+        defined? ::Gem and !defined? ::Bundler
+      end
+
+      # @api private
+      def source
+        if has_rubygems?
+          Gems18Source
+        else
+          NoGemsSource
+        end
+      end
+
+      def new(*args)
+        object = source.allocate
+        object.send(:initialize, *args)
+        object
+      end
+    end
+  end
+
+  # For RubyGems >= 1.8.0
+  # @api private
+  class Gems18Source < Source
+    def directories
+      # `require 'mygem'` will consider and potentially load
+      # prerelease gems, so we need to match that behavior.
+      #
+      # Just load the stub which points to the gem path, and
+      # delay loading the full specification until if/when the
+      # gem is required.
+      Gem::Specification.stubs.collect do |spec|
+        File.join(spec.full_gem_path, 'lib')
+      end
+    end
+
+    def clear_paths
+      Gem.clear_paths
+    end
+  end
+
+  # @api private
+  class NoGemsSource < Source
+    def directories
+      []
+    end
+
+    def clear_paths; end
+  end
+end

data/lib/puppet/util/run_mode.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'etc'
+
+module Puppet
+  module Util
+    class RunMode
+      def initialize(name)
+        @name = name.to_sym
+      end
+
+      attr_reader :name
+
+      def self.[](name)
+        @run_modes ||= {}
+        if Puppet::Util::Platform.windows?
+          @run_modes[name] ||= WindowsRunMode.new(name)
+        else
+          @run_modes[name] ||= UnixRunMode.new(name)
+        end
+      end
+
+      def server?
+        name == :master || name == :server
+      end
+
+      def master?
+        name == :master || name == :server
+      end
+
+      def agent?
+        name == :agent
+      end
+
+      def user?
+        name == :user
+      end
+
+      def run_dir
+        RunMode[name].run_dir
+      end
+
+      def log_dir
+        RunMode[name].log_dir
+      end
+
+      private
+
+      ##
+      # select the system or the user directory depending on the context of
+      # this process.  The most common use is determining filesystem path
+      # values for confdir and vardir.  The intended semantics are:
+      # {https://projects.puppetlabs.com/issues/16637 #16637} for Puppet 3.x
+      #
+      # @todo this code duplicates {Puppet::Settings#which\_configuration\_file}
+      #   as described in {https://projects.puppetlabs.com/issues/16637 #16637}
+      def which_dir(system, user)
+        if Puppet.features.root?
+          File.expand_path(system)
+        else
+          File.expand_path(user)
+        end
+      end
+    end
+
+    class UnixRunMode < RunMode
+      def conf_dir
+        which_dir("/etc/puppetlabs/puppet", "~/.puppetlabs/etc/puppet")
+      end
+
+      def code_dir
+        which_dir("/etc/puppetlabs/code", "~/.puppetlabs/etc/code")
+      end
+
+      def var_dir
+        which_dir("/opt/puppetlabs/puppet/cache", "~/.puppetlabs/opt/puppet/cache")
+      end
+
+      def public_dir
+        which_dir("/opt/puppetlabs/puppet/public", "~/.puppetlabs/opt/puppet/public")
+      end
+
+      def run_dir
+        ENV.fetch('RUNTIME_DIRECTORY') { which_dir("/var/run/puppetlabs", "~/.puppetlabs/var/run") }
+      end
+
+      def log_dir
+        which_dir("/var/log/puppetlabs/puppet", "~/.puppetlabs/var/log")
+      end
+
+      def pkg_config_path
+        '/opt/puppetlabs/puppet/lib/pkgconfig'
+      end
+
+      def gem_cmd
+        '/opt/puppetlabs/puppet/bin/gem'
+      end
+
+      def common_module_dir
+        '/opt/puppetlabs/puppet/modules'
+      end
+
+      def vendor_module_dir
+        '/opt/puppetlabs/puppet/vendor_modules'
+      end
+    end
+
+    class WindowsRunMode < RunMode
+      def conf_dir
+        which_dir(File.join(windows_common_base("puppet/etc")), "~/.puppetlabs/etc/puppet")
+      end
+
+      def code_dir
+        which_dir(File.join(windows_common_base("code")), "~/.puppetlabs/etc/code")
+      end
+
+      def var_dir
+        which_dir(File.join(windows_common_base("puppet/cache")), "~/.puppetlabs/opt/puppet/cache")
+      end
+
+      def public_dir
+        which_dir(File.join(windows_common_base("puppet/public")), "~/.puppetlabs/opt/puppet/public")
+      end
+
+      def run_dir
+        which_dir(File.join(windows_common_base("puppet/var/run")), "~/.puppetlabs/var/run")
+      end
+
+      def log_dir
+        which_dir(File.join(windows_common_base("puppet/var/log")), "~/.puppetlabs/var/log")
+      end
+
+      def pkg_config_path
+        nil
+      end
+
+      def gem_cmd
+        if (puppet_dir = ENV.fetch('PUPPET_DIR', nil))
+          File.join(puppet_dir.to_s, 'bin', 'gem.bat')
+        else
+          File.join(Gem.default_bindir, 'gem.bat')
+        end
+      end
+
+      def common_module_dir
+        "#{installdir}/puppet/modules" if installdir
+      end
+
+      def vendor_module_dir
+        "#{installdir}\\puppet\\vendor_modules" if installdir
+      end
+
+      private
+
+      def installdir
+        ENV.fetch('FACTER_env_windows_installdir', nil)
+      end
+
+      def windows_common_base(*extra)
+        [ENV.fetch('ALLUSERSPROFILE', nil), "PuppetLabs"] + extra
+      end
+    end
+  end
+end