openvox 8.19.0

data/lib/puppet/util/package.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Puppet::Util::Package
+  def versioncmp(version_a, version_b, ignore_trailing_zeroes = false)
+    vre = /[-.]|\d+|[^-.\d]+/
+
+    if ignore_trailing_zeroes
+      version_a = normalize(version_a)
+      version_b = normalize(version_b)
+    end
+
+    ax = version_a.scan(vre)
+    bx = version_b.scan(vre)
+
+    while ax.length > 0 && bx.length > 0
+      a = ax.shift
+      b = bx.shift
+
+      next      if a == b
+      return -1 if a == '-'
+      return 1  if b == '-'
+      return -1 if a == '.'
+      return 1  if b == '.'
+
+      if a =~ /^\d+$/ && b =~ /^\d+$/
+        return a.to_s.upcase <=> b.to_s.upcase if a =~ /^0/ || b =~ /^0/
+
+        return a.to_i <=> b.to_i
+      end
+      return a.upcase <=> b.upcase
+    end
+    version_a <=> version_b
+  end
+  module_function :versioncmp
+
+  def self.normalize(version)
+    version = version.split('-')
+    version.first.sub!(/([.0]+)$/, '')
+
+    version.join('-')
+  end
+  private_class_method :normalize
+end

data/lib/puppet/util/pidlock.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative '../../puppet/util/lockfile'
+
+class Puppet::Util::Pidlock
+  def initialize(lockfile)
+    @lockfile = Puppet::Util::Lockfile.new(lockfile)
+  end
+
+  def locked?
+    clear_if_stale
+    @lockfile.locked?
+  end
+
+  def mine?
+    Process.pid == lock_pid
+  end
+
+  def lock
+    return mine? if locked?
+
+    @lockfile.lock(Process.pid)
+  end
+
+  def unlock
+    if mine?
+      @lockfile.unlock
+    else
+      false
+    end
+  end
+
+  def lock_pid
+    pid = @lockfile.lock_data
+    begin
+      Integer(pid)
+    rescue ArgumentError, TypeError
+      nil
+    end
+  end
+
+  def file_path
+    @lockfile.file_path
+  end
+
+  private
+
+  def ps_argument_for_current_kernel
+    case Puppet.runtime[:facter].value(:kernel)
+    when "Linux"
+      "-eq"
+    when "AIX"
+      "-T"
+    else
+      "-p"
+    end
+  end
+
+  def clear_if_stale
+    pid = lock_pid
+    return @lockfile.unlock if pid.nil?
+    return if Process.pid == pid
+
+    errors = [Errno::ESRCH]
+    # Win32::Process now throws SystemCallError. Since this could be
+    # defined anywhere, only add when on Windows.
+    errors << SystemCallError if Puppet::Util::Platform.windows?
+
+    begin
+      Process.kill(0, pid)
+    rescue *errors
+      return @lockfile.unlock
+    end
+
+    # Ensure the process associated with this pid is our process. If
+    # not, we can unlock the lockfile. CLI arguments used for identifying
+    # on POSIX depend on the os and sometimes even version.
+    if Puppet.features.posix?
+      ps_argument = ps_argument_for_current_kernel
+
+      # Check, obtain and use the right ps argument
+      begin
+        procname = Puppet::Util::Execution.execute(["ps", ps_argument, pid, "-o", "comm="]).strip
+      rescue Puppet::ExecutionFailure
+        ps_argument = "-p"
+        procname = Puppet::Util::Execution.execute(["ps", ps_argument, pid, "-o", "comm="]).strip
+      end
+
+      args = Puppet::Util::Execution.execute(["ps", ps_argument, pid, "-o", "args="]).strip
+      @lockfile.unlock unless procname =~ /ruby/ && args =~ /puppet/ || procname =~ /puppet(-.*)?$/
+    elsif Puppet.features.microsoft_windows?
+      # On Windows, we're checking if the filesystem path name of the running
+      # process is our vendored ruby:
+      begin
+        exe_path = Puppet::Util::Windows::Process.get_process_image_name_by_pid(pid)
+        @lockfile.unlock unless exe_path =~ /\\bin\\ruby.exe$/
+      rescue Puppet::Util::Windows::Error => e
+        Puppet.debug("Failed to read pidfile #{file_path}: #{e.message}")
+      end
+    end
+  end
+end

data/lib/puppet/util/platform.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Puppet
+  module Util
+    module Platform
+      FIPS_STATUS_FILE = "/proc/sys/crypto/fips_enabled"
+      WINDOWS_FIPS_REGISTRY_KEY = 'System\\CurrentControlSet\\Control\\Lsa\\FipsAlgorithmPolicy'
+
+      def windows?
+        # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
+        # library uses that to test what platform it's on. In some places we
+        # would use Puppet.features.microsoft_windows?, but this method can be
+        # used to determine the behavior of the underlying system without
+        # requiring features to be initialized and without side effect.
+        !!File::ALT_SEPARATOR
+      end
+      module_function :windows?
+
+      def solaris?
+        RUBY_PLATFORM.include?('solaris')
+      end
+      module_function :solaris?
+
+      def default_paths
+        return [] if windows?
+
+        %w[/usr/sbin /sbin]
+      end
+      module_function :default_paths
+
+      @fips_enabled = if windows?
+                        require 'win32/registry'
+
+                        begin
+                          Win32::Registry::HKEY_LOCAL_MACHINE.open(WINDOWS_FIPS_REGISTRY_KEY) do |reg|
+                            reg.values.first == 1
+                          end
+                        rescue Win32::Registry::Error
+                          false
+                        end
+                      else
+                        File.exist?(FIPS_STATUS_FILE) &&
+                          File.read(FIPS_STATUS_FILE, 1) == '1'
+                      end
+
+      def fips_enabled?
+        @fips_enabled
+      end
+      module_function :fips_enabled?
+
+      def self.jruby?
+        RUBY_PLATFORM == 'java'
+      end
+
+      def jruby_fips?
+        @@jruby_fips ||= if RUBY_PLATFORM == 'java'
+                           require 'java'
+
+                           begin
+                             require 'openssl'
+                             false
+                           rescue LoadError, NameError
+                             true
+                           end
+                         else
+                           false
+                         end
+      end
+      module_function :jruby_fips?
+    end
+  end
+end

data/lib/puppet/util/plist.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'cfpropertylist' if Puppet.features.cfpropertylist?
+require_relative '../../puppet/util/execution'
+
+module Puppet::Util::Plist
+  class FormatError < RuntimeError; end
+
+  # So I don't have to prepend every method name with 'self.' Most of the
+  # methods are going to be Provider methods (as opposed to methods of the
+  # INSTANCE of the provider).
+  class << self
+    # Defines the magic number for binary plists
+    #
+    # @api private
+    def binary_plist_magic_number
+      "bplist00"
+    end
+
+    # Defines a default doctype string that should be at the top of most plist
+    # files. Useful if we need to modify an invalid doctype string in memory.
+    # In version 10.9 and lower of OS X the plist at
+    # /System/Library/LaunchDaemons/org.ntp.ntpd.plist had an invalid doctype
+    # string. This corrects for that.
+    def plist_xml_doctype
+      '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
+    end
+
+    # Read a plist file, whether its format is XML or in Apple's "binary1"
+    # format, using the CFPropertyList gem.
+    def read_plist_file(file_path)
+      # We can't really read the file until we know the source encoding in
+      # Ruby 1.9.x, so we use the magic number to detect it.
+      # NOTE: We used IO.read originally to be Ruby 1.8.x compatible.
+      if read_file_with_offset(file_path, binary_plist_magic_number.length) == binary_plist_magic_number
+        plist_obj = new_cfpropertylist(:file => file_path)
+        return convert_cfpropertylist_to_native_types(plist_obj)
+      else
+        plist_data = open_file_with_args(file_path, "r:UTF-8")
+        plist = parse_plist(plist_data, file_path)
+        return plist if plist
+
+        Puppet.debug "Plist #{file_path} ill-formatted, converting with plutil"
+        begin
+          plist = Puppet::Util::Execution.execute(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', file_path],
+                                                  { :failonfail => true, :combine => true })
+          return parse_plist(plist)
+        rescue Puppet::ExecutionFailure => detail
+          message = _("Cannot read file %{file_path}; Puppet is skipping it.") % { file_path: file_path }
+          message += '\n' + _("Details: %{detail}") % { detail: detail }
+          Puppet.warning(message)
+        end
+      end
+      nil
+    end
+
+    # Read plist text using the CFPropertyList gem.
+    def parse_plist(plist_data, file_path = '')
+      bad_xml_doctype = %r{^.*<!DOCTYPE plist PUBLIC -//Apple Computer.*$}
+      # Depending on where parse_plist is called from, plist_data can be either XML or binary.
+      # If we get XML, make sure ruby knows it's UTF-8 so we avoid invalid byte sequence errors.
+      if plist_data.include?('encoding="UTF-8"') && plist_data.encoding != Encoding::UTF_8
+        plist_data.force_encoding(Encoding::UTF_8)
+      end
+
+      begin
+        if plist_data =~ bad_xml_doctype
+          plist_data.gsub!(bad_xml_doctype, plist_xml_doctype)
+          Puppet.debug("Had to fix plist with incorrect DOCTYPE declaration: #{file_path}")
+        end
+      rescue ArgumentError => e
+        Puppet.debug "Failed with #{e.class} on #{file_path}: #{e.inspect}"
+        return nil
+      end
+
+      begin
+        plist_obj = new_cfpropertylist(:data => plist_data)
+      # CFPropertyList library will raise NoMethodError for invalid data
+      rescue CFFormatError, NoMethodError => e
+        Puppet.debug "Failed with #{e.class} on #{file_path}: #{e.inspect}"
+        return nil
+      end
+      convert_cfpropertylist_to_native_types(plist_obj)
+    end
+
+    # Helper method to assist in reading a file. It's its own method for
+    # stubbing purposes
+    #
+    # @api private
+    #
+    # @param args [String] Extra file operation mode information to use
+    #   (defaults to read-only mode 'r')
+    #   This is the standard mechanism Ruby uses in the IO class, and therefore
+    #   encoding may be explicitly like fmode : encoding or fmode : "BOM|UTF-*"
+    #   for example, a:ASCII or w+:UTF-8
+    def open_file_with_args(file, args)
+      File.open(file, args).read
+    end
+
+    # Helper method to assist in generating a new CFPropertyList Plist. It's
+    # its own method for stubbing purposes
+    #
+    # @api private
+    def new_cfpropertylist(plist_opts)
+      CFPropertyList::List.new(plist_opts)
+    end
+
+    # Helper method to assist in converting a native CFPropertyList object to a
+    # native Ruby object (hash). It's its own method for stubbing purposes
+    #
+    # @api private
+    def convert_cfpropertylist_to_native_types(plist_obj)
+      CFPropertyList.native_types(plist_obj.value)
+    end
+
+    # Helper method to convert a string into a CFProperty::Blob, which is
+    # needed to properly handle binary strings
+    #
+    # @api private
+    def string_to_blob(str)
+      CFPropertyList::Blob.new(str)
+    end
+
+    # Helper method to assist in reading a file with an offset value. It's its
+    # own method for stubbing purposes
+    #
+    # @api private
+    def read_file_with_offset(file_path, offset)
+      IO.read(file_path, offset)
+    end
+
+    def to_format(format)
+      case format.to_sym
+      when :xml
+        CFPropertyList::List::FORMAT_XML
+      when :binary
+        CFPropertyList::List::FORMAT_BINARY
+      when :plain
+        CFPropertyList::List::FORMAT_PLAIN
+      else
+        raise FormatError, "Unknown plist format #{format}"
+      end
+    end
+
+    # This method will write a plist file using a specified format (or XML
+    # by default)
+    def write_plist_file(plist, file_path, format = :xml)
+      plist_to_save       = CFPropertyList::List.new
+      plist_to_save.value = CFPropertyList.guess(plist)
+      plist_to_save.save(file_path, to_format(format), :formatted => true)
+    rescue IOError => e
+      Puppet.err(_("Unable to write the file %{file_path}. %{error}") % { file_path: file_path, error: e.inspect })
+    end
+
+    def dump_plist(plist_data, format = :xml)
+      plist_to_save       = CFPropertyList::List.new
+      plist_to_save.value = CFPropertyList.guess(plist_data)
+      plist_to_save.to_str(to_format(format), :formatted => true)
+    end
+  end
+end

data/lib/puppet/util/posix.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+# Utility methods for interacting with POSIX objects; mostly user and group
+module Puppet::Util::POSIX
+  # This is a list of environment variables that we will set when we want to override the POSIX locale
+  LOCALE_ENV_VARS = %w[LANG LC_ALL LC_MESSAGES LANGUAGE
+                       LC_COLLATE LC_CTYPE LC_MONETARY LC_NUMERIC LC_TIME]
+
+  # This is a list of user-related environment variables that we will unset when we want to provide a pristine
+  # environment for "exec" runs
+  USER_ENV_VARS = %w[HOME USER LOGNAME]
+
+  class << self
+    # Returns an array of all the groups that the user's a member of.
+    def groups_of(user)
+      begin
+        require_relative '../../puppet/ffi/posix'
+        groups = get_groups_list(user)
+      rescue StandardError, LoadError => e
+        Puppet.debug("Falling back to Puppet::Etc.group: #{e.message}")
+
+        groups = []
+        Puppet::Etc.group do |group|
+          groups << group.name if group.mem.include?(user)
+        end
+      end
+
+      uniq_groups = groups.uniq
+      if uniq_groups != groups
+        Puppet.debug(_('Removing any duplicate group entries'))
+      end
+
+      uniq_groups
+    end
+
+    private
+
+    def get_groups_list(user)
+      raise LoadError, "The 'getgrouplist' method is not available" unless Puppet::FFI::POSIX::Functions.respond_to?(:getgrouplist)
+
+      user_gid = Puppet::Etc.getpwnam(user).gid
+      ngroups = Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS
+
+      loop do
+        FFI::MemoryPointer.new(:int) do |ngroups_ptr|
+          FFI::MemoryPointer.new(:uint, ngroups) do |groups_ptr|
+            old_ngroups = ngroups
+            ngroups_ptr.write_int(ngroups)
+
+            if Puppet::FFI::POSIX::Functions.getgrouplist(user, user_gid, groups_ptr, ngroups_ptr) != -1
+              groups_gids = groups_ptr.get_array_of_uint(0, ngroups_ptr.read_int)
+
+              result = []
+              groups_gids.each do |group_gid|
+                group_info = Puppet::Etc.getgrgid(group_gid)
+                result |= [group_info.name] if group_info.mem.include?(user)
+              end
+              return result
+            end
+
+            ngroups = ngroups_ptr.read_int
+            if ngroups <= old_ngroups
+              ngroups *= 2
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # Retrieve a field from a POSIX Etc object.  The id can be either an integer
+  # or a name.  This only works for users and groups.  It's also broken on
+  # some platforms, unfortunately, which is why we fall back to the other
+  # method search_posix_field in the gid and uid methods if a sanity check
+  # fails
+  def get_posix_field(space, field, id)
+    raise Puppet::DevError, _("Did not get id from caller") unless id
+
+    if id.is_a?(Integer)
+      if id > Puppet[:maximum_uid].to_i
+        Puppet.err _("Tried to get %{field} field for silly id %{id}") % { field: field, id: id }
+        return nil
+      end
+      method = methodbyid(space)
+    else
+      method = methodbyname(space)
+    end
+
+    begin
+      Etc.send(method, id).send(field)
+    rescue NoMethodError, ArgumentError
+      # ignore it; we couldn't find the object
+      nil
+    end
+  end
+
+  # A degenerate method of retrieving name/id mappings.  The job of this method is
+  # to retrieve all objects of a certain type, search for a specific entry
+  # and then return a given field from that entry.
+  def search_posix_field(type, field, id)
+    idmethod = idfield(type)
+    integer = false
+    if id.is_a?(Integer)
+      integer = true
+      if id > Puppet[:maximum_uid].to_i
+        Puppet.err _("Tried to get %{field} field for silly id %{id}") % { field: field, id: id }
+        return nil
+      end
+    end
+
+    Etc.send(type) do |object|
+      if integer and object.send(idmethod) == id
+        return object.send(field)
+      elsif object.name == id
+        return object.send(field)
+      end
+    end
+
+    # Apparently the group/passwd methods need to get reset; if we skip
+    # this call, then new users aren't found.
+    case type
+    when :passwd; Etc.send(:endpwent)
+    when :group; Etc.send(:endgrent)
+    end
+    nil
+  end
+
+  # Determine what the field name is for users and groups.
+  def idfield(space)
+    case space.intern
+    when :gr, :group; :gid
+    when :pw, :user, :passwd; :uid
+    else
+      raise ArgumentError, _("Can only handle users and groups")
+    end
+  end
+
+  # Determine what the method is to get users and groups by id
+  def methodbyid(space)
+    case space.intern
+    when :gr, :group; :getgrgid
+    when :pw, :user, :passwd; :getpwuid
+    else
+      raise ArgumentError, _("Can only handle users and groups")
+    end
+  end
+
+  # Determine what the method is to get users and groups by name
+  def methodbyname(space)
+    case space.intern
+    when :gr, :group; :getgrnam
+    when :pw, :user, :passwd; :getpwnam
+    else
+      raise ArgumentError, _("Can only handle users and groups")
+    end
+  end
+
+  # Get the GID
+  def gid(group)
+    get_posix_value(:group, :gid, group)
+  end
+
+  # Get the UID
+  def uid(user)
+    get_posix_value(:passwd, :uid, user)
+  end
+
+  private
+
+  # Get the specified id_field of a given field (user or group),
+  # whether an ID name is provided
+  def get_posix_value(location, id_field, field)
+    begin
+      field = Integer(field)
+    rescue ArgumentError
+      # pass
+    end
+    if field.is_a?(Integer)
+      name = get_posix_field(location, :name, field)
+      return nil unless name
+
+      id = get_posix_field(location, id_field, name)
+      check_value = id
+    else
+      id = get_posix_field(location, id_field, field)
+      return nil unless id
+
+      name = get_posix_field(location, :name, id)
+      check_value = name
+    end
+
+    if check_value != field
+      check_value_id = get_posix_field(location, id_field, check_value) if check_value
+
+      if id == check_value_id
+        Puppet.debug("Multiple entries found for resource: '#{location}' with #{id_field}: #{id}")
+        id
+      else
+        Puppet.debug("The value retrieved: '#{check_value}' is different than the required state: '#{field}', searching in all entries")
+        search_posix_field(location, id_field, field)
+      end
+    else
+      id
+    end
+  end
+end

data/lib/puppet/util/profiler/aggregate.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/profiler'
+require_relative '../../../puppet/util/profiler/wall_clock'
+
+class Puppet::Util::Profiler::Aggregate < Puppet::Util::Profiler::WallClock
+  def initialize(logger, identifier)
+    super(logger, identifier)
+    @metrics_hash = Metric.new
+  end
+
+  def shutdown
+    super
+    @logger.call("AGGREGATE PROFILING RESULTS:")
+    @logger.call("----------------------------")
+    print_metrics(@metrics_hash, "")
+    @logger.call("----------------------------")
+  end
+
+  def do_finish(context, description, metric_id)
+    result = super(context, description, metric_id)
+    update_metric(@metrics_hash, metric_id, result[:time])
+    result
+  end
+
+  def update_metric(metrics_hash, metric_id, time)
+    first, *rest = *metric_id
+    if first
+      m = metrics_hash[first]
+      m.increment
+      m.add_time(time)
+      if rest.count > 0
+        update_metric(m, rest, time)
+      end
+    end
+  end
+
+  def values
+    @metrics_hash
+  end
+
+  def print_metrics(metrics_hash, prefix)
+    metrics_hash.sort_by { |_k, v| v.time }.reverse_each do |k, v|
+      @logger.call("#{prefix}#{k}: #{v.time} s (#{v.count} calls)")
+      print_metrics(metrics_hash[k], "#{prefix}#{k} -> ")
+    end
+  end
+
+  class Metric < Hash
+    def initialize
+      super
+      @count = 0
+      @time = 0
+    end
+    attr_reader :count, :time
+
+    def [](key)
+      unless has_key?(key)
+        self[key] = Metric.new
+      end
+      super(key)
+    end
+
+    def increment
+      @count += 1
+    end
+
+    def add_time(time)
+      @time += time
+    end
+  end
+
+  class Timer
+    def initialize
+      @start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second)
+    end
+
+    def stop
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second) - @start
+    end
+  end
+end