puppet 4.0.0 → 4.5.0

data/lib/puppet/provider/mount/parsed.rb

@@ -4,6 +4,7 @@ require 'puppet/provider/mount'
 fstab = nil
 case Facter.value(:osfamily)
 when "Solaris"; fstab = "/etc/vfstab"
+when "AIX"; fstab = "/etc/filesystems"
 else
   fstab = "/etc/fstab"
 end
@@ -25,7 +26,12 @@ Puppet::Type.type(:mount).provide(
     @fields = [:device, :name, :fstype, :options, :dump, :pass]
   end
 
-  text_line :comment, :match => /^\s*#/
+  if Facter.value(:osfamily) == "AIX"
+    # * is the comment character on AIX /etc/filesystems
+    text_line :comment, :match => /^\s*\*/
+  else
+    text_line :comment, :match => /^\s*#/
+  end
   text_line :blank, :match => /^\s*$/
 
   optional_fields  = @fields - [:device, :name, :blockdevice]
@@ -36,7 +42,158 @@ Puppet::Type.type(:mount).provide(
   field_pattern = '(\s*(?>\S+))'
   text_line :incomplete, :match => /^(?!#{field_pattern}{#{mandatory_fields.length}})/
 
-  record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
+  case Facter.value(:osfamily)
+  when "AIX"
+    # The only field that is actually ordered is :name. See `man filesystems` on AIX
+    @fields = [:name, :account, :boot, :check, :dev, :free, :mount, :nodename,
+               :options, :quota, :size, :type, :vfs, :vol, :log]
+    self.line_separator = "\n"
+    # Override lines and use scan instead of split, because we DON'T want to
+    # remove the separators
+    def self.lines(text)
+      lines = text.split("\n")
+      filesystem_stanza = false
+      filesystem_index = 0
+      ret = Array.new
+      lines.each_with_index do |line,i|
+        if line.match(%r{^\S+:})
+          # Begin new filesystem stanza and save the index
+          ret[filesystem_index] = filesystem_stanza.join("\n") if filesystem_stanza
+          filesystem_stanza = Array(line)
+          filesystem_index = i
+          # Eat the preceeding blank line
+          ret[i-1] = nil if i > 0 and ret[i-1] and ret[i-1].match(%r{^\s*$})
+          nil
+        elsif line.match(%r{^(\s*\*.*|\s*)$})
+          # Just a comment or blank line; add in place
+          ret[i] = line
+        else
+          # Non-comments or blank lines must be part of a stanza
+          filesystem_stanza << line
+        end
+      end
+      # Add the final stanza to the return
+      ret[filesystem_index] = filesystem_stanza.join("\n") if filesystem_stanza
+      ret = ret.compact.flatten
+      ret.reject { |line| line.match(/^\* HEADER/) }
+    end
+    def self.header
+      super.gsub(/^#/,'*')
+    end
+
+    record_line self.name,
+      :fields    => @fields,
+      :separator => /\n/,
+      :block_eval => :instance do
+
+      def post_parse(result)
+        property_map = {
+          :dev      => :device,
+          :nodename => :nodename,
+          :options  => :options,
+          :vfs      => :fstype,
+        }
+        # Result is modified in-place instead of being returned; icky!
+        memo = result.dup
+        result.clear
+        # Save the line for later, just in case it is unparsable
+        result[:line] = @fields.collect do |field|
+          memo[field] if memo[field] != :absent
+        end.compact.join("\n")
+        result[:record_type] = memo[:record_type]
+        special_options = Array.new
+        result[:name] = memo[:name].sub(%r{:\s*$},'').strip
+        memo.each do |_,k_v|
+          if k_v and k_v.is_a?(String) and k_v.match("=")
+            attr_name, attr_value = k_v.split("=",2).map(&:strip)
+            if attr_map_name = property_map[attr_name.to_sym]
+              # These are normal "options" options (see `man filesystems`)
+              result[attr_map_name] = attr_value
+            else
+              # These /etc/filesystem attributes have no mount resource simile,
+              # so are added to the "options" property for puppet's sake
+              special_options << "#{attr_name}=#{attr_value}"
+            end
+            if result[:nodename]
+              result[:device] = "#{result[:nodename]}:#{result[:device]}"
+              result.delete(:nodename)
+            end
+          end
+        end
+        result[:options] = [result[:options],special_options.sort].flatten.compact.join(',')
+        if ! result[:device]
+          result[:device] = :absent
+          Puppet.err "Prefetch: Mount[#{result[:name]}]: Field 'device' is missing"
+        end
+        if ! result[:fstype]
+          result[:fstype] = :absent
+          Puppet.err "Prefetch: Mount[#{result[:name]}]: Field 'fstype' is missing"
+        end
+      end
+      def to_line(result)
+        output = Array.new
+        output << "#{result[:name]}:"
+        if result[:device] and result[:device].match(%r{^/})
+          output << "\tdev\t\t= #{result[:device]}"
+        elsif result[:device] and result[:device] != :absent
+          if ! result[:device].match(%{^.+:/})
+            # Just skip this entry; it was malformed to begin with
+            Puppet.err "Mount[#{result[:name]}]: Field 'device' must be in the format of <absolute path> or <host>:<absolute path>"
+            return result[:line]
+          end
+          nodename, path = result[:device].split(":")
+          output << "\tdev\t\t= #{path}"
+          output << "\tnodename\t= #{nodename}"
+        else
+          # Just skip this entry; it was malformed to begin with
+          Puppet.err "Mount[#{result[:name]}]: Field 'device' is required"
+          return result[:line]
+        end
+        if result[:fstype] and result[:fstype] != :absent
+          output << "\tvfs\t\t= #{result[:fstype]}"
+        else
+          # Just skip this entry; it was malformed to begin with
+          Puppet.err "Mount[#{result[:name]}]: Field 'device' is required"
+          return result[:line]
+        end
+        if result[:options]
+          options = result[:options].split(',')
+          special_options = options.select do |x|
+            x.match('=') and
+              ["account", "boot", "check", "free", "mount", "size", "type",
+               "vol", "log", "quota"].include? x.split('=').first
+          end
+          options = options - special_options
+          special_options.sort.each do |x|
+            k, v = x.split("=")
+            output << "\t#{k}\t\t= #{v}"
+          end
+          output << "\toptions\t\t= #{options.join(",")}" unless options.empty?
+        end
+        if result[:line] and result[:line].split("\n").sort == output.sort
+          return "\n#{result[:line]}"
+        else
+          return "\n#{output.join("\n")}"
+        end
+      end
+    end
+  else
+    record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields, :block_eval => :instance do
+      def pre_gen(record)
+        if !record[:options] || record[:options].empty?
+          if Facter.value(:kernel) == 'Linux'
+            record[:options] = 'defaults'
+          else
+            raise Puppet::Error, "Mount[#{record[:name]}]: Field 'options' is required"
+          end
+        end
+        if !record[:fstype] || record[:fstype].empty?
+          raise Puppet::Error, "Mount[#{record[:name]}]: Field 'fstype' is required"
+        end
+        record
+      end
+    end
+  end
 
   # Every entry in fstab is :unmounted until we can prove different
   def self.prefetch_hook(target_records)

data/lib/puppet/provider/nameservice/directoryservice.rb

@@ -1,6 +1,6 @@
 require 'puppet'
 require 'puppet/provider/nameservice'
-require 'plist'
+require 'puppet/util/plist' if Puppet.features.cfpropertylist?
 require 'fileutils'
 
 class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameService
@@ -18,8 +18,8 @@ class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameSe
   commands :dscl => "/usr/bin/dscl"
   commands :dseditgroup => "/usr/sbin/dseditgroup"
   commands :sw_vers => "/usr/bin/sw_vers"
-  commands :plutil => '/usr/bin/plutil'
   confine :operatingsystem => :darwin
+  confine :feature         => :cfpropertylist
   defaultfor :operatingsystem => :darwin
 
 
@@ -97,7 +97,7 @@ class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameSe
   end
 
   def self.parse_dscl_plist_data(dscl_output)
-    Plist.parse_xml(dscl_output)
+    Puppet::Util::Plist.parse_plist(dscl_output)
   end
 
   def self.generate_attribute_hash(input_hash, *type_properties)
@@ -160,7 +160,7 @@ class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameSe
   def self.get_exec_preamble(ds_action, resource_name = nil)
     # JJM 2007-07-24
     #     DSCL commands are often repetitive and contain the same positional
-    #     arguments over and over. See http://developer.apple.com/documentation/Porting/Conceptual/PortingUnix/additionalfeatures/chapter_10_section_9.html
+    #     arguments over and over. See https://developer.apple.com/documentation/Porting/Conceptual/PortingUnix/additionalfeatures/chapter_10_section_9.html
     #     for an example of what I mean.
     #     This method spits out proper DSCL commands for us.
     #     We EXPECT name to be @resource[:name] when called from an instance object.
@@ -192,92 +192,77 @@ class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameSe
            Please check your password and try again.")
     end
 
-    if Puppet::FileSystem.exist?("#{users_plist_dir}/#{resource_name}.plist")
+    plist_file = "#{users_plist_dir}/#{resource_name}.plist"
+    if Puppet::FileSystem.exist?(plist_file)
       # If a plist already exists in /var/db/dslocal/nodes/Default/users, then
       # we will need to extract the binary plist from the 'ShadowHashData'
       # key, log the new password into the resultant plist's 'SALTED-SHA512'
       # key, and then save the entire structure back.
-      users_plist = Plist::parse_xml(plutil( '-convert', 'xml1', '-o', '/dev/stdout', \
-                                     "#{users_plist_dir}/#{resource_name}.plist"))
+      users_plist = Puppet::Util::Plist.read_plist_file(plist_file)
 
-      # users_plist['ShadowHashData'][0].string is actually a binary plist
+      # users_plist['ShadowHashData'][0] is actually a binary plist
       # that's nested INSIDE the user's plist (which itself is a binary
       # plist). If we encounter a user plist that DOESN'T have a
       # ShadowHashData field, create one.
       if users_plist['ShadowHashData']
-        password_hash_plist = users_plist['ShadowHashData'][0].string
-        converted_hash_plist = convert_binary_to_xml(password_hash_plist)
+        password_hash_plist = users_plist['ShadowHashData'][0]
+        converted_hash_plist = convert_binary_to_hash(password_hash_plist)
       else
-        users_plist['ShadowHashData'] = [StringIO.new]
-        converted_hash_plist = {'SALTED-SHA512' => StringIO.new}
+        users_plist['ShadowHashData'] = ''
+        converted_hash_plist = {'SALTED-SHA512' => ''}
       end
 
-      # converted_hash_plist['SALTED-SHA512'].string expects a Base64 encoded
+      # converted_hash_plist['SALTED-SHA512'] expects a Base64 encoded
       # string. The password_hash provided as a resource attribute is a
       # hex value. We need to convert the provided hex value to a Base64
       # encoded string to nest it in the converted hash plist.
-      converted_hash_plist['SALTED-SHA512'].string = \
+      converted_hash_plist['SALTED-SHA512'] = \
         password_hash.unpack('a2'*(password_hash.size/2)).collect { |i| i.hex.chr }.join
 
       # Finally, we can convert the nested plist back to binary, embed it
       # into the user's plist, and convert the resultant plist back to
       # a binary plist.
-      changed_plist = convert_xml_to_binary(converted_hash_plist)
-      users_plist['ShadowHashData'][0].string = changed_plist
-      Plist::Emit.save_plist(users_plist, "#{users_plist_dir}/#{resource_name}.plist")
-      plutil('-convert', 'binary1', "#{users_plist_dir}/#{resource_name}.plist")
+      changed_plist = convert_hash_to_binary(converted_hash_plist)
+      users_plist['ShadowHashData'][0] = changed_plist
+      Puppet::Util::Plist.write_plist_file(users_plist, plist_file, :binary)
     end
   end
 
   def self.get_password(guid, username)
-    if Puppet::FileSystem.exist?("#{users_plist_dir}/#{username}.plist")
+    plist_file = "#{users_plist_dir}/#{username}.plist"
+    if Puppet::FileSystem.exist?(plist_file)
       # If a plist exists in /var/db/dslocal/nodes/Default/users, we will
       # extract the binary plist from the 'ShadowHashData' key, decode the
       # salted-SHA512 password hash, and then return it.
-      users_plist = Plist::parse_xml(plutil('-convert', 'xml1', '-o', '/dev/stdout', "#{users_plist_dir}/#{username}.plist"))
+      users_plist = Puppet::Util::Plist.read_plist_file(plist_file)
+
       if users_plist['ShadowHashData']
-        # users_plist['ShadowHashData'][0].string is actually a binary plist
+        # users_plist['ShadowHashData'][0] is actually a binary plist
         # that's nested INSIDE the user's plist (which itself is a binary
         # plist).
-        password_hash_plist = users_plist['ShadowHashData'][0].string
-        converted_hash_plist = convert_binary_to_xml(password_hash_plist)
+        password_hash_plist = users_plist['ShadowHashData'][0]
+        converted_hash_plist = convert_binary_to_hash(password_hash_plist)
 
-        # converted_hash_plist['SALTED-SHA512'].string is a Base64 encoded
+        # converted_hash_plist['SALTED-SHA512'] is a Base64 encoded
         # string. The password_hash provided as a resource attribute is a
         # hex value. We need to convert the Base64 encoded string to a
         # hex value and provide it back to Puppet.
-        password_hash = converted_hash_plist['SALTED-SHA512'].string.unpack("H*")[0]
+        password_hash = converted_hash_plist['SALTED-SHA512'].unpack("H*")[0]
         password_hash
       end
     end
   end
 
-  # This method will accept a hash that has been returned from Plist::parse_xml
-  # and convert it to a binary plist (string value).
-  def self.convert_xml_to_binary(plist_data)
-    Puppet.debug('Converting XML plist to binary')
-    Puppet.debug('Executing: \'plutil -convert binary1 -o - -\'')
-    IO.popen('plutil -convert binary1 -o - -', 'r+') do |io|
-      io.write plist_data.to_plist
-      io.close_write
-      @converted_plist = io.read
-    end
-    @converted_plist
+  # This method will accept a hash and convert it to a binary plist (string value).
+  def self.convert_hash_to_binary(plist_data)
+    Puppet.debug('Converting plist hash to binary')
+    Puppet::Util::Plist.dump_plist(plist_data, :binary)
   end
 
-  # This method will accept a binary plist (as a string) and convert it to a
-  # hash via Plist::parse_xml.
-  def self.convert_binary_to_xml(plist_data)
-    Puppet.debug('Converting binary plist to XML')
-    Puppet.debug('Executing: \'plutil -convert xml1 -o - -\'')
-    IO.popen('plutil -convert xml1 -o - -', 'r+') do |io|
-      io.write plist_data
-      io.close_write
-      @converted_plist = io.read
-    end
-    Puppet.debug('Converting XML values to a hash.')
-    @plist_hash = Plist::parse_xml(@converted_plist)
-    @plist_hash
+  # This method will accept a binary plist (as a string) and convert it to a hash.
+  def self.convert_binary_to_hash(plist_data)
+    Puppet.debug('Converting binary plist to hash')
+    Puppet::Util::Plist.parse_plist(plist_data)
   end
 
   # Unlike most other *nixes, OS X doesn't provide built in functionality
@@ -333,7 +318,7 @@ class Puppet::Provider::NameService::DirectoryService < Puppet::Provider::NameSe
     exec_arg_vector << ns_to_ds_attribute_map[:guid]
     begin
       guid_output = execute(exec_arg_vector)
-      guid_plist = Plist.parse_xml(guid_output)
+      guid_plist = Puppet::Util::Plist.parse_plist(guid_output)
       # Although GeneratedUID like all DirectoryService values can be multi-valued
       # according to the schema, in practice user accounts cannot have multiple UUIDs
       # otherwise Bad Things Happen, so we just deal with the first value.

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

@@ -13,10 +13,12 @@
 # in /var/db/.puppet_appdmg_installed_<name>
 
 require 'puppet/provider/package'
+require 'puppet/util/plist' if Puppet.features.cfpropertylist?
 Puppet::Type.type(:package).provide(:appdmg, :parent => Puppet::Provider::Package) do
   desc "Package management which copies application bundles to a target."
 
   confine :operatingsystem => :darwin
+  confine :feature         => :cfpropertylist
 
   commands :hdiutil => "/usr/bin/hdiutil"
   commands :curl => "/usr/bin/curl"
@@ -50,7 +52,6 @@ Puppet::Type.type(:package).provide(:appdmg, :parent => Puppet::Provider::Packag
 
   def self.installpkgdmg(source, name)
     require 'open-uri'
-    require 'plist'
     cached_source = source
     tmpdir = Dir.mktmpdir
     begin
@@ -67,7 +68,7 @@ Puppet::Type.type(:package).provide(:appdmg, :parent => Puppet::Provider::Packag
 
       open(cached_source) do |dmg|
         xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
-          ptable = Plist::parse_xml xml_str
+          ptable = Puppet::Util::Plist::parse_plist(xml_str)
           # JJM Filter out all mount-paths into a single array, discard the rest.
           mounts = ptable['system-entities'].collect { |entity|
             entity['mount-point']

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

@@ -14,7 +14,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
   commands :aptcache => "/usr/bin/apt-cache"
   commands :preseed => "/usr/bin/debconf-set-selections"
 
-  defaultfor :operatingsystem => [:debian, :ubuntu]
+  defaultfor :osfamily => :debian
 
   ENV['DEBIAN_FRONTEND'] = "noninteractive"
 

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

@@ -0,0 +1,41 @@
+Puppet::Type.type(:package).provide :dnf, :parent => :yum do
+  desc "Support via `dnf`.
+
+  Using this provider's `uninstallable` feature will not remove dependent packages. To
+  remove dependent packages with this provider use the `purgeable` feature, but note this
+  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 dnf.
+  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
+
+  commands :cmd => "dnf", :rpm => "rpm"
+
+  # Note: this confine was borrowed from the Yum provider. The
+  # original purpose (from way back in 2007) was to make sure we
+  # never try to use RPM on a machine without it. We think this
+  # has probably become obsolete with the way `commands` work, so
+  # we should investigate removing it at some point.
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  defaultfor :operatingsystem => :fedora, :operatingsystemmajrelease => ['22', '23']
+
+  # The value to pass to DNF as its error output level.
+  # DNF differs from Yum slightly with regards to error outputting.
+  #
+  # @param None
+  # @return [String]
+  def self.error_level
+    '1'
+  end
+end

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

@@ -74,6 +74,22 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
     end
   end
 
+  def insync?(is)
+    return false unless is && is != :absent
+
+    begin
+      dependency = Gem::Dependency.new('', resource[:ensure])
+    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 install(useversion = true)
     command = [command(:gemcmd), "install"]
     command << "-v" << resource[:ensure] if (! resource[:ensure].is_a? Symbol) and useversion
@@ -95,8 +111,13 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
         # 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 << "--source" << "#{source}" << resource[:name]
+        # check whether it's an absolute file path to help Windows out
+        if Puppet::Util.absolute_path?(source)
+          command << source
+        else
+          # interpret it as a gem repository
+          command << "--source" << "#{source}" << resource[:name]
+        end
       end
     else
       command << "--no-rdoc" << "--no-ri" << resource[:name]

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

@@ -87,7 +87,7 @@ Puppet::Type.type(:package).provide :nim, :parent => :aix, :source => :aix do
       version = nil
       showres_command << "'#{Regexp.escape(pkg)}'"
     end
-    output = Puppet::Util.execute(showres_command)
+    output = Puppet::Util::Execution.execute(showres_command)
 
 
     if (version_specified)

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

@@ -78,10 +78,11 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
     end
 
     output = Puppet::Util.withenv(e_vars) {pkginfo "-Q", query}
+    version = properties[:ensure]
 
     if output.nil? or output.size == 0 or output =~ /Error from /
       debug "Failed to query for #{resource[:name]}"
-      return properties[:ensure]
+      return version
     else
       # Remove all fuzzy matches first.
       output = output.split.select {|p| p =~ /^#{resource[:name]}-(\d[^-]*)[-]?(\w*)/ }.join
@@ -90,22 +91,21 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
 
     if output =~ /^#{resource[:name]}-(\d[^-]*)[-]?(\w*) \(installed\)$/
       debug "Package is already the latest available"
-      return properties[:ensure]
+      return version
     else
       match = /^(.*)-(\d[^-]*)[-]?(\w*)$/.match(output)
       debug "Latest available for #{resource[:name]}: #{match[2]}"
 
-      if properties[:ensure].to_sym == :absent
+      if version.to_sym == :absent || version.to_sym == :purged
         return match[2]
       end
 
-      vcmp = properties[:ensure].split('.').map{|s|s.to_i} <=> match[2].split('.').map{|s|s.to_i}
+      vcmp = version.split('.').map{|s|s.to_i} <=> match[2].split('.').map{|s|s.to_i}
       if vcmp > 0
-        debug "ensure: #{properties[:ensure]}"
         # The locally installed package may actually be newer than what a mirror
         # has. Log it at debug, but ignore it otherwise.
-        debug "Package #{resource[:name]} #{properties[:ensure]} newer then available #{match[2]}"
-        return properties[:ensure]
+        debug "Package #{resource[:name]} #{version} newer then available #{match[2]}"
+        return version
       else
         return match[2]
       end

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

@@ -30,7 +30,8 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     begin
       !pacman("-Sg", name).empty?
     rescue Puppet::ExecutionFailure
-      fail("Error while determining if '#{@resource[:name]}' is a group")
+      # pacman returns an expected non-zero exit code when the name is not a group
+      false
     end
   end
 
@@ -74,10 +75,10 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
   def self.get_installed_packages
     begin
       packages = {}
-      execpipe([command(:pacman), "-Q"]) do |process|
+      execpipe([command(:pacman), "-Q"]) do |pipe|
         # pacman -Q output is 'packagename version-rel'
         regex = %r{^(\S+)\s(\S+)}
-        process.each_line do |line|
+        pipe.each_line do |line|
           if match = regex.match(line)
             packages[match.captures[0]] = match.captures[1]
           else
@@ -98,8 +99,8 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
       # Build a hash of group name => list of packages
       command = [command(:pacman), "-Sgg"]
       command << filter if filter
-      execpipe(command) do |process|
-        process.each_line do |line|
+      execpipe(command) do |pipe|
+        pipe.each_line do |line|
           name, package = line.split
           packages = (groups[name] ||= [])
           packages << package
@@ -115,11 +116,11 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
       groups.each do |name, packages|
         groups[name] = packages.sort.map {|package| "#{package} #{installed_packages[package]}"}.join ', '
       end
-
-      groups
     rescue Puppet::ExecutionFailure
-      fail("Error while getting installed groups")
+      # pacman returns an expected non-zero exit code when the filter name is not a group
+      raise unless filter
     end
+    groups
   end
 
   # Because Archlinux is a rolling release based distro, installing a package