facter 4.0.50 → 4.2.0

data/lib/facter/framework/config/config_reader.rb

@@ -45,6 +45,8 @@ module Facter
       end
 
       def default_path
+        return '' if RUBY_PLATFORM == 'java'
+
         os = OsDetector.instance.identifier
 
         windows_path = File.join('C:', 'ProgramData', 'PuppetLabs', 'facter', 'etc', 'facter.conf')

data/lib/facter/framework/config/fact_groups.rb

@@ -7,7 +7,15 @@ module Facter
     attr_accessor :groups_ttls
     attr_reader :groups, :block_list, :facts_ttls
 
-    STRING_TO_SECONDS = { 'seconds' => 1, 'minutes' => 60, 'hours' => 3600, 'days' => 3600 * 24 }.freeze
+    STRING_TO_SECONDS = { 'ns' => 1.fdiv(1_000_000_000), 'nanos' => 1.fdiv(1_000_000_000),
+                          'nanoseconds' => 1.fdiv(1_000_000_000),
+                          'us' => 1.fdiv(1_000_000), 'micros' => 1.fdiv(1_000_000), 'microseconds' => 1.fdiv(1_000_000),
+                          '' => 1.fdiv(1000), 'ms' => 1.fdiv(1000), 'milis' => 1.fdiv(1000),
+                          'milliseconds' => 1.fdiv(1000),
+                          's' => 1, 'seconds' => 1,
+                          'm' => 60, 'minutes' => 60,
+                          'h' => 3600, 'hours' => 3600,
+                          'd' => 3600 * 24, 'days' => 3600 * 24 }.freeze
 
     def initialize
       @groups = Facter::Config::FACT_GROUPS.dup
@@ -103,7 +111,22 @@ module Facter
 
     def ttls_to_seconds(ttls)
       duration, unit = ttls.split(' ', 2)
-      duration.to_i * STRING_TO_SECONDS[unit]
+      unit = '' if duration && !unit
+      unit = append_s(unit)
+      seconds = STRING_TO_SECONDS[unit]
+      if seconds
+        (duration.to_i * seconds).to_i
+      else
+        log = Log.new(self)
+        log.error("Could not parse time unit #{unit} (try #{STRING_TO_SECONDS.keys.reject(&:empty?).join(', ')})")
+        nil
+      end
+    end
+
+    def append_s(unit)
+      return unit + 's' if unit.length > 2 && unit[-1] != 's'
+
+      unit
     end
   end
 end

data/lib/facter/framework/core/cache_manager.rb

@@ -123,7 +123,7 @@ cache_format_version is incorrect!")
         return unless data[searched_fact.name]
 
         [Facter::ResolvedFact.new(searched_fact.name, data[searched_fact.name], searched_fact.type,
-                                  searched_fact.user_query, searched_fact.filter_tokens)]
+                                  searched_fact.user_query)]
       end
     end
 
@@ -133,7 +133,7 @@ cache_format_version is incorrect!")
         next if fact_name == 'cache_format_version'
 
         fact = Facter::ResolvedFact.new(fact_name, fact_value, searched_fact.type,
-                                        searched_fact.user_query, searched_fact.filter_tokens)
+                                        searched_fact.user_query)
         fact.file = searched_fact.file
         facts << fact
       end
@@ -209,7 +209,11 @@ cache_format_version is incorrect!")
     def delete_cache(group_name)
       cache_file_name = File.join(@cache_dir, group_name)
 
-      File.delete(cache_file_name) if File.readable?(cache_file_name)
+      begin
+        File.delete(cache_file_name) if File.readable?(cache_file_name)
+      rescue Errno::EACCES => e
+        @log.warn("Could not delete cache: #{e.message}")
+      end
     end
   end
 end

data/lib/facter/framework/core/fact/external/external_fact_manager.rb

@@ -19,7 +19,6 @@ module Facter
       custom_facts.each do |custom_fact|
         fact = LegacyFacter[custom_fact.name]
         resolved_fact = ResolvedFact.new(custom_fact.name, fact.value, :custom)
-        resolved_fact.filter_tokens = []
         resolved_fact.user_query = custom_fact.user_query
         resolved_fact.file = fact.options[:file]
 

data/lib/facter/framework/core/fact/internal/internal_fact_manager.rb

@@ -2,20 +2,25 @@
 
 module Facter
   class InternalFactManager
-    @@log = Facter::Log.new(self)
-
+    # resolves each SearchFact and filter out facts that do not match the given user query
+    # @param searched_facts [Array<Facter::SearchedFact>] array of searched facts
+    #
+    # @return [Array<Facter::ResolvedFact>]
+    #
+    # @api private
     def resolve_facts(searched_facts)
       internal_searched_facts = filter_internal_facts(searched_facts)
-
       resolved_facts = if Options[:sequential]
-                         @@log.debug('Resolving facts sequentially')
+                         log.debug('Resolving facts sequentially')
                          resolve_sequentially(internal_searched_facts)
                        else
-                         @@log.debug('Resolving fact in parallel')
-                         threads = start_threads(internal_searched_facts)
-                         join_threads(threads, internal_searched_facts)
+                         log.debug('Resolving fact in parallel')
+                         resolve_in_parallel(internal_searched_facts)
                        end
 
+      resolved_facts.flatten!
+      resolved_facts.compact!
+
       nil_resolved_facts = resolve_nil_facts(searched_facts)
 
       resolved_facts.concat(nil_resolved_facts)
@@ -27,6 +32,17 @@ module Facter
       searched_facts.select { |searched_fact| %i[core legacy].include? searched_fact.type }
     end
 
+    def valid_fact?(searched_fact, resolved_fact)
+      return if resolved_fact.value.nil?
+
+      searched_fact_name = searched_fact.name
+      if searched_fact_name.include?('.*')
+        resolved_fact.name.match(searched_fact_name)
+      else
+        resolved_fact.name == searched_fact_name
+      end
+    end
+
     def resolve_nil_facts(searched_facts)
       resolved_facts = []
       searched_facts.select { |fact| fact.type == :nil }.each do |fact|
@@ -37,49 +53,35 @@ module Facter
     end
 
     def resolve_sequentially(searched_facts)
-      resolved_facts = []
-
-      searched_facts
-        .uniq { |searched_fact| searched_fact.fact_class.name }
-        .each do |searched_fact|
-        begin
-          fact = CoreFact.new(searched_fact)
-          fact_value = fact.create
-          resolved_facts << fact_value unless fact_value.nil?
-        rescue StandardError => e
-          @@log.log_exception(e)
-        end
-      end
+      searched_facts.map! { |searched_fact| resolve_fact(searched_fact) }
+    end
 
-      resolved_facts.flatten!
-      FactAugmenter.augment_resolved_facts(searched_facts, resolved_facts)
+    def resolve_in_parallel(searched_facts)
+      searched_facts.map! do |searched_fact|
+        Thread.new { resolve_fact(searched_fact) }
+      end.map!(&:value)
     end
 
-    def start_threads(searched_facts)
-      # only resolve a fact once, even if multiple search facts depend on that fact
-      searched_facts
-        .uniq { |searched_fact| searched_fact.fact_class.name }
-        .map do |searched_fact|
-        Thread.new do
-          resolve_fact(searched_fact)
+    def resolve_fact(searched_fact)
+      fact_value = core_fact(searched_fact)
+      Array(fact_value).map! do |resolved_fact|
+        if valid_fact?(searched_fact, resolved_fact)
+          resolved_fact.user_query = searched_fact.user_query
+          resolved_fact
         end
       end
     end
 
-    def join_threads(threads, searched_facts)
-      resolved_facts = threads.map(&:value)
-      resolved_facts.compact!
-      resolved_facts.flatten!
-
-      FactAugmenter.augment_resolved_facts(searched_facts, resolved_facts)
-    end
-
-    def resolve_fact(searched_fact)
+    def core_fact(searched_fact)
       fact = CoreFact.new(searched_fact)
       fact.create
     rescue StandardError => e
-      @@log.log_exception(e)
+      log.log_exception(e)
       nil
     end
+
+    def log
+      @log ||= Facter::Log.new(self)
+    end
   end
 end

data/lib/facter/framework/core/fact_filter.rb

@@ -1,21 +1,11 @@
 # frozen_string_literal: true
 
 module Facter
-  # Filter inside value of a fact.
-  # e.g. os.release.major is the user query, os.release is the fact
-  # and major is the filter criteria inside tha fact
   class FactFilter
-    def filter_facts!(searched_facts)
-      filter_legacy_facts!(searched_facts)
-      filter_blocked_legacy_facts!(searched_facts)
-
-      searched_facts.each do |fact|
-        fact.value = if fact.filter_tokens.any? && fact.value.respond_to?(:dig)
-                       fact.value.dig(*fact.filter_tokens)
-                     else
-                       fact.value
-                     end
-      end
+    def filter_facts!(resolved_facts, user_query)
+      filter_legacy_facts!(resolved_facts) if user_query.empty?
+      filter_blocked_legacy_facts!(resolved_facts)
+      resolved_facts
     end
 
     private
@@ -32,7 +22,7 @@ module Facter
     end
 
     def filter_legacy_facts!(resolved_facts)
-      return unless !Options[:show_legacy] && Options[:user_query].empty?
+      return if Options[:show_legacy]
 
       resolved_facts.reject!(&:legacy?)
     end

data/lib/facter/framework/core/fact_loaders/external_fact_loader.rb

@@ -10,20 +10,23 @@ module Facter
       @external_facts = load_external_facts
     end
 
+    def load_fact(fact_name)
+      build_custom_facts(LegacyFacter.collection.custom_fact(fact_name)) || []
+    end
+
     private
 
     def load_custom_facts
-      custom_facts = []
-
       custom_facts_to_load = LegacyFacter.collection.custom_facts
+      build_custom_facts(custom_facts_to_load) || []
+    end
 
-      custom_facts_to_load&.each do |k, v|
+    def build_custom_facts(custom_facts_to_load)
+      custom_facts_to_load&.map do |k, v|
         loaded_fact = LoadedFact.new(k.to_s, nil, :custom)
         loaded_fact.is_env = v.options[:is_env] if v.options[:is_env]
-        custom_facts << loaded_fact
+        loaded_fact
       end
-
-      custom_facts
     end
 
     def load_external_facts

data/lib/facter/framework/core/fact_loaders/fact_loader.rb

@@ -11,45 +11,27 @@ module Facter
 
       @internal_facts = []
       @external_facts = []
+      @custom_facts = []
       @facts = []
-    end
 
-    def load(options)
       @internal_loader ||= InternalFactLoader.new
       @external_fact_loader ||= ExternalFactLoader.new
+    end
 
-      @facts = []
-      @external_facts = []
-
-      @internal_facts = load_internal_facts(options)
+    def load(user_query, options)
+      @internal_facts = load_internal_facts(user_query, options)
+      @custom_facts = load_custom_facts(options)
       @external_facts = load_external_facts(options)
 
       filter_env_facts
 
-      @facts = @internal_facts + @external_facts
-    end
-
-    private
-
-    def filter_env_facts
-      env_fact_names = @external_facts.select { |fact| fact.is_env == true }.map(&:name)
-      return unless env_fact_names.any?
-
-      @internal_facts.delete_if do |fact|
-        if env_fact_names.include?(fact.name)
-          @log.debug("Reading #{fact.name} fact from environment variable")
-          true
-        else
-          false
-        end
-      end
+      @facts = @internal_facts + @external_facts + @custom_facts
     end
 
-    def load_internal_facts(options)
+    def load_internal_facts(user_query, options)
       @log.debug('Loading internal facts')
       internal_facts = []
-
-      if options[:user_query] || options[:show_legacy]
+      if user_query || options[:show_legacy]
         # if we have a user query, then we must search in core facts and legacy facts
         @log.debug('Loading all internal facts')
         internal_facts = @internal_loader.facts
@@ -61,23 +43,43 @@ module Facter
       block_facts(internal_facts, options)
     end
 
+    def load_custom_fact(options, fact_name)
+      return [] unless options[:custom_facts]
+
+      custom_facts = @external_fact_loader.load_fact(fact_name)
+      block_facts(custom_facts, options)
+    end
+
+    def load_custom_facts(options)
+      return [] unless options[:custom_facts]
+
+      @log.debug('Loading custom facts')
+      custom_facts = @external_fact_loader.custom_facts
+      block_facts(custom_facts, options)
+    end
+
     def load_external_facts(options)
+      return [] unless options[:external_facts]
+
       @log.debug('Loading external facts')
-      external_facts = []
+      external_facts = @external_fact_loader.external_facts
+      block_facts(external_facts, options)
+    end
 
-      if options[:custom_facts]
-        @log.debug('Loading custom facts')
-        external_facts += @external_fact_loader.custom_facts
-      end
+    private
 
-      external_facts = block_facts(external_facts, options)
+    def filter_env_facts
+      env_fact_names = @external_facts.select { |fact| fact.is_env == true }.map(&:name)
+      return unless env_fact_names.any?
 
-      if options[:external_facts]
-        @log.debug('Loading external facts')
-        external_facts += @external_fact_loader.external_facts
+      @internal_facts.delete_if do |fact|
+        if env_fact_names.include?(fact.name)
+          @log.debug("Reading #{fact.name} fact from environment variable")
+          true
+        else
+          false
+        end
       end
-
-      external_facts
     end
 
     def block_facts(facts, options)

data/lib/facter/framework/core/fact_manager.rb

@@ -8,18 +8,16 @@ module Facter
       @internal_fact_mgr = InternalFactManager.new
       @external_fact_mgr = ExternalFactManager.new
       @fact_loader = FactLoader.instance
+      @options = Options.get
       @log = Log.new(self)
     end
 
-    def searched_facts(user_query = [])
-      loaded_facts = @fact_loader.load(Options.get)
-      QueryParser.parse(user_query, loaded_facts)
-    end
-
     def resolve_facts(user_query = [])
-      searched_facts = parse_user_query(user_query)
-
+      @options[:user_query] = user_query
       cache_manager = Facter::CacheManager.new
+
+      searched_facts = QueryParser.parse(user_query, @fact_loader.load(user_query, @options))
+
       searched_facts, cached_facts = cache_manager.resolve_facts(searched_facts)
       internal_facts = @internal_fact_mgr.resolve_facts(searched_facts)
       external_facts = @external_fact_mgr.resolve_facts(searched_facts)
@@ -29,27 +27,99 @@ module Facter
       resolved_facts = resolved_facts.concat(cached_facts)
       cache_manager.cache_facts(resolved_facts)
 
-      FactFilter.new.filter_facts!(resolved_facts)
+      FactFilter.new.filter_facts!(resolved_facts, user_query)
 
       log_resolved_facts(resolved_facts)
       resolved_facts
     end
 
-    def resolve_core(user_query = [])
-      loaded_facts_hash = @fact_loader.internal_facts
+    # resolve a fact by name, in a similar way that facter 3 does.
+    # search is done in multiple steps, and the next step is executed
+    # only if the previous one was not able to resolve the fact
+    # - load the `fact_name.rb` from the configured custom directories
+    # - load all the core facts, external facts and env facts
+    # - load all custom facts
+    def resolve_fact(user_query)
+      @options[:user_query] = user_query
+      @log.debug("resolving fact with user_query: #{user_query}")
+
+      @cache_manager = Facter::CacheManager.new
+
+      custom_facts = custom_fact_by_filename(user_query) || []
+      core_and_external_facts = core_or_external_fact(user_query) || []
+      resolved_facts = core_and_external_facts + custom_facts
+
+      resolved_facts = all_custom_facts(user_query) if resolved_facts.empty?
+
+      @cache_manager.cache_facts(resolved_facts)
+
+      log_resolved_facts(resolved_facts)
+      resolved_facts
+    end
+
+    def resolve_core(user_query = [], options = {})
+      @cache_manager = CacheManager.new
+      core_fact(user_query, options)
+    end
+
+    private
+
+    def core_fact(user_query, options)
+      loaded_facts_hash = @fact_loader.load_internal_facts(user_query, options)
 
       searched_facts = QueryParser.parse(user_query, loaded_facts_hash)
+      searched_facts, cached_facts = @cache_manager.resolve_facts(searched_facts)
+
       resolved_facts = @internal_fact_mgr.resolve_facts(searched_facts)
-      FactFilter.new.filter_facts!(resolved_facts)
+      resolved_facts = resolved_facts.concat(cached_facts)
+
+      FactFilter.new.filter_facts!(resolved_facts, user_query)
 
       resolved_facts
     end
 
-    private
+    def custom_fact_by_filename(user_query)
+      @log.debug("Searching fact: #{user_query} in file: #{user_query}.rb")
+
+      custom_fact = @fact_loader.load_custom_fact(@options, user_query)
+      return unless custom_fact.any?
+
+      searched_facts = parse_user_query(custom_fact, user_query)
+      searched_facts, cached_facts = @cache_manager.resolve_facts(searched_facts)
+
+      resolved_facts = @external_fact_mgr.resolve_facts(searched_facts)
+      resolved_facts = resolved_facts.concat(cached_facts)
+      resolved_facts if resolved_facts.any?
+    end
 
-    def parse_user_query(user_query)
-      loaded_facts = @fact_loader.load(Options.get)
+    def core_or_external_fact(user_query)
+      @log.debug("Searching fact: #{user_query} in core facts and external facts")
+
+      core_facts = core_fact([user_query], @options)
+      external_facts = @fact_loader.load_external_facts(@options)
+      searched_facts = parse_user_query(external_facts, user_query)
+      searched_facts, cached_facts = @cache_manager.resolve_facts(searched_facts)
+
+      resolved_facts = @external_fact_mgr.resolve_facts(searched_facts)
+      resolved_facts = override_core_facts(core_facts, resolved_facts)
+      resolved_facts = resolved_facts.concat(cached_facts)
+
+      resolved_facts unless resolved_facts.map(&:value).compact.empty?
+    end
+
+    def all_custom_facts(user_query)
+      @log.debug("Searching fact: #{user_query} in all custom facts")
+
+      custom_facts = @fact_loader.load_custom_facts(@options)
+      searched_facts = parse_user_query(custom_facts, user_query)
+      searched_facts, cached_facts = @cache_manager.resolve_facts(searched_facts)
+
+      resolved_facts = @external_fact_mgr.resolve_facts(searched_facts)
+      resolved_facts.concat(cached_facts)
+    end
 
+    def parse_user_query(loaded_facts, user_query)
+      user_query = Array(user_query)
       QueryParser.parse(user_query, loaded_facts)
     end