facter 4.0.44 → 4.0.50

data/lib/facter/resolvers/{lpar_resolver.rb → lpar.rb}

@@ -3,12 +3,12 @@
 module Facter
   module Resolvers
     class Lpar < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_lpar(fact_name) }
         end
 

data/lib/facter/resolvers/{lsb_release_resolver.rb → lsb_release.rb}

@@ -9,12 +9,12 @@ module Facter
       # :release
       # :codename
 
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
         end
 

data/lib/facter/resolvers/lspci.rb

@@ -3,7 +3,7 @@
 module Facter
   module Resolvers
     class Lspci < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       REGEX_VALUES = { 'VirtualBox' => 'virtualbox', 'XenSource' => 'xenhvm',
                        'Microsoft Corporation Hyper-V' => 'hyperv', 'Class 8007: Google, Inc' => 'gce',
@@ -13,7 +13,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { lspci_command(fact_name) }
         end
 

data/lib/facter/resolvers/macosx/{dmi_resolver.rb → dmi.rb}

@@ -4,14 +4,14 @@ module Facter
   module Resolvers
     module Macosx
       class DmiBios < BaseResolver
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           #:model
 
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_facts }
           end
 

data/lib/facter/resolvers/macosx/{filesystems_resolver.rb → filesystems.rb}

@@ -5,12 +5,12 @@ module Facter
     module Macosx
       class Filesystems < BaseResolver
         # :macosx_filesystems
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_filesystems(fact_name) }
           end
 

data/lib/facter/resolvers/macosx/{load_averages_resolver.rb → load_averages.rb}

@@ -4,11 +4,12 @@ module Facter
   module Resolvers
     module Macosx
       class LoadAverages < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_load_averages_file(fact_name) }
           end
 

data/lib/facter/resolvers/macosx/{mountpoints_resolver.rb → mountpoints.rb}

@@ -4,19 +4,20 @@ module Facter
   module Resolvers
     module Macosx
       class Mountpoints < BaseResolver
-        include Facter::FilesystemHelper
-        @fact_list ||= {}
+        include Facter::Util::Resolvers::FilesystemHelper
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_mounts }
           end
 
           def read_mounts
             mounts = {}
 
-            FilesystemHelper.read_mountpoints.each do |fs|
+            Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |fs|
               device = fs.name
               filesystem = fs.mount_type
               path = fs.mount_point
@@ -34,7 +35,7 @@ module Facter
 
           def read_stats(path)
             begin
-              stats = FilesystemHelper.read_mountpoint_stats(path)
+              stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(path)
               size_bytes = stats.bytes_total
               available_bytes = stats.bytes_available
               used_bytes = size_bytes - available_bytes
@@ -46,10 +47,10 @@ module Facter
               size_bytes: size_bytes,
               used_bytes: used_bytes,
               available_bytes: available_bytes,
-              capacity: FilesystemHelper.compute_capacity(used_bytes, size_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)
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used_bytes, size_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)
             }
           end
         end

data/lib/facter/resolvers/macosx/{processor_resolver.rb → processor.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',
@@ -17,7 +18,7 @@ module Facter
 
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_processor_data(fact_name) }
           end
 

data/lib/facter/resolvers/macosx/{swap_memory_resolver.rb → swap_memory.rb}

@@ -4,11 +4,12 @@ module Facter
   module Resolvers
     module Macosx
       class SwapMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_swap_memory(fact_name) }
           end
 

data/lib/facter/resolvers/macosx/{system_memory_resolver.rb → system_memory.rb}

@@ -4,11 +4,12 @@ module Facter
   module Resolvers
     module Macosx
       class SystemMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { calculate_system_memory(fact_name) }
           end
 

data/lib/facter/resolvers/macosx/{system_profiler_resolver.rb → system_profiler.rb}

@@ -15,25 +15,23 @@ 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
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { retrieve_system_profiler(fact_name) }
           end
 
           def retrieve_system_profiler(fact_name)
-            @fact_list ||= {}
-
             case fact_name
             when *SP_HARDWARE_DATA_TYPE
-              @fact_list.merge!(SystemProfileExecutor.execute('SPHardwareDataType'))
+              @fact_list.merge!(Facter::Util::Macosx::SystemProfileExecutor.execute('SPHardwareDataType'))
             when *SP_SOFTWARE_DATA_TYPE
-              @fact_list.merge!(SystemProfileExecutor.execute('SPSoftwareDataType'))
+              @fact_list.merge!(Facter::Util::Macosx::SystemProfileExecutor.execute('SPSoftwareDataType'))
             when *SP_ETHERNET_DATA_TYPE
-              @fact_list.merge!(SystemProfileExecutor.execute('SPEthernetDataType'))
+              @fact_list.merge!(Facter::Util::Macosx::SystemProfileExecutor.execute('SPEthernetDataType'))
             end
 
             @fact_list[fact_name]

data/lib/facter/resolvers/{memory_resolver.rb → memory.rb}

@@ -4,17 +4,19 @@ module Facter
   module Resolvers
     module Linux
       class Memory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         @log = Facter::Log.new(self)
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_meminfo_file(fact_name) }
           end
 
           def read_meminfo_file(fact_name)
-            meminfo_output = Util::FileHelper.safe_read('/proc/meminfo', nil)
+            meminfo_output = Facter::Util::FileHelper.safe_read('/proc/meminfo', nil)
             return unless meminfo_output
 
             read_system(meminfo_output)

data/lib/facter/resolvers/{mountpoints_resolver.rb → mountpoints.rb}

@@ -3,18 +3,21 @@
 module Facter
   module Resolvers
     class Mountpoints < BaseResolver
-      include Facter::FilesystemHelper
-      @fact_list ||= {}
+      include Facter::Util::Resolvers::FilesystemHelper
+
+      init_resolver
+
       @log = Facter::Log.new(self)
+
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_mounts(fact_name) }
         end
 
         def root_device
-          cmdline = Util::FileHelper.safe_read('/proc/cmdline')
+          cmdline = Facter::Util::FileHelper.safe_read('/proc/cmdline')
           match = cmdline.match(/root=([^\s]+)/)
           root = match&.captures&.first
 
@@ -42,7 +45,7 @@ module Facter
 
         def read_mounts(fact_name)
           mounts = []
-          FilesystemHelper.read_mountpoints.each do |file_system|
+          Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |file_system|
             mount = {}
             get_mount_data(file_system, mount)
 
@@ -64,16 +67,16 @@ module Facter
         end
 
         def get_mount_sizes(mount)
-          stats = FilesystemHelper.read_mountpoint_stats(mount[:path])
+          stats = Facter::Util::Resolvers::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[:capacity] = Facter::Util::Resolvers::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])
+          mount[:size] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:size_bytes])
+          mount[:available] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:available_bytes])
+          mount[:used] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:used_bytes])
         end
 
         def get_bytes_data(mount, stats)

data/lib/facter/resolvers/{networking_resolver.rb → networking.rb}

@@ -3,26 +3,29 @@
 module Facter
   module Resolvers
     class Networking < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_facts(fact_name) }
         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/networking_linux.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class NetworkingLinux < BaseResolver
+      init_resolver
+
+      DIRS = ['/var/lib/dhclient/', '/var/lib/dhcp/', '/var/lib/dhcp3/', '/var/lib/NetworkManager/', '/var/db/'].freeze
+      ROUTE_TYPES = %w[anycast
+                       unicast
+                       broadcast
+                       local
+                       nat
+                       unreachable
+                       prohibit
+                       blackhole
+                       throw].freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { retrieve_network_info(fact_name) }
+
+          @fact_list[fact_name]
+        end
+
+        def retrieve_network_info(fact_name)
+          mtu_and_indexes = interfaces_mtu_and_index
+          retrieve_interfaces_with_socket(mtu_and_indexes)
+          add_info_from_routing_table
+          retrieve_primary_interface
+          Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+          @fact_list[fact_name]
+        end
+
+        def interfaces_mtu_and_index
+          mtu_and_indexes = {}
+          output = Facter::Core::Execution.execute('ip link show', logger: log)
+          output.each_line do |line|
+            next unless line.include?('mtu')
+
+            parse_ip_command_line(line, mtu_and_indexes)
+          end
+          log.debug("Associated MTU and index in ip command: #{mtu_and_indexes}")
+          mtu_and_indexes
+        end
+
+        def parse_ip_command_line(line, mtu_and_indexes)
+          mtu = line.match(/mtu (\d+)/)&.captures&.first&.to_i
+          index_tokens = line.split(':')
+          index = index_tokens[0].strip
+          # vlans are displayed as <vlan_name>@<physical_interface>
+          name = index_tokens[1].split('@').first.strip
+          mtu_and_indexes[name] = { index: index, mtu: mtu }
+        end
+
+        def retrieve_interfaces_with_socket(mtu_and_indexes)
+          require 'socket'
+          interfaces = {}
+          Socket.getifaddrs.each do |ifaddr|
+            populate_interface_info(ifaddr, interfaces, mtu_and_indexes)
+          end
+
+          @fact_list[:interfaces] = interfaces
+        end
+
+        def populate_interface_info(ifaddr, interfaces, mtu_and_indexes)
+          interface_name = ifaddr.name
+          interfaces[interface_name] = {} if interfaces[interface_name].nil?
+          interface_data = interfaces[interface_name]
+
+          mac(ifaddr, interfaces)
+          mtu(ifaddr, interfaces, mtu_and_indexes)
+          ip, netmask, ipv4_type = ip_info_of(ifaddr)
+          add_binding(interface_data, interface_name, ip, netmask, ipv4_type)
+          dhcp(interface_name, mtu_and_indexes[interface_name], interface_data) if interface_data[:dhcp].nil?
+          log.debug("Found interface #{interface_name} with #{interface_data}")
+        end
+
+        def mac(ifaddr, interfaces)
+          return unless interfaces[ifaddr.name][:mac].nil?
+
+          mac = search_for_mac(ifaddr)
+          interfaces[ifaddr.name][:mac] = mac if mac
+        end
+
+        def search_for_mac(ifaddr)
+          mac = mac_from_bonded_interface(ifaddr.name)
+          mac ||= mac_from(ifaddr)
+          mac if !mac.nil? && mac != '00:00:00:00:00:00' && mac =~ /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/
+        end
+
+        def mac_from_bonded_interface(interface_name)
+          master = bond_master_of(interface_name)
+          return unless master
+
+          output = Facter::Util::FileHelper.safe_read("/proc/net/bonding/#{master}", nil)
+          return unless output
+
+          found_match = false
+          output.each_line do |line|
+            if line.strip == "Slave Interface: #{interface_name}"
+              found_match = true
+            elsif line.include? 'Slave Interface'
+              # if we reached the data block of another interface belonging to the bonded interface
+              found_match = false
+            end
+            return Regexp.last_match(1) if found_match && line =~ /Permanent HW addr: (\S*)/
+          end
+        end
+
+        def bond_master_of(interface_name)
+          content = Facter::Core::Execution.execute("ip link show #{interface_name}", logger: log)
+          content.match(/master (\S*) /)&.captures&.first
+        end
+
+        def mac_from(ifaddr)
+          if Socket.const_defined? :PF_LINK
+            ifaddr.addr&.getnameinfo&.first # sometimes it returns localhost or ip
+          elsif Socket.const_defined? :PF_PACKET
+            return if ifaddr.addr.nil?
+
+            search_mac_in_sockaddr(ifaddr)
+          end
+        rescue StandardError => e
+          log.debug("Could not read mac, got #{e}")
+        end
+
+        def search_mac_in_sockaddr(ifaddr)
+          result = ifaddr.addr.inspect_sockaddr
+          result&.match(/hwaddr=([\h:]+)/)&.captures&.first
+        end
+
+        def mtu(ifaddr, interfaces, mtu_and_indexes)
+          return unless interfaces[ifaddr.name][:mtu].nil?
+
+          mtu = mtu_and_indexes.dig(ifaddr.name, :mtu)
+          interfaces[ifaddr.name][:mtu] = mtu unless mtu.nil?
+        end
+
+        def ip_info_of(ifaddr)
+          return if ifaddr.addr.nil? || ifaddr.netmask.nil?
+
+          # ipv6 ips are retrieved as <ip>%<interface_name>
+          ip = ifaddr.addr.ip_address.split('%').first
+          netmask = ifaddr.netmask.ip_address
+          [ip, netmask, ifaddr.addr.ipv4?]
+        rescue StandardError => e
+          log.debug("Could not read binding data, got #{e}")
+        end
+
+        def add_binding(interface_data, interface_name, ip, netmask, ip_v4_type)
+          binding = Facter::Util::Resolvers::Networking.build_binding(ip, netmask)
+          return if binding.nil?
+
+          log.debug("Adding to interface #{interface_name}, binding:\n#{binding}")
+          binding_key = ip_v4_type == true ? :bindings : :bindings6
+          interface_data[binding_key] = [] if interface_data[binding_key].nil?
+          interface_data[binding_key] << binding
+        end
+
+        def add_info_from_routing_table
+          routes4, routes6 = read_routing_table
+          compare_ips(routes4, :bindings)
+          compare_ips(routes6, :bindings6)
+        end
+
+        def read_routing_table
+          ipv4_output = Facter::Core::Execution.execute('ip route show', logger: log)
+          ipv6_output = Facter::Core::Execution.execute('ip -6 route show', logger: log)
+          routes4 = parse_routes(ipv4_output, true)
+          routes6 = parse_routes(ipv6_output, false)
+          [routes4, routes6]
+        end
+
+        def parse_routes(output, ipv4_type)
+          routes = []
+          output.each_line do |line|
+            parts = line.split(' ').compact
+            next if parts.include?('linkdown')
+
+            delete_invalid_route_type(parts)
+            next if !ipv4_type && !parts[0].include?(':')
+
+            route = construct_route(parts)
+            routes << route unless route[:ip].nil?
+          end
+          routes.uniq
+        end
+
+        def delete_invalid_route_type(parts)
+          route_type = parts[0]
+          parts.delete_at(0) if ROUTE_TYPES.include?(route_type)
+        end
+
+        def construct_route(parts)
+          route = {}
+          dev_index = parts.find_index { |elem| elem == 'dev' }
+          src_index = parts.find_index { |elem| elem == 'src' }
+          route[:interface] = parts[dev_index + 1] if dev_index
+          route[:ip] = parts[src_index + 1] if src_index
+          route
+        end
+
+        def compare_ips(routes, binding_key)
+          routes.each do |route|
+            next unless @fact_list[:interfaces].key?(route[:interface])
+
+            interface_data = @fact_list[:interfaces][route[:interface]]
+            add_binding_if_missing(interface_data, binding_key, route)
+          end
+        end
+
+        def add_binding_if_missing(interface_data, binding_key, route)
+          interface_binding = interface_data[binding_key]
+
+          if interface_binding.nil?
+            interface_data[binding_key] = [{ address: route[:ip] }]
+          elsif interface_binding.none? { |binding| binding[:address] == route[:ip] }
+            interface_binding << { address: route[:ip] }
+          end
+        end
+
+        def dhcp(interface_name, index_and_mtu, interface_data)
+          log.debug("Get DHCP for interface #{interface_name}")
+
+          search_systemd_netif_leases(interface_data, index_and_mtu)
+          search_dhclient_leases(interface_data, interface_name)
+          search_internal_leases(interface_data, interface_name)
+          search_with_dhcpcd_command(interface_data, interface_name)
+        end
+
+        def search_systemd_netif_leases(interface_data, index_and_mtu)
+          return if index_and_mtu.nil?
+
+          index = index_and_mtu[:index]
+          file_content = Facter::Util::FileHelper.safe_read("/run/systemd/netif/leases/#{index}", nil)
+          dhcp = file_content.match(/SERVER_ADDRESS=(.*)/) if file_content
+          interface_data[:dhcp] = dhcp[1] if dhcp
+        end
+
+        def search_dhclient_leases(interface_data, interface_name)
+          return unless interface_data[:dhcp].nil?
+
+          DIRS.each do |dir|
+            next unless File.readable?(dir)
+
+            lease_files = Dir.entries(dir).select { |file| file =~ /dhclient.*\.lease/ }
+            next if lease_files.empty?
+
+            lease_files.select do |file|
+              content = Facter::Util::FileHelper.safe_read("#{dir}#{file}", nil)
+              next unless content =~ /interface.*#{interface_name}/
+
+              dhcp = content.match(/dhcp-server-identifier ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/)
+              return interface_data[:dhcp] = dhcp[1] if dhcp
+            end
+          end
+        end
+
+        def search_internal_leases(interface_data, interface_name)
+          return if !interface_data[:dhcp].nil? || !File.readable?('/var/lib/NetworkManager/')
+
+          files = Dir.entries('/var/lib/NetworkManager/').reject { |dir| dir =~ /^\.+$/ }
+          lease_file = files.find { |file| file =~ /internal.*#{interface_name}\.lease/ }
+          return unless lease_file
+
+          dhcp = Facter::Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
+
+          return unless dhcp
+
+          dhcp = dhcp.match(/SERVER_ADDRESS=(.*)/)
+          interface_data[:dhcp] = dhcp[1] if dhcp
+        end
+
+        def search_with_dhcpcd_command(interface_data, interface_name)
+          return unless interface_data[:dhcp].nil?
+
+          output = Facter::Core::Execution.execute("dhcpcd -U #{interface_name}", logger: log)
+          dhcp = output.match(/dhcp_server_identifier='(.*)'/)
+          interface_data[:dhcp] = dhcp[1] if dhcp
+        end
+
+        def retrieve_primary_interface
+          primary_helper = Facter::Util::Resolvers::Networking::PrimaryInterface
+          primary_interface = primary_helper.read_from_proc_route
+          primary_interface ||= primary_helper.read_from_ip_route
+          primary_interface ||= primary_helper.find_in_interfaces(@fact_list[:interfaces])
+
+          @fact_list[:primary_interface] = primary_interface
+        end
+      end
+    end
+  end
+end