openvox 8.19.0

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

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/package/version/range'
+require_relative '../../../puppet/util/package/version/rpm'
+require_relative '../../../puppet/util/rpm_compare'
+
+Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
+  # provides Rpm parsing and comparison
+  include Puppet::Util::RpmCompare
+
+  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 an array where each element is either a string or a hash."
+
+  has_feature :install_options, :versionable, :virtual_packages, :install_only, :version_ranges
+
+  RPM_VERSION       = Puppet::Util::Package::Version::Rpm
+  RPM_VERSION_RANGE = Puppet::Util::Package::Version::Range
+
+  commands :cmd => "yum", :rpm => "rpm"
+
+  # Mixing confine statements, control expressions, and exception handling
+  # confuses Rubocop's Layout cops, so we disable them entirely.
+  # rubocop:disable Layout
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+  # rubocop:enable Layout
+
+  defaultfor 'os.name' => :amazon
+  defaultfor 'os.family' => :redhat, 'os.release.major' => (4..7).to_a
+
+  def insync?(is)
+    return false if [:purged, :absent].include?(is)
+    return false if is.include?(self.class::MULTIVERSION_SEPARATOR) && !@resource[:install_only]
+
+    should = @resource[:ensure]
+    if should.is_a?(String)
+      begin
+        should_version = RPM_VERSION_RANGE.parse(should, RPM_VERSION)
+
+        if should_version.is_a?(RPM_VERSION_RANGE::Eq)
+          return super
+        end
+      rescue RPM_VERSION_RANGE::ValidationFailure, RPM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return super
+      end
+
+      is.split(self.class::MULTIVERSION_SEPARATOR).any? do |version|
+        is_version = RPM_VERSION.parse(version)
+        should_version.include?(is_version)
+      rescue RPM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{is} as a RPM version")
+      end
+    end
+  end
+
+  VERSION_REGEX = /^(?:(\d+):)?(\S+)-(\S+)$/
+
+  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 = {}
+    case output.exitstatus
+    when 100
+      updates = parse_updates(output)
+    when 0
+      debug "#{command(:cmd)} check-update exited with 0; no package updates available."
+    else
+      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 that contains Obsoleting, Security: or Update
+    body = str.partition(/^(Obsoleting|Security:|Update)/).first
+
+    updates = Hash.new { |h, k| h[k] = [] }
+
+    body.split(/^\s*\n/).each do |line|
+      line.split.each_slice(3) do |tuple|
+        next unless tuple[0].include?('.') && tuple[1] =~ VERSION_REGEX
+
+        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
+    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(VERSION_REGEX)
+    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 best_version(should)
+    if should.is_a?(String)
+      begin
+        should_range = RPM_VERSION_RANGE.parse(should, RPM_VERSION)
+        if should_range.is_a?(RPM_VERSION_RANGE::Eq)
+          return should
+        end
+      rescue RPM_VERSION_RANGE::ValidationFailure, RPM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return should
+      end
+      versions = []
+      available_versions(@resource[:name], disablerepo, enablerepo, disableexcludes).each do |version|
+        rpm_version = RPM_VERSION.parse(version)
+        versions << rpm_version if should_range.include?(rpm_version)
+      rescue RPM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{version} as a RPM version")
+      end
+
+      version = versions.max if versions.any?
+
+      if version
+        version = version.to_s.sub(/^\d+:/, '')
+        return version
+      end
+
+      Puppet.debug("No available version for package #{@resource[:name]} is included in range #{should_range}")
+      should
+    end
+  end
+
+  def available_versions(package_name, disablerepo, enablerepo, disableexcludes)
+    args = [command(:cmd), 'list', package_name, '--showduplicates']
+    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 = execute("#{args.compact.join(' ')} | sed -e '1,/Available Packages/ d' | awk '{print $2}'")
+    output.split("\n")
+  end
+
+  def install
+    wanted = @resource[:name]
+    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), '-y', install_options, :list, wanted].compact)
+    end
+
+    should = @resource.should(:ensure)
+    debug "Ensuring => #{should}"
+    operation = :install
+
+    case should
+    when :latest
+      current_package = query
+      if current_package && !current_package[:ensure].to_s.empty?
+        operation = update_command
+        debug "Ensuring latest, so using #{operation}"
+      else
+        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]
+        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]
+        debug "Installing directly from #{wanted}"
+      else
+        # No explicit source was specified, so add the package version
+        should = best_version(should)
+        wanted += "-#{should}"
+        if wanted.scan(self.class::ARCH_REGEX)
+          debug "Detected Arch argument in package! - Moving arch to end of version string"
+          wanted.gsub!(/(.+)(#{self.class::ARCH_REGEX})(.+)/, '\1\3\2')
+        end
+      end
+      current_package = query
+      if current_package
+        if @resource[:install_only]
+          debug "Updating package #{@resource[:name]} from version #{current_package[:ensure]} to #{should} as install_only packages are never downgraded"
+          operation = update_command
+        elsif rpm_compare_evr(should, current_package[:ensure]) < 0
+          debug "Downgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
+          operation = :downgrade
+        elsif rpm_compare_evr(should, current_package[:ensure]) > 0
+          debug "Upgrading package #{@resource[:name]} from version #{current_package[:ensure]} to #{should}"
+          operation = update_command
+        end
+      end
+    end
+
+    command = [command(:cmd)] + ["-y", install_options, operation, wanted].compact
+    output = execute(command)
+
+    if output.to_s =~ /^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 = query
+      raise Puppet::Error, _("Could not find package %{name}") % { name: name } unless is
+
+      version = is[:ensure]
+      # 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 %{version} instead") % { should: should, version: version } unless
+        insync?(version)
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    upd = self.class.latest_package_version(@resource[:name], disablerepo, enablerepo, disableexcludes)
+    if upd.nil?
+      # Yum didn't find updates, pretend the current version is the latest
+      debug "Yum didn't find updates, current version (#{properties[:ensure]}) is the latest"
+      version = properties[:ensure]
+      raise Puppet::DevError, _("Tried to get latest on a missing package") if version == :absent || version == :purged
+
+      version
+    else
+      # FIXME: there could be more than one update for a package
+      # because of multiarch
+      "#{upd[:epoch]}:#{upd[:version]}-#{upd[:release]}"
+    end
+  end
+
+  def update
+    # Install in yum can be used for update, too
+    install
+  end
+
+  def purge
+    execute([command(:cmd), "-y", :remove, @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 [] unless options.is_a?(Enumerable)
+
+    values =
+      options.map do |repo|
+        value =
+          if repo.is_a?(String)
+            next unless repo.include?('=')
+
+            Hash[*repo.strip.split('=')] # make it a hash
+          else
+            repo
+          end
+        value[key]
+      end
+    values.compact.uniq
+  end
+end

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+Puppet::Type.type(:package).provide :zypper, :parent => :rpm, :source => :rpm do
+  desc "Support for SuSE `zypper` package manager. Found in SLES10sp2+ and SLES11.
+
+    This provider supports the `install_options` attribute, which allows command-line flags to be passed to zypper.
+    These options should be specified as an array where each element is either a
+    string or a hash."
+
+  has_feature :versionable, :install_options, :virtual_packages
+
+  commands :zypper => "/usr/bin/zypper"
+
+  defaultfor 'os.name' => [:suse, :sles, :sled, :opensuse]
+  confine    'os.name' => [:suse, :sles, :sled, :opensuse]
+
+  # @api private
+  # Reset the latest version hash to nil
+  # needed for spec tests to clear cached value
+  def self.reset!
+    @latest_versions = nil
+  end
+
+  def self.latest_package_version(package)
+    if @latest_versions.nil?
+      @latest_versions = list_updates
+    end
+
+    @latest_versions[package]
+  end
+
+  def self.list_updates
+    output = zypper 'list-updates'
+
+    avail_updates = {}
+
+    # split up columns
+    output.lines.each do |line|
+      pkg_ver = line.split(/\s*\|\s*/)
+      # ignore zypper headers
+      next unless pkg_ver[0] == 'v'
+
+      avail_updates[pkg_ver[2]] = pkg_ver[4]
+    end
+
+    avail_updates
+  end
+
+  # on zypper versions <1.0, the version option returns 1
+  # some versions of zypper output on stderr
+  def zypper_version
+    cmd = [self.class.command(:zypper), "--version"]
+    execute(cmd, { :failonfail => false, :combine => true })
+  end
+
+  def best_version(should)
+    if should.is_a?(String)
+      begin
+        should_range = Puppet::Util::Package::Version::Range.parse(should, Puppet::Util::Package::Version::Rpm)
+      rescue Puppet::Util::Package::Version::Range::ValidationFailure, Puppet::Util::Package::Version::Rpm::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return should
+      end
+
+      if should_range.is_a?(Puppet::Util::Package::Version::Range::Eq)
+        return should
+      end
+
+      versions = []
+
+      output = zypper('search', '--match-exact', '--type', 'package', '--uninstalled-only', '-s', @resource[:name])
+      output.lines.each do |line|
+        pkg_ver = line.split(/\s*\|\s*/)
+        next unless pkg_ver[1] == @resource[:name]
+
+        begin
+          rpm_version = Puppet::Util::Package::Version::Rpm.parse(pkg_ver[3])
+
+          versions << rpm_version if should_range.include?(rpm_version)
+        rescue Puppet::Util::Package::Version::Rpm::ValidationFailure
+          Puppet.debug("Cannot parse #{pkg_ver[3]} as a RPM version")
+        end
+      end
+
+      return versions.max if versions.any?
+
+      Puppet.debug("No available version for package #{@resource[:name]} is included in range #{should_range}")
+      should
+    end
+  end
+
+  # Install a package using 'zypper'.
+  def install
+    should = @resource.should(:ensure)
+    debug "Ensuring => #{should}"
+    wanted = @resource[:name]
+
+    # XXX: We don't actually deal with epochs here.
+    case should
+    when true, false, Symbol
+      should = nil
+    else
+      # Add the package version
+      should = best_version(should)
+      wanted = "#{wanted}-#{should}"
+    end
+
+    # This has been tested with following zypper versions
+    # SLE 10.4: 0.6.201
+    # SLE 11.3: 1.6.307
+    # SLE 12.0: 1.11.14
+    # Assume that this will work on newer zypper versions
+
+    # extract version numbers and convert to integers
+    major, minor, patch = zypper_version.scan(/\d+/).map(&:to_i)
+    debug "Detected zypper version #{major}.#{minor}.#{patch}"
+
+    # zypper version < 1.0 does not support --quiet flag
+    if major < 1
+      quiet = '--terse'
+    else
+      quiet = '--quiet'
+    end
+
+    inst_opts = []
+    inst_opts = install_options if resource[:install_options]
+
+    options = []
+    options << quiet
+    options << '--no-gpg-check' unless inst_opts.delete('--no-gpg-check').nil?
+    options << '--no-gpg-checks' unless inst_opts.delete('--no-gpg-checks').nil?
+    options << :install
+
+    # zypper 0.6.13 (OpenSuSE 10.2) does not support auto agree with licenses
+    options << '--auto-agree-with-licenses' unless major < 1 and minor <= 6 and patch <= 13
+    options << '--no-confirm'
+    options += inst_opts unless inst_opts.empty?
+
+    # Zypper 0.6.201 doesn't recognize '--name'
+    # It is unclear where this functionality was introduced, but it
+    # is present as early as 1.0.13
+    options << '--name' unless major < 1 || @resource.allow_virtual? || should
+    options << wanted
+
+    zypper(*options)
+
+    unless query
+      raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: name }
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    self.class.latest_package_version(@resource[:name]) ||
+      # zypper didn't find updates, pretend the current
+      # version is the latest
+      @property_hash[:ensure]
+  end
+
+  def update
+    # zypper install can be used for update, too
+    install
+  end
+
+  def uninstall
+    # extract version numbers and convert to integers
+    major, minor, _ = zypper_version.scan(/\d+/).map(&:to_i)
+
+    if major < 1
+      super
+    else
+      options = [:remove, '--no-confirm']
+      if major == 1 && minor < 6
+        options << '--force-resolution'
+      end
+
+      options << @resource[:name]
+
+      zypper(*options)
+    end
+  end
+
+  def insync?(is)
+    return false if [:purged, :absent].include?(is)
+
+    should = @resource[:ensure]
+    if should.is_a?(String)
+      begin
+        should_version = Puppet::Util::Package::Version::Range.parse(should, Puppet::Util::Package::Version::Rpm)
+        if should_version.is_a?(RPM_VERSION_RANGE::Eq)
+          return super
+        end
+      rescue Puppet::Util::Package::Version::Range::ValidationFailure, Puppet::Util::Package::Version::Rpm::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a RPM version range")
+        return super
+      end
+
+      begin
+        is_version = Puppet::Util::Package::Version::Rpm.parse(is)
+        should_version.include?(is_version)
+      rescue Puppet::Util::Package::Version::Rpm::ValidationFailure
+        Puppet.debug("Cannot parse #{is} as a RPM version")
+      end
+    end
+  end
+end

data/lib/puppet/provider/package.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/provider'
+
+class Puppet::Provider::Package < Puppet::Provider
+  # Prefetch our package list, yo.
+  def self.prefetch(packages)
+    instances.each do |prov|
+      pkg = packages[prov.name]
+      if pkg
+        pkg.provider = prov
+      end
+    end
+  end
+
+  # Clear out the cached values.
+  def flush
+    @property_hash.clear
+  end
+
+  # Look up the current status.
+  def properties
+    if @property_hash.empty?
+      # For providers that support purging, default to purged; otherwise default to absent
+      # Purged is the "most uninstalled" a package can be, so a purged package will be in-sync with
+      # either `ensure => absent` or `ensure => purged`; an absent package will be out of sync with `ensure => purged`.
+      default_status = self.class.feature?(:purgeable) ? :purged : :absent
+      @property_hash = query || { :ensure => default_status }
+      @property_hash[:ensure] = default_status if @property_hash.empty?
+    end
+    @property_hash.dup
+  end
+
+  def validate_source(value)
+    true
+  end
+
+  # Turns a array of options into flags to be passed to a command.
+  # The options can be passed as a string or hash. Note that passing a hash
+  # should only be used in case --foo=bar must be passed,
+  # which can be accomplished with:
+  #     install_options => [ { '--foo' => 'bar' } ]
+  # Regular flags like '--foo' must be passed as a string.
+  # @param options [Array]
+  # @return Concatenated list of options
+  # @api private
+  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
+      else
+        val
+      end
+    end.flatten
+  end
+end