puppet 3.8.7 → 4.0.0

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

@@ -9,19 +9,29 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
   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."
 
+  # If yaourt is installed, we can make use of it
+  def self.yaourt?
+    @yaourt ||= Puppet::FileSystem.exist?('/usr/bin/yaourt')
+  end
+
   commands :pacman => "/usr/bin/pacman"
   # Yaourt is a common AUR helper which, if installed, we can use to query the AUR
-  commands :yaourt => "/usr/bin/yaourt" if Puppet::FileSystem.exist? '/usr/bin/yaourt'
+  commands :yaourt => "/usr/bin/yaourt" if yaourt?
 
-  confine     :operatingsystem => :archlinux
-  defaultfor  :operatingsystem => :archlinux
+  confine     :operatingsystem => [:archlinux, :manjarolinux]
+  defaultfor  :operatingsystem => [:archlinux, :manjarolinux]
   has_feature :install_options
   has_feature :uninstall_options
   has_feature :upgradeable
+  has_feature :virtual_packages
 
-  # If yaourt is installed, we can make use of it
-  def yaourt?
-    return Puppet::FileSystem.exist?('/usr/bin/yaourt')
+  # Checks if a given name is a group
+  def self.group?(name)
+    begin
+      !pacman("-Sg", name).empty?
+    rescue Puppet::ExecutionFailure
+      fail("Error while determining if '#{@resource[:name]}' is a group")
+    end
   end
 
   # Install a package using 'pacman', or 'yaourt' if available.
@@ -35,135 +45,83 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     end
 
     unless self.query
-      raise Puppet::ExecutionFailure.new("Could not find package %s" % self.name)
+      fail("Could not find package '#{@resource[:name]}'")
     end
   end
 
-  def install_from_repo
-    if yaourt?
-      cmd = %w{--noconfirm}
-      cmd += install_options if @resource[:install_options]
-      cmd << "-S" << @resource[:name]
-      yaourt *cmd
-    else
-      cmd = %w{--noconfirm --noprogressbar}
-      cmd += install_options if @resource[:install_options]
-      cmd << "-Sy" << @resource[:name]
-      pacman *cmd
-    end
-  end
-  private :install_from_repo
+  # Fetch the list of packages and package groups that are currently installed on the system.
+  # Only package groups that are fully installed are included. If a group adds packages over time, it will not
+  # be considered as fully installed any more, and we would install the new packages on the next run.
+  # If a group removes packages over time, nothing will happen. This is intended.
+  def self.instances
+    instances = []
 
-  def install_from_file
-    source = @resource[:source]
-    begin
-      source_uri = URI.parse source
-    rescue => detail
-      self.fail Puppet::Error, "Invalid source '#{source}': #{detail}", detail
+    # Get the installed packages
+    installed_packages = get_installed_packages
+    installed_packages.sort_by { |k, _| k }.each do |package, version|
+      instances << new(to_resource_hash(package, version))
     end
 
-    source = case source_uri.scheme
-    when nil then source
-    when /https?/i then source
-    when /ftp/i then source
-    when /file/i then source_uri.path
-    when /puppet/i
-      fail "puppet:// URL is not supported by pacman"
-    else
-      fail "Source #{source} is not supported by pacman"
+    # Get the installed groups
+    get_installed_groups(installed_packages).each do |group, version|
+      instances << new(to_resource_hash(group, version))
     end
-    pacman "--noconfirm", "--noprogressbar", "-Sy"
-    pacman "--noconfirm", "--noprogressbar", "-U", source
-  end
-  private :install_from_file
-
-  def self.listcmd
-    [command(:pacman), "-Q"]
-  end
 
-  # Pacman has a concept of package groups as well.
-  # Package groups have no versions.
-  def self.listgroupcmd
-    [command(:pacman), "-Qg"]
+    instances
   end
 
-  # Get installed packages (pacman -Q)
-  def self.installedpkgs
-    packages = []
+  # returns a hash package => version of installed packages
+  def self.get_installed_packages
     begin
-      execpipe(listcmd()) do |process|
+      packages = {}
+      execpipe([command(:pacman), "-Q"]) do |process|
         # pacman -Q output is 'packagename version-rel'
         regex = %r{^(\S+)\s(\S+)}
-        fields = [:name, :ensure]
-        hash = {}
-
-        process.each_line { |line|
+        process.each_line do |line|
           if match = regex.match(line)
-            fields.zip(match.captures) { |field,value|
-              hash[field] = value
-            }
-
-            hash[:provider] = self.name
-
-            packages << new(hash)
-
-            hash = {}
+            packages[match.captures[0]] = match.captures[1]
           else
-            warning("Failed to match line %s" % line)
+            warning("Failed to match line '#{line}'")
           end
-        }
+        end
       end
+      packages
     rescue Puppet::ExecutionFailure
-      return nil
+      fail("Error getting installed packages")
     end
-    packages
   end
 
-  # Get installed groups (pacman -Qg)
-  def self.installedgroups
-    packages = []
+  # returns a hash of group => version of installed groups
+  def self.get_installed_groups(installed_packages, filter = nil)
+    groups = {}
     begin
-      execpipe(listgroupcmd()) do |process|
-        # pacman -Qg output is 'groupname packagename'
-        # Groups need to be deduplicated
-        groups = Set[]
-
-        process.each_line { |line|
-          groups.add(line.split[0])
-        }
-
-        groups.each { |line|
-          hash = {
-            :name   => line,
-            :ensure => "1", # Groups don't have versions, so ensure => latest
-                            # will still cause a reinstall.
-            :provider => self.name
-          }
-          packages << new(hash)
-        }
+      # 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|
+          name, package = line.split
+          packages = (groups[name] ||= [])
+          packages << package
+        end
       end
-    rescue Puppet::ExecutionFailure
-      return nil
-    end
-    packages
-  end
 
-  # Fetch the list of packages currently installed on the system.
-  def self.instances
-    packages = self.installedpkgs
-    groups   = self.installedgroups
-    result   = nil
-
-    if (!packages && !groups)
-      nil
-    elsif (packages && groups)
-      packages.concat(groups)
-    else
-      packages
+      # Remove any group that doesn't have all its packages installed
+      groups.delete_if do |_, packages|
+        !packages.all? { |package| installed_packages[package] }
+      end
+
+      # Replace the list of packages with a version string consisting of packages that make up the group
+      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")
     end
   end
 
-
   # Because Archlinux is a rolling release based distro, installing a package
   # should always result in the newest release.
   def update
@@ -173,20 +131,29 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
 
   # We rescue the main check from Pacman with a check on the AUR using yaourt, if installed
   def latest
+    # Synchronize the database
     pacman "-Sy"
-    pacman_check = true   # Query the main repos first
+
+    resource_name = @resource[:name]
+
+    # If target is a group, construct the group version
+    return pacman("-Sp", "--print-format", "%n %v", resource_name).lines.map{ |line| line.chomp }.sort.join(', ') if self.class.group?(resource_name)
+
+    # Start by querying with pacman first
+    # If that fails, retry using yaourt against the AUR
+    pacman_check = true
     begin
       if pacman_check
-        output = pacman "-Sp", "--print-format", "%v", @resource[:name]
+        output = pacman "-Sp", "--print-format", "%v", resource_name
         return output.chomp
       else
-        output = yaourt "-Qma", @resource[:name]
+        output = yaourt "-Qma", resource_name
         output.split("\n").each do |line|
           return line.split[1].chomp if line =~ /^aur/
         end
       end
     rescue Puppet::ExecutionFailure
-      if pacman_check and self.yaourt?
+      if pacman_check and self.class.yaourt?
         pacman_check = false # now try the AUR
         retry
       else
@@ -195,31 +162,56 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     end
   end
 
-  # Querys the pacman master list for information about the package.
+  # Querys information for a package or package group
   def query
-    begin
-      output = pacman("-Qi", @resource[:name])
+    installed_packages = self.class.get_installed_packages
+    resource_name = @resource[:name]
 
-      if output =~ /Version.*:\s(.+)/
-        return { :ensure => $1 }
+    # Check for the resource being a group
+    version = self.class.get_installed_groups(installed_packages, resource_name)[resource_name]
+
+    if version
+      unless @resource.allow_virtual?
+        warning("#{resource_name} is a group, but allow_virtual is false.")
+        return nil
       end
-    rescue Puppet::ExecutionFailure
-      return {
-        :ensure => :purged,
-        :status => 'missing',
-        :name => @resource[:name],
-        :error => 'ok',
-      }
+    else
+      version = installed_packages[resource_name]
     end
-    nil
+
+    # Return nil if no package or group found
+    return nil unless version
+
+    self.class.to_resource_hash(resource_name, version)
+  end
+
+  def self.to_resource_hash(name, version)
+    {
+      :name     => name,
+      :ensure   => version,
+      :provider => self.name
+    }
   end
 
   # Removes a package from the system.
   def uninstall
+    resource_name = @resource[:name]
+
+    is_group = self.class.group?(resource_name)
+
+    fail("Refusing to uninstall package group #{resource_name}, because allow_virtual is false.") if is_group && !@resource.allow_virtual?
+
     cmd = %w{--noconfirm --noprogressbar}
     cmd += uninstall_options if @resource[:uninstall_options]
-    cmd << "-R" << @resource[:name]
-    pacman *cmd
+    cmd << "-R"
+    cmd << '-s' if is_group
+    cmd << resource_name
+
+    if self.class.yaourt?
+      yaourt *cmd
+    else
+      pacman *cmd
+    end
   end
 
   private
@@ -231,4 +223,44 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
   def uninstall_options
     join_options(@resource[:uninstall_options])
   end
+
+  def install_from_file
+    source = @resource[:source]
+    begin
+      source_uri = URI.parse source
+    rescue => detail
+      self.fail Puppet::Error, "Invalid source '#{source}': #{detail}", detail
+    end
+
+    source = case source_uri.scheme
+    when nil then source
+    when /https?/i then source
+    when /ftp/i then source
+    when /file/i then source_uri.path
+    when /puppet/i
+      fail "puppet:// URL is not supported by pacman"
+    else
+      fail "Source #{source} is not supported by pacman"
+    end
+    pacman "--noconfirm", "--noprogressbar", "-Sy"
+    pacman "--noconfirm", "--noprogressbar", "-U", source
+  end
+
+  def install_from_repo
+    resource_name = @resource[:name]
+
+    # Refuse to install if not allowing virtual packages and the resource is a group
+    fail("Refusing to install package group #{resource_name}, because allow_virtual is false.") if self.class.group?(resource_name) && !@resource.allow_virtual?
+
+    cmd = %w{--noconfirm --needed --noprogressbar}
+    cmd += install_options if @resource[:install_options]
+    cmd << "-Sy" << resource_name
+
+    if self.class.yaourt?
+      yaourt *cmd
+    else
+      pacman *cmd
+    end
+  end
+
 end

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

@@ -3,7 +3,6 @@
 
 require 'puppet/provider/package'
 require 'xmlrpc/client'
-require 'puppet/util/http_proxy'
 
 Puppet::Type.type(:package).provide :pip,
   :parent => ::Puppet::Provider::Package do
@@ -57,16 +56,7 @@ Puppet::Type.type(:package).provide :pip,
   # cache of PyPI's package list so this operation will always have to
   # ask the web service.
   def latest
-    http_proxy_host = Puppet::Util::HttpProxy.http_proxy_host
-    http_proxy_port = Puppet::Util::HttpProxy.http_proxy_port
-    if http_proxy_host && http_proxy_port
-      proxy = "#{http_proxy_host}:#{http_proxy_port}"
-    else
-      # nil is acceptable
-      proxy = http_proxy_host
-    end
-
-    client = XMLRPC::Client.new2("http://pypi.python.org/pypi", proxy)
+    client = XMLRPC::Client.new2("http://pypi.python.org/pypi")
     client.http_header_extra = {"Content-Type" => "text/xml"}
     client.timeout = 10
     result = client.call("package_releases", @resource[:name])

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

@@ -26,7 +26,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   defaultfor :osfamily => :solaris, :kernelrelease => '5.11'
 
   def self.instances
-    pkg(:list, '-H').split("\n").map{|l| new(parse_line(l))}
+    pkg(:list, '-Hv').split("\n").map{|l| new(parse_line(l))}
   end
 
   # The IFO flag field is just what it names, the first field can have ether
@@ -90,23 +90,15 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
   # formats of output for different pkg versions.
   def self.parse_line(line)
     (case line.chomp
-    # NAME (PUBLISHER)            VERSION           IFO  (new:630e1ffc7a19)
-    # system/core-os              0.5.11-0.169      i--
-    when /^(\S+) +(\S+) +(...)$/
-      {:name => $1, :ensure => $2}.merge ifo_flag($3)
+    # FMRI                                                                         IFO
+    # pkg://omnios/SUNWcs@0.5.11,5.11-0.151008:20131204T022241Z                    ---
+    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(...)$'
+      {:publisher => $1, :name => $2, :ensure => $3}.merge ifo_flag($4)
 
-    # x11/wm/fvwm (fvwm.org)      2.6.1-3           i--
-    when /^(\S+) \((.+)\) +(\S+) +(...)$/
-      {:name => $1, :publisher => $2, :ensure => $3}.merge ifo_flag($4)
-
-    # NAME (PUBLISHER)                  VERSION          STATE      UFOXI (dvd:052adf36c3f4)
-    # SUNWcs                            0.5.11-0.126     installed  -----
-    when /^(\S+) +(\S+) +(\S+) +(.....)$/
-      {:name => $1, :ensure => $2}.merge pkg_state($3).merge(ufoxi_flag($4))
-
-    # web/firefox/plugin/flash (extra)  10.0.32.18-0.111 installed  -----
-    when /^(\S+) \((.+)\) +(\S+) +(\S+) +(.....)$/
-      {:name => $1, :publisher => $2, :ensure => $3}.merge pkg_state($4).merge(ufoxi_flag($5))
+    # FMRI                                                             STATE      UFOXI
+    # pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  u----
+    when %r'^pkg://([^/]+)/([^@]+)@(\S+) +(\S+) +(.....)$'
+      {:publisher => $1, :name => $2, :ensure => $3}.merge pkg_state($4).merge(ufoxi_flag($5))
 
     else
       raise ArgumentError, 'Unknown line format %s: %s' % [self.name, line]
@@ -122,19 +114,69 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     raise Puppet::Error, "Unable to unfreeze #{r[:out]}" unless [0,4].include? r[:exit]
   end
 
+  def insync?(is)
+    # this is called after the generic version matching logic (insync? for the
+    # type), so we only get here if should != is, and 'should' is a version
+    # number. 'is' might not be, though.
+    should = @resource[:ensure]
+    # NB: it is apparently possible for repository administrators to publish
+    # packages which do not include build or branch versions, but component
+    # version must always be present, and the timestamp is added by pkgsend
+    # publish.
+    if /^[0-9.]+(,[0-9.]+)?(-[0-9.]+)?:[0-9]+T[0-9]+Z$/ !~ should
+      # We have a less-than-explicit version string, which we must accept for
+      # backward compatibility. We can find the real version this would match
+      # by asking pkg for the all matching versions, and selecting the first
+      # installable one [0]; this can change over time when remote repositories
+      # are updated, but the principle of least astonishment should still hold:
+      # if we allow users to specify less-than-explicit versions, the
+      # functionality should match that of the package manager.
+      #
+      # [0]: we could simply get the newest matching version with 'pkg list
+      # -n', but that isn't always correct, since it might not be installable.
+      # If that were the case we could potentially end up returning false for
+      # insync? here but not actually changing the package version in install
+      # (ie. if the currently installed version is the latest matching version
+      # that is installable, we would falsely conclude here that since the
+      # installed version is not the latest matching version, we're not in
+      # sync).  'pkg list -a' instead of '-n' would solve this, but
+      # unfortunately it doesn't consider downgrades 'available' (eg. with
+      # installed foo@1.0, list -a foo@0.9 would fail).
+      name = @resource[:name]
+      potential_matches = pkg(:list, '-Hvfa', "#{name}@#{should}").split("\n").map{|l|self.class.parse_line(l)}
+      n = potential_matches.length
+      if n > 1
+        warning("Implicit version #{should} has #{n} possible matches")
+      end
+      potential_matches.each{ |p|
+        command = is == :absent ? 'install' : 'update'
+        status = exec_cmd(command(:pkg), command, '-n', "#{name}@#{p[:ensure]}")[:exit]
+        case status
+        when 4
+          # if the first installable match would cause no changes, we're in sync
+          return true
+        when 0
+          warning("Selecting version '#{p[:ensure]}' for implicit '#{should}'")
+          @resource[:ensure] = p[:ensure]
+          return false
+        end
+      }
+      raise Puppet::DevError, "No version of #{name} matching #{should} is installable, even though the package is currently installed"
+    end
+
+    false
+  end
+
   # Return the version of the package. Note that the bug
   # http://defect.opensolaris.org/bz/show_bug.cgi?id=19159%
   # notes that we can't use -Ha for the same even though the manual page reads that way.
   def latest
-    lines = pkg(:list, "-Hn", @resource[:name]).split("\n")
+    lines = pkg(:list, "-Hvn", @resource[:name]).split("\n")
 
     # remove certificate expiration warnings from the output, but report them
-    # Note: we'd like to use select! here to modify the lines array and avoid
-    #       the second select further down. But Solaris 11 comes with ruby 1.8.7
-    #       which doesn't support select!, so do this as two selects.
     cert_warnings = lines.select { |line| line =~ /^Certificate/ }
-    if cert_warnings
-      Puppet.warning("pkg warning: #{cert_warnings}")
+    unless cert_warnings.empty?
+      Puppet.warning("pkg warning: #{cert_warnings.join(', ')}")
     end
 
     lst = lines.select { |line| line !~ /^Certificate/ }.map { |line| self.class.parse_line(line) }
@@ -155,14 +197,16 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
     should = @resource[:ensure]
     # always unhold if explicitly told to install/update
     self.unhold
+    is = self.query
+    if is[:ensure].to_sym == :absent
+      command = 'install'
+    else
+      command = 'update'
+    end
     unless should.is_a? Symbol
       name += "@#{should}"
-      is = self.query
-      unless is[:ensure].to_sym == :absent
-        self.uninstall if Puppet::Util::Package.versioncmp(should, is[:ensure]) < 0
-      end
     end
-    r = exec_cmd(command(:pkg), 'install', '--accept', name)
+    r = exec_cmd(command(:pkg), command, '--accept', name)
     return r if nofail
     raise Puppet::Error, "Unable to update #{r[:out]}" if r[:exit] != 0
   end
@@ -189,7 +233,7 @@ Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package d
 
   # list a specific package
   def query
-    r = exec_cmd(command(:pkg), 'list', '-H', @resource[:name])
+    r = exec_cmd(command(:pkg), 'list', '-Hv', @resource[:name])
     return {:ensure => :absent, :name => @resource[:name]} if r[:exit] != 0
     self.class.parse_line(r[:out])
   end

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

@@ -9,7 +9,7 @@
 # in /var/db/.puppet_pkgdmg_installed_<name>
 
 require 'puppet/provider/package'
-require 'facter/util/plist'
+require 'plist'
 require 'puppet/util/http_proxy'
 
 Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Package do
@@ -81,7 +81,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
     begin
       if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
         cached_source = File.join(tmpdir, "#{name}#{ext}")
-        args = [ "-o", cached_source, "-C", "-", "-k", "-L", "-s", "--fail", "--url", source ]
+        args = [ "-o", cached_source, "-C", "-", "-L", "-s", "--fail", "--url", source ]
         if http_proxy_host and http_proxy_port
           args << "--proxy" << "#{http_proxy_host}:#{http_proxy_port}"
         elsif http_proxy_host and not http_proxy_port
@@ -89,7 +89,7 @@ Puppet::Type.type(:package).provide :pkgdmg, :parent => Puppet::Provider::Packag
         end
       begin
         curl *args
-          Puppet.debug "Success: curl transfered [#{name}] (via: curl #{args.join(" ")})"
+          Puppet.debug "Success: curl transferred [#{name}] (via: curl #{args.join(" ")})"
         rescue Puppet::ExecutionFailure
           Puppet.debug "curl #{args.join(" ")} did not transfer [#{name}].  Falling back to local file." # This used to fall back to open-uri. -NF
           cached_source = source

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

@@ -75,7 +75,7 @@ Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package
   end
 
   def latest
-    package = parse_pkgsearch_line.detect{ |package| package[:status] == '<' }
+    package = parse_pkgsearch_line.detect{ |p| p[:status] == '<' }
     return properties[:ensure] if not package
     return package[:ensure]
   end

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

@@ -4,7 +4,7 @@ require 'fileutils'
 Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Package do
   desc "Provides packaging support for Gentoo's portage system."
 
-  has_feature :versionable
+  has_features :versionable, :reinstallable
 
   {
     :emerge => "/usr/bin/emerge",
@@ -73,6 +73,10 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
     emerge "--unmerge", package_name
   end
 
+  def reinstall
+    self.install
+  end
+
   def update
     self.install
   end

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

@@ -46,7 +46,6 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
       output = portinfo(*cmdline)
     rescue Puppet::ExecutionFailure
       raise Puppet::Error.new(output, $!)
-      return nil
     end
 
     # split output and match it and populate temp hash
@@ -162,7 +161,6 @@ Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::P
     # At this point normal operation has finished and we shouldn't have been called.
     # Error out and let the admin deal with it.
     raise Puppet::Error, "portversion.latest() - fatal error with portversion: #{output}"
-    return nil
   end
 
   ###### Query subcommand - return a hash of details if exists, or nil if it doesn't.

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

@@ -0,0 +1,17 @@
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :puppet_gem, :parent => :gem do
+  desc "Puppet Ruby Gem support. This provider is useful for managing
+        gems needed by the ruby provided in the puppet-agent package."
+
+  has_feature :versionable, :install_options, :uninstall_options
+
+  if Puppet.features.microsoft_windows?
+    # On windows, we put our ruby ahead of anything that already
+    # existed on the system PATH. This means that we do not need to
+    # sort out the absolute path.
+    commands :gemcmd => "gem"
+  else
+    commands :gemcmd => "/opt/puppetlabs/puppet/bin/gem"
+  end
+end