openvox 8.19.0

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/provider/package'
+
+Puppet::Type.type(:package).provide :opkg, :source => :opkg, :parent => Puppet::Provider::Package do
+  desc "Opkg packaging support. Common on OpenWrt and OpenEmbedded platforms"
+
+  commands :opkg => "opkg"
+
+  confine     'os.name' => :openwrt
+  defaultfor  'os.name' => :openwrt
+
+  def self.instances
+    packages = []
+    execpipe("#{command(:opkg)} list-installed") do |process|
+      regex = /^(\S+) - (\S+)/
+      fields = [:name, :ensure]
+      hash = {}
+
+      process.each_line { |line|
+        match = regex.match(line)
+        if match
+          fields.zip(match.captures) { |field, value| hash[field] = value }
+          hash[:provider] = name
+          packages << new(hash)
+          hash = {}
+        else
+          warning(_("Failed to match line %{line}") % { line: line })
+        end
+      }
+    end
+    packages
+  rescue Puppet::ExecutionFailure
+    nil
+  end
+
+  def latest
+    output = opkg("list", @resource[:name])
+    matches = /^(\S+) - (\S+)/.match(output).captures
+    matches[1]
+  end
+
+  def install
+    # OpenWrt package lists are ephemeral, make sure we have at least
+    # some entries in the list directory for opkg to use
+    opkg('update') if package_lists.size <= 2
+
+    if @resource[:source]
+      opkg('--force-overwrite', 'install', @resource[:source])
+    else
+      opkg('--force-overwrite', 'install', @resource[:name])
+    end
+  end
+
+  def uninstall
+    opkg('remove', @resource[:name])
+  end
+
+  def update
+    install
+  end
+
+  def query
+    # list out our specific package
+    output = opkg('list-installed', @resource[:name])
+    if output =~ /^(\S+) - (\S+)/
+      return { :ensure => Regexp.last_match(2) }
+    end
+
+    nil
+  rescue Puppet::ExecutionFailure
+    {
+      :ensure => :purged,
+      :status => 'missing',
+      :name => @resource[:name],
+      :error => 'ok',
+    }
+  end
+
+  private
+
+  def package_lists
+    Dir.entries('/var/opkg-lists/')
+  end
+end

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

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/provider/package'
+require 'set'
+require 'uri'
+
+Puppet::Type.type(:package).provide :pacman, :parent => Puppet::Provider::Package do
+  desc "Support for the Package Manager Utility (pacman) used in Archlinux.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pacman.
+  These options should be specified as an array where each element is either a string or a hash."
+
+  # If yaourt is installed, we can make use of it
+  def self.yaourt?
+    @yaourt ||= Puppet::FileSystem.exist?('/usr/bin/yaourt')
+  end
+
+  commands :pacman => "/usr/bin/pacman"
+  # Yaourt is a common AUR helper which, if installed, we can use to query the AUR
+  commands :yaourt => "/usr/bin/yaourt" if yaourt?
+
+  confine     'os.name' => [:archlinux, :manjarolinux, :artix]
+  defaultfor  'os.name' => [:archlinux, :manjarolinux, :artix]
+  has_feature :install_options
+  has_feature :uninstall_options
+  has_feature :upgradeable
+  has_feature :virtual_packages
+  has_feature :purgeable
+
+  # Checks if a given name is a group
+  def self.group?(name)
+    !pacman('--sync', '--groups', name).empty?
+  rescue Puppet::ExecutionFailure
+    # pacman returns an expected non-zero exit code when the name is not a group
+    false
+  end
+
+  # Install a package using 'pacman', or 'yaourt' if available.
+  # Installs quietly, without confirmation or progress bar, updates package
+  # list from servers defined in pacman.conf.
+  def install
+    if @resource[:source]
+      install_from_file
+    else
+      install_from_repo
+    end
+
+    unless query
+      fail(_("Could not find package '%{name}'") % { name: @resource[:name] })
+    end
+  end
+
+  # Fetch the list of packages and package groups that are currently installed on the system.
+  # Only package groups that are fully installed are included. If a group adds packages over time, it will not
+  # be considered as fully installed any more, and we would install the new packages on the next run.
+  # If a group removes packages over time, nothing will happen. This is intended.
+  def self.instances
+    instances = []
+
+    # Get the installed packages
+    installed_packages = get_installed_packages
+    installed_packages.sort_by { |k, _| k }.each do |package, version|
+      instances << new(to_resource_hash(package, version))
+    end
+
+    # Get the installed groups
+    get_installed_groups(installed_packages).each do |group, version|
+      instances << new(to_resource_hash(group, version))
+    end
+
+    instances
+  end
+
+  # returns a hash package => version of installed packages
+  def self.get_installed_packages
+    packages = {}
+    execpipe([command(:pacman), "--query"]) do |pipe|
+      # pacman -Q output is 'packagename version-rel'
+      regex = /^(\S+)\s(\S+)/
+      pipe.each_line do |line|
+        match = regex.match(line)
+        if match
+          packages[match.captures[0]] = match.captures[1]
+        else
+          warning(_("Failed to match line '%{line}'") % { line: line })
+        end
+      end
+    end
+    packages
+  rescue Puppet::ExecutionFailure
+    fail(_("Error getting installed packages"))
+  end
+
+  # returns a hash of group => version of installed groups
+  def self.get_installed_groups(installed_packages, filter = nil)
+    groups = {}
+    begin
+      # Build a hash of group name => list of packages
+      command = [command(:pacman), '--sync', '-gg']
+      command << filter if filter
+      execpipe(command) do |pipe|
+        pipe.each_line do |line|
+          name, package = line.split
+          packages = (groups[name] ||= [])
+          packages << package
+        end
+      end
+
+      # Remove any group that doesn't have all its packages installed
+      groups.delete_if do |_, packages|
+        !packages.all? { |package| installed_packages[package] }
+      end
+
+      # Replace the list of packages with a version string consisting of packages that make up the group
+      groups.each do |name, packages|
+        groups[name] = packages.sort.map { |package| "#{package} #{installed_packages[package]}" }.join ', '
+      end
+    rescue Puppet::ExecutionFailure
+      # pacman returns an expected non-zero exit code when the filter name is not a group
+      raise unless filter
+    end
+    groups
+  end
+
+  # Because Archlinux is a rolling release based distro, installing a package
+  # should always result in the newest release.
+  def update
+    # Install in pacman can be used for update, too
+    install
+  end
+
+  # We rescue the main check from Pacman with a check on the AUR using yaourt, if installed
+  def latest
+    resource_name = @resource[:name]
+
+    # If target is a group, construct the group version
+    return pacman("--sync", "--print", "--print-format", "%n %v", resource_name).lines.map(&:chomp).sort.join(', ') if self.class.group?(resource_name)
+
+    # Start by querying with pacman first
+    # If that fails, retry using yaourt against the AUR
+    pacman_check = true
+    begin
+      if pacman_check
+        output = pacman "--sync", "--print", "--print-format", "%v", resource_name
+        output.chomp
+      else
+        output = yaourt "-Qma", resource_name
+        output.split("\n").each do |line|
+          return line.split[1].chomp if line =~ /^aur/
+        end
+      end
+    rescue Puppet::ExecutionFailure
+      if pacman_check and self.class.yaourt?
+        pacman_check = false # now try the AUR
+        retry
+      else
+        raise
+      end
+    end
+  end
+
+  # Queries information for a package or package group
+  def query
+    installed_packages = self.class.get_installed_packages
+    resource_name = @resource[:name]
+
+    # Check for the resource being a group
+    version = self.class.get_installed_groups(installed_packages, resource_name)[resource_name]
+
+    if version
+      unless @resource.allow_virtual?
+        warning(_("%{resource_name} is a group, but allow_virtual is false.") % { resource_name: resource_name })
+        return nil
+      end
+    else
+      version = installed_packages[resource_name]
+    end
+
+    # Return nil if no package or group found
+    return nil unless version
+
+    self.class.to_resource_hash(resource_name, version)
+  end
+
+  def self.to_resource_hash(name, version)
+    {
+      :name => name,
+      :ensure => version,
+      :provider => self.name
+    }
+  end
+
+  # Removes a package from the system.
+  def uninstall
+    remove_package(false)
+  end
+
+  def purge
+    remove_package(true)
+  end
+
+  private
+
+  def remove_package(purge_configs = false)
+    resource_name = @resource[:name]
+
+    is_group = self.class.group?(resource_name)
+
+    fail(_("Refusing to uninstall package group %{resource_name}, because allow_virtual is false.") % { resource_name: resource_name }) if is_group && !@resource.allow_virtual?
+
+    cmd = %w[--noconfirm --noprogressbar]
+    cmd += uninstall_options if @resource[:uninstall_options]
+    cmd << "--remove"
+    cmd << '--recursive' if is_group
+    cmd << '--nosave' if purge_configs
+    cmd << resource_name
+
+    if self.class.yaourt?
+      yaourt(*cmd)
+    else
+      pacman(*cmd)
+    end
+  end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(@resource[:uninstall_options])
+  end
+
+  def install_from_file
+    source = @resource[:source]
+    begin
+      source_uri = URI.parse source
+    rescue => detail
+      self.fail Puppet::Error, _("Invalid source '%{source}': %{detail}") % { source: source, detail: detail }, detail
+    end
+
+    source = case source_uri.scheme
+             when nil       then source
+             when /https?/i then source
+             when /ftp/i    then source
+             when /file/i   then source_uri.path
+             when /puppet/i
+               fail _("puppet:// URL is not supported by pacman")
+             else
+               fail _("Source %{source} is not supported by pacman") % { source: source }
+             end
+    pacman "--noconfirm", "--noprogressbar", "--update", source
+  end
+
+  def install_from_repo
+    resource_name = @resource[:name]
+
+    # Refuse to install if not allowing virtual packages and the resource is a group
+    fail(_("Refusing to install package group %{resource_name}, because allow_virtual is false.") % { resource_name: resource_name }) if self.class.group?(resource_name) && !@resource.allow_virtual?
+
+    cmd = %w[--noconfirm --needed --noprogressbar]
+    cmd += install_options if @resource[:install_options]
+    cmd << "--sync" << resource_name
+
+    if self.class.yaourt?
+      yaourt(*cmd)
+    else
+      pacman(*cmd)
+    end
+  end
+end

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

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+# Puppet package provider for Python's `pip` package management frontend.
+# <http://pip.pypa.io/>
+
+require_relative '../../../puppet/util/package/version/pip'
+require_relative '../../../puppet/util/package/version/range'
+require_relative '../../../puppet/provider/package_targetable'
+
+Puppet::Type.type(:package).provide :pip, :parent => ::Puppet::Provider::Package::Targetable do
+  desc "Python packages via `pip`.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip.
+  These options should be specified as an array where each element is either a string or a hash."
+
+  has_feature :installable, :uninstallable, :upgradeable, :versionable, :version_ranges, :install_options, :targetable
+
+  PIP_VERSION       = Puppet::Util::Package::Version::Pip
+  PIP_VERSION_RANGE = Puppet::Util::Package::Version::Range
+
+  # Override the specificity method to return 1 if pip 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
+    # Ensure pip can upgrade pip, which usually puts pip into a new path /usr/local/bin/pip (compared to /usr/bin/pip)
+    cmd.map { |c| which(c) }.find { |c| !c.nil? }
+  end
+
+  def self.cmd
+    if Puppet::Util::Platform.windows?
+      ["pip.exe"]
+    else
+      %w[pip pip-python pip2 pip-2]
+    end
+  end
+
+  def self.pip_version(command)
+    version = nil
+    execpipe [quote(command), '--version'] do |process|
+      process.collect do |line|
+        md = line.strip.match(/^pip (\d+\.\d+\.?\d*).*$/)
+        if md
+          version = md[1]
+          break
+        end
+      end
+    end
+
+    raise Puppet::Error, _("Cannot resolve pip version") unless version
+
+    version
+  end
+
+  # Return an array of structured information about every installed package
+  # that's managed by `pip` or an empty array if `pip` is not available.
+  def self.instances(target_command = nil)
+    if target_command
+      command = target_command
+      validate_command(command)
+    else
+      command = provider_command
+    end
+
+    packages = []
+    return packages unless command
+
+    command_options = ['freeze']
+    command_version = pip_version(command)
+    if compare_pip_versions(command_version, '8.1.0') >= 0
+      command_options << '--all'
+    end
+
+    execpipe [quote(command), command_options] do |process|
+      process.collect do |line|
+        pkg = parse(line)
+        next unless pkg
+
+        pkg[:command] = command
+        packages << new(pkg)
+      end
+    end
+
+    # Pip can also upgrade pip, but it's not listed in freeze so need to special case it
+    # Pip list would also show pip installed version, but "pip list" doesn't exist for older versions of pip (E.G v1.0)
+    # Not needed when "pip freeze --all" is available.
+    if compare_pip_versions(command_version, '8.1.0') == -1
+      packages << new({ :ensure => command_version, :name => File.basename(command), :provider => name, :command => command })
+    end
+
+    packages
+  end
+
+  # Parse lines of output from `pip freeze`, which are structured as:
+  # _package_==_version_ or _package_===_version_
+  # or _package_ @ someURL@_version_
+  def self.parse(line)
+    if line.chomp =~ /^([^=]+)===?([^=]+)$/
+      { :ensure => Regexp.last_match(2), :name => Regexp.last_match(1), :provider => name }
+    elsif line.chomp =~ /^([^@]+) @ [^@]+@(.+)$/
+      { :ensure => Regexp.last_match(2), :name => Regexp.last_match(1), :provider => name }
+    end
+  end
+
+  # Return structured information about a particular package or `nil`
+  # if the package is not installed or `pip` itself is not available.
+  def query
+    command = resource_or_provider_command
+    self.class.validate_command(command)
+
+    self.class.instances(command).each do |pkg|
+      return pkg.properties if @resource[:name].casecmp(pkg.name).zero?
+    end
+    nil
+  end
+
+  # Return latest version available for current package
+  def latest
+    command = resource_or_provider_command
+    self.class.validate_command(command)
+
+    command_version = self.class.pip_version(command)
+    if self.class.compare_pip_versions(command_version, '1.5.4') == -1
+      available_versions_with_old_pip.last
+    else
+      available_versions_with_new_pip(command_version).last
+    end
+  end
+
+  def self.compare_pip_versions(x, y)
+    Puppet::Util::Package::Version::Pip.compare(x, y)
+  rescue PIP_VERSION::ValidationFailure => ex
+    Puppet.debug("Cannot compare #{x} and #{y}. #{ex.message} Falling through default comparison mechanism.")
+    Puppet::Util::Package.versioncmp(x, y)
+  end
+
+  # Use pip CLI to look up versions from PyPI repositories,
+  # honoring local pip config such as custom repositories.
+  def available_versions
+    command = resource_or_provider_command
+    self.class.validate_command(command)
+
+    command_version = self.class.pip_version(command)
+    if self.class.compare_pip_versions(command_version, '1.5.4') == -1
+      available_versions_with_old_pip
+    else
+      available_versions_with_new_pip(command_version)
+    end
+  end
+
+  def available_versions_with_new_pip(command_version)
+    command = resource_or_provider_command
+    self.class.validate_command(command)
+
+    command_and_options = [self.class.quote(command), 'install', "#{@resource[:name]}==9!0dev0+x"]
+    extra_arg = list_extra_flags(command_version)
+    command_and_options << extra_arg if extra_arg
+    command_and_options << install_options if @resource[:install_options]
+    execpipe command_and_options do |process|
+      process.collect do |line|
+        # PIP OUTPUT: Could not find a version that satisfies the requirement example==versionplease (from versions: 1.2.3, 4.5.6)
+        next unless line =~ /from versions: (.+)\)/
+
+        versionList = Regexp.last_match(1).split(', ').sort do |x, y|
+          self.class.compare_pip_versions(x, y)
+        end
+        return versionList
+      end
+    end
+    []
+  end
+
+  def available_versions_with_old_pip
+    command = resource_or_provider_command
+    self.class.validate_command(command)
+
+    Dir.mktmpdir("puppet_pip") do |dir|
+      command_and_options = [self.class.quote(command), 'install', (@resource[:name]).to_s, '-d', dir.to_s, '-v']
+      command_and_options << install_options if @resource[:install_options]
+      execpipe command_and_options do |process|
+        process.collect do |line|
+          # PIP OUTPUT: Using version 0.10.1 (newest of versions: 1.2.3, 4.5.6)
+          next unless line =~ /Using version .+? \(newest of versions: (.+?)\)/
+
+          versionList = Regexp.last_match(1).split(', ').sort do |x, y|
+            self.class.compare_pip_versions(x, y)
+          end
+          return versionList
+        end
+      end
+      return []
+    end
+  end
+
+  # Finds the most suitable version available in a given range
+  def best_version(should_range)
+    included_available_versions = []
+    available_versions.each do |version|
+      version = PIP_VERSION.parse(version)
+      included_available_versions.push(version) if should_range.include?(version)
+    end
+
+    included_available_versions.sort!
+    return included_available_versions.last unless included_available_versions.empty?
+
+    Puppet.debug("No available version for package #{@resource[:name]} is included in range #{should_range}")
+    should_range
+  end
+
+  def get_install_command_options
+    should = @resource[:ensure]
+    command_options = %w[install -q]
+    command_options += install_options if @resource[:install_options]
+
+    if @resource[:source]
+      if should.is_a?(String)
+        command_options << "#{@resource[:source]}@#{should}#egg=#{@resource[:name]}"
+      else
+        command_options << "#{@resource[:source]}#egg=#{@resource[:name]}"
+      end
+
+      return command_options
+    end
+
+    if should == :latest
+      command_options << "--upgrade" << @resource[:name]
+
+      return command_options
+    end
+
+    unless should.is_a?(String)
+      command_options << @resource[:name]
+
+      return command_options
+    end
+
+    begin
+      should_range = PIP_VERSION_RANGE.parse(should, PIP_VERSION)
+    rescue PIP_VERSION_RANGE::ValidationFailure, PIP_VERSION::ValidationFailure
+      Puppet.debug("Cannot parse #{should} as a pip version range, falling through.")
+      command_options << "#{@resource[:name]}==#{should}"
+
+      return command_options
+    end
+
+    if should_range.is_a?(PIP_VERSION_RANGE::Eq)
+      command_options << "#{@resource[:name]}==#{should}"
+
+      return command_options
+    end
+
+    should = best_version(should_range)
+
+    if should == should_range
+      # when no suitable version for the given range was found, let pip handle
+      if should.is_a?(PIP_VERSION_RANGE::MinMax)
+        command_options << "#{@resource[:name]} #{should.split.join(',')}"
+      else
+        command_options << "#{@resource[:name]} #{should}"
+      end
+    else
+      command_options << "#{@resource[:name]}==#{should}"
+    end
+
+    command_options
+  end
+
+  # Install a package.  The ensure parameter may specify installed,
+  # latest, a version number, or, in conjunction with the source
+  # parameter, an SCM revision.  In that case, the source parameter
+  # gives the fully-qualified URL to the repository.
+  def install
+    command = resource_or_provider_command
+    self.class.validate_command(command)
+
+    command_options = get_install_command_options
+    execute([command, command_options])
+  end
+
+  # Uninstall a package. Uninstall won't work reliably on Debian/Ubuntu unless this issue gets fixed.
+  # http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=562544
+  def uninstall
+    command = resource_or_provider_command
+    self.class.validate_command(command)
+
+    command_options = ["uninstall", "-y", "-q", @resource[:name]]
+
+    execute([command, command_options])
+  end
+
+  def update
+    install
+  end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def insync?(is)
+    return false unless is && is != :absent
+
+    begin
+      should = @resource[:ensure]
+      should_range = PIP_VERSION_RANGE.parse(should, PIP_VERSION)
+    rescue PIP_VERSION_RANGE::ValidationFailure, PIP_VERSION::ValidationFailure
+      Puppet.debug("Cannot parse #{should} as a pip version range")
+      return false
+    end
+
+    begin
+      is_version = PIP_VERSION.parse(is)
+    rescue PIP_VERSION::ValidationFailure
+      Puppet.debug("Cannot parse #{is} as a pip version")
+      return false
+    end
+
+    should_range.include?(is_version)
+  end
+
+  # Quoting is required if the path to the pip command contains spaces.
+  # Required for execpipe() but not execute(), as execute() already does this.
+  def self.quote(path)
+    if path.include?(" ")
+      "\"#{path}\""
+    else
+      path
+    end
+  end
+
+  private
+
+  def list_extra_flags(command_version)
+    klass = self.class
+    if klass.compare_pip_versions(command_version, '20.2.4') == 1 &&
+       klass.compare_pip_versions(command_version, '21.1') == -1
+      '--use-deprecated=legacy-resolver'
+    end
+  end
+end