openfact 5.0.0.rc0

data/lib/facter/custom_facts/util/fact.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+# This class represents a fact. Each fact has a name and multiple
+# {Facter::Util::Resolution resolutions}.
+#
+# Create facts using {Facter.add}
+#
+# @api public
+module Facter
+  module Util
+    class Fact
+      # The location from where fact is resolved
+      # @return [String]
+      attr_reader :location
+
+      # The name of the fact
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      # @deprecated
+      attr_accessor :ldapname
+
+      # Fact options e.g. fact_type
+      attr_accessor :options
+
+      # Weight of the resolution that was used to obtain the fact value
+      attr_accessor :used_resolution_weight
+
+      # Creates a new fact, with no resolution mechanisms. See {Facter.add}
+      # for the public API for creating facts.
+      # @param name [String] the fact name
+      # @param options [Hash] optional parameters
+      # @option options [String] :ldapname set the ldapname property on the fact
+      #
+      # @api private
+      def initialize(name, options = {})
+        @name = LegacyFacter::Util::Normalization.normalize(name.to_s.downcase).intern
+
+        @options = options.dup
+        extract_ldapname_option!(options)
+
+        @ldapname ||= @name.to_s
+
+        @resolves = []
+        @searching = false
+        @used_resolution_weight = 0
+
+        @value = nil
+      end
+
+      # Adds a new {Facter::Util::Resolution resolution}.  This requires a
+      # block, which will then be evaluated in the context of the new
+      # resolution.
+      #
+      # @param options [Hash] A hash of options to set on the resolution
+      #
+      # @return [Facter::Util::Resolution]
+      #
+      # @api private
+      def add(options = {}, &block)
+        @options = @options.merge(options)
+
+        @location = options[:file]
+        @location ||= block.source_location if block_given?
+
+        define_resolution(nil, options, &block)
+      end
+
+      # Define a new named resolution or return an existing resolution with
+      # the given name.
+      #
+      # @param resolution_name [String] The name of the resolve to define or look up
+      # @param options [Hash] A hash of options to set on the resolution
+      # @return [Facter::Util::Resolution]
+      #
+      # @api public
+      def define_resolution(resolution_name, options = {}, &block)
+        resolution_type = options.delete(:type) || :simple
+
+        resolve = create_or_return_resolution(resolution_name, resolution_type)
+
+        resolve.options(options) unless options.empty?
+        resolve.evaluate(&block) if block
+
+        resolve
+      rescue StandardError => e
+        msg = "Unable to add resolve #{resolution_name.inspect} for fact '#{@name}': #{e.message}"
+        msg += "\n#{e.backtrace.join("\n")}" if Options[:trace]
+        log.error(msg, true)
+        nil
+      end
+
+      # Retrieve an existing resolution by name
+      #
+      # @param name [String]
+      #
+      # @return [Facter::Util::Resolution, nil] The resolution if exists, nil if
+      #   it doesn't exist or name is nil
+      def resolution(name)
+        return nil if name.nil?
+
+        @resolves.find { |resolve| resolve.name == name }
+      end
+
+      # Flushes any cached values.
+      #
+      # @return [void]
+      #
+      # @api private
+      def flush
+        @resolves.each(&:flush)
+        @value = nil
+      end
+
+      # Returns the value for this fact. This searches all resolutions by
+      # suitability and weight (see {Facter::Util::Resolution}). If no
+      # suitable resolution is found, it returns nil.
+      #
+      # @api public
+      def value
+        return @value unless @value.nil?
+
+        if @resolves.empty?
+          log.debug format('No resolves for %<name>s', name: @name)
+          return nil
+        end
+
+        searching do
+          suitable_resolutions = sort_by_weight(find_suitable_resolutions(@resolves))
+
+          Facter::Framework::Benchmarking::Timer.measure(@name) do
+            @value = find_first_real_value(suitable_resolutions)
+          end
+
+          announce_when_no_suitable_resolution(suitable_resolutions)
+          announce_when_no_value_found(@value)
+
+          @value = resolve_value
+        end
+
+        @value
+      end
+
+      # @api private
+      # @deprecated
+      def extract_ldapname_option!(options)
+        return unless options[:ldapname]
+
+        log.warnonce('ldapname is deprecated and will be removed in a future version')
+        self.ldapname = options.delete(:ldapname)
+      end
+
+      private
+
+      def log
+        @log ||= Facter::Log.new(self)
+      end
+
+      def resolve_value
+        return Facter.core_value(name) if @value.nil?
+
+        core_value = Facter.core_value(name) if @used_resolution_weight <= 0
+        core_value.nil? ? @value : core_value
+      end
+
+      # Are we in the midst of a search?
+      def searching?
+        @searching
+      end
+
+      # Lock our searching process, so we never get stuck in recursion.
+      def searching
+        raise "Caught recursion on #{@name}" if searching?
+
+        # If we've gotten this far, we're not already searching, so go ahead and do so.
+        @searching = true
+        begin
+          yield
+        ensure
+          @searching = false
+        end
+      end
+
+      def find_suitable_resolutions(resolutions)
+        resolutions.find_all(&:suitable?)
+      end
+
+      def sort_by_weight(resolutions)
+        # sort resolutions:
+        # - descending by weight
+        # - multiple facts have the same weight but different types, the :external fact take precedence
+        # - multiple facts with the same weight and type, the order is preserved.
+        # note: sort_by with index is slower than .sort
+        # we cannot use .sort because it is not stable: https://bugs.ruby-lang.org/issues/1089
+        # solution from: https://bugs.ruby-lang.org/issues/1089#note-10
+
+        # rubocop:disable Style/NestedTernaryOperator
+        idx = 0
+        resolutions.sort_by do |x|
+          [
+            -x.weight,
+            x.respond_to?(:fact_type) ? x.fact_type == :external ? 0 : 1 : 1,
+            idx += 1
+          ]
+        end
+        # rubocop:enable Style/NestedTernaryOperator
+      end
+
+      def find_first_real_value(resolutions)
+        resolutions.each do |resolve|
+          begin
+            value = resolve.value
+          rescue Facter::ResolveCustomFactError
+            break
+          end
+          @used_resolution_weight = resolve.weight
+          next if value.nil?
+
+          log_fact_path(resolve)
+
+          return value
+        end
+        nil
+      end
+
+      def log_fact_path(resolve)
+        log.debug("#{resolve.fact_type} fact #{resolve.fact.name} was resolved from: #{resolve.last_evaluated}")
+      end
+
+      def announce_when_no_suitable_resolution(resolutions)
+        return unless resolutions.empty?
+
+        log.debug format('Found no suitable resolves of %<resolver_length> for %<name>s',
+                         resolver_length: @resolves.length, name: @name)
+      end
+
+      def announce_when_no_value_found(value)
+        log.debug(format('value for %<name>s is still nil', name: @name)) if value.nil?
+      end
+
+      def create_or_return_resolution(resolution_name, resolution_type)
+        resolve = resolution(resolution_name)
+
+        if resolve
+          if resolution_type != resolve.resolution_type
+            raise ArgumentError, "Cannot return resolution #{resolution_name} with type" \
+                                 " #{resolution_type}; already defined as #{resolve.resolution_type}"
+          end
+        else
+          case resolution_type
+          when :simple
+            resolve = Facter::Util::Resolution.new(resolution_name, self)
+          when :aggregate
+            resolve = Facter::Core::Aggregate.new(resolution_name, self)
+          else
+            raise ArgumentError,
+                  "Expected resolution type to be one of (:simple, :aggregate) but was #{resolution_type}"
+          end
+
+          @resolves << resolve
+        end
+
+        resolve
+      end
+    end
+  end
+end

data/lib/facter/custom_facts/util/loader.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Load facts on demand.
+module LegacyFacter
+  module Util
+    class Loader
+      def initialize(environment_vars = ENV)
+        @loaded = []
+        @environment_vars = environment_vars
+      end
+
+      # Load all resolutions for a single fact.
+      #
+      # @api public
+      # @param name [Symbol]
+      def load(fact)
+        # Now load from the search path
+        shortname = fact.to_s.downcase
+        load_env(shortname)
+
+        filename = "#{shortname}.rb"
+
+        paths = search_path
+        paths&.each do |dir|
+          # Load individual files
+          file = File.join(dir, filename)
+
+          load_file(file) if FileTest.file?(file)
+        end
+      end
+
+      # Load all facts from all directories.
+      #
+      # @api public
+      def load_all
+        return if defined?(@loaded_all)
+
+        load_env
+
+        paths = search_path
+        paths&.each do |dir|
+          # clean the search path of wrong slashes and backslashes
+          dir = dir.gsub(%r{[/\\]+}, File::SEPARATOR)
+          # dir is already an absolute path
+          Dir.glob(File.join(dir, '*.rb')).each do |path|
+            # exclude dirs that end with .rb
+            load_file(path) if FileTest.file?(path)
+          end
+        end
+
+        @loaded_all = true
+      end
+
+      # List directories to search for fact files.
+      #
+      # Search paths are gathered from the following sources:
+      #
+      # 1. $LOAD_PATH entries are expanded to absolute paths
+      # 2. ENV['FACTERLIB'] is split and used verbatim
+      # 3. Entries from Facter.search_path are used verbatim
+      #
+      # @api public
+      # @return [Array<String>]
+      def search_path
+        search_paths = []
+        search_paths += $LOAD_PATH.map { |path| File.expand_path('facter', path) }
+
+        if @environment_vars.include?('FACTERLIB')
+          search_paths += @environment_vars['FACTERLIB'].split(File::PATH_SEPARATOR)
+        end
+
+        Facter::Options.custom_dir.each do |path|
+          search_paths << path
+        end
+
+        search_paths.delete_if { |path| !File.directory?(path) }
+
+        search_paths.uniq
+      end
+
+      private
+
+      def log
+        @log ||= Facter::Log.new(self)
+      end
+
+      # Load a file and record is paths to prevent duplicate loads.
+      #
+      # @api private
+      # @params file [String] The *absolute path* to the file to load
+      def load_file(file)
+        return if @loaded.include? file
+
+        # We have to specify Kernel.load, because we have a load method.
+        begin
+          # Store the file path so we don't try to reload it
+          @loaded << file
+          kernel_load(file)
+        rescue ScriptError => e
+          # Don't store the path if the file can't be loaded
+          # in case it's loadable later on.
+          @loaded.delete(file)
+          Facter.log_exception(e, "Error loading fact #{file}: #{e.message}")
+        rescue StandardError => e
+          Facter.log_exception(e, "error while resolving custom facts in #{file} #{e.message}")
+        end
+      end
+
+      # Load and execute the Ruby program specified in the file. This exists
+      # for testing purposes.
+      #
+      # @api private
+      # @return [Boolean]
+      def kernel_load(file)
+        Kernel.load(file)
+      end
+
+      # Load facts from the environment.  If no name is provided,
+      # all will be loaded.
+      def load_env(fact = nil)
+        # Load from the environment, if possible
+        @environment_vars.each do |name, value|
+          # Skip anything that doesn't match our regex.
+          next unless name =~ /^facter_?(\w+)$/i
+
+          env_name = Regexp.last_match(1).downcase
+
+          # If a fact name was specified, skip anything that doesn't
+          # match it.
+          next if fact && (env_name != fact)
+
+          LegacyFacter.add(env_name, fact_type: :external, is_env: true) do
+            has_weight 1_000_000
+            setcode { value }
+          end
+
+          # Short-cut, if we are only looking for one value.
+          break if fact
+        end
+      end
+    end
+  end
+end

data/lib/facter/custom_facts/util/normalization.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module LegacyFacter
+  module Util
+    module Normalization
+      class NormalizationError < StandardError; end
+
+      # load Date and Time classes
+      require 'time'
+
+      VALID_TYPES = [Integer, Float, TrueClass, FalseClass, NilClass, Symbol, String, Array, Hash, Date, Time].freeze
+
+      module_function
+
+      # Recursively normalize the given data structure
+      #
+      # @api public
+      # @raise [NormalizationError] If the data structure contained an invalid element.
+      # @return [void]
+      def normalize(value)
+        case value
+        when Integer, Float, TrueClass, FalseClass, NilClass, Symbol
+          value
+        when Date, Time
+          value.iso8601
+        when String
+          normalize_string(value)
+        when Array
+          normalize_array(value)
+        when Hash
+          normalize_hash(value)
+        else
+          raise NormalizationError, "Expected #{value} to be one of #{VALID_TYPES.inspect}, but was #{value.class}"
+        end
+      end
+
+      # @!method normalize_string(value)
+      #
+      # Attempt to normalize and validate the given string.
+      #
+      # The string is validated by checking that the string encoding
+      # is UTF-8 and that the string content matches the encoding. If the string
+      # is not an expected encoding then it is converted to UTF-8.
+      #
+      # @api public
+      # @raise [NormalizationError] If the string used an unsupported encoding or did not match its encoding
+      # @param value [String]
+      # @return [void]
+
+      def normalize_string(value)
+        value = value.encode(Encoding::UTF_8)
+
+        unless value.valid_encoding?
+          raise NormalizationError, "String #{value.inspect} doesn't match the reported encoding #{value.encoding}"
+        end
+
+        if value.codepoints.include?(0)
+          raise NormalizationError, "String #{value.inspect} contains a null byte reference; unsupported for all facts."
+        end
+
+        value
+      rescue EncodingError
+        raise NormalizationError, "String encoding #{value.encoding} is not UTF-8 and could not be converted to UTF-8"
+      end
+
+      # Validate all elements of the array.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the elements failed validation
+      # @param value [Array]
+      # @return [void]
+      def normalize_array(value)
+        value.collect do |elem|
+          normalize(elem)
+        end
+      end
+
+      # Validate all keys and values of the hash.
+      #
+      # @api public
+      # @raise [NormalizationError] If one of the keys or values failed normalization
+      # @param value [Hash]
+      # @return [void]
+      def normalize_hash(value)
+        Hash[value.collect { |k, v| [normalize(k), normalize(v)] }]
+      end
+    end
+  end
+end

data/lib/facter/custom_facts/util/nothing_loader.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module LegacyFacter
+  module Util
+    # An external fact loader that doesn't load anything
+    # This makes it possible to disable loading
+    # of external facts
+    class NothingLoader
+      def load(collection); end
+    end
+  end
+end