puppet 2.7.26 → 3.0.0.rc4

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

@@ -0,0 +1,60 @@
+require "puppet/provider/package"
+
+Puppet::Type.type(:package).provide :pkgin, :parent => Puppet::Provider::Package do
+  desc "Package management using pkgin, a binary package manager for pkgsrc."
+
+  commands :pkgin => "pkgin"
+
+  has_feature :installable, :uninstallable
+
+  def self.parse_pkgin_line(package, force_status=nil)
+
+    # e.g.
+    #   vim-7.2.446 =        Vim editor (vi clone) without GUI
+    match, name, version, status = *package.match(/(\S+)-(\S+)(?: (=|>|<))?\s+.+$/)
+    if match
+      ensure_status = if force_status
+        force_status
+      elsif status
+        :present
+      else
+        :absent
+      end
+
+      {
+        :name     => name,
+        :ensure   => ensure_status,
+        :provider => :pkgin
+      }
+    end
+  end
+
+  def self.instances
+    pkgin(:list).split("\n").map do |package|
+      new(parse_pkgin_line(package, :present))
+    end
+  end
+
+  def query
+    packages = pkgin(:search, resource[:name]).split("\n")
+
+    # Remove the last three lines of help text.
+    packages.slice!(-3, 3)
+
+    matching_package = nil
+    packages.detect do |package|
+      properties = self.class.parse_pkgin_line(package)
+      matching_package = properties if properties && resource[:name] == properties[:name]
+    end
+
+    matching_package
+  end
+
+  def install
+    pkgin("-y", :install, resource[:name])
+  end
+
+  def uninstall
+    pkgin("-y", :remove, resource[:name])
+  end
+end

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

@@ -7,9 +7,11 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
     pkgutil_bin = "/opt/csw/bin/pkgutil"
   end
 
-  confine :operatingsystem => :solaris
+  confine :osfamily => :solaris
 
-  commands :pkguti => pkgutil_bin
+  has_command(:pkguti, pkgutil_bin) do
+    environment :HOME => ENV['HOME']
+  end
 
   def self.healthcheck()
     unless FileTest.exists?("/var/opt/csw/pkgutil/admin")
@@ -39,7 +41,8 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
 
     # The -c pkglist lists installed packages
     pkginsts = []
-    pkglist(hash).each do |pkg|
+    output = pkguti(["-c"])
+    parse_pkglist(output).each do |pkg|
       pkg.delete(:avail)
       pkginsts << new(pkg)
 
@@ -72,19 +75,17 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
     end.reject { |h| h.nil? }
   end
 
-  # Turn our pkgutil -c listing into a bunch of hashes.
-  # Supports :justme => packagename, which uses the optimised --single arg
-  def self.pkglist(hash)
-    command = ["-c"]
-
-    if hash[:justme]
-      # The --single option speeds up the execution, because it queries
-      # the package managament system for one package only.
-      command << "--single"
-      command << hash[:justme]
-    end
+  # Turn our pkgutil -c listing into a hash for a single package.
+  def pkgsingle(resource)
+    # The --single option speeds up the execution, because it queries
+    # the package managament system for one package only.
+    command = ["-c", "--single", resource[:name]]
+    self.class.parse_pkglist(run_pkgutil(resource, command), { :justme => resource[:name] })
+  end
 
-    output = pkguti(command).split("\n")
+  # Turn our pkgutil -c listing into a bunch of hashes.
+  def self.parse_pkglist(output, hash = {})
+    output = output.split("\n")
 
     if output[-1] == "Not in catalog"
       Puppet.warning "Package not in pkgutil catalog: %s" % hash[:justme]
@@ -146,18 +147,29 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
     end
   end
 
+  def run_pkgutil(resource, *args)
+    # Allow source to be one or more URLs pointing to a repository that all
+    # get passed to pkgutil via one or more -t options
+    if resource[:source]
+      sources = [resource[:source]].flatten
+      pkguti *[sources.map{|src| [ "-t", src ]}, *args].flatten
+    else
+      pkguti *args.flatten
+    end
+  end
+
   def install
-    pkguti "-y", "-i", @resource[:name]
+    run_pkgutil @resource, "-y", "-i", @resource[:name]
   end
 
   # Retrieve the version from the current package file.
   def latest
-    hash = self.class.pkglist(:justme => @resource[:name])
+    hash = pkgsingle(@resource)
     hash[:avail] if hash
   end
 
   def query
-    if hash = self.class.pkglist(:justme => @resource[:name])
+    if hash = pkgsingle(@resource)
       hash
     else
       {:ensure => :absent}
@@ -165,10 +177,10 @@ Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun d
   end
 
   def update
-    pkguti "-y", "-u", @resource[:name]
+    run_pkgutil @resource, "-y", "-u", @resource[:name]
   end
 
   def uninstall
-    pkguti "-y", "-r", @resource[:name]
+    run_pkgutil @resource, "-y", "-r", @resource[:name]
   end
 end

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

@@ -24,7 +24,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
       update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
 
       search_output = nil
-      Puppet::Util::Execution.withenv :LASTVERSION => version_format do
+      Puppet::Util.withenv :LASTVERSION => version_format do
         search_output = eix "--nocolor", "--pure-packages", "--stable", "--installed", "--format", search_format
       end
 
@@ -86,7 +86,7 @@ Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Packa
       update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
 
       search_output = nil
-      Puppet::Util::Execution.withenv :LASTVERSION => version_format do
+      Puppet::Util.withenv :LASTVERSION => version_format do
         search_output = eix "--nocolor", "--pure-packages", "--stable", "--format", search_format, "--exact", search_field, search_value
       end
 

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

@@ -5,150 +5,117 @@ require 'puppet/provider/package'
 Puppet::Type.type(:package).provide :sun, :parent => Puppet::Provider::Package do
   desc "Sun's packaging system.  Requires that you specify the source for
     the packages you're managing."
+
   commands :pkginfo => "/usr/bin/pkginfo",
     :pkgadd => "/usr/sbin/pkgadd",
     :pkgrm => "/usr/sbin/pkgrm"
 
-  confine :operatingsystem => :solaris
+  confine :osfamily => :solaris
+  defaultfor :osfamily => :solaris
 
-  defaultfor :operatingsystem => :solaris
+  has_feature :install_options
 
-  def self.instances
-    packages = []
-    hash = {}
-    names = {
-      "PKGINST" => :name,
-      "NAME" => nil,
-      "CATEGORY" => :category,
-      "ARCH" => :platform,
-      "VERSION" => :ensure,
-      "BASEDIR" => :root,
-      "HOTLINE" => nil,
-      "EMAIL" => nil,
-      "VENDOR" => :vendor,
-      "DESC" => :description,
-      "PSTAMP" => nil,
-      "INSTDATE" => nil,
-      "STATUS" => nil,
-      "FILES" => nil
-    }
+  Namemap = {
+    "PKGINST"  => :name,
+    "CATEGORY" => :category,
+    "ARCH"     => :platform,
+    "VERSION"  => :ensure,
+    "BASEDIR"  => :root,
+    "VENDOR"   => :vendor,
+    "DESC"     => :description,
+  }
 
-    cmd = "#{command(:pkginfo)} -l"
-
-    # list out all of the packages
-    execpipe(cmd) { |process|
-      # we're using the long listing, so each line is a separate
-      # piece of information
-      process.each_line { |line|
-        case line
-        when /^$/
-          hash[:provider] = :sun
-
-          packages << new(hash)
-          hash = {}
-        when /\s*(\w+):\s+(.+)/
-          name = $1
-          value = $2
-          if names.include?(name)
-            hash[names[name]] = value unless names[name].nil?
-          end
-        when /\s+\d+.+/
-          # nothing; we're ignoring the FILES info
-        end
-      }
-    }
-    packages
+  def self.namemap(hash)
+    Namemap.keys.inject({}) do |hsh,k|
+      hsh.merge(Namemap[k] => hash[k])
+    end
   end
 
-  # Get info on a package, optionally specifying a device.
-  def info2hash(device = nil)
-    names = {
-      "PKGINST" => :name,
-      "NAME" => nil,
-      "CATEGORY" => :category,
-      "ARCH" => :platform,
-      "VERSION" => :ensure,
-      "BASEDIR" => :root,
-      "HOTLINE" => nil,
-      "EMAIL" => nil,
-      "VSTOCK" => nil,
-      "VENDOR" => :vendor,
-      "DESC" => :description,
-      "PSTAMP" => nil,
-      "INSTDATE" => nil,
-      "STATUS" => nil,
-      "FILES" => nil
-    }
-
-    hash = {}
-    cmd = "#{command(:pkginfo)} -l"
-    cmd += " -d #{device}" if device
-    cmd += " #{@resource[:name]}"
-
-    begin
-      # list out all of the packages
-      execpipe(cmd) { |process|
-        # we're using the long listing, so each line is a separate
-        # piece of information
-        process.readlines.each { |line|
-          case line
-          when /^$/  # ignore
-          when /\s*([A-Z]+):\s+(.+)/
-            name = $1
-            value = $2
-            if names.include?(name)
-              hash[names[name]] = value unless names[name].nil?
-            end
-          when /\s+\d+.+/
-            # nothing; we're ignoring the FILES info
-          end
-        }
-      }
-      return hash
-    rescue Puppet::ExecutionFailure => detail
-      return {:ensure => :absent} if detail.message =~ /information for "#{Regexp.escape(@resource[:name])}" was not found/
-      puts detail.backtrace if Puppet[:trace]
-      raise Puppet::Error, "Unable to get information about package #{@resource[:name]} because of: #{detail}"
+  def self.parse_pkginfo(out)
+    # collect all the lines with : in them, and separate them out by ^$
+    pkgs = []
+    pkg = {}
+    out.each_line do |line|
+      case line.chomp
+      when /^\s*$/
+        pkgs << pkg unless pkg.empty?
+        pkg = {}
+      when /^\s*([^:]+):\s+(.+)$/
+        pkg[$1] = $2
+      end
     end
+    pkgs << pkg unless pkg.empty?
+    pkgs
   end
 
-  def install
-    raise Puppet::Error, "Sun packages must specify a package source" unless @resource[:source]
-    cmd = []
-
-    cmd << "-a" << @resource[:adminfile] if @resource[:adminfile]
-
-    cmd << "-r" << @resource[:responsefile] if @resource[:responsefile]
-
-    cmd << "-d" << @resource[:source]
-    cmd << "-n" << @resource[:name]
+  def self.instances
+    parse_pkginfo(execute([command(:pkginfo), '-l'])).collect do |p|
+      hash = namemap(p)
+      hash[:provider] = :sun
+      new(hash)
+    end
+  end
 
-    pkgadd cmd
+  # Get info on a package, optionally specifying a device.
+  def info2hash(device = nil)
+    cmd = [command(:pkginfo), '-l']
+    cmd << '-d' << device if device
+    cmd << @resource[:name]
+    pkgs = self.class.parse_pkginfo(execute(cmd, :failonfail => false))
+    errmsg = case pkgs.size
+             when 0; 'No message'
+             when 1; pkgs[0]['ERROR']
+             end
+    return self.class.namemap(pkgs[0]) if errmsg.nil?
+    return {:ensure => :absent} if errmsg =~ /information for "#{Regexp.escape(@resource[:name])}"/
+    raise Puppet::Error, "Unable to get information about package #{@resource[:name]} because of: #{errmsg}"
   end
 
   # Retrieve the version from the current package file.
   def latest
-    hash = info2hash(@resource[:source])
-    hash[:ensure]
+    info2hash(@resource[:source])[:ensure]
   end
 
   def query
-    info2hash()
+    info2hash
   end
 
-  def uninstall
-    command  = ["-n"]
-
-    command << "-a" << @resource[:adminfile] if @resource[:adminfile]
+  # only looking for -G now
+  def install
+    raise Puppet::Error, "Sun packages must specify a package source" unless @resource[:source]
+    options = {
+      :adminfile    => @resource[:adminfile],
+      :responsefile => @resource[:responsefile],
+      :source       => @resource[:source],
+      :cmd_options  => @resource[:install_options]
+    }
+    pkgadd prepare_cmd(options)
+  end
 
-    command << @resource[:name]
-    pkgrm command
+  def uninstall
+    pkgrm prepare_cmd(:adminfile => @resource[:adminfile])
   end
 
   # Remove the old package, and install the new one.  This will probably
   # often fail.
   def update
-    self.uninstall if (@property_hash[:ensure] || info2hash()[:ensure]) != :absent
+    self.uninstall if (@property_hash[:ensure] || info2hash[:ensure]) != :absent
     self.install
   end
+
+  def prepare_cmd(opt)
+    [if_have_value('-a', opt[:adminfile]),
+     if_have_value('-r', opt[:responsefile]),
+     if_have_value('-d', opt[:source]),
+     opt[:cmd_options] || [],
+     ['-n', @resource[:name]]].flatten
+  end
+
+  def if_have_value(prefix, value)
+    if value
+      [prefix, value]
+    else
+      []
+    end
+  end
 end

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

@@ -5,5 +5,5 @@ Puppet::Type.type(:package).provide :sunfreeware, :parent => :blastwave, :source
     has not actually been tested."
   commands :pkgget => "pkg-get"
 
-  confine :operatingsystem => :solaris
+  confine :osfamily => :solaris
 end

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

@@ -4,10 +4,9 @@ Puppet::Type.type(:package).provide :up2date, :parent => :rpm, :source => :rpm d
 
   commands :up2date => "/usr/sbin/up2date-nox"
 
-  defaultfor :operatingsystem => [:redhat, :oel, :ovm],
-    :lsbdistrelease => ["2.1", "3", "4"]
+  defaultfor :osfamily => :redhat, :lsbdistrelease => ["2.1", "3", "4"]
 
-  confine    :operatingsystem => [:redhat, :oel, :ovm]
+  confine    :osfamily => :redhat
 
   # Install a package using 'up2date'.
   def install

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

@@ -0,0 +1,130 @@
+require 'puppet/provider/package'
+require 'puppet/util/windows'
+require 'puppet/provider/package/windows/package'
+
+Puppet::Type.type(:package).provide(:windows, :parent => Puppet::Provider::Package) do
+  desc "Windows package management.
+
+    This provider supports either MSI or self-extracting executable installers.
+
+    This provider requires a `source` attribute when installing the package.
+    It accepts paths paths to local files, mapped drives, or UNC paths.
+
+    If the executable requires special arguments to perform a silent install or
+    uninstall, then the appropriate arguments should be specified using the
+    `install_options` or `uninstall_options` attributes, respectively.  Puppet
+    will automatically quote any option that contains spaces."
+
+  confine    :operatingsystem => :windows
+  defaultfor :operatingsystem => :windows
+
+  has_feature :installable
+  has_feature :uninstallable
+  has_feature :install_options
+  has_feature :uninstall_options
+
+  attr_accessor :package
+
+  # Return an array of provider instances
+  def self.instances
+    Puppet::Provider::Package::Windows::Package.map do |pkg|
+      provider = new(to_hash(pkg))
+      provider.package = pkg
+      provider
+    end
+  end
+
+  def self.to_hash(pkg)
+    {
+      :name     => pkg.name,
+      # we're not versionable, so we can't set the ensure
+      # parameter to the currently installed version
+      :ensure   => :installed,
+      :provider => :windows
+    }
+  end
+
+  # Query for the provider hash for the current resource. The provider we
+  # are querying, may not have existed during prefetch
+  def query
+    Puppet::Provider::Package::Windows::Package.find do |pkg|
+      if pkg.match?(resource)
+        return self.class.to_hash(pkg)
+      end
+    end
+    nil
+  end
+
+  def install
+    installer = Puppet::Provider::Package::Windows::Package.installer_class(resource)
+
+    command = [installer.install_command(resource), install_options].flatten.compact.join(' ')
+    execute(command, {:combine => true})
+
+    check_result(exit_status)
+  end
+
+  def uninstall
+    command = [package.uninstall_command, uninstall_options].flatten.compact.join(' ')
+    execute(command, {:combine => true})
+
+    check_result(exit_status)
+  end
+
+  def exit_status
+    $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'
+
+    case hr
+    when ERROR_SUCCESS
+      # yeah
+    when 194
+      warning("The package requested a reboot to finish the operation.")
+    when ERROR_SUCCESS_REBOOT_INITIATED
+      warning("The package #{operation}ed successfully and the system is rebooting now.")
+    when ERROR_SUCCESS_REBOOT_REQUIRED
+      warning("The package #{operation}ed successfully, but the system must be rebooted.")
+    else
+      raise Puppet::Util::Windows::Error.new("Failed to #{operation}", hr)
+    end
+  end
+
+  # This only get's called if there is a value to validate, but not if it's absent
+  def validate_source(value)
+    fail("The source parameter cannot be empty when using the Windows provider.") if value.empty?
+  end
+
+  def install_options
+    join_options(resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(resource[:uninstall_options])
+  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