facter 4.0.52 → 4.2.2

data/lib/facter/facts/windows/hypervisors/vmware.rb

@@ -15,7 +15,7 @@ module Facts
         private
 
         def vmware?
-          Facter::Resolvers::Virtualization.resolve(:virtual) == 'vmware' ||
+          Facter::Resolvers::Windows::Virtualization.resolve(:virtual) == 'vmware' ||
             Facter::Resolvers::DMIBios.resolve(:manufacturer) == 'VMware, Inc.'
         end
       end

data/lib/facter/facts/windows/hypervisors/xen.rb

@@ -7,7 +7,9 @@ module Facts
         FACT_NAME = 'hypervisors.xen'
 
         def call_the_resolver
-          fact_value = { context: hvm? ? 'hvm' : 'pv' } if Facter::Resolvers::Virtualization.resolve(:virtual) == 'xen'
+          if Facter::Resolvers::Windows::Virtualization.resolve(:virtual) == 'xen'
+            fact_value = { context: hvm? ? 'hvm' : 'pv' }
+          end
 
           Facter::ResolvedFact.new(FACT_NAME, fact_value)
         end

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

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

data/lib/facter/facts/windows/{virtualization/is_virtual.rb → processors/cores.rb}

@@ -2,12 +2,12 @@
 
 module Facts
   module Windows
-    module Virtualization
-      class IsVirtual
-        FACT_NAME = 'is_virtual'
+    module Processors
+      class Cores
+        FACT_NAME = 'processors.cores'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::Virtualization.resolve(:is_virtual)
+          fact_value = Facter::Resolvers::Processors.resolve(:cores_per_socket)
 
           Facter::ResolvedFact.new(FACT_NAME, fact_value)
         end

data/lib/facter/facts/windows/{virtualization/virtual.rb → processors/threads.rb}

@@ -2,12 +2,12 @@
 
 module Facts
   module Windows
-    module Virtualization
-      class Virtual
-        FACT_NAME = 'virtual'
+    module Processors
+      class Threads
+        FACT_NAME = 'processors.threads'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::Virtualization.resolve(:virtual)
+          fact_value = Facter::Resolvers::Processors.resolve(:threads_per_core)
 
           Facter::ResolvedFact.new(FACT_NAME, fact_value)
         end

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,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, 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/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,44 +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
@@ -60,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)