facter 4.0.52 → 4.2.2

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)
@@ -35,23 +33,93 @@ module Facter
       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)
+      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)
-      options = Options.get
-      options[:user_query] = user_query
-      loaded_facts = @fact_loader.load(options)
+    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
 

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

@@ -37,6 +37,7 @@ load_dir(['config'])
 load_dir(['util'])
 load_dir(%w[util resolvers])
 load_dir(%w[util facts])
+load_dir(%w[util facts posix])
 load_dir(%w[util resolvers networking])
 
 load_dir(['resolvers'])
@@ -58,5 +59,4 @@ os_hierarchy.each { |operating_system| load_dir(['resolvers', operating_system.d
 require 'facter/custom_facts/core/legacy_facter'
 load_dir(%w[framework utils])
 
-require 'facter/framework/core/fact_augmenter'
 require 'facter/framework/parsers/query_parser'

data/lib/facter/framework/core/options/config_file_options.rb

@@ -18,6 +18,12 @@ module Facter
 
       private
 
+      def augment_structured_facts(global_conf)
+        return if !global_conf || global_conf['force-dot-resolution'].nil?
+
+        @options[:force_dot_resolution] = global_conf['force-dot-resolution']
+      end
+
       def augment_all
         augment_cli(Facter::ConfigReader.cli) if Options.cli?
         augment_globals
@@ -27,6 +33,7 @@ module Facter
       def augment_globals
         augment_ruby(Facter::ConfigReader.global)
 
+        augment_structured_facts(Facter::ConfigReader.global)
         augment_custom(Facter::ConfigReader.global)
         augment_external(Facter::ConfigReader.global)
         augment_show_legacy(Facter::ConfigReader.global)

data/lib/facter/framework/core/options/option_store.rb

@@ -35,6 +35,7 @@ module Facter
     @custom_dir = []
     @hocon = false
     @allow_external_loggers = true
+    @force_dot_resolution = false
 
     class << self
       attr_reader :debug, :verbose, :log_level, :show_legacy,
@@ -42,7 +43,7 @@ module Facter
 
       attr_accessor :config, :strict, :json,
                     :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
-                    :config_file_external_dir, :default_external_dir, :fact_groups,
+                    :config_file_external_dir, :default_external_dir, :fact_groups, :force_dot_resolution,
                     :block_list, :color, :trace, :sequential, :timing, :hocon, :allow_external_loggers
 
       attr_writer :external_dir
@@ -202,6 +203,7 @@ module Facter
 
       def reset_facts
         @custom_facts = true
+        @force_dot_resolution = false
         @external_dir = []
         @custom_dir = []
       end

data/lib/facter/framework/formatters/formatter_helper.rb

@@ -4,12 +4,11 @@ module Facter
   class FormatterHelper
     class << self
       def retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
-        facts_to_display = {}
+        facts_to_display = FactCollection.new
         user_queries.each do |user_query|
           fact_collection = build_fact_collection_for_user_query(user_query, resolved_facts)
 
-          splitted_user_query = Utils.split_user_query(user_query)
-          printable_value = fact_collection.dig(*splitted_user_query)
+          printable_value = fact_collection.dig_fact(user_query)
           facts_to_display.merge!(user_query => printable_value)
         end
 
@@ -24,8 +23,7 @@ module Facter
       def retrieve_fact_value_for_single_query(user_query, resolved_facts)
         fact_collection = build_fact_collection_for_user_query(user_query, resolved_facts)
         fact_collection = Utils.sort_hash_by_key(fact_collection)
-        splitted_user_query = Utils.split_user_query(user_query)
-        fact_collection.dig(*splitted_user_query)
+        fact_collection.dig_fact(user_query)
       end
 
       private

data/lib/facter/framework/parsers/query_parser.rb

@@ -41,7 +41,7 @@ module Facter
       def no_user_query(loaded_facts)
         searched_facts = []
         loaded_facts.each do |loaded_fact|
-          searched_facts << SearchedFact.new(loaded_fact.name, loaded_fact.klass, [], '', loaded_fact.type)
+          searched_facts << SearchedFact.new(loaded_fact.name, loaded_fact.klass, '', loaded_fact.type)
         end
         searched_facts
       end
@@ -59,7 +59,7 @@ module Facter
           return resolvable_fact_list if resolvable_fact_list.any?
         end
 
-        resolvable_fact_list << SearchedFact.new(query, nil, [], query, :nil) if resolvable_fact_list.empty?
+        resolvable_fact_list << SearchedFact.new(query, nil, query, :nil) if resolvable_fact_list.empty?
 
         resolvable_fact_list
       end
@@ -69,19 +69,12 @@ module Facter
         resolvable_fact_list = []
 
         loaded_fact_hash.each do |loaded_fact|
-          # return the fact if toplevel namespace is found in the first query token
-          # eg. query: 'os.name' and loaded_fact_hash contains a fact with 'os' name
-          # it will construt and return the 'os' fact
-          if loaded_fact.name == query_tokens[0]
-            resolvable_fact_list = [construct_loaded_fact(query_tokens, query_token_range, loaded_fact)]
-          else
-            query_fact = query_tokens[query_token_range].join('.')
-
-            next unless found_fact?(loaded_fact.name, query_fact)
-
-            searched_fact = construct_loaded_fact(query_tokens, query_token_range, loaded_fact)
-            resolvable_fact_list << searched_fact
-          end
+          query_fact = query_tokens[query_token_range].join('.')
+
+          next unless found_fact?(loaded_fact.name, query_fact)
+
+          searched_fact = construct_loaded_fact(query_tokens, loaded_fact)
+          resolvable_fact_list << searched_fact
         end
 
         @log.debug "List of resolvable facts: #{resolvable_fact_list.inspect}"
@@ -100,23 +93,16 @@ module Facter
         true
       end
 
-      def construct_loaded_fact(query_tokens, query_token_range, loaded_fact)
-        filter_tokens = construct_filter_tokens(query_tokens, query_token_range)
+      def construct_loaded_fact(query_tokens, loaded_fact)
         user_query = @query_list.any? ? query_tokens.join('.') : ''
         fact_name = loaded_fact.name.to_s
         klass_name = loaded_fact.klass
         type = loaded_fact.type
-        sf = SearchedFact.new(fact_name, klass_name, filter_tokens, user_query, type)
+        sf = SearchedFact.new(fact_name, klass_name, user_query, type)
         sf.file = loaded_fact.file
 
         sf
       end
-
-      def construct_filter_tokens(query_tokens, query_token_range)
-        (query_tokens - query_tokens[query_token_range]).map do |token|
-          token =~ /^[0-9]+$/ ? token.to_i : token
-        end
-      end
     end
   end
 end

data/lib/facter/models/fact_collection.rb

@@ -7,6 +7,16 @@ module Facter
       @log = Log.new(self)
     end
 
+    def to_yaml
+      deep_to_h.to_yaml
+    end
+
+    # Transorms a list of {Facter::ResolvedFact} into a nested collection.
+    # @param facts [Array<Facter::ResolvedFact>]
+    #
+    # @return [FactCollection]
+    #
+    # @api private
     def build_fact_collection!(facts)
       facts.each do |fact|
         next if %i[core legacy].include?(fact.type) && fact.value.nil?
@@ -17,9 +27,29 @@ module Facter
       self
     end
 
-    def value(*keys)
-      keys.reduce(self) do |memo, key|
-        memo.fetch(key.to_s)
+    def dig_fact(user_query)
+      value(user_query)
+    rescue KeyError, TypeError
+      nil
+    end
+
+    # Collection#fetch implementation for nested collections.
+    # @param user_query [String] the search terms, separated by "."
+    #
+    # @return [String]
+    #
+    # @example for fact_collection = { "os": { "name": "Darwin" } }
+    #   fact_collection.fetch("os.name") #=> "Darwin"
+    #
+    # @api private
+    def value(user_query)
+      fetch(user_query) do
+        split_user_query = Facter::Utils.split_user_query(user_query)
+        split_user_query.reduce(self) do |memo, key|
+          raise KeyError unless memo.respond_to?(:fetch)
+
+          memo.fetch(key) { memo.fetch(key.to_s) }
+        end
       end
     end
 
@@ -39,9 +69,15 @@ module Facter
 
     private
 
+    def deep_to_h(collection = self)
+      collection.each_pair.with_object({}) do |(key, value), hash|
+        hash[key] = value.is_a?(FactCollection) ? deep_to_h(value) : value
+      end
+    end
+
     def bury_fact(fact)
       split_fact_name = extract_fact_name(fact)
-      bury(*split_fact_name + fact.filter_tokens << fact.value)
+      bury(*split_fact_name << fact.value)
     rescue NoMethodError
       @log.error("#{fact.type.to_s.capitalize} fact `#{fact.name}` cannot be added to collection."\
           ' The format of this fact is incompatible with other'\
@@ -49,7 +85,14 @@ module Facter
     end
 
     def extract_fact_name(fact)
-      fact.type == :legacy ? [fact.name] : fact.name.split('.')
+      case fact.type
+      when :legacy
+        [fact.name]
+      when :custom, :external
+        Options[:force_dot_resolution] == true ? fact.name.split('.') : [fact.name]
+      else
+        fact.name.split('.')
+      end
     end
   end
 end

data/lib/facter/models/resolved_fact.rb

@@ -3,14 +3,13 @@
 module Facter
   class ResolvedFact
     attr_reader :name, :type
-    attr_accessor :user_query, :filter_tokens, :value, :file
+    attr_accessor :user_query, :value, :file
 
-    def initialize(name, value = '', type = :core, user_query = nil, filter_tokens = [])
+    def initialize(name, value = '', type = :core, user_query = nil)
       @name = name
       @value = Utils.deep_stringify_keys(value)
       @type = type
       @user_query = user_query
-      @filter_tokens = filter_tokens
     end
 
     def legacy?

data/lib/facter/models/searched_fact.rb

@@ -2,13 +2,12 @@
 
 module Facter
   class SearchedFact
-    attr_reader :name, :fact_class, :filter_tokens, :user_query, :type
+    attr_reader :name, :fact_class, :user_query, :type
     attr_accessor :file
 
-    def initialize(fact_name, fact_class, filter_tokens, user_query, type)
+    def initialize(fact_name, fact_class, user_query, type)
       @name = fact_name
       @fact_class = fact_class
-      @filter_tokens = filter_tokens
       @user_query = user_query
       @type = type
     end

data/lib/facter/resolvers/aix/ffi/ffi_helper.rb

@@ -33,7 +33,7 @@ module Facter
 
           return if Libc.getkerninfo(KINFO_READ | KINFO_GET_AVENRUN, averages, averages_size, 0).negative?
 
-          averages.read_array_of_long_long(3).map { |x| (x / 65_536.0).round(5) }
+          averages.read_array_of_long_long(3).map { |x| (x / 65_536.0) }
         end
 
         def self.read_interfaces

data/lib/facter/resolvers/aix/processors.rb

@@ -16,6 +16,8 @@ module Facter
           def query_pddv(fact_name)
             @fact_list[:models] = []
             @fact_list[:logical_count] = 0
+            @fact_list[:cores_per_socket] = 0
+            @fact_list[:threads_per_core] = 0
 
             odmquery = Facter::Util::Aix::ODMQuery.new
             odmquery.equals('class', 'processor')
@@ -59,6 +61,8 @@ module Facter
             threads = smt_enabled ? smt_threads : 1
 
             @fact_list[:logical_count] += threads
+            @fact_list[:cores_per_socket] += 1
+            @fact_list[:threads_per_core] = threads
             @fact_list[:models].concat([type] * threads)
           end
 

data/lib/facter/resolvers/base_resolver.rb

@@ -28,10 +28,10 @@ module Facter
           cache_nil_for_unresolved_facts(fact_name)
         end
       rescue NoMethodError => e
-        log.debug("Could not resolve #{fact_name}, got #{e}")
+        log.debug("Could not resolve #{fact_name}, got #{e} at #{e.backtrace[0]}")
         @fact_list[fact_name] = nil
       rescue LoadError, NameError => e
-        log.debug("resolving fact #{fact_name}, but #{e}")
+        log.debug("Resolving fact #{fact_name}, but got #{e} at #{e.backtrace[0]}")
         @fact_list[fact_name] = nil
       end
 

data/lib/facter/resolvers/dmi_decode.rb

@@ -37,7 +37,6 @@ module Facter
           @fact_list[:virtualbox_version] = output.match(/vboxVer_(\S+)/)&.captures&.first
           @fact_list[:virtualbox_revision] = output.match(/vboxRev_(\S+)/)&.captures&.first
           @fact_list[:vmware_version] = extract_vmware_version(output)
-          @fact_list[:vendor] = output.match(/Vendor: (\S+)/)&.captures&.first
 
           @fact_list[fact_name]
         end