facter 4.0.52 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 778d4d972d3e950f98d4fd8dbd4100e7b2a0c168369949b234d7088ddeba539f
-  data.tar.gz: 50303cfdfcf434c38d3d9539c35362f190dd84b82a8f85227d804a876b5a4ce3
+  metadata.gz: c5eeb6c68641c9730832a6e41af6bd0bf5367f1953cd737122356a1ddb9a1265
+  data.tar.gz: 3ead9f3065982b9eb476844a21901d5fd1fa8bc1f165b3118490054b004352df
 SHA512:
-  metadata.gz: 38f84ef3e3699e3bed3b348ae07562f9423121011659ef9ebac4395a157eb06bd110a64e7481f82331e8f65e908936df826c630f57f879ba79686bee0878ac5a
-  data.tar.gz: bf2a8b2d1d1e23a0d0ba22f21d2b8e228bc238f2eededc1ab4474dff9e0d5f13094ec2c5990f24916a563b28fd75bfa2d745bd728d2f6cda9b31283116d9df34
+  metadata.gz: 6c10f947a77e46942b5b062b2f3e1ded108b15f9f3a48202e75681be8590400644f42f6d3f3496061741ed81e8fca9ae314098257f1036d6ac09fee694e9a366
+  data.tar.gz: 39b85182513dd1a2b8737785cf5b56f946df171c62462bd39cb32008d52ba7cf2c23d27e91e55998e4b037734838f3eba061d3b96d41c11b2cffe1714d1de838

data/lib/facter.rb

@@ -253,23 +253,6 @@ module Facter
       self
     end
 
-    # Returns a fact object by name.  If you use this, you still have to
-    # call {Facter::Util::Fact#value `value`} on it to retrieve the actual
-    # value.
-    #
-    # @param user_query [String] the name of the fact
-    #
-    # @return [Facter::Util::Fact, nil] The fact object, or nil if no fact
-    #   is found.
-    #
-    # @api public
-    def fact(user_query)
-      user_query = user_query.to_s
-      resolve_fact(user_query)
-
-      @already_searched[user_query]
-    end
-
     # Reset search paths for custom and external facts
     # If config file is set custom and external facts will be reloaded
     #
@@ -411,9 +394,27 @@ module Facter
     def value(user_query)
       user_query = user_query.to_s
       resolve_fact(user_query)
+
       @already_searched[user_query]&.value
     end
 
+    # Returns a fact object by name.  If you use this, you still have to
+    # call {Facter::Util::Fact#value `value`} on it to retrieve the actual
+    # value.
+    #
+    # @param user_query [String] the name of the fact
+    #
+    # @return [Facter::Util::Fact, nil] The fact object, or nil if no fact
+    #   is found.
+    #
+    # @api public
+    def fact(user_query)
+      user_query = user_query.to_s
+      resolve_fact(user_query)
+
+      @already_searched[user_query]
+    end
+
     # Returns Facter version
     #
     # @return [String] Current version
@@ -545,15 +546,14 @@ module Facter
     # @return [ResolvedFact]
     def resolve_fact(user_query)
       user_query = user_query.to_s
-      resolved_facts = Facter::FactManager.instance.resolve_facts([user_query])
+      resolved_facts = Facter::FactManager.instance.resolve_fact(user_query)
       # we must make a distinction between custom facts that return nil and nil facts
       # Nil facts should not be packaged as ResolvedFacts! (add_fact_to_searched_facts packages facts)
       resolved_facts = resolved_facts.reject { |fact| fact.type == :nil }
       fact_collection = FactCollection.new.build_fact_collection!(resolved_facts)
-      splitted_user_query = Facter::Utils.split_user_query(user_query)
 
       begin
-        value = fact_collection.value(*splitted_user_query)
+        value = fact_collection.value(user_query)
         add_fact_to_searched_facts(user_query, value)
       rescue KeyError
         nil

data/lib/facter/custom_facts/core/execution/base.rb

@@ -94,11 +94,15 @@ module Facter
             end
             log_stderr(stderr, command, logger)
           rescue StandardError => e
-            return '' if logger
+            message = "Failed while executing '#{command}': #{e.message}"
+            if logger
+              @log.debug(message)
+              return ''
+            end
+
             return on_fail unless on_fail == :raise
 
-            raise Facter::Core::Execution::ExecutionFailure.new,
-                  "Failed while executing '#{command}': #{e.message}"
+            raise Facter::Core::Execution::ExecutionFailure.new, message
           end
 
           [out.strip, stderr]

data/lib/facter/custom_facts/core/execution/popen3.rb

@@ -11,6 +11,8 @@ module Facter
   module Core
     module Execution
       class Popen3
+        @log ||= Log.new(self)
+
         def self.popen_rune(cmd, opts, child_io, parent_io) # :nodoc:
           pid = spawn(*cmd, opts)
           child_io.each(&:close)
@@ -20,7 +22,17 @@ module Facter
               return yield(*result)
             ensure
               parent_io.each(&:close)
-              Process.wait(pid)
+              begin
+                Process.wait(pid)
+              rescue Errno::ENOENT
+                # For some reason, the first Process.wait executed in JRuby
+                # always fails with ENOENT. However, the command output is
+                # filled in so we just need to silently continue.
+                # https://github.com/jruby/jruby/issues/5971
+                raise unless RUBY_PLATFORM == 'java'
+
+                @log.debug('Caught ENOENT during Process.wait on JRuby, continuing...')
+              end
             end
           end
           result

data/lib/facter/custom_facts/util/collection.rb

@@ -106,6 +106,11 @@ module LegacyFacter
         @loaded = false
       end
 
+      def custom_fact(fact_name)
+        internal_loader.load(fact_name)
+        @custom_facts = @facts.select { |_k, v| v.options[:fact_type] == :custom }
+      end
+
       # Builds a hash of custom facts
       def custom_facts
         return @custom_facts if @valid_custom_facts

data/lib/facter/custom_facts/util/normalization.rb

@@ -5,7 +5,10 @@ module LegacyFacter
     module Normalization
       class NormalizationError < StandardError; end
 
-      VALID_TYPES = [Integer, Float, TrueClass, FalseClass, NilClass, Symbol, String, Array, Hash].freeze
+      # load Date and Time classes
+      require 'time'
+
+      VALID_TYPES = [Integer, Float, TrueClass, FalseClass, NilClass, Symbol, String, Array, Hash, Date, Time].freeze
 
       module_function
 
@@ -16,8 +19,10 @@ module LegacyFacter
       # @return [void]
       def normalize(value)
         case value
-        when Integer, Float, TrueClass, FalseClass, NilClass, Symbol, Date
+        when Integer, Float, TrueClass, FalseClass, NilClass, Symbol
           value
+        when Date, Time
+          value.iso8601
         when String
           normalize_string(value)
         when Array

data/lib/facter/facts/linux/cloud/provider.rb

@@ -6,10 +6,17 @@ module Facts
       class Provider
         FACT_NAME = 'cloud.provider'
 
+        def initialize
+          @virtual = Facter::Util::Facts::VirtualDetector.new
+        end
+
         def call_the_resolver
-          az_metadata = Facter::Resolvers::Az.resolve(:metadata)
+          provider = case @virtual.platform
+                     when 'hyperv'
+                       'azure' unless Facter::Resolvers::Az.resolve(:metadata).empty?
+                     end
 
-          Facter::ResolvedFact.new(FACT_NAME, az_metadata&.empty? ? nil : 'azure')
+          Facter::ResolvedFact.new(FACT_NAME, provider)
         end
       end
     end

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

@@ -8,6 +8,7 @@ module Facts
 
         def initialize
           @log = Facter::Log.new(self)
+          @virtual = Facter::Util::Facts::VirtualDetector.new
         end
 
         def call_the_resolver
@@ -28,10 +29,7 @@ module Facts
         private
 
         def xen?
-          Facter::Resolvers::VirtWhat.resolve(:vm) =~ /xen/ ||
-            Facter::Resolvers::Xen.resolve(:vm) =~ /xen/ ||
-            discover_hypervisor == 'xenhvm' ||
-            Facter::Resolvers::Lspci.resolve(:vm) =~ /xen/
+          @virtual.platform =~ /xen/
         end
 
         def hvm?

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

@@ -17,7 +17,7 @@ module Facts
           fact_value = %i[
             chassis_serial control_domain domain_name
             domain_uuid role_control role_io role_root role_service
-          ].map! { |key| [key, Facter::Resolvers::Solaris::Ldom.resolve(key)] }.to_h
+          ].map! { |key| [key, Facter::Utils.try_to_bool(Facter::Resolvers::Solaris::Ldom.resolve(key))] }.to_h
 
           Facter::ResolvedFact.new(FACT_NAME, fact_value)
         end

data/lib/facter/facts/solaris/hypervisors/zone.rb

@@ -27,7 +27,7 @@ module Facts
 
           {
             brand: current_zone[:brand],
-            id: current_zone[:id],
+            id: Facter::Utils.try_to_int(current_zone[:id]),
             ip_type: current_zone[:iptype],
             name: current_zone[:name],
             uuid: current_zone[:uuid]

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

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'mountpoints'
 
       def call_the_resolver
-        mountpoints = Facter::Resolvers::Mountpoints.resolve(FACT_NAME.to_sym)
+        mountpoints = Facter::Resolvers::Solaris::Mountpoints.resolve(FACT_NAME.to_sym)
         return Facter::ResolvedFact.new(FACT_NAME, nil) unless mountpoints
 
         fact = {}

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

@@ -5,10 +5,6 @@ module Facts
     class AzMetadata
       FACT_NAME = 'az_metadata'
 
-      def initialize
-        @virtual = Facter::Util::Facts::VirtualDetector.new
-      end
-
       def call_the_resolver
         return Facter::ResolvedFact.new(FACT_NAME, nil) unless azure_hypervisor?
 
@@ -20,7 +16,7 @@ module Facts
       private
 
       def azure_hypervisor?
-        @virtual.platform == 'hyperv'
+        Facter::Resolvers::Virtualization.resolve(:virtual) == 'hyperv'
       end
     end
   end

data/lib/facter/facts/windows/cloud/provider.rb

@@ -7,9 +7,13 @@ module Facts
         FACT_NAME = 'cloud.provider'
 
         def call_the_resolver
-          az_metadata = Facter::Resolvers::Az.resolve(:metadata)
+          virtual = Facter::Resolvers::Virtualization.resolve(:virtual)
+          provider = case virtual
+                     when 'hyperv'
+                       'azure' unless Facter::Resolvers::Az.resolve(:metadata).empty?
+                     end
 
-          Facter::ResolvedFact.new(FACT_NAME, az_metadata&.empty? ? nil : 'azure')
+          Facter::ResolvedFact.new(FACT_NAME, provider)
         end
       end
     end

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

@@ -20,10 +20,9 @@ module Facter
           .reject(&:user_query)
           .uniq(&:name)
       else
-        resolved_facts
-          .select { |resolved_fact| searched_fact.name.eql?(resolved_fact.name) }
-          .reject(&:user_query)
-          .uniq(&:name)
+        resolved_facts.select do |resolved_fact|
+          valid_fact(searched_fact, resolved_fact)
+        end.reject(&:user_query).uniq(&:name)
       end
     end
 
@@ -33,5 +32,23 @@ module Facter
         matched_fact.filter_tokens = searched_fact.filter_tokens
       end
     end
+
+    private_class_method def self.valid_fact(searched_fact, resolved_fact)
+      return false unless searched_fact.name.eql?(resolved_fact.name)
+
+      if searched_fact.filter_tokens.any?
+        case resolved_fact.value
+        when Array, Hash
+          begin
+            resolved_fact.value.dig(*searched_fact.filter_tokens)
+          rescue TypeError
+            return false
+          end
+        else
+          return false
+        end
+      end
+      true
+    end
   end
 end

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,38 +11,21 @@ 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 = []
-
+    def load(options)
       @internal_facts = load_internal_facts(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)
@@ -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)