facter 4.0.46 → 4.0.47

data/lib/facter/resolvers/windows/dmi_computersystem_resolver.rb

@@ -17,7 +17,7 @@ module Facter
         end
 
         def read_fact_from_computer_system(fact_name)
-          win = Win32Ole.new
+          win = Facter::Util::Windows::Win32Ole.new
           computersystem = win.return_first('SELECT Name,UUID FROM Win32_ComputerSystemProduct')
           unless computersystem
             @log.debug 'WMI query returned no results for Win32_ComputerSystemProduct with values Name and UUID.'

data/lib/facter/resolvers/windows/memory_resolver.rb

@@ -23,6 +23,10 @@ module Facter
             return
           end
 
+          # we need to enlarge the scope of this pointer so that Ruby GC will not free the memory.
+          # If the pointer if freed, Lifreq structures will contain garbage from memory.
+          @long_living_pointer = state_ptr
+
           PerformanceInformation.new(state_ptr)
         end
 

data/lib/facter/resolvers/windows/networking_resolver.rb

@@ -26,7 +26,7 @@ module Facter
 
             iterate_list(adapter_addresses)
 
-            ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+            Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
 
             @fact_list[fact_name]
           end
@@ -120,13 +120,13 @@ module Facter
           def find_bindings(sock_addr, unicast, addr)
             return unless [NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family])
 
-            ::Resolvers::Utils::Networking.build_binding(addr, unicast[:OnLinkPrefixLength])
+            Facter::Util::Resolvers::Networking.build_binding(addr, unicast[:OnLinkPrefixLength])
           end
 
           def find_primary_interface(sock_addr, name, addr)
             if !@fact_list[:primary_interface] &&
                ([NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family]) &&
-               !::Resolvers::Utils::Networking.ignored_ip_address(addr))
+               !::Facter::Util::Resolvers::Networking.ignored_ip_address(addr))
               @fact_list[:primary_interface] = name.to_s
             end
           end

data/lib/facter/resolvers/windows/processors_resolver.rb

@@ -18,7 +18,7 @@ module Facter
         end
 
         def read_fact_from_win32_processor(fact_name)
-          win = Win32Ole.new
+          win = Facter::Util::Windows::Win32Ole.new
           proc = win.exec_query('SELECT Name,Architecture,NumberOfLogicalProcessors FROM Win32_Processor')
           unless proc
             log.debug 'WMI query returned no results'\

data/lib/facter/resolvers/windows/ssh.rb

@@ -24,11 +24,11 @@ module Facter
             ssh_list = []
 
             FILE_NAMES.each do |file_name|
-              output = Util::FileHelper.safe_read(File.join(ssh_dir, file_name))
+              output = Facter::Util::FileHelper.safe_read(File.join(ssh_dir, file_name))
               next if output.empty?
 
               key_type, key = output.split(' ')
-              ssh_list << ::Resolvers::Utils::SshHelper.create_ssh(key_type, key)
+              ssh_list << Facter::Util::Resolvers::SshHelper.create_ssh(key_type, key)
             end
             @fact_list[:ssh] = ssh_list.empty? ? nil : ssh_list
             @fact_list[fact_name]

data/lib/facter/resolvers/windows/uptime_resolver.rb

@@ -18,7 +18,7 @@ module Facter
           end
 
           def substract_system_uptime_from_ole
-            win = Win32Ole.new
+            win = Facter::Util::Windows::Win32Ole.new
             opsystem = win.return_first('SELECT LocalDateTime,LastBootUpTime FROM Win32_OperatingSystem')
             unless opsystem
               @log.debug 'WMI query returned no results'\

data/lib/facter/resolvers/windows/virtualization_resolver.rb

@@ -21,7 +21,7 @@ module Facter
         end
 
         def read_fact_from_computer_system(fact_name)
-          win = Win32Ole.new
+          win = Facter::Util::Windows::Win32Ole.new
           comp = win.exec_query('SELECT Manufacturer,Model,OEMStringArray FROM Win32_ComputerSystem')
           unless comp
             @log.debug 'WMI query returned no results for Win32_ComputerSystem with values'\

data/lib/facter/resolvers/windows/win_os_description_resolver.rb

@@ -15,7 +15,7 @@ module Facter
         end
 
         def read_from_ole(fact_name)
-          win = Win32Ole.new
+          win = Facter::Util::Windows::Win32Ole.new
           op_sys = win.return_first('SELECT ProductType,OtherTypeDescription FROM Win32_OperatingSystem')
           unless op_sys
             @log.debug 'WMI query returned no results for Win32_OperatingSystem'\

data/lib/facter/resolvers/xen.rb

@@ -32,7 +32,7 @@ module Facter
         end
 
         def privileged?(xen_type)
-          content = Util::FileHelper.safe_read(XEN_PATH, nil)
+          content = Facter::Util::FileHelper.safe_read(XEN_PATH, nil)
           content&.strip == 'control_d' || xen_type == 'xen0'
         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,14 @@
+# 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
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# 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?
+
+            prefix = { 3 => 'k', 6 => 'M', 9 => 'G', 12 => 'T' }
+            power = Math.log10(speed).floor
+            validated_speed = power.zero? ? speed.to_f : speed.fdiv(10**power)
+            format('%<displayed_speed>.2f', displayed_speed: validated_speed).to_s + ' ' + prefix[power] + '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
+        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