puppet 6.11.1-x64-mingw32 → 6.16.0-x64-mingw32

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

@@ -0,0 +1,15 @@
+module Puppet::Util::Package::Version
+  class Gem < ::Gem::Version
+    def self.parse(version)
+      raise ValidationFailure, version unless version.is_a? String
+      raise ValidationFailure, version unless version =~ ANCHORED_VERSION_PATTERN
+      new(version)
+    end
+
+    class ValidationFailure < ArgumentError
+      def initialize(version)
+        super("#{version} is not a valid ruby gem version.")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+module Puppet::Util::Package::Version
+  class Pip
+    include Comparable
+
+    VERSION_PATTERN = "
+      v?
+      (?:
+        (?:(?<epoch>[0-9]+)!)?                              # epoch
+        (?<release>[0-9]+(?:\\.[0-9]+)*)                    # release segment
+        (?<pre>                                             # pre-release
+          [-_\\.]?
+          (?<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+          [-_\\.]?
+          (?<pre_n>[0-9]+)?
+        )?
+        (?<post>                                            # post release
+          (?:-(?<post_n1>[0-9]+))
+          |
+          (?:
+            [-_\\.]?
+            (?<post_l>post|rev|r)
+            [-_\\.]?
+            (?<post_n2>[0-9]+)?
+          )
+        )?
+        (?<dev>                                             # dev release
+          [-_\\.]?
+          (?<dev_l>dev)
+          [-_\\.]?
+          (?<dev_n>[0-9]+)?
+        )?
+      )
+      (?:\\+(?<local>[a-z0-9]+(?:[-_\\.][a-z0-9]+)*))?      # local version
+    ".freeze
+
+    def self.parse(version)
+      raise ValidationFailure, version.to_s unless version.is_a? String
+
+      matched = version.match(Regexp.new(("^\\s*") + VERSION_PATTERN + ("\\s*$"), Regexp::EXTENDED | Regexp::MULTILINE | Regexp::IGNORECASE))
+      raise ValidationFailure, version unless matched
+
+      new(matched)
+    end
+
+    def self.compare(version_a, version_b)
+      version_a = parse(version_a) unless version_a.is_a?(self)
+      version_b = parse(version_b) unless version_b.is_a?(self)
+
+      version_a <=> version_b
+    end
+
+    def to_s
+      parts = []
+
+      parts.push("#{@epoch_data}!")           if @epoch_data && @epoch_data != 0
+      parts.push(@release_data.join("."))     if @release_data
+      parts.push(@pre_data.join)              if @pre_data
+      parts.push(".post#{@post_data[1]}")     if @post_data
+      parts.push(".dev#{@dev_data[1]}")       if @dev_data
+      parts.push("+#{@local_data.join(".")}") if @local_data
+
+      parts.join
+    end
+    alias inspect to_s
+
+    def eql?(other)
+      other.is_a?(self.class) && key.eql?(other.key)
+    end
+    alias == eql?
+
+    def <=>(other)
+      raise ValidationFailure, other.to_s unless other.is_a?(self.class)
+      compare(key, other.key)
+    end
+
+    attr_reader :key
+
+    private
+
+    def initialize(matched)
+      @epoch_data   = matched[:epoch].to_i
+      @release_data = matched[:release].split('.').map(&:to_i)                                       if matched[:release]
+      @pre_data     = parse_letter_version(matched[:pre_l], matched[:pre_n])                         if matched[:pre_l]  || matched[:pre_n]
+      @post_data    = parse_letter_version(matched[:post_l], matched[:post_n1] || matched[:post_n2]) if matched[:post_l] || matched[:post_n1] || matched[:post_n2]
+      @dev_data     = parse_letter_version(matched[:dev_l], matched[:dev_n])                         if matched[:dev_l]  || matched[:dev_n]
+      @local_data   = parse_local_version(matched[:local])                                           if matched[:local]
+
+      @key = compose_key(@epoch_data, @release_data, @pre_data, @post_data, @dev_data, @local_data)
+    end
+
+    def parse_letter_version(letter, number)
+      if letter
+        number = 0 if !number
+        letter.downcase!
+
+        if letter == "alpha"
+          letter = "a"
+        elsif letter == "beta"
+          letter = "b"
+        elsif ["c", "pre", "preview"].include?(letter)
+          letter = "rc"
+        elsif ["rev", "r"].include?(letter)
+          letter = "post"
+        end
+
+        return [letter, number.to_i]
+      end
+
+      ["post", number.to_i] if !letter && number
+    end
+
+    def parse_local_version(local_version)
+      local_version.split(/[\\._-]/).map{|part| part =~ /[0-9]+/ && part !~ /[a-zA-Z]+/ ? part.to_i : part.downcase} if local_version
+    end
+
+    def compose_key(epoch, release, pre, post, dev, local)
+      release_key = release.reverse
+      release_key.each_with_index do |element, index|
+        break unless element == 0
+        release_key.delete_at(index) unless release_key.at(index + 1) != 0
+      end
+      release_key.reverse!
+
+      if !pre && !post && dev
+        pre_key = -Float::INFINITY
+      else
+        pre_key = pre || Float::INFINITY
+      end
+
+      post_key = post || -Float::INFINITY
+
+      dev_key = dev || Float::INFINITY
+
+      if !local
+        local_key = [[-Float::INFINITY, ""]]
+      else
+        local_key = local.map{|i| (i.is_a? Integer) ? [i, ""] : [-Float::INFINITY, i]}
+      end
+
+      [epoch, release_key, pre_key, post_key, dev_key, local_key]
+    end
+
+    def compare(this, other)
+      if (this.is_a? Array) && (other.is_a? Array)
+        this  << -Float::INFINITY if this.length < other.length
+        other << -Float::INFINITY if this.length > other.length
+
+        this.each_with_index do |element, index|
+          return compare(element, other.at(index)) if element != other.at(index)
+        end
+      elsif (this.is_a? Array) && !(other.is_a? Array)
+        raise Puppet::Error, 'Cannot compare #{this} (Array) with #{other} (#{other.class}). Only ±Float::INFINITY accepted.' unless other.abs == Float::INFINITY
+        return other == -Float::INFINITY ? 1 : -1
+      elsif !(this.is_a? Array) && (other.is_a? Array)
+        raise Puppet::Error, 'Cannot compare #{this} (#{this.class}) with #{other} (Array). Only ±Float::INFINITY accepted.' unless this.abs == Float::INFINITY
+        return this == -Float::INFINITY ? -1 : 1
+      end
+      this <=> other
+    end
+
+    class ValidationFailure < ArgumentError
+      def initialize(version)
+        super("#{version} is not a valid python package version. Please refer to https://www.python.org/dev/peps/pep-0440/.")
+      end
+    end
+  end
+end

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