puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/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(values['DisplayName'],
+                         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
+      !!(values['DisplayName'] and values['DisplayName'].length > 0 and
+         values['SystemComponent'] != 1 and # DWORD
+         values['WindowsInstaller'] == 1 and # 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/vendor/gems/puppet-3.7.3/lib/puppet/provider/package/windows/package.rb

@@ -0,0 +1,92 @@
+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|
+              uninstall.each_key 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: '#{resource[:source]}'") unless Puppet::FileSystem.exist?(resource[:source])
+        ExePackage
+      else
+        fail("Don't know how to install '#{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 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/vendor/gems/puppet-3.7.3/lib/puppet/provider/package/yum.rb

@@ -0,0 +1,199 @@
+require 'puppet/util/package'
+
+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 :yum => "yum", :rpm => "rpm", :python => "python"
+
+  self::YUMHELPER = File::join(File::dirname(__FILE__), "yumhelper.py")
+
+  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 enablerepo [Array<String>] A list of repositories to enable for this query
+  # @param disablerepo [Array<String>] A list of repositories to disable for this query
+  # @return [Hash<Symbol, String>]
+  def self.latest_package_version(package, enablerepo, disablerepo)
+
+    key = [enablerepo, disablerepo]
+
+    @latest_versions ||= {}
+    if @latest_versions[key].nil?
+      @latest_versions[key] = fetch_latest_versions(enablerepo, disablerepo)
+    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 enablerepo [Array<String>] A list of repositories to enable for this query
+  # @param disablerepo [Array<String>] A list of repositories 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.fetch_latest_versions(enablerepo, disablerepo)
+    latest_versions = Hash.new {|h, k| h[k] = []}
+
+    args = [self::YUMHELPER]
+    args.concat(enablerepo.map { |repo| ['-e', repo] }.flatten)
+    args.concat(disablerepo.map { |repo| ['-d', repo] }.flatten)
+
+    python(args).scan(/^_pkg (.*)$/) do |match|
+      hash = nevra_to_hash(match[0])
+
+      # 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]}"
+
+      latest_versions[short_name] << hash
+      latest_versions[long_name]  << hash
+    end
+    latest_versions
+  end
+
+  def self.clear
+    @latest_versions = nil
+  end
+
+  def install
+    wanted = @resource[:name]
+    # If not allowing virtual packages, do a query to ensure a real package exists
+    unless @resource.allow_virtual?
+      yum *['-d', '0', '-e', '0', '-y', install_options, :list, wanted].compact
+    end
+
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    operation = :install
+
+    case should
+    when true, false, Symbol
+      # pass
+      should = nil
+    else
+      # Add the package version
+      wanted += "-#{should}"
+      is = self.query
+      if is && Puppet::Util::Package.versioncmp(should, is[:ensure]) < 0
+        self.debug "Downgrading package #{@resource[:name]} from version #{is[:ensure]} to #{should}"
+        operation = :downgrade
+      end
+    end
+
+    args = ["-d", "0", "-e", "0", "-y", install_options, operation, wanted].compact
+    yum *args
+
+
+    # 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 #{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] ?
+      raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if should != is[:ensure]
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    upd = self.class.latest_package_version(@resource[:name], enablerepo, disablerepo)
+    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
+      raise Puppet::DevError, "Tried to get latest on a missing package" if properties[:ensure] == :absent
+      return properties[:ensure]
+    end
+  end
+
+  def update
+    # Install in yum can be used for update, too
+    self.install
+  end
+
+  def purge
+    yum "-y", :erase, @resource[:name]
+  end
+
+  # @deprecated
+  def latest_info
+    Puppet.deprecation_warning("#{self.class}##{__method__} is deprecated and is no longer used.")
+    @latest_info
+  end
+
+  # @deprecated
+  def latest_info=(latest)
+    Puppet.deprecation_warning("#{self.class}##{__method__} is deprecated and is no longer used.")
+    @latest_info = latest
+  end
+
+  private
+
+  def enablerepo
+    scan_options(resource[:install_options], '--enablerepo')
+  end
+
+  def disablerepo
+    scan_options(resource[:install_options], '--disablerepo')
+  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

data/vendor/gems/puppet-3.7.3/lib/puppet/provider/package/yumhelper.py

@@ -0,0 +1,159 @@
+# Python helper script to query for the packages that have
+# pending updates. Called by the yum package provider
+#
+# (C) 2007 Red Hat Inc.
+# David Lutterkort <dlutter @redhat.com>
+
+import sys
+import string
+import re
+
+# this maintains compatibility with really old platforms with python 1.x
+from os import popen, WEXITSTATUS
+
+# Try to use the yum libraries by default, but shell out to the yum executable
+# if they are not present (i.e. yum <= 2.0). This is only required for RHEL3
+# and earlier that do not support later versions of Yum. Once RHEL3 is EOL,
+# shell_out() and related code can be removed.
+try:
+    import yum
+except ImportError:
+    useyumlib = 0
+else:
+    useyumlib = 1
+
+OVERRIDE_OPTS = {
+    'debuglevel': 0,
+    'errorlevel': 0,
+    'logfile': '/dev/null'
+}
+
+enable = []
+disable = []
+args = list(sys.argv)
+
+while len(args) > 0:
+    a = args.pop(0)
+
+    if a == "-d":
+        if len(args) < 1:
+            raise ValueError, a
+        next = args.pop(0)
+        disable.extend( next.split(",") )
+    if a == "-e":
+        if len(args) < 1:
+            raise ValueError, a
+        next = args.pop(0)
+        enable.extend( next.split(",") )
+
+def pkg_lists(my):
+    my.doConfigSetup()
+
+    for k in OVERRIDE_OPTS.keys():
+        if hasattr(my.conf, k):
+            setattr(my.conf, k, OVERRIDE_OPTS[k])
+        else:
+            my.conf.setConfigOption(k, OVERRIDE_OPTS[k])
+
+    my.doTsSetup()
+    my.doRpmDBSetup()
+
+    # Yum 2.2/2.3 python libraries require a couple of extra function calls to setup package sacks.
+    # They also don't have a __version__ attribute
+    try:
+        yumver = yum.__version__
+    except AttributeError:
+        my.doRepoSetup()
+        my.doSackSetup()
+
+    return my.doPackageLists('updates')
+
+def shell_out():
+    try:
+        repostring = ""
+        if disable:
+            repostring += " '--disablerepo=%s'" % ",".join(disable)
+        if enable:
+            repostring += " '--disablerepo=%s'" % ",".join(enable)
+        p = popen("/usr/bin/env yum%s check-update 2>&1" % repostring)
+        output = p.readlines()
+        rc = p.close()
+
+        if rc is not None:
+            # None represents exit code of 0, otherwise the exit code is in the
+            # format returned by wait(). Exit code of 100 from yum represents
+            # updates available.
+            if WEXITSTATUS(rc) != 100:
+                return WEXITSTATUS(rc)
+        else:
+            # Exit code is None (0), no updates waiting so don't both parsing output
+            return 0
+
+        # Yum prints a line of hyphens (old versions) or a blank line between
+        # headers and package data, so skip everything before them
+        skipheaders = 0
+        for line in output:
+            if not skipheaders:
+                if re.compile("^((-){80}|)$").search(line):
+                    skipheaders = 1
+                continue
+
+            # Skip any blank lines
+            if re.compile("^[ \t]*$").search(line):
+                continue
+
+            # Format is:
+            # Yum 1.x: name arch (epoch:)?version
+            # Yum 2.0: name arch (epoch:)?version repo
+            # epoch is optional if 0
+
+            p = string.split(line)
+            pname = p[0]
+            parch = p[1]
+            pevr = p[2]
+
+            # Separate out epoch:version-release
+            evr_re = re.compile("^(\d:)?(\S+)-(\S+)$")
+            evr = evr_re.match(pevr)
+
+            pepoch = ""
+            if evr.group(1) is None:
+                pepoch = "0"
+            else:
+                pepoch = evr.group(1).replace(":", "")
+            pversion = evr.group(2)
+            prelease = evr.group(3)
+
+            print "_pkg", pname, pepoch, pversion, prelease, parch
+
+        return 0
+    except:
+        print sys.exc_info()[0]
+        return 1
+
+if useyumlib:
+    try:
+        try:
+            my = yum.YumBase()
+
+            for repo in disable:
+                my.repos.disableRepo(repo)
+
+            for repo in enable:
+                my.repos.enableRepo(repo)
+
+            ypl = pkg_lists(my)
+            for pkg in ypl.updates:
+                print "_pkg %s %s %s %s %s" % (pkg.name, pkg.epoch, pkg.version, pkg.release, pkg.arch)
+        finally:
+            my.closeRpmDB()
+    except IOError, e:
+        print "_err IOError %d %s" % (e.errno, e)
+        sys.exit(1)
+    except AttributeError, e:
+        # catch yumlib errors in buggy 2.x versions of yum
+        print "_err AttributeError %s" % e
+        sys.exit(1)
+else:
+    rc = shell_out()
+    sys.exit(rc)