facter 4.0.46 → 4.0.51

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

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

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

@@ -51,13 +51,13 @@ 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
 
       def check_if_virtual(found_vm)
-        Facter::FactsUtils::PHYSICAL_HYPERVISORS.count(found_vm).zero?
+        Facter::Util::Facts::PHYSICAL_HYPERVISORS.count(found_vm).zero?
       end
     end
   end

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

@@ -4,16 +4,35 @@ module Facts
   module Solaris
     class Ldom
       FACT_NAME = 'ldom'
+      ALIASES = %w[
+        ldom_domainchassis
+        ldom_domaincontrol
+        ldom_domainname
+        ldom_domainrole_control
+        ldom_domainrole_impl
+        ldom_domainrole_io
+        ldom_domainrole_root
+        ldom_domainrole_service
+        ldom_domainuuid
+      ].freeze
 
       def initialize
         @log = Facter::Log.new(self)
       end
 
       def call_the_resolver
+        @log.debug('Solving the ldom fact.')
+        fact_value = resolve_fact
+        return Facter::ResolvedFact.new(FACT_NAME, nil) if fact_value.nil?
+
+        create_resolved_facts_list(fact_value)
+      end
+
+      def resolve_fact
         chassis_serial = resolve(:chassis_serial)
-        return Facter::ResolvedFact.new(FACT_NAME, nil) if !chassis_serial || chassis_serial.empty?
+        return nil if !chassis_serial || chassis_serial.empty?
 
-        fact_value = {
+        {
           domainchassis: chassis_serial,
           domaincontrol: resolve(:control_domain),
           domainname: resolve(:domain_name),
@@ -26,13 +45,21 @@ module Facts
           },
           domainuuid: resolve(:domain_uuid)
         }
-
-        Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
 
       def resolve(key)
         Facter::Resolvers::Solaris::Ldom.resolve(key)
       end
+
+      def create_resolved_facts_list(fact_value)
+        resolved_facts = [Facter::ResolvedFact.new(FACT_NAME, fact_value)]
+        ALIASES.each do |fact_alias|
+          key = fact_alias.split('_')[1..-1].map!(&:to_sym)
+          resolved_facts << Facter::ResolvedFact.new(fact_alias, fact_value.dig(*key), :legacy)
+        end
+
+        resolved_facts
+      end
     end
   end
 end

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/ssh.rb

@@ -16,7 +16,7 @@ module Facts
       end
 
       def resolver_data
-        Facter::Resolvers::SshResolver.resolve(:ssh)
+        Facter::Resolvers::Ssh.resolve(:ssh)
       end
 
       def create_ssh_fact(ssh)

data/lib/facter/facts/solaris/sshalgorithmkey.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 { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
         facts
       end

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/cli/cli.rb

@@ -159,9 +159,7 @@ module Facter
     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!')
+      Facter.puppet_facts
 
       output, status = Facter.to_user_output(@options, *args)
       puts output
@@ -184,7 +182,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

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

@@ -33,10 +33,17 @@ module Facter
 
       def refresh_config(config_path)
         @conf = File.readable?(config_path) ? Hocon.load(config_path) : {}
+      rescue StandardError => e
+        log.warn("Facter failed to read config file #{config_path} with the following error: #{e.message}")
+        @conf = {}
       end
 
       private
 
+      def log
+        @log ||= Log.new(self)
+      end
+
       def default_path
         os = OsDetector.instance.identifier
 

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

@@ -24,6 +24,9 @@ module Facter
       fact_list = []
 
       @block_list.each do |group_name|
+        # legacy is a special group and does not need to be broken into facts
+        next if group_name == 'legacy'
+
         facts_for_block = @groups[group_name]
 
         fact_list += facts_for_block || [group_name]

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

@@ -181,7 +181,7 @@ cache_format_version is incorrect!")
 
       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) unless file.nil?
       rescue JSON::ParserError

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

@@ -10,10 +10,6 @@ module Facter
       @external_facts = load_external_facts
     end
 
-    def all_facts
-      @all_facts ||= Utils.deep_copy(custom_facts + external_facts)
-    end
-
     private
 
     def load_custom_facts
@@ -21,8 +17,9 @@ module Facter
 
       custom_facts_to_load = LegacyFacter.collection.custom_facts
 
-      custom_facts_to_load&.each do |custom_fact_name|
-        loaded_fact = LoadedFact.new(custom_fact_name.to_s, nil, :custom)
+      custom_facts_to_load&.each 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
       end
 
@@ -37,6 +34,7 @@ module Facter
       external_facts_to_load&.each do |k, v|
         loaded_fact = LoadedFact.new(k.to_s, nil, :external)
         loaded_fact.file = v.options[:file]
+        loaded_fact.is_env = v.options[:is_env]
         external_facts << loaded_fact
       end
 

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

@@ -24,11 +24,27 @@ module Facter
       @internal_facts = load_internal_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
+    end
+
     def load_internal_facts(options)
       @log.debug('Loading internal facts')
       internal_facts = []
@@ -67,6 +83,8 @@ module Facter
     def block_facts(facts, options)
       blocked_facts = options[:blocked_facts] || []
 
+      facts.reject! { |fact| fact.type == :legacy } if options[:block_list]&.include?('legacy')
+
       reject_list_core, reject_list_legacy = construct_reject_lists(blocked_facts, facts)
 
       facts = facts.reject do |fact|