facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/lib/custom_facts/core/logging.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module LegacyFacter
+  module Core
+    module Logging
+      extend self
+
+      # @api private
+      GREEN = "\e[0;32m"
+      # @api private
+      RESET = "\e[0m"
+
+      RED = "\e[31m"
+
+      # @api private
+      @@debug = false
+      # @api private
+      @@timing = false
+      # @api private
+      @@trace = false
+
+      # @api private
+      @@warn_messages = {}
+      # @api private
+      @@debug_messages = {}
+
+      # @api private
+      @@message_callback = nil
+
+      # Used to register a callback that is called when a message is logged.
+      # If a block is given, Facter will not log messages.
+      # If a block is not given, Facter will resume logging messages.
+      # @param block [Proc] the callback to call when a message is logged.
+      #   The first argument to the callback will be a symbol representing a level. The supported
+      #   levels are: :trace, :debug, :info, :warn, :error, and :fatal.
+      #   The second argument to the callback will be a string containing the message
+      #   that was logged.
+      # @api public
+      def on_message(&block)
+        @@message_callback = block
+      end
+
+      # Prints a debug message if debugging is turned on
+      #
+      # @param msg [String] the debug message
+      # @return [void]
+      def debug(msg)
+        return unless debugging?
+
+        if msg.nil? || msg.empty?
+          invoker = caller[0].slice(/.*:\d+/)
+          self.warn "#{self.class}#debug invoked with invalid message #{msg.inspect}:#{msg.class} at #{invoker}"
+        elsif @@message_callback
+          @@message_callback.call(:debug, msg)
+        else
+          puts GREEN + msg + RESET
+        end
+      end
+
+      # Prints a debug message only once.
+      #
+      # @note Uniqueness is based on the string, not the specific location
+      #   of the method call.
+      #
+      # @param msg [String] the debug message
+      # @return [void]
+      def debugonce(msg)
+        return unless msg && !msg.empty? && @@debug_messages[msg].nil?
+
+        @@debug_messages[msg] = true
+        debug(msg)
+      end
+
+      # Prints a warning message. The message is only printed if debugging
+      # is enabled.
+      #
+      # @param msg [String] the warning message to be printed
+      #
+      # @return [void]
+      def warn(msg)
+        if msg.nil? || msg.empty?
+          invoker = caller[0].slice(/.*:\d+/)
+          msg = "#{self.class}#debug invoked with invalid message #{msg.inspect}:#{msg.class} at #{invoker}"
+        end
+        if @@message_callback
+          @@message_callback.call(:warn, msg)
+        else
+          Kernel.warn msg
+        end
+      end
+
+      # Prints a warning message only once per process. Each unique string
+      # is printed once.
+      #
+      # @note Unlike {warn} the message will be printed even if debugging is
+      #   not turned on. This behavior is likely to change and should not be
+      #   relied on.
+      #
+      # @param msg [String] the warning message to be printed
+      #
+      # @return [void]
+      def warnonce(msg)
+        return unless @@warn_messages[msg].nil?
+
+        self.warn(msg)
+        @@warn_messages[msg] = true
+      end
+
+      def log_exception(exception, message = :default)
+        self.warn(format_exception(exception, message, @@trace))
+      end
+
+      def format_exception(exception, message, trace)
+        arr = []
+
+        if message == :default
+          arr << exception.message
+        elsif message
+          arr << message
+        end
+
+        arr.concat(exception.backtrace) if trace
+
+        "#{RED}#{arr.flatten.join("\n")}#{RESET}"
+      end
+
+      # Print an exception message, and optionally a backtrace if trace is set
+
+      # Print timing information
+      #
+      # @param string [String] the time to print
+      # @return [void]
+      #
+      # @api private
+      def show_time(string)
+        return unless string && timing?
+
+        if @@message_callback
+          @@message_callback.call(:info, string)
+        else
+          $stderr.puts "#{GREEN}#{string}#{RESET}"
+        end
+      end
+
+      # Enable or disable logging of debug messages
+      #
+      # @param bool [true, false]
+      # @return [void]
+      #
+      # @api private
+      def debugging(bool)
+        @@debug = bool
+      end
+
+      # Is debugging enabled?
+      #
+      # @return [true, false]
+      #
+      # @api private
+      def debugging?
+        @@debug
+      end
+
+      # Enable or disable logging of timing information
+      #
+      # @param bool [true, false]
+      # @return [void]
+      #
+      # @api private
+      def timing(bool)
+        @@timing = bool
+      end
+
+      # Returns whether timing output is turned on
+      #
+      # @api private
+      def timing?
+        @@timing
+      end
+
+      def trace(bool)
+        @@trace = bool
+      end
+
+      def trace?
+        @@trace
+      end
+
+      # Clears the seen state of debug and warning messages. See {debugonce} and {warnonce}.
+      #
+      # @return [void]
+      #
+      # @api private
+      def clear_messages
+        @@debug_messages.clear
+        @@warn_messages.clear
+      end
+    end
+  end
+end

data/lib/custom_facts/core/resolvable.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+# The resolvable mixin defines behavior for evaluating and returning fact
+# resolutions.
+#
+# Classes including this mixin should implement at #name method describing
+# the value being resolved and a #resolve_value that actually executes the code
+# to resolve the value.
+module LegacyFacter
+  module Core
+    module Resolvable
+      # The timeout, in seconds, for evaluating this resolution.
+      # @return [Integer]
+      # @api public
+      attr_accessor :timeout
+
+      # Return the timeout period for resolving a value.
+      # (see #timeout)
+      # @return [Numeric]
+      # @comment requiring 'timeout' stdlib class causes Object#timeout to be
+      #   defined which delegates to Timeout.timeout. This method may potentially
+      #   overwrite the #timeout attr_reader on this class, so we define #limit to
+      #   avoid conflicts.
+      def limit
+        @timeout || 0
+      end
+
+      ##
+      # on_flush accepts a block and executes the block when the resolution's value
+      # is flushed.  This makes it possible to model a single, expensive system
+      # call inside of a Ruby object and then define multiple dynamic facts which
+      # resolve by sending messages to the model instance.  If one of the dynamic
+      # facts is flushed then it can, in turn, flush the data stored in the model
+      # instance to keep all of the dynamic facts in sync without making multiple,
+      # expensive, system calls.
+      #
+      # Please see the Solaris zones fact for an example of how this feature may be
+      # used.
+      #
+      # @see Facter::Util::Fact#flush
+      # @see Facter::Util::Resolution#flush
+      #
+      # @api public
+      def on_flush(&block)
+        @on_flush_block = block
+      end
+
+      ##
+      # flush executes the block, if any, stored by the {on_flush} method
+      #
+      # @see Facter::Util::Fact#flush
+      # @see Facter::Util::Resolution#on_flush
+      #
+      # @api private
+      def flush
+        @on_flush_block&.call
+      end
+
+      def value
+        result = nil
+
+        with_timing do
+          Timeout.timeout(limit) do
+            result = resolve_value
+          end
+        end
+
+        LegacyFacter::Util::Normalization.normalize(result)
+      rescue Timeout::Error => e
+        LegacyFacter.log_exception(e, "Timed out after #{limit} seconds while resolving #{qualified_name}")
+        nil
+      rescue LegacyFacter::Util::Normalization::NormalizationError => e
+        LegacyFacter.log_exception(e, "Fact resolution #{qualified_name} resolved to an invalid value: #{e.message}")
+        nil
+      rescue StandardError => e
+        LegacyFacter.log_exception(e, "error while resolving custom fact #{qualified_name}: #{e.message}")
+        nil
+      end
+
+      private
+
+      def with_timing
+        starttime = Time.now.to_f
+
+        yield
+
+        finishtime = Time.now.to_f
+        ms = (finishtime - starttime) * 1000
+        LegacyFacter.show_time format('%<qn>s: %<ms>.2fms', qn: qualified_name, ms: ms)
+      end
+
+      def qualified_name
+        "fact='#{@fact.name}', resolution='#{@name || '<anonymous>'}'"
+      end
+    end
+  end
+end

data/lib/custom_facts/core/suitable.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# The Suitable mixin provides mechanisms for confining objects to run on
+# certain platforms and determining the run precedence of these objects.
+#
+# Classes that include the Suitable mixin should define a `#confines` method
+# that returns an Array of zero or more Facter::Util::Confine objects.
+module LegacyFacter
+  module Core
+    module Suitable
+      # Sets the weight of this resolution. If multiple suitable resolutions
+      # are found, the one with the highest weight will be used.  If weight
+      # is not given, the number of confines set on a resolution will be
+      # used as its weight (so that the most specific resolution is used).
+      #
+      # @param weight [Integer] the weight of this resolution
+      #
+      # @return [void]
+      #
+      # @api public
+      def has_weight(weight)
+        @weight = weight
+      end
+
+      # Sets the conditions for this resolution to be used.  This method accepts
+      # multiple forms of arguments to determine suitability.
+      #
+      # @return [void]
+      #
+      # @api public
+      #
+      # @overload confine(confines)
+      #   Confine a fact to a specific fact value or values.  This form takes a
+      #   hash of fact names and values. Every fact must match the values given for
+      #   that fact, otherwise this resolution will not be considered suitable. The
+      #   values given for a fact can be an array, in which case the value of the
+      #   fact must be in the array for it to match.
+      #   @param [Hash{String,Symbol=>String,Array<String>}] confines set of facts identified by the hash keys whose
+      #     fact value must match the argument value.
+      #   @example Confining to Linux
+      #       Facter.add(:powerstates) do
+      #         # This resolution only makes sense on linux systems
+      #         confine :kernel => "Linux"
+      #         setcode do
+      #           File.read('/sys/power/states')
+      #         end
+      #       end
+      #
+      # @overload confine(confines, &block)
+      #   Confine a fact to a block with the value of a specified fact yielded to
+      #   the block.
+      #   @param [String,Symbol] confines the fact name whose value should be
+      #     yielded to the block
+      #   @param [Proc] block determines the suitability of the fact.  If the block
+      #     evaluates to `false` or `nil` then the confined fact will not be
+      #     evaluated.
+      #   @yield [value] the value of the fact identified by {confines}
+      #   @example Confine the fact to a host with an ipaddress in a specific
+      #     subnet
+      #       confine :ipaddress do |addr|
+      #         require 'ipaddr'
+      #         IPAddr.new('192.168.0.0/16').include? addr
+      #       end
+      #
+      # @overload confine(&block)
+      #   Confine a fact to a block.  The fact will be evaluated only if the block
+      #   evaluates to something other than `false` or `nil`.
+      #   @param [Proc] block determines the suitability of the fact.  If the block
+      #     evaluates to `false` or `nil` then the confined fact will not be
+      #     evaluated.
+      #   @example Confine the fact to systems with a specific file.
+      #       confine { File.exist? '/bin/foo' }
+      def confine(confines = nil, &block)
+        case confines
+        when Hash
+          confines.each do |fact, values|
+            @confines.push LegacyFacter::Util::Confine.new(fact, *values)
+          end
+        else
+          if block
+            if confines
+              @confines.push LegacyFacter::Util::Confine.new(confines, &block)
+            else
+              @confines.push LegacyFacter::Util::Confine.new(&block)
+            end
+          end
+        end
+      end
+
+      # Returns the importance of this resolution. If the weight was not
+      # given, the number of confines is used instead (so that a more
+      # specific resolution wins over a less specific one).
+      #
+      # @return [Integer] the weight of this resolution
+      #
+      # @api private
+      def weight
+        @weight || @confines.length
+      end
+
+      # Is this resolution mechanism suitable on the system in question?
+      #
+      # @api private
+      def suitable?
+        @confines.all?(&:true?)
+      end
+    end
+  end
+end

data/lib/custom_facts/util/collection.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+# Manage which facts exist and how we access them.  Largely just a wrapper
+# around a hash of facts.
+#
+# @api private
+module LegacyFacter
+  module Util
+    class Collection
+      def initialize(internal_loader, external_loader)
+        @facts = {}
+        @internal_loader = internal_loader
+        @external_loader = external_loader
+      end
+
+      # Return a fact object by name.
+      def [](name)
+        value(name)
+      end
+
+      # Define a new fact or extend an existing fact.
+      #
+      # @param name [Symbol] The name of the fact to define
+      # @param options [Hash] A hash of options to set on the fact
+      #
+      # @return [LegacyFacter::Util::Fact] The fact that was defined
+      def define_fact(name, options = {}, &block)
+        fact = create_or_return_fact(name, options)
+
+        fact.instance_eval(&block) if block_given?
+
+        fact
+      rescue StandardError => e
+        LegacyFacter.log_exception(e, "Unable to add fact #{name}: #{e}")
+      end
+
+      # Add a resolution mechanism for a named fact.  This does not distinguish
+      # between adding a new fact and adding a new way to resolve a fact.
+      #
+      # @param name [Symbol] The name of the fact to define
+      # @param options [Hash] A hash of options to set on the fact and resolution
+      #
+      # @return [LegacyFacter::Util::Fact] The fact that was defined
+      def add(name, options = {}, &block)
+        fact = create_or_return_fact(name, options)
+
+        fact.add(options, &block)
+
+        fact
+      end
+
+      include Enumerable
+
+      # Iterate across all of the facts.
+      def each
+        load_all
+        @facts.each do |name, fact|
+          value = fact.value
+          yield name.to_s, value unless value.nil?
+        end
+      end
+
+      # Return a fact by name.
+      def fact(name)
+        name = canonicalize(name)
+
+        # Try to load the fact if necessary
+        load(name) unless @facts[name]
+
+        # Try HARDER
+        internal_loader.load_all unless @facts[name]
+
+        if @facts.empty?
+          LegacyFacter.warnonce("No facts loaded from #{internal_loader.search_path.join(File::PATH_SEPARATOR)}")
+        end
+
+        @facts[name]
+      end
+
+      # Flush all cached values.
+      def flush
+        @facts.each { |_name, fact| fact.flush }
+        @external_facts_loaded = nil
+      end
+
+      # Return a list of all of the facts.
+      def list
+        load_all
+        @facts.keys
+      end
+
+      # Build a hash of external facts
+      def external_facts
+        return @external_facts unless @external_facts.nil?
+
+        load_external_facts
+        external_facts = @facts.reject { |_k, v| v.options[:fact_type] }
+        @external_facts = Facter::Utils.deep_copy(external_facts.keys)
+      end
+
+      # Builds a hash of custom facts
+      def custom_facts
+        return @custom_facts unless @custom_facts.nil?
+
+        internal_loader.load_all
+        custom_facts = @facts.select { |_k, v| v.options[:fact_type] }
+        @custom_facts = Facter::Utils.deep_copy(custom_facts.keys)
+      end
+
+      def load(name)
+        internal_loader.load(name)
+        load_external_facts
+      end
+
+      # Load all known facts.
+      def load_all
+        internal_loader.load_all
+        load_external_facts
+      end
+
+      attr_reader :internal_loader
+
+      attr_reader :external_loader
+
+      # Return a hash of all of our facts.
+      def to_hash
+        @facts.each_with_object({}) do |ary, h|
+          value = ary[1].value
+          unless value.nil?
+            # For backwards compatibility, convert the fact name to a string.
+            h[ary[0].to_s] = value
+          end
+        end
+      end
+
+      def value(name)
+        fact = fact(name)
+
+        return Facter.core_value(name) if fact.nil?
+
+        value = fact&.value
+        weight = fact&.used_resolution_weight || 0
+
+        core_value = Facter.core_value(name)
+        return core_value if weight <= 0 && core_value
+
+        value
+      end
+
+      private
+
+      def create_or_return_fact(name, options)
+        name = canonicalize(name)
+
+        fact = @facts[name]
+
+        if fact.nil?
+          fact = LegacyFacter::Util::Fact.new(name, options)
+          @facts[name] = fact
+        else
+          fact.extract_ldapname_option!(options)
+        end
+
+        fact
+      end
+
+      def canonicalize(name)
+        name.to_s.downcase.to_sym
+      end
+
+      def load_external_facts
+        return if @external_facts_loaded
+
+        @external_facts_loaded = true
+        external_loader.load(self)
+      end
+    end
+  end
+end