puppet 6.14.0-x86-mingw32 → 6.15.0-x86-mingw32

data/lib/puppet/provider/group/windows_adsi.rb

@@ -24,7 +24,7 @@ Puppet::Type.type(:group).provide :windows_adsi do
     # since the default array_matching comparison is not commutative
 
     # dupes automatically weeded out when hashes built
-    current_members = Puppet::Util::Windows::ADSI::Group.name_sid_hash(current)
+    current_members = Puppet::Util::Windows::ADSI::Group.name_sid_hash(current, true)
     specified_members = Puppet::Util::Windows::ADSI::Group.name_sid_hash(should)
 
     current_sids = current_members.keys.to_a
@@ -52,7 +52,7 @@ Puppet::Type.type(:group).provide :windows_adsi do
         account = sid.account
       end
       resource.debug("#{sid.domain}\\#{account} (#{sid.sid})")
-      "#{sid.domain}\\#{account}"
+      sid.domain ? "#{sid.domain}\\#{account}" : account
     end
     return users.join(',')
   end
@@ -66,7 +66,7 @@ Puppet::Type.type(:group).provide :windows_adsi do
   end
 
   def members
-    @members ||= Puppet::Util::Windows::ADSI::Group.name_sid_hash(group.members)
+    @members ||= Puppet::Util::Windows::ADSI::Group.name_sid_hash(group.members, true)
 
     # @members.keys returns an array of SIDs. We need to convert those SIDs into
     # names so that `puppet resource` prints the right output.

data/lib/puppet/provider/package/apt.rb

@@ -1,7 +1,11 @@
+require 'puppet/util/package/version/range'
+require 'puppet/util/package/version/debian'
+
 Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
   # Provide sorting functionality
   include Puppet::Util::Package
-
+  DebianVersion = Puppet::Util::Package::Version::Debian
+  VersionRange  = Puppet::Util::Package::Version::Range
   desc "Package management via `apt-get`.
 
     This provider supports the `install_options` attribute, which allows command-line flags to be passed to apt-get.
@@ -44,12 +48,41 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     end
   end
 
+  def best_version(should_range)
+    available_versions = SortedSet.new
+
+    output = aptcache :madison, @resource[:name]
+    output.each_line do |line|
+      is = line.split('|')[1].strip
+      begin
+        is_version = DebianVersion.parse(is)
+        available_versions << is_version if should_range.include?(is_version)
+      rescue DebianVersion::ValidationFailure
+        Puppet.debug("Cannot parse #{is} as a debian version")
+      end
+    end
+
+    return available_versions.to_a.last unless available_versions.empty?
+
+    Puppet.debug("No available version for package #{@resource[:name]} is included in range #{should_range}")
+    should_range
+  end
+
   # Install a package using 'apt-get'.  This function needs to support
   # installing a specific version.
   def install
     self.run_preseed if @resource[:responsefile]
     should = @resource[:ensure]
 
+    if should.is_a?(String)
+      begin
+        should_range = VersionRange.parse(should, DebianVersion)
+        should = best_version(should_range)
+      rescue VersionRange::ValidationFailure, DebianVersion::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a debian version range, falling through")
+      end
+    end
+
     checkforcdrom
     cmd = %w{-q -y}
 
@@ -130,4 +163,31 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
   def install_options
     join_options(@resource[:install_options])
   end
+
+  def insync?(is)
+    # this is called after the generic version matching logic (insync? for the
+    # type), so we only get here if should != is
+
+    return false unless is && is != :absent
+
+    #if 'should' is a range and 'is' a debian version we should check if 'should' includes 'is'
+    should = @resource[:ensure]
+
+    return false unless is.is_a?(String) && should.is_a?(String)
+
+    begin
+      should_range = VersionRange.parse(should, DebianVersion)
+    rescue VersionRange::ValidationFailure, DebianVersion::ValidationFailure
+      Puppet.debug("Cannot parse #{should} as a debian version range")
+      return false
+    end
+
+    begin
+      is_version = DebianVersion.parse(is)
+    rescue DebianVersion::ValidationFailure
+      Puppet.debug("Cannot parse #{is} as a debian version")
+      return false
+    end
+    should_range.include?(is_version)
+  end
 end

data/lib/puppet/provider/package/dnfmodule.rb

@@ -34,14 +34,22 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
 
   def self.instances
     packages = []
-    cmd = "#{command(:dnf)} module list --installed -d 0 -e #{error_level}"
+    cmd = "#{command(:dnf)} module list --enabled -d 0 -e #{error_level}"
     execute(cmd).each_line do |line|
-      next unless line =~ /\[i\][, ]/  # get rid of non-package lines (including last Hint line)
-      line.gsub!(/\[[de]\]/, '')  # we don't care about default/enabled flags
+      # select only lines with actual packages since DNF clutters the output
+      next unless line =~ /\[[ei]\][, ]/
+      line.gsub!(/\[d\]/, '')  # we don't care about the default flag
+
+      flavor = if line.include?('[i]')
+                 line.split('[i]').first.split.last
+               else
+                 :absent
+               end
+
       packages << new(
         name: line.split[0],
         ensure: line.split[1],
-        flavor: line.split('[i]').first.split.last,  # this is nasty
+        flavor: flavor,
         provider: name
       )
     end
@@ -55,28 +63,43 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
     pkg ? pkg.properties : nil
   end
 
-  def reset
-    execute([command(:dnf), 'module', 'reset', '-d', '0', '-e', self.class.error_level, '-y', @resource[:name]])
-  end
-
   # to install specific streams and profiles:
   # $ dnf module install module-name:stream/profile
   # $ dnf module install perl:5.24/minimal
   # if unspecified, they will be defaulted (see [d] param in dnf module list output)
   def install
-    args = @resource[:name]
     # ensure we start fresh (remove existing stream)
     uninstall unless [:absent, :purged].include?(@property_hash[:ensure])
+
+    args = @resource[:name].dup
     case @resource[:ensure]
     when true, false, Symbol
       # pass
     else
       args << ":#{@resource[:ensure]}"
     end
-    if @resource[:flavor]
-      args << "/#{@resource[:flavor]}"
+    args << "/#{@resource[:flavor]}" if @resource[:flavor]
+
+    if @resource[:enable_only] == true
+      enable(args)
+    else
+      begin
+        execute([command(:dnf), 'module', 'install', '-d', '0', '-e', self.class.error_level, '-y', args])
+      rescue Puppet::ExecutionFailure => e
+        # module has no default profile and no profile was requested, so just enable the stream
+        # DNF versions prior to 4.2.8 do not need this workaround
+        # see https://bugzilla.redhat.com/show_bug.cgi?id=1669527
+        if @resource[:flavor] == nil && e.message =~ /^missing groups or modules: #{Regexp.quote(@resource[:name])}$/
+          enable(args)
+        else
+          raise
+        end
+      end
     end
-    execute([command(:dnf), 'module', 'install', '-d', '0', '-e', self.class.error_level, '-y', args])
+  end
+
+  def enable(args = @resource[:name])
+    execute([command(:dnf), 'module', 'enable', '-d', '0', '-e', self.class.error_level, '-y', args])
   end
 
   def uninstall
@@ -84,6 +107,10 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
     reset  # reset module to the default stream
   end
 
+  def reset
+    execute([command(:dnf), 'module', 'reset', '-d', '0', '-e', self.class.error_level, '-y', @resource[:name]])
+  end
+
   def flavor
     @property_hash[:flavor]
   end

data/lib/puppet/provider/package/gem.rb

@@ -1,3 +1,5 @@
+require 'puppet/util/package/version/gem'
+require 'puppet/util/package/version/range'
 require 'puppet/provider/package_targetable'
 require 'uri'
 
@@ -15,7 +17,10 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     These options should be specified as an array where each element is either a 
     string or a hash."
 
-  has_feature :versionable, :install_options, :uninstall_options, :targetable
+  has_feature :versionable, :install_options, :uninstall_options, :targetable, :version_ranges
+
+  GEM_VERSION =       Puppet::Util::Package::Version::Gem
+  GEM_VERSION_RANGE = Puppet::Util::Package::Version::Range
 
   # Override the specificity method to return 1 if gem is not set as default provider
   def self.specificity
@@ -125,16 +130,35 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
 
   def insync?(is)
     return false unless is && is != :absent
+    is = [is] unless is.is_a? Array
+    should = @resource[:ensure]
 
+    unless should =~ Regexp.union(/,/, Gem::Requirement::PATTERN)
+      begin
+        should_range = GEM_VERSION_RANGE.parse(should, GEM_VERSION)
+      rescue GEM_VERSION_RANGE::ValidationFailure, GEM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a ruby gem version range")
+        return false
+      end
+
+      return is.any? do |version|
+        begin
+          should_range.include?(GEM_VERSION.parse(version))
+        rescue GEM_VERSION::ValidationFailure
+          Puppet.debug("Cannot parse #{version} as a ruby gem version")
+          false
+        end
+      end
+    end
+    
     begin
-      dependency = Gem::Dependency.new('', resource[:ensure])
+      # Range intersections are not supported by Gem::Requirement, so just split by comma.
+      dependency = Gem::Dependency.new('', should.split(','))
     rescue ArgumentError
       # Bad requirements will cause an error during gem command invocation, so just return not in sync
       return false
     end
 
-    is = [is] unless is.is_a? Array
-
     # Check if any version matches the dependency
     is.any? { |version| dependency.match?('', version) }
   end
@@ -148,12 +172,22 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     command = resource_or_provider_command
     command_options = ["install"]
     command_options += install_options if resource[:install_options]
+    should = resource[:ensure]
+
+    unless should =~ Regexp.union(/,/, Gem::Requirement::PATTERN)
+      begin
+        should_range = GEM_VERSION_RANGE.parse(should, GEM_VERSION)
+        should = should_range.to_gem_version
+        useversion = true
+      rescue GEM_VERSION_RANGE::ValidationFailure, GEM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a ruby gem version range. Falling through.")
+      end
+    end
 
     if Puppet::Util::Platform.windows?
-      version = resource[:ensure]
-      command_options << "-v" << %Q["#{version}"] if (! resource[:ensure].is_a? Symbol) and useversion
+      command_options << "-v" << %Q["#{should}"] if useversion && !should.is_a?(Symbol)
     else
-      command_options << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
+      command_options << "-v" << should if useversion && !should.is_a?(Symbol)
     end
 
     if Puppet::Util::Package.versioncmp(rubygem_version(command), '2.0.0') == -1

data/lib/puppet/provider/package/pacman.rb

@@ -132,9 +132,6 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
   # We rescue the main check from Pacman with a check on the AUR using yaourt, if installed
   def latest
-    # Synchronize the database
-    pacman "-Sy"
-
     resource_name = @resource[:name]
 
     # If target is a group, construct the group version
@@ -243,7 +240,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     else
       fail _("Source %{source} is not supported by pacman") % { source: source }
     end
-    pacman "--noconfirm", "--noprogressbar", "-Sy"
+    pacman "--noconfirm", "--noprogressbar", "-S"
     pacman "--noconfirm", "--noprogressbar", "-U", source
   end
 
@@ -255,7 +252,7 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
     cmd = %w{--noconfirm --needed --noprogressbar}
     cmd += install_options if @resource[:install_options]
-    cmd << "-Sy" << resource_name
+    cmd << "-S" << resource_name
 
     if self.class.yaourt?
       yaourt(*cmd)

data/lib/puppet/provider/package/pip.rb

@@ -1,6 +1,8 @@
 # Puppet package provider for Python's `pip` package management frontend.
 # <http://pip.pypa.io/>
 
+require 'puppet/util/package/version/pip'
+require 'puppet/util/package/version/range'
 require 'puppet/provider/package_targetable'
 require 'puppet/util/http_proxy'
 
@@ -11,7 +13,10 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip.
   These options should be specified as an array where each element is either a string or a hash."
 
-  has_feature :installable, :uninstallable, :upgradeable, :versionable, :install_options, :targetable
+  has_feature :installable, :uninstallable, :upgradeable, :versionable, :version_ranges, :install_options, :targetable
+
+  PIP_VERSION       = Puppet::Util::Package::Version::Pip
+  PIP_VERSION_RANGE = Puppet::Util::Package::Version::Range
 
   # Override the specificity method to return 1 if pip is not set as default provider
   def self.specificity
@@ -25,7 +30,6 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
 
   # Define the default provider package command name when the provider is targetable.
   # Required by Puppet::Provider::Package::Targetable::resource_or_provider_command
-
   def self.provider_command
     # Ensure pip can upgrade pip, which usually puts pip into a new path /usr/local/bin/pip (compared to /usr/bin/pip)
     self.cmd.map { |c| which(c) }.find { |c| c != nil }
@@ -58,7 +62,6 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
 
   # Return an array of structured information about every installed package
   # that's managed by `pip` or an empty array if `pip` is not available.
-
   def self.instances(target_command = nil)
     if target_command
       command = target_command
@@ -72,7 +75,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
 
     command_options = ['freeze']
     command_version = self.pip_version(command)
-    if Puppet::Util::Package.versioncmp(command_version, '8.1.0') >= 0
+    if compare_pip_versions(command_version, '8.1.0') >= 0
       command_options << '--all'
     end
 
@@ -88,7 +91,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     # Pip can also upgrade pip, but it's not listed in freeze so need to special case it
     # Pip list would also show pip installed version, but "pip list" doesn't exist for older versions of pip (E.G v1.0)
     # Not needed when "pip freeze --all" is available.
-    if Puppet::Util::Package.versioncmp(command_version, '8.1.0') == -1
+    if compare_pip_versions(command_version, '8.1.0') == -1
       packages << new({:ensure => command_version, :name => File.basename(command), :provider => name, :command => command})
     end
 
@@ -105,7 +108,6 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
 
   # Return structured information about a particular package or `nil`
   # if the package is not installed or `pip` itself is not available.
-
   def query
     command = resource_or_provider_command
     self.class.validate_command(command)
@@ -116,24 +118,43 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     return nil
   end
 
-  # Use pip CLI to look up versions from PyPI repositories,
-  # honoring local pip config such as custom repositories.
-
+  # Return latest version available for current package
   def latest
     command = resource_or_provider_command
     self.class.validate_command(command)
 
     command_version = self.class.pip_version(command)
-    if Puppet::Util::Package.versioncmp(command_version, '1.5.4') == -1
-      latest_with_old_pip
+    if self.class.compare_pip_versions(command_version, '1.5.4') == -1
+      available_versions_with_old_pip.last
     else
-      latest_with_new_pip
+      available_versions_with_new_pip.last
+    end
+  end
+
+  def self.compare_pip_versions(x, y)
+    begin
+      Puppet::Util::Package::Version::Pip.compare(x, y)
+    rescue PIP_VERSION::ValidationFailure => ex
+      Puppet.debug("Cannot compare #{x} and #{y}. #{ex.message} Falling through default comparison mechanism.")
+      Puppet::Util::Package.versioncmp(x, y)
     end
   end
 
-  # Less resource-intensive approach for pip version 1.5.4 and newer.
+  # Use pip CLI to look up versions from PyPI repositories,
+  # honoring local pip config such as custom repositories.
+  def available_versions
+    command = resource_or_provider_command
+    self.class.validate_command(command)
+
+    command_version = self.class.pip_version(command)
+    if self.class.compare_pip_versions(command_version, '1.5.4') == -1
+      available_versions_with_old_pip
+    else
+      available_versions_with_new_pip
+    end
+  end
 
-  def latest_with_new_pip
+  def available_versions_with_new_pip
     command = resource_or_provider_command
     self.class.validate_command(command)
 
@@ -142,21 +163,18 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     execpipe command_and_options do |process|
       process.collect do |line|
         # PIP OUTPUT: Could not find a version that satisfies the requirement example==versionplease (from versions: 1.2.3, 4.5.6)
-        if line =~ /from versions: /
-          textAfterLastMatch = $'.chomp(")\n")
-          versionList = textAfterLastMatch.split(', ').sort do |x,y|
-            Puppet::Util::Package.versioncmp(x, y)
+        if line =~ /from versions: (.+)\)/
+          versionList = $1.split(', ').sort do |x,y|
+            self.class.compare_pip_versions(x, y)
           end
-          return versionList.last
+          return versionList
         end
       end
-      return nil
     end
+    []
   end
 
-  # More resource-intensive approach for pip version 1.5.3 and older.
-
-  def latest_with_old_pip
+  def available_versions_with_old_pip
     command = resource_or_provider_command
     self.class.validate_command(command)
 
@@ -166,38 +184,73 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
       execpipe command_and_options do |process|
         process.collect do |line|
           # PIP OUTPUT: Using version 0.10.1 (newest of versions: 1.2.3, 4.5.6)
-          if line =~ /Using version (.+?) \(newest of versions/
-            return $1
+          if line =~ /Using version .+? \(newest of versions: (.+?)\)/
+            versionList = $1.split(', ').sort do |x,y|
+              self.class.compare_pip_versions(x, y)
+            end
+            return versionList
           end
         end
-        return nil
       end
+      return []
     end
   end
 
+  # Finds the most suitable version available in a given range
+  def best_version(should_range)
+    included_available_versions = []
+    available_versions.each do |version|
+      version = PIP_VERSION.parse(version)
+      included_available_versions.push(version) if should_range.include?(version)
+    end
+
+    included_available_versions.sort!
+    return included_available_versions.last unless included_available_versions.empty?
+
+    Puppet.debug("No available version for package #{@resource[:name]} is included in range #{should_range}")
+    should_range
+  end
+
   # Install a package.  The ensure parameter may specify installed,
   # latest, a version number, or, in conjunction with the source
   # parameter, an SCM revision.  In that case, the source parameter
   # gives the fully-qualified URL to the repository.
-
   def install
     command = resource_or_provider_command
     self.class.validate_command(command)
 
+    should = @resource[:ensure]
     command_options = %w{install -q}
     command_options +=  install_options if @resource[:install_options]
     if @resource[:source]
-      if String === @resource[:ensure]
-        command_options << "#{@resource[:source]}@#{@resource[:ensure]}#egg=#{@resource[:name]}"
+      if String === should
+        command_options << "#{@resource[:source]}@#{should}#egg=#{@resource[:name]}"
       else
         command_options << "#{@resource[:source]}#egg=#{@resource[:name]}"
       end
     else
-      case @resource[:ensure]
-      when String
-        command_options << "#{@resource[:name]}==#{@resource[:ensure]}"
+      case should
       when :latest
         command_options << "--upgrade" << @resource[:name]
+      when String
+        begin
+          should_range = PIP_VERSION_RANGE.parse(should, PIP_VERSION)
+          should = best_version(should_range)
+
+          unless should == should_range
+            command_options << "#{@resource[:name]}==#{should}"
+          else
+            # when no suitable version for the given range was found, let pip handle
+            if should.is_a?(PIP_VERSION_RANGE::MinMax)
+              command_options << "#{@resource[:name]} #{should.split.join(',')}"
+            else
+              command_options << "#{@resource[:name]} #{should}"
+            end
+          end
+        rescue PIP_VERSION_RANGE::ValidationFailure, PIP_VERSION::ValidationFailure
+          Puppet.debug("Cannot parse #{should} as a pip version range, falling through.")
+          command_options << "#{@resource[:name]}==#{should}"
+        end
       else
         command_options << @resource[:name]
       end
@@ -208,7 +261,6 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
 
   # Uninstall a package. Uninstall won't work reliably on Debian/Ubuntu unless this issue gets fixed.
   # http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=562544
-
   def uninstall
     command = resource_or_provider_command
     self.class.validate_command(command)
@@ -226,6 +278,26 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     join_options(@resource[:install_options])
   end
 
+  def insync?(is)
+    return false unless is && is != :absent
+    begin
+      should = @resource[:ensure]
+      should_range = PIP_VERSION_RANGE.parse(should, PIP_VERSION)
+    rescue PIP_VERSION_RANGE::ValidationFailure, PIP_VERSION::ValidationFailure
+      Puppet.debug("Cannot parse #{should} as a pip version range")
+      return false
+    end
+
+    begin
+      is_version = PIP_VERSION.parse(is)
+    rescue PIP_VERSION::ValidationFailure
+      Puppet.debug("Cannot parse #{is} as a pip version")
+      return false
+    end
+
+    should_range.include?(is_version)
+  end
+
   def self.quote(path)
     if path.include?(" ")
       "\"#{path}\""