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

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

@@ -9,7 +9,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm 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 => "yum", :rpm => "rpm"
 
@@ -25,8 +25,6 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
 
   defaultfor :osfamily => :redhat
 
-  VERSION_REGEX = /^(?:(\d+):)?(\S+)-(\S+)$/
-
   def self.prefetch(packages)
     raise Puppet::Error, _("The yum provider can only be used as root") if Process.euid != 0
     super
@@ -88,29 +86,28 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   end
 
   def self.parse_updates(str)
-    # Strip off all content that contains Obsoleting, Security: or Update
-    body = str.partition(/^(Obsoleting|Security:|Update)/).first
+    # Strip off all content before the first blank line
+    body = str.partition(/^\s*\n/m).last
 
     updates = Hash.new { |h, k| h[k] = [] }
-
-    body.split(/^\s*\n/).each do |line|
-      line.split.each_slice(3) do |tuple|
-        next unless tuple[0].include?('.') && tuple[1] =~ VERSION_REGEX
-
-        hash = update_to_hash(*tuple[0..1])
-        # Create entries for both the package name without a version and a
-        # version since yum considers those as mostly interchangeable.
-        short_name = hash[:name]
-        long_name  = "#{hash[:name]}.#{hash[:arch]}"
-        updates[short_name] << hash
-        updates[long_name] << hash
-      end
+    body.split.each_slice(3) do |tuple|
+      break if tuple[0] =~ /^(Obsoleting|Security:|Update)/
+      break unless tuple[1].match(/^(?:(\d+):)?(\S+)-(\S+)$/)
+      hash = update_to_hash(*tuple[0..1])
+      # Create entries for both the package name without a version and a
+      # version since yum considers those as mostly interchangeable.
+      short_name = hash[:name]
+      long_name  = "#{hash[:name]}.#{hash[:arch]}"
+
+      updates[short_name] << hash
+      updates[long_name] << hash
     end
+
     updates
   end
 
   def self.update_to_hash(pkgname, pkgversion)
-
+    
     # The pkgname string has two parts: name, and architecture. Architecture
     # is the portion of the string following the last "." character. All
     # characters preceding the final dot are the package name. Parse out
@@ -120,7 +117,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
       raise _("Failed to parse package name and architecture from '%{pkgname}'") % { pkgname: pkgname }
     end
 
-    match = pkgversion.match(VERSION_REGEX)
+    match = pkgversion.match(/^(?:(\d+):)?(\S+)-(\S+)$/)
     epoch = match[1] || '0'
     version = match[2]
     release = match[3]
@@ -206,10 +203,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
       end
       current_package = self.query
       if current_package
-        if @resource[:install_only]
-          self.debug "Updating package #{@resource[:name]} from version #{current_package[:ensure]} to #{should} as install_only packages are never downgraded"
-          operation = update_command
-        elsif rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(current_package[:ensure])) < 0
+        if rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(current_package[:ensure])) < 0
           self.debug "Downgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
           operation = :downgrade
         elsif rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(current_package[:ensure])) > 0
@@ -234,11 +228,10 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
       is = self.query
       raise Puppet::Error, _("Could not find package %{name}") % { name: self.name } unless is
 
-      version = is[:ensure]
       # FIXME: Should we raise an exception even if should == :latest
       # and yum updated us to a version other than @param_hash[:ensure] ?
-      raise Puppet::Error, _("Failed to update to version %{should}, got version %{version} instead") % { should: should, version: version } unless
-        insync?(version)
+      vercmp_result = rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(is[:ensure]))
+      raise Puppet::Error, _("Failed to update to version %{should}, got version %{version} instead") % { should: should, version: is[:ensure] } if vercmp_result != 0
     end
   end
 
@@ -251,7 +244,6 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
       return "#{upd[:epoch]}:#{upd[:version]}-#{upd[:release]}"
     else
       # Yum didn't find updates, pretend the current version is the latest
-      self.debug "Yum didn't find updates, current version (#{properties[:ensure]}) is the latest"
       version = properties[:ensure]
       raise Puppet::DevError, _("Tried to get latest on a missing package") if version == :absent || version == :purged
       return version
@@ -290,16 +282,12 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   # @param key [String] The key to look for in all contained hashes
   # @return [Array<String>] All hash values with the given key.
   def scan_options(options, key)
-    return [] unless options.is_a?(Enumerable)
-    values = options.map do | repo |
-      value = if repo.is_a?(String)
-        next unless repo.include?('=')
-        Hash[*repo.strip.split('=')] # make it a hash
-      else
-        repo
+    return [] if options.nil?
+    options.inject([]) do |repos, opt|
+      if opt.is_a? Hash and opt[key]
+        repos << opt[key]
       end
-      value[key]
+      repos
     end
-    values.compact.uniq
   end
 end

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

@@ -89,7 +89,6 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm, :source => :rpm do
     options = []
     options << quiet
     options << '--no-gpg-check' unless inst_opts.delete('--no-gpg-check').nil?
-    options << '--no-gpg-checks' unless inst_opts.delete('--no-gpg-checks').nil?
     options << :install
 
     #zypper 0.6.13 (OpenSuSE 10.2) does not support auto agree with licenses

data/lib/puppet/provider/parsedfile.rb

@@ -10,17 +10,11 @@ require 'puppet/util/fileparsing'
 #
 # Once the provider prefetches the data, it's the resource's job to copy
 # that data over to the @is variables.
-#
-# NOTE: The prefetch method swallows FileReadErrors by treating the
-# corresponding target as an empty file. If you would like to turn this
-# behavior off, then set the raise_prefetch_errors class variable to
-# true. Doing so will error all resources associated with the failed
-# target.
 class Puppet::Provider::ParsedFile < Puppet::Provider
   extend Puppet::Util::FileParsing
 
   class << self
-    attr_accessor :default_target, :target, :raise_prefetch_errors
+    attr_accessor :default_target, :target
   end
 
   attr_accessor :property_hash
@@ -71,7 +65,7 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
     flushed = []
     begin
-      @modified.sort_by(&:to_s).uniq.each do |target|
+      @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
         Puppet.debug "Flushing #{@resource_type.name} provider target #{target}"
         flushed << target
         flush_target(target)
@@ -95,10 +89,6 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
   # Flush all of the records relating to a specific target.
   def self.flush_target(target)
-    if @raise_prefetch_errors && @failed_prefetch_targets.key?(target)
-      raise Puppet::Error, _("Failed to read %{target}'s records when prefetching them. Reason: %{detail}") % { target: target, detail: @failed_prefetch_targets[target] }
-    end
-
     backup_target(target)
 
     records = target_records(target).reject { |r|
@@ -152,10 +142,6 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
     @records = []
     @target_objects = {}
 
-    # Hash of <target> => <failure reason>.
-    @failed_prefetch_targets = {}
-    @raise_prefetch_errors = false
-
     @target = nil
 
     # Default to flat files
@@ -274,19 +260,12 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
   # Prefetch an individual target.
   def self.prefetch_target(target)
+
     begin
       target_records = retrieve(target)
     rescue Puppet::Util::FileType::FileReadError => detail
-      if @raise_prefetch_errors
-        # We will raise an error later in flush_target. This way,
-        # only the resources linked to our target will fail
-        # evaluation.
-        @failed_prefetch_targets[target] = detail.to_s
-      else
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err _("Could not prefetch %{resource} provider '%{name}' target '%{target}': %{detail}. Treating as empty") % { resource: self.resource_type.name, name: self.name, target: target, detail: detail }
-      end
-
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err _("Could not prefetch %{resource} provider '%{name}' target '%{target}': %{detail}. Treating as empty") % { resource: self.resource_type.name, name: self.name, target: target, detail: detail }
       target_records = []
     end
 

data/lib/puppet/provider/service/base.rb

@@ -46,7 +46,7 @@ Puppet::Type.type(:service).provide :base, :parent => :service do
     # If that fails, force to UTF-8 and then scrub as most uses are scanning
     # for ACII-compatible program names.
     table.force_encoding(Encoding::UTF_8) unless table.encoding == Encoding::UTF_8
-    table = Puppet::Util::CharacterEncoding.scrub(table) unless table.valid_encoding?
+    table = table.scrub unless table.valid_encoding?
 
     table.each_line { |line|
       if regex.match(line)

data/lib/puppet/provider/service/daemontools.rb

@@ -46,8 +46,14 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
 
     # Determine the daemon path.
     def defpath
-      @defpath ||= ["/var/lib/service", "/etc"].find do |path|
-        Puppet::FileSystem.exist?(path) && FileTest.directory?(path)
+      unless @defpath
+        ["/var/lib/service", "/etc"].each do |path|
+          if Puppet::FileSystem.exist?(path)
+            @defpath = path
+            break
+          end
+        end
+        raise "Could not find the daemon directory (tested [/var/lib/service,/etc])" unless @defpath
       end
       @defpath
     end
@@ -59,10 +65,6 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
   # ie enabled or not
   def self.instances
     path = self.defpath
-    unless path
-      Puppet.info("#{self.name} is unsuitable because service directory is nil")
-      return
-    end
     unless FileTest.directory?(path)
       Puppet.notice "Service path #{path} does not exist"
       return
@@ -107,9 +109,7 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
   # note that this path can be overridden in the resource
   # definition
   def daemon
-    path = resource[:path]
-    raise Puppet::Error.new("#{self.class.name} must specify a path for daemon directory") unless path
-    File.join(path, resource[:name])
+    File.join(resource[:path], resource[:name])
   end
 
   def status

data/lib/puppet/provider/service/debian.rb

@@ -19,6 +19,7 @@ Puppet::Type.type(:service).provide :debian, :parent => :init do
 
   defaultfor :operatingsystem => :cumuluslinux, :operatingsystemmajrelease => ['1','2']
   defaultfor :operatingsystem => :debian, :operatingsystemmajrelease => ['5','6','7']
+  defaultfor :operatingsystem => :devuan
 
   # Remove the symlinks
   def disable

data/lib/puppet/provider/service/launchd.rb

@@ -196,22 +196,6 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     Puppet::Util::Plist.read_plist_file(path)
   end
 
-  # Read overrides plist, retrying if necessary
-  def self.read_overrides
-    i = 1
-    overrides = nil
-    loop do
-      Puppet.debug(_("Reading overrides plist, attempt %{i}") % {i: i}) if i > 1
-      overrides = read_plist(launchd_overrides)
-      break unless overrides.nil?
-      raise Puppet::Error.new(_('Unable to read overrides plist, too many attempts')) if i == 20
-      Puppet.info(_('Overrides file could not be read, trying again.'))
-      Kernel.sleep(0.1)
-      i += 1
-    end
-    overrides
-  end
-
   # Clean out the @property_hash variable containing the cached list of services
   def flush
     @property_hash.clear
@@ -240,20 +224,12 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   def status
     if @resource && ((@resource[:hasstatus] == :false) || (@resource[:status]))
       return super
-    elsif @property_hash[:status].nil?
-      # property_hash was flushed so the service changed status
-      service_name = @resource[:name]
-      # Updating services with new statuses
-      job_list = self.class.job_list
-      # if job is present in job_list, return its status
-      if job_list.key?(service_name)
-        job_list[service_name]
-      # if job is no longer present in job_list, it was stopped
+    else
+      if @property_hash[:status].nil?
+        :absent
       else
-        :stopped
+        @property_hash[:status]
       end
-    else
-      @property_hash[:status]
     end
   end
 
@@ -321,17 +297,10 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     job_plist_disabled = nil
     overrides_disabled = nil
 
-    begin
-      _, job_plist = plist_from_label(resource[:name])
-    rescue Puppet::Error => err
-      # if job does not exist, log the error and return false as on other platforms
-      Puppet.log_exception(err)
-      return :false
-    end
-
+    _, job_plist = plist_from_label(resource[:name])
     job_plist_disabled = job_plist["Disabled"] if job_plist.has_key?("Disabled")
 
-    if FileTest.file?(self.class.launchd_overrides) and overrides = self.class.read_overrides
+    if FileTest.file?(self.class.launchd_overrides) and overrides = self.class.read_plist(self.class.launchd_overrides)
       if overrides.has_key?(resource[:name])
         if self.class.get_os_version < 14
           overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
@@ -355,7 +324,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   # rather than dealing with launchctl as it is unable to change the Disabled flag
   # without actually loading/unloading the job.
   def enable
-    overrides = self.class.read_overrides
+    overrides = self.class.read_plist(self.class.launchd_overrides)
     if self.class.get_os_version < 14
       overrides[resource[:name]] = { "Disabled" => false }
     else
@@ -365,7 +334,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   end
 
   def disable
-    overrides = self.class.read_overrides
+    overrides = self.class.read_plist(self.class.launchd_overrides)
     if self.class.get_os_version < 14
       overrides[resource[:name]] = { "Disabled" => true }
     else

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

@@ -79,7 +79,7 @@ Puppet::Type.type(:service).provide :openbsd, :parent => :init do
   def running?
     output = execute([command(:rcctl), "check", @resource[:name]],
                      :failonfail => false, :combine => false, :squelch => false).chomp
-    return true if output =~ /\(ok\)/
+    return true if output.match(/\(ok\)/)
   end
 
   # Uses the wrapper to prevent failure when the service is not running;

data/lib/puppet/provider/service/rcng.rb

@@ -17,7 +17,7 @@ Puppet::Type.type(:service).provide :rcng, :parent => :bsd do
     if Puppet::FileSystem.exist?(rcfile)
       File.open(rcfile).readlines.each do |line|
         # Now look for something that looks like "service=${service:=YES}" or "service=YES"
-        if line =~ /^\s*#{@resource[:name]}=(?:YES|\${#{@resource[:name]}:=YES})/
+        if line.match(/^\s*#{@resource[:name]}=(?:YES|\${#{@resource[:name]}:=YES})/)
           return :true
         end
       end
@@ -34,7 +34,7 @@ Puppet::Type.type(:service).provide :rcng, :parent => :bsd do
     if Puppet::FileSystem.exist?(rcfile)
       newcontents = []
       File.open(rcfile).readlines.each do |line|
-        if line =~ /^\s*#{@resource[:name]}=(NO|\$\{#{@resource[:name]}:NO\})/
+        if line.match(/^\s*#{@resource[:name]}=(NO|\$\{#{@resource[:name]}:NO\})/)
           line = "#{@resource[:name]}=${#{@resource[:name]}:=YES}"
         end
         newcontents.push(line)

data/lib/puppet/provider/service/runit.rb

@@ -40,8 +40,14 @@ Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
     # this is necessary to autodetect a valid resource
     # default path, since there is no standard for such directory.
     def defpath
-      @defpath ||= ["/var/lib/service", "/etc/sv"].find do |path|
-        Puppet::FileSystem.exist?(path) && FileTest.directory?(path)
+      unless @defpath
+        ["/etc/sv", "/var/lib/service"].each do |path|
+          if Puppet::FileSystem.exist?(path)
+            @defpath = path
+            break
+          end
+        end
+        raise "Could not find the daemon directory (tested [/etc/sv,/var/lib/service])" unless @defpath
       end
       @defpath
     end

data/lib/puppet/provider/service/smf.rb

@@ -49,52 +49,6 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
    end
   end
 
-  # Returns the service's FMRI. We fail if multiple FMRIs correspond to
-  # @resource[:name].
-  #
-  # If the service does not exist or we fail to get any FMRIs from svcs,
-  # this method will raise a Puppet::Error
-  def service_fmri
-    return @fmri if @fmri
-
-    # `svcs -l` is better to use because we can detect service instances
-    # that have not yet been activated or enabled (i.e. it lets us detect
-    # services that svcadm has not yet touched). `svcs -H -o fmri` is a bit
-    # more limited.
-    lines = svcs("-l", @resource[:name]).chomp.lines.to_a
-    lines.select! { |line| line =~ /^fmri/ }
-    fmris = lines.map! { |line| line.split(' ')[-1].chomp }
-    unless fmris.length == 1
-      raise Puppet::Error, _("Failed to get the FMRI of the %{service} service: The pattern '%{service}' matches multiple FMRIs! These are the FMRIs it matches: %{all_fmris}") % { service: @resource[:name], all_fmris: fmris.join(', ') }
-    end
-
-    @fmri = fmris.first
-  end
-
-  # Returns true if the provider supports incomplete services.
-  def supports_incomplete_services?
-    Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemrelease), '11.1') >= 0
-  end
-
-  # Returns true if the service is complete. A complete service is a service that
-  # has the general/complete property defined.
-  def complete_service?
-    unless supports_incomplete_services?
-      raise Puppet::Error, _("Cannot query if the %{service} service is complete: The concept of complete/incomplete services was introduced in Solaris 11.1. You are on a Solaris %{release} machine.") % { service: @resource[:name], release: Facter.value(:operatingsystemrelease) }
-    end
-
-    return @complete_service if @complete_service
-
-    # We need to use the service's FMRI when querying its config. because
-    # general/complete is an instance-specific property.
-    fmri = service_fmri
-
-    # Check if the general/complete property is defined. If it is undefined,
-    # then svccfg will not print anything to the console.
-    property_defn = svccfg("-s", fmri, "listprop", "general/complete").chomp
-    @complete_service = ! property_defn.empty?
-  end
-
   def enable
     self.start
   end
@@ -177,14 +131,6 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
     end
 
     begin
-      if supports_incomplete_services?
-        unless complete_service?
-          debug _("The %{service} service is incomplete so its status will be reported as :stopped. See `svcs -xv %{fmri}` for more details.") % { service: @resource[:name], fmri: service_fmri }
-
-          return :stopped
-        end
-      end
-
       # get the current state and the next state, and if the next
       # state is set (i.e. not "-") use it for state comparison
       states = service_states