facter 4.0.36 → 4.0.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ceb625b0a349be8f5f574055b24aebd9860672ccdfc27224377a75255681b571
-  data.tar.gz: 1081225dee1a50781041d65599bc74fccf1552fe1ce75a9195f0aecd8608afb8
+  metadata.gz: c21fc41638fbbab14ccb415eec2104ed296236c98d7870a341c37742796c8fc1
+  data.tar.gz: 7b09bdc7ecc99e1947d9eb5bcacb7873f3b954224904d0930ee69846c47d5e88
 SHA512:
-  metadata.gz: 0c31f37ed2064c1683e9f56a5d252bab225e1af0c0df025d1621ef89551fefa6a0816cc3862d4c98ab2480a6e158f62b18bcf0d5ae9f2d75f22799297660ffc9
-  data.tar.gz: d6f071e0bf9bcdf01c460ea7ac45d0cb50459c4a40e663761cf7c58de0068b6c9e444cebedd5304a692317a960a8d1327accea35f6815b90076e4acc4ce2ec3b
+  metadata.gz: 327664693c0725ab4aafc339e6091557dc00d2dee945a9f6d6f3bca5d3a6d1ab8b56809c5d9b7374029fcd277a8bc5107ff76a03522c9104e214f4c967417a04
+  data.tar.gz: 2d60b83c461d1bcdaa611322061f844f186951341562b5a3ec83d35512d58059776a5772b41bdf97b2cb77c2fb53abd2a744f9bddc49042b6d421868411c010a

data/bin/facter

@@ -4,8 +4,7 @@
 require 'pathname'
 require 'facter/framework/cli/cli_launcher.rb'
 
-cli_launcher = CliLauncher.new(ARGV)
+Facter::OptionsValidator.validate(ARGV)
+processed_arguments = CliLauncher.prepare_arguments(ARGV)
 
-cli_launcher.validate_options
-cli_launcher.prepare_arguments
-cli_launcher.start
+CliLauncher.start(processed_arguments)

data/lib/facter.rb

@@ -13,8 +13,31 @@ module Facter
   Options.init
   Log.output(STDOUT)
   @already_searched = {}
+  @debug_once = []
+  @warn_once = []
 
   class << self
+    def resolve(args_as_string)
+      require 'facter/framework/cli/cli_launcher'
+
+      args = args_as_string.split(' ')
+
+      Facter::OptionsValidator.validate(args)
+      processed_arguments = CliLauncher.prepare_arguments(args, nil)
+
+      cli = Facter::Cli.new([], processed_arguments)
+
+      if cli.args.include?(:version)
+        cli.invoke(:version, [])
+      elsif cli.args.include?('--list-cache-groups')
+        cli.invoke(:list_cache_groups, [])
+      elsif cli.args.include?('--list-block-groups')
+        cli.invoke(:list_block_groups, [])
+      else
+        cli.invoke(:arg_parser)
+      end
+    end
+
     def clear_messages
       logger.debug('clear_messages is not implemented')
     end
@@ -54,6 +77,8 @@ module Facter
     # @api public
     def clear
       @already_searched = {}
+      @debug_once = []
+      @warn_once = []
       LegacyFacter.clear
       Options[:custom_dir] = []
       LegacyFacter.collection.invalidate_custom_facts
@@ -68,24 +93,54 @@ module Facter
       fact_collection.dig(*splitted_user_query)
     end
 
-    # Prints out a debug message when debug option is set to true
-    # @param msg [String] Message to be printed out
+    # Logs debug message when debug option is set to true
+    # @param message [Object] Message object to be logged
+    #
+    # @return [nil]
+    #
+    # @api public
+    def debug(message)
+      return unless debugging?
+
+      logger.debug(message.to_s)
+      nil
+    end
+
+    # Logs the same debug message only once when debug option is set to true
+    # @param message [Object] Message object to be logged
     #
     # @return [nil]
     #
     # @api public
-    def debug(msg)
+    def debugonce(message)
       return unless debugging?
 
-      logger.debug(msg)
+      message_string = message.to_s
+      return if @debug_once.include? message_string
+
+      @debug_once << message_string
+      logger.debug(message_string)
       nil
     end
 
+    # Define a new fact or extend an existing fact.
+    #
+    # @param name [Symbol] The name of the fact to define
+    # @param options [Hash] A hash of options to set on the fact
+    #
+    # @return [Facter::Util::Fact] The fact that was defined
+    #
+    # @api public
+    def define_fact(name, options = {}, &block)
+      options[:fact_type] = :custom
+      LegacyFacter.define_fact(name, options, &block)
+    end
+
     def on_message(&block)
       Facter::Log.on_message(&block)
     end
 
-    # Check whether debuging is enabled
+    # Check whether debugging is enabled
     #
     # @return [bool]
     #
@@ -104,11 +159,31 @@ module Facter
       Facter::Options[:debug] = debug_bool
     end
 
+    # Iterates over fact names and values
+    #
+    # @yieldparam [String] name the fact name
+    # @yieldparam [String] value the current value of the fact
+    #
+    # @return [Facter]
+    #
+    # @api public
+    def each
+      log_blocked_facts
+      resolved_facts = Facter::FactManager.instance.resolve_facts
+      SessionCache.invalidate_all_caches
+
+      resolved_facts.each do |fact|
+        yield(fact.name, fact.value)
+      end
+
+      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 name [String] the name of the fact
+    # @param user_query [String] the name of the fact
     #
     # @return [Facter::Util::Fact, nil] The fact object, or nil if no fact
     #   is found.
@@ -134,6 +209,16 @@ module Facter
       nil
     end
 
+    # Loads all facts
+    #
+    # @return [nil]
+    #
+    # @api public
+    def loadfacts
+      LegacyFacter.loadfacts
+      nil
+    end
+
     # Register directories to be searched for custom facts. The registered directories
     # must be absolute paths or they will be ignored.
     #
@@ -199,7 +284,7 @@ module Facter
     end
 
     # Enable or disable trace
-    # @param debug_bool [bool] Set trace on debug state
+    # @param bool [bool] Set trace on debug state
     #
     # @return [type] [description]
     #
@@ -210,7 +295,7 @@ module Facter
 
     # Gets the value for a fact. Returns `nil` if no such fact exists.
     #
-    # @param name [String] the fact name
+    # @param user_query [String] the fact name
     # @return [String] the value of the fact, or nil if no fact is found
     #
     # @api public
@@ -220,6 +305,18 @@ module Facter
       @already_searched[user_query]&.value
     end
 
+    def values(options, user_queries)
+      init_cli_options(options, user_queries)
+      resolved_facts = Facter::FactManager.instance.resolve_facts(user_queries)
+      Facter::SessionCache.invalidate_all_caches
+
+      if user_queries.count.zero?
+        Facter::FactCollection.new.build_fact_collection!(resolved_facts)
+      else
+        FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+      end
+    end
+
     # Returns Facter version
     #
     # @return [String] Current version
@@ -247,23 +344,67 @@ module Facter
       [fact_formatter.format(resolved_facts), status || 0]
     end
 
-    def log_exception(exception, message = :default)
-      arr = []
-      if message == :default
-        arr << exception.message
-      elsif message
-        arr << message
-      end
-      if Options[:trace]
-        arr << 'backtrace:'
-        arr.concat(exception.backtrace)
-      end
+    def log_exception(exception, message = nil)
+      error_message = []
+
+      error_message << message.to_s unless message.nil? || (message.is_a?(String) && message.empty?)
 
-      logger.error(arr.flatten.join("\n"))
+      parse_exception(exception, error_message)
+      logger.error(error_message.flatten.join("\n"))
+    end
+
+    # Returns a list with the names of all solved facts
+    #
+    # @return [Array] the list with all the fact names
+    #
+    # @api public
+    def list
+      to_hash.keys.sort
+    end
+
+    # Logs the message parameter as a warning.
+    #
+    # @param message [Object] the warning object to be displayed
+    #
+    # @return [nil]
+    #
+    # @api public
+    def warn(message)
+      logger.warn(message.to_s)
+      nil
+    end
+
+    # Logs only once the same warning message.
+    #
+    # @param message [Object] the warning message object
+    #
+    # @return [nil]
+    #
+    # @api public
+    def warnonce(message)
+      message_string = message.to_s
+      return if @warn_once.include? message_string
+
+      @warn_once << message_string
+      logger.warn(message_string)
+      nil
     end
 
     private
 
+    def parse_exception(exception, error_message)
+      if exception.is_a?(Exception)
+        error_message << exception.message if error_message.empty?
+
+        if Options[:trace] && !exception.backtrace.nil?
+          error_message << 'backtrace:'
+          error_message.concat(exception.backtrace)
+        end
+      elsif error_message.empty?
+        error_message << exception.to_s
+      end
+    end
+
     def logger
       @logger ||= Log.new(self)
     end
@@ -303,10 +444,9 @@ module Facter
     # Returns exit status when user query contains facts that do
     #   not exist
     #
-    # @param dirs [Array] Arguments sent to CLI
-    # @param dirs [Array] List of resolved facts
+    # @param resolved_facts [Array] List of resolved facts
     #
-    # @return [Integer, nil] Will return status 1 if user query contains
+    # @return [1/nil] Will return status 1 if user query contains
     #  facts that are not found or resolved, otherwise it will return nil
     #
     # @api private

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

@@ -6,6 +6,10 @@ module Facter
       class Base
         STDERR_MESSAGE = 'Command %s resulted with the following stderr message: %s'
 
+        def initialize
+          @log = Log.new(self)
+        end
+
         # This is part of the public API. No race condition can happen
         # here because custom facts are executed sequentially
         def with_env(values)
@@ -36,9 +40,7 @@ module Facter
         end
 
         def execute(command, options = {})
-          on_fail = options.fetch(:on_fail, :raise)
-          expand = options.fetch(:expand, true)
-          logger = options[:logger]
+          on_fail, expand, logger, time_limit = extract_options(options)
 
           expanded_command = if !expand && builtin_command?(command) || logger
                                command
@@ -55,11 +57,21 @@ module Facter
             return on_fail
           end
 
-          execute_command(expanded_command, on_fail, logger)
+          execute_command(expanded_command, on_fail, logger, time_limit)
         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?
 
@@ -77,12 +89,30 @@ module Facter
           output.chomp =~ /builtin/ ? true : false
         end
 
-        def execute_command(command, on_fail, logger = nil)
+        def execute_command(command, on_fail, logger = nil, time_limit = nil)
+          time_limit ||= 1.5
           begin
             # Set LC_ALL and LANG to force i18n to C for the duration of this exec;
             # this ensures that any code that parses the
             # output of the command can expect it to be in a consistent / predictable format / locale
-            out, stderr, _status_ = Open3.capture3({ 'LC_ALL' => 'C', 'LANG' => 'C' }, command.to_s)
+            opts = { 'LC_ALL' => 'C', 'LANG' => 'C' }
+            require 'timeout'
+            @log.debug("Executing command: #{command}")
+            out, stderr = Open3.popen3(opts, command.to_s) do |_, stdout, stderr, wait_thr|
+              pid = wait_thr.pid
+              output = +''
+              err = +''
+              begin
+                Timeout.timeout(time_limit) do
+                  output << stdout.read
+                  err << stderr.read
+                end
+              rescue Timeout::Error
+                @log.debug("Timeout encounter after #{time_limit}s, killing process with pid: #{pid}")
+                Process.kill('KILL', pid)
+              end
+              [output, err]
+            end
             log_stderr(stderr, command, logger)
           rescue StandardError => e
             return '' if logger

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

@@ -59,7 +59,7 @@ module LegacyFacter
           basename = File.basename(file)
           next if file_blocked?(basename)
 
-          if facts.find { |f| f.name == basename } && cm.group_cached?(basename)
+          if facts.find { |f| f.name == basename } && cm.fact_cache_enabled?(basename)
             Facter.log_exception(Exception.new("Caching is enabled for group \"#{basename}\" while "\
               'there are at least two external facts files with the same filename'))
           else
@@ -84,7 +84,7 @@ module LegacyFacter
           parser = LegacyFacter::Util::Parser.parser_for(fact.file)
           next if parser.nil?
 
-          data = parser.results
+          data = resolve_fact(fact, parser)
 
           if data == false
             LegacyFacter.warn "Could not interpret fact file #{fact.file}"
@@ -99,6 +99,14 @@ module LegacyFacter
         end
       end
 
+      def resolve_fact(fact, parser)
+        data = nil
+        fact_name = File.basename(fact.file)
+        Facter::Framework::Benchmarking::Timer.measure(fact_name) { data = parser.results }
+
+        data
+      end
+
       def entries
         dirs = @directories.select { |directory| File.directory?(directory) }.map do |directory|
           Dir.entries(directory).map { |directory_entry| File.join(directory, directory_entry) }

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

@@ -118,7 +118,10 @@ module Facter
 
         searching do
           suitable_resolutions = sort_by_weight(find_suitable_resolutions(@resolves))
-          @value = find_first_real_value(suitable_resolutions)
+
+          Facter::Framework::Benchmarking::Timer.measure(@name) do
+            @value = find_first_real_value(suitable_resolutions)
+          end
 
           announce_when_no_suitable_resolution(suitable_resolutions)
           announce_when_no_value_found(@value)

data/lib/facter/facts/aix/disks.rb

@@ -24,7 +24,7 @@ module Facts
 
       def add_legacy_facts(disks, facts)
         disks.each do |disk_name, disk_info|
-          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes].to_s, :legacy))
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes], :legacy))
         end
       end
     end

data/lib/facter/facts/aix/kernel.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'kernel'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::OsLevel.resolve(:kernel)
+        fact_value = Facter::Resolvers::Aix::OsLevel.resolve(:kernel)
 
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end

data/lib/facter/facts/aix/kernelmajversion.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'kernelmajversion'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::OsLevel.resolve(:build)
+        fact_value = Facter::Resolvers::Aix::OsLevel.resolve(:build)
         kernelmajversion = fact_value.split('-')[0]
 
         Facter::ResolvedFact.new(FACT_NAME, kernelmajversion)