puppet 6.12.0-x64-mingw32 → 6.17.0-x64-mingw32

data/lib/puppet/util/package/version/range.rb

@@ -0,0 +1,53 @@
+require 'puppet/util/package/version/range/lt'
+require 'puppet/util/package/version/range/lt_eq'
+require 'puppet/util/package/version/range/gt'
+require 'puppet/util/package/version/range/gt_eq'
+require 'puppet/util/package/version/range/eq'
+require 'puppet/util/package/version/range/min_max'
+
+module Puppet::Util::Package::Version
+  class Range
+    class ValidationFailure < ArgumentError; end
+    # Parses a version range string into a comparable {Range} instance.
+    #
+    # Currently parsed version range string may take any of the following
+    # forms:
+    #
+    # * Regular Version strings
+    #   * ex. `"1.0.0"`, `"1.2.3-pre"`
+    # * Inequalities
+    #   * ex. `">1.0.0"`, `"<3.2.0"`, `">=4.0.0"`
+    # * Range Intersections (min is always first)
+    #   * ex. `">1.0.0 <=2.3.0"`
+    #
+    RANGE_SPLIT = /\s+/
+    FULL_REGEX = /\A((?:[<>=])*)(.+)\Z/
+
+    # @param range_string [String] the version range string to parse
+    # @param version_class [Version] a version class implementing comparison operators and parse method
+    # @return [Range] a new {Range} instance
+    # @api public
+    def self.parse(range_string, version_class)
+      raise ValidationFailure, "Unable to parse '#{range_string}' as a string" unless range_string.is_a?(String)
+      simples = range_string.split(RANGE_SPLIT).map do |simple|
+        match, operator, version = *simple.match(FULL_REGEX)
+        raise ValidationFailure, "Unable to parse '#{simple}' as a version range identifier" unless match
+        case operator
+        when '>'
+          Gt.new(version_class::parse(version))
+        when '>='
+          GtEq.new(version_class::parse(version))
+        when '<'
+          Lt.new(version_class::parse(version))
+        when '<='
+          LtEq.new(version_class::parse(version))
+        when ''
+          Eq.new(version_class::parse(version))
+        else
+          raise ValidationFailure, "Operator '#{operator}' is not implemented"
+        end
+      end
+      simples.size == 1 ? simples[0] : MinMax.new(simples[0], simples[1])
+    end
+  end
+end

data/lib/puppet/util/package/version/range/eq.rb

@@ -0,0 +1,14 @@
+require 'puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class Eq < Simple
+      def to_s
+        "#{@version}"
+      end
+      def include?(version)
+        version == @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/gt.rb

@@ -0,0 +1,14 @@
+require 'puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class Gt < Simple
+      def to_s
+        ">#{@version}"
+      end
+      def include?(version)
+        version > @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/gt_eq.rb

@@ -0,0 +1,14 @@
+require 'puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class GtEq < Simple
+      def to_s
+        ">=#{@version}"
+      end
+      def include?(version)
+        version >= @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/lt.rb

@@ -0,0 +1,14 @@
+require 'puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class Lt< Simple
+      def to_s
+        "<#{@version}"
+      end
+      def include?(version)
+        version < @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/lt_eq.rb

@@ -0,0 +1,14 @@
+require 'puppet/util/package/version/range/simple'
+
+module Puppet::Util::Package::Version
+  class Range
+    class LtEq < Simple
+      def to_s
+        "<=#{@version}"
+      end
+      def include?(version)
+        version <= @version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/min_max.rb

@@ -0,0 +1,21 @@
+require 'puppet/util/package/version/range'
+
+module Puppet::Util::Package::Version
+  class Range
+    class MinMax
+      def initialize(min, max)
+        @min = min
+        @max = max
+      end
+      def to_s
+        "#{@min} #{@max}"
+      end
+      def to_gem_version
+        "#{@min}, #{@max}"
+      end
+      def include?(version)
+        @min.include?(version) && @max.include?(version)
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/range/simple.rb

@@ -0,0 +1,11 @@
+require 'puppet/util/package/version/range'
+
+module Puppet::Util::Package::Version
+  class Range
+    class Simple
+      def initialize(version)
+        @version = version
+      end
+    end
+  end
+end

data/lib/puppet/util/package/version/rpm.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+require 'puppet/util/rpm_compare'
+
+module Puppet::Util::Package::Version
+  class Rpm < Numeric
+    # provides Rpm parsing and comparison
+    extend Puppet::Util::RpmCompare
+    include Puppet::Util::RpmCompare
+    include Comparable
+
+    class ValidationFailure < ArgumentError; end
+
+    attr_reader :epoch, :version, :release, :arch
+
+    def self.parse(ver)
+      raise ValidationFailure unless ver.is_a?(String)
+      version = rpm_parse_evr(ver)
+      new(version[:epoch], version[:version], version[:release], version[:arch]).freeze
+    end
+
+    def to_s
+      version_found = ''
+      version_found += "#{@epoch}:"   if @epoch
+      version_found += @version
+      version_found += "-#{@release}" if @release
+      version_found
+    end
+    alias inspect to_s
+
+    def eql?(other)
+      other.is_a?(self.class) &&
+        @epoch.eql?(other.epoch) &&
+        @version.eql?(other.version) &&
+        @release.eql?(other.release) &&
+        @arch.eql?(other.arch)
+    end
+    alias == eql?
+
+    def <=>(other)
+      raise ArgumentError, _("Cannot compare, as %{other} is not a Rpm Version") % { other: other } unless other.is_a?(self.class)
+
+      rpm_compareEVR(self.to_s, other.to_s)
+    end
+
+    private
+
+    # overwrite rpm_compareEVR to treat no epoch as zero epoch
+    # in order to compare version correctly
+    #
+    # returns 1 if a is newer than b,
+    #         0 if they are identical
+    #        -1 if a is older than b
+    def rpm_compareEVR(a, b)
+      a_hash = rpm_parse_evr(a)
+      b_hash = rpm_parse_evr(b)
+
+      a_hash[:epoch] ||= '0'
+      b_hash[:epoch] ||= '0'
+
+      rc = compare_values(a_hash[:epoch], b_hash[:epoch])
+      return rc unless rc == 0
+
+      super(a, b)
+    end
+
+    def initialize(epoch, version, release, arch)
+      @epoch   = epoch
+      @version = version
+      @release = release
+      @arch    = arch
+    end
+  end
+end

data/lib/puppet/util/pidlock.rb

@@ -43,8 +43,23 @@ class Puppet::Util::Pidlock
     @lockfile.file_path
   end
 
+  private
+
+  def ps_argument_for_current_kernel
+    case Facter.value(:kernel)
+      when "Linux"
+        "-eq"
+      when "AIX"
+        "-T"
+      else
+        "-p"
+    end
+  end
+
   def clear_if_stale
-    return @lockfile.unlock if lock_pid.nil?
+    pid = lock_pid
+    return @lockfile.unlock if pid == nil
+    return if Process.pid == pid
 
     errors = [Errno::ESRCH]
     # Win32::Process now throws SystemCallError. Since this could be
@@ -52,25 +67,36 @@ class Puppet::Util::Pidlock
     errors << SystemCallError if Puppet::Util::Platform.windows?
 
     begin
-      Process.kill(0, lock_pid)
+      Process.kill(0, pid)
     rescue *errors
       return @lockfile.unlock
     end
 
     # Ensure the process associated with this pid is our process. If
-    # not, we can unlock the lockfile. For now this is only done on
-    # POSIX and Windows platforms (PUP-9247).
+    # not, we can unlock the lockfile. CLI arguments used for identifying
+    # on POSIX depend on the os and sometimes even version.
     if Puppet.features.posix?
-      procname = Puppet::Util::Execution.execute(["ps", "-p", lock_pid, "-o", "comm="]).strip
-      args     = Puppet::Util::Execution.execute(["ps", "-p", lock_pid, "-o", "args="]).strip
+      ps_argument = ps_argument_for_current_kernel
+
+      # Check, obtain and use the right ps argument
+      begin
+        procname = Puppet::Util::Execution.execute(["ps", ps_argument, pid, "-o", "comm="]).strip
+      rescue Puppet::ExecutionFailure
+        ps_argument = "-p"
+        procname = Puppet::Util::Execution.execute(["ps", ps_argument, pid, "-o", "comm="]).strip
+      end
+
+      args = Puppet::Util::Execution.execute(["ps", ps_argument, pid, "-o", "args="]).strip
       @lockfile.unlock unless procname =~ /ruby/ && args =~ /puppet/ || procname =~ /puppet(-.*)?$/
     elsif Puppet.features.microsoft_windows?
       # On Windows, we're checking if the filesystem path name of the running
       # process is our vendored ruby:
-      exe_path = Puppet::Util::Windows::Process::get_process_image_name_by_pid(lock_pid)
-      @lockfile.unlock unless exe_path =~ /\\bin\\ruby.exe$/
+      begin
+        exe_path = Puppet::Util::Windows::Process::get_process_image_name_by_pid(pid)
+        @lockfile.unlock unless exe_path =~ /\\bin\\ruby.exe$/
+      rescue Puppet::Util::Windows::Error => e
+        Puppet.debug("Failed to read pidfile #{file_path}: #{e.message}")
+      end
     end
   end
-  private :clear_if_stale
-
 end

data/lib/puppet/util/platform.rb

@@ -14,6 +14,11 @@ module Puppet
       end
       module_function :windows?
 
+      def solaris?
+        RUBY_PLATFORM.include?('solaris')
+      end
+      module_function :solaris?
+
       def default_paths
         return [] if windows?
 

data/lib/puppet/util/plist.rb

@@ -56,6 +56,12 @@ module Puppet::Util::Plist
     # Read plist text using the CFPropertyList gem.
     def parse_plist(plist_data, file_path = '')
       bad_xml_doctype = /^.*<!DOCTYPE plist PUBLIC -\/\/Apple Computer.*$/
+      # Depending on where parse_plist is called from, plist_data can be either XML or binary.
+      # If we get XML, make sure ruby knows it's UTF-8 so we avoid invalid byte sequence errors.
+      if plist_data.include?('encoding="UTF-8"') && plist_data.encoding != Encoding::UTF_8
+        plist_data.force_encoding(Encoding::UTF_8)
+      end
+
       begin
         if plist_data =~ bad_xml_doctype
           plist_data.gsub!( bad_xml_doctype, plist_xml_doctype )

data/lib/puppet/util/provider_features.rb

@@ -62,7 +62,7 @@ module Puppet::Util::ProviderFeatures
     @features ||= {}
     raise Puppet::DevError, _("Feature %{name} is already defined") % { name: name } if @features.include?(name)
     begin
-      obj = ProviderFeature.new(name, docs, hash)
+      obj = ProviderFeature.new(name, docs, **hash)
       @features[obj.name] = obj
     rescue ArgumentError => detail
       error = ArgumentError.new(

data/lib/puppet/util/reference.rb

@@ -15,7 +15,7 @@ class Puppet::Util::Reference
   end
 
   def self.newreference(name, options = {}, &block)
-    ref = self.new(name, options, &block)
+    ref = self.new(name, **options, &block)
     instance_hash(:reference)[name.intern] = ref
 
     ref

data/lib/puppet/util/rpm_compare.rb

@@ -0,0 +1,193 @@
+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.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..-1]
+        str2 = str2[1..-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 = $~.to_s
+          str1 = $~.post_match
+        else
+          segment1 = ''
+        end
+        if str2 =~ /^[0-9]+/
+          segment2 = $~.to_s
+          str2 = $~.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 = $~.to_s
+          str1 = $~.post_match
+        else
+          segment1 = ''
+        end
+        if str2 =~ /^[A-Za-z]+/
+          segment2 = $~.to_s
+          str2 = $~.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
+    return { :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 ( not s1.nil? ) && s2.nil?
+    return -1 if s1.nil? && (not s2.nil?)
+    return 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_compareEVR(should, is)
+    # pass on to rpm labelCompare
+    should_hash = rpm_parse_evr(should)
+    is_hash = rpm_parse_evr(is)
+
+    if !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?
+
+    rc = compare_values(should_hash[:release], is_hash[:release])
+
+    return rc
+  end
+end