facter 4.0.28

data/lib/custom_facts/util/confine.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# A restricting tag for fact resolution mechanisms.  The tag must be true
+# for the resolution mechanism to be suitable.
+
+module LegacyFacter
+  module Util
+    class Confine
+      attr_accessor :fact, :values
+
+      include LegacyFacter::Util::Values
+
+      # Add the restriction.  Requires the fact name, an operator, and the value
+      # we're comparing to.
+      #
+      # @param fact [Symbol] Name of the fact
+      # @param values [Array] One or more values to match against.
+      #   They can be any type that provides a === method.
+      # @param block [Proc] Alternatively a block can be supplied as a check.  The fact
+      #   value will be passed as the argument to the block.  If the block returns
+      #   true then the fact will be enabled, otherwise it will be disabled.
+      def initialize(fact = nil, *values, &block)
+        raise ArgumentError, 'The fact name must be provided' unless fact || block_given?
+        raise ArgumentError, 'One or more values or a block must be provided' if values.empty? && !block_given?
+
+        @fact = fact
+        @values = values
+        @block = block
+      end
+
+      def to_s
+        return @block.to_s if @block
+
+        format("'%<fact>s' '%<values>s'", fact: @fact, values: @values.join(','))
+      end
+
+      # Evaluate the fact, returning true or false.
+      # if we have a block paramter then we only evaluate that instead
+      def true?
+        if @block && !@fact
+          begin
+            return !!@block.call
+          rescue StandardError => e
+            LegacyFacter.debug "Confine raised #{e.class} #{e}"
+            return false
+          end
+        end
+
+        unless (fact = Facter[@fact])
+          LegacyFacter.debug format('No fact for %<fact>s', fact: @fact)
+          return false
+        end
+        value = convert(fact.value)
+
+        return false if value.nil?
+
+        if @block
+          begin
+            return !!@block.call(value)
+          rescue StandardError => e
+            LegacyFacter.debug "Confine raised #{e.class} #{e}"
+            return false
+          end
+        end
+
+        @values.any? { |v| convert(v) === value }
+      end
+    end
+  end
+end

data/lib/custom_facts/util/directory_loader.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# A Facter plugin that loads external facts.
+#
+# Default Unix Directories:
+# /opt/puppetlabs/custom_facts/facts.d, /etc/custom_facts/facts.d, /etc/puppetlabs/custom_facts/facts.d
+#
+# Beginning with Facter 3, only /opt/puppetlabs/custom_facts/facts.d will be a default external fact
+# directory in Unix.
+#
+# Default Windows Direcotires:
+# C:\ProgramData\Puppetlabs\custom_facts\facts.d (2008)
+# C:\Documents and Settings\All Users\Application Data\Puppetlabs\custom_facts\facts.d (2003)
+#
+# Can also load from command-line specified directory
+#
+# Facts can be in the form of JSON, YAML or Text files
+# and any executable that returns key=value pairs.
+
+require 'yaml'
+
+module LegacyFacter
+  module Util
+    class DirectoryLoader
+      class NoSuchDirectoryError < RuntimeError
+      end
+
+      # This value makes it highly likely that external facts will take
+      # precedence over all other facts
+      EXTERNAL_FACT_WEIGHT = 10_000
+
+      # Directory for fact loading
+      attr_reader :directories
+
+      def initialize(dir = LegacyFacter::Util::Config.external_facts_dirs, weight = EXTERNAL_FACT_WEIGHT)
+        @directories = [dir].flatten
+        @weight = weight
+      end
+
+      # Load facts from files in fact directory using the relevant parser classes to
+      # parse them.
+      def load(collection)
+        weight = @weight
+
+        searched_facts, cached_facts = load_directory_entries(collection)
+
+        load_cached_facts(collection, cached_facts, weight)
+
+        load_searched_facts(collection, searched_facts, weight)
+      end
+
+      private
+
+      def load_directory_entries(_collection)
+        cm = Facter::CacheManager.new
+        facts = []
+        entries.each do |file|
+          basename = File.basename(file)
+          if facts.find { |f| f.name == basename } && cm.group_cached?(basename)
+            Facter.log_exception(Exception.new("Caching is enabled for group \"#{basename}\" while "\
+              'there are at least two external facts files with the same filename'))
+          else
+            searched_fact = Facter::SearchedFact.new(basename, nil, [], nil, :file)
+            searched_fact.file = file
+            facts << searched_fact
+          end
+        end
+
+        cm.resolve_facts(facts)
+      end
+
+      def load_cached_facts(collection, cached_facts, weight)
+        cached_facts.each do |cached_fact|
+          collection.add(cached_fact.name, value: cached_fact.value, fact_type: :external,
+                                           file: cached_fact.file) { has_weight(weight) }
+        end
+      end
+
+      def load_searched_facts(collection, searched_facts, weight)
+        searched_facts.each do |fact|
+          parser = LegacyFacter::Util::Parser.parser_for(fact.file)
+          next if parser.nil?
+
+          data = parser.results
+          if data == false
+            LegacyFacter.warn "Could not interpret fact file #{fact.file}"
+          elsif (data == {}) || data.nil?
+            LegacyFacter.warn "Fact file #{fact.file} was parsed but returned an empty data set"
+          else
+            data.each do |p, v|
+              collection.add(p, value: v, fact_type: :external,
+                                file: fact.file) { has_weight(weight) }
+            end
+          end
+        end
+      end
+
+      def entries
+        dirs = @directories.select { |directory| File.directory?(directory) }.map do |directory|
+          Dir.entries(directory).map { |directory_entry| File.join(directory, directory_entry) }
+        end
+        dirs.flatten.select { |f| should_parse?(f) }
+      rescue Errno::ENOENT
+        []
+      end
+
+      def should_parse?(file)
+        File.basename(file) !~ /^\./
+      end
+    end
+  end
+end

data/lib/custom_facts/util/fact.rb

@@ -0,0 +1,226 @@
+# 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 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 = name.to_s.downcase.intern
+
+        @options = Facter::Utils.deep_copy(options)
+        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 = Facter::Utils.deep_copy(@options.merge(options))
+        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
+        LegacyFacter
+          .log_exception(e, "Unable to add resolve #{resolution_name.inspect} for fact #{@name}: #{e.message}")
+      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 if @value
+
+        if @resolves.empty?
+          LegacyFacter.debug format('No resolves for %<name>s', name: @name)
+          return nil
+        end
+
+        searching do
+          suitable_resolutions = sort_by_weight(find_suitable_resolutions(@resolves))
+          @value = find_first_real_value(suitable_resolutions)
+
+          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]
+
+        LegacyFacter.warnonce('ldapname is deprecated and will be removed in a future version')
+        self.ldapname = options.delete(:ldapname)
+      end
+
+      private
+
+      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 ge 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)
+        resolutions.sort { |a, b| b <=> a }
+      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
+          return value unless value.nil?
+        end
+        nil
+      end
+
+      def announce_when_no_suitable_resolution(resolutions)
+        return unless resolutions.empty?
+
+        LegacyFacter.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)
+        LegacyFacter.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/custom_facts/util/loader.rb

@@ -0,0 +1,157 @@
+# 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
+      #
+      # A warning will be generated for paths in Facter.search_path that are not
+      # absolute directories.
+      #
+      # @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
+
+        search_paths.delete_if { |path| !valid_search_path?(path) }
+
+        Facter::Options.custom_dir.each do |path|
+          if valid_search_path?(path)
+            search_paths << path
+          else
+            LegacyFacter.warn "Excluding #{path} from search path. Fact file paths must be an absolute directory"
+          end
+        end
+
+        search_paths.delete_if { |path| !File.directory?(path) }
+
+        search_paths.uniq
+      end
+
+      private
+
+      # Validate that the given path is valid, ie it is an absolute path.
+      #
+      # @api private
+      # @param path [String]
+      # @return [Boolean]
+      def valid_search_path?(path)
+        Pathname.new(path).absolute?
+      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)
+
+          # If a fact name was specified, skip anything that doesn't
+          # match it.
+          next if fact && (env_name != fact)
+
+          LegacyFacter.add(Regexp.last_match(1), fact_type: :external) 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