puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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 =~ /^\d+$/ }
+    ids = dscl_out.split.compact.collect { |l| l.to_i if l.match(/^\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}del", @resource[:name]]
+      [command(:pw), "#{@resource.class.name.to_s}del", @resource[:name]]
     end
 
     def modifycmd(param, value)
       cmd = [
           command(:pw),
-          "#{@resource.class.name}mod",
+          "#{@resource.class.name.to_s}mod",
           @resource[:name],
           flag(param),
           munge(param, value)

data/lib/puppet/provider/package.rb

@@ -1,5 +1,3 @@
-require 'puppet/provider'
-
 class Puppet::Provider::Package < Puppet::Provider
   # Prefetch our package list, yo.
   def self.prefetch(packages)

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

@@ -29,15 +29,6 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
 
   attr_accessor   :latest_info
 
-  STATE_CODE = {
-    'A' => :applied,
-    'B' => :broken,
-    'C' => :committed,
-    'E' => :efix_locked,
-    'O' => :obsolete,
-    '?' => :inconsistent,
-  }.freeze
-
   def self.srclistcmd(source)
     [ command(:installp), "-L", "-d", source ]
   end
@@ -105,11 +96,6 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
     if output =~ /^#{Regexp.escape(@resource[:name])}\s+.*\s+Already superseded by.*$/
       self.fail _("aix package provider is unable to downgrade packages")
     end
-
-    pkg_info = query
-    if pkg_info && [:broken, :inconsistent].include?(pkg_info[:status])
-      self.fail _("Package '%{name}' is in a %{status} state and requires manual intervention") % { name: @resource[:name], status: pkg_info[:status] }
-    end
   end
 
   def self.pkglist(hash = {})
@@ -120,9 +106,8 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
     end
 
     begin
-      list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*):[^:]*:[^:]*:([^:])/).collect { |n,e,s|
-        e = :absent if [:broken, :inconsistent].include?(STATE_CODE[s])
-        { :name => n, :ensure => e, :status => STATE_CODE[s], :provider => self.name }
+      list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*)/).collect { |n,e|
+        { :name => n, :ensure => e, :provider => self.name }
       }
     rescue Puppet::ExecutionFailure => detail
       if hash[:pkgname]

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

@@ -70,12 +70,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     cmd += install_options if @resource[:install_options]
     cmd << :install << str
 
-    self.unhold if self.properties[:mark] == :hold
-    begin
-      aptget(*cmd)
-    ensure
-      self.hold if @resource[:mark] == :hold
-    end
+    aptget(*cmd)
   end
 
   # What's the latest package version available?
@@ -105,18 +100,12 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
 
   def uninstall
     self.run_preseed if @resource[:responsefile]
-    args = ['-y', '-q']
-    args << '--allow-change-held-packages' if self.properties[:mark] == :hold
-    args << :remove << @resource[:name]
-    aptget(*args)
+    aptget "-y", "-q", :remove, @resource[:name]
   end
 
   def purge
     self.run_preseed if @resource[:responsefile]
-    args = ['-y', '-q']
-    args << '--allow-change-held-packages' if self.properties[:mark] == :hold
-    args << :remove << '--purge' << @resource[:name]
-    aptget(*args)
+    aptget '-y', '-q', :remove, '--purge', @resource[:name]
     # workaround a "bug" in apt, that already removed packages are not purged
     super
   end

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

@@ -9,7 +9,7 @@ Puppet::Type.type(:package).provide :dnf, :parent => :yum do
   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."
 
-  has_feature :install_options, :versionable, :virtual_packages, :install_only
+  has_feature :install_options, :versionable, :virtual_packages
 
   commands :cmd => "dnf", :rpm => "rpm"
 
@@ -28,8 +28,8 @@ Puppet::Type.type(:package).provide :dnf, :parent => :yum do
       end
   end
 
-  defaultfor :operatingsystem => :fedora, :operatingsystemmajrelease => (22..30).to_a
-  defaultfor :osfamily => :redhat, :operatingsystemmajrelease => ["8"]
+  defaultfor :operatingsystem => :fedora
+  notdefaultfor :operatingsystem => :fedora, :operatingsystemmajrelease => (19..21).to_a
 
   def self.update_command
     # In DNF, update is deprecated for upgrade

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

@@ -44,7 +44,7 @@ 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::FIELDS_REGEX = %r{^'?(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
+  self::FIELDS_REGEX = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
   self::FIELDS= [:desired, :error, :status, :name, :ensure]
 
   # @param line [String] one line of dpkg-query output
@@ -67,7 +67,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[:mark] = :hold if hash[:desired] == 'hold'
+      hash[:ensure] = :held if hash[:desired] == 'hold'
     else
       Puppet.debug("Failed to match dpkg-query line #{line.inspect}")
     end
@@ -81,8 +81,11 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     unless file = @resource[:source]
       raise ArgumentError, _("You cannot install dpkg packages without a source")
     end
+
     args = []
 
+    # We always unhold when installing to remove any prior hold.
+    self.unhold
 
     if @resource[:configfiles] == :keep
       args << '--force-confold'
@@ -91,12 +94,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
     args << '-i' << file
 
-    self.unhold if self.properties[:mark] == :hold
-    begin
-      dpkg(*args)
-    ensure
-      self.hold if @resource[:mark] == :hold
-    end
+    dpkg(*args)
   end
 
   def update
@@ -147,14 +145,8 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     dpkg "--purge", @resource[:name]
   end
 
-  def deprecated_hold
-    if package_not_installed?
-      self.install
-    end
-    hold
-  end
-
   def hold
+    self.install
     Tempfile.open('puppet_dpkg_set_selection') do |tmpfile|
       tmpfile.write("#{@resource[:name]} hold\n")
       tmpfile.flush
@@ -170,7 +162,4 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
   end
 
-  def package_not_installed?
-    query[:status] != "installed"
-  end
 end

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

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

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

@@ -1,8 +1,8 @@
-require 'puppet/provider/package_targetable'
+require 'puppet/provider/package'
 require 'uri'
 
 # Ruby gems support.
-Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::Targetable do
+Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package do
   desc "Ruby Gem support. If a URL is passed via `source`, then that URL is
     appended to the list of remote gem repositories; to ensure that only the
     specified source is used, also pass `--clear-sources` via `install_options`.
@@ -15,81 +15,27 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     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."
 
-  has_feature :versionable, :install_options, :uninstall_options, :targetable
+  has_feature :versionable, :install_options, :uninstall_options
 
-  # Override the specificity method to return 1 if gem is not set as default provider
-  def self.specificity
-    match = default_match
-    length = match ? match.length : 0
-
-    return 1 if length == 0
-
-    super
-  end
-
-  # 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
-    command(:gemcmd)
-  end
-
-  # Define the default provider package command as optional when the provider is targetable.
-  # Doing do defers the evaluation of provider suitability until all commands are evaluated.
-
-  has_command(:gemcmd, 'gem') do
-    is_optional
-  end
-
-  # CommandDefiner in provider.rb creates convenience execution methods that set failonfail, combine, and optionally, environment.
-  # And when a child provider defines its own command via commands() or has_command(), the provider-specific path is always returned by command().
-  # But when the convenience execution method is invoked, the last convenience method to be defined is executed.
-  # This makes invoking those convenience execution methods unsuitable for inherited providers.
-  #
-  # In this case, causing the puppet_gem provider to inherit the parent gem provider's convenience gemcmd() methods, with the wrong path.
-
-  def self.execute_gem_command(command, command_options, custom_environment = {})
-    validate_command(command)
-    cmd = [command] << command_options
-
-    custom_environment = {'HOME'=>Puppet::Util.get_env('HOME')}.merge(custom_environment)
-
-    execute(cmd, {:failonfail => true, :combine => true, :custom_environment => custom_environment})
-  end
-
-  def self.instances(target_command = nil)
-    if target_command
-      command = target_command
-    else
-      command = provider_command
-      # The default provider package command is optional.
-      return [] unless command
-    end
-
-    gemlist(:command => command, :local => true).collect do |pkg|
-      # Track the command when the provider is targetable.
-      pkg[:command] = command
-      new(pkg)
-    end
-  end
+  commands :gemcmd => "gem"
 
   def self.gemlist(options)
-    command_options = ["list"]
+    gem_list_command = [command(:gemcmd), "list"]
 
     if options[:local]
-      command_options << "--local"
+      gem_list_command << "--local"
     else
-      command_options << "--remote"
+      gem_list_command << "--remote"
     end
     if options[:source]
-      command_options << "--source" << options[:source]
+      gem_list_command << "--source" << options[:source]
     end
     if name = options[:justme]
-      command_options << '\A' + name + '\z'
+      gem_list_command << '\A' + name + '\z'
     end
 
     begin
-      list = execute_gem_command(options[:command], command_options).lines.
+      list = execute(gem_list_command, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).lines.
         map {|set| gemsplit(set) }.
         reject {|x| x.nil? }
     rescue Puppet::ExecutionFailure => detail
@@ -124,6 +70,12 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     end
   end
 
+  def self.instances(justme = false)
+    gemlist(:local => true).collect do |hash|
+      new(hash)
+    end
+  end
+
   def insync?(is)
     return false unless is && is != :absent
 
@@ -140,27 +92,14 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
     is.any? { |version| dependency.match?('', version) }
   end
 
-  def rubygem_version(command)
-    command_options = ["--version"]
-    self.class.execute_gem_command(command, command_options)
-  end
-
   def install(useversion = true)
-    command = resource_or_provider_command
-    command_options = ["install"]
-    command_options += install_options if resource[:install_options]
-
-    if Puppet.features.microsoft_windows?
+    command = [command(:gemcmd), "install"]
+    command += install_options if resource[:install_options]
+    if Puppet::Util::Platform.windows?
       version = resource[:ensure]
-      command_options << "-v" << %Q["#{version}"] if (! resource[:ensure].is_a? Symbol) and useversion
-    else
-      command_options << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
-    end
-
-    if Puppet::Util::Package.versioncmp(rubygem_version(command), '2.0.0') == -1
-      command_options << "--no-rdoc" << "--no-ri"
+      command << "-v" << %Q["#{version}"] if (! resource[:ensure].is_a? Symbol) and useversion
     else
-      command_options << "--no-document"
+      command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
     end
 
     if source = resource[:source]
@@ -173,53 +112,52 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::
       case uri.scheme
       when nil
         # no URI scheme => interpret the source as a local file
-        command_options << source
+        command << source
       when /file/i
-        command_options << uri.path
+        command << uri.path
       when 'puppet'
         # we don't support puppet:// URLs (yet)
         raise Puppet::Error.new(_("puppet:// URLs are not supported as gem sources"))
       else
         # check whether it's an absolute file path to help Windows out
         if Puppet::Util.absolute_path?(source)
-          command_options << source
+          command << source
         else
           # interpret it as a gem repository
-          command_options << "--source" << "#{source}" << resource[:name]
+          command << "--source" << "#{source}" << resource[:name]
         end
       end
     else
-      command_options << resource[:name]
+      command << "--no-rdoc" << "--no-ri" << resource[:name]
     end
 
-    output = self.class.execute_gem_command(command, command_options)
-    # Apparently some gem versions don't exit non-0 on failure.
+    output = execute(command, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}})
+    # Apparently some stupid gem versions don't exit non-0 on failure
     self.fail _("Could not install: %{output}") % { output: output.chomp } if output.include?("ERROR")
   end
 
   def latest
-    command = resource_or_provider_command
-    options = { :command => command, :justme => resource[:name] }
-    options[:source] = resource[:source] unless resource[:source].nil?
-    pkg = self.class.gemlist(options)
-    pkg[:ensure][0]
+    # This always gets the latest version available.
+    gemlist_options = {:justme => resource[:name]}
+    gemlist_options.merge!({:source => resource[:source]}) unless resource[:source].nil?
+    hash = self.class.gemlist(gemlist_options)
+
+    hash[:ensure][0]
   end
 
   def query
-    command = resource_or_provider_command
-    options = { :command => command, :justme => resource[:name], :local => true }
-    pkg = self.class.gemlist(options)
-    pkg[:command] = command unless pkg.nil?
-    pkg
+    self.class.gemlist(:justme => resource[:name], :local => true)
   end
 
   def uninstall
-    command = resource_or_provider_command
-    command_options = ["uninstall"]
-    command_options << "--executables" << "--all" << resource[:name]
-    command_options += uninstall_options if resource[:uninstall_options]
-    output = self.class.execute_gem_command(command, command_options)
-    # Apparently some gem versions don't exit non-0 on failure.
+    command = [command(:gemcmd), "uninstall"]
+    command << "--executables" << "--all" << resource[:name]
+
+    command += uninstall_options if resource[:uninstall_options]
+
+    output = execute(command, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}})
+
+    # Apparently some stupid gem versions don't exit non-0 on failure
     self.fail _("Could not uninstall: %{output}") % { output: output.chomp } if output.include?("ERROR")
   end