facter 4.0.43 → 4.0.49

data/lib/facter/facts/solaris/sshfp_algorithm.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
                                             "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)

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

@@ -51,7 +51,7 @@ module Facts
 
         return unless product_name
 
-        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+        Facter::Util::Facts::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
 
         nil
       end

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

@@ -4,6 +4,7 @@ module Facts
   module Windows
     class DhcpServers
       FACT_NAME = 'dhcp_servers'
+      TYPE = :legacy
 
       def call_the_resolver
         fact_value = construct_addresses_hash

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

@@ -4,6 +4,7 @@ module Facts
   module Windows
     class Interfaces
       FACT_NAME = 'interfaces'
+      TYPE = :legacy
 
       def call_the_resolver
         fact_value = Facter::Resolvers::Windows::Networking.resolve(:interfaces)

data/lib/facter/facts/windows/memory/system/available.rb

@@ -10,7 +10,7 @@ module Facts
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Memory.resolve(:available_bytes)
-            fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value)
+            fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value)
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/windows/memory/system/available_bytes.rb

@@ -12,7 +12,7 @@ module Facts
             fact_value = Facter::Resolvers::Memory.resolve(:available_bytes)
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/windows/memory/system/total.rb

@@ -10,7 +10,7 @@ module Facts
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Memory.resolve(:total_bytes)
-            fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value)
+            fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value)
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/windows/memory/system/total_bytes.rb

@@ -12,7 +12,7 @@ module Facts
             fact_value = Facter::Resolvers::Memory.resolve(:total_bytes)
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/windows/memory/system/used.rb

@@ -9,7 +9,7 @@ module Facts
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Memory.resolve(:used_bytes)
-            fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value)
+            fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value)
 
             Facter::ResolvedFact.new(FACT_NAME, fact_value)
           end

data/lib/facter/facts/windows/networking/fqdn.rb

@@ -12,7 +12,7 @@ module Facts
           hostname = Facter::Resolvers::Hostname.resolve(:hostname)
           return Facter::ResolvedFact.new(FACT_NAME, nil) if !hostname || hostname.empty?
 
-          fact_value = [hostname, domain].compact.join('.')
+          fact_value = domain && !domain.empty? ? [hostname, domain].compact.join('.') : hostname
 
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end

data/lib/facter/facts/windows/os/release.rb

@@ -16,7 +16,7 @@ module Facts
             kernel_version: kernel_resolver(:kernelversion)
           }
 
-          fact_value = Facter::WindowsReleaseFinder.find_release(input)
+          fact_value = Facter::Util::Facts::WindowsReleaseFinder.find_release(input)
           arr << Facter::ResolvedFact.new(FACT_NAME, ({ full: fact_value, major: fact_value } if fact_value))
           ALIASES.each { |aliass| arr << Facter::ResolvedFact.new(aliass, fact_value, :legacy) }
           arr

data/lib/facter/framework/benchmarking/timer.rb

@@ -7,11 +7,13 @@ module Facter
     module Benchmarking
       class Timer
         class << self
-          def measure(fact_name)
+          def measure(fact_name, prefix_message = '')
             if Options[:timing]
               time = Benchmark.measure { yield }
 
-              puts "fact `#{fact_name}`, took: #{time.format('%r')} seconds"
+              log = "fact '#{fact_name}', took: #{time.format('%r')} seconds"
+              prefix_message = "#{prefix_message} " unless prefix_message.empty?
+              puts "#{prefix_message}#{log}"
             else
               yield
             end

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

@@ -79,11 +79,6 @@ module Facter
                  type: :boolean,
                  desc: 'Show legacy facts when querying all facts.'
 
-    class_option :puppet,
-                 type: :boolean,
-                 aliases: '-p',
-                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
-
     class_option :yaml,
                  aliases: '-y',
                  type: :boolean,
@@ -98,6 +93,10 @@ module Facter
                  aliases: '-t',
                  desc: 'Show how much time it took to resolve each fact'
 
+    class_option :sequential,
+                 type: :boolean,
+                 desc: 'Resolve facts sequentially'
+
     desc '--man', 'Display manual.', hide: true
     map ['--man'] => :man
     def man(*args)
@@ -157,6 +156,20 @@ module Facter
       puts cache_groups
     end
 
+    desc '--puppet, -p', '(NOT SUPPORTED)Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
+    map ['--puppet', '-p'] => :puppet
+    def puppet(*args)
+      log = Log.new(self)
+      log.warn('`facter --puppet` and `facter -p` are no longer supported, use `puppet facts show` instead')
+      log.warn('the output does not contain 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'
     def help(*args)
       help_string = +''
@@ -171,7 +184,7 @@ module Facter
       def help_header(_args)
         path = File.join(File.dirname(__FILE__), '../../')
 
-        Util::FileHelper.safe_read("#{path}fixtures/facter_help_header")
+        Facter::Util::FileHelper.safe_read("#{path}fixtures/facter_help_header")
       end
 
       IGNORE_OPTIONS = %w[log_level color no_color].freeze
@@ -201,6 +214,7 @@ module Facter
       end
 
       def build_option(name, aliases, description)
+        name = name.tr('_', '-')
         help_option = +''
         help_option << aliases.join(',').rjust(10)
         help_option << ' '

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

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
 
+require 'facter/config'
+
 module Facter
   class FactGroups
+    attr_accessor :groups_ttls
     attr_reader :groups, :block_list, :facts_ttls
 
-    @groups_ttls = []
-
     STRING_TO_SECONDS = { 'seconds' => 1, 'minutes' => 60, 'hours' => 3600, 'days' => 3600 * 24 }.freeze
 
-    def initialize(group_list_path = nil)
-      default_path = File.join(File.dirname(__FILE__), '../../fact_groups.conf')
-      @groups_file_path = group_list_path || default_path
-      @groups ||= File.readable?(@groups_file_path) ? Hocon.load(@groups_file_path) : {}
+    def initialize
+      @groups = Facter::Config::FACT_GROUPS.dup
       load_groups
       load_groups_from_options
       load_facts_ttls
@@ -38,7 +37,10 @@ module Facter
       fact = get_fact(fact_name)
       return fact[:group] if fact
 
-      @groups.detect { |k, v| break k if Array(v).find { |f| fact_name =~ /^#{f}.*/ } }
+      # @groups.detect { |k, v| break k if Array(v).find { |f| fact_name =~ /^#{f}.*/ } }
+      @groups.detect do |k, v|
+        break k if Array(v).find { |f| fact_name.include?('.*') ? fact_name == f : fact_name =~ /^#{f}.*/ }
+      end
     end
 
     # Get config ttls for a given group
@@ -91,7 +93,7 @@ module Facter
 
     def load_groups
       config = ConfigReader.init(Options[:config])
-      @block_list = config.block_list || {}
+      @block_list = config.block_list || []
       @groups_ttls = config.ttls || []
       @groups.merge!(config.fact_groups) if config.fact_groups
     end

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

@@ -10,7 +10,7 @@ module Facter
     end
 
     def resolve_facts(searched_facts)
-      return searched_facts, [] if !File.directory?(@cache_dir) || !Options[:cache]
+      return searched_facts, [] if (!File.directory?(@cache_dir) || !Options[:cache]) && Options[:ttls].any?
 
       facts = []
       searched_facts.delete_if do |fact|
@@ -27,8 +27,9 @@ module Facter
     end
 
     def cache_facts(resolved_facts)
-      return unless Options[:cache]
+      return unless Options[:cache] && Options[:ttls].any?
 
+      @groups = {}
       resolved_facts.each do |fact|
         cache_fact(fact)
       end
@@ -48,8 +49,8 @@ module Facter
                  false
                end
 
-      fact_group = @fact_groups.get_fact_group(fact_name)
-      delete_cache(fact_group) if fact_group && !cached
+      # fact_group = @fact_groups.get_fact_group(fact_name)
+      # delete_cache(fact_group) if fact_group && !cached
       cached
     end
 
@@ -66,6 +67,8 @@ module Facter
 
       fact = @fact_groups.get_fact(fact_name)
 
+      return if external_fact_in_custom_group?(searched_fact, fact_name, fact)
+
       return unless fact
 
       return unless check_ttls?(fact[:group], fact[:ttls])
@@ -73,31 +76,70 @@ module Facter
       read_fact(searched_fact, fact[:group])
     end
 
+    def external_fact_in_custom_group?(searched_fact, fact_name, fact)
+      if searched_fact.type == :file && fact[:group] != fact_name
+        @log.error("Cannot cache '#{fact_name}' fact from '#{fact[:group]}' group. "\
+                    'Caching custom group is not supported for external facts.')
+        return true
+      end
+
+      false
+    end
+
     def read_fact(searched_fact, fact_group)
-      data = read_group_json(fact_group)
+      data = nil
+      Facter::Framework::Benchmarking::Timer.measure(searched_fact.name, 'cached') do
+        data = read_group_json(fact_group)
+      end
       return unless data
 
+      unless searched_fact.file
+        return unless valid_format_version?(searched_fact, data, fact_group)
+
+        delete_cache(fact_group) unless data.keys.grep(/#{searched_fact.name}/).any?
+        # data.fetch(searched_fact.name) { delete_cache(fact_group) }
+      end
+
       @log.debug("loading cached values for #{searched_fact.name} facts")
 
       create_facts(searched_fact, data)
     end
 
+    def valid_format_version?(searched_fact, data, fact_group)
+      unless data['cache_format_version'] == 1
+        @log.debug("The fact #{searched_fact.name} could not be read from the cache, \
+cache_format_version is incorrect!")
+        delete_cache(fact_group)
+        return false
+      end
+
+      true
+    end
+
     def create_facts(searched_fact, data)
       if searched_fact.type == :file
-        facts = []
-        data.each do |fact_name, fact_value|
-          fact = Facter::ResolvedFact.new(fact_name, fact_value, searched_fact.type,
-                                          searched_fact.user_query, searched_fact.filter_tokens)
-          fact.file = searched_fact.file
-          facts << fact
-        end
-        facts
+        resolve_external_fact(searched_fact, data)
       else
+        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)]
       end
     end
 
+    def resolve_external_fact(searched_fact, data)
+      facts = []
+      data.each do |fact_name, fact_value|
+        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)
+        fact.file = searched_fact.file
+        facts << fact
+      end
+      facts
+    end
+
     def cache_fact(fact)
       fact_name = if fact.file
                     File.basename(fact.file)
@@ -107,7 +149,7 @@ module Facter
 
       group_name = @fact_groups.get_fact_group(fact_name)
 
-      return if !group_name || fact.value.nil?
+      return unless group_name
 
       return unless fact_cache_enabled?(fact_name)
 
@@ -128,6 +170,8 @@ module Facter
         next if File.readable?(cache_file_name)
 
         @log.debug("caching values for #{group_name} facts")
+
+        data['cache_format_version'] = 1
         File.write(cache_file_name, JSON.pretty_generate(data))
       end
     end
@@ -137,9 +181,9 @@ module Facter
 
       cache_file_name = File.join(@cache_dir, group_name)
       data = nil
-      file = Util::FileHelper.safe_read(cache_file_name)
+      file = Facter::Util::FileHelper.safe_read(cache_file_name)
       begin
-        data = JSON.parse(file)
+        data = JSON.parse(file) unless file.nil?
       rescue JSON::ParserError
         delete_cache(group_name)
       end
@@ -158,12 +202,13 @@ module Facter
         File.delete(cache_file_name)
       end
 
-      @log.debug("#{group_name} facts cache file expired/missing")
+      @log.debug("#{group_name} facts cache file expired, missing or is corrupt")
       true
     end
 
     def delete_cache(group_name)
       cache_file_name = File.join(@cache_dir, group_name)
+
       File.delete(cache_file_name) if File.readable?(cache_file_name)
     end
   end

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

@@ -11,7 +11,12 @@ module Facter
 
       return unless fact_class
 
-      fact_class.new.call_the_resolver
+      fact_value = nil
+      Facter::Framework::Benchmarking::Timer.measure(@searched_fact.name) do
+        fact_value = fact_class.new.call_the_resolver
+      end
+
+      fact_value
     end
   end
 end

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

@@ -7,7 +7,15 @@ module Facter
     def resolve_facts(searched_facts)
       internal_searched_facts = filter_internal_facts(searched_facts)
 
-      resolved_facts = resolve(internal_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)
+                       end
+
       nil_resolved_facts = resolve_nil_facts(searched_facts)
 
       resolved_facts.concat(nil_resolved_facts)
@@ -28,7 +36,7 @@ module Facter
       resolved_facts
     end
 
-    def resolve(searched_facts)
+    def resolve_sequentially(searched_facts)
       resolved_facts = []
 
       searched_facts
@@ -36,8 +44,7 @@ module Facter
         .each do |searched_fact|
         begin
           fact = CoreFact.new(searched_fact)
-          fact_value = nil
-          Facter::Framework::Benchmarking::Timer.measure(searched_fact.name) { fact_value = fact.create }
+          fact_value = fact.create
           resolved_facts << fact_value unless fact_value.nil?
         rescue StandardError => e
           @@log.log_exception(e)
@@ -47,5 +54,32 @@ module Facter
       resolved_facts.flatten!
       FactAugmenter.augment_resolved_facts(searched_facts, resolved_facts)
     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)
+        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)
+      fact = CoreFact.new(searched_fact)
+      fact.create
+    rescue StandardError => e
+      @@log.log_exception(e)
+      nil
+    end
   end
 end