path: root/modules/base_installation/lib/puppet/provider/package/pacman.rb

require '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 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 aura is installed, we can make use of it
  def self.aura?
    @aura ||= Puppet::FileSystem.exist?('/usr/bin/aura')
  end

  commands :pacman => "/usr/bin/pacman"
  # Aura is a common AUR helper which, if installed, we can use to query the AUR
  commands :aura => "/usr/bin/aura" if aura?

  confine     :operatingsystem => [:archlinux, :manjarolinux]
  defaultfor  :operatingsystem => [:archlinux, :manjarolinux]
  has_feature :install_options
  has_feature :uninstall_options
  has_feature :upgradeable
  has_feature :virtual_packages

  # Checks if a given name is a group
  def self.group?(name)
    begin
      !pacman("-Sg", name).empty?
    rescue Puppet::ExecutionFailure
      # pacman returns an expected non-zero exit code when the name is not a group
      false
    end
  end

  # Install a package using 'pacman', or 'aura' 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 self.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
    begin
      packages = {}
      execpipe([command(:pacman), "-Q"]) do |pipe|
        # pacman -Q output is 'packagename version-rel'
        regex = %r{^(\S+)\s(\S+)}
        pipe.each_line do |line|
          if match = regex.match(line)
            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
  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), "-Sgg"]
      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
    self.install
  end

  # We rescue the main check from Pacman with a check on the AUR using aura, if installed
  def latest
    # Synchronize the database
    pacman "-Sy"

    resource_name = @resource[:name]

    # If target is a group, construct the group version
    return pacman("-Sp", "--print-format", "%n %v", resource_name).lines.map{ |line| line.chomp }.sort.join(', ') if self.class.group?(resource_name)

    # Start by querying with pacman first
    # If that fails, retry using aura against the AUR
    pacman_check = true
    begin
      if pacman_check
        output = pacman "-Sp", "--print-format", "%v", resource_name
        return output.chomp
      else
        output = aura "-Ai", resource_name
        output.split("\n").each do |line|
          return line.split[2].chomp if line.split[0] =~ /Version/
        end
      end
    rescue Puppet::ExecutionFailure
      if pacman_check and self.class.aura?
        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
    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 << "-R"
    cmd << '-s' if is_group
    cmd << resource_name

    if self.class.aura?
      aura(*cmd)
    else
      pacman(*cmd)
    end
  end

  private

  def install_with_aura?
    resource_name = @resource[:name]
    if !self.class.aura?
      return false
    end

    begin
      pacman "-Sp", resource_name
      return false
    rescue Puppet::ExecutionFailure
      return true
    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", "-Sy"
    pacman "--noconfirm", "--noprogressbar", "-U", 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}
    cmd += install_options if @resource[:install_options]

    if install_with_aura?
      cmd << "-Aq" << resource_name
      aura(*cmd)
    else
      cmd << "--noprogressbar"
      cmd << "-Sy" << resource_name
      pacman(*cmd)
    end
  end

end