openvox 8.19.0

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/provider/package'
+
+Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package do
+  desc "Package management via `dpkg`.  Because this only uses `dpkg`
+    and not `apt`, you must specify the source of any packages you want
+    to manage."
+
+  has_feature :holdable, :virtual_packages
+  commands :dpkg => "/usr/bin/dpkg"
+  commands :dpkg_deb => "/usr/bin/dpkg-deb"
+  commands :dpkgquery => "/usr/bin/dpkg-query"
+
+  # Performs a dpkgquery call with a pipe so that output can be processed
+  # inline in a passed block.
+  # @param args [Array<String>] any command line arguments to be appended to the command
+  # @param block expected to be passed on to execpipe
+  # @return whatever the block returns
+  # @see Puppet::Util::Execution.execpipe
+  # @api private
+  def self.dpkgquery_piped(*args, &block)
+    cmd = args.unshift(command(:dpkgquery))
+    Puppet::Util::Execution.execpipe(cmd, &block)
+  end
+
+  def self.instances
+    packages = []
+
+    # list out all of the packages
+    dpkgquery_piped('-W', '--showformat', self::DPKG_QUERY_FORMAT_STRING) do |pipe|
+      # now turn each returned line into a package object
+      pipe.each_line do |line|
+        hash = parse_line(line)
+        if hash
+          packages << new(hash)
+        end
+      end
+    end
+
+    packages
+  end
+
+  private
+
+  # Note: self:: is required here to keep these constants in the context of what will
+  # eventually become this Puppet::Type::Package::ProviderDpkg class.
+  self::DPKG_QUERY_FORMAT_STRING = "'${Status} ${Package} ${Version}\\n'"
+  self::DPKG_QUERY_PROVIDES_FORMAT_STRING = "'${Status} ${Package} ${Version} [${Provides}]\\n'"
+  self::FIELDS_REGEX = /^'?(\S+) +(\S+) +(\S+) (\S+) (\S*)$/
+  self::FIELDS_REGEX_WITH_PROVIDES = /^'?(\S+) +(\S+) +(\S+) (\S+) (\S*) \[.*\]$/
+  self::FIELDS = [:desired, :error, :status, :name, :ensure]
+
+  def self.defaultto_allow_virtual
+    false
+  end
+
+  # @param line [String] one line of dpkg-query output
+  # @return [Hash,nil] a hash of FIELDS or nil if we failed to match
+  # @api private
+  def self.parse_line(line, regex = self::FIELDS_REGEX)
+    hash = nil
+
+    match = regex.match(line)
+    if match
+      hash = {}
+
+      self::FIELDS.zip(match.captures) do |field, value|
+        hash[field] = value
+      end
+
+      hash[:provider] = name
+
+      if hash[:status] == 'not-installed'
+        hash[:ensure] = :purged
+      elsif %w[config-files half-installed unpacked half-configured].include?(hash[:status])
+        hash[:ensure] = :absent
+      end
+      hash[:mark] = hash[:desired] == 'hold' ? :hold : :none
+    else
+      Puppet.debug("Failed to match dpkg-query line #{line.inspect}")
+    end
+
+    hash
+  end
+
+  public
+
+  def install
+    file = @resource[:source]
+    unless file
+      raise ArgumentError, _("You cannot install dpkg packages without a source")
+    end
+
+    args = []
+
+    if @resource[:configfiles] == :keep
+      args << '--force-confold'
+    else
+      args << '--force-confnew'
+    end
+    args << '-i' << file
+
+    unhold if properties[:mark] == :hold
+    begin
+      dpkg(*args)
+    ensure
+      hold if @resource[:mark] == :hold
+    end
+  end
+
+  def update
+    install
+  end
+
+  # Return the version from the package.
+  def latest
+    source = @resource[:source]
+    unless source
+      @resource.fail _("Could not update: You cannot install dpkg packages without a source")
+    end
+    output = dpkg_deb "--show", source
+    matches = /^(\S+)\t(\S+)$/.match(output).captures
+    warning _("source doesn't contain named package, but %{name}") % { name: matches[0] } unless matches[0].match(Regexp.escape(@resource[:name]))
+    matches[1]
+  end
+
+  def query
+    hash = nil
+
+    # list out our specific package
+    begin
+      if @resource.allow_virtual?
+        output = dpkgquery(
+          "-W",
+          "--showformat",
+          self.class::DPKG_QUERY_PROVIDES_FORMAT_STRING
+          # the regex searches for the resource[:name] in the dpkquery result in which the Provides field is also available
+          # it will search for the packages only in the brackets ex: [rubygems]
+        ).lines.find { |package| package.match(/[\[ ](#{Regexp.escape(@resource[:name])})[\],]/) }
+        if output
+          hash = self.class.parse_line(output, self.class::FIELDS_REGEX_WITH_PROVIDES)
+          Puppet.info("Package #{@resource[:name]} is virtual, defaulting to #{hash[:name]}")
+          @resource[:name] = hash[:name]
+        end
+      end
+      output = dpkgquery(
+        "-W",
+        "--showformat",
+        self.class::DPKG_QUERY_FORMAT_STRING,
+        @resource[:name]
+      )
+      hash = self.class.parse_line(output)
+    rescue Puppet::ExecutionFailure
+      # dpkg-query exits 1 if the package is not found.
+      return { :ensure => :purged, :status => 'missing', :name => @resource[:name], :error => 'ok' }
+    end
+
+    hash ||= { :ensure => :absent, :status => 'missing', :name => @resource[:name], :error => 'ok' }
+
+    if hash[:error] != "ok"
+      raise Puppet::Error, "Package #{hash[:name]}, version #{hash[:ensure]} is in error state: #{hash[:error]}"
+    end
+
+    hash
+  end
+
+  def uninstall
+    dpkg "-r", @resource[:name]
+  end
+
+  def purge
+    dpkg "--purge", @resource[:name]
+  end
+
+  def hold
+    Tempfile.open('puppet_dpkg_set_selection') do |tmpfile|
+      tmpfile.write("#{@resource[:name]} hold\n")
+      tmpfile.flush
+      execute([:dpkg, "--set-selections"], :failonfail => false, :combine => false, :stdinfile => tmpfile.path.to_s)
+    end
+  end
+
+  def unhold
+    Tempfile.open('puppet_dpkg_set_selection') do |tmpfile|
+      tmpfile.write("#{@resource[:name]} install\n")
+      tmpfile.flush
+      execute([:dpkg, "--set-selections"], :failonfail => false, :combine => false, :stdinfile => tmpfile.path.to_s)
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+Puppet::Type.type(:package).provide :fink, :parent => :dpkg, :source => :dpkg do
+  # Provide sorting functionality
+  include Puppet::Util::Package
+
+  desc "Package management via `fink`."
+
+  commands :fink => "/sw/bin/fink"
+  commands :aptget => "/sw/bin/apt-get"
+  commands :aptcache => "/sw/bin/apt-cache"
+  commands :dpkgquery => "/sw/bin/dpkg-query"
+
+  has_feature :versionable
+
+  # 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 finkcmd(*args)
+    fink(*args)
+  end
+
+  # Install a package using 'apt-get'.  This function needs to support
+  # installing a specific version.
+  def install
+    run_preseed if @resource[:responsefile]
+    should = @resource.should(:ensure)
+
+    str = @resource[:name]
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      str += "=#{should}"
+    end
+    cmd = %w[-b -q -y]
+
+    cmd << :install << str
+
+    unhold if properties[:mark] == :hold
+    begin
+      finkcmd(cmd)
+    ensure
+      hold if @resource[:mark] == :hold
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    output = aptcache :policy, @resource[:name]
+
+    if output =~ /Candidate:\s+(\S+)\s/
+      Regexp.last_match(1)
+    else
+      err _("Could not find latest version")
+      nil
+    end
+  end
+
+  #
+  # preseeds answers to dpkg-set-selection from the "responsefile"
+  #
+  def run_preseed
+    response = @resource[:responsefile]
+    if response && Puppet::FileSystem.exist?(response)
+      info(_("Preseeding %{response} to debconf-set-selections") % { response: response })
+
+      preseed response
+    else
+      info _("No responsefile specified or non existent, not preseeding anything")
+    end
+  end
+
+  def update
+    install
+  end
+
+  def uninstall
+    unhold if properties[:mark] == :hold
+    begin
+      finkcmd "-y", "-q", :remove, @model[:name]
+    rescue StandardError, LoadError => e
+      hold if properties[:mark] == :hold
+      raise e
+    end
+  end
+
+  def purge
+    unhold if properties[:mark] == :hold
+    begin
+      aptget '-y', '-q', 'remove', '--purge', @resource[:name]
+    rescue StandardError, LoadError => e
+      hold if properties[:mark] == :hold
+      raise e
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
+  desc "The specific form of package management on FreeBSD.  This is an
+    extremely quirky packaging system, in that it freely mixes between
+    ports and packages.  Apparently all of the tools are written in Ruby,
+    so there are plans to rewrite this support to directly use those
+    libraries."
+
+  commands :pkginfo => "/usr/sbin/pkg_info",
+           :pkgadd => "/usr/sbin/pkg_add",
+           :pkgdelete => "/usr/sbin/pkg_delete"
+
+  confine 'os.name' => :freebsd
+
+  def self.listcmd
+    command(:pkginfo)
+  end
+
+  def install
+    if @resource[:source] =~ %r{/$}
+      if @resource[:source] =~ /^(ftp|https?):/
+        Puppet::Util.withenv :PACKAGESITE => @resource[:source] do
+          pkgadd "-r", @resource[:name]
+        end
+      else
+        Puppet::Util.withenv :PKG_PATH => @resource[:source] do
+          pkgadd @resource[:name]
+        end
+      end
+    else
+      Puppet.warning _("source is defined but does not have trailing slash, ignoring %{source}") % { source: @resource[:source] } if @resource[:source]
+      pkgadd "-r", @resource[:name]
+    end
+  end
+
+  def query
+    self.class.instances.each do |provider|
+      if provider.name == @resource.name
+        return provider.properties
+      end
+    end
+    nil
+  end
+
+  def uninstall
+    pkgdelete "#{@resource[:name]}-#{@resource.should(:ensure)}"
+  end
+end

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

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/package/version/gem'
+require_relative '../../../puppet/util/package/version/range'
+require_relative '../../../puppet/provider/package_targetable'
+require 'uri'
+
+# Ruby gems support.
+Puppet::Type.type(:package).provide :gem, :parent => Puppet::Provider::Package::Targetable do
+  desc "Ruby Gem support. If a URL is passed via `source`, then that URL is
+    appended to the list of remote gem repositories; to ensure that only the
+    specified source is used, also pass `--clear-sources` via `install_options`.
+    If source is present but is not a valid URL, it will be interpreted as the
+    path to a local gem file. If source is not present, the gem will be
+    installed from the default gem repositories. Note that to modify this for Windows, it has to be a valid URL.
+
+    This provider supports the `install_options` and `uninstall_options` attributes,
+    which allow command-line flags to be passed to the gem command.
+    These options should be specified as an array where each element is either a
+    string or a hash."
+
+  has_feature :versionable, :install_options, :uninstall_options, :targetable, :version_ranges
+
+  GEM_VERSION =       Puppet::Util::Package::Version::Gem
+  GEM_VERSION_RANGE = Puppet::Util::Package::Version::Range
+
+  # Override the specificity method to return 1 if gem is not set as default provider
+  def self.specificity
+    match = default_match
+    length = match ? match.length : 0
+
+    return 1 if length == 0
+
+    super
+  end
+
+  # Define the default provider package command name when the provider is targetable.
+  # Required by Puppet::Provider::Package::Targetable::resource_or_provider_command
+
+  def self.provider_command
+    if Puppet::Util::Platform.windows?
+      Puppet::Util.withenv(PATH: windows_path_without_puppet_bin) { command(:gemcmd) }
+    else
+      command(:gemcmd)
+    end
+  end
+
+  # Define the default provider package command as optional when the provider is targetable.
+  # Doing do defers the evaluation of provider suitability until all commands are evaluated.
+
+  has_command(:gemcmd, 'gem') do
+    is_optional
+  end
+
+  # Having puppet/bin in PATH makes gem provider to use puppet/bin/gem
+  # This is an utility methods that reads the PATH and returns a string
+  # that contains the content of PATH but without puppet/bin dir.
+  # This is used to pass a custom PATH and execute commands in a controlled environment
+  def self.windows_path_without_puppet_bin
+    # rubocop:disable Naming/MemoizedInstanceVariableName
+    @path ||= ENV['PATH'].split(File::PATH_SEPARATOR)
+                         .reject { |dir| dir =~ /puppet\\bin$/ }
+                         .join(File::PATH_SEPARATOR)
+    # rubocop:enable Naming/MemoizedInstanceVariableName
+  end
+
+  private_class_method :windows_path_without_puppet_bin
+
+  # CommandDefiner in provider.rb creates convenience execution methods that set failonfail, combine, and optionally, environment.
+  # And when a child provider defines its own command via commands() or has_command(), the provider-specific path is always returned by command().
+  # But when the convenience execution method is invoked, the last convenience method to be defined is executed.
+  # This makes invoking those convenience execution methods unsuitable for inherited providers.
+  #
+  # In this case, causing the puppet_gem provider to inherit the parent gem provider's convenience gemcmd() methods, with the wrong path.
+
+  def self.execute_gem_command(command, command_options, custom_environment = {})
+    validate_command(command)
+    cmd = [command] << command_options
+
+    custom_environment = { 'HOME' => ENV.fetch('HOME', nil) }.merge(custom_environment)
+
+    if Puppet::Util::Platform.windows?
+      custom_environment[:PATH] = windows_path_without_puppet_bin
+    end
+
+    # This uses an unusual form of passing the command and args as [<cmd>, [<arg1>, <arg2>, ...]]
+    execute(cmd, { :failonfail => true, :combine => true, :custom_environment => custom_environment })
+  end
+
+  def self.instances(target_command = nil)
+    if target_command
+      command = target_command
+    else
+      command = provider_command
+      # The default provider package command is optional.
+      return [] unless command
+    end
+
+    gemlist(:command => command, :local => true).collect do |pkg|
+      # Track the command when the provider is targetable.
+      pkg[:command] = command
+      new(pkg)
+    end
+  end
+
+  def self.gemlist(options)
+    command_options = ["list"]
+
+    if options[:local]
+      command_options << "--local"
+    else
+      command_options << "--remote"
+    end
+    if options[:source]
+      command_options << "--source" << options[:source]
+    end
+    name = options[:justme]
+    if name
+      command_options << '\A' + name + '\z'
+    end
+
+    begin
+      list = execute_gem_command(options[:command], command_options).lines
+                                                                    .filter_map { |set| gemsplit(set) }
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, _("Could not list gems: %{detail}") % { detail: detail }, detail.backtrace
+    end
+
+    if options[:justme]
+      list.shift
+    else
+      list
+    end
+  end
+
+  def self.gemsplit(desc)
+    # `gem list` when output console has a line like:
+    # *** LOCAL GEMS ***
+    # but when it's not to the console that line
+    # and all blank lines are stripped
+    # so we don't need to check for them
+
+    if desc =~ /^(\S+)\s+\((.+)\)/
+      gem_name = Regexp.last_match(1)
+      versions = Regexp.last_match(2).sub('default: ', '').split(/,\s*/)
+      {
+        :name => gem_name,
+        :ensure => versions.map { |v| v.split[0] },
+        :provider => name
+      }
+    else
+      Puppet.warning _("Could not match %{desc}") % { desc: desc } unless desc.chomp.empty?
+      nil
+    end
+  end
+
+  def insync?(is)
+    return false unless is && is != :absent
+
+    is = [is] unless is.is_a? Array
+    should = @resource[:ensure]
+
+    unless should =~ Regexp.union(/,/, Gem::Requirement::PATTERN)
+      begin
+        should_range = GEM_VERSION_RANGE.parse(should, GEM_VERSION)
+      rescue GEM_VERSION_RANGE::ValidationFailure, GEM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a ruby gem version range")
+        return false
+      end
+
+      return is.any? do |version|
+        should_range.include?(GEM_VERSION.parse(version))
+      rescue GEM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{version} as a ruby gem version")
+        false
+      end
+    end
+
+    begin
+      # Range intersections are not supported by Gem::Requirement, so just split by comma.
+      dependency = Gem::Dependency.new('', should.split(','))
+    rescue ArgumentError
+      # Bad requirements will cause an error during gem command invocation, so just return not in sync
+      return false
+    end
+
+    # Check if any version matches the dependency
+    is.any? { |version| dependency.match?('', version) }
+  end
+
+  def rubygem_version(command)
+    command_options = ["--version"]
+    self.class.execute_gem_command(command, command_options)
+  end
+
+  def install(useversion = true)
+    command = resource_or_provider_command
+    command_options = ["install"]
+    command_options += install_options if resource[:install_options]
+    should = resource[:ensure]
+
+    unless should =~ Regexp.union(/,/, Gem::Requirement::PATTERN)
+      begin
+        should_range = GEM_VERSION_RANGE.parse(should, GEM_VERSION)
+        should = should_range.to_gem_version
+        useversion = true
+      rescue GEM_VERSION_RANGE::ValidationFailure, GEM_VERSION::ValidationFailure
+        Puppet.debug("Cannot parse #{should} as a ruby gem version range. Falling through.")
+      end
+    end
+
+    if Puppet::Util::Platform.windows?
+      command_options << "-v" << %Q("#{should}") if useversion && !should.is_a?(Symbol)
+    elsif useversion && !should.is_a?(Symbol)
+      command_options << "-v" << should
+    end
+
+    if Puppet::Util::Package.versioncmp(rubygem_version(command), '2.0.0') == -1
+      command_options << "--no-rdoc" << "--no-ri"
+    else
+      command_options << "--no-document"
+    end
+
+    source = resource[:source]
+    if source
+      begin
+        uri = URI.parse(source)
+      rescue => detail
+        self.fail Puppet::Error, _("Invalid source '%{uri}': %{detail}") % { uri: uri, detail: detail }, detail
+      end
+
+      case uri.scheme
+      when nil
+        # no URI scheme => interpret the source as a local file
+        command_options << source
+      when /file/i
+        command_options << uri.path
+      when 'puppet'
+        # we don't support puppet:// URLs (yet)
+        raise Puppet::Error, _("puppet:// URLs are not supported as gem sources")
+      else
+        # check whether it's an absolute file path to help Windows out
+        if Puppet::Util.absolute_path?(source)
+          command_options << source
+        else
+          # interpret it as a gem repository
+          command_options << "--source" << source.to_s << resource[:name]
+        end
+      end
+    else
+      command_options << resource[:name]
+    end
+
+    output = self.class.execute_gem_command(command, command_options)
+    # Apparently some gem versions don't exit non-0 on failure.
+    self.fail _("Could not install: %{output}") % { output: output.chomp } if output.include?("ERROR")
+  end
+
+  def latest
+    command = resource_or_provider_command
+    options = { :command => command, :justme => resource[:name] }
+    options[:source] = resource[:source] unless resource[:source].nil?
+    pkg = self.class.gemlist(options)
+    pkg[:ensure][0]
+  end
+
+  def query
+    command = resource_or_provider_command
+    options = { :command => command, :justme => resource[:name], :local => true }
+    pkg = self.class.gemlist(options)
+    pkg[:command] = command unless pkg.nil?
+    pkg
+  end
+
+  def uninstall
+    command = resource_or_provider_command
+    command_options = ["uninstall"]
+    command_options << "--executables" << "--all" << resource[:name]
+    command_options += uninstall_options if resource[:uninstall_options]
+    output = self.class.execute_gem_command(command, command_options)
+    # Apparently some gem versions don't exit non-0 on failure.
+    self.fail _("Could not uninstall: %{output}") % { output: output.chomp } if output.include?("ERROR")
+  end
+
+  def update
+    install(false)
+  end
+
+  def install_options
+    join_options(resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(resource[:uninstall_options])
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# HP-UX packaging.
+
+require_relative '../../../puppet/provider/package'
+
+Puppet::Type.type(:package).provide :hpux, :parent => Puppet::Provider::Package do
+  desc "HP-UX's packaging system."
+
+  commands :swinstall => "/usr/sbin/swinstall",
+           :swlist => "/usr/sbin/swlist",
+           :swremove => "/usr/sbin/swremove"
+
+  confine 'os.name' => "hp-ux"
+
+  defaultfor 'os.name' => "hp-ux"
+
+  def self.instances
+    # TODO:  This is very hard on HP-UX!
+    []
+  end
+
+  # source and name are required
+  def install
+    raise ArgumentError, _("source must be provided to install HP-UX packages") unless resource[:source]
+
+    args = standard_args + ["-s", resource[:source], resource[:name]]
+    swinstall(*args)
+  end
+
+  def query
+    swlist resource[:name]
+    { :ensure => :present }
+  rescue
+    { :ensure => :absent }
+  end
+
+  def uninstall
+    args = standard_args + [resource[:name]]
+    swremove(*args)
+  end
+
+  def standard_args
+    ["-x", "mount_all_filesystems=false"]
+  end
+end