puppet-retrospec 0.12.2 → 1.0.0

data/vendor/gems/puppet-4.5.2/lib/puppet/provider/package/rug.rb

@@ -0,0 +1,51 @@
+Puppet::Type.type(:package).provide :rug, :parent => :rpm do
+  desc "Support for suse `rug` package manager."
+
+  has_feature :versionable
+
+  commands :rug => "/usr/bin/rug"
+  commands :rpm => "rpm"
+  confine    :operatingsystem => [:suse, :sles]
+
+  # Install a package using 'rug'.
+  def install
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    wanted = @resource[:name]
+
+    # XXX: We don't actually deal with epochs here.
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      wanted += "-#{should}"
+    end
+    rug "--quiet", :install, "-y", wanted
+
+    unless self.query
+      raise Puppet::ExecutionFailure.new(
+        "Could not find package #{self.name}"
+      )
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    #rug can only get a list of *all* available packages?
+    output = rug "list-updates"
+
+    if output =~ /#{Regexp.escape @resource[:name]}\s*\|\s*([^\s\|]+)/
+      return $1
+    else
+      # rug didn't find updates, pretend the current
+      # version is the latest
+      return @property_hash[:ensure]
+    end
+  end
+
+  def update
+    # rug install can be used for update, too
+    self.install
+  end
+end

data/vendor/gems/puppet-4.5.2/lib/puppet/provider/package/windows.rb

@@ -0,0 +1,113 @@
+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 to local files, mapped drives, or UNC paths.
+
+    This provider supports the `install_options` and `uninstall_options`
+    attributes, which allow command-line flags to be passed to the installer.
+    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 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
+  has_feature :versionable
+
+  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,
+      :ensure   => pkg.version || :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(' ')
+    output = execute(command, :failonfail => false, :combine => true)
+
+    check_result(output.exitstatus)
+  end
+
+  def uninstall
+    command = [package.uninstall_command, uninstall_options].flatten.compact.join(' ')
+    output = execute(command, :failonfail => false, :combine => true)
+
+    check_result(output.exitstatus)
+  end
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
+  self::ERROR_SUCCESS                  = 0
+  self::ERROR_SUCCESS_REBOOT_INITIATED = 1641
+  self::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 self.class::ERROR_SUCCESS
+      # yeah
+    when self.class::ERROR_SUCCESS_REBOOT_INITIATED
+      warning("The package #{operation}ed successfully and the system is rebooting now.")
+    when self.class::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 gets 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
+end

data/vendor/gems/puppet-4.5.2/lib/puppet/provider/package/windows/exe_package.rb

@@ -0,0 +1,71 @@
+require 'puppet/provider/package/windows/package'
+
+class Puppet::Provider::Package::Windows
+  class ExePackage < Puppet::Provider::Package::Windows::Package
+    attr_reader :uninstall_string
+
+    # Return an instance of the package from the registry, or nil
+    def self.from_registry(name, values)
+      if valid?(name, values)
+        ExePackage.new(
+          get_display_name(values),
+          values['DisplayVersion'],
+          values['UninstallString']
+        )
+      end
+    end
+
+    # Is this a valid executable 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['UninstallString'] &&
+         values['UninstallString'].length > 0 &&
+         values['WindowsInstaller'] != 1 && # DWORD
+         name !~ /^KB[0-9]{6}/ &&
+         values['ParentKeyName'] == nil &&
+         values['Security Update'] == nil &&
+         values['Update Rollup'] == nil &&
+         values['Hotfix'] == nil)
+    end
+
+    def initialize(name, version, uninstall_string)
+      super(name, version)
+
+      @uninstall_string = uninstall_string
+    end
+
+    # Does this package match the resource?
+    def match?(resource)
+      resource[:name] == name
+    end
+
+    def self.install_command(resource)
+      ['cmd.exe', '/c', 'start', '"puppet-install"', '/w', munge(resource[:source])]
+    end
+
+    def uninstall_command
+      # 1. Launch using cmd /c start because if the executable is a console
+      #    application Windows will automatically display its console window
+      # 2. Specify a quoted title, otherwise if uninstall_string is quoted,
+      #    start will interpret that to be the title, and get confused
+      # 3. Specify /w (wait) to wait for uninstall to finish
+      command = ['cmd.exe', '/c', 'start', '"puppet-uninstall"', '/w']
+
+      # Only quote bare uninstall strings, e.g.
+      #   C:\Program Files (x86)\Notepad++\uninstall.exe
+      # Don't quote uninstall strings that are already quoted, e.g.
+      #   "c:\ruby187\unins000.exe"
+      # Don't quote uninstall strings that contain arguments:
+      #   "C:\Program Files (x86)\Git\unins000.exe" /SILENT
+      if uninstall_string =~ /\A[^"]*.exe\Z/i
+        command << "\"#{uninstall_string}\""
+      else
+        command << uninstall_string
+      end
+
+      command
+    end
+  end
+end

data/vendor/gems/puppet-4.5.2/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/vendor/gems/puppet-4.5.2/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: '#{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 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/vendor/gems/puppet-4.5.2/lib/puppet/provider/package/yum.rb

@@ -0,0 +1,241 @@
+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 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
+  # @param disableexcludes [Array<String>] A list of repository excludes to disable for this query
+  # @return [Hash<Symbol, String>]
+  def self.latest_package_version(package, enablerepo, disablerepo, disableexcludes)
+
+    key = [enablerepo, disablerepo, disableexcludes]
+
+    @latest_versions ||= {}
+    if @latest_versions[key].nil?
+      @latest_versions[key] = check_updates(enablerepo, disablerepo, 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 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
+  # @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(enablerepo, disablerepo, disableexcludes)
+    args = [command(:cmd), 'check-update']
+    args.concat(enablerepo.map { |repo| ["--enablerepo=#{repo}"] }.flatten)
+    args.concat(disablerepo.map { |repo| ["--disablerepo=#{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, '#{command(:cmd)} check-update' exited with #{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)/
+      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)
+    name, arch = pkgname.split('.')
+
+    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 install
+    wanted = @resource[:name]
+    error_level = self.class.error_level
+    # 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 true, false, Symbol
+      # pass
+      should = nil
+    else
+      # 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
+
+      is = self.query
+      if is && rpm_compareEVR(rpm_parse_evr(should), rpm_parse_evr(is[:ensure])) < 0
+        self.debug "Downgrading package #{@resource[:name]} from version #{is[:ensure]} to #{should}"
+        operation = :downgrade
+      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}"
+    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 #{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 #{is[:ensure]} instead" if vercmp_result != 0
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    upd = self.class.latest_package_version(@resource[:name], enablerepo, disablerepo, 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