facter 4.0.40 → 4.0.46

data/lib/facter/resolvers/macosx/processor_resolver.rb

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Macosx
       class Processors < BaseResolver
-        @fact_list = {}
+        init_resolver
+
         ITEMS = { logical_count: 'hw.logicalcpu_max',
                   physical_count: 'hw.physicalcpu_max',
                   brand: 'machdep.cpu.brand_string',

data/lib/facter/resolvers/macosx/swap_memory_resolver.rb

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Macosx
       class SwapMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 

data/lib/facter/resolvers/macosx/system_memory_resolver.rb

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Macosx
       class SystemMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 

data/lib/facter/resolvers/macosx/system_profiler_resolver.rb

@@ -15,7 +15,7 @@ module Facter
         SP_ETHERNET_DATA_TYPE = %i[type bus vendor_id device_id subsystem_vendor_id
                                    subsystem_id revision_id bsd_name kext_name location version].freeze
 
-        @fact_list = {}
+        init_resolver
 
         class << self
           private
@@ -25,8 +25,6 @@ module Facter
           end
 
           def retrieve_system_profiler(fact_name)
-            @fact_list ||= {}
-
             case fact_name
             when *SP_HARDWARE_DATA_TYPE
               @fact_list.merge!(SystemProfileExecutor.execute('SPHardwareDataType'))

data/lib/facter/resolvers/memory_resolver.rb

@@ -4,8 +4,10 @@ module Facter
   module Resolvers
     module Linux
       class Memory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         @log = Facter::Log.new(self)
+
         class << self
           private
 
@@ -25,11 +27,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 +56,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

@@ -4,19 +4,36 @@ module Facter
   module Resolvers
     class Mountpoints < BaseResolver
       include Facter::FilesystemHelper
-      @fact_list ||= {}
+
+      init_resolver
+
       @log = Facter::Log.new(self)
+
       class << self
         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 +43,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 mount[:path] =~ %r{^/(proc|sys)} && mount[:filesystem] != 'tmpfs' || mount[:filesystem] == 'autofs'
+
+            get_mount_sizes(mount)
+            mounts << mount
+          end
 
-            next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
+          @fact_list[:mountpoints] = mounts
+          @fact_list[fact_name]
+        end
 
-            stats = FilesystemHelper.read_mountpoint_stats(path)
-            size_bytes = stats.bytes_total.abs
-            available_bytes = stats.bytes_available.abs
+        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
 
-            used_bytes = stats.bytes_used.abs
-            total_bytes = used_bytes + available_bytes
-            capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
+        def get_mount_sizes(mount)
+          stats = FilesystemHelper.read_mountpoint_stats(mount[:path])
 
-            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)
+          get_bytes_data(mount, stats)
 
-            mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
-              .map { |v| binding.local_variable_get(v) })]
-          end
-          @fact_list[:mountpoints] = mounts
+          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

@@ -3,22 +3,20 @@
 module Facter
   module Resolvers
     class NetworkingLinux < BaseResolver
-      @fact_list = {}
+      init_resolver
+
       DIRS = ['/var/lib/dhclient/', '/var/lib/dhcp/', '/var/lib/dhcp3/', '/var/lib/NetworkManager/', '/var/db/'].freeze
 
       class << self
         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]
         end
 
         def retrieve_network_info(fact_name)
-          @fact_list ||= {}
-
           retrieve_interface_info
           retrieve_interfaces_mac_and_mtu
           retrieve_default_interface
@@ -60,9 +58,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 +79,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/')
@@ -108,6 +112,8 @@ module Facter
                       "ip4_mask_length = #{ip4_mask_length}")
 
           binding = ::Resolvers::Utils::Networking.build_binding(ip4_address, ip4_mask_length)
+          return unless binding
+
           build_network_info_structure!(network_info, interface_name, :bindings)
 
           network_info[interface_name][:bindings] << binding
@@ -115,7 +121,7 @@ module Facter
 
         def retrieve_name_and_ip_info(tokens)
           interface_name = tokens[1]
-          ip_info = tokens[3].split('/')
+          ip_info = tokens[4] =~ /peer/ ? tokens[5].split('/') : tokens[3].split('/')
           ip_address = ip_info[0]
           ip_mask_length = ip_info[1]
 

data/lib/facter/resolvers/networking_resolver.rb

@@ -3,7 +3,7 @@
 module Facter
   module Resolvers
     class Networking < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private

data/lib/facter/resolvers/open_vz.rb

@@ -5,7 +5,7 @@ module Facter
     class OpenVz < BaseResolver
       # build
 
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private

data/lib/facter/resolvers/os_release_resolver.rb

@@ -14,7 +14,7 @@ module Facter
       # :support_url
       # :bug_report_url
 
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private

data/lib/facter/resolvers/partitions.rb

@@ -3,7 +3,8 @@
 module Facter
   module Resolvers
     class Partitions < BaseResolver
-      @fact_list ||= {}
+      init_resolver
+
       BLOCK_PATH = '/sys/block'
       BLOCK_SIZE = 512
 
@@ -15,98 +16,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
+
+          partition_data = blkid_and_lsblk[:blkid][partition_name]
+          return {} unless partition_data
 
-          @blkid_content ||= execute_and_extract_blkid_info
-          return {} unless @blkid_content[partition_name]
+          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
 
-          output = Facter::Core::Execution.execute('which blkid', logger: log)
+          return blkid_and_lsblk[command_exists_key] unless blkid_and_lsblk[command_exists_key].nil?
 
-          @blkid_exists = !output.empty?
+          output = Facter::Core::Execution.execute("which #{command}", logger: log)
+
+          blkid_and_lsblk[:command_exists_key] = !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 pupulate_from_lsblk(partition_name)
-          return {} unless lsblk_command?
+        def populate_from_lsblk(partition_name, blkid_and_lsblk)
+          return {} unless available?('lsblk', blkid_and_lsblk)
 
-          @lsblk_content ||= Facter::Core::Execution.execute('lsblk -fp', logger: log)
+          blkid_and_lsblk[:lsblk] ||= Facter::Core::Execution.execute('lsblk -fp', logger: log)
 
-          part_info = @lsblk_content.match(/#{partition_name}.*/).to_s.split(' ')
+          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 +143,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