openfact 5.0.0.rc0

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

@@ -0,0 +1,188 @@
+# 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
+        @loaded = false
+      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 [Facter::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
+        log.log_exception(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 [Facter::Util::Fact] The fact that was defined
+      def add(name, options = {}, &block)
+        fact = create_or_return_fact(name, options)
+
+        fact.add(options, &block)
+
+        fact
+      rescue StandardError => e
+        log.log_exception(e)
+      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]
+
+        log.warnonce("No facts loaded from #{internal_loader.search_path.join(File::PATH_SEPARATOR)}") if @facts.empty?
+
+        @facts[name]
+      end
+
+      # Flush all cached values.
+      def flush
+        @facts.each_value(&: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.select { |_k, v| v.options[:fact_type] == :external }
+      end
+
+      def invalidate_custom_facts
+        @valid_custom_facts = false
+      end
+
+      def reload_custom_facts
+        @loaded = false
+      end
+
+      def custom_fact(fact_name)
+        internal_loader.load(fact_name)
+        @custom_facts = @facts.select { |_k, v| v.options[:fact_type] == :custom }
+      end
+
+      # Builds a hash of custom facts
+      def custom_facts
+        return @custom_facts if @valid_custom_facts
+
+        @valid_custom_facts = true
+
+        internal_loader.load_all unless @loaded
+        @loaded = true
+
+        @custom_facts = @facts.select { |_k, v| v.options[:fact_type] == :custom }
+      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, :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)
+        fact&.value
+      end
+
+      private
+
+      def create_or_return_fact(name, options)
+        name = canonicalize(name)
+
+        fact = @facts[name]
+
+        if fact.nil?
+          fact = Facter::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
+
+      def log
+        @log ||= Facter::Log.new(self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# A composite loader that allows for more than one
+# default directory loader
+
+module LegacyFacter
+  module Util
+    class CompositeLoader
+      def initialize(loaders)
+        @loaders = loaders
+      end
+
+      def load(collection)
+        @loaders.each { |loader| loader.load(collection) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+# A module to return config related data
+#
+module LegacyFacter
+  module Util
+    module Config
+      def self.ext_fact_loader
+        @ext_fact_loader || LegacyFacter::Util::DirectoryLoader.new
+      end
+
+      def self.ext_fact_loader=(loader)
+        @ext_fact_loader = loader
+      end
+
+      def self.mac?
+        RbConfig::CONFIG['host_os'] =~ /darwin/i
+      end
+
+      # Returns true if OS is windows
+      def self.windows?
+        RbConfig::CONFIG['host_os'] =~ /mswin|win32|dos|mingw|cygwin/i
+      end
+
+      def self.windows_data_dir
+        ENV['ProgramData'] || ENV['APPDATA'] if LegacyFacter::Util::Config.windows?
+      end
+
+      def self.external_facts_dirs
+        Facter::Options.external_dir
+      end
+
+      def self.facts_cache_dir
+        @facts_cache_dir ||= setup_default_cache_dir
+      end
+
+      def self.setup_default_ext_facts_dirs
+        if LegacyFacter::Util::Root.root?
+          windows_dir = windows_data_dir
+          Facter::Options[:default_external_dir] = if windows_dir
+                                                     [File.join(windows_dir, 'PuppetLabs', 'facter', 'facts.d')]
+                                                   else
+                                                     [
+                                                       '/etc/puppetlabs/facter/facts.d',
+                                                       '/etc/facter/facts.d/',
+                                                       '/opt/puppetlabs/facter/facts.d'
+                                                     ]
+                                                   end
+        elsif ENV['HOME']
+          Facter::Options[:default_external_dir] =
+            [File.join(ENV['HOME'], '.facter', 'facts.d'),
+             File.join(ENV['HOME'], '.puppetlabs', 'opt', 'facter', 'facts.d')]
+        else
+          Facter::Options[:default_external_dir] = []
+        end
+      end
+
+      if LegacyFacter::Util::Config.windows?
+        require_relative 'windows_root'
+      else
+        require_relative 'unix_root'
+      end
+
+      setup_default_ext_facts_dirs
+
+      def self.override_binary_dir=(dir)
+        @override_binary_dir = dir
+      end
+
+      def self.override_binary_dir
+        @override_binary_dir
+      end
+
+      def self.setup_default_cache_dir
+        windows_dir = windows_data_dir
+        @facts_cache_dir = if windows_dir
+                             File.join(windows_dir, 'PuppetLabs', 'facter', 'cache', 'cached_facts')
+                           else
+                             '/opt/puppetlabs/facter/cache/cached_facts'
+                           end
+      end
+
+      def self.setup_default_override_binary_dir
+        @override_binary_dir = if LegacyFacter::Util::Config.windows?
+                                 nil
+                               else
+                                 '/opt/puppetlabs/puppet/bin'
+                               end
+      end
+
+      setup_default_override_binary_dir
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# 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 parameter then we only evaluate that instead
+      def true?
+        if @block && !@fact
+          begin
+            return !!@block.call
+          rescue StandardError => e
+            log.debug "Confine raised #{e.class} #{e}"
+            return false
+          end
+        end
+
+        unless (fact = Facter[@fact])
+          log.debug format('No fact for %<fact>s', fact: @fact)
+          return false
+        end
+        value = convert(fact.value)
+
+        return false if value.nil?
+
+        # We call the block with both the downcased and raw fact value for
+        # backwards-compatibility.
+        if @block
+          begin
+            return !!@block.call(value) || !!@block.call(fact.value) # rubocop:disable Style/DoubleNegation
+          rescue StandardError => e
+            log.debug "Confine raised #{e.class} #{e}"
+            return false
+          end
+        end
+
+        # we're intentionally using case equality (triple equals) because we
+        # support matching against anything that supports === such as ranges,
+        # regular expressions, etc
+        @values.any? { |v| convert(v) === value } # rubocop:disable Style/CaseEquality
+      end
+
+      private
+
+      def log
+        @log ||= Facter::Log.new(self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# 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
+        @log ||= Facter::Log.new(self)
+      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 log
+        @log ||= Facter::Log.new(self)
+      end
+
+      def load_directory_entries(_collection)
+        cm = Facter::CacheManager.new
+        facts = []
+        entries.each do |file|
+          basename = File.basename(file)
+          next if file_blocked?(basename)
+
+          if facts.find { |f| f.name == basename } && cm.fact_cache_enabled?(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 = resolve_fact(fact, parser)
+
+          if data == false
+            log.warn "Could not interpret fact file #{fact.file}"
+          elsif (data == {}) || data.nil?
+            log.debug(
+              "Structured data fact file #{fact.file} was parsed but was either empty or an invalid filetype "\
+                '(valid filetypes are .yaml, .json, and .txt).'
+            )
+          elsif !data.is_a?(Hash)
+            log.error("Structured data fact file #{fact.file} was parsed but no key=>value data was returned.")
+          else
+            add_data(data, collection, fact, weight)
+          end
+        end
+      end
+
+      def add_data(data, collection, fact, weight)
+        data.each do |key, value|
+          collection.add(
+            key,
+            value: value,
+            fact_type: :external,
+            file: fact.file
+          ) { has_weight(weight) }
+        end
+      end
+
+      def resolve_fact(fact, parser)
+        data = nil
+        fact_name = File.basename(fact.file)
+        Facter::Framework::Benchmarking::Timer.measure(fact_name) { data = parser.results }
+
+        data
+      end
+
+      def entries
+        dirs = @directories.select { |directory| File.directory?(directory) }.map do |directory|
+          Dir.entries(directory).map { |directory_entry| File.join(directory, directory_entry) }.sort.reverse!
+        end
+        dirs.flatten.select { |f| should_parse?(f) }
+      rescue Errno::ENOENT
+        []
+      end
+
+      def should_parse?(file)
+        File.basename(file) !~ /^\./
+      end
+
+      def file_blocked?(file)
+        if Facter::Options[:blocked_facts].include? file
+          Facter.debug("External fact file #{file} blocked.")
+          return true
+        end
+        false
+      end
+    end
+  end
+end