puppet 5.3.4 → 6.29.0

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

@@ -0,0 +1,141 @@
+# 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, :supports_flavors, :disableable
+  #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 -d 0 -e #{error_level}"
+    execute(cmd).each_line do |line|
+      # select only lines with actual packages since DNF clutters the output
+      next unless line =~ /\[[eix]\][, ]/
+      line.gsub!(/\[d\]/, '')  # we don't care about the default flag
+
+      flavor = if line.include?('[i]')
+                 line.split('[i]').first.split.last
+               else
+                 :absent
+               end
+
+      packages << new(
+        name: line.split[0],
+        ensure: if line.include?('[x]')
+                  :disabled
+                else
+                  line.split[1]
+                end,
+        flavor: flavor,
+        provider: name
+      )
+    end
+    packages
+  end
+
+  def query
+    pkg = self.class.instances.find do |package|
+            @resource[:name] == package.name
+          end
+    pkg ? pkg.properties : nil
+  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
+    # ensure we start fresh (remove existing stream)
+    uninstall unless [:absent, :purged].include?(@property_hash[:ensure])
+
+    args = @resource[:name].dup
+    case @resource[:ensure]
+    when true, false, Symbol
+      # pass
+    else
+      args << ":#{@resource[:ensure]}"
+    end
+    args << "/#{@resource[:flavor]}" if @resource[:flavor]
+
+    if @resource[:enable_only] == true
+      enable(args)
+    else
+      begin
+        execute([command(:dnf), 'module', 'install', '-d', '0', '-e', self.class.error_level, '-y', args])
+      rescue Puppet::ExecutionFailure => e
+        # module has no default profile and no profile was requested, so just enable the stream
+        # DNF versions prior to 4.2.8 do not need this workaround
+        # see https://bugzilla.redhat.com/show_bug.cgi?id=1669527
+        if @resource[:flavor] == nil && e.message =~ /^(?:missing|broken) groups or modules: #{Regexp.quote(@resource[:name])}$/
+          enable(args)
+        else
+          raise
+        end
+      end
+    end
+  end
+
+  # should only get here when @resource[ensure] is :disabled
+  def insync?(is)
+    if resource[:ensure] == :disabled
+      # in sync only if package is already disabled
+      pkg = self.class.instances.find do |package|
+        @resource[:name] == package.name && package.properties[:ensure] == :disabled
+      end
+      return true if pkg
+    end
+    return false
+  end
+
+  def enable(args = @resource[:name])
+    execute([command(:dnf), 'module', 'enable', '-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
+
+  def disable(args = @resource[:name])
+    execute([command(:dnf), 'module', 'disable', '-d', '0', '-e', self.class.error_level, '-y', args])
+  end
+
+  def reset
+    execute([command(:dnf), 'module', 'reset', '-d', '0', '-e', self.class.error_level, '-y', @resource[:name]])
+  end
+
+  def flavor
+    @property_hash[:flavor]
+  end
+
+  def flavor=(value)
+    install if flavor != @resource.should(:flavor)
+  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"
@@ -30,7 +29,8 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     dpkgquery_piped('-W', '--showformat', self::DPKG_QUERY_FORMAT_STRING) do |pipe|
       # now turn each returned line into a package object
       pipe.each_line do |line|
-        if hash = parse_line(line)
+        hash = parse_line(line)
+        if hash
           packages << new(hash)
         end
       end
@@ -44,16 +44,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::FIELDS_REGEX = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
+  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|
@@ -67,7 +74,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[:ensure] = :held if hash[:desired] == 'hold'
+      hash[:mark] = hash[:desired] == 'hold' ? :hold : :none
     else
       Puppet.debug("Failed to match dpkg-query line #{line.inspect}")
     end
@@ -78,14 +85,12 @@ 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 = []
 
-    # We always unhold when installing to remove any prior hold.
-    self.unhold
 
     if @resource[:configfiles] == :keep
       args << '--force-confold'
@@ -94,7 +99,12 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     end
     args << '-i' << file
 
-    dpkg(*args)
+    self.unhold if self.properties[:mark] == :hold
+    begin
+      dpkg(*args)
+    ensure
+      self.hold if @resource[:mark] == :hold
+    end
   end
 
   def update
@@ -103,7 +113,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]
@@ -114,6 +128,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,8 +173,14 @@ 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
@@ -162,4 +196,7 @@ 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,7 +37,12 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
 
     cmd << :install << str
 
-    finkcmd(cmd)
+    self.unhold if self.properties[:mark] == :hold
+    begin
+      finkcmd(cmd)
+    ensure
+      self.hold if @resource[:mark] == :hold
+    end
   end
 
   # What's the latest package version available?
@@ -56,7 +61,8 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
   # preseeds answers to dpkg-set-selection from the "responsefile"
   #
   def run_preseed
-    if response = @resource[:responsefile] and Puppet::FileSystem.exist?(response)
+    response = @resource[:responsefile]
+    if response && Puppet::FileSystem.exist?(response)
       self.info(_("Preseeding %{response} to debconf-set-selections") % { response: response })
 
       preseed response
@@ -70,10 +76,22 @@ Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
   end
 
   def uninstall
-    finkcmd "-y", "-q", :remove, @model[:name]
+    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
   end
 
   def purge
-    aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+    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
   end
 end

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

@@ -1,41 +1,101 @@
-require 'puppet/provider/package'
+require 'puppet/util/package/version/gem'
+require 'puppet/util/package/version/range'
+require 'puppet/provider/package_targetable'
 require 'uri'
 
 # Ruby gems support.
-Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package do
+Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::Targetable 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`.
     If 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, the gem will be
-    installed from the default gem repositories.
+    installed from the default gem repositories. Note that to modify this for Windows, it has to be a valid URL.
 
     This provider supports the `install_options` and `uninstall_options` attributes,
     which allow command-line flags to be passed to the gem command.
-    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, :uninstall_options
+  has_feature :versionable, :install_options, :uninstall_options, :targetable, :version_ranges
 
-  commands :gemcmd => "gem"
+  GEM_VERSION =       Puppet::Util::Package::Version::Gem
+  GEM_VERSION_RANGE = Puppet::Util::Package::Version::Range
+
+  # 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
 
   def self.gemlist(options)
-    gem_list_command = [command(:gemcmd), "list"]
+    command_options = ["list"]
 
     if options[:local]
-      gem_list_command << "--local"
+      command_options << "--local"
     else
-      gem_list_command << "--remote"
+      command_options << "--remote"
     end
     if options[:source]
-      gem_list_command << "--source" << options[:source]
+      command_options << "--source" << options[:source]
     end
-    if name = options[:justme]
-      gem_list_command << "^" + name + "$"
+    name = options[:justme]
+    if name
+      command_options << '\A' + name + '\z'
     end
 
     begin
-      list = execute(gem_list_command, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).lines.
+      list = execute_gem_command(options[:command], command_options).lines.
         map {|set| gemsplit(set) }.
         reject {|x| x.nil? }
     rescue Puppet::ExecutionFailure => detail
@@ -58,7 +118,7 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
 
     if desc =~ /^(\S+)\s+\((.+)\)/
       gem_name = $1
-      versions = $2.split(/,\s*/)
+      versions = $2.sub('default: ', '').split(/,\s*/)
       {
         :name     => gem_name,
         :ensure   => versions.map{|v| v.split[0]},
@@ -70,39 +130,76 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
     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
+    is = [is] unless is.is_a? Array
+    should = @resource[:ensure]
+
+    unless should =~ Regexp.union(/,/, Gem::Requirement::PATTERN)
+      begin
+        should_range = GEM_VERSION_RANGE.parse(should, GEM_VERSION)
+      rescue GEM_VERSION_RANGE::ValidationFailure, GEM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a ruby gem version range")
+        return false
+      end
 
+      return is.any? do |version|
+        begin
+          should_range.include?(GEM_VERSION.parse(version))
+        rescue GEM_VERSION::ValidationFailure
+          Puppet.debug("Cannot parse #{version} as a ruby gem version")
+          false
+        end
+      end
+    end
+    
     begin
-      dependency = Gem::Dependency.new('', resource[:ensure])
+      # Range intersections are not supported by Gem::Requirement, so just split by comma.
+      dependency = Gem::Dependency.new('', should.split(','))
     rescue ArgumentError
       # Bad requirements will cause an error during gem command invocation, so just return not in sync
       return false
     end
 
-    is = [is] unless is.is_a? Array
-
     # Check if any version matches the dependency
     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 = [command(:gemcmd), "install"]
-    command += install_options if resource[:install_options]
-    if Puppet.features.microsoft_windows?
-      version = resource[:ensure]
-      command << "-v" << %Q["#{version}"] if (! resource[:ensure].is_a? Symbol) and useversion
+    command = resource_or_provider_command
+    command_options = ["install"]
+    command_options += install_options if resource[:install_options]
+    should = resource[:ensure]
+
+    unless should =~ Regexp.union(/,/, Gem::Requirement::PATTERN)
+      begin
+        should_range = GEM_VERSION_RANGE.parse(should, GEM_VERSION)
+        should = should_range.to_gem_version
+        useversion = true
+      rescue GEM_VERSION_RANGE::ValidationFailure, GEM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a ruby gem version range. Falling through.")
+      end
+    end
+
+    if Puppet::Util::Platform.windows?
+      command_options << "-v" << %Q["#{should}"] if useversion && !should.is_a?(Symbol)
     else
-      command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
+      command_options << "-v" << should if useversion && !should.is_a?(Symbol)
     end
 
-    if source = resource[:source]
+    if Puppet::Util::Package.versioncmp(rubygem_version(command), '2.0.0') == -1
+      command_options << "--no-rdoc" << "--no-ri"
+    else
+      command_options << "--no-document"
+    end
+
+    source = resource[:source]
+    if source
       begin
         uri = URI.parse(source)
       rescue => detail
@@ -112,52 +209,53 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
       case uri.scheme
       when nil
         # no URI scheme => interpret the source as a local file
-        command << source
+        command_options << source
       when /file/i
-        command << uri.path
+        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
         # check whether it's an absolute file path to help Windows out
         if Puppet::Util.absolute_path?(source)
-          command << source
+          command_options << source
         else
           # interpret it as a gem repository
-          command << "--source" << "#{source}" << resource[:name]
+          command_options << "--source" << "#{source}" << resource[:name]
         end
       end
     else
-      command << "--no-rdoc" << "--no-ri" << resource[:name]
+      command_options << resource[:name]
     end
 
-    output = execute(command, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}})
-    # Apparently some stupid gem versions don't exit non-0 on failure
+    output = self.class.execute_gem_command(command, 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 latest
-    # 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]
+    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]
   end
 
   def query
-    self.class.gemlist(:justme => resource[:name], :local => true)
+    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
   end
 
   def uninstall
-    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
+    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.
     self.fail _("Could not uninstall: %{output}") % { output: output.chomp } if output.include?("ERROR")
   end
 

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

@@ -38,7 +38,8 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
 
   def self.hash_from_line(line, regex, fields)
     hash = {}
-    if match = regex.match(line)
+    match = regex.match(line)
+    if match
       fields.zip(match.captures) { |field, value|
         hash[field] = value
       }
@@ -51,7 +52,8 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
   def self.instances
     packages = []
     port("-q", :installed).each_line do |line|
-      if hash = parse_installed_query_line(line)
+      hash = parse_installed_query_line(line)
+      if hash
         packages << new(hash)
       end
     end
@@ -61,9 +63,9 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
   def install
     should = @resource.should(:ensure)
     if [:latest, :installed, :present].include?(should)
-      output = port("-q", :install, @resource[:name])
+      port("-q", :install, @resource[:name])
     else
-      output = port("-q", :install, @resource[:name], "@#{should}")
+      port("-q", :install, @resource[:name], "@#{should}")
     end
     # MacPorts now correctly exits non-zero with appropriate errors in
     # situations where a port cannot be found or installed.
@@ -82,7 +84,8 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
     info_line = execute([command(:port), "-q", :info, "--line", "--version", "--revision", @resource[:name]], :failonfail => false, :combine => false)
     return nil if info_line == ""
 
-    if newest = self.class.parse_info_query_line(info_line)
+    newest = self.class.parse_info_query_line(info_line)
+    if newest
       current = query
       # We're doing some fiddling behind the scenes here to cope with updated revisions.
       # If we're already at the latest version/revision, then just return the version