puppet 6.11.1 → 6.16.0

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

@@ -45,8 +45,8 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
   # eventually become this Puppet::Type::Package::ProviderDpkg class.
   self::DPKG_QUERY_FORMAT_STRING = %Q{'${Status} ${Package} ${Version}\\n'}
   self::DPKG_QUERY_PROVIDES_FORMAT_STRING = %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}
-  self::FIELDS_REGEX = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
-  self::FIELDS_REGEX_WITH_PROVIDES = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*) \[.*\]$}
+  self::FIELDS_REGEX = %r{^'?(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
+  self::FIELDS_REGEX_WITH_PROVIDES = %r{^'?(\S+) +(\S+) +(\S+) (\S+) (\S*) \[.*\]$}
   self::FIELDS= [:desired, :error, :status, :name, :ensure]
 
   def self.defaultto_allow_virtual
@@ -74,7 +74,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
       elsif ['config-files', 'half-installed', 'unpacked', 'half-configured'].include?(hash[:status])
         hash[:ensure] = :absent
       end
-      hash[:ensure] = :held if hash[:desired] == 'hold'
+      hash[:mark] = :hold if hash[:desired] == 'hold'
     else
       Puppet.debug("Failed to match dpkg-query line #{line.inspect}")
     end
@@ -91,8 +91,6 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
     args = []
 
-    # We always unhold when installing to remove any prior hold.
-    self.unhold
 
     if @resource[:configfiles] == :keep
       args << '--force-confold'
@@ -101,7 +99,12 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
     args << '-i' << file
 
-    dpkg(*args)
+    self.unhold if self.properties[:mark] == :hold
+    begin
+      dpkg(*args)
+    ensure
+      self.hold if @resource[:mark] == :hold
+    end
   end
 
   def update
@@ -170,10 +173,14 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     dpkg "--purge", @resource[:name]
   end
 
-  def hold
+  def deprecated_hold
     if package_not_installed?
       self.install
     end
+    hold
+  end
+
+  def hold
     Tempfile.open('puppet_dpkg_set_selection') do |tmpfile|
       tmpfile.write("#{@resource[:name]} hold\n")
       tmpfile.flush

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

@@ -37,7 +37,12 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
 
     cmd << :install << str
 
-    finkcmd(cmd)
+    self.unhold if self.properties[:mark] == :hold
+    begin
+      finkcmd(cmd)
+    ensure
+      self.hold if @resource[:mark] == :hold
+    end
   end
 
   # What's the latest package version available?
@@ -71,10 +76,22 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
   end
 
   def uninstall
-    finkcmd "-y", "-q", :remove, @model[:name]
+    self.unhold if self.properties[:mark] == :hold
+    begin
+      finkcmd "-y", "-q", :remove, @model[:name]
+    rescue StandardError, LoadError => e
+      self.hold if self.properties[:mark] == :hold
+      raise e
+    end
   end
 
   def purge
-    aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+    self.unhold if self.properties[:mark] == :hold
+    begin
+      aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+    rescue StandardError, LoadError => e
+      self.hold if self.properties[:mark] == :hold
+      raise e
+    end
   end
 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/openbsd.rb

@@ -20,6 +20,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
   has_feature :install_options
   has_feature :uninstall_options
   has_feature :upgradeable
+  has_feature :supports_flavors
 
   def self.instances
     packages = []
@@ -27,7 +28,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
     begin
       execpipe(listcmd) do |process|
         # our regex for matching pkg_info output
-        regex = /^(.*)-(\d[^-]*)[-]?(\w*)(.*)$/
+        regex = /^(.*)-(\d[^-]*)[-]?([\w-]*)(.*)$/
         fields = [:name, :ensure, :flavor ]
         hash = {}
 
@@ -245,4 +246,15 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
   def purge
     pkgdelete "-c", "-q", @resource[:name]
   end
+
+  def flavor
+    @property_hash[:flavor]
+  end
+
+  def flavor=(value)
+    if flavor != @resource.should(:flavor)
+      uninstall
+      install
+    end
+  end
 end

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,11 +75,11 @@ 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
 
-    execpipe [command, command_options] do |process|
+    execpipe [quote(command), command_options] do |process|
       process.collect do |line|
         pkg = parse(line)
         next unless pkg
@@ -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,99 +118,171 @@ 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
 
-  # Less resource-intensive approach for pip version 1.5.4 and newer.
+  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
 
-  def latest_with_new_pip
+  # 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_and_options = [command, 'install', "#{@resource[:name]}==versionplease"]
+    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 available_versions_with_new_pip
+    command = resource_or_provider_command
+    self.class.validate_command(command)
+
+    command_and_options = [self.class.quote(command), 'install', "#{@resource[:name]}==versionplease"]
     command_and_options << install_options if @resource[:install_options]
     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)
 
     Dir.mktmpdir("puppet_pip") do |dir|
-      command_and_options = [command, 'install', "#{@resource[:name]}", '-d', "#{dir}", '-v']
+      command_and_options = [self.class.quote(command), 'install', "#{@resource[:name]}", '-d', "#{dir}", '-v']
       command_and_options << install_options if @resource[:install_options]
       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
 
-  # 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.
+  # 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
 
-  def install
-    command = resource_or_provider_command
-    self.class.validate_command(command)
+    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
 
+  def get_install_command_options()
+    should = @resource[:ensure]
     command_options = %w{install -q}
-    command_options +=  install_options if @resource[:install_options]
+    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]}"
-      when :latest
-        command_options << "--upgrade" << @resource[:name]
+
+      return command_options
+    end
+
+    if should == :latest
+      command_options << "--upgrade" << @resource[:name]
+
+      return command_options
+    end
+
+    unless String === should
+      command_options << @resource[:name]
+
+      return command_options
+    end
+
+    begin
+      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, falling through.")
+      command_options << "#{@resource[:name]}==#{should}"
+
+      return command_options
+    end
+
+    if should_range.is_a?(PIP_VERSION_RANGE::Eq)
+      command_options << "#{@resource[:name]}==#{should}"
+
+      return command_options
+    end
+
+    should = best_version(should_range)
+
+    if should == should_range
+      # 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]
+        command_options << "#{@resource[:name]} #{should}"
       end
+    else
+      command_options << "#{@resource[:name]}==#{should}"
     end
 
+    command_options
+  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)
+
+    command_options = get_install_command_options
     execute([command, command_options])
   end
 
   # 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 +300,28 @@ 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
+
+  # Quoting is required if the path to the pip command contains spaces.
+  # Required for execpipe() but not execute(), as execute() already does this.
   def self.quote(path)
     if path.include?(" ")
       "\"#{path}\""
@@ -233,5 +329,4 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
       path
     end
   end
-  private_class_method :quote
 end