bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,62 @@
+require 'puppet/provider/package/windows/package'
+
+class Puppet::Provider::Package::Windows
+  class MsiPackage < Puppet::Provider::Package::Windows::Package
+    attr_reader :productcode, :packagecode
+
+    # From msi.h
+    INSTALLSTATE_DEFAULT = 5 # product is installed for the current user
+    INSTALLUILEVEL_NONE  = 2 # completely silent installation
+
+    # Get the COM installer object, it's in a separate method for testing
+    def self.installer
+      # REMIND: when does the COM release happen?
+      WIN32OLE.new("WindowsInstaller.Installer")
+    end
+
+    # Return an instance of the package from the registry, or nil
+    def self.from_registry(name, values)
+      if valid?(name, values)
+        inst = installer
+
+        if inst.ProductState(name) == INSTALLSTATE_DEFAULT
+          MsiPackage.new(get_display_name(values),
+                         values['DisplayVersion'],
+                         name, # productcode
+                         inst.ProductInfo(name, 'PackageCode'))
+        end
+      end
+    end
+
+    # Is this a valid MSI package we should manage?
+    def self.valid?(name, values)
+      # See http://community.spiceworks.com/how_to/show/2238
+      displayName = get_display_name(values)
+      !!(displayName && displayName.length > 0 &&
+         values['WindowsInstaller'] == 1 && # DWORD
+         name =~ /\A\{[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}\Z/i)
+    end
+
+    def initialize(name, version, productcode, packagecode)
+      super(name, version)
+
+      @productcode = productcode
+      @packagecode = packagecode
+    end
+
+    # Does this package match the resource?
+    def match?(resource)
+      resource[:name].casecmp(packagecode) == 0 ||
+        resource[:name].casecmp(productcode) == 0 ||
+        resource[:name] == name
+    end
+
+    def self.install_command(resource)
+      ['msiexec.exe', '/qn', '/norestart', '/i', munge(resource[:source])]
+    end
+
+    def uninstall_command
+      ['msiexec.exe', '/qn', '/norestart', '/x', productcode]
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require 'puppet/provider/package'
+require 'puppet/util/windows'
+
+class Puppet::Provider::Package::Windows
+  class Package
+    extend Enumerable
+    extend Puppet::Util::Errors
+
+    include Puppet::Util::Windows::Registry
+    extend Puppet::Util::Windows::Registry
+
+    attr_reader :name, :version
+
+    # Enumerate each package. The appropriate package subclass
+    # will be yielded.
+    def self.each(&block)
+      with_key do |key, values|
+        name = key.name.match(/^.+\\([^\\]+)$/).captures[0]
+
+        [MsiPackage, ExePackage].find do |klass|
+          if pkg = klass.from_registry(name, values)
+            yield pkg
+          end
+        end
+      end
+    end
+
+    # Yield each registry key and its values associated with an
+    # installed package. This searches both per-machine and current
+    # user contexts, as well as packages associated with 64 and
+    # 32-bit installers.
+    def self.with_key(&block)
+      %w[HKEY_LOCAL_MACHINE HKEY_CURRENT_USER].each do |hive|
+        [KEY64, KEY32].each do |mode|
+          mode |= KEY_READ
+          begin
+            open(hive, 'Software\Microsoft\Windows\CurrentVersion\Uninstall', mode) do |uninstall|
+              each_key(uninstall) do |name, wtime|
+                open(hive, "#{uninstall.keyname}\\#{name}", mode) do |key|
+                  yield key, values(key)
+                end
+              end
+            end
+          rescue Puppet::Util::Windows::Error => e
+            raise e unless e.code == Puppet::Util::Windows::Error::ERROR_FILE_NOT_FOUND
+          end
+        end
+      end
+    end
+
+    # Get the class that knows how to install this resource
+    def self.installer_class(resource)
+      fail(_("The source parameter is required when using the Windows provider.")) unless resource[:source]
+
+      case resource[:source]
+      when /\.msi"?\Z/i
+        # REMIND: can we install from URL?
+        # REMIND: what about msp, etc
+        MsiPackage
+      when /\.exe"?\Z/i
+        fail(_("The source does not exist: '%{source}'") % { source: resource[:source] }) unless Puppet::FileSystem.exist?(resource[:source])
+        ExePackage
+      else
+        fail(_("Don't know how to install '%{source}'") % { source: resource[:source] })
+      end
+    end
+
+    def self.munge(value)
+      quote(replace_forward_slashes(value))
+    end
+
+    def self.replace_forward_slashes(value)
+      if value.include?('/')
+        value.gsub!('/', "\\")
+        Puppet.debug('Package source parameter contained /s - replaced with \\s')
+      end
+      value
+    end
+
+    def self.quote(value)
+      value.include?(' ') ? %Q["#{value.gsub(/"/, '\"')}"] : value
+    end
+
+    def self.get_display_name(values)
+      return if values.nil?
+      return values['DisplayName'] if values['DisplayName'] && values['DisplayName'].length > 0
+      return values['QuietDisplayName'] if values['QuietDisplayName'] && values['QuietDisplayName'].length > 0
+
+      ''
+    end
+
+    def initialize(name, version)
+      @name = name
+      @version = version
+    end
+  end
+end
+
+require 'puppet/provider/package/windows/msi_package'
+require 'puppet/provider/package/windows/exe_package'

data/vendored/puppet/lib/puppet/provider/package/yum.rb

@@ -0,0 +1,293 @@
+Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
+  desc "Support via `yum`.
+
+  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 yum.
+  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 => "yum", :rpm => "rpm"
+
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  defaultfor :osfamily => :redhat
+
+  def self.prefetch(packages)
+    raise Puppet::Error, _("The yum provider can only be used as root") if Process.euid != 0
+    super
+  end
+
+  # Retrieve the latest package version information for a given package name
+  # and combination of repos to enable and disable.
+  #
+  # @note If multiple package versions are defined (such as in the case where a
+  #   package is built for multiple architectures), the first package found
+  #   will be used.
+  #
+  # @api private
+  # @param package [String] The name of the package to query
+  # @param disablerepo [Array<String>] A list of repositories to disable for this query
+  # @param enablerepo [Array<String>] A list of repositories to enable for this query
+  # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
+  # @return [Hash<Symbol, String>]
+  def self.latest_package_version(package, disablerepo, enablerepo, disableexcludes)
+
+    key = [disablerepo, enablerepo, disableexcludes]
+
+    @latest_versions ||= {}
+    if @latest_versions[key].nil?
+      @latest_versions[key] = check_updates(disablerepo, enablerepo, disableexcludes)
+    end
+
+    if @latest_versions[key][package]
+      @latest_versions[key][package].first
+    end
+  end
+
+  # Search for all installed packages that have newer versions, given a
+  # combination of repositories to enable and disable.
+  #
+  # @api private
+  # @param disablerepo [Array<String>] A list of repositories to disable for this query
+  # @param enablerepo [Array<String>] A list of repositories to enable for this query
+  # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
+  # @return [Hash<String, Array<Hash<String, String>>>] All packages that were
+  #   found with a list of found versions for each package.
+  def self.check_updates(disablerepo, enablerepo, disableexcludes)
+    args = [command(:cmd), 'check-update']
+    args.concat(disablerepo.map { |repo| ["--disablerepo=#{repo}"] }.flatten)
+    args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
+    args.concat(disableexcludes.map { |repo| ["--disableexcludes=#{repo}"] }.flatten)
+
+    output = Puppet::Util::Execution.execute(args, :failonfail => false, :combine => false)
+
+    updates = {}
+    if output.exitstatus == 100
+      updates = parse_updates(output)
+    elsif output.exitstatus == 0
+      self.debug "#{command(:cmd)} check-update exited with 0; no package updates available."
+    else
+      self.warning _("Could not check for updates, '%{cmd} check-update' exited with %{status}") % { cmd: command(:cmd), status: output.exitstatus }
+    end
+    updates
+  end
+
+  def self.parse_updates(str)
+    # Strip off all content before the first blank line
+    body = str.partition(/^\s*\n/m).last
+
+    updates = Hash.new { |h, k| h[k] = [] }
+    body.split.each_slice(3) do |tuple|
+      break if tuple[0] =~ /^(Obsoleting|Security:|Update)/
+      break unless tuple[1].match(/^(?:(\d+):)?(\S+)-(\S+)$/)
+      hash = update_to_hash(*tuple[0..1])
+      # Create entries for both the package name without a version and a
+      # version since yum considers those as mostly interchangeable.
+      short_name = hash[:name]
+      long_name  = "#{hash[:name]}.#{hash[:arch]}"
+
+      updates[short_name] << hash
+      updates[long_name] << hash
+    end
+
+    updates
+  end
+
+  def self.update_to_hash(pkgname, pkgversion)
+    
+    # The pkgname string has two parts: name, and architecture. Architecture
+    # is the portion of the string following the last "." character. All
+    # characters preceding the final dot are the package name. Parse out
+    # these two pieces of component data.
+    name, _, arch = pkgname.rpartition('.')
+    if name.empty?
+      raise _("Failed to parse package name and architecture from '%{pkgname}'") % { pkgname: pkgname }
+    end
+
+    match = pkgversion.match(/^(?:(\d+):)?(\S+)-(\S+)$/)
+    epoch = match[1] || '0'
+    version = match[2]
+    release = match[3]
+
+    {
+      :name => name,
+      :epoch => epoch,
+      :version => version,
+      :release => release,
+      :arch    => arch,
+    }
+  end
+
+  def self.clear
+    @latest_versions = nil
+  end
+
+  def self.error_level
+    '0'
+  end
+
+  def self.update_command
+    # In yum both `upgrade` and `update` can be used to update packages
+    # `yum upgrade` == `yum --obsoletes update`
+    # Quote the DNF docs:
+    # "Yum does this if its obsoletes config option is enabled but
+    # the behavior is not properly documented and can be harmful."
+    # So we'll stick with the safer option
+    # If a user wants to remove obsoletes, they can use { :install_options => '--obsoletes' }
+    # More detail here: https://bugzilla.redhat.com/show_bug.cgi?id=1096506
+    'update'
+  end
+
+  def install
+    wanted = @resource[:name]
+    error_level = self.class.error_level
+    update_command = self.class.update_command
+    # If not allowing virtual packages, do a query to ensure a real package exists
+    unless @resource.allow_virtual?
+      execute([command(:cmd), '-d', '0', '-e', error_level, '-y', install_options, :list, wanted].compact)
+    end
+
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    operation = :install
+
+    case should
+    when :latest
+      current_package = self.query
+      if current_package && !current_package[:ensure].to_s.empty?
+        operation = update_command
+        self.debug "Ensuring latest, so using #{operation}"
+      else
+        self.debug "Ensuring latest, but package is absent, so using #{:install}"
+        operation = :install
+      end
+      should = nil
+    when true, :present, :installed
+      # if we have been given a source and we were not asked for a specific
+      # version feed it to yum directly
+      if @resource[:source]
+        wanted = @resource[:source]
+        self.debug "Installing directly from #{wanted}"
+      end
+      should = nil
+    when false,:absent
+      # pass
+      should = nil
+    else
+      if @resource[:source]
+        # An explicit source was supplied, which means we're ensuring a specific
+        # version, and also supplying the path to a package that supplies that
+        # version.
+        wanted = @resource[:source]
+        self.debug "Installing directly from #{wanted}"
+      else
+        # No explicit source was specified, so add the package version
+        wanted += "-#{should}"
+        if wanted.scan(ARCH_REGEX)
+          self.debug "Detected Arch argument in package! - Moving arch to end of version string"
+          wanted.gsub!(/(.+)(#{ARCH_REGEX})(.+)/,'\1\3\2')
+        end
+      end
+      current_package = self.query
+      if current_package
+        if rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(current_package[:ensure])) < 0
+          self.debug "Downgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
+          operation = :downgrade
+        elsif rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(current_package[:ensure])) > 0
+          self.debug "Upgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
+          operation = update_command
+        end
+      end
+    end
+
+    # Yum on el-4 and el-5 returns exit status 0 when trying to install a package it doesn't recognize;
+    # ensure we capture output to check for errors.
+    no_debug = if Facter.value(:operatingsystemmajrelease).to_i > 5 then ["-d", "0"] else [] end
+    command = [command(:cmd)] + no_debug + ["-e", error_level, "-y", install_options, operation, wanted].compact
+    output = execute(command)
+
+    if output =~ /^No package #{wanted} available\.$/
+      raise Puppet::Error, _("Could not find package %{wanted}") % { wanted: wanted }
+    end
+
+    # If a version was specified, query again to see if it is a matching version
+    if should
+      is = self.query
+      raise Puppet::Error, _("Could not find package %{name}") % { name: self.name } unless is
+
+      # FIXME: Should we raise an exception even if should == :latest
+      # and yum updated us to a version other than @param_hash[:ensure] ?
+      vercmp_result = rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(is[:ensure]))
+      raise Puppet::Error, _("Failed to update to version %{should}, got version %{version} instead") % { should: should, version: is[:ensure] } if vercmp_result != 0
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    upd = self.class.latest_package_version(@resource[:name], disablerepo, enablerepo, disableexcludes)
+    unless upd.nil?
+      # FIXME: there could be more than one update for a package
+      # because of multiarch
+      return "#{upd[:epoch]}:#{upd[:version]}-#{upd[:release]}"
+    else
+      # Yum didn't find updates, pretend the current version is the latest
+      version = properties[:ensure]
+      raise Puppet::DevError, _("Tried to get latest on a missing package") if version == :absent || version == :purged
+      return version
+    end
+  end
+
+  def update
+    # Install in yum can be used for update, too
+    self.install
+  end
+
+  def purge
+    execute([command(:cmd), "-y", :erase, @resource[:name]])
+  end
+
+  private
+
+  def enablerepo
+    scan_options(resource[:install_options], '--enablerepo')
+  end
+
+  def disablerepo
+    scan_options(resource[:install_options], '--disablerepo')
+  end
+
+  def disableexcludes
+    scan_options(resource[:install_options], '--disableexcludes')
+  end
+
+  # Scan a structure that looks like the package type 'install_options'
+  # structure for all hashes that have a specific key.
+  #
+  # @api private
+  # @param options [Array<String | Hash>, nil] The options structure. If the
+  #   options are nil an empty array will be returned.
+  # @param key [String] The key to look for in all contained hashes
+  # @return [Array<String>] All hash values with the given key.
+  def scan_options(options, key)
+    return [] if options.nil?
+    options.inject([]) do |repos, opt|
+      if opt.is_a? Hash and opt[key]
+        repos << opt[key]
+      end
+      repos
+    end
+  end
+end