facter 4.0.52 → 4.1.0

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(@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,96 @@ 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 || []
+      core_and_external_facts = core_or_external_fact || []
+      resolved_facts = core_and_external_facts + custom_facts
+
+      resolved_facts = all_custom_facts 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(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 = @options[: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, @options)
+      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 = @options[: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, @options)
+      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 = @options[: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, @options)
+      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, options)
+      user_query = Array(options[:user_query])
       QueryParser.parse(user_query, loaded_facts)
     end
 

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

@@ -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, query_token_range, loaded_fact)
+          resolvable_fact_list << searched_fact
         end
 
         @log.debug "List of resolvable facts: #{resolvable_fact_list.inspect}"
@@ -113,7 +106,7 @@ module Facter
       end
 
       def construct_filter_tokens(query_tokens, query_token_range)
-        (query_tokens - query_tokens[query_token_range]).map do |token|
+        query_tokens.drop(query_token_range.size).map do |token|
           token =~ /^[0-9]+$/ ? token.to_i : token
         end
       end

data/lib/facter/models/fact_collection.rb

@@ -7,6 +7,10 @@ module Facter
       @log = Log.new(self)
     end
 
+    def to_yaml
+      deep_to_h.to_yaml
+    end
+
     def build_fact_collection!(facts)
       facts.each do |fact|
         next if %i[core legacy].include?(fact.type) && fact.value.nil?
@@ -17,10 +21,20 @@ module Facter
       self
     end
 
-    def value(*keys)
-      keys.reduce(self) do |memo, key|
-        memo.fetch(key.to_s)
-      end
+    def dig_fact(user_query)
+      split_user_query = Facter::Utils.split_user_query(user_query)
+      fact = dig(user_query) || dig(*split_user_query)
+    rescue TypeError
+      # An incorrect user query (e.g. mountpoints./.available.asd) can cause
+      # Facter to call dig on a string, which raises a type error.
+      # If this happens, we assume the query is wrong and silently continue.
+    ensure
+      @log.debug("Fact \"#{user_query}\" does not exist") unless fact
+      fact
+    end
+
+    def value(user_query)
+      dig_fact(user_query)
     end
 
     def bury(*args)
@@ -39,6 +53,12 @@ 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)
@@ -49,7 +69,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/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/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

data/lib/facter/resolvers/linux/hostname.rb

@@ -19,7 +19,6 @@ module Facter
 
           def retrieve_info(fact_name)
             require 'socket'
-            require 'facter/util/resolvers/ffi/hostname'
 
             output = retrieving_hostname
             return nil unless output
@@ -38,13 +37,20 @@ module Facter
           end
 
           def retrieving_hostname
-            output = Socket.gethostname
-            if !output || output.empty? || output['0.0.0.0']
-              output = Facter::Util::Resolvers::Ffi::Hostname.getffihostname
+            output = Socket.gethostname || ''
+            if output.empty? || output['0.0.0.0']
+              begin
+                require 'facter/util/resolvers/ffi/hostname'
+
+                output = Facter::Util::Resolvers::Ffi::Hostname.getffihostname
+              rescue LoadError => e
+                log.debug(e.message)
+                output = nil
+              end
             end
 
             log.debug("Tried to retrieve hostname and got: #{output}")
-            output && !output.empty? ? output : nil
+            return output unless output&.empty?
           end
 
           def parse_fqdn(output)
@@ -70,9 +76,14 @@ module Facter
           end
 
           def retrieve_fqdn_for_host_with_ffi(host)
+            require 'facter/util/resolvers/ffi/hostname'
+
             fqdn = Facter::Util::Resolvers::Ffi::Hostname.getffiaddrinfo(host)
             log.debug("FFI getaddrinfo was called and it retrieved: #{fqdn}")
             fqdn
+          rescue LoadError => e
+            log.debug(e.message)
+            nil
           end
 
           def exists_and_valid_fqdn?(fqdn, hostname)

data/lib/facter/resolvers/macosx/mountpoints.rb

@@ -21,7 +21,7 @@ module Facter
               device = fs.name
               filesystem = fs.mount_type
               path = fs.mount_point
-              options = fs.options.split(',').map(&:strip).map { |o| o == 'rootfs' ? 'root' : o }
+              options = read_options(fs.options)
 
               mounts[path] = read_stats(path).tap do |hash|
                 hash[:device] = device
@@ -53,6 +53,19 @@ module Facter
               used: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes)
             }
           end
+
+          def read_options(options)
+            options_map = {
+              'read-only' => 'readonly',
+              'asynchronous' => 'async',
+              'synchronous' => 'noasync',
+              'quotas' => 'quota',
+              'rootfs' => 'root',
+              'defwrite' => 'deferwrites'
+            }
+
+            options.split(',').map(&:strip).map { |o| options_map.key?(o) ? options_map[o] : o }
+          end
         end
       end
     end

data/lib/facter/resolvers/networking.rb

@@ -42,7 +42,7 @@ module Facter
 
         def parse_interfaces_response(response)
           parsed_interfaces_data = {}
-          interfaces_data = Hash[*response.split(/^([A-Za-z0-9_]+): /)[1..-1]]
+          interfaces_data = Hash[*response.split(/^([A-Za-z0-9_\.]+): /)[1..-1]]
 
           interfaces_data.each do |interface_name, raw_data|
             parsed_interface_data = {}

data/lib/facter/resolvers/selinux.rb

@@ -13,21 +13,21 @@ module Facter
         end
 
         def retrieve_facts(fact_name)
-          mountpoint = read_mounts_file if @fact_list[:enabled].nil?
+          mountpoint = selinux_mountpoint
+
+          @fact_list[:enabled] = !mountpoint.empty? && read_selinux_config
           read_other_selinux_facts(mountpoint) if @fact_list[:enabled]
 
           @fact_list[fact_name]
         end
 
-        def read_mounts_file
+        def selinux_mountpoint
           output = Facter::Core::Execution.execute('cat /proc/self/mounts', logger: log)
-          @fact_list[:enabled] = false
           mountpoint = ''
 
           output.each_line do |line|
             next unless line =~ /selinuxfs/
 
-            @fact_list[:enabled] = true
             mountpoint = line.split("\s")[1]
             break
           end
@@ -35,8 +35,6 @@ module Facter
         end
 
         def read_other_selinux_facts(mountpoint)
-          return unless read_selinux_config
-
           enforce_file = "#{mountpoint}/enforce"
           policy_file = "#{mountpoint}/policyvers"
 
@@ -60,7 +58,7 @@ module Facter
             @fact_list[:config_policy] = line.split('=').last.strip if line =~ /^SELINUXTYPE=/
           end
 
-          true unless file_lines.empty?
+          !file_lines.empty? ? true : false
         end
       end
     end