facter 4.0.39 → 4.0.44

data/lib/facter/framework/detector/os_hierarchy.rb

@@ -1,29 +1,25 @@
 # frozen_string_literal: true
 
+require 'facter/config'
+
 module Facter
   class OsHierarchy
     def initialize
       @log = Log.new(self)
-      json_file_path = File.join(File.dirname(__FILE__), '../../os_hierarchy.json')
-      json_file = Util::FileHelper.safe_read(json_file_path)
-      begin
-        @json_os_hierarchy = JSON.parse(json_file)
-      rescue JSON::ParserError => _e
-        @log.error('Could not parse os_hierarchy json')
-      end
+      @os_hierarchy = Facter::Config::OS_HIERARCHY
     end
 
     def construct_hierarchy(searched_os)
       return [] if searched_os.nil?
 
       searched_os = searched_os.to_s.capitalize
-      if @json_os_hierarchy.nil?
+      if @os_hierarchy.nil?
         @log.debug("There is no os_hierarchy, will fall back to: #{searched_os}")
         return [searched_os]
       end
 
       @searched_path = []
-      search(@json_os_hierarchy, searched_os, [])
+      search(@os_hierarchy, searched_os, [])
 
       @searched_path.map { |os_name| os_name.to_s.capitalize }
     end

data/lib/facter/framework/logging/logger.rb

@@ -91,9 +91,7 @@ module Facter
     def error(msg, colorize = false)
       @@has_errors = true
 
-      if msg.nil? || msg.empty?
-        empty_message_error(msg)
-      elsif @@message_callback
+      if @@message_callback
         @@message_callback.call(:error, msg)
       else
         msg = colorize(msg, RED) if colorize || Options[:color]
@@ -111,8 +109,6 @@ module Facter
     private
 
     def colorize(msg, color)
-      return msg if OsDetector.instance.identifier.eql?(:windows)
-
       "#{color}#{msg}#{RESET}"
     end
 

data/lib/facter/resolvers/aix/architecture_resolver.rb

@@ -14,9 +14,11 @@ module Facter
 
         def read_architecture(fact_name)
           require_relative 'utils/odm_query'
+
+          proc_number = read_proc
           odmquery = ODMQuery.new
           odmquery
-            .equals('name', 'proc0')
+            .equals('name', proc_number)
             .equals('attribute', 'type')
 
           result = odmquery.execute
@@ -32,6 +34,18 @@ module Facter
 
           @fact_list[fact_name]
         end
+
+        def read_proc
+          odmquery = ODMQuery.new
+          odmquery
+            .equals('PdDvLn', 'processor/sys/proc_rspc')
+            .equals('status', '1')
+
+          result = odmquery.execute
+          result.each_line do |line|
+            return line.split('=')[1].strip.delete('\"') if line.include?('name')
+          end
+        end
       end
     end
   end

data/lib/facter/resolvers/aix/os_level.rb

@@ -14,7 +14,7 @@ module Facter
           end
 
           def read_oslevel(fact_name)
-            output = Facter::Core::Execution.execute('/usr/bin/oslevel -s', { limit: 2, logger: log })
+            output = Facter::Core::Execution.execute('/usr/bin/oslevel -s', logger: log)
             @fact_list[:build] = output unless output.empty?
             @fact_list[:kernel] = 'AIX'
 

data/lib/facter/resolvers/augeas_resolver.rb

@@ -20,7 +20,13 @@ module Facter
         end
 
         def read_augeas_from_cli
-          output = Facter::Core::Execution.execute('augparse --version 2>&1', logger: log)
+          command = if File.readable?('/opt/puppetlabs/puppet/bin/augparse')
+                      '/opt/puppetlabs/puppet/bin/augparse'
+                    else
+                      'augparse'
+                    end
+
+          output = Facter::Core::Execution.execute("#{command} --version 2>&1", logger: log)
           Regexp.last_match(1) if output =~ /^augparse (\d+\.\d+\.\d+)/
         end
 

data/lib/facter/resolvers/bsd/processors.rb

@@ -16,8 +16,12 @@ module Facter
           def collect_processors_info(fact_name)
             require 'facter/resolvers/bsd/ffi/ffi_helper'
 
-            @fact_list[:logical_count] = logical_count
-            @fact_list[:models] = Array.new(logical_count, model) if logical_count && model
+            count = logical_count
+            model = processor_model
+            speed = processor_speed
+
+            @fact_list[:logical_count] = count
+            @fact_list[:models] = Array.new(count, model) if count && model
             @fact_list[:speed] = speed * 1000 * 1000 if speed
 
             @fact_list[fact_name]
@@ -28,16 +32,16 @@ module Facter
           HW_NCPU = 3
           HW_CPUSPEED = 12
 
-          def model
-            @model ||= Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_MODEL])
+          def processor_model
+            Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_MODEL])
           end
 
           def logical_count
-            @logical_count ||= Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_NCPU])
+            Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_NCPU])
           end
 
-          def speed
-            @speed ||= Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_CPUSPEED])
+          def processor_speed
+            Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_CPUSPEED])
           end
         end
       end

data/lib/facter/resolvers/disk_resolver.rb

@@ -7,7 +7,7 @@ module Facter
         @log = Facter::Log.new(self)
         @fact_list ||= {}
         DIR = '/sys/block'
-        FILE_PATHS = { model: 'device/model', size: 'size', vendor: 'device/vendor' }.freeze
+        FILE_PATHS = { model: 'device/model', size: 'size', vendor: 'device/vendor', type: 'queue/rotational' }.freeze
         class << self
           private
 
@@ -25,8 +25,16 @@ module Facter
                 result = Util::FileHelper.safe_read(file_path).strip
                 next if result.empty?
 
-                # Linux always considers sectors to be 512 bytes long independently of the devices real block size.
-                value[key] = file =~ /size/ ? construct_size(value, result) : result
+                value[key] = case key
+                             when :size
+                               # Linux always considers sectors to be 512 bytes long
+                               # independently of the devices real block size.
+                               construct_size(value, result)
+                             when :type
+                               result == '0' ? 'ssd' : 'hdd'
+                             else
+                               result
+                             end
               end
             end
 

data/lib/facter/resolvers/dmi_decode.rb

@@ -37,6 +37,7 @@ module Facter
           @fact_list[:virtualbox_version] = output.match(/vboxVer_(\S+)/)&.captures&.first
           @fact_list[:virtualbox_revision] = output.match(/vboxRev_(\S+)/)&.captures&.first
           @fact_list[:vmware_version] = extract_vmware_version(output)
+          @fact_list[:vendor] = output.match(/Vendor: (\S+)/)&.captures&.first
 
           @fact_list[fact_name]
         end

data/lib/facter/resolvers/dmi_resolver.rb

@@ -36,9 +36,9 @@ module Facter
 
             file_content = Util::FileHelper.safe_read("/sys/class/dmi/id/#{fact_name}", nil)
             if files.include?(fact_name.to_s) && file_content
-              @fact_list[fact_name] = file_content.strip
+              file_content = file_content.strip
+              @fact_list[fact_name] = file_content unless file_content.empty?
               chassis_to_name(@fact_list[fact_name]) if fact_name == :chassis_type
-
             end
             @fact_list[fact_name]
           end

data/lib/facter/resolvers/freebsd/geom_resolver.rb

@@ -5,6 +5,8 @@ module Facter
     module Freebsd
       class Geom < BaseResolver
         @fact_list ||= {}
+        DISKS_ATTRIBUTES = %i[read_model read_serial_number read_size].freeze
+        PARTITIONS_ATTRIBUTES = %i[read_partlabel read_partuuid read_size].freeze
 
         class << self
           private
@@ -17,37 +19,27 @@ module Facter
             require_relative 'ffi/ffi_helper'
             require 'rexml/document'
 
-            read_disks
-            read_partitions
+            topology = geom_topology
+            read_data('DISK', topology, DISKS_ATTRIBUTES)
+            read_data('PART', topology, PARTITIONS_ATTRIBUTES)
 
             @fact_list[fact_name]
           end
 
-          def read_disks
-            @fact_list[:disks] = {}
+          def read_data(fact_name, geom_topology, data_to_read)
+            fact_list_key = fact_name == 'DISK' ? :disks : :partitions
+            @fact_list[fact_list_key] = {}
 
-            each_geom_class_provider('DISK') do |provider|
+            each_geom_class_provider(fact_name, geom_topology) do |provider|
               name = provider.get_text('./name').value
 
-              @fact_list[:disks][name] = %i[read_model read_serial_number read_size].map do |x|
+              @fact_list[fact_list_key][name] = data_to_read.map do |x|
                 send(x, provider)
               end.inject(:merge)
             end
           end
 
-          def read_partitions
-            @fact_list[:partitions] = {}
-
-            each_geom_class_provider('PART') do |provider|
-              name = provider.get_text('./name').value
-
-              @fact_list[:partitions][name] = %i[read_partlabel read_partuuid read_size].map do |x|
-                send(x, provider)
-              end.inject(:merge)
-            end
-          end
-
-          def each_geom_class_provider(geom_class_name, &block)
+          def each_geom_class_provider(geom_class_name, geom_topology, &block)
             REXML::XPath.each(geom_topology, "/mesh/class[name/text() = '#{geom_class_name}']/geom/provider", &block)
           end
 
@@ -95,7 +87,7 @@ module Facter
           end
 
           def geom_topology
-            @geom_topology ||= REXML::Document.new(geom_confxml)
+            REXML::Document.new(geom_confxml)
           end
 
           def geom_confxml

data/lib/facter/resolvers/freebsd/processors.rb

@@ -18,23 +18,27 @@ module Facter
           def collect_processors_info(fact_name)
             require 'facter/resolvers/freebsd/ffi/ffi_helper'
 
-            @fact_list[:logical_count] = logical_count
-            @fact_list[:models] = Array.new(logical_count, model) if logical_count && model
+            count = logical_count
+            model = processors_model
+            speed = processors_speed
+
+            @fact_list[:logical_count] = count
+            @fact_list[:models] = Array.new(count, model) if logical_count && model
             @fact_list[:speed] = speed * 1000 * 1000 if speed
 
             @fact_list[fact_name]
           end
 
-          def model
-            @model ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'hw.model')
+          def processors_model
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'hw.model')
           end
 
           def logical_count
-            @logical_count ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.ncpu')
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.ncpu')
           end
 
-          def speed
-            @speed ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.clockrate')
+          def processors_speed
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.clockrate')
           end
         end
       end

data/lib/facter/resolvers/memory_resolver.rb

@@ -25,11 +25,21 @@ module Facter
 
           def read_system(output)
             @fact_list[:total] = kilobytes_to_bytes(output.match(/MemTotal:\s+(\d+)\s/)[1])
-            @fact_list[:memfree] = kilobytes_to_bytes(output.match(/MemFree:\s+(\d+)\s/)[1])
-            @fact_list[:used_bytes] = compute_used(@fact_list[:total], reclaimable_memory(output))
+            @fact_list[:memfree] = memfree(output)
+            @fact_list[:used_bytes] = compute_used(@fact_list[:total], @fact_list[:memfree])
             @fact_list[:capacity] = compute_capacity(@fact_list[:used_bytes], @fact_list[:total])
           end
 
+          def memfree(output)
+            available = output.match(/MemAvailable:\s+(\d+)\s/)
+            return kilobytes_to_bytes(available[1]) if available
+
+            buffers = kilobytes_to_bytes(output.match(/Buffers:\s+(\d+)\s/)[1])
+            cached = kilobytes_to_bytes(output.match(/Cached:\s+(\d+)\s/)[1])
+            memfree = kilobytes_to_bytes(output.match(/MemFree:\s+(\d+)\s/)[1])
+            memfree + buffers + cached
+          end
+
           def read_swap(output)
             total = output.match(/SwapTotal:\s+(\d+)\s/)[1]
             return if total.to_i.zero?
@@ -44,18 +54,6 @@ module Facter
             quantity.to_i * 1024
           end
 
-          def reclaimable_memory(output)
-            buffers = kilobytes_to_bytes(output.match(/Buffers:\s+(\d+)\s/)[1])
-            cached = kilobytes_to_bytes(output.match(/Cached:\s+(\d+)\s/)[1])
-            s_reclaimable = output.match(/SReclaimable:\s+(\d+)\s/)
-            s_reclaimable = if s_reclaimable
-                              kilobytes_to_bytes(s_reclaimable[1])
-                            else
-                              0
-                            end
-            @fact_list[:memfree] + buffers + cached + s_reclaimable
-          end
-
           def compute_capacity(used, total)
             format('%<computed_capacity>.2f', computed_capacity: (used / total.to_f * 100)) + '%'
           end

data/lib/facter/resolvers/mountpoints_resolver.rb

@@ -10,13 +10,27 @@ module Facter
         private
 
         def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { read_mounts }
+          @fact_list.fetch(fact_name) { read_mounts(fact_name) }
         end
 
         def root_device
           cmdline = Util::FileHelper.safe_read('/proc/cmdline')
           match = cmdline.match(/root=([^\s]+)/)
-          match&.captures&.first
+          root = match&.captures&.first
+
+          if !root.nil? && root.include?('=')
+            # We are dealing with the PARTUUID of the partition. Need to extract partition path.
+            root_partition_path = convert_partuuid_to_path(root)
+            root = root_partition_path unless root_partition_path.nil?
+          end
+          root
+        end
+
+        def convert_partuuid_to_path(root)
+          blkid_content = Facter::Core::Execution.execute('blkid', logger: log)
+          partuuid = root.split('=').last
+          match = blkid_content.match(/(.+)#{partuuid}/)
+          match&.captures&.first&.split(':')&.first
         end
 
         def compute_device(device)
@@ -26,32 +40,46 @@ module Facter
           device
         end
 
-        def read_mounts # rubocop:disable Metrics/AbcSize
+        def read_mounts(fact_name)
           mounts = []
-          FilesystemHelper.read_mountpoints.each do |fs|
-            device = compute_device(fs.name)
-            filesystem = fs.mount_type
-            path = fs.mount_point
-            options = fs.options.split(',').map(&:strip)
+          FilesystemHelper.read_mountpoints.each do |file_system|
+            mount = {}
+            get_mount_data(file_system, mount)
 
-            next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
+            next if mount[:path] =~ %r{^/(proc|sys)} && mount[:filesystem] != 'tmpfs' || mount[:filesystem] == 'autofs'
 
-            stats = FilesystemHelper.read_mountpoint_stats(path)
-            size_bytes = stats.bytes_total.abs
-            available_bytes = stats.bytes_available.abs
+            get_mount_sizes(mount)
+            mounts << mount
+          end
 
-            used_bytes = stats.bytes_used.abs
-            total_bytes = used_bytes + available_bytes
-            capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
+          @fact_list[:mountpoints] = mounts
+          @fact_list[fact_name]
+        end
 
-            size = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
-            available = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes)
-            used = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes)
+        def get_mount_data(file_system, mount)
+          mount[:device] = compute_device(file_system.name)
+          mount[:filesystem] = file_system.mount_type
+          mount[:path] = file_system.mount_point
+          mount[:options] = file_system.options.split(',').map(&:strip)
+        end
 
-            mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
-              .map { |v| binding.local_variable_get(v) })]
-          end
-          @fact_list[:mountpoints] = mounts
+        def get_mount_sizes(mount)
+          stats = FilesystemHelper.read_mountpoint_stats(mount[:path])
+
+          get_bytes_data(mount, stats)
+
+          total_bytes = mount[:used_bytes] + mount[:available_bytes]
+          mount[:capacity] = FilesystemHelper.compute_capacity(mount[:used_bytes], total_bytes)
+
+          mount[:size] = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(mount[:size_bytes])
+          mount[:available] = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(mount[:available_bytes])
+          mount[:used] = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(mount[:used_bytes])
+        end
+
+        def get_bytes_data(mount, stats)
+          mount[:size_bytes] = stats.bytes_total.abs
+          mount[:available_bytes] = stats.bytes_available.abs
+          mount[:used_bytes] = stats.bytes_used.abs
         end
       end
     end

data/lib/facter/resolvers/networking_linux_resolver.rb

@@ -10,7 +10,6 @@ module Facter
         private
 
         def post_resolve(fact_name)
-          log.debug('in networking_linux_resolver')
           @fact_list.fetch(fact_name) { retrieve_network_info(fact_name) }
 
           @fact_list[fact_name]
@@ -60,9 +59,14 @@ module Facter
           return if !network_info[interface_name] || network_info[interface_name][:dhcp]
 
           index = tokens[0].delete(':')
-          dhcp = Util::FileHelper.safe_read("/run/systemd/netif/leases/#{index}", nil)
-          network_info[interface_name][:dhcp] = dhcp.match(/SERVER_ADDRESS=(.*)/)[1] if dhcp
-          network_info[interface_name][:dhcp] ||= retrieve_from_other_directories(interface_name)
+          file_content = Util::FileHelper.safe_read("/run/systemd/netif/leases/#{index}", nil)
+          dhcp = file_content.match(/SERVER_ADDRESS=(.*)/) if file_content
+          if dhcp
+            network_info[interface_name][:dhcp] = dhcp[1]
+          else
+            alternate_dhcp = retrieve_from_other_directories(interface_name)
+            network_info[interface_name][:dhcp] = alternate_dhcp if alternate_dhcp
+          end
         end
 
         def retrieve_from_other_directories(interface_name)
@@ -76,7 +80,8 @@ module Facter
               content = Util::FileHelper.safe_read("#{dir}#{file}", nil)
               next unless content =~ /interface.*#{interface_name}/
 
-              return content.match(/dhcp-server-identifier ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/)[1]
+              dhcp = content.match(/dhcp-server-identifier ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/)
+              return dhcp[1] if dhcp
             end
           end
           return unless File.readable?('/var/lib/NetworkManager/')