facter 4.0.35 → 4.0.40

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

@@ -2,7 +2,7 @@
 
 module Facter
   class FactGroups
-    attr_reader :groups, :block_list
+    attr_reader :groups, :block_list, :facts_ttls
 
     @groups_ttls = []
 
@@ -14,6 +14,10 @@ module Facter
       @groups ||= File.readable?(@groups_file_path) ? Hocon.load(@groups_file_path) : {}
       load_groups
       load_groups_from_options
+      load_facts_ttls
+
+      # Reverse sort facts so that children have precedence when caching. eg: os.macosx vs os
+      @facts_ttls = @facts_ttls.sort.reverse.to_h
     end
 
     # Breakes down blocked groups in blocked facts
@@ -31,6 +35,9 @@ module Facter
 
     # Get the group name a fact is part of
     def get_fact_group(fact_name)
+      fact = get_fact(fact_name)
+      return fact[:group] if fact
+
       @groups.detect { |k, v| break k if Array(v).find { |f| fact_name =~ /^#{f}.*/ } }
     end
 
@@ -41,6 +48,15 @@ module Facter
       ttls_to_seconds(ttls[group_name])
     end
 
+    def get_fact(fact_name)
+      return @facts_ttls[fact_name] if @facts_ttls[fact_name]
+
+      result = @facts_ttls.select { |name, fact| break fact if fact_name =~ /^#{name}\..*/ }
+      return nil if result == {}
+
+      result
+    end
+
     private
 
     def load_groups_from_options
@@ -55,10 +71,28 @@ module Facter
       end
     end
 
+    def load_facts_ttls
+      @facts_ttls ||= {}
+      return if @groups_ttls == []
+
+      @groups_ttls.reduce(:merge).each do |group, ttls|
+        ttls = ttls_to_seconds(ttls)
+        if @groups[group]
+          @groups[group].each do |fact|
+            if (@facts_ttls[fact] && @facts_ttls[fact][:ttls] < ttls) || @facts_ttls[fact].nil?
+              @facts_ttls[fact] = { ttls: ttls, group: group }
+            end
+          end
+        else
+          @facts_ttls[group] = { ttls: ttls, group: group }
+        end
+      end
+    end
+
     def load_groups
       config = ConfigReader.init(Options[:config])
       @block_list = config.block_list || {}
-      @groups_ttls = config.ttls || {}
+      @groups_ttls = config.ttls || []
       @groups.merge!(config.fact_groups) if config.fact_groups
     end
 

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

@@ -40,31 +40,42 @@ module Facter
       end
     end
 
-    def group_cached?(group_name)
-      cached = @fact_groups.get_group_ttls(group_name) ? true : false
-      delete_cache(group_name) unless cached
+    def fact_cache_enabled?(fact_name)
+      fact = @fact_groups.get_fact(fact_name)
+      cached = if fact
+                 !fact[:ttls].nil?
+               else
+                 false
+               end
+
+      fact_group = @fact_groups.get_fact_group(fact_name)
+      delete_cache(fact_group) if fact_group && !cached
       cached
     end
 
     private
 
     def resolve_fact(searched_fact)
-      group_name =  if searched_fact.file
-                      searched_fact.name
-                    else
-                      @fact_groups.get_fact_group(searched_fact.name)
-                    end
+      return unless fact_cache_enabled?(searched_fact.name)
 
-      return unless group_name
+      fact = if searched_fact.file
+               @fact_groups.get_fact(File.basename(searched_fact.file))
+             else
+               @fact_groups.get_fact(searched_fact.name)
+             end
 
-      return unless group_cached?(group_name)
+      return unless fact
 
-      return unless check_ttls?(group_name)
+      return unless check_ttls?(fact[:group], fact[:ttls])
 
-      data = read_group_json(group_name)
+      read_fact(searched_fact, fact[:group])
+    end
+
+    def read_fact(searched_fact, fact_group)
+      data = read_group_json(fact_group)
       return unless data
 
-      @log.debug("loading cached values for #{group_name} facts")
+      @log.debug("loading cached values for #{searched_fact.name} facts")
 
       create_facts(searched_fact, data)
     end
@@ -93,7 +104,7 @@ module Facter
                    end
       return if !group_name || fact.value.nil?
 
-      return unless group_cached?(group_name)
+      return unless fact_cache_enabled?(fact.name)
 
       @groups[group_name] ||= {}
       @groups[group_name][fact.name] = fact.value
@@ -106,10 +117,12 @@ module Facter
       end
 
       @groups.each do |group_name, data|
-        next unless check_ttls?(group_name)
+        next unless check_ttls?(group_name, @fact_groups.get_group_ttls(group_name))
 
-        @log.debug("caching values for #{group_name} facts")
         cache_file_name = File.join(@cache_dir, group_name)
+        next if File.readable?(cache_file_name)
+
+        @log.debug("caching values for #{group_name} facts")
         File.write(cache_file_name, JSON.pretty_generate(data))
       end
     end
@@ -128,8 +141,7 @@ module Facter
       @groups[group_name] = data
     end
 
-    def check_ttls?(group_name)
-      ttls = @fact_groups.get_group_ttls(group_name)
+    def check_ttls?(group_name, ttls)
       return false unless ttls
 
       cache_file_name = File.join(@cache_dir, group_name)

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

@@ -9,6 +9,8 @@ module Facter
     def create
       fact_class = @searched_fact.fact_class
 
+      return unless fact_class
+
       fact_class.new.call_the_resolver
     end
   end

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

@@ -6,9 +6,8 @@ module Facter
 
     def resolve_facts(searched_facts)
       internal_searched_facts = filter_internal_facts(searched_facts)
-      threads = start_threads(internal_searched_facts)
-      resolved_facts = join_threads(threads, internal_searched_facts)
 
+      resolved_facts = resolve(internal_searched_facts)
       nil_resolved_facts = resolve_nil_facts(searched_facts)
 
       resolved_facts.concat(nil_resolved_facts)
@@ -29,36 +28,23 @@ module Facter
       resolved_facts
     end
 
-    def start_threads(searched_facts)
-      threads = []
-      # only resolve a fact once, even if multiple search facts depend on that fact
+    def resolve(searched_facts)
+      resolved_facts = []
+
       searched_facts
         .uniq { |searched_fact| searched_fact.fact_class.name }
         .each do |searched_fact|
-        threads << Thread.new do
-          begin
-            fact = CoreFact.new(searched_fact)
-            fact.create
-          rescue StandardError => e
-            @@log.log_exception(e)
-            nil
-          end
+        begin
+          fact = CoreFact.new(searched_fact)
+          fact_value = nil
+          Facter::Framework::Benchmarking::Timer.measure(searched_fact.name) { fact_value = fact.create }
+          resolved_facts << fact_value unless fact_value.nil?
+        rescue StandardError => e
+          @@log.log_exception(e)
         end
       end
 
-      threads
-    end
-
-    def join_threads(threads, searched_facts)
-      resolved_facts = []
-
-      threads.each do |thread|
-        thread.join
-        resolved_facts << thread.value unless thread.value.nil?
-      end
-
       resolved_facts.flatten!
-
       FactAugmenter.augment_resolved_facts(searched_facts, resolved_facts)
     end
   end

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

@@ -7,6 +7,8 @@ module Facter
   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)
@@ -18,6 +20,17 @@ module Facter
 
     private
 
+    # This will filter out the legacy facts that should be blocked. Because some legacy facts are just aliases
+    # to the core ones, even if they are blocked, facter will resolved them but they won't be displayed.
+
+    def filter_blocked_legacy_facts!(facts)
+      blocked_facts = Options[:blocked_facts] || []
+
+      facts.reject! do |fact|
+        blocked_facts.select { |blocked_fact| fact.name.match(/^#{blocked_fact}/) && fact.type == :legacy }.any?
+      end
+    end
+
     def filter_legacy_facts!(resolved_facts)
       return unless !Options[:show_legacy] && Options[:user_query].empty?
 

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

@@ -20,55 +20,81 @@ module Facter
 
       @facts = []
       @external_facts = []
-      load_internal_facts(options)
-      load_external_facts(options)
 
-      @facts
+      @internal_facts = load_internal_facts(options)
+      @external_facts = load_external_facts(options)
+
+      @facts = @internal_facts + @external_facts
     end
 
     private
 
     def load_internal_facts(options)
       @log.debug('Loading internal facts')
+      internal_facts = []
 
       if options[: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
+        internal_facts = @internal_loader.facts
       else
         @log.debug('Load only core facts')
-        @internal_facts = @internal_loader.core_facts
+        internal_facts = @internal_loader.core_facts
       end
 
-      @internal_facts = block_facts(@internal_facts, options)
-      @facts.concat(@internal_facts)
+      block_facts(internal_facts, options)
     end
 
     def load_external_facts(options)
       @log.debug('Loading external facts')
+      external_facts = []
+
       if options[:custom_facts]
         @log.debug('Loading custom facts')
-        @external_facts.concat(@external_fact_loader.custom_facts)
+        external_facts += @external_fact_loader.custom_facts
       end
 
-      @external_facts = block_facts(@external_facts, options)
+      external_facts = block_facts(external_facts, options)
 
       if options[:external_facts]
         @log.debug('Loading external facts')
-        @external_facts.concat(@external_fact_loader.external_facts)
+        external_facts += @external_fact_loader.external_facts
       end
 
-      @facts.concat(@external_facts)
+      external_facts
     end
 
     def block_facts(facts, options)
       blocked_facts = options[:blocked_facts] || []
 
+      reject_list_core, reject_list_legacy = construct_reject_lists(blocked_facts, facts)
+
       facts = facts.reject do |fact|
-        blocked_facts.select { |blocked_fact| fact.name.match(/^#{blocked_fact}/) }.any?
+        reject_list_core.include?(fact) || reject_list_core.find do |fact_to_block|
+          fact_to_block.klass == fact.klass
+        end || reject_list_legacy.include?(fact)
       end
 
       facts
     end
+
+    def construct_reject_lists(blocked_facts, facts)
+      reject_list_core = []
+      reject_list_legacy = []
+
+      blocked_facts.each do |blocked|
+        facts.each do |fact|
+          next unless fact.name =~ /^#{blocked}/
+
+          if fact.type == :core
+            reject_list_core << fact
+          else
+            reject_list_legacy << fact
+          end
+        end
+      end
+
+      [reject_list_core, reject_list_legacy]
+    end
   end
 end

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

@@ -30,18 +30,18 @@ module Facter
     def load_for_os(operating_system)
       # select only classes
       classes = ClassDiscoverer.instance.discover_classes(operating_system)
-
       classes.each do |class_name|
         fact_name = class_name::FACT_NAME
-
         # if fact is already loaded, skip it
-        next if @facts.any? { |fact| fact.name == fact_name }
-
-        type = class_name.const_defined?('TYPE') ? class_name::TYPE : :core
-        load_fact(fact_name, class_name, type)
+        unless @facts.any? { |fact| fact.name == fact_name }
+          type = class_name.const_defined?('TYPE') ? class_name::TYPE : :core
+          load_fact(fact_name, class_name, type)
+        end
         next unless class_name.const_defined?('ALIASES')
 
-        [*class_name::ALIASES].each { |fact_alias| load_fact(fact_alias, class_name, :legacy) }
+        [*class_name::ALIASES].each do |fact_alias|
+          load_fact(fact_alias, class_name, :legacy) unless @facts.any? { |fact| fact.name == fact_alias }
+        end
       end
     end
 

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

@@ -39,6 +39,8 @@ load_dir(['resolvers'])
 load_dir(['facts_utils'])
 load_dir(%w[framework core])
 load_dir(['models'])
+load_dir(%w[framework benchmarking])
+
 load_dir(%w[framework core fact_loaders])
 load_dir(%w[framework core fact internal])
 load_dir(%w[framework core fact external])

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

@@ -46,7 +46,9 @@ module Facter
         return unless file_global_conf
 
         if Options.cli?
-          @options[:custom_facts] = !file_global_conf['no-custom-facts'] unless file_global_conf['no-custom-facts'].nil?
+          unless file_global_conf['no-custom-facts'].nil?
+            @options[:no_custom_facts] = file_global_conf['no-custom-facts']
+          end
         end
 
         @options[:custom_dir] = file_global_conf['custom-dir'] unless file_global_conf['custom-dir'].nil?
@@ -57,7 +59,7 @@ module Facter
         return unless global_conf
 
         if Options.cli?
-          @options[:external_facts] = !global_conf['no-external-facts'] unless global_conf['no-external-facts'].nil?
+          @options[:no_external_facts] = global_conf['no-external-facts'] unless global_conf['no-external-facts'].nil?
         end
 
         @options[:external_dir] = [global_conf['external-dir']].flatten unless global_conf['external-dir'].nil?
@@ -67,7 +69,7 @@ module Facter
       def augment_ruby(global_conf)
         return unless global_conf
 
-        @options[:ruby] = global_conf['no-ruby'].nil? ? true : !global_conf['no-ruby']
+        @options[:no_ruby] = global_conf['no-ruby'].nil? ? false : global_conf['no-ruby']
       end
 
       def augment_show_legacy(global_conf)

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

@@ -22,16 +22,17 @@ module Facter
     @user_query = []
     @block_list = {}
     @fact_groups = {}
-    @color = false
+    @color = true
+    @timing = false
 
     class << self
-      attr_reader :debug, :verbose, :log_level, :show_legacy, :ruby,
-                  :custom_facts, :blocked_facts
+      attr_reader :debug, :verbose, :log_level, :show_legacy,
+                  :custom_facts, :blocked_facts, :ruby, :external_facts
 
-      attr_accessor :config, :user_query, :strict, :json, :haml, :external_facts,
+      attr_accessor :config, :user_query, :strict, :json, :haml,
                     :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
                     :config_file_external_dir, :default_external_dir, :fact_groups,
-                    :block_list, :color, :trace
+                    :block_list, :color, :trace, :timing
 
       attr_writer :external_dir
 
@@ -44,16 +45,28 @@ module Facter
         options
       end
 
-      def ruby=(bool)
-        if bool == true
-          @ruby = true
-        else
+      def no_ruby=(bool)
+        if bool
           @ruby = false
           @custom_facts = false
           @blocked_facts << 'ruby'
+        else
+          @ruby = true
         end
       end
 
+      def no_block=(bool)
+        @block = !bool
+      end
+
+      def no_cache=(bool)
+        @cache = !bool
+      end
+
+      def no_color=(bool)
+        @color = !bool
+      end
+
       def external_dir
         return fallback_external_dir if @external_dir.empty? && @external_facts
 
@@ -98,8 +111,8 @@ module Facter
         end
       end
 
-      def custom_facts=(bool)
-        if bool == true
+      def no_custom_facts=(bool)
+        if bool == false
           @custom_facts = true
           @ruby = true
         else
@@ -107,6 +120,10 @@ module Facter
         end
       end
 
+      def no_external_facts=(bool)
+        @external_facts = !bool
+      end
+
       def log_level=(level)
         level = level.to_sym
         case level
@@ -155,10 +172,12 @@ module Facter
         @custom_facts = true
         @external_dir = []
         @default_external_dir = []
+        @config_file_external_dir = []
         @external_facts = true
         @blocked_facts = []
         @fact_groups = {}
         @block_list = {}
+        @timing = false
       end
 
       def fallback_external_dir