facter 4.0.43 → 4.0.44

data/lib/facter/framework/core/cache_manager.rb

@@ -74,7 +74,10 @@ module Facter
     end
 
     def read_fact(searched_fact, fact_group)
-      data = read_group_json(fact_group)
+      data = nil
+      Facter::Framework::Benchmarking::Timer.measure(searched_fact.name, 'cached') do
+        data = read_group_json(fact_group)
+      end
       return unless data
 
       @log.debug("loading cached values for #{searched_fact.name} facts")

data/lib/facter/framework/core/options/option_store.rb

@@ -8,28 +8,36 @@ module Facter
     # TODO: constant is not yet available when running puppet facts
     @log_level = :warn
     @show_legacy = true
+    @custom_facts = true
+    @blocked_facts = []
+    @ruby = true
+    @external_facts = true
+    @config = nil
+    @user_query = []
+    @strict = false
+    @json = false
+    @cache = true
+    @yaml = false
+    @puppet = false
+    @ttls = []
     @block = true
-    @custom_dir = []
+    @cli = nil
     @config_file_custom_dir = []
-    @custom_facts = true
-    @external_dir = []
     @config_file_external_dir = []
     @default_external_dir = []
-    @external_facts = true
-    @ruby = true
-    @cache = true
-    @blocked_facts = []
-    @user_query = []
-    @block_list = {}
     @fact_groups = {}
+    @block_list = []
     @color = true
+    @trace = false
     @timing = false
+    @external_dir = []
+    @custom_dir = []
 
     class << self
       attr_reader :debug, :verbose, :log_level, :show_legacy,
                   :custom_facts, :blocked_facts, :ruby, :external_facts
 
-      attr_accessor :config, :user_query, :strict, :json, :haml,
+      attr_accessor :config, :user_query, :strict, :json,
                     :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
                     :config_file_external_dir, :default_external_dir, :fact_groups,
                     :block_list, :color, :trace, :timing
@@ -158,26 +166,34 @@ module Facter
         # TODO: constant is not yet available when running puppet facts
         @log_level = :warn
         @show_legacy = true
-        @block = true
         @ruby = true
         @user_query = []
-        @cli = nil
+        @json = false
         @cache = true
-        @trace = false
+        @yaml = false
+        @puppet = false
+        @ttls = []
+        @block = true
+        @cli = nil
         reset_config
       end
 
       def reset_config
-        @custom_dir = []
         @custom_facts = true
-        @external_dir = []
-        @default_external_dir = []
-        @config_file_external_dir = []
-        @external_facts = true
         @blocked_facts = []
+        @external_facts = true
+        @config = nil
+        @strict = false
+        @config_file_custom_dir = []
+        @config_file_external_dir = []
+        @default_external_dir = []
         @fact_groups = {}
-        @block_list = {}
+        @block_list = []
+        @color = true
+        @trace = false
         @timing = false
+        @external_dir = []
+        @custom_dir = []
       end
 
       def fallback_external_dir

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/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/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/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/mountpoints_resolver.rb

@@ -16,7 +16,21 @@ module Facter
         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,36 +40,47 @@ module Facter
           device
         end
 
-        # rubocop:disable Metrics/MethodLength, 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)
-
-            next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
+          FilesystemHelper.read_mountpoints.each do |file_system|
+            mount = {}
+            get_mount_data(file_system, mount)
 
-            stats = FilesystemHelper.read_mountpoint_stats(path)
-            size_bytes = stats.bytes_total.abs
-            available_bytes = stats.bytes_available.abs
+            next if mount[:path] =~ %r{^/(proc|sys)} && mount[:filesystem] != 'tmpfs' || mount[:filesystem] == 'autofs'
 
-            used_bytes = stats.bytes_used.abs
-            total_bytes = used_bytes + available_bytes
-            capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
-
-            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)
-
-            mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
-              .map { |v| binding.local_variable_get(v) })]
+            get_mount_sizes(mount)
+            mounts << mount
           end
+
           @fact_list[:mountpoints] = mounts
           @fact_list[fact_name]
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        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
+
+        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
   end

data/lib/facter/resolvers/partitions.rb

@@ -15,98 +15,122 @@ module Facter
         end
 
         def read_partitions(fact_name)
-          @fact_list[:partitions] = {}
-          return {} unless File.readable?(BLOCK_PATH)
+          return unless File.readable?(BLOCK_PATH)
 
           block_devices = Dir.entries(BLOCK_PATH).reject { |dir| dir =~ /^\.+/ }
+          @fact_list[:partitions] = {} unless block_devices.empty?
+          blkid_and_lsblk = {}
+
           block_devices.each do |block_device|
             block_path = "#{BLOCK_PATH}/#{block_device}"
             if File.directory?("#{block_path}/device")
-              extract_from_device(block_path)
+              extract_from_device(block_path, blkid_and_lsblk)
             elsif File.directory?("#{block_path}/dm")
-              extract_from_dm(block_path)
+              extract_from_dm(block_path, block_device, blkid_and_lsblk)
             elsif File.directory?("#{block_path}/loop")
-              extract_from_loop(block_path)
+              extract_from_loop(block_path, block_device, blkid_and_lsblk)
             end
           end
+
           @fact_list[fact_name]
         end
 
-        def extract_from_device(block_path)
+        def extract_from_device(block_path, blkid_and_lsblk)
           subdirs = browse_subdirectories(block_path)
           subdirs.each do |subdir|
             name = "/dev/#{subdir.split('/').last}"
-            populate_partitions(name, subdir)
+            populate_partitions(name, subdir, blkid_and_lsblk)
           end
         end
 
-        def extract_from_dm(block_path)
+        def extract_from_dm(block_path, block_device, blkid_and_lsblk)
           map_name = Util::FileHelper.safe_read("#{block_path}/dm/name").chomp
           if map_name.empty?
-            populate_partitions("/dev#{block_path}", block_path)
+            populate_partitions("/dev/#{block_device}", block_path, blkid_and_lsblk)
           else
-            populate_partitions("/dev/mapper/#{map_name}", block_path)
+            populate_partitions("/dev/mapper/#{map_name}", block_path, blkid_and_lsblk)
           end
         end
 
-        def extract_from_loop(block_path)
+        def extract_from_loop(block_path, block_device, blkid_and_lsblk)
           backing_file = Util::FileHelper.safe_read("#{block_path}/loop/backing_file").chomp
           if backing_file.empty?
-            populate_partitions("/dev#{block_path}", block_path)
+            populate_partitions("/dev/#{block_device}", block_path, blkid_and_lsblk)
           else
-            populate_partitions("/dev#{block_path}", block_path, backing_file)
+            populate_partitions("/dev/#{block_device}", block_path, blkid_and_lsblk, backing_file)
           end
         end
 
-        def populate_partitions(partition_name, block_path, backing_file = nil)
-          @fact_list[:partitions][partition_name] = {}
+        def populate_partitions(partition_name, block_path, blkid_and_lsblk, backing_file = nil)
           size_bytes = Util::FileHelper.safe_read("#{block_path}/size", '0')
                                        .chomp.to_i * BLOCK_SIZE
           info_hash = { size_bytes: size_bytes,
                         size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes),
                         backing_file: backing_file }
-          info_hash.merge!(populate_from_syscalls(partition_name))
+          info_hash.merge!(populate_from_syscalls(partition_name, blkid_and_lsblk))
           @fact_list[:partitions][partition_name] = info_hash.reject { |_key, value| value.nil? }
         end
 
-        def populate_from_syscalls(partition_name)
-          part_info = populate_from_blkid(partition_name)
+        def populate_from_syscalls(partition_name, blkid_and_lsblk)
+          part_info = populate_from_blkid(partition_name, blkid_and_lsblk)
 
-          return pupulate_from_lsblk(partition_name) if part_info.empty?
+          return populate_from_lsblk(partition_name, blkid_and_lsblk) if part_info.empty?
 
           part_info
         end
 
-        def populate_from_blkid(partition_name)
-          return {} unless blkid_command?
+        def browse_subdirectories(path)
+          dirs = Dir[File.join(path, '**', '*')].select { |p| File.directory? p }
+          dirs.select { |subdir| subdir.split('/').last.include?(path.split('/').last) }.reject(&:nil?)
+        end
+
+        def populate_from_blkid(partition_name, blkid_and_lsblk)
+          return {} unless available?('blkid', blkid_and_lsblk)
+
+          blkid_and_lsblk[:blkid] ||= execute_and_extract_blkid_info
 
-          @blkid_content ||= execute_and_extract_blkid_info
-          return {} unless @blkid_content[partition_name]
+          partition_data = blkid_and_lsblk[:blkid][partition_name]
+          return {} unless partition_data
+
+          filesys = partition_data['TYPE']
+          uuid = partition_data['UUID']
+          label = partition_data['LABEL']
+          part_uuid = partition_data['PARTUUID']
+          part_label = partition_data['PARTLABEL']
 
-          filesys = @blkid_content[partition_name]['TYPE']
-          uuid = @blkid_content[partition_name]['UUID']
-          label = @blkid_content[partition_name]['LABEL']
-          part_uuid = @blkid_content[partition_name]['PARTUUID']
-          part_label = @blkid_content[partition_name]['PARTLABEL']
           { filesystem: filesys, uuid: uuid, label: label, partuuid: part_uuid, partlabel: part_label }
         end
 
-        def blkid_command?
-          return @blkid_exists unless @blkid_exists.nil?
+        def available?(command, blkid_and_lsblk)
+          command_exists_key = command == 'blkid' ? :blkid_exists : :lsblk_exists
+
+          return blkid_and_lsblk[command_exists_key] unless blkid_and_lsblk[command_exists_key].nil?
 
-          output = Facter::Core::Execution.execute('which blkid', logger: log)
+          output = Facter::Core::Execution.execute("which #{command}", logger: log)
 
-          @blkid_exists = !output.empty?
+          blkid_and_lsblk[:command_exists_key] = !output.empty?
         end
 
-        def pupulate_from_lsblk(partition_name)
-          return {} unless lsblk_command?
+        def execute_and_extract_blkid_info
+          stdout = Facter::Core::Execution.execute('blkid', logger: log)
+          output_hash = Hash[*stdout.split(/^([^:]+):/)[1..-1]]
+          output_hash.each do |key, value|
+            output_hash[key] = Hash[*value.delete('"').chomp.rstrip.split(/ ([^= ]+)=/)[1..-1]]
+          end
+        end
 
-          @lsblk_content ||= Facter::Core::Execution.execute('lsblk -fp', logger: log)
+        def populate_from_lsblk(partition_name, blkid_and_lsblk)
+          return {} unless available?('lsblk', blkid_and_lsblk)
 
-          part_info = @lsblk_content.match(/#{partition_name}.*/).to_s.split(' ')
+          blkid_and_lsblk[:lsblk] ||= Facter::Core::Execution.execute('lsblk -fp', logger: log)
+
+          part_info = blkid_and_lsblk[:lsblk].match(/#{partition_name}.*/).to_s.split(' ')
           return {} if part_info.empty?
 
+          parse_part_info(part_info)
+        end
+
+        def parse_part_info(part_info)
           result = { filesystem: part_info[1] }
 
           if part_info.count.eql?(5)
@@ -118,27 +142,6 @@ module Facter
 
           result
         end
-
-        def lsblk_command?
-          return @lsblk_exists unless @lsblk_exists.nil?
-
-          output = Facter::Core::Execution.execute('which lsblk', logger: log)
-
-          @lsblk_exists = !output.empty?
-        end
-
-        def execute_and_extract_blkid_info
-          stdout = Facter::Core::Execution.execute('blkid', logger: log)
-          output_hash = Hash[*stdout.split(/^([^:]+):/)[1..-1]]
-          output_hash.each do |key, value|
-            output_hash[key] = Hash[*value.delete('"').chomp.rstrip.split(/ ([^= ]+)=/)[1..-1]]
-          end
-        end
-
-        def browse_subdirectories(path)
-          dirs = Dir[File.join(path, '**', '*')].select { |p| File.directory? p }
-          dirs.select { |subdir| subdir.split('/').last.include?(path.split('/').last) }.reject(&:nil?)
-        end
       end
     end
   end