facter 4.0.38 → 4.0.43

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.
+      #   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
       #
-      # Returns nil if no matching executable can be found otherwise returns
-      # the expanded pathname.
-      #
-      # @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,9 +96,9 @@ 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 aggregate fact
       #
       # @option options [Object] :on_fail How to behave when the command could
       #   not be run. Specifying :raise will raise an error, anything else will
@@ -118,7 +111,6 @@ module Facter
       #   command execution failed and :on_fail was specified.
       #
       # @api public
-      # @since 2.0.1
       def execute(command, options = {})
         @@impl.execute(command, options)
       end

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/custom_facts/util/resolution.rb

@@ -14,6 +14,8 @@ module Facter
     class Resolution
       # @api private
       attr_accessor :code, :fact_type
+
+      # @api private
       attr_writer :value
 
       extend Facter::Core::Execution
@@ -24,7 +26,12 @@ module Facter
         # compatibility.
         #
         # @deprecated
-        public :search_paths, :which, :absolute_path?, :expand_command, :with_env, :exec
+        #
+        # @api public
+        public :which, :exec
+
+        # @api private
+        public :with_env
       end
 
       include LegacyFacter::Core::Resolvable
@@ -32,22 +39,27 @@ module Facter
 
       # @!attribute [rw] name
       # The name of this resolution. The resolution name should be unique with
-      # respect to the given fact.
+      #   respect to the given fact.
+      #
       # @return [String]
+      #
       # @api public
       attr_accessor :name
 
       # @!attribute [r] fact
-      # @return [Facter::Util::Fact]
+      #
+      # @return [Facter::Util::Fact] Associated fact with this resolution.
+      #
       # @api private
       attr_reader :fact
 
       # Create a new resolution mechanism.
       #
       # @param name [String] The name of the resolution.
-      # @return [void]
       #
-      # @api private
+      # @return [Facter::Util::Resolution] The created resolution
+      #
+      # @api public
       def initialize(name, fact)
         @name = name
         @fact = fact
@@ -57,6 +69,11 @@ module Facter
         @weight = nil
       end
 
+      # Returns the fact's resolution type
+      #
+      # @return [Symbol] The fact's type
+      #
+      # @api private
       def resolution_type
         :simple
       end
@@ -64,7 +81,9 @@ module Facter
       # Evaluate the given block in the context of this resolution. If a block has
       # already been evaluated emit a warning to that effect.
       #
-      # @return [void]
+      # @return [String] Result of the block's evaluation
+      #
+      # @api private
       def evaluate(&block)
         if @last_evaluated
           msg = "Already evaluated #{@name}"
@@ -85,6 +104,11 @@ module Facter
                           end
       end
 
+      # Sets options for the aggregate fact
+      #
+      # @return [nil]
+      #
+      # @api private
       def options(options)
         accepted_options = %i[name value timeout weight fact_type file]
 
@@ -98,8 +122,6 @@ module Facter
       # Sets the code block or external program that will be evaluated to
       # get the value of the fact.
       #
-      # @return [void]
-      #
       # @overload setcode(string)
       #   Sets an external program to call to get the value of the resolution
       #   @param [String] string the external program to run to get the
@@ -111,6 +133,8 @@ module Facter
       #     This block is run when the fact is evaluated. Errors raised from
       #     inside the block are rescued and printed to stderr.
       #
+      # @return [Facter::Util::Resolution] Returns itself
+      #
       # @api public
       def setcode(string = nil, &block)
         if string
@@ -127,11 +151,16 @@ module Facter
         else
           raise ArgumentError, 'You must pass either code or a block'
         end
+        self
       end
 
-      # Comparation is done based on weight and fact type.
-      # The greatter the weight, the higher the priority.
-      # If weights are equal, we consider external facts greater than custom facts
+      # Comparison is done based on weight and fact type.
+      #   The greater the weight, the higher the priority.
+      #   If weights are equal, we consider external facts greater than custom facts.
+      #
+      # @return [bool] Weight comparison result
+      #
+      # @api private
       def <=>(other)
         return compare_equal_weights(other) if weight == other.weight
         return 1 if weight > other.weight

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),

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    class Cloud
+      FACT_NAME = 'cloud'
+
+      def call_the_resolver
+        cloud_provider = Facter::Resolvers::Cloud.resolve(:cloud_provider)
+
+        Facter::ResolvedFact.new(FACT_NAME, cloud_provider)
+      end
+    end
+  end
+end

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

@@ -25,7 +25,7 @@ module Facts
       def add_legacy_facts(disks, facts)
         disks.each do |disk_name, disk_info|
           facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_model", disk_info[:model], :legacy))
-          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))
           facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_vendor", disk_info[:vendor], :legacy))
         end
       end

data/lib/facter/facts/linux/ec2_metadata.rb

@@ -5,6 +5,10 @@ module Facts
     class Ec2Metadata
       FACT_NAME = 'ec2_metadata'
 
+      def initialize
+        @virtual = Facter::VirtualDetector.new
+      end
+
       def call_the_resolver
         return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
@@ -16,33 +20,7 @@ module Facts
       private
 
       def aws_hypervisors?
-        virtual = check_virt_what || check_xen || check_product_name || check_bios_vendor || check_lspci
-
-        virtual == 'kvm' || virtual =~ /xen/
-      end
-
-      def check_virt_what
-        Facter::Resolvers::VirtWhat.resolve(:vm)
-      end
-
-      def check_xen
-        Facter::Resolvers::Xen.resolve(:vm)
-      end
-
-      def check_product_name
-        product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
-        return unless product_name
-
-        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
-      end
-
-      def check_bios_vendor
-        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
-        return 'kvm' if bios_vendor&.include?('Amazon EC2')
-      end
-
-      def check_lspci
-        Facter::Resolvers::Lspci.resolve(:vm)
+        @virtual.platform =~ /kvm|xen|aws/
       end
     end
   end