puppet 5.3.4 → 6.29.0

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

@@ -1,4 +1,11 @@
+require 'puppet/util/package/version/range'
+require 'puppet/util/package/version/rpm'
+require 'puppet/util/rpm_compare'
+
 Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
+  # provides Rpm parsing and comparison
+  include Puppet::Util::RpmCompare
+
   desc "Support via `yum`.
 
   Using this provider's `uninstallable` feature will not remove dependent packages. To
@@ -6,10 +13,12 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   feature is destructive and should be used with the utmost care.
 
   This provider supports the `install_options` attribute, which allows command-line flags to be passed to yum.
-  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."
+  These options should be specified as 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
+  RPM_VERSION       = Puppet::Util::Package::Version::Rpm
+  RPM_VERSION_RANGE = Puppet::Util::Package::Version::Range
 
   commands :cmd => "yum", :rpm => "rpm"
 
@@ -23,7 +32,38 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
       end
   end
 
-  defaultfor :osfamily => :redhat
+defaultfor :operatingsystem => :amazon
+defaultfor :osfamily => :redhat, :operatingsystemmajrelease => (4..7).to_a
+
+  def insync?(is)
+    return false if [:purged, :absent].include?(is)
+    return false if is.include?(self.class::MULTIVERSION_SEPARATOR) && !@resource[:install_only]
+
+    should = @resource[:ensure]
+    if should.is_a?(String)
+      begin
+        should_version = RPM_VERSION_RANGE.parse(should, RPM_VERSION)
+
+        if should_version.is_a?(RPM_VERSION_RANGE::Eq)
+          return super
+        end
+      rescue RPM_VERSION_RANGE::ValidationFailure, RPM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return super
+      end
+
+      is.split(self.class::MULTIVERSION_SEPARATOR).any? do |version|
+        begin
+          is_version = RPM_VERSION.parse(version)
+          should_version.include?(is_version)
+        rescue RPM_VERSION::ValidationFailure
+          Puppet.debug("Cannot parse #{is} as a RPM version")
+        end
+      end
+    end
+  end
+
+  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
@@ -86,28 +126,29 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   end
 
   def self.parse_updates(str)
-    # Strip off all content before the first blank line
-    body = str.partition(/^\s*\n/m).last
+    # Strip off all content that contains Obsoleting, Security: or Update
+    body = str.partition(/^(Obsoleting|Security:|Update)/).first
 
     updates = Hash.new { |h, k| h[k] = [] }
-    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
 
+    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
+    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
@@ -117,7 +158,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(/^(?:(\d+):)?(\S+)-(\S+)$/)
+    match = pkgversion.match(VERSION_REGEX)
     epoch = match[1] || '0'
     version = match[2]
     release = match[3]
@@ -145,12 +186,50 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     # Quote the DNF docs:
     # "Yum does this if its obsoletes config option is enabled but
     # the behavior is not properly documented and can be harmful."
-    # So we'll stick with the safter option
+    # So we'll stick with the safer option
     # If a user wants to remove obsoletes, they can use { :install_options => '--obsoletes' }
     # More detail here: https://bugzilla.redhat.com/show_bug.cgi?id=1096506
     'update'
   end
 
+  def best_version(should)
+    if should.is_a?(String)
+      begin
+        should_range = RPM_VERSION_RANGE.parse(should, RPM_VERSION)
+        if should_range.is_a?(RPM_VERSION_RANGE::Eq)
+          return should
+        end
+      rescue RPM_VERSION_RANGE::ValidationFailure, RPM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return should
+      end
+      sorted_versions = SortedSet.new
+      available_versions(@resource[:name]).each do |version|
+        begin
+          rpm_version = RPM_VERSION.parse(version)
+          sorted_versions << rpm_version if should_range.include?(rpm_version)
+        rescue RPM_VERSION::ValidationFailure
+          Puppet.debug("Cannot parse #{version} as a RPM version")
+        end
+      end
+
+      version = sorted_versions.entries.last
+
+      if version
+        version = version.to_s.sub(/^\d+:/, '')
+        return version
+      end
+
+      Puppet.debug("No available version for package #{@resource[:name]} is included in range #{should_range}")
+      should
+    end
+  end
+
+  def available_versions(package_name)
+    output = execute("yum list #{package_name} --showduplicates | sed -e '1,/Available Packages/ d' | awk '{print $2}'")
+    output.split("\n")
+  end
+
   def install
     wanted = @resource[:name]
     error_level = self.class.error_level
@@ -175,23 +254,42 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
         operation = :install
       end
       should = nil
-    when true, false, Symbol
+    when true, :present, :installed
+      # if we have been given a source and we were not asked for a specific
+      # version feed it to yum directly
+      if @resource[:source]
+        wanted = @resource[:source]
+        self.debug "Installing directly from #{wanted}"
+      end
+      should = nil
+    when false,:absent
       # pass
       should = nil
     else
-      # Add the package version
-      wanted += "-#{should}"
-      if wanted.scan(ARCH_REGEX)
-        self.debug "Detected Arch argument in package! - Moving arch to end of version string"
-        wanted.gsub!(/(.+)(#{ARCH_REGEX})(.+)/,'\1\3\2')
+      if @resource[:source]
+        # An explicit source was supplied, which means we're ensuring a specific
+        # version, and also supplying the path to a package that supplies that
+        # version.
+        wanted = @resource[:source]
+        self.debug "Installing directly from #{wanted}"
+      else
+        # No explicit source was specified, so add the package version
+        should = best_version(should)
+        wanted += "-#{should}"
+        if wanted.scan(self.class::ARCH_REGEX)
+          self.debug "Detected Arch argument in package! - Moving arch to end of version string"
+          wanted.gsub!(/(.+)(#{self.class::ARCH_REGEX})(.+)/,'\1\3\2')
+        end
       end
-
       current_package = self.query
       if current_package
-        if rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(current_package[:ensure])) < 0
+        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(should, 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
+        elsif rpm_compareEVR(should, current_package[:ensure]) > 0
           self.debug "Upgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
           operation = update_command
         end
@@ -200,11 +298,11 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
 
     # Yum on el-4 and el-5 returns exit status 0 when trying to install a package it doesn't recognize;
     # ensure we capture output to check for errors.
-    no_debug = if Facter.value(:operatingsystemmajrelease).to_i > 5 then ["-d", "0"] else [] end
+    no_debug = if Puppet.runtime[:facter].value(:operatingsystemmajrelease).to_i > 5 then ["-d", "0"] else [] end
     command = [command(:cmd)] + no_debug + ["-e", error_level, "-y", install_options, operation, wanted].compact
     output = execute(command)
 
-    if output =~ /^No package #{wanted} available\.$/
+    if output.to_s =~ /^No package #{wanted} available\.$/
       raise Puppet::Error, _("Could not find package %{wanted}") % { wanted: wanted }
     end
 
@@ -213,10 +311,11 @@ 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] ?
-      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
+      raise Puppet::Error, _("Failed to update to version %{should}, got version %{version} instead") % { should: should, version: version } unless
+        insync?(version)
     end
   end
 
@@ -229,6 +328,7 @@ 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
@@ -267,12 +367,16 @@ 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 [] if options.nil?
-    options.inject([]) do |repos, opt|
-      if opt.is_a? Hash and opt[key]
-        repos << opt[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
       end
-      repos
+      value[key]
     end
+    values.compact.uniq
   end
 end

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

@@ -1,9 +1,9 @@
-Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
+Puppet::Type.type(:package).provide :zypper, :parent => :rpm, :source => :rpm do
   desc "Support for SuSE `zypper` package manager. Found in SLES10sp2+ and SLES11.
 
     This provider supports the `install_options` attribute, which allows command-line flags to be passed to zypper.
-    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."
+    These options should be specified as an array where each element is either a
+    string or a hash."
 
   has_feature :versionable, :install_options, :virtual_packages
 
@@ -50,6 +50,41 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
     execute(cmd, { :failonfail => false, :combine => true})
   end
 
+  def best_version(should)
+    if should.is_a?(String)
+      begin
+        should_range = Puppet::Util::Package::Version::Range.parse(should, Puppet::Util::Package::Version::Rpm)
+      rescue Puppet::Util::Package::Version::Range::ValidationFailure, Puppet::Util::Package::Version::Rpm::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return should
+      end
+
+      if should_range.is_a?(Puppet::Util::Package::Version::Range::Eq)
+        return should
+      end
+
+      sorted_versions = SortedSet.new
+
+      output = zypper('search', '--match-exact', '--type', 'package', '--uninstalled-only', '-s', @resource[:name])
+      output.lines.each do |line|
+        pkg_ver = line.split(/\s*\|\s*/)
+        next unless pkg_ver[1] == @resource[:name]
+        begin
+          rpm_version = Puppet::Util::Package::Version::Rpm.parse(pkg_ver[3])
+
+          sorted_versions << rpm_version if should_range.include?(rpm_version)
+        rescue Puppet::Util::Package::Version::Rpm::ValidationFailure
+          Puppet.debug("Cannot parse #{pkg_ver[3]} as a RPM version")
+        end
+      end
+
+      return sorted_versions.entries.last if sorted_versions.any?
+
+      Puppet.debug("No available version for package #{@resource[:name]} is included in range #{should_range}")
+      should
+    end
+  end
+
   # Install a package using 'zypper'.
   def install
     should = @resource.should(:ensure)
@@ -62,6 +97,7 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
       should = nil
     else
       # Add the package version
+      should = best_version(should)
       wanted = "#{wanted}-#{should}"
     end
 
@@ -89,6 +125,7 @@ Puppet::Type.type(:package).provide :zypper, :parent => :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
@@ -102,7 +139,7 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
     options << '--name' unless major < 1 || @resource.allow_virtual? || should
     options << wanted
 
-    zypper *options
+    zypper(*options)
 
     unless self.query
       raise Puppet::ExecutionFailure.new(
@@ -126,7 +163,7 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
 
   def uninstall
     #extract version numbers and convert to integers
-    major, minor, patch = zypper_version.scan(/\d+/).map{ |x| x.to_i }
+    major, minor, _ = zypper_version.scan(/\d+/).map{ |x| x.to_i }
 
     if major < 1
       super
@@ -137,9 +174,33 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
       end
 
       options << @resource[:name]
-    	
-      zypper *options
+
+      zypper(*options)
     end
 
   end
+
+  def insync?(is)
+    return false if [:purged, :absent].include?(is)
+
+    should = @resource[:ensure]
+    if should.is_a?(String)
+      begin
+        should_version = Puppet::Util::Package::Version::Range.parse(should, Puppet::Util::Package::Version::Rpm)
+        if should_version.is_a?(RPM_VERSION_RANGE::Eq)
+          return super
+        end
+      rescue Puppet::Util::Package::Version::Range::ValidationFailure, Puppet::Util::Package::Version::Rpm::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return super
+      end
+
+      begin
+        is_version = Puppet::Util::Package::Version::Rpm.parse(is)
+        should_version.include?(is_version)
+      rescue Puppet::Util::Package::Version::Rpm::ValidationFailure
+        Puppet.debug("Cannot parse #{is} as a RPM version")
+      end
+    end
+  end
 end

data/lib/puppet/provider/package.rb

@@ -1,8 +1,11 @@
+require 'puppet/provider'
+
 class Puppet::Provider::Package < Puppet::Provider
   # Prefetch our package list, yo.
   def self.prefetch(packages)
     instances.each do |prov|
-      if pkg = packages[prov.name]
+      pkg = packages[prov.name]
+      if pkg
         pkg.provider = prov
       end
     end

data/lib/puppet/provider/package_targetable.rb

@@ -0,0 +1,69 @@
+# Targetable package providers implement a `command` attribute.
+#
+# The `packages` hash passed to `Puppet::Provider::Package::prefetch` is deduplicated,
+# as it is keyed only by name in `Puppet::Transaction::prefetch_if_necessary`.
+#
+# (The `packages` hash passed to ``Puppet::Provider::Package::prefetch`` should be keyed by all namevars,
+# possibly via a `prefetchV2` method that could take a better data structure.)
+#
+# In addition, `Puppet::Provider::Package::properties` calls `query` in the provider.
+require 'puppet/provider/package'
+
+# But `query` in the provider depends upon whether a `command` attribute is defined for the resource.
+# This is a Catch-22.
+#
+# Instead ...
+#
+# Inspect any package to access the catalog (every package includes a reference to the catalog).
+# Inspect the catalog to find all of the `command` attributes for all of the packages of this class.
+# Find all of the package instances using each package `command`, including the default provider command.
+# Assign each instance's `provider` by selecting it from the `packages` hash passed to `prefetch`, based upon `name` and `command`.
+#
+# The original `command` parameter in the catalog is not populated by the default (`:default`) for the parameter in type/package.rb.
+# Rather, the result of the `original_parameters` is `nil` when the `command` parameter is undefined in the catalog.
+
+class Puppet::Provider::Package::Targetable < Puppet::Provider::Package
+  # Prefetch our package list, yo.
+  def self.prefetch(packages)
+    catalog_packages = packages.values.first.catalog.resources.select{ |p| p.provider.class == self }
+    package_commands = catalog_packages.map { |catalog_package| catalog_package::original_parameters[:command] }.uniq
+    package_commands.each do |command|
+      instances(command).each do |instance|
+        catalog_packages.each do |catalog_package|
+          if catalog_package[:name] == instance.name && catalog_package.original_parameters[:command] == command
+            catalog_package.provider = instance
+            self.debug "Prefetched instance: %{name} via command: %{cmd}" % { name: instance.name, cmd: (command || :default) }
+          end
+        end
+      end
+    end
+    package_commands
+  end
+
+  # Returns the resource command or provider command.
+
+  def resource_or_provider_command
+    resource.original_parameters[:command] || self.class.provider_command
+  end
+
+  # Targetable providers use has_command/is_optional to defer validation of provider suitability.
+  # Evaluate provider suitability here and now by validating that the command is defined and exists.
+  #
+  # cmd: the full path to the package command.
+
+  def self.validate_command(cmd)
+    unless cmd
+      raise Puppet::Error, _("Provider %{name} package command is not functional on this host") % { name: name }
+    end
+    unless File.file?(cmd)
+      raise Puppet::Error, _("Provider %{name} package command '%{cmd}' does not exist on this host") % { name: name, cmd: cmd }
+    end
+  end
+
+  # Return information about the package, its provider, and its (optional) command.
+
+  def to_s
+    cmd = resource[:command] || :default
+    "#{@resource}(provider=#{self.class.name})(command=#{cmd})"
+  end
+end

data/lib/puppet/provider/parsedfile.rb

@@ -10,11 +10,17 @@ 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
+    attr_accessor :default_target, :target, :raise_prefetch_errors
   end
 
   attr_accessor :property_hash
@@ -40,10 +46,13 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
   def self.filetype=(type)
     if type.is_a?(Class)
       @filetype = type
-    elsif klass = Puppet::Util::FileType.filetype(type)
-      @filetype = klass
     else
-      raise ArgumentError, _("Invalid filetype %{type}") % { type: type }
+      klass = Puppet::Util::FileType.filetype(type)
+      if klass
+        @filetype = klass
+      else
+        raise ArgumentError, _("Invalid filetype %{type}") % { type: type }
+      end
     end
   end
 
@@ -65,7 +74,7 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
     flushed = []
     begin
-      @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
+      @modified.sort_by(&:to_s).uniq.each do |target|
         Puppet.debug "Flushing #{@resource_type.name} provider target #{target}"
         flushed << target
         flush_target(target)
@@ -89,6 +98,10 @@ 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|
@@ -142,6 +155,10 @@ 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
@@ -226,7 +243,8 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
       if (resource = resource_for_record(record, resources))
         resource.provider = new(record)
       elsif respond_to?(:match)
-        if resource = match(record, matchers)
+        resource = match(record, matchers)
+        if resource
           matchers.delete(resource.title)
           record[:name] = resource[:name]
           resource.provider = new(record)
@@ -260,12 +278,22 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
   # Prefetch an individual target.
   def self.prefetch_target(target)
-
     begin
       target_records = retrieve(target)
+      unless target_records
+        raise Puppet::DevError, _("Prefetching %{target} for provider %{name} returned nil") % { target: target, name: self.name }
+      end
     rescue Puppet::Util::FileType::FileReadError => detail
-      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 }
+      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
+
       target_records = []
     end
 
@@ -359,7 +387,8 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
     # Lastly, check the file from any resource instances
     if resources
       resources.each do |name, resource|
-        if value = resource.should(:target)
+        value = resource.should(:target)
+        if value
           targets << value
         end
       end
@@ -393,7 +422,8 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
   def create
     @resource.class.validproperties.each do |property|
-      if value = @resource.should(property)
+      value = @resource.should(property)
+      if value
         @property_hash[property] = value
       end
     end
@@ -451,7 +481,8 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
   # Mark both the resource and provider target as modified.
   def mark_target_modified
-    if defined?(@resource) and restarget = @resource.should(:target) and restarget != @property_hash[:target]
+    restarget = @resource.should(:target) if defined?(@resource)
+    if restarget && restarget != @property_hash[:target]
       self.class.modified(restarget)
     end
     self.class.modified(@property_hash[:target]) if @property_hash[:target] != :absent and @property_hash[:target]

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

@@ -15,14 +15,14 @@ Puppet::Type.type(:service).provide :base, :parent => :service do
   # ported from the facter 2.x implementation, since facter 3.x
   # is dropping the fact (for which this was the only use)
   def getps
-    case Facter.value(:operatingsystem)
+    case Puppet.runtime[:facter].value(:operatingsystem)
     when 'OpenWrt'
       'ps www'
     when 'FreeBSD', 'NetBSD', 'OpenBSD', 'Darwin', 'DragonFly'
       'ps auxwww'
     else
       'ps -ef'
-     end
+    end
   end
   private :getps
 
@@ -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)
@@ -76,11 +76,14 @@ Puppet::Type.type(:service).provide :base, :parent => :service do
       else
         return :stopped
       end
-    elsif pid = getpid
-      self.debug "PID is #{pid}"
-      return :running
     else
-      return :stopped
+      pid = getpid
+      if pid
+        self.debug "PID is #{pid}"
+        return :running
+      else
+        return :stopped
+      end
     end
   end