openvox 7.37.1

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

@@ -0,0 +1,262 @@
+require_relative '../../../puppet/util/package/version/range'
+require_relative '../../../puppet/util/package/version/debian'
+
+Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
+  # Provide sorting functionality
+  include Puppet::Util::Package
+  DebianVersion = Puppet::Util::Package::Version::Debian
+  VersionRange  = Puppet::Util::Package::Version::Range
+  desc "Package management via `apt-get`.
+
+    This provider supports the `install_options` attribute, which allows command-line flags to be passed to apt-get.
+    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, :version_ranges
+
+  commands :aptget => "/usr/bin/apt-get"
+  commands :aptcache => "/usr/bin/apt-cache"
+  commands :aptmark => "/usr/bin/apt-mark"
+  commands :preseed => "/usr/bin/debconf-set-selections"
+
+  defaultfor :osfamily => :debian
+
+  ENV['DEBIAN_FRONTEND'] = "noninteractive"
+
+  # disable common apt helpers to allow non-interactive package installs
+  ENV['APT_LISTBUGS_FRONTEND'] = "none"
+  ENV['APT_LISTCHANGES_FRONTEND'] = "none"
+
+  def self.defaultto_allow_virtual
+    false
+  end
+
+  def self.instances
+    packages = super
+    manual_marks = aptmark('showmanual').split("\n")
+    packages.each do |package|
+      package.mark = :manual if manual_marks.include?(package.name)
+    end
+    packages
+  end
+
+  def query
+    hash = super
+
+    if !%i(absent purged).include?(hash[:ensure]) && aptmark('showmanual', @resource[:name]).strip == @resource[:name]
+      hash[:mark] = :manual
+    end
+
+    hash
+  end
+
+  def initialize(value={})
+    super(value)
+    @property_flush = {}
+  end
+
+  def mark
+    @property_flush[:mark]
+  end
+
+  def mark=(value)
+    @property_flush[:mark] = value
+  end
+
+  def flush
+    # unless we are removing the package mark it if it hasn't already been marked
+    if @property_flush
+      unless @property_flush[:mark] || [:purge, :absent].include?(resource[:ensure])
+        aptmark('manual', resource[:name])
+      end
+    end
+  end
+
+  # A derivative of DPKG; this is how most people actually manage
+  # Debian boxes, and the only thing that differs is that it can
+  # install packages from remote sites.
+
+  def checkforcdrom
+    have_cdrom = begin
+                   !!(File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/)
+                 rescue
+                   # This is basically pathological...
+                   false
+                 end
+
+    if have_cdrom and @resource[:allowcdrom] != :true
+      raise Puppet::Error,
+        _("/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure.")
+    end
+  end
+
+  def best_version(should_range)
+    versions = []
+
+    output = aptcache :madison, @resource[:name]
+    output.each_line do |line|
+      is = line.split('|')[1].strip
+      begin
+        is_version = DebianVersion.parse(is)
+        versions << is_version if should_range.include?(is_version)
+      rescue DebianVersion::ValidationFailure
+        Puppet.debug("Cannot parse #{is} as a debian version")
+      end
+    end
+
+    return versions.sort.last if versions.any?
+
+    Puppet.debug("No available version for package #{@resource[:name]} is included in range #{should_range}")
+    should_range
+  end
+
+  # Install a package using 'apt-get'.  This function needs to support
+  # installing a specific version.
+  def install
+    self.run_preseed if @resource[:responsefile]
+    should = @resource[:ensure]
+
+    if should.is_a?(String)
+      begin
+        should_range = VersionRange.parse(should, DebianVersion)
+
+        unless should_range.is_a?(VersionRange::Eq)
+          should = best_version(should_range)
+        end
+      rescue VersionRange::ValidationFailure, DebianVersion::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a debian version range, falling through")
+      end
+    end
+
+    checkforcdrom
+    cmd = %w{-q -y}
+
+    config = @resource[:configfiles]
+    if config
+      if config == :keep
+        cmd << "-o" << 'DPkg::Options::=--force-confold'
+      else
+        cmd << "-o" << 'DPkg::Options::=--force-confnew'
+      end
+    end
+
+    str = @resource[:name]
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version and --force-yes option
+      str += "=#{should}"
+      cmd << "--force-yes"
+    end
+
+    cmd += install_options if @resource[:install_options]
+    cmd << :install
+
+    if source
+      cmd << source
+    else
+      cmd << str
+    end
+
+    self.unhold if self.properties[:mark] == :hold
+    begin
+      aptget(*cmd)
+    ensure
+      self.hold if @resource[:mark] == :hold
+    end
+
+    # If a source file was specified, we must make sure the expected version was installed from specified file
+    if source && !%i(present installed).include?(should)
+      is = self.query
+      raise Puppet::Error, _("Could not find package %{name}") % { name: self.name } unless is
+
+      version = is[: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
+    output = aptcache :policy,  @resource[:name]
+
+    if output =~ /Candidate:\s+(\S+)\s/
+      return $1
+    else
+      self.err _("Could not find latest version")
+      return nil
+    end
+  end
+
+  #
+  # preseeds answers to dpkg-set-selection from the "responsefile"
+  #
+  def run_preseed
+    response = @resource[:responsefile]
+    if response && Puppet::FileSystem.exist?(response)
+      self.info(_("Preseeding %{response} to debconf-set-selections") % { response: response })
+
+      preseed response
+    else
+      self.info _("No responsefile specified or non existent, not preseeding anything")
+    end
+  end
+
+  def uninstall
+    self.run_preseed if @resource[:responsefile]
+    args = ['-y', '-q']
+    args << '--allow-change-held-packages' if self.properties[:mark] == :hold
+    args << :remove << @resource[:name]
+    aptget(*args)
+  end
+
+  def purge
+    self.run_preseed if @resource[:responsefile]
+    args = ['-y', '-q']
+    args << '--allow-change-held-packages' if self.properties[:mark] == :hold
+    args << :remove << '--purge' << @resource[:name]
+    aptget(*args)
+    # workaround a "bug" in apt, that already removed packages are not purged
+    super
+  end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def insync?(is)
+    # this is called after the generic version matching logic (insync? for the
+    # type), so we only get here if should != is
+
+    return false unless is && is != :absent
+
+    #if 'should' is a range and 'is' a debian version we should check if 'should' includes 'is'
+    should = @resource[:ensure]
+
+    return false unless is.is_a?(String) && should.is_a?(String)
+
+    begin
+      should_range = VersionRange.parse(should, DebianVersion)
+    rescue VersionRange::ValidationFailure, DebianVersion::ValidationFailure
+      Puppet.debug("Cannot parse #{should} as a debian version range")
+      return false
+    end
+
+    begin
+      is_version = DebianVersion.parse(is)
+    rescue DebianVersion::ValidationFailure
+      Puppet.debug("Cannot parse #{is} as a debian version")
+      return false
+    end
+    should_range.include?(is_version)
+  end
+
+  private
+
+  def source
+    @source ||= @resource[:source]
+  end
+end

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

@@ -0,0 +1,35 @@
+Puppet::Type.type(:package).provide :aptitude, :parent => :apt, :source => :dpkg do
+  desc "Package management via `aptitude`."
+
+  has_feature :versionable
+
+  commands :aptitude => "/usr/bin/aptitude"
+  commands :aptcache => "/usr/bin/apt-cache"
+
+  ENV['DEBIAN_FRONTEND'] = "noninteractive"
+
+  def aptget(*args)
+    args.flatten!
+    # Apparently aptitude hasn't always supported a -q flag.
+    args.delete("-q") if args.include?("-q")
+    args.delete("--force-yes") if args.include?("--force-yes")
+    output = aptitude(*args)
+
+    # Yay, stupid aptitude doesn't throw an error when the package is missing.
+    if args.include?(:install) and output.to_s =~ /Couldn't find any package/
+      raise Puppet::Error.new(
+        _("Could not find package %{name}") % { name: self.name }
+      )
+    end
+  end
+
+  def purge
+    aptitude '-y', 'purge', @resource[:name]
+  end
+
+  private
+
+  def source
+    nil
+  end
+end

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

@@ -0,0 +1,83 @@
+Puppet::Type.type(:package).provide :aptrpm, :parent => :rpm, :source => :rpm do
+  # Provide sorting functionality
+  include Puppet::Util::Package
+
+  desc "Package management via `apt-get` ported to `rpm`."
+
+  has_feature :versionable
+
+  commands :aptget => "apt-get"
+  commands :aptcache => "apt-cache"
+  commands :rpm => "rpm"
+
+  if command('rpm')
+    confine :true => begin
+      rpm('-ql', 'rpm')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  # Install a package using 'apt-get'.  This function needs to support
+  # installing a specific version.
+  def install
+    should = @resource.should(:ensure)
+
+    str = @resource[:name]
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      str += "=#{should}"
+    end
+    cmd = %w{-q -y}
+
+    cmd << 'install' << str
+
+    aptget(*cmd)
+  end
+
+  # What's the latest package version available?
+  def latest
+    output = aptcache :showpkg,  @resource[:name]
+
+    if output =~ /Versions:\s*\n((\n|.)+)^$/
+      versions = $1
+      available_versions = versions.split(/\n/).collect { |version|
+        if version =~ /^([^\(]+)\(/
+          $1
+        else
+          self.warning _("Could not match version '%{version}'") % { version: version }
+          nil
+        end
+      }.reject { |vers| vers.nil? }.sort { |a,b|
+        versioncmp(a,b)
+      }
+
+      if available_versions.length == 0
+        self.debug "No latest version"
+        print output if Puppet[:debug]
+      end
+
+      # Get the latest and greatest version number
+      return available_versions.pop
+    else
+      self.err _("Could not match string")
+    end
+  end
+
+  def update
+    self.install
+  end
+
+  def uninstall
+    aptget "-y", "-q", 'remove', @resource[:name]
+  end
+
+  def purge
+    aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+  end
+end

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

@@ -0,0 +1,112 @@
+# Packaging using Blastwave's pkg-get program.
+Puppet::Type.type(:package).provide :blastwave, :parent => :sun, :source => :sun do
+  desc "Package management using Blastwave.org's `pkg-get` command on Solaris."
+  pkgget = "pkg-get"
+  pkgget = "/opt/csw/bin/pkg-get" if FileTest.executable?("/opt/csw/bin/pkg-get")
+
+  confine :osfamily => :solaris
+
+  commands :pkgget => pkgget
+
+  def pkgget_with_cat(*args)
+    Puppet::Util.withenv(:PAGER => "/usr/bin/cat") { pkgget(*args) }
+  end
+
+  def self.extended(mod)
+    unless command(:pkgget) != "pkg-get"
+      raise Puppet::Error,
+        _("The pkg-get command is missing; blastwave packaging unavailable")
+    end
+
+    unless Puppet::FileSystem.exist?("/var/pkg-get/admin")
+      Puppet.notice _("It is highly recommended you create '/var/pkg-get/admin'.")
+      Puppet.notice _("See /var/pkg-get/admin-fullauto")
+    end
+  end
+
+  def self.instances(hash = {})
+    blastlist(hash).collect do |bhash|
+      bhash.delete(:avail)
+      new(bhash)
+    end
+  end
+
+  # Turn our blastwave listing into a bunch of hashes.
+  def self.blastlist(hash)
+    command = ["-c"]
+
+    command << hash[:justme] if hash[:justme]
+
+    output = Puppet::Util.withenv(:PAGER => "/usr/bin/cat") { pkgget command }
+
+    list = output.split("\n").collect do |line|
+      next if line =~ /^#/
+      next if line =~ /^WARNING/
+      next if line =~ /localrev\s+remoterev/
+
+      blastsplit(line)
+    end.reject { |h| h.nil? }
+
+    if hash[:justme]
+      return list[0]
+    else
+      list.reject! { |h|
+        h[:ensure] == :absent
+      }
+      return list
+    end
+
+  end
+
+  # Split the different lines into hashes.
+  def self.blastsplit(line)
+    if line =~ /\s*(\S+)\s+((\[Not installed\])|(\S+))\s+(\S+)/
+      hash = {}
+      hash[:name] = $1
+      hash[:ensure] = if $2 == "[Not installed]"
+        :absent
+      else
+        $2
+      end
+      hash[:avail] = $5
+
+      hash[:avail] = hash[:ensure] if hash[:avail] == "SAME"
+
+      # Use the name method, so it works with subclasses.
+      hash[:provider] = self.name
+
+      return hash
+    else
+      Puppet.warning _("Cannot match %{line}") % { line: line }
+      return nil
+    end
+  end
+
+  def install
+    pkgget_with_cat "-f", :install, @resource[:name]
+  end
+
+  # Retrieve the version from the current package file.
+  def latest
+    hash = self.class.blastlist(:justme => @resource[:name])
+    hash[:avail]
+  end
+
+  def query
+    hash = self.class.blastlist(:justme => @resource[:name])
+    if hash
+      hash
+    else
+      {:ensure => :absent}
+    end
+  end
+
+  # Remove the old package, and install the new one
+  def update
+    pkgget_with_cat "-f", :upgrade, @resource[:name]
+  end
+
+  def uninstall
+    pkgget_with_cat "-f", :remove, @resource[:name]
+  end
+end

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

@@ -0,0 +1,50 @@
+Puppet::Type.type(:package).provide :dnf, :parent => :yum do
+  desc "Support via `dnf`.
+
+  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 dnf.
+  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
+
+  commands :cmd => "dnf", :rpm => "rpm"
+
+  # Note: this confine was borrowed from the Yum provider. The
+  # original purpose (from way back in 2007) was to make sure we
+  # never try to use RPM on a machine without it. We think this
+  # has probably become obsolete with the way `commands` work, so
+  # we should investigate removing it at some point.
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  defaultfor :operatingsystem => :fedora
+  notdefaultfor :operatingsystem => :fedora, :operatingsystemmajrelease => (19..21).to_a
+  defaultfor :osfamily => :redhat
+  notdefaultfor :osfamily => :redhat, :operatingsystemmajrelease => (4..7).to_a
+  defaultfor :operatingsystem => :amazon, :operatingsystemmajrelease => ["2023"]
+
+  def self.update_command
+    # In DNF, update is deprecated for upgrade
+    'upgrade'
+  end
+
+  # The value to pass to DNF as its error output level.
+  # DNF differs from Yum slightly with regards to error outputting.
+  #
+  # @param None
+  # @return [String]
+  def self.error_level
+    '1'
+  end
+end

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

@@ -0,0 +1,141 @@
+# dnfmodule - A puppet package provider for DNF modules
+#
+# Installing a module:
+#  package { 'postgresql':
+#   provider => 'dnfmodule',
+#   ensure   => '9.6',  # install a specific stream
+#   flavor   => 'client',  # install a specific profile
+# }
+
+
+require_relative '../../../puppet/provider/package'
+
+Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
+
+  has_feature :installable, :uninstallable, :versionable, :supports_flavors, :disableable
+  #has_feature :upgradeable
+  # it's not (yet) feasible to make this upgradeable since module streams don't
+  # always have matching version types (i.e. idm has streams DL1 and client,
+  # other modules have semver streams, others have string streams... we cannot
+  # programatically determine a latest version for ensure => 'latest'
+
+  commands :dnf => '/usr/bin/dnf'
+
+  def self.current_version
+    @current_version ||= dnf('--version').split.first
+  end
+
+  def self.prefetch(packages)
+    if Puppet::Util::Package.versioncmp(current_version, '3.0.1') < 0
+      raise Puppet::Error, _("Modules are not supported on DNF versions lower than 3.0.1")
+    end
+    super
+  end
+
+  def self.instances
+    packages = []
+    cmd = "#{command(:dnf)} module list -y -d 0 -e #{error_level}"
+    execute(cmd).each_line do |line|
+      # select only lines with actual packages since DNF clutters the output
+      next unless line =~ /\[[eix]\][, ]/
+      line.gsub!(/\[d\]/, '')  # we don't care about the default flag
+
+      flavor = if line.include?('[i]')
+                 line.split('[i]').first.split.last
+               else
+                 :absent
+               end
+
+      packages << new(
+        name: line.split[0],
+        ensure: if line.include?('[x]')
+                  :disabled
+                else
+                  line.split[1]
+                end,
+        flavor: flavor,
+        provider: name
+      )
+    end
+    packages
+  end
+
+  def query
+    pkg = self.class.instances.find do |package|
+            @resource[:name] == package.name
+          end
+    pkg ? pkg.properties : nil
+  end
+
+  # to install specific streams and profiles:
+  # $ dnf module install module-name:stream/profile
+  # $ dnf module install perl:5.24/minimal
+  # if unspecified, they will be defaulted (see [d] param in dnf module list output)
+  def install
+    # ensure we start fresh (remove existing stream)
+    uninstall unless [:absent, :purged].include?(@property_hash[:ensure])
+
+    args = @resource[:name].dup
+    case @resource[:ensure]
+    when true, false, Symbol
+      # pass
+    else
+      args << ":#{@resource[:ensure]}"
+    end
+    args << "/#{@resource[:flavor]}" if @resource[:flavor]
+
+    if @resource[:enable_only] == true
+      enable(args)
+    else
+      begin
+        execute([command(:dnf), 'module', 'install', '-d', '0', '-e', self.class.error_level, '-y', args])
+      rescue Puppet::ExecutionFailure => e
+        # module has no default profile and no profile was requested, so just enable the stream
+        # DNF versions prior to 4.2.8 do not need this workaround
+        # see https://bugzilla.redhat.com/show_bug.cgi?id=1669527
+        if @resource[:flavor] == nil && e.message =~ /^(?:missing|broken) groups or modules: #{Regexp.quote(args)}$/
+          enable(args)
+        else
+          raise
+        end
+      end
+    end
+  end
+
+  # should only get here when @resource[ensure] is :disabled
+  def insync?(is)
+    if resource[:ensure] == :disabled
+      # in sync only if package is already disabled
+      pkg = self.class.instances.find do |package|
+        @resource[:name] == package.name && package.properties[:ensure] == :disabled
+      end
+      return true if pkg
+    end
+    return false
+  end
+
+  def enable(args = @resource[:name])
+    execute([command(:dnf), 'module', 'enable', '-d', '0', '-e', self.class.error_level, '-y', args])
+  end
+
+  def uninstall
+    execute([command(:dnf), 'module', 'remove', '-d', '0', '-e', self.class.error_level, '-y', @resource[:name]])
+    reset  # reset module to the default stream
+  end
+
+  def disable(args = @resource[:name])
+    execute([command(:dnf), 'module', 'disable', '-d', '0', '-e', self.class.error_level, '-y', args])
+  end
+
+  def reset
+    execute([command(:dnf), 'module', 'reset', '-d', '0', '-e', self.class.error_level, '-y', @resource[:name]])
+  end
+
+  def flavor
+    @property_hash[:flavor]
+  end
+
+  def flavor=(value)
+    install if flavor != @resource.should(:flavor)
+  end
+end