openvox 7.37.1

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

@@ -0,0 +1,91 @@
+Puppet::Type.type(:package).provide :ports, :parent => :freebsd, :source => :freebsd do
+  desc "Support for FreeBSD's ports.  Note that this, too, mixes packages and ports."
+
+  commands :portupgrade => "/usr/local/sbin/portupgrade",
+    :portversion => "/usr/local/sbin/portversion",
+    :portuninstall => "/usr/local/sbin/pkg_deinstall",
+    :portinfo => "/usr/sbin/pkg_info"
+
+  %w{INTERACTIVE UNAME}.each do |var|
+    ENV.delete(var) if ENV.include?(var)
+  end
+
+  def install
+    # -N: install if the package is missing, otherwise upgrade
+    # -M: yes, we're a batch, so don't ask any questions
+    cmd = %w{-N -M BATCH=yes} << @resource[:name]
+
+    output = portupgrade(*cmd)
+    if output =~ /\*\* No such /
+      raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: @resource[:name] }
+    end
+  end
+
+  # If there are multiple packages, we only use the last one
+  def latest
+    cmd = ["-v", @resource[:name]]
+
+    begin
+      output = portversion(*cmd)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output, $!)
+    end
+    line = output.split("\n").pop
+
+    unless line =~ /^(\S+)\s+(\S)\s+(.+)$/
+      # There's no "latest" version, so just return a placeholder
+      return :latest
+    end
+
+    pkgstuff = $1
+    match = $2
+    info = $3
+
+    unless pkgstuff =~ /^\S+-([^-\s]+)$/
+      raise Puppet::Error,
+        _("Could not match package info '%{pkgstuff}'") % { pkgstuff: pkgstuff }
+    end
+
+    version = $1
+
+    if match == "=" or match == ">"
+      # we're up to date or more recent
+      return version
+    end
+
+    # Else, we need to be updated; we need to pull out the new version
+
+    unless info =~ /\((\w+) has (.+)\)/
+      raise Puppet::Error,
+        _("Could not match version info '%{info}'") % { info: info }
+    end
+
+    source, newversion = $1, $2
+
+    debug "Newer version in #{source}"
+    newversion
+  end
+
+  def query
+    # support portorigin_glob such as "mail/postfix"
+    name = self.name
+    if name =~ /\//
+      name = self.name.split(/\//).slice(1)
+    end
+    self.class.instances.each do |instance|
+      if instance.name == name
+        return instance.properties
+      end
+    end
+
+    nil
+  end
+
+  def uninstall
+    portuninstall @resource[:name]
+  end
+
+  def update
+    install
+  end
+end

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

@@ -0,0 +1,240 @@
+# Whole new package, so include pack stuff
+require_relative '../../../puppet/provider/package'
+
+Puppet::Type.type(:package).provide :portupgrade, :parent => Puppet::Provider::Package do
+  include Puppet::Util::Execution
+
+  desc "Support for FreeBSD's ports using the portupgrade ports management software.
+    Use the port's full origin as the resource name. eg (ports-mgmt/portupgrade)
+    for the portupgrade port."
+
+  ## has_features is usually autodetected based on defs below.
+  # has_features :installable, :uninstallable, :upgradeable
+
+  commands :portupgrade   => "/usr/local/sbin/portupgrade",
+  :portinstall   => "/usr/local/sbin/portinstall",
+  :portversion   => "/usr/local/sbin/portversion",
+  :portuninstall => "/usr/local/sbin/pkg_deinstall",
+  :portinfo      => "/usr/sbin/pkg_info"
+
+  ## Activate this only once approved by someone important.
+  # defaultfor :operatingsystem => :freebsd
+
+  # Remove unwanted environment variables.
+  %w{INTERACTIVE UNAME}.each do |var|
+    if ENV.include?(var)
+      ENV.delete(var)
+    end
+  end
+
+  ######## instances sub command (builds the installed packages list)
+
+  def self.instances
+    Puppet.debug "portupgrade.rb Building packages list from installed ports"
+
+    # regex to match output from pkg_info
+    regex = %r{^(\S+)-([^-\s]+):(\S+)$}
+    # Corresponding field names
+    fields = [:portname, :ensure, :portorigin]
+    # define Temporary hash used, packages array of hashes
+    hash = Hash.new
+    packages = []
+
+    # exec command
+    cmdline = ["-aoQ"]
+    begin
+      output = portinfo(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output, $!)
+    end
+
+    # split output and match it and populate temp hash
+    output.split("\n").each { |data|
+      # reset hash to nil for each line
+      hash.clear
+      match = regex.match(data)
+      if match
+        # Output matched regex
+        fields.zip(match.captures) { |field, value|
+          hash[field] = value
+        }
+
+        # populate the actual :name field from the :portorigin
+        # Set :provider to this object name
+        hash[:name] = hash[:portorigin]
+        hash[:provider] = self.name
+
+        # Add to the full packages listing
+        packages << new(hash)
+      else
+        # unrecognised output from pkg_info
+        Puppet.debug "portupgrade.Instances() - unable to match output: #{data}"
+      end
+    }
+
+    # return the packages array of hashes
+    return packages
+  end
+
+  ######## Installation sub command
+
+  def install
+    Puppet.debug "portupgrade.install() - Installation call on #{@resource[:name]}"
+    # -M: yes, we're a batch, so don't ask any questions
+    cmdline = ["-M BATCH=yes", @resource[:name]]
+
+    # FIXME: it's possible that portinstall prompts for data so locks up.
+    begin
+      output = portinstall(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output, $!)
+    end
+
+    if output =~ /\*\* No such /
+      raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: @resource[:name] }
+    end
+
+    # No return code required, so do nil to be clean
+    return nil
+  end
+
+  ######## Latest subcommand (returns the latest version available, or current version if installed is latest)
+
+  def latest
+    Puppet.debug "portupgrade.latest() - Latest check called on #{@resource[:name]}"
+    # search for latest version available, or return current version.
+    # cmdline = "portversion -v <portorigin>", returns "<portname> <code> <stuff>"
+    # or "** No matching package found: <portname>"
+    cmdline = ["-v", @resource[:name]]
+
+    begin
+      output = portversion(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output, $!)
+    end
+
+    # Check: output format.
+    if output =~ /^\S+-([^-\s]+)\s+(\S)\s+(.*)/
+      installedversion = $1
+      comparison = $2
+      otherdata = $3
+
+      # Only return a new version number when it's clear that there is a new version
+      # all others return the current version so no unexpected 'upgrades' occur.
+      case comparison
+      when "=", ">"
+        Puppet.debug "portupgrade.latest() - Installed package is latest (#{installedversion})"
+        return installedversion
+      when "<"
+        # "portpkg-1.7_5 < needs updating (port has 1.14)"
+        # "portpkg-1.7_5 < needs updating (port has 1.14) (=> 'newport/pkg')
+        if otherdata =~ /\(port has (\S+)\)/
+          newversion = $1
+          Puppet.debug "portupgrade.latest() - Installed version needs updating to (#{newversion})"
+          return newversion
+        else
+          Puppet.debug "portupgrade.latest() - Unable to determine new version from (#{otherdata})"
+          return installedversion
+        end
+      when "?", "!", "#"
+        Puppet.debug "portupgrade.latest() - Comparison Error reported from portversion (#{output})"
+        return installedversion
+      else
+        Puppet.debug "portupgrade.latest() - Unknown code from portversion output (#{output})"
+        return installedversion
+      end
+
+    else
+      # error: output not parsed correctly, error out with nil.
+      # Seriously - this section should never be called in a perfect world.
+      # as verification that the port is installed has already happened in query.
+      if output =~ /^\*\* No matching package /
+        raise Puppet::ExecutionFailure, _("Could not find package %{name}") % { name: @resource[:name] }
+      else
+        # Any other error (dump output to log)
+        raise Puppet::ExecutionFailure, _("Unexpected output from portversion: %{output}") % { output: output }
+      end
+
+      # Just in case we still are running, return nil
+      return nil
+    end
+
+    # At this point normal operation has finished and we shouldn't have been called.
+    # Error out and let the admin deal with it.
+    raise Puppet::Error, _("portversion.latest() - fatal error with portversion: %{output}") % { output: output }
+  end
+
+  ###### Query subcommand - return a hash of details if exists, or nil if it doesn't.
+  # Used to make sure the package is installed
+
+  def query
+    Puppet.debug "portupgrade.query() - Called on #{@resource[:name]}"
+
+    cmdline = ["-qO", @resource[:name]]
+    begin
+      output = portinfo(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output, $!)
+    end
+
+    # Check: if output isn't in the right format, return nil
+    if output =~ /^(\S+)-([^-\s]+)/
+      # Fill in the details
+      hash = Hash.new
+      hash[:portorigin] = self.name
+      hash[:portname]   = $1
+      hash[:ensure]     = $2
+
+      # If more details are required, then we can do another pkg_info
+      # query here and parse out that output and add to the hash
+      # return the hash to the caller
+      return hash
+    else
+      Puppet.debug "portupgrade.query() - package (#{@resource[:name]}) not installed"
+      return nil
+    end
+  end
+
+  ####### Uninstall command
+
+  def uninstall
+    Puppet.debug "portupgrade.uninstall() - called on #{@resource[:name]}"
+    # Get full package name from port origin to uninstall with
+    cmdline = ["-qO", @resource[:name]]
+    begin
+      output = portinfo(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output, $!)
+    end
+
+    if output =~ /^(\S+)/
+      # output matches, so uninstall it
+      portuninstall $1
+    end
+  end
+
+  ######## Update/upgrade command
+
+  def update
+    Puppet.debug "portupgrade.update() - called on (#{@resource[:name]})"
+
+    cmdline = ["-qO", @resource[:name]]
+    begin
+      output = portinfo(*cmdline)
+    rescue Puppet::ExecutionFailure
+      raise Puppet::Error.new(output, $!)
+    end
+
+    if output =~ /^(\S+)/
+      # output matches, so upgrade the software
+      cmdline = ["-M BATCH=yes", $1]
+      begin
+        output = portupgrade(*cmdline)
+      rescue Puppet::ExecutionFailure
+        raise Puppet::Error.new(output, $!)
+      end
+    end
+  end
+
+  ## EOF
+end

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

@@ -0,0 +1,34 @@
+Puppet::Type.type(:package).provide :puppet_gem, :parent => :gem do
+  desc "Puppet Ruby Gem support. This provider is useful for managing
+        gems needed by the ruby provided in the puppet-agent package."
+
+  has_feature :versionable, :install_options, :uninstall_options
+
+  confine :true => Puppet.runtime[:facter].value(:aio_agent_version)
+
+  def self.windows_gemcmd
+    puppet_dir = Puppet::Util.get_env('PUPPET_DIR')
+    if puppet_dir
+      File.join(Puppet::Util.get_env('PUPPET_DIR').to_s, 'bin', 'gem.bat')
+    else
+      File.join(Gem.default_bindir, 'gem.bat')
+    end
+  end
+
+  if Puppet::Util::Platform.windows?
+    commands :gemcmd => windows_gemcmd
+  else
+    commands :gemcmd => "/opt/puppetlabs/puppet/bin/gem"
+  end
+
+  def uninstall
+    super
+    Puppet.debug("Invalidating rubygems cache after uninstalling gem '#{resource[:name]}'")
+    Puppet::Util::Autoload.gem_source.clear_paths
+  end
+
+  def self.execute_gem_command(command, command_options, custom_environment = {})
+    custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig' unless Puppet::Util::Platform.windows?
+    super(command, command_options, custom_environment)
+  end
+end

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

@@ -0,0 +1,171 @@
+unless Puppet::Util::Platform.jruby_fips?
+  require 'rubygems/commands/list_command'
+end
+require 'stringio'
+require 'uri'
+
+# Ruby gems support.
+Puppet::Type.type(:package).provide :puppetserver_gem, :parent => :gem do
+  desc "Puppet Server Ruby Gem support. If a URL is passed via `source`, then
+    that URL is appended to the list of remote gem repositories which by default
+    contains rubygems.org; To ensure that only the specified source is used also
+    pass `--clear-sources` in via `install_options`; if a 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 at all, the gem will be installed from the default
+    gem repositories."
+
+  has_feature :versionable, :install_options, :uninstall_options
+
+  confine :feature => :hocon
+  # see SERVER-2578
+  confine :fips_enabled => false
+
+  # Define the default provider package command name, as the parent 'gem' provider is targetable.
+  # Required by Puppet::Provider::Package::Targetable::resource_or_provider_command
+
+  def self.provider_command
+    command(:puppetservercmd)
+  end
+
+  # The gem command uses HOME to locate a gemrc file.
+  # CommandDefiner in provider.rb will set failonfail, combine, and environment.
+
+  has_command(:puppetservercmd, '/opt/puppetlabs/bin/puppetserver') do
+    environment(HOME: ENV['HOME'])
+  end
+
+  def self.gemlist(options)
+    command_options = ['gem', 'list']
+
+    if options[:local]
+      command_options << '--local'
+    else
+      command_options << '--remote'
+    end
+
+    if options[:source]
+      command_options << '--source' << options[:source]
+    end
+
+    if options[:justme]
+      gem_regex = '\A' + options[:justme] + '\z'
+      command_options << gem_regex
+    end
+
+    if options[:local]
+      list = execute_rubygems_list_command(command_options)
+    else
+      begin
+        list = puppetservercmd(command_options)
+      rescue Puppet::ExecutionFailure => detail
+        raise Puppet::Error, _("Could not list gems: %{detail}") % { detail: detail }, detail.backtrace
+      end
+    end
+
+    # When `/tmp` is mounted `noexec`, `puppetserver gem list` will output:
+    # *** LOCAL GEMS ***
+    # causing gemsplit to output:
+    # Warning: Could not match *** LOCAL GEMS ***
+    gem_list = list
+                 .lines
+                 .select { |x| x =~ /^(\S+)\s+\((.+)\)/ }
+                 .map { |set| gemsplit(set) }
+
+    if options[:justme]
+      return gem_list.shift
+    else
+      return gem_list
+    end
+  end
+
+  def install(useversion = true)
+    command_options = ['gem', 'install']
+    command_options += install_options if resource[:install_options]
+
+    command_options << '-v' << resource[:ensure] if (!resource[:ensure].is_a? Symbol) && useversion
+
+    command_options << '--no-document'
+
+    if resource[:source]
+      begin
+        uri = URI.parse(resource[: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 << resource[:source]
+      when /file/i
+        command_options << uri.path
+      when 'puppet'
+        # we don't support puppet:// URLs (yet)
+        raise Puppet::Error.new(_('puppet:// URLs are not supported as gem sources'))
+      else
+        # interpret it as a gem repository
+        command_options << '--source' << "#{resource[:source]}" << resource[:name]
+      end
+    else
+      command_options << resource[:name]
+    end
+
+    output = puppetservercmd(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 uninstall
+    command_options = ['gem', 'uninstall']
+    command_options << '--executables' << '--all' << resource[:name]
+    command_options += uninstall_options if resource[:uninstall_options]
+
+    output = puppetservercmd(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
+
+  private
+
+  # The puppetserver gem cli command is very slow, since it starts a JVM.
+  #
+  # Instead, for the list subcommand (which is executed with every puppet run),
+  # use the rubygems library from puppet ruby: setting GEM_HOME and GEM_PATH
+  # to the default values, or the values in the puppetserver configuration file.
+  #
+  # The rubygems library cannot access java platform gems,
+  # for example: json (1.8.3 java)
+  # but java platform gems should not be managed by this (or any) provider.
+
+  def self.execute_rubygems_list_command(command_options)
+    puppetserver_default_gem_home            = '/opt/puppetlabs/server/data/puppetserver/jruby-gems'
+    puppetserver_default_vendored_jruby_gems = '/opt/puppetlabs/server/data/puppetserver/vendored-jruby-gems'
+    puppet_default_vendor_gems               = '/opt/puppetlabs/puppet/lib/ruby/vendor_gems'
+    puppetserver_default_gem_path = [puppetserver_default_gem_home, puppetserver_default_vendored_jruby_gems, puppet_default_vendor_gems].join(':')
+
+    pe_puppetserver_conf_file = '/etc/puppetlabs/puppetserver/conf.d/pe-puppet-server.conf'
+    os_puppetserver_conf_file = '/etc/puppetlabs/puppetserver/puppetserver.conf'
+    puppetserver_conf_file = Puppet.runtime[:facter].value(:pe_server_version) ? pe_puppetserver_conf_file : os_puppetserver_conf_file
+    puppetserver_conf = Hocon.load(puppetserver_conf_file)
+
+    gem_env = {}
+    if puppetserver_conf.empty? || puppetserver_conf.key?('jruby-puppet') == false
+      gem_env['GEM_HOME'] = puppetserver_default_gem_home
+      gem_env['GEM_PATH'] = puppetserver_default_gem_path
+    else
+      gem_env['GEM_HOME'] = puppetserver_conf['jruby-puppet'].key?('gem-home') ? puppetserver_conf['jruby-puppet']['gem-home'] : puppetserver_default_gem_home
+      gem_env['GEM_PATH'] = puppetserver_conf['jruby-puppet'].key?('gem-path') ? puppetserver_conf['jruby-puppet']['gem-path'].join(':') : puppetserver_default_gem_path
+    end
+    gem_env['GEM_SPEC_CACHE'] = "/tmp/#{$$}"
+
+    # Remove the 'gem' from the command_options
+    command_options.shift
+    gem_out = execute_gem_command(Puppet::Type::Package::ProviderPuppet_gem.provider_command, command_options, gem_env)
+
+    # There is no method exclude default gems from the local gem list,
+    # for example: psych (default: 2.2.2)
+    # but default gems should not be managed by this (or any) provider.
+    gem_list = gem_out.lines.reject { |gem| gem =~ / \(default\: / }
+    gem_list.join("\n")
+  end
+end