facter 4.0.42 → 4.0.48

data/lib/facter/custom_facts/core/aggregate.rb

@@ -18,22 +18,31 @@ module Facter
       include LegacyFacter::Core::Resolvable
 
       # @!attribute [r] name
-      #   @return [Symbol] The name of the aggregate resolution
+      #
+      # @return [Symbol] The name of the aggregate resolution
+      #
+      # @api public
       attr_reader :name
 
       # @!attribute [r] deps
-      #   @api private
-      #   @return [LegacyFacter::Core::DirectedGraph]
+      #
+      # @return [LegacyFacter::Core::DirectedGraph]
+      #
+      # @api private
       attr_reader :deps
 
       # @!attribute [r] confines
-      #   @return [Array<LegacyFacter::Core::Confine>] An array of confines restricting
-      #     this to a specific platform
-      #   @see Facter::Core::Suitable
+      #
+      # @return [Array<LegacyFacter::Core::Confine>] An array of confines restricting
+      #  this to a specific platform
+      #
+      # @api private
       attr_reader :confines
 
       # @!attribute [r] fact
+      #
       # @return [Facter::Util::Fact]
+      #
       # @api private
       attr_reader :fact
 
@@ -48,10 +57,20 @@ module Facter
         @deps = LegacyFacter::Core::DirectedGraph.new
       end
 
+      # Compares the weight of two aggregate facts
+      #
+      # @return [bool] Weight comparison result
+      #
+      # @api private
       def <=>(other)
         weight <=> other.weight
       end
 
+      # Sets options for the aggregate fact
+      #
+      # @return [nil]
+      #
+      # @api private
       def options(options)
         accepted_options = %i[name timeout weight fact_type]
         accepted_options.each do |option_name|
@@ -60,14 +79,17 @@ module Facter
         raise ArgumentError, "Invalid aggregate options #{options.keys.inspect}" unless options.keys.empty?
       end
 
+      # Evaluates the given block
+      #
+      # @return [String] Result of the block's evaluation
+      #
+      # @api private
       def evaluate(&block)
         instance_eval(&block)
       end
 
       # Define a new chunk for the given aggregate
       #
-      # @api public
-      #
       # @example Defining a chunk with no dependencies
       #   aggregate.chunk(:mountpoints) do
       #     # generate mountpoint information
@@ -80,14 +102,14 @@ module Facter
       #   end
       #
       # @param name [Symbol] A name unique to this aggregate describing the chunk
-      # @param opts [Hash]
-      # @options opts [Array<Symbol>, Symbol] :require One or more chunks
-      #   to evaluate and pass to this block.
-      # @yield [*Object] Zero or more chunk results
       #
-      # @return [void]
+      # @param opts [Hash] Hash with options for the aggregate fact
+      #
+      # @return [Facter::Core::Aggregate] The aggregate object
+      #
+      # @api public
       def chunk(name, opts = {}, &block)
-        raise ArgumentError, "#{self.class.name}#chunk requires a block" unless block_given?
+        evaluate_params(name, &block)
 
         deps = Array(opts.delete(:require))
 
@@ -97,12 +119,11 @@ module Facter
 
         @deps[name] = deps
         @chunks[name] = block
+        self
       end
 
       # Define how all chunks should be combined
       #
-      # @api public
-      #
       # @example Merge all chunks
       #   aggregate.aggregate do |chunks|
       #     final_result = {}
@@ -124,19 +145,32 @@ module Facter
       # @yield [Hash<Symbol, Object>] A hash containing chunk names and
       #   chunk values
       #
-      # @return [void]
+      # @return [Facter::Core::Aggregate] The aggregate fact
+      #
+      # @api public
       def aggregate(&block)
         raise ArgumentError, "#{self.class.name}#aggregate requires a block" unless block_given?
 
         @aggregate = block
+        self
       end
 
+      # Returns the fact's resolution type
+      #
+      # @return [Symbol] The fact's type
+      #
+      # @api private
       def resolution_type
         :aggregate
       end
 
       private
 
+      def evaluate_params(name)
+        raise ArgumentError, "#{self.class.name}#chunk requires a block" unless block_given?
+        raise ArgumentError, "#{self.class.name}#expected chunk name to be a Symbol" unless name.is_a? Symbol
+      end
+
       # Evaluate the results of this aggregate.
       #
       # @see Facter::Core::Resolvable#value

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

@@ -3,10 +3,6 @@
 module Facter
   module Core
     module Execution
-      # require_relative 'execution/base'
-      # require_relative 'execution/windows'
-      # require_relative 'execution/posix'
-
       @@impl = if LegacyFacter::Util::Config.windows?
                  Facter::Core::Execution::Windows.new
                else
@@ -20,24 +16,22 @@ module Facter
       module_function
 
       # Returns the locations to be searched when looking for a binary. This
-      # is currently determined by the +PATH+ environment variable plus
-      # `/sbin` and `/usr/sbin` when run on unix
+      #   is currently determined by the +PATH+ environment variable plus
+      #   `/sbin` and `/usr/sbin` when run on unix
+      #
+      # @return [Array<String>] The paths to be searched for binaries
       #
-      # @return [Array<String>] the paths to be searched for binaries
       # @api private
       def search_paths
         @@impl.search_paths
       end
 
       # Determines the full path to a binary. If the supplied filename does not
-      # already describe an absolute path then different locations (determined
-      # by {search_paths}) will be searched for a match.
-      #
-      # Returns nil if no matching executable can be found otherwise returns
-      # the expanded pathname.
+      #   already describe an absolute path then different locations (determined
+      #   by {search_paths}) will be searched for a match.
+      # @param bin [String] The executable to locate
       #
-      # @param bin [String] the executable to locate
-      # @return [String,nil] the full path to the executable or nil if not
+      # @return [String/nil] The full path to the executable or nil if not
       #   found
       #
       # @api public
@@ -46,10 +40,12 @@ module Facter
       end
 
       # Determine in a platform-specific way whether a path is absolute. This
-      # defaults to the local platform if none is specified.
+      #   defaults to the local platform if none is specified.
+      # @param path [String] The path to check
+
+      # @param platform [:posix/:windows/nil] The platform logic to use
       #
-      # @param path [String] the path to check
-      # @param platform [:posix,:windows,nil] the platform logic to use
+      # @api private
       def absolute_path?(path, platform = nil)
         case platform
         when :posix
@@ -62,38 +58,35 @@ module Facter
       end
 
       # Given a command line, this returns the command line with the
-      # executable written as an absolute path. If the executable contains
-      # spaces, it has be put in double quotes to be properly recognized.
-      #
+      #   executable written as an absolute path. If the executable contains
+      #   spaces, it has to be put in double quotes to be properly recognized.
       # @param command [String] the command line
       #
-      # @return [String, nil] the command line with the executable's path
-      # expanded, or nil if the executable cannot be found.
+      # @return [String/nil] The command line with the executable's path
+      #   expanded, or nil if the executable cannot be found.
+      #
+      # @api private
       def expand_command(command)
         @@impl.expand_command(command)
       end
 
       # Overrides environment variables within a block of code.  The
-      # specified values will be set for the duration of the block, after
-      # which the original values (if any) will be restored.
-      #
-      # @overload with_env(values, { || ... })
-      #
+      #   specified values will be set for the duration of the block, after
+      #   which the original values (if any) will be restored.
       # @param values [Hash<String=>String>] A hash of the environment
       #   variables to override
       #
-      # @return [void]
+      # @return [String] The block's return string
       #
-      # @api public
+      # @api private
       def with_env(values, &block)
         @@impl.with_env(values, &block)
       end
 
       # Try to execute a command and return the output.
+      # @param command [String] Command to run
       #
-      # @param code [String] the program to run
-      #
-      # @return [String] the output of the program, or nil if the command does
+      # @return [String/nil] Output of the program, or nil if the command does
       #   not exist or could not be executed.
       #
       # @deprecated Use #{execute} instead
@@ -103,26 +96,49 @@ module Facter
       end
 
       # Execute a command and return the output of that program.
+      # @param command [String] Command to run
       #
-      # @param code [String] the program to run
-      # @param options [Hash]
+      # @param options [Hash] Hash with options for the command
       #
-      # @option options [Object] :on_fail How to behave when the command could
+      # Options accepted values :on_fail How to behave when the command could
       #   not be run. Specifying :raise will raise an error, anything else will
       #   return that object on failure. Default is :raise.
+      #   :logger Optional logger used to log the command's stderr.
+      #   :time_limit Optional time out for the specified command. If no time_limit is passed,
+      #   a default of 300 seconds is used.
       #
       # @raise [Facter::Core::Execution::ExecutionFailure] If the command does
-      #   not exist or could not be executed.
+      #   not exist or could not be executed and :on_fail is set to :raise
       #
-      # @return [String] the output of the program, or the value of :on_fail if
+      # @return [String] the output of the program, or the value of :on_fail (if it's different than :raise) if
       #   command execution failed and :on_fail was specified.
       #
       # @api public
-      # @since 2.0.1
       def execute(command, options = {})
         @@impl.execute(command, options)
       end
 
+      # Execute a command and return the stdout and stderr of that program.
+      # @param command [String] Command to run
+      #
+      # @param on_fail[Object] How to behave when the command could
+      #   not be run. Specifying :raise will raise an error, anything else will
+      #   return that object on failure. Default is :raise.
+      # @param logger Optional logger used to log the command's stderr.
+      # @param time_limit Optional time out for the specified command. If no time_limit is passed,
+      #   a default of 300 seconds is used.
+      #
+      # @raise [Facter::Core::Execution::ExecutionFailure] If the command does
+      #   not exist or could not be executed and :on_fail is set to :raise
+      #
+      # @return [String, String] the stdout and stderr of the program, or the value of
+      #   :on_fail if command execution failed and :on_fail was specified.
+      #
+      # @api private
+      def execute_command(command, on_fail = nil, logger = nil, time_limit = nil)
+        @@impl.execute_command(command, on_fail, logger, time_limit)
+      end
+
       class ExecutionFailure < StandardError; end
     end
   end

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

@@ -4,7 +4,7 @@ module Facter
   module Core
     module Execution
       class Base
-        STDERR_MESSAGE = 'Command %s resulted with the following stderr message: %s'
+        STDERR_MESSAGE = 'Command %s completed with the following stderr message: %s'
 
         def initialize
           @log = Log.new(self)
@@ -57,39 +57,11 @@ module Facter
             return on_fail
           end
 
-          execute_command(expanded_command, on_fail, logger, time_limit)
+          out, = execute_command(expanded_command, on_fail, logger, time_limit)
+          out
         end
 
-        private
-
-        def extract_options(options)
-          on_fail = options.fetch(:on_fail, :raise)
-          expand = options.fetch(:expand, true)
-          logger = options[:logger]
-          time_limit = options[:limit].to_i
-          time_limit = time_limit.positive? ? time_limit : nil
-
-          [on_fail, expand, logger, time_limit]
-        end
-
-        def log_stderr(msg, command, logger)
-          return if !msg || msg.empty?
-
-          if logger
-            logger.debug(format(STDERR_MESSAGE, command, msg.strip))
-          else
-            file_name = command.split('/').last
-            logger = Facter::Log.new(file_name)
-            logger.warn(format(STDERR_MESSAGE, command, msg.strip))
-          end
-        end
-
-        def builtin_command?(command)
-          output, _status = Open3.capture2("type #{command}")
-          output.chomp =~ /builtin/ ? true : false
-        end
-
-        def execute_command(command, on_fail, logger = nil, time_limit = nil)
+        def execute_command(command, on_fail = nil, logger = nil, time_limit = nil)
           time_limit ||= 300
           begin
             # Set LC_ALL and LANG to force i18n to C for the duration of this exec;
@@ -128,7 +100,35 @@ module Facter
                   "Failed while executing '#{command}': #{e.message}"
           end
 
-          out.strip
+          [out.strip, stderr]
+        end
+
+        private
+
+        def extract_options(options)
+          on_fail = options.fetch(:on_fail, :raise)
+          expand = options.fetch(:expand, true)
+          logger = options[:logger]
+          time_limit = options[:limit].to_i
+          time_limit = time_limit.positive? ? time_limit : nil
+
+          [on_fail, expand, logger, time_limit]
+        end
+
+        def log_stderr(msg, command, logger)
+          return if !msg || msg.empty?
+
+          unless logger
+            file_name = command.split('/').last
+            logger = Facter::Log.new(file_name)
+          end
+
+          logger.debug(format(STDERR_MESSAGE, command, msg.strip))
+        end
+
+        def builtin_command?(command)
+          output, _status = Open3.capture2("type #{command}")
+          output.chomp =~ /builtin/ ? true : false
         end
       end
     end

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

@@ -115,8 +115,7 @@ module LegacyFacter
         internal_loader.load_all unless @loaded
         @loaded = true
 
-        custom_facts = @facts.select { |_k, v| v.options[:fact_type] == :custom }
-        @custom_facts = Facter::Utils.deep_copy(custom_facts.keys)
+        @custom_facts = @facts.select { |_k, v| v.options[:fact_type] == :custom }
       end
 
       def load(name)

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

@@ -109,7 +109,7 @@ module LegacyFacter
 
       def entries
         dirs = @directories.select { |directory| File.directory?(directory) }.map do |directory|
-          Dir.entries(directory).map { |directory_entry| File.join(directory, directory_entry) }
+          Dir.entries(directory).map { |directory_entry| File.join(directory, directory_entry) }.sort.reverse!
         end
         dirs.flatten.select { |f| should_parse?(f) }
       rescue Errno::ENOENT

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

@@ -43,6 +43,8 @@ module Facter
         @used_resolution_weight = 0
 
         @value = nil
+
+        @log = Facter::Log.new(self)
       end
 
       # Adds a new {Facter::Util::Resolution resolution}.  This requires a
@@ -155,7 +157,7 @@ module Facter
         @searching
       end
 
-      # Lock our searching process, so we never ge stuck in recursion.
+      # Lock our searching process, so we never get stuck in recursion.
       def searching
         raise "Caught recursion on #{@name}" if searching?
 
@@ -173,7 +175,24 @@ module Facter
       end
 
       def sort_by_weight(resolutions)
-        resolutions.sort { |a, b| b <=> a }
+        # sort resolutions:
+        # - descending by weight
+        # - multiple facts have the same weight but different types, the :external fact take precedence
+        # - multiple facts with the same weight and type, the order is preserved.
+        # note: sort_by with index is slower than .sort
+        # we cannot use .sort because it is not stable: https://bugs.ruby-lang.org/issues/1089
+        # solution from: https://bugs.ruby-lang.org/issues/1089#note-10
+
+        # rubocop:disable Style/NestedTernaryOperator
+        idx = 0
+        resolutions.sort_by do |x|
+          [
+            -x.weight,
+            x.respond_to?(:fact_type) ? x.fact_type == :external ? 0 : 1 : 1,
+            idx += 1
+          ]
+        end
+        # rubocop:enable Style/NestedTernaryOperator
       end
 
       def find_first_real_value(resolutions)
@@ -184,11 +203,27 @@ module Facter
             break
           end
           @used_resolution_weight = resolve.weight
-          return value unless value.nil?
+          next if value.nil?
+
+          log_fact_path(resolve)
+
+          return value
         end
         nil
       end
 
+      def log_fact_path(resolve)
+        fact_type, resolved_from = if resolve.instance_of?(Facter::Core::Aggregate)
+                                     ['aggregate', resolve.instance_variable_get(:@aggregate).source_location[0]]
+                                   elsif resolve.fact_type == :external
+                                     ['external', resolve.file]
+                                   else
+                                     ['custom', resolve.last_evaluated]
+                                   end
+
+        @log.debug("#{fact_type} fact #{resolve.fact.name} got resolved from: #{resolved_from}")
+      end
+
       def announce_when_no_suitable_resolution(resolutions)
         return unless resolutions.empty?