facter 4.0.46 → 4.0.47

data/lib/facter/resolvers/networking_resolver.rb

@@ -13,16 +13,19 @@ module Facter
         end
 
         def read_facts(fact_name)
-          primary_interface
           interfaces_data
-          ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+          primary_interface
+          Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
           @fact_list[fact_name]
         end
 
         def primary_interface
-          result = Facter::Core::Execution.execute('route -n get default', logger: log)
+          primary_helper = Facter::Util::Resolvers::Networking::PrimaryInterface
+          primary_interface ||= primary_helper.read_from_route
+
+          primary_interface ||= primary_helper.find_in_interfaces(@fact_list[:interfaces])
 
-          @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
+          @fact_list[:primary_interface] = primary_interface
         end
 
         def interfaces_data
@@ -95,7 +98,7 @@ module Facter
         def create_bindings(ips, masks)
           bindings = []
           ips.zip(masks).each do |ip, mask|
-            bindings << ::Resolvers::Utils::Networking.build_binding(ip, mask)
+            bindings << Facter::Util::Resolvers::Networking.build_binding(ip, mask)
           end
           bindings
         end

data/lib/facter/resolvers/open_vz.rb

@@ -15,9 +15,7 @@ module Facter
         end
 
         def check_proc_vz(fact_name)
-          if !Dir.exist?('/proc/vz') || !File.executable?('/proc/lve/list') || Dir.entries('/proc/vz').count.equal?(2)
-            return
-          end
+          return if !Dir.exist?('/proc/vz') || File.file?('/proc/lve/list') || Dir.entries('/proc/vz').count.equal?(2)
 
           @fact_list[:vm] = read_proc_status
           @fact_list[fact_name]

data/lib/facter/resolvers/os_release_resolver.rb

@@ -24,7 +24,7 @@ module Facter
         end
 
         def read_os_release_file(fact_name)
-          output = Util::FileHelper.safe_readlines('/etc/os-release')
+          output = Facter::Util::FileHelper.safe_readlines('/etc/os-release')
           return @fact_list[:name] = nil if output.empty?
 
           pairs = []

data/lib/facter/resolvers/partitions.rb

@@ -45,7 +45,7 @@ module Facter
         end
 
         def extract_from_dm(block_path, block_device, blkid_and_lsblk)
-          map_name = Util::FileHelper.safe_read("#{block_path}/dm/name").chomp
+          map_name = Facter::Util::FileHelper.safe_read("#{block_path}/dm/name").chomp
           if map_name.empty?
             populate_partitions("/dev/#{block_device}", block_path, blkid_and_lsblk)
           else
@@ -54,7 +54,7 @@ module Facter
         end
 
         def extract_from_loop(block_path, block_device, blkid_and_lsblk)
-          backing_file = Util::FileHelper.safe_read("#{block_path}/loop/backing_file").chomp
+          backing_file = Facter::Util::FileHelper.safe_read("#{block_path}/loop/backing_file").chomp
           if backing_file.empty?
             populate_partitions("/dev/#{block_device}", block_path, blkid_and_lsblk)
           else
@@ -63,10 +63,10 @@ module Facter
         end
 
         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
+          size_bytes = Facter::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),
+                        size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes),
                         backing_file: backing_file }
           info_hash.merge!(populate_from_syscalls(partition_name, blkid_and_lsblk))
           @fact_list[:partitions][partition_name] = info_hash.reject { |_key, value| value.nil? }

data/lib/facter/resolvers/processors_resolver.rb

@@ -23,7 +23,7 @@ module Facter
           end
 
           def read_cpuinfo(fact_name)
-            cpuinfo_output = Util::FileHelper.safe_readlines('/proc/cpuinfo')
+            cpuinfo_output = Facter::Util::FileHelper.safe_readlines('/proc/cpuinfo')
             return if cpuinfo_output.empty?
 
             read_processors(cpuinfo_output) # + model names
@@ -65,7 +65,7 @@ module Facter
                .select { |dir| dir =~ /cpu[0-9]+$/ }
                .select { |dir| File.exist?("/sys/devices/system/cpu/#{dir}/topology/physical_package_id") }
                .map do |dir|
-              Util::FileHelper.safe_read("/sys/devices/system/cpu/#{dir}/topology/physical_package_id").strip
+              Facter::Util::FileHelper.safe_read("/sys/devices/system/cpu/#{dir}/topology/physical_package_id").strip
             end
                .uniq.count
           end

data/lib/facter/resolvers/redhat_release_resolver.rb

@@ -17,7 +17,7 @@ module Facter
         end
 
         def read_redhat_release(fact_name)
-          output = Util::FileHelper.safe_read('/etc/redhat-release', nil)
+          output = Facter::Util::FileHelper.safe_read('/etc/redhat-release', nil)
           return @fact_list[fact_name] = nil if output.nil?
 
           build_fact_list(output)

data/lib/facter/resolvers/selinux_resolver.rb

@@ -40,9 +40,9 @@ module Facter
           enforce_file = "#{mountpoint}/enforce"
           policy_file = "#{mountpoint}/policyvers"
 
-          @fact_list[:policy_version] = Util::FileHelper.safe_read(policy_file, nil)
+          @fact_list[:policy_version] = Facter::Util::FileHelper.safe_read(policy_file, nil)
 
-          enforce = Util::FileHelper.safe_read(enforce_file)
+          enforce = Facter::Util::FileHelper.safe_read(enforce_file)
           if enforce.eql?('1')
             @fact_list[:enforced] = true
             @fact_list[:current_mode] = 'enforcing'
@@ -53,7 +53,7 @@ module Facter
         end
 
         def read_selinux_config
-          file_lines = Util::FileHelper.safe_readlines('/etc/selinux/config')
+          file_lines = Facter::Util::FileHelper.safe_readlines('/etc/selinux/config')
 
           file_lines.map do |line|
             @fact_list[:config_mode] = line.split('=').last.strip if line =~ /^SELINUX=/

data/lib/facter/resolvers/solaris/disks.rb

@@ -36,7 +36,7 @@ module Facter
               disk_size = sizes[index].to_i
               disks[name] = {
                 product: products[index],
-                size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(disk_size),
+                size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(disk_size),
                 size_bytes: disk_size,
                 vendor: vendors[index]
               }

data/lib/facter/resolvers/solaris/memory.rb

@@ -32,7 +32,7 @@ module Facter
             sys[:total_bytes] = total
             sys[:available_bytes] = free
             sys[:used_bytes] = total - free
-            sys[:capacity] = FilesystemHelper.compute_capacity(total - free, total)
+            sys[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(total - free, total)
 
             sys
           end
@@ -45,7 +45,7 @@ module Facter
             swap_hash[:total_bytes] = total
             swap_hash[:available_bytes] = free
             swap_hash[:used_bytes] = total - free
-            swap_hash[:capacity] = FilesystemHelper.compute_capacity(total - free, total)
+            swap_hash[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(total - free, total)
 
             swap_hash if total != 0
           end

data/lib/facter/resolvers/solaris/mountpoints.rb

@@ -4,7 +4,7 @@ module Facter
   module Resolvers
     module Solaris
       class Mountpoints < BaseResolver
-        include Facter::FilesystemHelper
+        include Facter::Util::Resolvers::FilesystemHelper
         init_resolver
 
         class << self
@@ -15,7 +15,7 @@ module Facter
           end
 
           def root_device
-            cmdline = Util::FileHelper.safe_read('/proc/cmdline')
+            cmdline = Facter::Util::FileHelper.safe_read('/proc/cmdline')
             match = cmdline.match(/root=([^\s]+)/)
             match&.captures&.first
           end
@@ -27,27 +27,28 @@ module Facter
             device
           end
 
-          def read_mounts(fact_name) # rubocop:disable Metrics/AbcSize
+          def read_mounts(fact_name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
             mounts = []
-            FilesystemHelper.read_mountpoints.each do |fs|
+            Facter::Util::Resolvers::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)
 
-              stats = FilesystemHelper.read_mountpoint_stats(path)
+              stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(path)
               size_bytes = stats.bytes_total.abs
               available_bytes = stats.bytes_available.abs
 
               used_bytes = stats.bytes_used.abs
               total_bytes = used_bytes + available_bytes
-              capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
+              capacity = Facter::Util::Resolvers::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)
+              size = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes)
+              available = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(available_bytes)
+              used = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes)
 
-              mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
+              mounts << Hash[Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+                             .zip(Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
                 .map { |v| binding.local_variable_get(v) })]
             end
             @fact_list[:mountpoints] = mounts

data/lib/facter/resolvers/solaris/networking.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'ffi/ffi.rb'
-require 'ipaddr'
-
 module Facter
   module Resolvers
     module Solaris
@@ -18,24 +16,38 @@ module Facter
           end
 
           def read_facts(fact_name)
-            lifreqs = load_interfaces
-            @interfaces = {}
+            begin
+              lifreqs = load_interfaces
+              @interfaces = {}
+
+              lifreqs.each do |lifreq|
+                obtain_info_for_interface(lifreq)
+              end
+
+              @fact_list[:primary_interface] = Facter::Util::Resolvers::Networking::PrimaryInterface.read_from_route
 
-            lifreqs.each do |lifreq|
-              @interfaces[lifreq.name] ||= {}
+              unless @interfaces.empty?
+                @fact_list[:interfaces] = @interfaces
+                @fact_list[:primary_interface] ||=
+                  Facter::Util::Resolvers::Networking::PrimaryInterface.find_in_interfaces(@interfaces)
+              end
 
-              add_mac(lifreq)
-              add_bindings(lifreq)
-              add_mtu(lifreq)
-              add_dhcp(lifreq.name)
+              Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+            rescue StandardError => e
+              @log.log_exception(e)
             end
+            @fact_list[fact_name]
+          end
 
-            @fact_list = { interfaces: @interfaces } unless @interfaces.empty?
-            primary_interface
+          def obtain_info_for_interface(lifreq)
+            @interfaces[lifreq.name] ||= {}
 
-            ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+            add_mac(lifreq)
+            add_bindings(lifreq)
+            add_mtu(lifreq)
 
-            @fact_list[fact_name]
+            dhcp = Facter::Util::Resolvers::Networking::Dhcp.get(lifreq.name, @log)
+            @interfaces[lifreq.name][:dhcp] = dhcp if dhcp
           end
 
           def add_mac(lifreq)
@@ -43,7 +55,10 @@ module Facter
 
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGARP, arp, lifreq.ss_family)
 
-            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+            if ioctl == -1
+              @log.debug("Could not read MAC address for interface #{lifreq.name} "\
+                          "error code is: #{::FFI::LastError.error}")
+            end
 
             mac = arp.sa_data_to_mac
             @interfaces[lifreq.name][:mac] ||= mac if mac.count('0') < 12
@@ -53,7 +68,7 @@ module Facter
             ip = inet_ntop(lifreq, lifreq.ss_family)
             _netmask, netmask_length = load_netmask(lifreq)
 
-            bindings = ::Resolvers::Utils::Networking.build_binding(ip, netmask_length)
+            bindings = Facter::Util::Resolvers::Networking.build_binding(ip, netmask_length)
 
             bindings_key = BINDINGS_KEY[lifreq.ss_family]
             @interfaces[lifreq.name][bindings_key] ||= []
@@ -63,7 +78,10 @@ module Facter
           def add_mtu(lifreq)
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFMTU, lifreq, lifreq.ss_family)
 
-            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+            if ioctl == -1
+              @log.error("Cold not read MTU, error code is #{::FFI::LastError.error}")
+              return
+            end
 
             @interfaces[lifreq.name][:mtu] ||= lifreq[:lifr_lifru][:lifru_metric]
           end
@@ -74,11 +92,12 @@ module Facter
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFNETMASK, netmask_lifreq, lifreq.ss_family)
 
             if ioctl == -1
-              @log.debug("Error! #{::FFI::LastError.error}")
-            else
-              netmask = inet_ntop(netmask_lifreq, lifreq.ss_family)
-              [netmask, calculate_mask_length(netmask)]
+              @log.error("Could not read Netmask, error code is: #{::FFI::LastError.error}")
+              return
             end
+
+            netmask = inet_ntop(netmask_lifreq, lifreq.ss_family)
+            [netmask, Facter::Util::Resolvers::Networking.calculate_mask_length(netmask)]
           end
 
           def inet_ntop(lifreq, ss_family)
@@ -100,7 +119,7 @@ module Facter
 
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFNUM, lifnum)
 
-            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+            @log.error("Could not read interface count, error code is: #{::FFI::LastError.error}") if ioctl == -1
 
             lifnum[:lifn_count]
           end
@@ -112,7 +131,14 @@ module Facter
 
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFCONF, lifconf)
 
-            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+            # 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 = lifconf
+
+            if ioctl == -1
+              @log.error("Could not read interface information, error code is: #{::FFI::LastError.error}")
+              return []
+            end
 
             interfaces = []
             interface_count.times do |i|
@@ -121,24 +147,6 @@ module Facter
 
             interfaces
           end
-
-          def calculate_mask_length(netmask)
-            ipaddr = IPAddr.new(netmask)
-            ipaddr.to_i.to_s(2).count('1')
-          end
-
-          def primary_interface
-            result = Facter::Core::Execution.execute('route -n get default', logger: log)
-
-            @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
-          end
-
-          def add_dhcp(interface_name)
-            dhcpinfo_command = Facter::Core::Execution.which('dhcpinfo') || '/sbin/dhcpinfo'
-            result = Facter::Core::Execution.execute("#{dhcpinfo_command} -i #{interface_name} ServerID", logger: log)
-
-            @interfaces[interface_name][:dhcp] = result.chomp
-          end
         end
       end
     end

data/lib/facter/resolvers/solaris/os_release.rb

@@ -17,7 +17,7 @@ module Facter
           end
 
           def build_release_facts(fact_name)
-            result = Util::FileHelper.safe_read('/etc/release', nil)
+            result = Facter::Util::FileHelper.safe_read('/etc/release', nil)
             return @fact_list[fact_name] = nil if result.nil?
 
             OS_VERSION_REGEX_PATTERNS.each do |os_version_regex|

data/lib/facter/resolvers/ssh_resolver.rb

@@ -23,11 +23,12 @@ module Facter
             next unless File.directory?(file_path)
 
             FILE_NAMES.each do |file_name|
-              file_content = Util::FileHelper.safe_read(File.join(file_path, file_name), nil)
+              file_content = Facter::Util::FileHelper.safe_read(File.join(file_path, file_name), nil)
               next unless file_content
 
               key_type, key = file_content.split(' ')
-              ssh_list << ::Resolvers::Utils::SshHelper.create_ssh(key_type, key)
+              ssh = Facter::Util::Resolvers::SshHelper.create_ssh(key_type, key)
+              ssh_list << ssh if ssh
             end
           end
           @fact_list[:ssh] = ssh_list

data/lib/facter/resolvers/suse_release_resolver.rb

@@ -17,7 +17,7 @@ module Facter
         end
 
         def read_suse_release(fact_name)
-          output = Util::FileHelper.safe_read('/etc/SuSE-release', nil)
+          output = Facter::Util::FileHelper.safe_read('/etc/SuSE-release', nil)
           return @fact_list[fact_name] = nil if output.nil?
 
           output_strings = output.split(' ')

data/lib/facter/resolvers/uptime_resolver.rb

@@ -13,7 +13,7 @@ module Facter
         end
 
         def uptime_system_call(fact_name)
-          seconds = Facter::UptimeParser.uptime_seconds_unix
+          seconds = Facter::Util::Facts::UptimeParser.uptime_seconds_unix
           build_fact_list(seconds)
 
           @fact_list[fact_name]
@@ -22,7 +22,7 @@ module Facter
         def build_fact_list(seconds)
           return @fact_list[:uptime] = 'unknown' unless seconds
 
-          @fact_list = Utils::UptimeHelper.create_uptime_hash(seconds)
+          @fact_list = Facter::Util::Resolvers::UptimeHelper.create_uptime_hash(seconds)
         end
       end
     end

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

@@ -30,7 +30,7 @@ module Facter
             return if puppet_aio_path.nil? || puppet_aio_path.empty?
 
             puppet_aio_version_path = File.join(puppet_aio_path, 'VERSION')
-            aio_agent_version = Util::FileHelper.safe_read(puppet_aio_version_path, nil)&.chomp
+            aio_agent_version = Facter::Util::FileHelper.safe_read(puppet_aio_version_path, nil)&.chomp
 
             @fact_list[:aio_agent_version] = aio_agent_version&.match(/^\d+\.\d+\.\d+(\.\d+){0,2}/)&.to_s
           end

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

@@ -17,7 +17,7 @@ module Facter
         end
 
         def read_fact_from_bios(fact_name)
-          win = Win32Ole.new
+          win = Facter::Util::Windows::Win32Ole.new
 
           bios = win.return_first('SELECT Manufacturer,SerialNumber from Win32_BIOS')
           unless bios