facter 4.0.44 → 4.0.50

data/lib/facter/resolvers/zfs.rb

@@ -3,11 +3,12 @@
 module Facter
   module Resolvers
     class ZFS < BaseResolver
-      @fact_list ||= {}
+      init_resolver
+
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { zfs_fact(fact_name) }
         end
 

data/lib/facter/resolvers/zpool.rb

@@ -3,11 +3,12 @@
 module Facter
   module Resolvers
     class Zpool < BaseResolver
-      @fact_list ||= {}
+      init_resolver
+
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { zpool_fact(fact_name) }
         end
 

data/lib/facter/util/aix/info_extractor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Aix
+      module InfoExtractor
+        MEGABYTES_EXPONENT = 1024**2
+        GIGABYTES_EXPONENT = 1024**3
+
+        def self.extract(content, regex)
+          content = content.each_line.map do |line|
+            next unless regex =~ line
+
+            line.split(/:\s*|\s{2,}/)
+          end
+
+          content.flatten!.reject!(&:nil?)
+
+          Hash[*content]
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/aix/odm_query.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# CuAt (Customized Attributes) non-default attribute values
+# CuDv (Customized Devices) the devices present on this machine
+# PdAt (Predefined Attributes) default values for all device attributes
+# PdDv (Predefined Devices) the list of all devices supported by this release of AIX
+
+module Facter
+  module Util
+    module Aix
+      class ODMQuery
+        REPOS = %w[CuAt CuDv PdAt PdDv].freeze
+
+        def initialize
+          @query = ''
+          @conditions = []
+          @log = Facter::Log.new(self)
+        end
+
+        def equals(field, value)
+          @conditions << "#{field}='#{value}'"
+          self
+        end
+
+        def like(field, value)
+          @conditions << "#{field} like '#{value}'"
+          self
+        end
+
+        def execute
+          result = nil
+          REPOS.each do |repo|
+            break if result && !result.empty?
+
+            result = Facter::Core::Execution.execute("#{query} #{repo}", logger: @log)
+          end
+          result
+        end
+
+        def query
+          'odmget -q "' + @conditions.join(' AND ') + '"'
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/api_debugger.rb

@@ -1,43 +1,47 @@
 # frozen_string_literal: true
 
-module ApiDebugger
-  def self.prepended(receiver) # rubocop:disable Metrics/AbcSize
-    exclude, print_caller = parse_options(ENV['API_DEBUG'])
+module Facter
+  module Util
+    module ApiDebugger
+      def self.prepended(receiver) # rubocop:disable Metrics/AbcSize
+        exclude, print_caller = parse_options(ENV['API_DEBUG'])
 
-    receiver_methods = receiver.instance_methods - Object.methods
-    receiver_methods.each do |meth|
-      ApiDebugger.class_eval do
-        define_method(meth) do |*args|
-          method_call = super(*args)
+        receiver_methods = receiver.instance_methods - Object.methods
+        receiver_methods.each do |meth|
+          ApiDebugger.class_eval do
+            define_method(meth) do |*args|
+              method_call = super(*args)
 
-          unless exclude.include?(meth)
-            puts '#' * 80
-            puts "Method call: #{meth}"
-            puts "Called with: #{args.inspect}"
-            if print_caller.include?(meth)
-              puts '-' * 80
-              puts caller
+              unless exclude.include?(meth)
+                puts '#' * 80
+                puts "Method call: #{meth}"
+                puts "Called with: #{args.inspect}"
+                if print_caller.include?(meth)
+                  puts '-' * 80
+                  puts caller
+                end
+                puts '#' * 80
+              end
+              method_call
             end
-            puts '#' * 80
           end
-          method_call
         end
       end
-    end
-  end
 
-  def self.parse_options(options)
-    exclude = []
-    print_caller = []
+      def self.parse_options(options)
+        exclude = []
+        print_caller = []
+
+        options.split(',').each do |option|
+          if option.start_with?('-')
+            exclude << option[1..-1].to_sym
+          elsif option.start_with?('+')
+            print_caller << option[1..-1].to_sym
+          end
+        end
 
-    options.split(',').each do |option|
-      if option.start_with?('-')
-        exclude << option[1..-1].to_sym
-      elsif option.start_with?('+')
-        print_caller << option[1..-1].to_sym
+        [exclude, print_caller]
       end
     end
-
-    [exclude, print_caller]
   end
 end

data/lib/facter/util/facts/facts_utils.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      HYPERVISORS_HASH = { 'VMware' => 'vmware', 'VirtualBox' => 'virtualbox', 'Parallels' => 'parallels',
+                           'KVM' => 'kvm', 'Virtual Machine' => 'hyperv', 'RHEV Hypervisor' => 'rhev',
+                           'oVirt Node' => 'ovirt', 'HVM domU' => 'xenhvm', 'Bochs' => 'bochs', 'OpenBSD' => 'vmm',
+                           'BHYVE' => 'bhyve' }.freeze
+
+      PHYSICAL_HYPERVISORS = %w[physical xen0 vmware_server vmware_workstation openvzhn vserver_host].freeze
+      REDHAT_FAMILY = %w[redhat rhel fedora centos scientific ascendos cloudlinux psbm
+                         oraclelinux ovs oel amazon xenserver xcp-ng virtuozzo photon].freeze
+      DEBIAN_FAMILY = %w[debian ubuntu huaweios linuxmint devuan kde].freeze
+      SUSE_FAMILY = %w[sles sled suse].freeze
+      GENTOO_FAMILY = ['gentoo'].freeze
+      ARCH_FAMILY = %w[arch manjaro].freeze
+      MANDRAKE_FAMILY = %w[mandrake mandriva mageia].freeze
+      FAMILY_HASH = { 'RedHat' => REDHAT_FAMILY, 'Debian' => DEBIAN_FAMILY, 'Suse' => SUSE_FAMILY,
+                      'Gentoo' => GENTOO_FAMILY, 'Archlinux' => ARCH_FAMILY, 'Mandrake' => MANDRAKE_FAMILY }.freeze
+
+      class << self
+        def discover_family(os)
+          FAMILY_HASH.each { |key, array_value| return key if array_value.any? { |os_flavour| os =~ /#{os_flavour}/i } }
+          os
+        end
+
+        def release_hash_from_string(output)
+          return unless output
+
+          versions = output.split('.')
+          {}.tap do |release|
+            release['full'] = output
+            release['major'] = versions[0]
+            release['minor'] = versions[1] if versions[1]
+          end
+        end
+
+        def release_hash_from_matchdata(data)
+          return if data.nil? || data[1].nil?
+
+          release_hash_from_string(data[1].to_s)
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/facts/unit_converter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      class UnitConverter
+        class << self
+          def bytes_to_mb(value_in_bytes)
+            return unless value_in_bytes
+
+            value_in_bytes = value_in_bytes.to_i
+
+            (value_in_bytes / (1024.0 * 1024.0)).round(2)
+          end
+
+          def hertz_to_human_readable(speed)
+            speed = speed.to_i
+            return if !speed || speed.zero?
+
+            validated_speed, metric_prefix = determine_metric_prefix(speed)
+
+            format('%<displayed_speed>.2f', displayed_speed: validated_speed).to_s + ' ' + metric_prefix + 'Hz'
+          end
+
+          def bytes_to_human_readable(bytes)
+            return unless bytes
+            return bytes.to_s + ' bytes' if bytes < 1024
+
+            number, multiple = determine_exponent(bytes)
+
+            "#{pad_number(number)} #{multiple}"
+          end
+
+          private
+
+          def pad_number(number)
+            number = number.to_s
+            number << '0' if number.split('.').last.length == 1
+            number
+          end
+
+          def determine_exponent(bytes)
+            prefix = %w[KiB MiB GiB TiB PiB EiB]
+            exp = (Math.log2(bytes) / 10.0).floor
+            converted_number = (100.0 * (bytes / 1024.0**exp)).round / 100.0
+
+            if (converted_number - 1024.0).abs < Float::EPSILON
+              exp += 1
+              converted_number = 1.00
+            end
+            multiple = prefix[exp - 1] || 'bytes'
+
+            converted_number = bytes if multiple == 'bytes'
+            [converted_number, multiple]
+          end
+
+          def determine_metric_prefix(num)
+            metric_prefix = { 0 => '', 3 => 'k', 6 => 'M', 9 => 'G', 12 => 'T' }
+            power = Math.log10(num).floor
+            display_exponent = power - power % 3
+            coefficient = power.zero? ? num.to_f : num.fdiv(10**display_exponent)
+            [coefficient, metric_prefix[display_exponent]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/facts/uptime_parser.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Facter
+  module Util
+    module Facts
+      class UptimeParser
+        SECS_IN_A_DAY = 86_400
+        SECS_IN_AN_HOUR = 3_600
+        SECS_IN_A_MINUTE = 60
+
+        @log = Facter::Log.new(self)
+
+        class << self
+          def uptime_seconds_unix
+            uptime_proc_uptime || uptime_sysctl || uptime_executable
+          end
+
+          private
+
+          def uptime_proc_uptime
+            output = Facter::Core::Execution.execute("/bin/cat #{uptime_file}", logger: @log)
+
+            output.chomp.split(' ').first.to_i unless output.empty?
+          end
+
+          def uptime_sysctl
+            output = Facter::Core::Execution.execute("sysctl -n #{uptime_sysctl_variable}", logger: @log)
+
+            compute_uptime(Time.at(output.match(/\d+/)[0].to_i)) unless output.empty?
+          end
+
+          def uptime_executable
+            output = Facter::Core::Execution.execute(uptime_executable_cmd, logger: @log)
+
+            return unless output
+
+            up = 0
+            output_calculator_methods.find { |method| up = send(method, output) }
+            up || 0
+          end
+
+          def uptime_file
+            '/proc/uptime'
+          end
+
+          def uptime_sysctl_variable
+            'kern.boottime'
+          end
+
+          def uptime_executable_cmd
+            'uptime'
+          end
+
+          def output_calculator_methods
+            %i[
+              calculate_days_hours_minutes
+              calculate_days_hours
+              calculate_days_minutes
+              calculate_days
+              calculate_hours_minutes
+              calculate_hours
+              calculate_minutes
+            ]
+          end
+
+          def compute_uptime(time)
+            (Time.now - time).to_i
+          end
+
+          # Regexp handles Solaris, AIX, HP-UX, and Tru64.
+          # 'day(?:s|\(s\))?' says maybe 'day', 'days',
+          #   or 'day(s)', and don't set $2.
+          def calculate_days_hours_minutes(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,?\s+(\d+):-?(\d+)/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+              SECS_IN_AN_HOUR * Regexp.last_match(2).to_i +
+              SECS_IN_A_MINUTE * Regexp.last_match(3).to_i
+          end
+
+          def calculate_days_hours(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) hr(?:s|\(s\))?,/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+              SECS_IN_AN_HOUR * Regexp.last_match(2).to_i
+          end
+
+          def calculate_days_minutes(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) min(?:s|\(s\))?,/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+              SECS_IN_A_MINUTE * Regexp.last_match(2).to_i
+          end
+
+          def calculate_days(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i
+          end
+
+          # must anchor to 'up' to avoid matching time of day
+          # at beginning of line. Certain versions of uptime on
+          # Solaris may insert a '-' into the minutes field.
+          def calculate_hours_minutes(output)
+            return unless output =~ /up\s+(\d+):-?(\d+),/
+
+            SECS_IN_AN_HOUR * Regexp.last_match(1).to_i +
+              SECS_IN_A_MINUTE * Regexp.last_match(2).to_i
+          end
+
+          def calculate_hours(output)
+            return unless output =~ /(\d+) hr(?:s|\(s\))?,/
+
+            SECS_IN_AN_HOUR * Regexp.last_match(1).to_i
+          end
+
+          def calculate_minutes(output)
+            return unless output =~ /(\d+) min(?:s|\(s\))?,/
+
+            SECS_IN_A_MINUTE * Regexp.last_match(1).to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/facts/virtual_detector.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      class VirtualDetector
+        def initialize
+          @log = Facter::Log.new(self)
+        end
+
+        def platform
+          fact_value = check_docker_lxc || check_dmi || check_freebsd || check_gce || retrieve_from_virt_what
+          fact_value ||= check_vmware || check_open_vz || check_vserver || check_xen || check_other_facts
+          fact_value ||= check_lspci || 'physical'
+
+          fact_value
+        end
+
+        def check_docker_lxc
+          @log.debug('Checking Docker and LXC')
+          Facter::Resolvers::Containers.resolve(:vm)
+        end
+
+        def check_dmi
+          @log.debug('Checking DMI')
+          vendor = Facter::Resolvers::DmiDecode.resolve(:vendor)
+          @log.debug("dmi detected vendor: #{vendor}")
+          return 'kvm' if vendor =~ /Amazon/
+
+          'xen' if vendor =~ /Xen/
+        end
+
+        def check_gce
+          @log.debug('Checking GCE')
+          bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+          'gce' if bios_vendor&.include?('Google')
+        end
+
+        def check_vmware
+          @log.debug('Checking VMware')
+          Facter::Resolvers::Vmware.resolve(:vm)
+        end
+
+        def retrieve_from_virt_what
+          @log.debug('Checking virtual_what')
+          Facter::Resolvers::VirtWhat.resolve(:vm)
+        end
+
+        def check_open_vz
+          @log.debug('Checking OpenVZ')
+          Facter::Resolvers::OpenVz.resolve(:vm)
+        end
+
+        def check_vserver
+          @log.debug('Checking VServer')
+          Facter::Resolvers::VirtWhat.resolve(:vserver)
+        end
+
+        def check_xen
+          @log.debug('Checking XEN')
+          Facter::Resolvers::Xen.resolve(:vm)
+        end
+
+        def check_freebsd
+          return unless Object.const_defined?('Facter::Resolvers::Freebsd::Virtual')
+
+          @log.debug('Checking if jailed')
+          Facter::Resolvers::Freebsd::Virtual.resolve(:vm)
+        end
+
+        def check_other_facts
+          @log.debug('Checking others')
+          product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+          bios_vendor =  Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+          return 'kvm' if bios_vendor&.include?('Amazon EC2')
+          return unless product_name
+
+          Facter::Util::Facts::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+          nil
+        end
+
+        def check_lspci
+          @log.debug('Checking lspci')
+          Facter::Resolvers::Lspci.resolve(:vm)
+        end
+      end
+    end
+  end
+end