facter 4.0.28

data/lib/custom_facts/core/resolvable.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+# The resolvable mixin defines behavior for evaluating and returning fact
+# resolutions.
+#
+# Classes including this mixin should implement a #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
+      attr_reader :logger
+
+      # 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
+        Facter.log_exception(e, "Timed out after #{limit} seconds while resolving #{qualified_name}")
+
+        nil
+      rescue LegacyFacter::Util::Normalization::NormalizationError => e
+        Facter.log_exception(e, "Fact resolution #{qualified_name} resolved to an invalid value: #{e.message}")
+
+        nil
+      rescue StandardError => e
+        Facter.log_exception(e, "Error while resolving custom fact #{qualified_name}: #{e.message}")
+
+        raise Facter::ResolveCustomFactError
+      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,110 @@
+# 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
+        self
+      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.readable? '/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,182 @@
+# 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
+        Facter.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 [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
+      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.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
+
+      # 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 }
+        @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)
+        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
+    end
+  end
+end

data/lib/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/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