facter 4.0.37 → 4.0.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2ed5162fef26cfbf5bd010cf7737ac8b4856cf59f9f55745d6cfc1bec39781e
-  data.tar.gz: 761beee20f449b3bbe1e5dc35c0bcd675e9602902804e7add3ee6c3d31a8916d
+  metadata.gz: ffa55de7f92a74b84788507b7e9667f158edc68abef1412f40ab5d3beb8f6aad
+  data.tar.gz: e92ff5798a9abab30f1887c5e4f934d75cef67975b2485e53ba6dc58b59ee899
 SHA512:
-  metadata.gz: 92751ef6452023c4e4edd9c2b7d21bd78bef74404d5550d4de353b4243f6639f29abbba1f00d6f8ba0b4bbf7afbea060f00aa34919a2d1d94459e1df5515e706
-  data.tar.gz: b4ca79c0907439874ae638a920def98b9ed0d3e2893a77b6bc3d44dfb3cba756f88e550d55d14a8e4cdb9d2c5b58a6d0c6a6c335955ae819607021a80562cd65
+  metadata.gz: 4841268cf5f76f1ad2b0ed2bf16b2527dd73e4d41728c64dbe13986b1a574759f900e2748e72ce72f6c677cf754d8a4f5115530140285412a07943e13b6312a5
+  data.tar.gz: bd48e0942af375429188957956a5555963297d62a9bc6549529ae1713b7670b41bfc5eea6b894d961e3e32507963e394779c372ad3b12a6422b5218f94b0f9e4

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,36 @@ 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 ||= 300
           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
+              stdout_messages = +''
+              stderr_messages = +''
+              out_reader = Thread.new { stdout.read }
+              err_reader = Thread.new { stderr.read }
+              begin
+                Timeout.timeout(time_limit) do
+                  stdout_messages << out_reader.value
+                  stderr_messages << err_reader.value
+                end
+              rescue Timeout::Error
+                message = "Timeout encounter after #{time_limit}s, killing process with pid: #{pid}"
+                Process.kill('KILL', pid)
+                on_fail == :raise ? (raise StandardError, message) : @log.debug(message)
+              ensure
+                out_reader.kill
+                err_reader.kill
+              end
+              [stdout_messages, stderr_messages]
+            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

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)

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

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

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

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

data/lib/facter/facts/aix/os/release.rb

@@ -8,7 +8,7 @@ module Facts
         ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::OsLevel.resolve(:build)
+          fact_value = Facter::Resolvers::Aix::OsLevel.resolve(:build)
           major = fact_value.split('-')[0]
 
           [Facter::ResolvedFact.new(FACT_NAME, full: fact_value.strip, major: major),