facter 4.1.1 → 4.2.3

data/lib/facter/facts/windows/virtual.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Virtual
+      FACT_NAME = 'virtual'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Windows::Virtualization.resolve(:virtual)
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facter/framework/cli/cli.rb

@@ -97,6 +97,11 @@ module Facter
                  type: :boolean,
                  desc: 'Resolve facts sequentially'
 
+    class_option :puppet,
+                 type: :boolean,
+                 aliases: '-p',
+                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
+
     desc '--man', 'Display manual.', hide: true
     map ['--man'] => :man
     def man(*args)
@@ -111,6 +116,7 @@ module Facter
 
     desc 'query', 'Default method', hide: true
     def query(*args)
+      Facter.puppet_facts if options[:puppet]
       output, status = Facter.to_user_output(@options, *args)
       puts output
 
@@ -126,7 +132,7 @@ module Facter
       Facter.values(@options, args)
     end
 
-    desc '--version, -v', 'Print the version', hide: true
+    desc '--version, -v', 'Print the version'
     map ['--version', '-v'] => :version
     def version(*_args)
       puts Facter::VERSION
@@ -156,19 +162,7 @@ module Facter
       puts cache_groups
     end
 
-    desc '--puppet, -p', 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
-    map ['--puppet', '-p'] => :puppet
-    def puppet(*args)
-      Facter.puppet_facts
-
-      output, status = Facter.to_user_output(@options, *args)
-      puts output
-
-      status = 1 if Facter::Log.errors?
-      exit status
-    end
-
-    desc 'help', 'Help for all arguments'
+    desc '--help, -h', 'Help for all arguments'
     def help(*args)
       help_string = +''
       help_string << help_header(args)
@@ -205,7 +199,11 @@ module Facter
         Cli.commands
            .select { |_k, command_class| command_class.instance_of?(Thor::Command) }
            .each do |_k, command|
-          help_command_options << build_option(command['name'], [], command['description'])
+          help_command_options << build_option(
+            command['name'],
+            [command['usage'].split(',')[1]],
+            command['description']
+          )
         end
 
         help_command_options

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

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,23 @@
 
 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')
                          resolve_sequentially(internal_searched_facts)
                        else
-                         @@log.debug('Resolving fact in parallel')
-                         threads = start_threads(internal_searched_facts)
-                         join_threads(threads, internal_searched_facts)
+                         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 +30,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 +51,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, user_query)
-      filter_legacy_facts!(searched_facts) if user_query.empty?
-      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

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

@@ -29,7 +29,6 @@ module Facter
     end
 
     def load_internal_facts(user_query, options)
-      @log.debug('Loading internal facts')
       internal_facts = []
       if user_query || options[:show_legacy]
         # if we have a user query, then we must search in core facts and legacy facts

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

@@ -13,6 +13,7 @@ module Facter
     end
 
     def resolve_facts(user_query = [])
+      log_resolving_method
       @options[:user_query] = user_query
       cache_manager = Facter::CacheManager.new
 
@@ -40,6 +41,7 @@ module Facter
     # - load all the core facts, external facts and env facts
     # - load all custom facts
     def resolve_fact(user_query)
+      log_resolving_method
       @options[:user_query] = user_query
       @log.debug("resolving fact with user_query: #{user_query}")
 
@@ -58,12 +60,21 @@ module Facter
     end
 
     def resolve_core(user_query = [], options = {})
+      log_resolving_method
       @cache_manager = CacheManager.new
       core_fact(user_query, options)
     end
 
     private
 
+    def log_resolving_method
+      if Options[:sequential]
+        @log.debugonce('Resolving facts sequentially')
+      else
+        @log.debugonce('Resolving fact in parallel')
+      end
+    end
+
     def core_fact(user_query, options)
       loaded_facts_hash = @fact_loader.load_internal_facts(user_query, options)
 

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/logging/logger.rb

@@ -15,8 +15,16 @@ module Facter
     @@logger = nil
     @@message_callback = nil
     @@has_errors = false
+    @@debug_messages = []
+    @@warn_messages = []
+    @@timing = false
 
     class << self
+      def clear_messages
+        @@debug_messages.clear
+        @@warn_messages.clear
+      end
+
       def on_message(&block)
         @@message_callback = block
       end
@@ -47,6 +55,41 @@ module Facter
           "[#{datetime}] #{severity} #{msg} \n"
         end
       end
+
+      # Print an exception message, and optionally a backtrace if trace is set
+
+      # Print timing information
+      #
+      # @param string [String] the time to print
+      # @return [void]
+      #
+      # @api private
+      def show_time(string)
+        return unless string && timing?
+
+        if @@message_callback
+          @@message_callback.call(:info, string)
+        else
+          warn("#{GREEN}#{string}#{RESET}")
+        end
+      end
+
+      # Enable or disable logging of timing information
+      #
+      # @param bool [true, false]
+      # @return [void]
+      #
+      # @api private
+      def timing(bool)
+        @@timing = bool
+      end
+
+      # Returns whether timing output is turned on
+      #
+      # @api private
+      def timing?
+        @@timing
+      end
     end
 
     def initialize(logged_class)
@@ -68,6 +111,16 @@ module Facter
       end
     end
 
+    def debugonce(msg)
+      return unless debugging_active?
+
+      message_string = msg.to_s
+      return if @@debug_messages.include? message_string
+
+      @@debug_messages << message_string
+      debug(message_string)
+    end
+
     def info(msg)
       if msg.nil? || msg.empty?
         empty_message_error(msg)
@@ -88,6 +141,14 @@ module Facter
       end
     end
 
+    def warnonce(message)
+      message_string = message.to_s
+      return if @@warn_messages.include? message_string
+
+      @@warn_messages << message_string
+      warn(message_string)
+    end
+
     def error(msg, colorize = false)
       @@has_errors = true
 

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

@@ -24,13 +24,11 @@ module Facter
       # Returns a list of SearchedFact objects that resolve the users query.
       def parse(query_list, loaded_fact)
         matched_facts = []
-        @log.debug "User query is: #{query_list}"
         @query_list = query_list
 
         return no_user_query(loaded_fact) unless query_list.any?
 
         query_list.each do |query|
-          @log.debug "Query is #{query}"
           found_facts = search_for_facts(query, loaded_fact)
           matched_facts << found_facts
         end
@@ -41,7 +39,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,13 +57,12 @@ 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
 
       def get_facts_matching_tokens(query_tokens, query_token_range, loaded_fact_hash)
-        @log.debug "Checking query tokens #{query_tokens[query_token_range].join('.')}"
         resolvable_fact_list = []
 
         loaded_fact_hash.each do |loaded_fact|
@@ -73,11 +70,11 @@ module Facter
 
           next unless found_fact?(loaded_fact.name, query_fact)
 
-          searched_fact = construct_loaded_fact(query_tokens, query_token_range, loaded_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}"
+        @log.debug "List of resolvable facts: #{resolvable_fact_list.inspect}" if resolvable_fact_list.any?
         resolvable_fact_list
       end
 
@@ -93,23 +90,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.drop(query_token_range.size).map do |token|
-          token =~ /^[0-9]+$/ ? token.to_i : token
-        end
-      end
     end
   end
 end