puppet 6.10.1 → 6.11.0

data/lib/puppet/pops/types/p_sensitive_type.rb

@@ -22,7 +22,7 @@ class PSensitiveType < PTypeWithContainedType
     end
 
     def inspect
-      "#<#{to_s}>"
+      "#<#{self}>"
     end
   end
 

data/lib/puppet/pops/types/p_uri_type.rb

@@ -175,7 +175,7 @@ class PURIType < PAnyType
       result[SCHEME] = scheme
     end
     result[USERINFO] = uri.userinfo unless uri.userinfo.nil?
-    result[HOST] = uri.host.downcase unless uri.host.nil?
+    result[HOST] = uri.host.downcase unless uri.host.nil? || uri.host.empty?
     result[PORT] = uri.port.to_s unless uri.port.nil? || uri.port == 80 && 'http' == scheme || uri.port == 443 && 'https' == scheme
     result[PATH] = uri.path unless uri.path.nil? || uri.path.empty?
     result[QUERY] = uri.query unless uri.query.nil?

data/lib/puppet/pops/types/string_converter.rb

@@ -728,7 +728,7 @@ class StringConverter
     when :c
       char = [val].pack("U")
       char = f.alt? ? "\"#{char}\"" : char
-      Kernel.format(f.orig_fmt.gsub('c','s'), char)
+      Kernel.format(f.orig_fmt.tr('c','s'), char)
 
     when :s
       fmt = f.alt? ? 'p' : 's'
@@ -781,7 +781,7 @@ class StringConverter
 
     when :p
       # width & precision applied to string, not the the name of the type
-      "Binary(\"#{Kernel.format(f.orig_fmt.gsub('p', 's'), val.to_s)}\")"
+      "Binary(\"#{Kernel.format(f.orig_fmt.tr('p', 's'), val.to_s)}\")"
 
     when :b
       Kernel.format(f.orig_fmt.gsub('b', substitute), val.relaxed_to_s)
@@ -817,23 +817,23 @@ class StringConverter
 
     when :c
       c_val = val.capitalize
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('c', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('c', 's'), c_val)
 
     when :C
       c_val = val.split('::').map {|s| s.capitalize }.join('::')
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('C', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('C', 's'), c_val)
 
     when :u
       c_val = val.upcase
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('u', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('u', 's'), c_val)
 
     when :d
       c_val = val.downcase
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('d', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('d', 's'), c_val)
 
     when :t  # trim
       c_val = val.strip
-      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.gsub('t', 's'), c_val)
+      f.alt? ? apply_string_flags(f, puppet_quote(c_val)) :  Kernel.format(f.orig_fmt.tr('t', 's'), c_val)
 
     else
       raise FormatError.new('String', f.format, 'cCudspt')
@@ -921,7 +921,7 @@ class StringConverter
     case f.format
     when :p
       str_regexp = PRegexpType.regexp_to_s_with_delimiters(val)
-      f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.gsub('p', 's'), str_regexp)
+      f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.tr('p', 's'), str_regexp)
     when :s
       str_regexp = PRegexpType.regexp_to_s(val)
       str_regexp = puppet_quote(str_regexp) if f.alt?
@@ -1098,10 +1098,10 @@ class StringConverter
     f = get_format(val_type, format_map)
     case f.format
     when :s
-      str_val = f.alt? ? "\"#{val.to_s}\"" : val.to_s
+      str_val = f.alt? ? "\"#{val}\"" : val.to_s
       Kernel.format(f.orig_fmt, str_val)
     when :p
-      Kernel.format(f.orig_fmt.gsub('p', 's'), val.to_s)
+      Kernel.format(f.orig_fmt.tr('p', 's'), val.to_s)
     else
       raise FormatError.new('Type', f.format, 'sp')
     end

data/lib/puppet/pops/types/types.rb

@@ -340,7 +340,7 @@ class PAnyType < TypedModelObject
   # @raises ArgumentError
   #
   def self.new_function(type)
-    raise ArgumentError.new("Creation of new instance of type '#{type.to_s}' is not supported")
+    raise ArgumentError.new("Creation of new instance of type '#{type}' is not supported")
   end
 
   # Answers the question if instances of this type can represent themselves as a string that
@@ -1268,7 +1268,7 @@ class PFloatType < PNumericType
         else
           begin
             # support a binary as float
-            if from[0] == '0' && from[1].downcase == 'b'
+            if from[0] == '0' && from[1].casecmp('b').zero?
               from = Integer(from)
             end
             Float(from)
@@ -1700,7 +1700,7 @@ class PRegexpType < PScalarType
   # @param regexp [Regexp] the regular expression
   # @return [String] the Regexp as a slash delimited string with slashes escaped
   def self.regexp_to_s_with_delimiters(regexp)
-    regexp.options == 0 ? regexp.inspect : "/#{regexp.to_s}/"
+    regexp.options == 0 ? regexp.inspect : "/#{regexp}/"
   end
 
   # @param regexp [Regexp] the regular expression

data/lib/puppet/property.rb

@@ -207,7 +207,7 @@ class Puppet::Property < Puppet::Parameter
       else
         return "#{name} changed #{is_to_s(current_value)} to #{should_to_s(newvalue)}"
       end
-    rescue Puppet::Error, Puppet::DevError
+    rescue Puppet::Error
       raise
     rescue => detail
       message = _("Could not convert change '%{name}' to string: %{detail}") % { name: name, detail: detail }

data/lib/puppet/property/ensure.rb

@@ -56,7 +56,7 @@ class Puppet::Property::Ensure < Puppet::Property
       else
         return _('%{name} changed %{is} to %{should}') % { name: name, is: is_to_s(currentvalue), should: should_to_s(newvalue) }
       end
-    rescue Puppet::Error, Puppet::DevError
+    rescue Puppet::Error
       raise
     rescue => detail
       raise Puppet::DevError, _("Could not convert change %{name} to string: %{detail}") % { name: self.name, detail: detail }, detail.backtrace

data/lib/puppet/provider/exec.rb

@@ -52,7 +52,11 @@ class Puppet::Provider::Exec < Puppet::Provider
     # This is backwards compatible all the way to Ruby 1.8.7.
     Timeout::timeout(resource[:timeout], Timeout::Error) do
       cwd = resource[:cwd]
-      cwd ||= Dir.pwd
+      # It's ok if cwd is nil. In that case Puppet::Util::Execution.execute() simply will not attempt to
+      # change the working directory, which is exactly the right behavior when no cwd parameter is
+      # expressed on the resource.  Moreover, attempting to change to the directory that is already
+      # the working directory can fail under some circumstances, so avoiding the directory change attempt
+      # is preferable to defaulting cwd to that directory.
 
       # note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
       # default/system locale will be respected.  Callers may override this behavior by setting locale-related
@@ -96,6 +100,6 @@ class Puppet::Provider::Exec < Puppet::Provider
   def validatecmd(command)
     exe = extractexe(command)
     # if we're not fully qualified, require a path
-    self.fail _("'%{command}' is not qualified and no path was specified. Please qualify the command or specify a path.") % { command: command } if !absolute_path?(exe) and resource[:path].nil?
+    self.fail _("'%{exe}' is not qualified and no path was specified. Please qualify the command or specify a path.") % { exe: exe } if !absolute_path?(exe) and resource[:path].nil?
   end
 end

data/lib/puppet/provider/nameservice/directoryservice.rb

@@ -289,7 +289,7 @@ class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameSe
     end
     dscl_out = dscl(dscl_args)
     # We're ok with throwing away negative uids here.
-    ids = dscl_out.split.compact.collect { |l| l.to_i if l.match(/^\d+$/) }
+    ids = dscl_out.split.compact.collect { |l| l.to_i if l =~ /^\d+$/ }
     ids.compact!.sort! { |a,b| a.to_f <=> b.to_f }
     # We're just looking for an unused id in our sorted array.
     ids.each_index do |i|

data/lib/puppet/provider/nameservice/pw.rb

@@ -3,13 +3,13 @@ require 'puppet/provider/nameservice/objectadd'
 class Puppet::Provider::NameService
   class PW < ObjectAdd
     def deletecmd
-      [command(:pw), "#{@resource.class.name.to_s}del", @resource[:name]]
+      [command(:pw), "#{@resource.class.name}del", @resource[:name]]
     end
 
     def modifycmd(param, value)
       cmd = [
           command(:pw),
-          "#{@resource.class.name.to_s}mod",
+          "#{@resource.class.name}mod",
           @resource[:name],
           flag(param),
           munge(param, value)

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

@@ -8,7 +8,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     These options should be specified as an array where each element is either a
      string or a hash."
 
-  has_feature :versionable, :install_options
+  has_feature :versionable, :install_options, :virtual_packages
 
   commands :aptget => "/usr/bin/apt-get"
   commands :aptcache => "/usr/bin/apt-cache"
@@ -22,6 +22,10 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
   ENV['APT_LISTBUGS_FRONTEND'] = "none"
   ENV['APT_LISTCHANGES_FRONTEND'] = "none"
 
+  def self.defaultto_allow_virtual
+    false
+  end
+
   # A derivative of DPKG; this is how most people actually manage
   # Debian boxes, and the only thing that differs is that it can
   # install packages from remote sites.

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

@@ -0,0 +1,87 @@
+# dnfmodule - A puppet package provider for DNF modules
+#
+# Installing a module:
+#  package { 'postgresql':
+#   provider => 'dnfmodule',
+#   ensure   => '9.6',  # install a specific stream
+#   flavor   => 'client',  # install a specific profile
+# }
+
+
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
+
+  has_feature :installable, :uninstallable, :versionable
+  #has_feature :upgradeable
+  # it's not (yet) feasible to make this upgradeable since module streams don't
+  # always have matching version types (i.e. idm has streams DL1 and client,
+  # other modules have semver streams, others have string streams... we cannot
+  # programatically determine a latest version for ensure => 'latest'
+
+  commands :dnf => '/usr/bin/dnf'
+
+  def self.current_version
+    @current_version ||= dnf('--version').split.first
+  end
+
+  def self.prefetch(packages)
+    if Puppet::Util::Package.versioncmp(current_version, '3.0.1') < 0
+      raise Puppet::Error, _("Modules are not supported on DNF versions lower than 3.0.1")
+    end
+    super
+  end
+
+  def self.instances
+    packages = []
+    cmd = "#{command(:dnf)} module list --installed -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
+      packages << new(
+        name: line.split[0],
+        ensure: line.split[1],
+        flavor: line.split('[i]').first.split.last,  # this is nasty
+        provider: name
+      )
+    end
+    packages
+  end
+
+  def query
+    pkg = self.class.instances.find do |package|
+            @resource[:name] == package.name
+          end
+    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])
+    case @resource[:ensure]
+    when true, false, Symbol
+      # pass
+    else
+      args << ":#{@resource[:ensure]}"
+    end
+    if @resource[:flavor]
+      args << "/#{@resource[:flavor]}"
+    end
+    execute([command(:dnf), 'module', 'install', '-d', '0', '-e', self.class.error_level, '-y', args])
+  end
+
+  def uninstall
+    execute([command(:dnf), 'module', 'remove', '-d', '0', '-e', self.class.error_level, '-y', @resource[:name]])
+    reset  # reset module to the default stream
+  end
+end
+

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

@@ -5,8 +5,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     and not `apt`, you must specify the source of any packages you want
     to manage."
 
-  has_feature :holdable
-
+  has_feature :holdable, :virtual_packages
   commands :dpkg => "/usr/bin/dpkg"
   commands :dpkg_deb => "/usr/bin/dpkg-deb"
   commands :dpkgquery => "/usr/bin/dpkg-query"
@@ -45,16 +44,22 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
   # Note: self:: is required here to keep these constants in the context of what will
   # 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= [:desired, :error, :status, :name, :ensure]
 
+  def self.defaultto_allow_virtual
+    false
+  end
+
   # @param line [String] one line of dpkg-query output
   # @return [Hash,nil] a hash of FIELDS or nil if we failed to match
   # @api private
-  def self.parse_line(line)
+  def self.parse_line(line, regex=self::FIELDS_REGEX)
     hash = nil
 
-    match = self::FIELDS_REGEX.match(line)
+    match = regex.match(line)
     if match
       hash = {}
 
@@ -105,7 +110,11 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
 
   # Return the version from the package.
   def latest
-    output = dpkg_deb "--show", @resource[:source]
+    source = @resource[:source]
+    unless source
+      @resource.fail _("Could not update: You cannot install dpkg packages without a source")
+    end
+    output = dpkg_deb "--show", source
     matches = /^(\S+)\t(\S+)$/.match(output).captures
     warning _("source doesn't contain named package, but %{name}") % { name: matches[0] } unless matches[0].match( Regexp.escape(@resource[:name]) )
     matches[1]
@@ -116,6 +125,20 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
 
     # list out our specific package
     begin
+      if @resource.allow_virtual?
+        output = dpkgquery(
+          "-W",
+          "--showformat",
+          self.class::DPKG_QUERY_PROVIDES_FORMAT_STRING
+          #the regex searches for the resource[:name] in the dpkquery result in which the Provides field is also available
+          #it will search for the packages only in the brackets ex: [rubygems]
+        ).lines.find {|package| package.match(/[\[ ](#{Regexp.escape(@resource[:name])})[\],]/)}
+        if output
+          hash = self.class.parse_line(output,self.class::FIELDS_REGEX_WITH_PROVIDES)
+          Puppet.info("Package #{@resource[:name]} is virtual, defaulting to #{hash[:name]}")
+          @resource[:name] = hash[:name]
+        end
+      end
       output = dpkgquery(
         "-W",
         "--showformat",
@@ -148,7 +171,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
   end
 
   def hold
-    if package_not_installed?(@resource[:name])
+    if package_not_installed?
       self.install
     end
     Tempfile.open('puppet_dpkg_set_selection') do |tmpfile|
@@ -166,16 +189,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
   end
 
-  def package_not_installed?(name)
-    if !name.nil? && !name.empty?
-      begin
-       dpkgquery("-W", "--showformat", self.class::DPKG_QUERY_FORMAT_STRING, name)
-      rescue Puppet::ExecutionFailure
-        # return true if exception is generated because package is not found
-        return true
-      end
-      return false
-    end
-    raise ArgumentError.new("Package name is nil or empty")
+  def package_not_installed?
+    query[:status] != "installed"
   end
 end

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

@@ -185,7 +185,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
       # If :ensure contains a version, use that instead of looking it up.
       # This allows for installing packages with the same stem, but multiple
       # version such as openldap-server.
-      if /(\d[^-]*)$/.match(@resource[:ensure].to_s)
+      if @resource[:ensure].to_s =~ /(\d[^-]*)$/
         use_version = @resource[:ensure]
       else
         use_version = get_version

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

@@ -35,16 +35,25 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     if Puppet::Util::Platform.windows?
       ["pip.exe"]
     else
-      ["pip", "pip-python"]
+      ["pip", "pip-python", "pip2", "pip-2"]
     end
   end
 
   def self.pip_version(command)
-    execpipe [command, '--version'] do |process|
+    version = nil
+    execpipe [quote(command), '--version'] do |process|
       process.collect do |line|
-        return line.strip.match(/^pip (\d+\.\d+\.?\d*).*$/)[1]
+        md = line.strip.match(/^pip (\d+\.\d+\.?\d*).*$/)
+        if md
+          version = md[1]
+          break
+        end
       end
     end
+
+    raise Puppet::Error, _("Cannot resolve pip version") unless version
+
+    version
   end
 
   # Return an array of structured information about every installed package
@@ -102,7 +111,7 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     self.class.validate_command(command)
 
     self.class.instances(command).each do |pkg|
-      return pkg.properties if @resource[:name].downcase == pkg.name.downcase
+      return pkg.properties if @resource[:name].casecmp(pkg.name).zero?
     end
     return nil
   end
@@ -122,14 +131,17 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     end
   end
 
+  # Less resource-intensive approach for pip version 1.5.4 and newer.
+
   def latest_with_new_pip
     command = resource_or_provider_command
     self.class.validate_command(command)
 
-    # Less resource intensive approach for pip version 1.5.4 and above
-    execpipe [command, "install", "#{@resource[:name]}==versionplease"] do |process|
+    command_and_options = [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 Django==versionplease (from versions: 1.1.3, 1.8rc1)
+        # 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|
@@ -142,14 +154,18 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
     end
   end
 
+  # More resource-intensive approach for pip version 1.5.3 and older.
+
   def latest_with_old_pip
     command = resource_or_provider_command
     self.class.validate_command(command)
 
     Dir.mktmpdir("puppet_pip") do |dir|
-      execpipe [command, "install", "#{@resource[:name]}", "-d", "#{dir}", "-v"] do |process|
+      command_and_options = [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: 0.10.1, 0.10, 0.9, 0.8.1, 0.8, 0.7.2, 0.7.1, 0.7, 0.6.1, 0.6, 0.5.2, 0.5.1, 0.5, 0.4, 0.3.1, 0.3, 0.2, 0.1)
+          # 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
           end
@@ -209,4 +225,13 @@ Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package
   def install_options
     join_options(@resource[:install_options])
   end
+
+  def self.quote(path)
+    if path.include?(" ")
+      "\"#{path}\""
+    else
+      path
+    end
+  end
+  private_class_method :quote
 end