facter 4.0.42 → 4.0.48

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

@@ -143,7 +143,7 @@ module LegacyFacter
           # match it.
           next if fact && (env_name != fact)
 
-          LegacyFacter.add(Regexp.last_match(1), fact_type: :external) do
+          LegacyFacter.add(Regexp.last_match(1), fact_type: :external, is_env: true) do
             has_weight 1_000_000
             setcode { value }
           end

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

@@ -8,6 +8,8 @@
 module LegacyFacter
   module Util
     module Parser
+      STDERR_MESSAGE = 'Command %s completed with the following stderr message: %s'
+
       @parsers = []
 
       # For support mutliple extensions you can pass an array of extensions as
@@ -75,6 +77,15 @@ module LegacyFacter
           res = KeyValuePairOutputFormat.parse output unless res.is_a?(Hash)
           res
         end
+
+        def log_stderr(msg, command, file)
+          return if !msg || msg.empty?
+
+          file_name = file.split('/').last
+          logger = Facter::Log.new(file_name)
+
+          logger.warn(format(STDERR_MESSAGE, command, msg.strip))
+        end
       end
 
       module KeyValuePairOutputFormat
@@ -139,7 +150,9 @@ module LegacyFacter
 
       class ScriptParser < Base
         def parse_results
-          parse_executable_output(Facter::Core::Execution.exec(quote(filename)))
+          stdout, stderr = Facter::Core::Execution.execute_command(quote(filename))
+          log_stderr(stderr, filename, filename)
+          parse_executable_output(stdout)
         end
 
         private
@@ -172,8 +185,9 @@ module LegacyFacter
 
           shell_command =
             "\"#{powershell}\" -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -File \"#{filename}\""
-          output = Facter::Core::Execution.exec(shell_command)
-          parse_executable_output(output)
+          stdout, stderr = Facter::Core::Execution.execute_command(shell_command)
+          log_stderr(stderr, shell_command, filename)
+          parse_executable_output(stdout)
         end
       end
 

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
+      attr_reader :fact, :last_evaluated, :file
 
       # 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,8 +104,13 @@ 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]
+        accepted_options = %i[name value timeout weight fact_type file is_env]
 
         accepted_options.each do |option_name|
           instance_variable_set("@#{option_name}", options.delete(option_name)) if options.key?(option_name)
@@ -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

@@ -4,7 +4,7 @@ module Facts
   module Aix
     class Disks
       FACT_NAME = 'disks'
-      ALIASES = %w[blockdevices blockdevice_.*_size'].freeze
+      ALIASES = %w[blockdevices blockdevice_.*_size].freeze
 
       def call_the_resolver
         facts = []

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

@@ -4,6 +4,7 @@ module Facts
   module Aix
     class Interfaces
       FACT_NAME = 'interfaces'
+      TYPE = :legacy
 
       def call_the_resolver
         fact_value = Facter::Resolvers::Aix::Networking.resolve(:interfaces)

data/lib/facter/facts/aix/memory/swap/available.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
             end
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/aix/memory/swap/available_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:available_bytes] if fact_value
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/aix/memory/swap/total.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
             end
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/aix/memory/swap/total_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:total_bytes] if fact_value
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/aix/memory/swap/used.rb

@@ -10,7 +10,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
             end
             Facter::ResolvedFact.new(FACT_NAME, fact_value)
           end

data/lib/facter/facts/aix/memory/system/available.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
             end
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/aix/memory/system/available_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:available_bytes] if fact_value
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/aix/memory/system/total.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
             end
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/aix/memory/system/total_bytes.rb

@@ -13,7 +13,7 @@ module Facts
             fact_value = fact_value[:total_bytes] if fact_value
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/aix/memory/system/used.rb

@@ -10,7 +10,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
             if fact_value
-              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
+              fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
             end
             Facter::ResolvedFact.new(FACT_NAME, fact_value)
           end

data/lib/facter/facts/aix/processors/speed.rb

@@ -8,7 +8,7 @@ module Facts
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Aix::Processors.resolve(:speed)
-          speed = Facter::FactsUtils::UnitConverter.hertz_to_human_readable(fact_value)
+          speed = Facter::Util::Facts::UnitConverter.hertz_to_human_readable(fact_value)
           Facter::ResolvedFact.new(FACT_NAME, speed)
         end
       end

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

@@ -16,7 +16,7 @@ module Facts
       end
 
       def resolver_data
-        Facter::Resolvers::SshResolver.resolve(:ssh)
+        Facter::Resolvers::Ssh.resolve(:ssh)
       end
 
       def create_ssh_fact(ssh)

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

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
         facts
       end

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

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
                                             "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)

data/lib/facter/facts/bsd/processors/speed.rb

@@ -8,7 +8,7 @@ module Facts
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Bsd::Processors.resolve(:speed)
-          speed = Facter::FactsUtils::UnitConverter.hertz_to_human_readable(fact_value)
+          speed = Facter::Util::Facts::UnitConverter.hertz_to_human_readable(fact_value)
           Facter::ResolvedFact.new(FACT_NAME, speed)
         end
       end

data/lib/facter/facts/freebsd/is_virtual.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facts
+  module Freebsd
+    class IsVirtual
+      FACT_NAME = 'is_virtual'
+
+      def initialize
+        @virtual = Facter::Util::Facts::VirtualDetector.new
+      end
+
+      def call_the_resolver
+        fact_value = @virtual.platform
+
+        Facter::ResolvedFact.new(FACT_NAME, check_if_virtual(fact_value))
+      end
+
+      private
+
+      def check_if_virtual(found_vm)
+        Facter::Util::Facts::PHYSICAL_HYPERVISORS.count(found_vm).zero?
+      end
+    end
+  end
+end

data/lib/facter/facts/freebsd/memory/swap/available.rb

@@ -10,7 +10,7 @@ module Facts
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Freebsd::SwapMemory.resolve(:available_bytes)
-            fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value)
+            fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value)
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/freebsd/memory/swap/available_bytes.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Freebsd::SwapMemory.resolve(:available_bytes)
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/freebsd/memory/swap/total.rb

@@ -10,7 +10,7 @@ module Facts
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Freebsd::SwapMemory.resolve(:total_bytes)
-            fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value)
+            fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value)
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/freebsd/memory/swap/total_bytes.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Freebsd::SwapMemory.resolve(:total_bytes)
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end

data/lib/facter/facts/freebsd/memory/swap/used.rb

@@ -9,7 +9,7 @@ module Facts
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Freebsd::SwapMemory.resolve(:used_bytes)
-            fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value)
+            fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value)
 
             Facter::ResolvedFact.new(FACT_NAME, fact_value)
           end

data/lib/facter/facts/freebsd/memory/system/available.rb

@@ -10,7 +10,7 @@ module Facts
 
           def call_the_resolver
             fact_value = Facter::Resolvers::Freebsd::SystemMemory.resolve(:available_bytes)
-            fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value)
+            fact_value = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(fact_value)
 
             [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
           end

data/lib/facter/facts/freebsd/memory/system/available_bytes.rb

@@ -11,7 +11,7 @@ module Facts
           def call_the_resolver
             fact_value = Facter::Resolvers::Freebsd::SystemMemory.resolve(:available_bytes)
             [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+             Facter::ResolvedFact.new(ALIASES, Facter::Util::Facts::UnitConverter.bytes_to_mb(fact_value), :legacy)]
           end
         end
       end