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

data/lib/puppet/util/at_fork.rb

@@ -13,7 +13,7 @@ require 'puppet'
 #   service.
 module Puppet::Util::AtFork
   @handler_class = loop do
-    if Facter.value(:operatingsystem) == 'Solaris'
+    if Puppet::Util::Platform.solaris?
       begin
         require 'puppet/util/at_fork/solaris'
         # using break to return a value from the loop block

data/lib/puppet/util/autoload.rb

@@ -2,6 +2,7 @@ require 'pathname'
 require 'puppet/util/rubygems'
 require 'puppet/util/warnings'
 require 'puppet/pops/adaptable'
+require 'puppet/concurrent/synchronized'
 
 # An adapter that ties the module_directories cache to the environment where the modules are parsed. This
 # adapter ensures that the life-cycle of this cache doesn't exceed  the life-cycle of the environment.
@@ -13,6 +14,9 @@ end
 
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
+  include Puppet::Concurrent::Synchronized
+  extend Puppet::Concurrent::Synchronized
+
   @loaded = {}
 
   class << self
@@ -124,19 +128,6 @@ class Puppet::Util::Autoload
       end.directories
     end
 
-    # @api private
-    def vendored_modules
-      dir = Puppet[:vendormoduledir]
-      if dir && File.directory?(dir)
-        Dir.entries(dir)
-          .reject { |f| f =~ /^\./ }
-          .collect { |f| File.join(dir, f, "lib") }
-          .find_all { |d| FileTest.directory?(d) }
-      else
-        []
-      end
-    end
-
     # @api private
     def gem_directories
       gem_source.directories
@@ -164,11 +155,6 @@ class Puppet::Util::Autoload
       # "app_defaults_initialized?" method on the main puppet Settings object.
       # --cprice 2012-03-16
       if Puppet.settings.app_defaults_initialized?
-        unless @initialized
-          $LOAD_PATH.unshift(Puppet[:libdir])
-          $LOAD_PATH.concat(vendored_modules)
-          @initialized = true
-        end
         gem_directories + module_directories(env) + $LOAD_PATH
       else
         gem_directories + $LOAD_PATH

data/lib/puppet/util/checksums.rb

@@ -7,11 +7,26 @@ require 'time'
 module Puppet::Util::Checksums
   module_function
 
+  KNOWN_CHECKSUMS = [
+    :sha256, :sha256lite,
+    :md5, :md5lite,
+    :sha1, :sha1lite,
+    :sha512,
+    :sha384,
+    :sha224,
+    :mtime, :ctime, :none
+  ].freeze
+
   # It's not a good idea to use some of these in some contexts: for example, I
   # wouldn't try bucketing a file using the :none checksum type.
   def known_checksum_types
-    [:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, 
-      :mtime, :ctime, :none]
+    KNOWN_CHECKSUMS
+  end
+
+  def valid_checksum?(type, value)
+    !!send("#{type}?", value)
+  rescue NoMethodError
+    false
   end
 
   class FakeChecksum
@@ -223,7 +238,7 @@ module Puppet::Util::Checksums
 
   # Return the :mtime timestamp of a file.
   def mtime_file(filename)
-    Puppet::FileSystem.stat(filename).send(:mtime)
+    Puppet::FileSystem.stat(filename).mtime
   end
 
   # by definition this doesn't exist
@@ -293,7 +308,7 @@ module Puppet::Util::Checksums
 
   # Return the :ctime of a file.
   def ctime_file(filename)
-    Puppet::FileSystem.stat(filename).send(:ctime)
+    Puppet::FileSystem.stat(filename).ctime
   end
 
   def ctime_stream(&block)

data/lib/puppet/util/fileparsing.rb

@@ -300,7 +300,7 @@ module Puppet::Util::FileParsing
   def record_line(name, options, &block)
     raise ArgumentError, _("Must include a list of fields") unless options.include?(:fields)
 
-    record = FileRecord.new(:record, options, &block)
+    record = FileRecord.new(:record, **options, &block)
     record.name = name.intern
 
     new_line_type(record)
@@ -315,7 +315,7 @@ module Puppet::Util::FileParsing
   def text_line(name, options, &block)
     raise ArgumentError, _("You must provide a :match regex for text lines") unless options.include?(:match)
 
-    record = FileRecord.new(:text, options, &block)
+    record = FileRecord.new(:text, **options, &block)
     record.name = name.intern
 
     new_line_type(record)

data/lib/puppet/util/instance_loader.rb

@@ -1,5 +1,6 @@
 require 'puppet/util/autoload'
 require 'puppet/util'
+require 'puppet/concurrent/lock'
 
 # A module that can easily autoload things for us.  Uses an instance
 # of Puppet::Util::Autoload
@@ -18,6 +19,7 @@ module Puppet::Util::InstanceLoader
     type = type.intern
     @instances[type] = {}
     @autoloaders[type] = Puppet::Util::Autoload.new(self, path)
+    @instance_loader_lock = Puppet::Concurrent::Lock.new
 
     # Now define our new simple methods
     unless respond_to?(type)
@@ -44,19 +46,21 @@ module Puppet::Util::InstanceLoader
 
   # Retrieve an already-loaded instance, or attempt to load our instance.
   def loaded_instance(type, name)
-    name = name.intern
-    instances = instance_hash(type)
-    return nil unless instances
-    unless instances.include? name
-      if instance_loader(type).load(name, Puppet.lookup(:current_environment))
-        unless instances.include? name
-          Puppet.warning(_("Loaded %{type} file for %{name} but %{type} was not defined") % { type: type, name: name })
+    @instance_loader_lock.synchronize do
+      name = name.intern
+      instances = instance_hash(type)
+      return nil unless instances
+      unless instances.include? name
+        if instance_loader(type).load(name, Puppet.lookup(:current_environment))
+          unless instances.include? name
+            Puppet.warning(_("Loaded %{type} file for %{name} but %{type} was not defined") % { type: type, name: name })
+            return nil
+          end
+        else
           return nil
         end
-      else
-        return nil
       end
+      instances[name]
     end
-    instances[name]
   end
 end

data/lib/puppet/util/log/destinations.rb

@@ -47,7 +47,7 @@ Puppet::Util::Log.newdesttype :file do
   require 'fileutils'
 
   def self.match?(obj)
-    Puppet::Util.absolute_path?(obj)
+    obj.is_a?(String) && Puppet::Util.absolute_path?(obj)
   end
 
   def close
@@ -91,18 +91,9 @@ Puppet::Util::Log.newdesttype :file do
       end
     end
 
-    file = File.open(path,  File::WRONLY|File::CREAT|File::APPEND)
+    file = File.open(path, File::WRONLY|File::CREAT|File::APPEND)
     file.puts('[') if need_array_start
 
-    # Give ownership to the user and group puppet will run as
-    if Puppet.features.root? && !Puppet::Util::Platform.windows? && !file_exists
-      begin
-        FileUtils.chown(Puppet[:user], Puppet[:group], path)
-      rescue ArgumentError, Errno::EPERM
-        Puppet.err _("Unable to set ownership to %{user}:%{group} for log file: %{path}") % { user: Puppet[:user], group: Puppet[:group], path: path }
-      end
-    end
-
     @file = file
 
     @autoflush = Puppet[:autoflush]

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

@@ -0,0 +1,175 @@
+module Puppet::Util::Package::Version
+  class Debian < Numeric
+    include Comparable
+
+    # Version string matching regexes
+    REGEX_EPOCH   = '(?:([0-9]+):)?'
+    # alphanumerics and the characters . + - ~ , starts with a digit, ~ only of debian_revision is present
+    REGEX_UPSTREAM_VERSION = '([\.\+~0-9a-zA-Z-]+?)'
+    #alphanumerics and the characters + . ~
+    REGEX_DEBIAN_REVISION = '(?:-([\.\+~0-9a-zA-Z]*))?'
+
+    REGEX_FULL    = REGEX_EPOCH + REGEX_UPSTREAM_VERSION + REGEX_DEBIAN_REVISION.freeze
+    REGEX_FULL_RX = /\A#{REGEX_FULL}\Z/
+
+    class ValidationFailure < ArgumentError; end
+
+    def self.parse(ver)
+      raise ValidationFailure, "Unable to parse '#{ver}' as a string" unless ver.is_a?(String)
+
+      match, epoch, upstream_version, debian_revision = *ver.match(REGEX_FULL_RX)
+
+      raise ValidationFailure, "Unable to parse '#{ver}' as a debian version identifier" unless match
+
+      new(epoch.to_i, upstream_version, debian_revision).freeze
+    end
+
+    def to_s
+      s = @upstream_version
+      s = "#{@epoch}:#{s}" if @epoch != 0
+      s = "#{s}-#{@debian_revision}" if @debian_revision
+      s
+    end
+    alias inspect to_s
+
+    def eql?(other)
+      other.is_a?(self.class) &&
+        @epoch.eql?(other.epoch) &&
+        @upstream_version.eql?(other.upstream_version) &&
+        @debian_revision.eql?(other.debian_revision)
+    end
+    alias == eql?
+
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+      cmp = @epoch <=> other.epoch
+      if cmp == 0
+        cmp = compare_upstream_version(other)
+        if cmp == 0
+          cmp = compare_debian_revision(other)
+        end
+      end
+      cmp
+    end
+
+    attr_reader :epoch, :upstream_version, :debian_revision
+
+    private
+
+    def initialize(epoch, upstream_version, debian_revision)
+      @epoch            = epoch
+      @upstream_version = upstream_version
+      @debian_revision  = debian_revision
+    end
+
+    def compare_upstream_version(other)
+      mine = @upstream_version
+      yours = other.upstream_version
+      compare_debian_versions(mine, yours)
+    end
+
+    def compare_debian_revision(other)
+      mine = @debian_revision
+      yours = other.debian_revision
+      compare_debian_versions(mine, yours)
+    end
+
+    def compare_debian_versions(mine, yours)
+      #   First the initial part of each string consisting entirely of non-digit characters is determined.
+      # These two parts (one of which may be empty) are compared lexically. If a difference is found it is
+      # returned. The lexical comparison is a comparison of ASCII values modified so that all the letters
+      # sort earlier than all the non-letters and so that a tilde sorts before anything, even the end of a
+      # part. For example, the following parts are in sorted order from earliest to latest: ~~, ~~a, ~, the
+      # empty part, a.
+      #
+      #   Then the initial part of the remainder of each string which consists entirely of digit characters
+      # is determined. The numerical values of these two parts are compared, and any difference found is
+      # returned as the result of the comparison. For these purposes an empty string (which can only occur
+      # at the end of one or both version strings being compared) counts as zero.
+      #
+      #   These two steps (comparing and removing initial non-digit strings and initial digit strings) are
+      # repeated until a difference is found or both strings are exhausted.
+
+      mine_index = 0
+      yours_index = 0
+      cmp = 0
+      mine ||= ''
+      yours ||= ''
+      while mine_index < mine.length && yours_index < yours.length && cmp == 0
+        #handle ~
+        _mymatch, mytilde = *match_tildes(mine.slice(mine_index..-1))
+        mytilde ||= ''
+
+        _yoursmatch, yourstilde = *match_tildes(yours.slice(yours_index..-1))
+        yourstilde ||= ''
+
+        cmp = -1 * (mytilde.length <=> yourstilde.length)
+        mine_index += mytilde.length
+        yours_index += yourstilde.length
+
+        if cmp == 0 # handle letters
+
+          _mymatch, myletters = *match_letters(mine.slice(mine_index..-1))
+          myletters ||= ''
+
+          _yoursmatch, yoursletters = *match_letters(yours.slice(yours_index..-1))
+          yoursletters ||= ''
+
+          cmp = myletters <=> yoursletters
+          mine_index += myletters.length
+          yours_index += yoursletters.length
+
+          if cmp == 0 # handle nonletters except tilde
+            _mymatch, mynon_letters = *match_non_letters(mine.slice(mine_index..-1))
+            mynon_letters ||= ''
+
+            _yoursmatch, yoursnon_letters = *match_non_letters(yours.slice(yours_index..-1))
+            yoursnon_letters ||= ''
+
+            cmp = mynon_letters <=> yoursnon_letters
+            mine_index += mynon_letters.length
+            yours_index += yoursnon_letters.length
+
+            if cmp == 0 # handle digits
+              _mymatch, mydigits = *match_digits(mine.slice(mine_index..-1))
+              mydigits ||= ''
+
+              _yoursmatch, yoursdigits = *match_digits(yours.slice(yours_index..-1))
+              yoursdigits ||= ''
+
+              cmp = mydigits.to_i <=> yoursdigits.to_i
+              mine_index += mydigits.length
+              yours_index += yoursdigits.length
+            end
+          end
+        end
+      end
+      if cmp == 0
+        if mine_index < mine.length && match_tildes(mine[mine_index])
+          cmp = -1
+        elsif yours_index < yours.length && match_tildes(yours[yours_index])
+          cmp = 1
+        else
+          cmp = mine.length <=> yours.length
+        end
+      end
+      cmp
+    end
+
+    def match_digits(a)
+      a.match(/^([0-9]+)/)
+    end
+
+    def match_non_letters(a)
+      a.match(/^([\.\+-]+)/)
+    end
+
+    def match_tildes(a)
+      a.match(/^(~+)/)
+    end
+
+    def match_letters(a)
+      a.match(/^([A-Za-z]+)/)
+    end
+  end
+end

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