openvox 7.37.1

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

@@ -0,0 +1,173 @@
+require_relative '../../../puppet/provider/package'
+
+Puppet::Type.type(:package).provide :pkgng, :parent => Puppet::Provider::Package do
+  desc "A PkgNG provider for FreeBSD and DragonFly."
+
+  commands :pkg => "/usr/local/sbin/pkg"
+
+  confine :operatingsystem => [:freebsd, :dragonfly]
+
+  defaultfor :operatingsystem => [:freebsd, :dragonfly]
+
+  has_feature :versionable
+  has_feature :upgradeable
+  has_feature :install_options
+
+  def self.get_query
+    pkg(['query', '-a', '%n %v %o'])
+  end
+
+  def self.get_resource_info(name)
+    pkg(['query', '%n %v %o', name])
+  end
+
+  def self.cached_version_list
+    @version_list ||= get_version_list
+  end
+
+  def self.get_version_list
+    @version_list = pkg(['version', '-voRL='])
+  end
+
+  def self.get_latest_version(origin)
+    latest_version = cached_version_list.lines.find { |l| l =~ /^#{origin} / }
+    if latest_version
+      _name, compare, status = latest_version.chomp.split(' ', 3)
+      if ['!', '?'].include?(compare)
+        return nil
+      end
+      latest_version = status.split(' ').last.split(')').first
+      return latest_version
+    end
+    nil
+  end
+
+  def self.parse_pkg_query_line(line)
+    name, version, origin = line.chomp.split(' ', 3)
+    latest_version  = get_latest_version(origin) || version
+
+    {
+      :ensure   => version,
+      :name     => name,
+      :provider => self.name,
+      :origin   => origin,
+      :version  => version,
+      :latest   => latest_version
+    }
+  end
+
+  def self.instances
+    packages = []
+    begin
+      info = self.get_query
+      get_version_list
+
+      unless info
+        return packages
+      end
+
+      info.lines.each do |line|
+        hash = parse_pkg_query_line(line)
+        packages << new(hash)
+      end
+
+      return packages
+    rescue Puppet::ExecutionFailure
+      return []
+    end
+  end
+
+  def self.prefetch(resources)
+    packages = instances
+    resources.each_key do |name|
+      provider = packages.find{|p| p.name == name or p.origin == name }
+      if provider
+        resources[name].provider = provider
+      end
+    end
+  end
+
+  def repo_tag_from_urn(urn)
+    # extract repo tag from URN: urn:freebsd:repo:<tag>
+    match = /^urn:freebsd:repo:(.+)$/.match(urn)
+    raise ArgumentError urn.inspect unless match
+    match[1]
+  end
+
+  def install
+    source = resource[:source]
+    source = URI(source) unless source.nil?
+
+    # Ensure we handle the version
+    case resource[:ensure]
+    when true, false, Symbol
+      installname = resource[:name]
+    else
+      # If resource[:name] is actually an origin (e.g. 'www/curl' instead of
+      # just 'curl'), drop the category prefix. pkgng doesn't support version
+      # pinning with the origin syntax (pkg install curl-1.2.3 is valid, but
+      # pkg install www/curl-1.2.3 is not).
+      if resource[:name] =~ /\//
+        installname = resource[:name].split('/')[1] + '-' + resource[:ensure]
+      else
+        installname = resource[:name] + '-' + resource[:ensure]
+      end
+    end
+
+    if not source # install using default repo logic
+      args = ['install', '-qy']
+    elsif source.scheme == 'urn' # install from repo named in URN
+      tag = repo_tag_from_urn(source.to_s)
+      args = ['install', '-qy', '-r', tag]
+    else # add package located at URL
+      args = ['add', '-q']
+      installname = source.to_s
+    end
+    args += install_options if @resource[:install_options]
+    args << installname
+
+    pkg(args)
+  end
+
+  def uninstall
+    pkg(['remove', '-qy', resource[:name]])
+  end
+
+  def query
+    begin
+      output = self.class.get_resource_info(resource[:name])
+    rescue Puppet::ExecutionFailure
+      return nil
+    end
+
+    self.class.parse_pkg_query_line(output)
+  end
+
+  def version
+    @property_hash[:version]
+  end
+
+  def version=
+    pkg(['install', '-qfy', "#{resource[:name]}-#{resource[:version]}"])
+  end
+
+  # Upgrade to the latest version
+  def update
+    install
+  end
+
+  # Return the latest version of the package
+  def latest
+    debug "returning the latest #{@property_hash[:name].inspect} version #{@property_hash[:latest].inspect}"
+    @property_hash[:latest]
+  end
+
+  def origin
+    @property_hash[:origin]
+  end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+end

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

@@ -0,0 +1,187 @@
+# Packaging using Peter Bonivart's pkgutil program.
+Puppet::Type.type(:package).provide :pkgutil, :parent => :sun, :source => :sun do
+  desc "Package management using Peter Bonivart's ``pkgutil`` command on Solaris."
+
+  pkgutil_bin = "pkgutil"
+  if FileTest.executable?("/opt/csw/bin/pkgutil")
+    pkgutil_bin = "/opt/csw/bin/pkgutil"
+  end
+
+  confine :osfamily => :solaris
+
+  has_command(:pkguti, pkgutil_bin) do
+    environment :HOME => ENV['HOME']
+  end
+
+  def self.healthcheck()
+    unless Puppet::FileSystem.exist?("/var/opt/csw/pkgutil/admin")
+      Puppet.notice _("It is highly recommended you create '/var/opt/csw/pkgutil/admin'.")
+      Puppet.notice _("See /var/opt/csw/pkgutil")
+    end
+
+    correct_wgetopts = false
+    [ "/opt/csw/etc/pkgutil.conf", "/etc/opt/csw/pkgutil.conf" ].each do |confpath|
+      File.open(confpath) do |conf|
+        conf.each_line {|line| correct_wgetopts = true if line =~ /^\s*wgetopts\s*=.*(-nv|-q|--no-verbose|--quiet)/ }
+      end
+    end
+    if ! correct_wgetopts
+      Puppet.notice _("It is highly recommended that you set 'wgetopts=-nv' in your pkgutil.conf.")
+    end
+  end
+
+  def self.instances(hash = {})
+    healthcheck
+
+    # Use the available pkg list (-a) to work out aliases
+    aliases = {}
+    availlist.each do |pkg|
+      aliases[pkg[:name]] = pkg[:alias]
+    end
+
+    # The -c pkglist lists installed packages
+    pkginsts = []
+    output = pkguti(["-c"])
+    parse_pkglist(output).each do |pkg|
+      pkg.delete(:avail)
+      pkginsts << new(pkg)
+
+      # Create a second instance with the alias if it's different
+      pkgalias = aliases[pkg[:name]]
+      if pkgalias and pkg[:name] != pkgalias
+        apkg = pkg.dup
+        apkg[:name] = pkgalias
+        pkginsts << new(apkg)
+      end
+    end
+
+    pkginsts
+  end
+
+  # Turns a pkgutil -a listing into hashes with the common alias, full
+  # package name and available version
+  def self.availlist
+    output = pkguti ["-a"]
+
+    output.split("\n").collect do |line|
+      next if line =~ /^common\s+package/  # header of package list
+      next if noise?(line)
+
+      if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
+        { :alias => $1, :name => $2, :avail => $3 }
+      else
+        Puppet.warning _("Cannot match %{line}") % { line: line }
+      end
+    end.reject { |h| h.nil? }
+  end
+
+  # Turn our pkgutil -c listing into a hash for a single package.
+  def pkgsingle(resource)
+    # The --single option speeds up the execution, because it queries
+    # the package management system for one package only.
+    command = ["-c", "--single", resource[:name]]
+    self.class.parse_pkglist(run_pkgutil(resource, command), { :justme => resource[:name] })
+  end
+
+  # Turn our pkgutil -c listing into a bunch of hashes.
+  def self.parse_pkglist(output, hash = {})
+    output = output.split("\n")
+
+    if output[-1] == "Not in catalog"
+      Puppet.warning _("Package not in pkgutil catalog: %{package}") % { package: hash[:justme] }
+      return nil
+    end
+
+    list = output.collect do |line|
+      next if line =~ /installed\s+catalog/  # header of package list
+      next if noise?(line)
+
+      pkgsplit(line)
+    end.reject { |h| h.nil? }
+
+    if hash[:justme]
+      # Single queries may have been for an alias so return the name requested
+      if list.any?
+        list[-1][:name] = hash[:justme]
+        return list[-1]
+      end
+    else
+      list.reject! { |h| h[:ensure] == :absent }
+      return list
+    end
+  end
+
+  # Identify common types of pkgutil noise as it downloads catalogs etc
+  def self.noise?(line)
+    true if line =~ /^#/
+    true if line =~ /^Checking integrity / # use_gpg
+    true if line =~ /^gpg: /               # gpg verification
+    true if line =~ /^=+> /                # catalog fetch
+    true if line =~ /\d+:\d+:\d+ URL:/     # wget without -q
+    false
+  end
+
+  # Split the different lines into hashes.
+  def self.pkgsplit(line)
+    if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
+      hash = {}
+      hash[:name] = $1
+      hash[:ensure] = if $2 == "notinst"
+        :absent
+      else
+        $2
+      end
+      hash[:avail] = $3
+
+      if hash[:avail] =~ /^SAME\s*$/
+        hash[:avail] = hash[:ensure]
+      end
+
+      # 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 run_pkgutil(resource, *args)
+    # Allow source to be one or more URLs pointing to a repository that all
+    # get passed to pkgutil via one or more -t options
+    if resource[:source]
+      sources = [resource[:source]].flatten
+      pkguti(*[sources.map{|src| [ "-t", src ]}, *args].flatten)
+    else
+      pkguti(*args.flatten)
+    end
+  end
+
+  def install
+    run_pkgutil @resource, "-y", "-i", @resource[:name]
+  end
+
+  # Retrieve the version from the current package file.
+  def latest
+    hash = pkgsingle(@resource)
+    hash[:avail] if hash
+  end
+
+  def query
+    hash = pkgsingle(@resource)
+    if hash
+      hash
+    else
+      {:ensure => :absent}
+    end
+  end
+
+  def update
+    run_pkgutil @resource, "-y", "-u", @resource[:name]
+  end
+
+  def uninstall
+    run_pkgutil @resource, "-y", "-r", @resource[:name]
+  end
+end

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

@@ -0,0 +1,310 @@
+require_relative '../../../puppet/provider/package'
+require 'fileutils'
+
+Puppet::Type.type(:package).provide :portage, :parent => Puppet::Provider::Package do
+  desc "Provides packaging support for Gentoo's portage system.
+
+    This provider supports the `install_options` and `uninstall_options` attributes, which allows command-line
+    flags to be passed to emerge. These options should be specified as an array where each element is either a string or a hash."
+
+  has_features :install_options, :purgeable, :reinstallable, :uninstall_options, :versionable, :virtual_packages
+
+  {
+    :emerge => '/usr/bin/emerge',
+    :eix => '/usr/bin/eix',
+    :qatom_bin => '/usr/bin/qatom',
+    :update_eix => '/usr/bin/eix-update',
+  }.each_pair do |name, path|
+    has_command(name, path) do
+      environment :HOME => '/'
+    end
+  end
+
+  confine :osfamily => :gentoo
+
+  defaultfor :osfamily => :gentoo
+
+  def self.instances
+    result_format = self.eix_result_format
+    result_fields = self.eix_result_fields
+
+    limit = self.eix_limit
+    version_format = self.eix_version_format
+    slot_versions_format = self.eix_slot_versions_format
+    installed_versions_format = self.eix_installed_versions_format
+    installable_versions_format = self.eix_install_versions_format
+    begin
+      eix_file = File.directory?('/var/cache/eix') ? '/var/cache/eix/portage.eix' : '/var/cache/eix'
+      update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
+
+      search_output = nil
+      Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
+        search_output = eix(*(self.eix_search_arguments + ['--installed']))
+      end
+
+      packages = []
+      search_output.each_line do |search_result|
+        match = result_format.match(search_result)
+
+        if match
+          package = {}
+          result_fields.zip(match.captures) do |field, value|
+            package[field] = value unless !value or value.empty?
+          end
+          package[:provider] = :portage
+          packages << new(package)
+        end
+      end
+
+      return packages
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new(detail)
+    end
+  end
+
+  def install
+    should = @resource.should(:ensure)
+    cmd = %w{}
+    name = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
+    name = qatom[:pfx] + name if qatom[:pfx]
+    name = name + '-' + qatom[:pv] if qatom[:pv]
+    name = name + '-' + qatom[:pr] if qatom[:pr]
+    name = name + ':' + qatom[:slot] if qatom[:slot]
+    cmd << '--update' if [:latest].include?(should)
+    cmd += install_options if @resource[:install_options]
+    cmd << name
+    emerge(*cmd)
+  end
+
+  def uninstall
+    should = @resource.should(:ensure)
+    cmd = %w{--rage-clean}
+    name = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
+    name = qatom[:pfx] + name if qatom[:pfx]
+    name = name + '-' + qatom[:pv] if qatom[:pv]
+    name = name + '-' + qatom[:pr] if qatom[:pr]
+    name = name + ':' + qatom[:slot] if qatom[:slot]
+    cmd += uninstall_options if @resource[:uninstall_options]
+    cmd << name
+    if [:purged].include?(should)
+      Puppet::Util.withenv :CONFIG_PROTECT => "-*" do
+        emerge(*cmd)
+      end
+    else
+      emerge(*cmd)
+    end
+  end
+
+  def reinstall
+    self.install
+  end
+
+  def update
+    self.install
+  end
+
+  def qatom
+    output_format = self.qatom_output_format
+    result_format = self.qatom_result_format
+    result_fields = self.qatom_result_fields
+    @atom ||= begin
+      package_info = {}
+      # do the search
+      should = @resource[:ensure]
+      case should
+      # The terms present, absent, purged, installed, latest in :ensure
+      # resolve as Symbols, and we do not need specific package version in this case
+      when true, false, Symbol
+        search = @resource[:name]
+      else
+        search = '=' + @resource[:name] + '-' + "#{should}"
+      end
+      search_output = qatom_bin(*([search, '--format', output_format]))
+      # verify if the search found anything
+      match = result_format.match(search_output)
+      if match
+        result_fields.zip(match.captures) do |field, value|
+          # some fields can be empty or (null) (if we are not passed a category in the package name for instance)
+          if value == '(null)' || value == '<unset>'
+            package_info[field] = nil
+          elsif !value or value.empty?
+            package_info[field] = nil
+          else
+            package_info[field] = value
+          end
+        end
+      end
+      @atom = package_info
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new(detail)
+    end
+  end
+
+  def qatom_output_format
+    '"[%[CATEGORY]] [%[PN]] [%[PV]] [%[PR]] [%[SLOT]] [%[pfx]] [%[sfx]]"'
+  end
+
+  def qatom_result_format
+    /^\"\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\](.*)\"$/
+  end
+
+  def qatom_result_fields
+    [:category, :pn, :pv, :pr, :slot, :pfx, :sfx]
+  end
+
+  def self.get_sets
+    @sets ||= begin
+      @sets = emerge(*(['--list-sets']))
+    end
+  end
+
+  def query
+    limit = self.class.eix_limit
+    result_format = self.class.eix_result_format
+    result_fields = self.class.eix_result_fields
+
+    version_format = self.class.eix_version_format
+    slot_versions_format = self.class.eix_slot_versions_format
+    installed_versions_format = self.class.eix_installed_versions_format
+    installable_versions_format = self.class.eix_install_versions_format
+    search_field = qatom[:category] ? '--category-name' : '--name'
+    search_value = qatom[:category] ? "#{qatom[:category]}/#{qatom[:pn]}" : qatom[:pn]
+
+    @eix_result ||= begin
+      # package sets
+      package_sets = []
+      self.class.get_sets.each_line do |package_set|
+        package_sets << package_set.to_s.strip
+      end
+
+      if @resource[:name] =~ /^@/
+        if package_sets.include?(@resource[:name][1..-1].to_s)
+          return({:name => "#{@resource[:name]}", :ensure => '9999', :version_available => nil, :installed_versions => nil, :installable_versions => "9999,"})
+        end
+      end
+
+      eix_file = File.directory?('/var/cache/eix') ? '/var/cache/eix/portage.eix' : '/var/cache/eix'
+      update_eix if !FileUtils.uptodate?(eix_file, %w{/usr/bin/eix /usr/portage/metadata/timestamp})
+
+      search_output = nil
+      Puppet::Util.withenv :EIX_LIMIT => limit, :LASTVERSION => version_format, :LASTSLOTVERSIONS => slot_versions_format, :INSTALLEDVERSIONS => installed_versions_format, :STABLEVERSIONS => installable_versions_format do
+        search_output = eix(*(self.class.eix_search_arguments + ['--exact',search_field,search_value]))
+      end
+
+      packages = []
+      search_output.each_line do |search_result|
+        match = result_format.match(search_result)
+
+        if match
+          package = {}
+          result_fields.zip(match.captures) do |field, value|
+            package[field] = value unless !value or value.empty?
+          end
+          # dev-lang python [3.4.5] [3.5.2] [2.7.12:2.7,3.4.5:3.4] [2.7.12:2.7,3.4.5:3.4,3.5.2:3.5] https://www.python.org/ An interpreted, interactive, object-oriented programming language
+          # version_available is what we CAN install / update to
+          # ensure is what is currently installed
+          # This DOES NOT choose to install/upgrade or not, just provides current info
+          # prefer checking versions to slots as versions are finer grained
+          search = qatom[:pv]
+          search = search + '-' + qatom[:pr] if qatom[:pr]
+          if search
+            package[:version_available] = eix_get_version_for_versions(package[:installable_versions], search)
+            package[:ensure] = eix_get_version_for_versions(package[:installed_versions], search)
+          elsif qatom[:slot]
+            package[:version_available] = eix_get_version_for_slot(package[:slot_versions_available], qatom[:slot])
+            package[:ensure] = eix_get_version_for_slot(package[:installed_slots], qatom[:slot])
+          end
+
+          package[:ensure] = package[:ensure] ? package[:ensure] : :absent
+          packages << package
+        end
+      end
+
+      case packages.size
+        when 0
+          raise Puppet::Error.new(_("No package found with the specified name [%{name}]") % { name: @resource[:name] })
+        when 1
+          @eix_result = packages[0]
+        else
+          raise Puppet::Error.new(_("More than one package with the specified name [%{search_value}], please use the category parameter to disambiguate") % { search_value: search_value })
+      end
+    rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error.new(detail)
+    end
+  end
+
+  def latest
+    self.query[:version_available]
+  end
+
+  private
+  def eix_get_version_for_versions(versions, target)
+    # [2.7.10-r1,2.7.12,3.4.3-r1,3.4.5,3.5.2] 3.5.2
+    return nil if versions.nil?
+    versions = versions.split(',')
+    # [2.7.10-r1 2.7.12 3.4.3-r1 3.4.5 3.5.2]
+    versions.find { |version| version == target }
+    # 3.5.2
+  end
+
+  private
+  def eix_get_version_for_slot(versions_and_slots, slot)
+    # [2.7.12:2.7 3.4.5:3.4 3.5.2:3.5] 3.5
+    return nil if versions_and_slots.nil?
+    versions_and_slots = versions_and_slots.split(',')
+    # [2.7.12:2.7 3.4.5:3.4 3.5.2:3.5]
+    versions_and_slots.map! { |version_and_slot| version_and_slot.split(':') }
+    # [2.7.12: 2.7
+    #  3.4.5:  3.4
+    #  3.5.2:  3.5]
+    version_for_slot = versions_and_slots.find { |version_and_slot| version_and_slot.last == slot }
+    # [3.5.2:  3.5]
+    version_for_slot.first if version_for_slot
+    # 3.5.2
+  end
+
+  def self.eix_search_format
+    "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] [<installedversions:LASTSLOTVERSIONS>] [<installedversions:INSTALLEDVERSIONS>] [<availableversions:STABLEVERSIONS>] [<bestslotversions:LASTSLOTVERSIONS>] <homepage> <description>\n'"
+  end
+
+  def self.eix_result_format
+    /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+\[(\S*)\]\s+(\S+)\s+(.*)$/
+  end
+
+  def self.eix_result_fields
+    # ensure:[3.4.5], version_available:[3.5.2], installed_slots:[2.7.12:2.7,3.4.5:3.4], installable_versions:[2.7.10-r1,2.7.12,3.4.3-r1,3.4.5,3.5.2] slot_versions_available:[2.7.12:2.7,3.4.5:3.4,3.5.2:3.5]
+    [:category, :name, :ensure, :version_available, :installed_slots, :installed_versions, :installable_versions, :slot_versions_available, :vendor, :description]
+  end
+
+  def self.eix_version_format
+    '{last}<version>{}'
+  end
+
+  def self.eix_slot_versions_format
+    '{!first},{}<version>:<slot>'
+  end
+
+  def self.eix_installed_versions_format
+    '{!first},{}<version>'
+  end
+
+  def self.eix_install_versions_format
+    '{!first}{!last},{}{}{isstable}<version>{}'
+  end
+
+  def self.eix_limit
+    '0'
+  end
+
+  def self.eix_search_arguments
+    ['--nocolor', '--pure-packages', '--format', self.eix_search_format]
+  end
+
+  def install_options
+    join_options(@resource[:install_options])
+  end
+
+  def uninstall_options
+    join_options(@resource[:uninstall_options])
+  end
+end