openvox 8.19.0

data/lib/puppet/util/logging.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+# A module to make logging a bit easier.
+require_relative '../../puppet/util/log'
+require_relative '../../puppet/error'
+
+module Puppet::Util
+module Logging
+  def send_log(level, message)
+    Puppet::Util::Log.create({ :level => level, :source => log_source, :message => message }.merge(log_metadata))
+  end
+
+  # Create a method for each log level.
+  Puppet::Util::Log.eachlevel do |level|
+    # handle debug a special way for performance reasons
+    next if level == :debug
+
+    define_method(level) do |args|
+      args = args.join(" ") if args.is_a?(Array)
+      send_log(level, args)
+    end
+  end
+
+  # Output a debug log message if debugging is on (but only then)
+  # If the output is anything except a static string, give the debug
+  # a block - it will be called with all other arguments, and is expected
+  # to return the single string result.
+  #
+  # Use a block at all times for increased performance.
+  #
+  # @example This takes 40% of the time compared to not using a block
+  #  Puppet.debug { "This is a string that interpolated #{x} and #{y} }"
+  #
+  def debug(*args)
+    return nil unless Puppet::Util::Log.level == :debug
+
+    if block_given?
+      send_log(:debug, yield(*args))
+    else
+      send_log(:debug, args.join(" "))
+    end
+  end
+
+  # Log an exception via Puppet.err.  Will also log the backtrace if Puppet[:trace] is set.
+  # Parameters:
+  # [exception] an Exception to log
+  # [message] an optional String overriding the message to be logged; by default, we log Exception.message.
+  #    If you pass a String here, your string will be logged instead.  You may also pass nil if you don't
+  #    wish to log a message at all; in this case it is likely that you are only calling this method in order
+  #    to take advantage of the backtrace logging.
+  def log_exception(exception, message = :default, options = {})
+    level = options[:level] || :err
+    combined_trace = Puppet[:trace] || options[:trace]
+    puppet_trace = Puppet[:puppet_trace] || options[:puppet_trace]
+
+    if message == :default && exception.is_a?(Puppet::ParseErrorWithIssue)
+      # Retain all detailed info and keep plain message and stacktrace separate
+      backtrace = build_exception_trace(exception, combined_trace, puppet_trace)
+      Puppet::Util::Log.create({
+        :level => level,
+        :source => log_source,
+        :message => exception.basic_message,
+        :issue_code => exception.issue_code,
+        :backtrace => backtrace.empty? ? nil : backtrace,
+        :file => exception.file,
+        :line => exception.line,
+        :pos => exception.pos,
+        :environment => exception.environment,
+        :node => exception.node
+      }.merge(log_metadata))
+    else
+      send_log(level, format_exception(exception, message, combined_trace, puppet_trace))
+    end
+  end
+
+  def build_exception_trace(exception, combined_trace = true, puppet_trace = false)
+    built_trace = format_backtrace(exception, combined_trace, puppet_trace)
+
+    if exception.respond_to?(:original)
+      original = exception.original
+      unless original.nil?
+        built_trace << _('Wrapped exception:')
+        built_trace << original.message
+        built_trace += build_exception_trace(original, combined_trace, puppet_trace)
+      end
+    end
+
+    built_trace
+  end
+  private :build_exception_trace
+
+  def format_exception(exception, message = :default, combined_trace = true, puppet_trace = false)
+    arr = []
+    case message
+    when :default
+      arr << exception.message
+    when nil
+      # don't log anything if they passed a nil; they are just calling for the optional backtrace logging
+    else
+      arr << message
+    end
+
+    arr += format_backtrace(exception, combined_trace, puppet_trace)
+
+    if exception.respond_to?(:original) and exception.original
+      arr << _("Wrapped exception:")
+      arr << format_exception(exception.original, :default, combined_trace, puppet_trace)
+    end
+
+    arr.flatten.join("\n")
+  end
+
+  def format_backtrace(exception, combined_trace, puppet_trace)
+    puppetstack = exception.respond_to?(:puppetstack) ? exception.puppetstack : []
+
+    if combined_trace and exception.backtrace
+      Puppet::Util.format_backtrace_array(exception.backtrace, puppetstack)
+    elsif puppet_trace && !puppetstack.empty?
+      Puppet::Util.format_backtrace_array(puppetstack)
+    else
+      []
+    end
+  end
+
+  def log_and_raise(exception, message)
+    log_exception(exception, message)
+    raise exception, message + "\n" + exception.to_s, exception.backtrace
+  end
+
+  class DeprecationWarning < Exception; end # rubocop:disable Lint/InheritException
+
+  # Logs a warning indicating that the Ruby code path is deprecated.  Note that
+  # this method keeps track of the offending lines of code that triggered the
+  # deprecation warning, and will only log a warning once per offending line of
+  # code.  It will also stop logging deprecation warnings altogether after 100
+  # unique deprecation warnings have been logged.  Finally, if
+  # Puppet[:disable_warnings] includes 'deprecations', it will squelch all
+  # warning calls made via this method.
+  #
+  # @param message [String] The message to log (logs via warning)
+  # @param key [String] Optional key to mark the message as unique. If not
+  #   passed in, the originating call line will be used instead.
+  def deprecation_warning(message, key = nil)
+    issue_deprecation_warning(message, key, nil, nil, true)
+  end
+
+  # Logs a warning whose origin comes from Puppet source rather than somewhere
+  # internal within Puppet.  Otherwise the same as deprecation_warning()
+  #
+  # @param message [String] The message to log (logs via warning)
+  # @param options [Hash]
+  # @option options [String] :file File we are warning from
+  # @option options [Integer] :line Line number we are warning from
+  # @option options [String] :key (:file + :line) Alternative key used to mark
+  #   warning as unique
+  #
+  # Either :file and :line and/or :key must be passed.
+  def puppet_deprecation_warning(message, options = {})
+    key = options[:key]
+    file = options[:file]
+    line = options[:line]
+    # TRANSLATORS the literals ":file", ":line", and ":key" should not be translated
+    raise Puppet::DevError, _("Need either :file and :line, or :key") if key.nil? && (file.nil? || line.nil?)
+
+    key ||= "#{file}:#{line}"
+    issue_deprecation_warning(message, key, file, line, false)
+  end
+
+  # Logs a (non deprecation) warning once for a given key.
+  #
+  # @param kind [String] The kind of warning. The
+  #   kind must be one of the defined kinds for the Puppet[:disable_warnings] setting.
+  # @param message [String] The message to log (logs via warning)
+  # @param key [String] Key used to make this warning unique
+  # @param file [String,:default,nil] the File related to the warning
+  # @param line [Integer,:default,nil] the Line number related to the warning
+  #   warning as unique
+  # @param level [Symbol] log level to use, defaults to :warning
+  #
+  # Either :file and :line and/or :key must be passed.
+  def warn_once(kind, key, message, file = nil, line = nil, level = :warning)
+    return if Puppet[:disable_warnings].include?(kind)
+
+    $unique_warnings ||= {}
+    if $unique_warnings.length < 100 then
+      unless $unique_warnings.has_key?(key) then
+        $unique_warnings[key] = message
+        call_trace = if file == :default and line == :default
+                       # Suppress the file and line number output
+                       ''
+                     else
+                       error_location_str = Puppet::Util::Errors.error_location(file, line)
+                       if error_location_str.empty?
+                         "\n   " + _('(file & line not available)')
+                       else
+                         "\n   %{error_location}" % { error_location: error_location_str }
+                       end
+                     end
+        send_log(level, "#{message}#{call_trace}")
+      end
+    end
+  end
+
+  def get_deprecation_offender
+    # we have to put this in its own method to simplify testing; we need to be able to mock the offender results in
+    # order to test this class, and our framework does not appear to enjoy it if you try to mock Kernel.caller
+    #
+    # let's find the offending line;  we need to jump back up the stack a few steps to find the method that called
+    #  the deprecated method
+    if Puppet[:trace]
+      caller(3)
+    else
+      [caller(3, 1).first]
+    end
+  end
+
+  def clear_deprecation_warnings
+    $unique_warnings.clear if $unique_warnings
+    $deprecation_warnings.clear if $deprecation_warnings
+  end
+
+  # TODO: determine whether there might be a potential use for adding a puppet configuration option that would
+  # enable this deprecation logging.
+
+  # utility method that can be called, e.g., from spec_helper config.after, when tracking down calls to deprecated
+  # code.
+  # Parameters:
+  # [deprecations_file] relative or absolute path of a file to log the deprecations to
+  # [pattern] (default nil) if specified, will only log deprecations whose message matches the provided pattern
+  def log_deprecations_to_file(deprecations_file, pattern = nil)
+    # this method may get called lots and lots of times (e.g., from spec_helper config.after) without the global
+    # list of deprecation warnings being cleared out.  We don't want to keep logging the same offenders over and over,
+    # so, we need to keep track of what we've logged.
+    #
+    # It'd be nice if we could just clear out the list of deprecation warnings, but then the very next spec might
+    # find the same offender, and we'd end up logging it again.
+    $logged_deprecation_warnings ||= {}
+
+    # Deprecation messages are UTF-8 as they are produced by Ruby
+    Puppet::FileSystem.open(deprecations_file, nil, "a:UTF-8") do |f|
+      if $deprecation_warnings then
+        $deprecation_warnings.each do |offender, message|
+          next if $logged_deprecation_warnings.has_key?(offender)
+
+          $logged_deprecation_warnings[offender] = true
+          next unless pattern.nil? || (message =~ pattern)
+
+          f.puts(message)
+          f.puts(offender)
+          f.puts()
+        end
+      end
+    end
+  end
+
+  # Sets up Facter logging.
+  # This method causes Facter output to be forwarded to Puppet.
+  def self.setup_facter_logging!
+    Puppet.runtime[:facter]
+    true
+  end
+
+  private
+
+  def issue_deprecation_warning(message, key, file, line, use_caller)
+    return if Puppet[:disable_warnings].include?('deprecations')
+
+    $deprecation_warnings ||= {}
+    if $deprecation_warnings.length < 100
+      key ||= (offender = get_deprecation_offender)
+      unless $deprecation_warnings.has_key?(key)
+        $deprecation_warnings[key] = message
+        # split out to allow translation
+        call_trace = if use_caller
+                       _("(location: %{location})") % { location: (offender || get_deprecation_offender).join('; ') }
+                     else
+                       Puppet::Util::Errors.error_location_with_unknowns(file, line)
+                     end
+        warning("%{message}\n   %{call_trace}" % { message: message, call_trace: call_trace })
+      end
+    end
+  end
+
+  def is_resource?
+    defined?(Puppet::Type) && is_a?(Puppet::Type)
+  end
+
+  def is_resource_parameter?
+    defined?(Puppet::Parameter) && is_a?(Puppet::Parameter)
+  end
+
+  def log_metadata
+    [:file, :line, :tags].each_with_object({}) do |attr, result|
+      result[attr] = send(attr) if respond_to?(attr)
+    end
+  end
+
+  def log_source
+    # We need to guard the existence of the constants, since this module is used by the base Puppet module.
+    (is_resource? or is_resource_parameter?) and respond_to?(:path) and return path.to_s
+    to_s
+  end
+end
+end

data/lib/puppet/util/metaid.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def singleton_class; class << self; self; end; end
+  def meta_eval(&blk); singleton_class.instance_eval(&blk); end
+
+  # Adds methods to a singleton_class
+  def meta_def(name, &blk)
+    meta_eval { define_method name, &blk }
+  end
+
+  # Remove singleton_class methods.
+  def meta_undef(name, &blk)
+    meta_eval { remove_method name }
+  end
+
+  # Defines an instance method within a class
+  def class_def(name, &blk)
+    class_eval { define_method name, &blk }
+  end
+end

data/lib/puppet/util/metric.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# included so we can test object types
+require_relative '../../puppet'
+require_relative '../../puppet/network/format_support'
+
+# A class for handling metrics.  This is currently ridiculously hackish.
+class Puppet::Util::Metric
+  include Puppet::Util::PsychSupport
+  include Puppet::Network::FormatSupport
+
+  attr_accessor :type, :name, :value, :label
+  attr_writer :values
+
+  def self.from_data_hash(data)
+    metric = allocate
+    metric.initialize_from_hash(data)
+    metric
+  end
+
+  def initialize_from_hash(data)
+    @name = data['name']
+    @label = data['label'] || self.class.labelize(@name)
+    @values = data['values']
+  end
+
+  def to_data_hash
+    {
+      'name' => @name,
+      'label' => @label,
+      'values' => @values
+    }
+  end
+
+  # Return a specific value
+  def [](name)
+    value = @values.find { |v| v[0] == name }
+    if value
+      value[2]
+    else
+      0
+    end
+  end
+
+  def initialize(name, label = nil)
+    @name = name.to_s
+
+    @label = label || self.class.labelize(name)
+
+    @values = []
+  end
+
+  def newvalue(name, value, label = nil)
+    raise ArgumentError, "metric name #{name.inspect} is not a string" unless name.is_a? String
+
+    label ||= self.class.labelize(name)
+    @values.push [name, label, value]
+  end
+
+  def values
+    @values.sort_by { |a| a[1] }
+  end
+
+  # Convert a name into a label.
+  def self.labelize(name)
+    name.to_s.capitalize.tr("_", " ")
+  end
+end

data/lib/puppet/util/monkey_patches.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util/platform'
+
+module Puppet::Util::MonkeyPatches
+end
+
+begin
+  Process.maxgroups = 1024
+rescue NotImplementedError
+  # Actually, I just want to ignore it, since various platforms - JRuby,
+  # Windows, and so forth - don't support it, but only because it isn't a
+  # meaningful or implementable concept there.
+end
+
+module RDoc
+  def self.caller(skip = nil)
+    in_gem_wrapper = false
+    Kernel.caller.reject { |call|
+      in_gem_wrapper ||= call =~ /#{Regexp.escape $PROGRAM_NAME}:\d+:in `load'/
+    }
+  end
+end
+
+class Object
+  # ActiveSupport 2.3.x mixes in a dangerous method
+  # that can cause rspec to fork bomb
+  # and other strange things like that.
+  def daemonize
+    raise NotImplementedError, "Kernel.daemonize is too dangerous, please don't try to use it."
+  end
+end
+
+unless Dir.singleton_methods.include?(:exists?)
+  class Dir
+    def self.exists?(file_name)
+      warn("Dir.exists?('#{file_name}') is deprecated, use Dir.exist? instead") if $VERBOSE
+      Dir.exist?(file_name)
+    end
+  end
+end
+
+unless File.singleton_methods.include?(:exists?)
+  class File
+    def self.exists?(file_name)
+      warn("File.exists?('#{file_name}') is deprecated, use File.exist? instead") if $VERBOSE
+      File.exist?(file_name)
+    end
+  end
+end
+
+require_relative '../../puppet/ssl/openssl_loader'
+unless Puppet::Util::Platform.jruby_fips?
+  class OpenSSL::SSL::SSLContext
+    if DEFAULT_PARAMS[:options]
+      DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv3
+    else
+      DEFAULT_PARAMS[:options] = OpenSSL::SSL::OP_NO_SSLv3
+    end
+
+    alias __original_initialize initialize
+    private :__original_initialize
+
+    def initialize(*args)
+      __original_initialize(*args)
+      params = {
+        :options => DEFAULT_PARAMS[:options],
+        :ciphers => DEFAULT_PARAMS[:ciphers],
+      }
+      set_params(params)
+    end
+  end
+end
+
+if Puppet::Util::Platform.windows?
+  class OpenSSL::X509::Store
+    @puppet_certs_loaded = false
+    alias __original_set_default_paths set_default_paths
+    def set_default_paths
+      # This can be removed once openssl integrates with windows
+      # cert store, see https://rt.openssl.org/Ticket/Display.html?id=2158
+      unless @puppet_certs_loaded
+        @puppet_certs_loaded = true
+
+        Puppet::Util::Windows::RootCerts.instance.to_a.uniq(&:to_der).each do |x509|
+          add_cert(x509)
+        rescue OpenSSL::X509::StoreError
+          warn "Failed to add #{x509.subject.to_utf8}"
+        end
+      end
+
+      __original_set_default_paths
+    end
+  end
+end
+
+unless Puppet::Util::Platform.jruby_fips?
+  unless defined?(OpenSSL::X509::V_ERR_HOSTNAME_MISMATCH)
+    module OpenSSL::X509
+      OpenSSL::X509::V_ERR_HOSTNAME_MISMATCH = 0x3E
+    end
+  end
+
+  # jruby-openssl doesn't support this
+  unless OpenSSL::X509::Name.instance_methods.include?(:to_utf8)
+    class OpenSSL::X509::Name
+      def to_utf8
+        # https://github.com/ruby/ruby/blob/v2_5_5/ext/openssl/ossl_x509name.c#L317
+        str = to_s(OpenSSL::X509::Name::RFC2253)
+        str.force_encoding(Encoding::UTF_8)
+      end
+    end
+  end
+end

data/lib/puppet/util/multi_match.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# MultiMatch allows multiple values to be tested at once in a case expression.
+# This class is needed since Array does not implement the === operator to mean
+# "each v === other.each v".
+#
+# This class is useful in situations when the Puppet Type System cannot be used
+# (e.g. in Logging, since it needs to be able to log very early in the initialization
+# cycle of puppet)
+#
+# Typically used with the constants
+# NOT_NIL
+# TUPLE
+# TRIPLE
+#
+# which test against single NOT_NIL value, Array with two NOT_NIL, and Array with three NOT_NIL
+#
+module Puppet::Util
+class MultiMatch
+  attr_reader :values
+
+  def initialize(*values)
+    @values = values
+  end
+
+  def ===(other)
+    lv = @values # local var is faster than instance var
+    case other
+    when MultiMatch
+      return false unless other.values.size == values.size
+
+      other.values.each_with_index { |v, i| return false unless lv[i] === v || v === lv[i] }
+    when Array
+      return false unless other.size == values.size
+
+      other.each_with_index { |v, i| return false unless lv[i] === v || v === lv[i] }
+    else
+      false
+    end
+    true
+  end
+
+  # Matches any value that is not nil using the === operator.
+  #
+  class MatchNotNil
+    def ===(v)
+      !v.nil?
+    end
+  end
+
+  NOT_NIL = MatchNotNil.new().freeze
+  TUPLE = MultiMatch.new(NOT_NIL, NOT_NIL).freeze
+  TRIPLE = MultiMatch.new(NOT_NIL, NOT_NIL, NOT_NIL).freeze
+end
+end

data/lib/puppet/util/network_device/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/autoload'
+require 'uri'
+require_relative '../../../puppet/util/network_device/transport'
+require_relative '../../../puppet/util/network_device/transport/base'
+
+class Puppet::Util::NetworkDevice::Base
+  attr_accessor :url, :transport
+
+  def initialize(url, options = {})
+    @url = URI.parse(url)
+
+    @autoloader = Puppet::Util::Autoload.new(self, "puppet/util/network_device/transport")
+
+    if @autoloader.load(@url.scheme, Puppet.lookup(:current_environment))
+      @transport = Puppet::Util::NetworkDevice::Transport.const_get(@url.scheme.capitalize).new(options[:debug])
+      @transport.host = @url.host
+      @transport.port = @url.port || case @url.scheme; when "ssh"; 22; when "telnet"; 23; end
+      @transport.user = @url.user
+      @transport.password = @url.password
+    end
+  end
+end

data/lib/puppet/util/network_device/config.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require_relative '../../../puppet/util/watched_file'
+require_relative '../../../puppet/util/network_device'
+
+class Puppet::Util::NetworkDevice::Config
+  def self.main
+    @main ||= new
+  end
+
+  def self.devices
+    main.devices || []
+  end
+
+  attr_reader :devices
+
+  def exists?
+    Puppet::FileSystem.exist?(@file.to_str)
+  end
+
+  def initialize
+    @file = Puppet::Util::WatchedFile.new(Puppet[:deviceconfig])
+
+    @devices = {}
+
+    read(true) # force reading at start
+  end
+
+  # Read the configuration file.
+  def read(force = false)
+    return unless exists?
+
+    parse if force or @file.changed?
+  end
+
+  private
+
+  def parse
+    begin
+      devices = {}
+      device = nil
+      File.open(@file) do |f|
+        file_line_count = 1
+        f.each do |line|
+          case line
+          when /^\s*#/ # skip comments
+            file_line_count += 1
+            next
+          when /^\s*$/ # skip blank lines
+            file_line_count += 1
+            next
+          when /^\[([\w.-]+)\]\s*$/ # [device.fqdn]
+            name = ::Regexp.last_match(1)
+            name.chomp!
+            if devices.include?(name)
+              file_error_location = Puppet::Util::Errors.error_location(nil, file_line_count)
+              device_error_location = Puppet::Util::Errors.error_location(nil, device.line)
+              raise Puppet::Error, _("Duplicate device found at %{file_error_location}, already found at %{device_error_location}") %
+                                   { file_error_location: file_error_location, device_error_location: device_error_location }
+            end
+            device = OpenStruct.new
+            device.name = name
+            device.line = file_line_count
+            device.options = { :debug => false }
+            Puppet.debug "found device: #{device.name} at #{device.line}"
+            devices[name] = device
+          when /^\s*(type|url|debug)(\s+(.+)\s*)*$/
+            parse_directive(device, ::Regexp.last_match(1), ::Regexp.last_match(3), file_line_count)
+          else
+            error_location_str = Puppet::Util::Errors.error_location(nil, file_line_count)
+            raise Puppet::Error, _("Invalid entry at %{error_location}: %{file_text}") %
+                                 { error_location: error_location_str, file_text: line }
+          end
+        end
+      end
+    rescue Errno::EACCES
+      Puppet.err _("Configuration error: Cannot read %{file}; cannot serve") % { file: @file }
+      # raise Puppet::Error, "Cannot read #{@config}"
+    rescue Errno::ENOENT
+      Puppet.err _("Configuration error: '%{file}' does not exit; cannot serve") % { file: @file }
+    end
+
+    @devices = devices
+  end
+
+  def parse_directive(device, var, value, count)
+    case var
+    when "type"
+      device.provider = value
+    when "url"
+      begin
+        URI.parse(value)
+      rescue URI::InvalidURIError
+        raise Puppet::Error, _("%{value} is an invalid url") % { value: value }
+      end
+      device.url = value
+    when "debug"
+      device.options[:debug] = true
+    else
+      error_location_str = Puppet::Util::Errors.error_location(nil, count)
+      raise Puppet::Error, _("Invalid argument '%{var}' at %{error_location}") % { var: var, error_location: error_location_str }
+    end
+  end
+end