puppet 2.7.26 → 3.0.0.rc4

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

@@ -23,17 +23,14 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
   # install packages from remote sites.
 
   def checkforcdrom
-    unless defined?(@@checkedforcdrom)
-      if FileTest.exists? "/etc/apt/sources.list"
-        @@checkedforcdrom = !!(File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/)
-      else
-        # This is basically a pathalogical case, but we'll just
-        # ignore it
-        @@checkedforcdrom = false
-      end
-    end
-
-    if @@checkedforcdrom and @resource[:allowcdrom] != :true
+    have_cdrom = begin
+                   !!(File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/)
+                 rescue
+                   # This is basically pathological...
+                   false
+                 end
+
+    if have_cdrom and @resource[:allowcdrom] != :true
       raise Puppet::Error,
         "/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure."
     end

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

@@ -4,12 +4,12 @@ Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun
   pkgget = "pkg-get"
   pkgget = "/opt/csw/bin/pkg-get" if FileTest.executable?("/opt/csw/bin/pkg-get")
 
-  confine :operatingsystem => :solaris
+  confine :osfamily => :solaris
 
   commands :pkgget => pkgget
 
   def pkgget_with_cat(*args)
-    Puppet::Util::Execution::withenv(:PAGER => "/usr/bin/cat") { pkgget(*args) }
+    Puppet::Util.withenv(:PAGER => "/usr/bin/cat") { pkgget(*args) }
   end
 
   def self.extended(mod)
@@ -37,7 +37,7 @@ Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun
 
     command << hash[:justme] if hash[:justme]
 
-    output = Puppet::Util::Execution::withenv(:PAGER => "/usr/bin/cat") { pkgget command }
+    output = Puppet::Util.withenv(:PAGER => "/usr/bin/cat") { pkgget command }
 
     list = output.split("\n").collect do |line|
       next if line =~ /^#/

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

@@ -17,7 +17,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     # list out all of the packages
     cmd = "#{command(:dpkgquery)} -W --showformat '${Status} ${Package} ${Version}\\n'"
     Puppet.debug "Executing '#{cmd}'"
-    execpipe(cmd) do |process|
+    Puppet::Util::Execution.execpipe(cmd) do |process|
       # our regex for matching dpkg output
       regex = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
       fields = [:desired, :error, :status, :name, :ensure]

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

@@ -20,11 +20,11 @@ Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
 
     if @resource[:source] =~ /\/$/
       if @resource[:source] =~ /^(ftp|https?):/
-        Puppet::Util::Execution::withenv :PACKAGESITE => @resource[:source] do
+        Puppet::Util.withenv :PACKAGESITE => @resource[:source] do
           pkgadd "-r", @resource[:name]
         end
       else
-        Puppet::Util::Execution::withenv :PKG_PATH => @resource[:source] do
+        Puppet::Util.withenv :PKG_PATH => @resource[:source] do
           pkgadd @resource[:name]
         end
       end

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

@@ -58,7 +58,7 @@ Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package d
         :provider => :gem
       }
     else
-      Puppet.warning "Could not match #{desc}"
+      Puppet.warning "Could not match #{desc}" unless desc.chomp.empty?
       nil
     end
   end

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

@@ -1,4 +1,5 @@
 require 'puppet/provider/package'
+require 'puppet/provider/command'
 
 Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Package do
   desc "Package management using MacPorts on OS X.
@@ -12,7 +13,10 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
   "
 
   confine :operatingsystem => :darwin
-  commands :port => "/opt/local/bin/port"
+
+  has_command(:port, "/opt/local/bin/port") do 
+    environment :HOME => "/opt/local"
+  end
 
   has_feature :installable
   has_feature :uninstallable
@@ -21,7 +25,7 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
 
 
   def self.parse_installed_query_line(line)
-    regex = /(\S+)\s+@(\S+)_(\S+)\s+\(active\)/
+    regex = /(\S+)\s+@(\S+)_(\d+).*\(active\)/
     fields = [:name, :ensure, :revision]
     hash_from_line(line, regex, fields)
   end
@@ -66,14 +70,16 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
   end
 
   def query
-    return self.class.parse_installed_query_line(port("-q", :installed, @resource[:name]))
+    result = self.class.parse_installed_query_line(execute([command(:port), "-q", :installed, @resource[:name]], :combine => false))
+    return {} if result.nil?
+    return result
   end
 
   def latest
     # We need both the version and the revision to be confident
     # we've got the latest revision of a specific version
     # Note we're still not doing anything with variants here.
-    info_line = port("-q", :info, "--line", "--version", "--revision", @resource[:name])
+    info_line = execute([command(:port), "-q", :info, "--line", "--version", "--revision", @resource[:name]], :combine => false)
     return nil if info_line == ""
 
     if newest = self.class.parse_info_query_line(info_line)
@@ -96,10 +102,6 @@ Puppet::Type.type(:package).provide :macports, :parent => Puppet::Provider::Pack
   end
 
   def update
-    if query[:name] == @resource[:name]  # 'port upgrade' cannot install new ports
-      port("-q", :upgrade, @resource[:name])
-    else
-      install
-    end
+    install
   end
 end

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

@@ -1,39 +1,36 @@
 require 'puppet/provider/package'
+require 'puppet/util/windows'
 
 Puppet::Type.type(:package).provide(:msi, :parent => Puppet::Provider::Package) do
   desc "Windows package management by installing and removing MSIs.
 
-    This provider requires a `source` attribute, and will accept paths to local
-    files, mapped drives, or UNC paths."
+    The `msi` provider is deprecated. Use the `windows` provider instead."
 
   confine    :operatingsystem => :windows
-  defaultfor :operatingsystem => :windows
 
   has_feature :installable
   has_feature :uninstallable
   has_feature :install_options
+  has_feature :uninstall_options
 
   class MsiPackage
     extend Enumerable
-
-    # From msi.h
-    INSTALLSTATE_DEFAULT = 5 # product is installed for the current user
-    INSTALLUILEVEL_NONE  = 2 # completely silent installation
+    include Puppet::Util::Windows::Registry
+    extend Puppet::Util::Windows::Registry
 
     def self.installer
-      require 'win32ole'
       WIN32OLE.new("WindowsInstaller.Installer")
     end
 
     def self.each(&block)
       inst = installer
-      inst.UILevel = INSTALLUILEVEL_NONE
+      inst.UILevel = 2
 
       inst.Products.each do |guid|
         # products may be advertised, installed in a different user
         # context, etc, we only want to know about products currently
         # installed in our context.
-        next unless inst.ProductState(guid) == INSTALLSTATE_DEFAULT
+        next unless inst.ProductState(guid) == 5
 
         package = {
           :name        => inst.ProductInfo(guid, 'ProductName'),
@@ -51,9 +48,13 @@ Puppet::Type.type(:package).provide(:msi, :parent => Puppet::Provider::Package)
     end
   end
 
-  # Get an array of provider instances for currently installed packages
   def self.instances
-    MsiPackage.enum_for.map { |package| new(package) }
+    []
+  end
+
+  def initialize(resource = nil)
+    Puppet.deprecation_warning "The `:msi` package provider is deprecated, use the `:windows` provider instead."
+    super(resource)
   end
 
   # Find first package whose PackageCode, e.g. {B2BE95D2-CD2C-46D6-8D27-35D150E58EC9},
@@ -81,7 +82,7 @@ Puppet::Type.type(:package).provide(:msi, :parent => Puppet::Provider::Package)
   def uninstall
     fail("The productcode property is missing.") unless properties[:productcode]
 
-    command = ['msiexec.exe', '/qn', '/norestart', '/x', properties[:productcode]].flatten.compact.join(' ')
+    command = ['msiexec.exe', '/qn', '/norestart', '/x', properties[:productcode], uninstall_options].flatten.compact.join(' ')
     execute(command, :combine => true)
 
     check_result(exit_status)
@@ -91,25 +92,21 @@ Puppet::Type.type(:package).provide(:msi, :parent => Puppet::Provider::Package)
     $CHILD_STATUS.exitstatus
   end
 
-  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
-  ERROR_SUCCESS                  = 0
-  ERROR_SUCCESS_REBOOT_INITIATED = 1641
-  ERROR_SUCCESS_REBOOT_REQUIRED  = 3010
-
   # (Un)install may "fail" because the package requested a reboot, the system requested a
   # reboot, or something else entirely. Reboot requests mean the package was installed
   # successfully, but we warn since we don't have a good reboot strategy.
   def check_result(hr)
     operation = resource[:ensure] == :absent ? 'uninstall' : 'install'
 
+    # http://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
     case hr
-    when ERROR_SUCCESS
+    when 0
       # yeah
     when 194
       warning("The package requested a reboot to finish the operation.")
-    when ERROR_SUCCESS_REBOOT_INITIATED
+    when 1641
       warning("The package #{operation}ed successfully and the system is rebooting now.")
-    when ERROR_SUCCESS_REBOOT_REQUIRED
+    when 3010
       warning("The package #{operation}ed successfully, but the system must be rebooted.")
     else
       raise Puppet::Util::Windows::Error.new("Failed to #{operation}", hr)
@@ -121,21 +118,29 @@ Puppet::Type.type(:package).provide(:msi, :parent => Puppet::Provider::Package)
   end
 
   def install_options
-    # properties is a string delimited by spaces, so each key value must be quoted
-    properties_for_command = nil
-    if resource[:install_options]
-      properties_for_command = resource[:install_options].collect do |k,v|
-        property = shell_quote k
-        value    = shell_quote v
-
-        "#{property}=#{value}"
-      end
-    end
+    join_options(resource[:install_options])
+  end
 
-    properties_for_command
+  def uninstall_options
+    join_options(resource[:uninstall_options])
   end
 
   def shell_quote(value)
     value.include?(' ') ? %Q["#{value.gsub(/"/, '\"')}"] : value
   end
+
+  def join_options(options)
+    return unless options
+
+    options.collect do |val|
+      case val
+      when Hash
+        val.keys.sort.collect do |k|
+          "#{k}=#{val[k]}"
+        end.join(' ')
+      else
+        val
+      end
+    end
+  end
 end

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

@@ -68,7 +68,7 @@ Puppet::Type.type(:package).provide :openbsd, :parent => Puppet::Provider::Packa
       full_name = @resource[:source]
     end
 
-    Puppet::Util::Execution::withenv(e_vars) { pkgadd full_name }
+     Puppet::Util.withenv(e_vars) { pkgadd full_name }
   end
 
   def get_version

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

@@ -1,24 +1,69 @@
 require 'puppet/provider/package'
+require 'uri'
 
 Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Package do
   desc "Support for the Package Manager Utility (pacman) used in Archlinux."
 
   commands :pacman => "/usr/bin/pacman"
-  defaultfor :operatingsystem => :archlinux
-  confine    :operatingsystem => :archlinux
+  # Yaourt is a common AUR helper which, if installed, we can use to query the AUR
+  commands :yaourt => "/usr/bin/yaourt" if File.exists? '/usr/bin/yaourt'
+
+  confine     :operatingsystem => :archlinux
+  defaultfor  :operatingsystem => :archlinux
   has_feature :upgradeable
 
-  # Install a package using 'pacman'.
+  # If yaourt is installed, we can make use of it
+  def yaourt?
+    return File.exists? '/usr/bin/yaourt'
+  end
+
+  # Install a package using 'pacman', or 'yaourt' if available.
   # Installs quietly, without confirmation or progressbar, updates package
   # list from servers defined in pacman.conf.
   def install
-    pacman "--noconfirm", "--noprogressbar", "-Sy", @resource[:name]
+    if @resource[:source]
+      install_from_file
+    else
+      install_from_repo
+    end
 
     unless self.query
       raise Puppet::ExecutionFailure.new("Could not find package %s" % self.name)
     end
   end
 
+  def install_from_repo
+    if yaourt?
+      yaourt "--noconfirm", "-S", @resource[:name]
+    else
+        pacman "--noconfirm", "--noprogressbar", "-Sy", @resource[:name]
+    end
+  end
+  private :install_from_repo
+
+  def install_from_file
+    source = @resource[:source]
+    begin
+      source_uri = URI.parse source
+    rescue => detail
+      fail "Invalid source '#{source}': #{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
+  private :install_from_file
+
   def self.listcmd
     [command(:pacman), "-Q"]
   end
@@ -62,10 +107,28 @@ Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Packag
     self.install
   end
 
+  # We rescue the main check from Pacman with a check on the AUR using yaourt, if installed
   def latest
     pacman "-Sy"
-    output = pacman "-Sp", "--print-format", "%v", @resource[:name]
-    output.chomp
+    pacman_check = true   # Query the main repos first
+    begin
+      if pacman_check
+        output = pacman "-Sp", "--print-format", "%v", @resource[:name]
+        return output.chomp
+      else 
+        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?
+        pacman_check = false # now try the AUR
+        retry
+      else
+        raise
+      end
+    end
   end
 
   # Querys the pacman master list for information about the package.

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

@@ -2,111 +2,162 @@ require 'puppet/provider/package'
 
 Puppet::Type.type(:package).provide :pkg, :parent => Puppet::Provider::Package do
   desc "OpenSolaris image packaging system. See pkg(5) for more information"
+  # http://docs.oracle.com/cd/E19963-01/html/820-6572/managepkgs.html
+  # A few notes before we start :
+  # Opensolaris pkg has two slightly different formats (as of now.)
+  # The first one is what is distributed with the Solaris 11 Express 11/10 dvd
+  # The latest one is what you get when you update package.
+  # To make things more interesting, pkg version just returns a sha sum.
+  # dvd:     pkg version => 052adf36c3f4
+  # updated: pkg version => 630e1ffc7a19
+  # Thankfully, solaris has not changed the commands to be used.
+  # TODO: We still have to allow packages to specify a preferred publisher.
+
+  has_feature :versionable
+
+  has_feature :upgradable
 
   commands :pkg => "/usr/bin/pkg"
 
-  confine :operatingsystem => :solaris
+  confine :osfamily => :solaris
 
-  #defaultfor [:operatingsystem => :solaris, :kernelrelease => "5.11"]
+  defaultfor :osfamily => :solaris, :kernelrelease => '5.11'
 
   def self.instances
-    packages = []
+    pkg(:list, '-H').split("\n").map{|l| new(parse_line(l))}
+  end
 
-    pkg(:list, '-H').each_line do |line|
-      # now turn each returned line into a package object
-      if hash = parse_line(line.chomp)
-        packages << new(hash)
-      end
+  # The IFO flag field is just what it names, the first field can have ether
+  # i_nstalled or -, and second field f_rozen or -, and last
+  # o_bsolate or r_rename or -
+  # so this checks if the installed field is present, and also verifies that
+  # if not the field is -, else we dont know what we are doing and exit with
+  # out doing more damage.
+  def self.ifo_flag(flags)
+    case flags
+    when /i../
+      {:status => 'installed'}
+    when /-../
+      {:status => 'known'}
+    else
+      raise ArgumentError, 'Unknown format %s: %s' % [self.name, flags]
     end
-
-    packages
   end
 
-  self::REGEX = /^(\S+)(?:\s+\(.*?\))?\s+(\S+)\s+(\S+)?\s+(\S+)$/
-  self::FIELDS = [:name, :version, :status, :flags]
+  # The UFOXI field is the field present in the older pkg
+  # (solaris 2009.06 - snv151a)
+  # similar to IFO, UFOXI is also an either letter or -
+  # u_pdate indicates that an update for the package is available.
+  # f_rozen(n/i) o_bsolete x_cluded(n/i) i_constrained(n/i)
+  # note that u_pdate flag may not be trustable due to constraints.
+  # so we dont rely on it
+  def self.ufoxi_flag(flags)
+    {}
+  end
 
-  def self.parse_line(line)
-    hash = {}
-    if match = self::REGEX.match(line)
-
-      self::FIELDS.zip(match.captures) { |field,value|
-        hash[field] = value
-      }
-
-      hash[:provider] = self.name
-
-      # on solaris 11 we do not have a status field because the status
-      # seems to be merged in the flags field. Simulate old behaviour on
-      # solaris 11
-      flags = hash.delete(:flags)
-      unless hash[:status]
-        hash[:status] = case flags
-          when /^i/
-            'installed'
-          when /^-/
-            'known'
-          else
-            warning "unknown package state for #{hash[:name]}: #{flags}"
-            'unknown'
-        end
-      end
-
-      if hash[:status] == "installed"
-        hash[:ensure] = :present
-      else
-        hash[:ensure] = :absent
-      end
+  # pkg state was present in the older version of pkg (with UFOXI) but is
+  # no longer available with the IFO field version. When it was present,
+  # it was used to indicate that a particular version was present (installed)
+  # and later versions were known. Note that according to the pkg man page,
+  # known never lists older versions of the package. So we can rely on this
+  # field to make sure that if a known is present, then the pkg is upgradable.
+  def self.pkg_state(state)
+    case state
+    when /installed/
+      {:status => 'installed'}
+    when /known/
+      {:status => 'known'}
     else
-      warning "Failed to match 'pkg list' line #{line.inspect}"
-      return nil
+      raise ArgumentError, 'Unknown format %s: %s' % [self.name, state]
     end
+  end
+
+  # Here is (hopefully) the only place we will have to deal with multiple
+  # 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)
+
+    # x11/wm/fvwm (fvwm.org)      2.6.1-3           i--
+    when /^(\S+) \((.+)\) +(\S+) +(\S+)$/
+      {:name => $1, :publisher => $2, :ensure => $3}.merge ifo_flag($4)
 
-    hash
+    # 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))
+
+    else
+      raise ArgumentError, 'Unknown line format %s: %s' % [self.name, line]
+    end).merge({:provider => self.name})
   end
 
-  # return the version of the package
-  # TODO deal with multiple publishers
+  # 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
-    version = nil
-    pkg(:list, "-Ha", @resource[:name]).each_line do |line|
-      v = parse_line(line.chomp)[:status]
-      case v
-      when "known"
-        return v
-      when "installed"
-        version = v
-      else
-        Puppet.warn "unknown package state for #{@resource[:name]}: #{v}"
-      end
-    end
-    version
+    lst = pkg(:list, "-Hn", @resource[:name]).split("\n").map{|l|self.class.parse_line(l)}
+
+    # Now we know there is a newer version. But is that installable? (i.e are there any constraints?)
+    # return the first known we find. The only way that is currently available is to do a dry run of
+    # pkg update and see if could get installed (`pkg update -n res`).
+    known = lst.find {|p| p[:status] == 'known' }
+    return known[:ensure] if known and exec_cmd(command(:pkg), 'update', '-n', @resource[:name])[:exit].zero?
+
+    # If not, then return the installed, else nil
+    (lst.find {|p| p[:status] == 'installed' } || {})[:ensure]
   end
 
-  # install the package
-  def install
-    pkg :install, @resource[:name]
+  # install the package and accept all licenses.
+  def install(nofail = false)
+    name = @resource[:name]
+    should = @resource[:ensure]
+    unless should.is_a? Symbol
+      name += "@#{should}"
+      is = self.query
+      self.uninstall if Puppet::Util::Package.versioncmp(should, is[:ensure]) < 0
+    end
+    r = exec_cmd(command(:pkg), 'install', '--accept', name)
+    return r if nofail
+    raise Puppet::Error, "Unable to update #{r[:out]}" if r[:exit] != 0
   end
 
-  # uninstall the package
+  # uninstall the package. The complication comes from the -r_ecursive flag which is no longer
+  # present in newer package version.
   def uninstall
-    pkg :uninstall, '-r', @resource[:name]
+    cmd = [:uninstall]
+    case (pkg :version).chomp
+    when /052adf36c3f4/
+      cmd << '-r'
+    end
+    cmd << @resource[:name]
+    pkg cmd
   end
 
   # update the package to the latest version available
   def update
-    self.install
+    r = install(true)
+    # 4 == /No updates available for this image./
+    return if [0,4].include? r[:exit]
+    raise Puppet::Error, "Unable to update #{r[:out]}"
   end
 
   # list a specific package
   def query
-    begin
-      output = pkg(:list, "-H", @resource[:name])
-    rescue Puppet::ExecutionFailure
-      # pkg returns 1 if the package is not found.
-      return {:ensure => :absent, :name => @resource[:name]}
-    end
+    r = exec_cmd(command(:pkg), 'list', '-H', @resource[:name])
+    return {:ensure => :absent, :name => @resource[:name]} if r[:exit] != 0
+    self.class.parse_line(r[:out])
+  end
 
-    hash = self.class.parse_line(output.chomp) || {:ensure => :absent, :name => @resource[:name]}
-    hash
+  def exec_cmd(*cmd)
+    output = Puppet::Util::Execution.execute(cmd, :failonfail => false, :combine => true)
+    {:out => output, :exit => $CHILD_STATUS.exitstatus}
   end
 end