puppet 6.4.4-x64-mingw32 → 6.4.5-x64-mingw32

data/lib/puppet/pops/puppet_stack.rb

@@ -1,57 +1,59 @@
-module Puppet::Pops
-# Module for making a call such that there is an identifiable entry on
-# the ruby call stack enabling getting a puppet call stack
-# To use this make a call with:
-# ```
-# Puppet::Pops::PuppetStack.stack(file, line, receiver, message, args)
-# ```
-# To get the stack call:
-# ```
-# Puppet::Pops::PuppetStack.stacktrace
-#
-# When getting a backtrace in Ruby, the puppet stack frames are
-# identified as coming from "in 'stack'" and having a ".pp" file
-# name.
-# To support testing, a given file that is an empty string, or nil
-# as well as a nil line number are supported. Such stack frames
-# will be represented with the text `unknown` and `0´ respectively.
-#
-module PuppetStack
-  # Pattern matching an entry in the ruby stack that is a puppet entry
-  PP_ENTRY_PATTERN = /^(.*\.pp)?:([0-9]+):in (`stack'|`block in call_function'|`<eval>')/
+module Puppet
+  module Pops
+    # Utility class for keeping track of the "Puppet stack", ie the file
+    # and line numbers of Puppet Code that created the current context.
+    #
+    # To use this make a call with:
+    #
+    # ```rb
+    # Puppet::Pops::PuppetStack.stack(file, line, receiver, message, args)
+    # ```
+    #
+    # To get the stack call:
+    #
+    # ```rb
+    # Puppet::Pops::PuppetStack.stacktrace
+    # ```
+    #
+    # or
+    #
+    # ```rb
+    # Puppet::Pops::PuppetStack.top_of_stack
+    # ```
+    #
+    # To support testing, a given file that is an empty string, or nil
+    # as well as a nil line number are supported. Such stack frames
+    # will be represented with the text `unknown` and `0´ respectively.
+    module PuppetStack
+      @stack = Array.new
 
-  # Sends a message to an obj such that it appears to come from
-  # file, line when calling stacktrace.
-  #
-  def self.stack(file, line, obj, message, args, &block)
-    file = '' if file.nil?
-    line = 0 if line.nil?
+      def self.stack(file, line, obj, message, args, &block)
+        file = 'unknown' if (file.nil? || file == '')
+        line = 0 if line.nil?
 
-    if block_given?
-      Kernel.eval("obj.send(message, *args, &block)", Kernel.binding(), file, line)
-    else
-      Kernel.eval("obj.send(message, *args)", Kernel.binding(), file, line)
-    end
-  end
+        result = nil
+        @stack.unshift([file, line])
+        begin
+          if block_given?
+            result = obj.send(message, *args, &block)
+          else
+            result = obj.send(message, *args)
+          end
+        ensure
+          @stack.shift()
+        end
+        result
+      end
 
-  def self.stacktrace
-    caller().reduce([]) do |memo, loc|
-      if loc =~ PP_ENTRY_PATTERN
-        memo << [$1.nil? ? 'unknown' : $1, $2.to_i]
+      def self.stacktrace
+        @stack.dup
       end
-      memo
-    end
-  end
 
-  # Returns an Array with the top of the puppet stack, or an empty Array if there was no such entry.
-  #
-  def self.top_of_stack
-    caller.each do |loc|
-      if loc =~ PP_ENTRY_PATTERN
-        return [$1.nil? ? 'unknown' : $1, $2.to_i]
+      # Returns an Array with the top of the puppet stack, or an empty
+      # Array if there was no such entry.
+      def self.top_of_stack
+        @stack.first || []
       end
     end
-    []
   end
-end
-end
+end

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/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)
@@ -1699,7 +1699,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

@@ -209,7 +209,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
@@ -93,6 +97,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"
@@ -44,16 +43,23 @@ 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
 
-    if match = self::FIELDS_REGEX.match(line)
+    match = regex.match(line)
+    if match
       hash = {}
 
       self::FIELDS.zip(match.captures) do |field,value|
@@ -78,7 +84,8 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
   public
 
   def install
-    unless file = @resource[:source]
+    file = @resource[:source]
+    unless file
       raise ArgumentError, _("You cannot install dpkg packages without a source")
     end
     args = []
@@ -102,7 +109,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]
@@ -113,6 +124,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",
@@ -145,7 +170,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|
@@ -163,16 +188,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