puppet 5.3.4 → 6.29.0

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

@@ -90,9 +90,9 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
         elsif http_proxy_host and not http_proxy_port
           args << "--proxy" << http_proxy_host
         end
-      begin
-        curl *args
-          Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(" ")})"
+        begin
+          curl(*args)
+            Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(" ")})"
         rescue Puppet::ExecutionFailure
           Puppet.debug "curl #{args.join(" ")} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
           cached_source = source
@@ -102,7 +102,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
       if source =~ /\.dmg$/i
         # If you fix this to use open-uri again, you must update the docs above. -NF
         File.open(cached_source) do |dmg|
-          xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-noidme", "-mountrandom", "/tmp", dmg.path
+          xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
           hdiutil_info = Puppet::Util::Plist.parse_plist(xml_str)
           raise Puppet::Error.new(_("No disk entities returned by mount at %{path}") % { path: dmg.path }) unless hdiutil_info.has_key?("system-entities")
           mounts = hdiutil_info["system-entities"].collect { |entity|
@@ -140,11 +140,12 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
   end
 
   def install
-    source = nil
-    unless source = @resource[:source]
+    source = @resource[:source]
+    unless source
       raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package source."))
     end
-    unless name = @resource[:name]
+    name = @resource[:name]
+    unless name
       raise Puppet::Error.new(_("Mac OS X PKG DMGs must specify a package name."))
     end
     self.class.installpkgdmg(source,name)

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

@@ -11,47 +11,64 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
 
   has_feature :versionable
   has_feature :upgradeable
+  has_feature :install_options
 
   def self.get_query
     pkg(['query', '-a', '%n %v %o'])
   end
 
+  def self.get_resource_info(name)
+    pkg(['query', '%n %v %o', name])
+  end
+
+  def self.cached_version_list
+    @version_list ||= get_version_list
+  end
+
   def self.get_version_list
-    pkg(['version', '-voRL='])
+    @version_list = pkg(['version', '-voRL='])
   end
 
-  def self.get_latest_version(origin, version_list)
-    if latest_version = version_list.lines.find { |l| l =~ /^#{origin} / }
-      latest_version = latest_version.split(' ').last.split(')').first
+  def self.get_latest_version(origin)
+    latest_version = cached_version_list.lines.find { |l| l =~ /^#{origin} / }
+    if latest_version
+      _name, compare, status = latest_version.chomp.split(' ', 3)
+      if ['!', '?'].include?(compare)
+        return nil
+      end
+      latest_version = status.split(' ').last.split(')').first
       return latest_version
     end
     nil
   end
 
+  def self.parse_pkg_query_line(line)
+    name, version, origin = line.chomp.split(' ', 3)
+    latest_version  = get_latest_version(origin) || version
+
+    {
+      :ensure   => version,
+      :name     => name,
+      :provider => self.name,
+      :origin   => origin,
+      :version  => version,
+      :latest   => latest_version
+    }
+  end
+
   def self.instances
     packages = []
     begin
       info = self.get_query
-      version_list = self.get_version_list
+      get_version_list
 
       unless info
         return packages
       end
 
       info.lines.each do |line|
-
-        name, version, origin = line.chomp.split(" ", 3)
-        latest_version  = get_latest_version(origin, version_list) || version
-
-        pkg = {
-          :ensure   => version,
-          :name     => name,
-          :provider => self.name,
-          :origin   => origin,
-          :version  => version,
-          :latest   => latest_version
-        }
-        packages << new(pkg)
+        hash = parse_pkg_query_line(line)
+        packages << new(hash)
       end
 
       return packages
@@ -63,7 +80,8 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
   def self.prefetch(resources)
     packages = instances
     resources.each_key do |name|
-      if provider = packages.find{|p| p.name == name or p.origin == name }
+      provider = packages.find{|p| p.name == name or p.origin == name }
+      if provider
         resources[name].provider = provider
       end
     end
@@ -97,13 +115,16 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
     end
 
     if not source # install using default repo logic
-      args = ['install', '-qy', installname]
+      args = ['install', '-qy']
     elsif source.scheme == 'urn' # install from repo named in URN
       tag = repo_tag_from_urn(source.to_s)
-      args = ['install', '-qy', '-r', tag, installname]
+      args = ['install', '-qy', '-r', tag]
     else # add package located at URL
-      args = ['add', '-q', source.to_s]
+      args = ['add', '-q']
+      installname = source.to_s
     end
+    args += install_options if @resource[:install_options]
+    args << installname
 
     pkg(args)
   end
@@ -113,18 +134,23 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
   end
 
   def query
-    if @property_hash[:ensure] == nil
+    begin
+      output = self.class.get_resource_info(resource[:name])
+    rescue Puppet::ExecutionFailure
       return nil
-    else
-      version = @property_hash[:version]
-      return { :version => version }
     end
+
+    self.class.parse_pkg_query_line(output)
   end
 
   def version
     @property_hash[:version]
   end
 
+  def version=
+    pkg(['install', '-qfy', "#{resource[:name]}-#{resource[:version]}"])
+  end
+
   # Upgrade to the latest version
   def update
     install
@@ -140,4 +166,8 @@ Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package
     @property_hash[:origin]
   end
 
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
 end

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

@@ -152,9 +152,9 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
     # get passed to pkgutil via one or more -t options
     if resource[:source]
       sources = [resource[:source]].flatten
-      pkguti *[sources.map{|src| [ "-t", src ]}, *args].flatten
+      pkguti(*[sources.map{|src| [ "-t", src ]}, *args].flatten)
     else
-      pkguti *args.flatten
+      pkguti(*args.flatten)
     end
   end
 
@@ -169,7 +169,8 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
   end
 
   def query
-    if hash = pkgsingle(@resource)
+    hash = pkgsingle(@resource)
+    if hash
       hash
     else
       {:ensure => :absent}

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

@@ -5,8 +5,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   desc "Provides packaging support for Gentoo's portage system.
 
     This provider supports the `install_options` and `uninstall_options` attributes, which allows command-line
-    flags to be passed to emerge.  These options should be specified as a string (e.g. '--flag'), a hash
-    (e.g. {'--flag' => 'value'}), or an array where each element is either a string or a hash."
+    flags to be passed to emerge. These options should be specified as an array where each element is either a string or a hash."
 
   has_features :install_options, :purgeable, :reinstallable, :uninstall_options, :versionable, :virtual_packages
 
@@ -21,9 +20,9 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     end
   end
 
-  confine :operatingsystem => :gentoo
+  confine :osfamily => :gentoo
 
-  defaultfor :operatingsystem => :gentoo
+  defaultfor :osfamily => :gentoo
 
   def self.instances
     result_format = self.eix_result_format
@@ -40,7 +39,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
       search_output = nil
       Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
-        search_output = eix *(self.eix_search_arguments + ['--installed'])
+        search_output = eix(*(self.eix_search_arguments + ['--installed']))
       end
 
       packages = []
@@ -70,11 +69,11 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     name = qatom[:pfx] + name if qatom[:pfx]
     name = name + '-' + qatom[:pv] if qatom[:pv]
     name = name + '-' + qatom[:pr] if qatom[:pr]
-    name = name + qatom[:slot] if qatom[:slot]
+    name = name + ':' + qatom[:slot] if qatom[:slot]
     cmd << '--update' if [:latest].include?(should)
     cmd += install_options if @resource[:install_options]
     cmd << name
-    emerge *cmd
+    emerge(*cmd)
   end
 
   def uninstall
@@ -84,15 +83,15 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     name = qatom[:pfx] + name if qatom[:pfx]
     name = name + '-' + qatom[:pv] if qatom[:pv]
     name = name + '-' + qatom[:pr] if qatom[:pr]
-    name = name + qatom[:slot] if qatom[:slot]
+    name = name + ':' + qatom[:slot] if qatom[:slot]
     cmd += uninstall_options if @resource[:uninstall_options]
     cmd << name
     if [:purged].include?(should)
       Puppet::Util.withenv :CONFIG_PROTECT => "-*" do
-        emerge *cmd
+        emerge(*cmd)
       end
     else
-      emerge *cmd
+      emerge(*cmd)
     end
   end
 
@@ -109,16 +108,24 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     result_format = self.qatom_result_format
     result_fields = self.qatom_result_fields
     @atom ||= begin
-      search_output = nil
       package_info = {}
       # do the search
-      search_output = qatom_bin *([@resource[:name], '--format', output_format])
+      should = @resource[:ensure]
+      case should
+      # The terms present, absent, purged, held, installed, latest in :ensure 
+      # resolve as Symbols, and we do not need specific package version in this case
+      when true, false, Symbol
+        search = @resource[:name]
+      else
+        search = '=' + @resource[:name] + '-' + "#{should}"
+      end
+      search_output = qatom_bin(*([search, '--format', output_format]))
       # verify if the search found anything
       match = result_format.match(search_output)
       if match
         result_fields.zip(match.captures) do |field, value|
           # some fields can be empty or (null) (if we are not passed a category in the package name for instance)
-          if value == '(null)'
+          if value == '(null)' || value == '<unset>'
             package_info[field] = nil
           elsif !value or value.empty?
             package_info[field] = nil
@@ -134,7 +141,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
   end
 
   def qatom_output_format
-    '"[%{CATEGORY}] [%{PN}] [%{PV}] [%[PR]] [%[SLOT]] [%[pfx]] [%[sfx]]"'
+    '"[%[CATEGORY]] [%[PN]] [%[PV]] [%[PR]] [%[SLOT]] [%[pfx]] [%[sfx]]"'
   end
 
   def qatom_result_format
@@ -147,7 +154,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
   def self.get_sets
     @sets ||= begin
-      @sets = emerge *(['--list-sets'])
+      @sets = emerge(*(['--list-sets']))
     end
   end
 
@@ -170,9 +177,9 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
         package_sets << package_set.to_s.strip
       end
 
-      if @resource[:name].match(/^@/)
-         if package_sets.include?(@resource[:name][1..-1].to_s)
-           return({:name => "#{@resource[:name]}", :ensure => '9999', :version_available => nil, :installed_versions => nil, :installable_versions => "9999,"})
+      if @resource[:name] =~ /^@/
+        if package_sets.include?(@resource[:name][1..-1].to_s)
+          return({:name => "#{@resource[:name]}", :ensure => '9999', :version_available => nil, :installed_versions => nil, :installable_versions => "9999,"})
         end
       end
 
@@ -181,7 +188,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
 
       search_output = nil
       Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
-        search_output = eix *(self.class.eix_search_arguments + ['--exact',search_field,search_value])
+        search_output = eix(*(self.class.eix_search_arguments + ['--exact',search_field,search_value]))
       end
 
       packages = []
@@ -198,9 +205,11 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
           # ensure is what is currently installed
           # This DOES NOT choose to install/upgrade or not, just provides current info
           # prefer checking versions to slots as versions are finer grained
-          if qatom[:pv]
-            package[:version_available] = eix_get_version_for_versions(package[:installable_versions], qatom[:pv])
-            package[:ensure] = eix_get_version_for_versions(package[:installed_versions], qatom[:pv])
+          search = qatom[:pv]
+          search = search + '-' + qatom[:pr] if qatom[:pr]
+          if search
+            package[:version_available] = eix_get_version_for_versions(package[:installable_versions], search)
+            package[:ensure] = eix_get_version_for_versions(package[:installed_versions], search)
           elsif qatom[:slot]
             package[:version_available] = eix_get_version_for_slot(package[:slot_versions_available], qatom[:slot])
             package[:ensure] = eix_get_version_for_slot(package[:installed_slots], qatom[:slot])
@@ -248,7 +257,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     # [2.7.12: 2.7
     #  3.4.5:  3.4
     #  3.5.2:  3.5]
-    version_for_slot = versions_and_slots.find { |version_and_slot| version_and_slot.last == slot[1..-1] }
+    version_for_slot = versions_and_slots.find { |version_and_slot| version_and_slot.last == slot }
     # [3.5.2:  3.5]
     version_for_slot.first if version_for_slot
     # 3.5.2

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

@@ -52,7 +52,8 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     output.split("\n").each { |data|
       # reset hash to nil for each line
       hash.clear
-      if match = regex.match(data)
+      match = regex.match(data)
+      if match
         # Output matched regex
         fields.zip(match.captures) { |field, value|
           hash[field] = value

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

@@ -1,12 +1,10 @@
-require 'puppet/provider/package'
-
 Puppet::Type.type(:package).provide :puppet_gem, :parent => :gem do
   desc "Puppet Ruby Gem support. This provider is useful for managing
         gems needed by the ruby provided in the puppet-agent package."
 
   has_feature :versionable, :install_options, :uninstall_options
 
-  if Puppet.features.microsoft_windows?
+  if Puppet::Util::Platform.windows?
     # On windows, we put our ruby ahead of anything that already
     # existed on the system PATH. This means that we do not need to
     # sort out the absolute path.
@@ -14,4 +12,15 @@ Puppet::Type.type(:package).provide :puppet_gem, :parent => :gem do
   else
     commands :gemcmd => "/opt/puppetlabs/puppet/bin/gem"
   end
+
+  def uninstall
+    super
+    Puppet.debug("Invalidating rubygems cache after uninstalling gem '#{resource[:name]}'")
+    Puppet::Util::Autoload.gem_source.clear_paths
+  end
+
+  def self.execute_gem_command(command, command_options, custom_environment = {})
+    custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig' unless Puppet::Util::Platform.windows?
+    super(command, command_options, custom_environment)
+  end
 end

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

@@ -0,0 +1,171 @@
+unless Puppet::Util::Platform.jruby_fips?
+  require 'rubygems/commands/list_command'
+end
+require 'stringio'
+require 'uri'
+
+# Ruby gems support.
+Puppet::Type.type(:package).provide :puppetserver_gem, :parent => :gem do
+  desc "Puppet Server Ruby Gem support. If a URL is passed via `source`, then
+    that URL is appended to the list of remote gem repositories which by default
+    contains rubygems.org; To ensure that only the specified source is used also
+    pass `--clear-sources` in via `install_options`; if a source is present but
+    is not a valid URL, it will be interpreted as the path to a local gem file.
+    If source is not present at all, the gem will be installed from the default
+    gem repositories."
+
+  has_feature :versionable, :install_options, :uninstall_options
+
+  confine :feature => :hocon
+  # see SERVER-2578
+  confine :fips_enabled => false
+
+  # Define the default provider package command name, as the parent 'gem' provider is targetable.
+  # Required by Puppet::Provider::Package::Targetable::resource_or_provider_command
+
+  def self.provider_command
+    command(:puppetservercmd)
+  end
+
+  # The gem command uses HOME to locate a gemrc file.
+  # CommandDefiner in provider.rb will set failonfail, combine, and environment.
+
+  has_command(:puppetservercmd, '/opt/puppetlabs/bin/puppetserver') do
+    environment(HOME: ENV['HOME'])
+  end
+
+  def self.gemlist(options)
+    command_options = ['gem', 'list']
+
+    if options[:local]
+      command_options << '--local'
+    else
+      command_options << '--remote'
+    end
+
+    if options[:source]
+      command_options << '--source' << options[:source]
+    end
+
+    if options[:justme]
+      gem_regex = '\A' + options[:justme] + '\z'
+      command_options << gem_regex
+    end
+
+    if options[:local]
+      list = execute_rubygems_list_command(command_options)
+    else
+      begin
+        list = puppetservercmd(command_options)
+      rescue Puppet::ExecutionFailure => detail
+        raise Puppet::Error, _("Could not list gems: %{detail}") % { detail: detail }, detail.backtrace
+      end
+    end
+
+    # When `/tmp` is mounted `noexec`, `puppetserver gem list` will output:
+    # *** LOCAL GEMS ***
+    # causing gemsplit to output:
+    # Warning: Could not match *** LOCAL GEMS ***
+    gem_list = list
+                 .lines
+                 .select { |x| x =~ /^(\S+)\s+\((.+)\)/ }
+                 .map { |set| gemsplit(set) }
+
+    if options[:justme]
+      return gem_list.shift
+    else
+      return gem_list
+    end
+  end
+
+  def install(useversion = true)
+    command_options = ['gem', 'install']
+    command_options += install_options if resource[:install_options]
+
+    command_options << '-v' << resource[:ensure] if (!resource[:ensure].is_a? Symbol) && useversion
+
+    command_options << '--no-document'
+
+    if resource[:source]
+      begin
+        uri = URI.parse(resource[:source])
+      rescue => detail
+        self.fail Puppet::Error, _("Invalid source '%{uri}': %{detail}") % { uri: uri, detail: detail }, detail
+      end
+
+      case uri.scheme
+      when nil
+        # no URI scheme => interpret the source as a local file
+        command_options << resource[:source]
+      when /file/i
+        command_options << uri.path
+      when 'puppet'
+        # we don't support puppet:// URLs (yet)
+        raise Puppet::Error.new(_('puppet:// URLs are not supported as gem sources'))
+      else
+        # interpret it as a gem repository
+        command_options << '--source' << "#{resource[:source]}" << resource[:name]
+      end
+    else
+      command_options << resource[:name]
+    end
+
+    output = puppetservercmd(command_options)
+    # Apparently, some gem versions don't exit non-0 on failure.
+    self.fail _("Could not install: %{output}") % { output: output.chomp } if output.include?('ERROR')
+  end
+
+  def uninstall
+    command_options = ['gem', 'uninstall']
+    command_options << '--executables' << '--all' << resource[:name]
+    command_options += uninstall_options if resource[:uninstall_options]
+
+    output = puppetservercmd(command_options)
+    # Apparently, some gem versions don't exit non-0 on failure.
+    self.fail _("Could not uninstall: %{output}") % { output: output.chomp } if output.include?('ERROR')
+  end
+
+  private
+
+  # The puppetserver gem cli command is very slow, since it starts a JVM.
+  #
+  # Instead, for the list subcommand (which is executed with every puppet run),
+  # use the rubygems library from puppet ruby: setting GEM_HOME and GEM_PATH
+  # to the default values, or the values in the puppetserver configuration file.
+  #
+  # The rubygems library cannot access java platform gems,
+  # for example: json (1.8.3 java)
+  # but java platform gems should not be managed by this (or any) provider.
+
+  def self.execute_rubygems_list_command(command_options)
+    puppetserver_default_gem_home            = '/opt/puppetlabs/server/data/puppetserver/jruby-gems'
+    puppetserver_default_vendored_jruby_gems = '/opt/puppetlabs/server/data/puppetserver/vendored-jruby-gems'
+    puppet_default_vendor_gems               = '/opt/puppetlabs/puppet/lib/ruby/vendor_gems'
+    puppetserver_default_gem_path = [puppetserver_default_gem_home, puppetserver_default_vendored_jruby_gems, puppet_default_vendor_gems].join(':')
+
+    pe_puppetserver_conf_file = '/etc/puppetlabs/puppetserver/conf.d/pe-puppet-server.conf'
+    os_puppetserver_conf_file = '/etc/puppetlabs/puppetserver/puppetserver.conf'
+    puppetserver_conf_file = Puppet.runtime[:facter].value(:pe_server_version) ? pe_puppetserver_conf_file : os_puppetserver_conf_file
+    puppetserver_conf = Hocon.load(puppetserver_conf_file)
+
+    gem_env = {}
+    if puppetserver_conf.empty? || puppetserver_conf.key?('jruby-puppet') == false
+      gem_env['GEM_HOME'] = puppetserver_default_gem_home
+      gem_env['GEM_PATH'] = puppetserver_default_gem_path
+    else
+      gem_env['GEM_HOME'] = puppetserver_conf['jruby-puppet'].key?('gem-home') ? puppetserver_conf['jruby-puppet']['gem-home'] : puppetserver_default_gem_home
+      gem_env['GEM_PATH'] = puppetserver_conf['jruby-puppet'].key?('gem-path') ? puppetserver_conf['jruby-puppet']['gem-path'].join(':') : puppetserver_default_gem_path
+    end
+    gem_env['GEM_SPEC_CACHE'] = "/tmp/#{$$}"
+
+    # Remove the 'gem' from the command_options
+    command_options.shift
+    gem_out = execute_gem_command(Puppet::Type::Package::ProviderPuppet_gem.provider_command, command_options, gem_env)
+
+    # There is no method exclude default gems from the local gem list,
+    # for example: psych (default: 2.2.2)
+    # but default gems should not be managed by this (or any) provider.
+    gem_list = gem_out.lines.reject { |gem| gem =~ / \(default\: / }
+    gem_list.join("\n")
+  end
+end