facter 4.0.41 → 4.0.47

data/lib/facter/facts/solaris/memory/swap/available.rb

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

data/lib/facter/facts/solaris/memory/swap/available_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:available_bytes] if fact_value
 
             [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/solaris/memory/swap/total.rb

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

data/lib/facter/facts/solaris/memory/swap/total_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:total_bytes] if fact_value
 
             [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/solaris/memory/swap/used.rb

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

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

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

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

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:available_bytes] if fact_value
 
             [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/solaris/memory/system/total.rb

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

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

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:total_bytes] if fact_value
 
             [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/solaris/memory/system/used.rb

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

data/lib/facter/facts/solaris/processors/speed.rb

@@ -8,7 +8,7 @@ module Facts
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Solaris::Processors.resolve(:speed)
-          speed = Facter::FactsUtils::UnitConverter.hertz_to_human_readable(fact_value)
+          speed = Facter::Util::Facts::UnitConverter.hertz_to_human_readable(fact_value)
           Facter::ResolvedFact.new(FACT_NAME, speed)
         end
       end

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/solaris/zones.rb

@@ -28,7 +28,7 @@ module Facts
         end
 
         resolved_facts << Facter::ResolvedFact.new('solaris_zones.zones', zones)
-        resolved_facts << Facter::ResolvedFact.new('zones', results.count.to_s, :legacy)
+        resolved_facts << Facter::ResolvedFact.new('zones', results.count, :legacy)
 
         resolved_facts.flatten
       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/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

@@ -75,11 +75,6 @@ module Facter
                  type: :boolean,
                  desc: 'Enable verbose (info) output.'
 
-    class_option :puppet,
-                 type: :boolean,
-                 aliases: '-p',
-                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
-
     class_option :show_legacy,
                  type: :boolean,
                  desc: 'Show legacy facts when querying all facts.'
@@ -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,21 +49,25 @@ 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
 
     private
 
     def resolve_fact(searched_fact)
-      return unless fact_cache_enabled?(searched_fact.name)
+      fact_name = if searched_fact.file
+                    File.basename(searched_fact.file)
+                  else
+                    searched_fact.name
+                  end
+
+      return unless fact_cache_enabled?(fact_name)
+
+      fact = @fact_groups.get_fact(fact_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 if external_fact_in_custom_group?(searched_fact, fact_name, fact)
 
       return unless fact
 
@@ -71,40 +76,82 @@ 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)
-      group_name = if fact.file
-                     File.basename(fact.file)
-                   else
-                     @fact_groups.get_fact_group(fact.name)
-                   end
-      return if !group_name || fact.value.nil?
+      fact_name = if fact.file
+                    File.basename(fact.file)
+                  else
+                    fact.name
+                  end
+
+      group_name = @fact_groups.get_fact_group(fact_name)
 
-      return unless fact_cache_enabled?(fact.name)
+      return unless group_name
+
+      return unless fact_cache_enabled?(fact_name)
 
       @groups[group_name] ||= {}
       @groups[group_name][fact.name] = fact.value
@@ -123,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
@@ -132,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
@@ -153,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